1 package net.avcompris.examples.users3.core.tests;
2
3 import static java.util.Locale.ENGLISH;
4 import static net.avcompris.commons.query.impl.FilteringsFactory.and;
5 import static net.avcompris.commons.query.impl.FilteringsFactory.or;
6 import static net.avcompris.commons3.core.tests.CoreTestUtils.defaultClock;
7 import static net.avcompris.commons3.core.tests.CoreTestUtils.newCorrelationId;
8 import static net.avcompris.commons3.core.tests.CoreTestUtils.random40;
9 import static net.avcompris.commons3.core.tests.CoreTestUtils.random8;
10 import static net.avcompris.commons3.databeans.DataBeans.instantiate;
11 import static net.avcompris.examples.shared3.core.tests.MyCoreTestUtils.defaultUser;
12 import static net.avcompris.examples.users3.api.UsersQuery.SortBy.SORT_BY_CREATED_AT;
13 import static net.avcompris.examples.users3.api.UsersQuery.SortBy.SORT_BY_CREATED_AT_DESC;
14 import static net.avcompris.examples.users3.api.UsersQuery.SortBy.SORT_BY_LAST_ACTIVE_AT;
15 import static net.avcompris.examples.users3.api.UsersQuery.SortBy.SORT_BY_LAST_ACTIVE_AT_DESC;
16 import static net.avcompris.examples.users3.api.UsersQuery.SortBy.SORT_BY_ROLE;
17 import static net.avcompris.examples.users3.api.UsersQuery.SortBy.SORT_BY_ROLE_DESC;
18 import static net.avcompris.examples.users3.api.UsersQuery.SortBy.SORT_BY_UPDATED_AT;
19 import static net.avcompris.examples.users3.api.UsersQuery.SortBy.SORT_BY_UPDATED_AT_DESC;
20 import static net.avcompris.examples.users3.api.UsersQuery.SortBy.SORT_BY_USERNAME;
21 import static net.avcompris.examples.users3.api.UsersQuery.SortBy.SORT_BY_USERNAME_DESC;
22 import static net.avcompris.examples.users3.core.tests.UsersCoreTestUtils.ensureUsername;
23 import static net.avcompris.examples.users3.core.tests.UsersCoreTestUtils.getUserCount;
24 import static net.avcompris.examples.users3.core.tests.UsersCoreTestUtils.setCorrelationId;
25 import static net.avcompris.examples.users3.core.tests.UsersCoreTestUtils.setUsersService;
26 import static net.avcompris.examples.users3.core.tests.UsersCoreTestUtils.toUser;
27 import static net.avcompris.examples.users3.query.UserFiltering.Field.CREATED_AT;
28 import static net.avcompris.examples.users3.query.UserFiltering.Field.LAST_ACTIVE_AT;
29 import static net.avcompris.examples.users3.query.UserFiltering.Field.UPDATED_AT;
30 import static net.avcompris.examples.users3.query.UserFilteringsUtils.gt;
31 import static net.avcompris.examples.users3.query.UserFilteringsUtils.gte;
32 import static net.avcompris.examples.users3.query.UserFilteringsUtils.lt;
33 import static org.apache.commons.lang3.StringUtils.isBlank;
34 import static org.apache.commons.lang3.StringUtils.substringAfter;
35 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
36 import static org.junit.jupiter.api.Assertions.assertEquals;
37 import static org.junit.jupiter.api.Assertions.assertNotEquals;
38 import static org.junit.jupiter.api.Assertions.assertNotNull;
39 import static org.junit.jupiter.api.Assertions.assertNull;
40 import static org.junit.jupiter.api.Assertions.assertSame;
41 import static org.junit.jupiter.api.Assertions.assertThrows;
42 import static org.junit.jupiter.api.Assertions.assertTrue;
43 import static org.junit.jupiter.api.Assumptions.assumeFalse;
44
45 import org.apache.commons.lang3.tuple.Pair;
46 import org.joda.time.DateTime;
47 import org.junit.jupiter.api.BeforeEach;
48 import org.junit.jupiter.api.Test;
49
50 import net.avcompris.commons3.api.User;
51 import net.avcompris.commons3.api.UserSession;
52 import net.avcompris.commons3.api.exception.IllegalStateUpdateException;
53 import net.avcompris.commons3.api.exception.InvalidQueryFilteringException;
54 import net.avcompris.commons3.api.exception.InvalidRoleException;
55 import net.avcompris.commons3.api.exception.ReservedUsernameException;
56 import net.avcompris.commons3.api.exception.ServiceException;
57 import net.avcompris.commons3.api.exception.UnauthenticatedException;
58 import net.avcompris.commons3.api.exception.UnauthorizedException;
59 import net.avcompris.commons3.api.exception.UsernameAlreadyExistsException;
60 import net.avcompris.commons3.api.exception.UsernameNotFoundException;
61 import net.avcompris.commons3.core.AuthService;
62 import net.avcompris.commons3.core.Permissions;
63 import net.avcompris.commons3.core.impl.PermissionsImpl;
64 import net.avcompris.commons3.core.tests.AbstractServiceTest;
65 import net.avcompris.commons3.utils.LogFactory;
66 import net.avcompris.examples.shared3.Role;
67 import net.avcompris.examples.users3.api.UserCreate;
68 import net.avcompris.examples.users3.api.UserInfo;
69 import net.avcompris.examples.users3.api.UserUpdate;
70 import net.avcompris.examples.users3.api.UsersInfo;
71 import net.avcompris.examples.users3.api.UsersQuery;
72 import net.avcompris.examples.users3.api.UsersQuery.SortBy;
73 import net.avcompris.examples.users3.core.api.UsersService;
74 import net.avcompris.examples.users3.core.impl.AuthServiceImpl;
75 import net.avcompris.examples.users3.core.impl.UsersServiceImpl;
76 import net.avcompris.examples.users3.dao.AuthDao;
77 import net.avcompris.examples.users3.dao.UsersDao;
78
79 public abstract class AbstractUsersServiceTest extends AbstractServiceTest<Pair<UsersDao, AuthDao>> {
80
81 protected AuthService authService;
82 protected UsersService usersService;
83
84 @BeforeEach
85 public final void setUpBeans() throws Exception {
86
87 final Pair<UsersDao, AuthDao> beans = getBeans(defaultClock());
88
89 final UsersDao usersDao = beans.getLeft();
90 final AuthDao authDao = beans.getRight();
91
92 final Permissions permissions = new PermissionsImpl();
93
94 authService = new AuthServiceImpl(permissions, defaultClock(), usersDao, authDao);
95 usersService = new UsersServiceImpl(permissions, defaultClock(), usersDao, authDao);
96
97 setUsersService(usersService);
98
99 LogFactory.resetCorrelationId();
100 }
101
102 @Test
103 public final void testGetUsers_null() throws Exception {
104
105 final UsersInfo users = usersService.getUsers(newCorrelationId(), defaultUser(), null);
106
107 assertNotNull(users);
108
109 users.getStart();
110 users.getLimit();
111 users.getSize();
112 users.getTotal();
113 users.getTookMs();
114 assertNotNull(users.getResults());
115 assertTrue(isBlank(users.getSqlWhereClause()));
116 }
117
118 @Test
119 public final void testCreateUser_me_crash() throws Exception {
120
121 final String password = random8();
122 final String correlationId = setCorrelationId(newCorrelationId());
123
124 assertThrows(ReservedUsernameException.class, ()
125
126 -> usersService.createUser(correlationId, defaultUser(), "me", instantiate(UserCreate.class)
127 .setPassword(password)
128 .setRole(Role.USERMGR)
129 .setEnabled(true)));
130 }
131
132 @Test
133 public final void testCreateUser_full_noCrash() throws Exception {
134
135 final String password = random8();
136 final String correlationId = setCorrelationId(newCorrelationId());
137
138 assumeFalse(usersService.hasUser(correlationId, defaultUser(), "full"));
139
140 usersService.createUser(correlationId, defaultUser(), "full", instantiate(UserCreate.class)
141 .setPassword(password)
142 .setRole(Role.USERMGR)
143 .setEnabled(true));
144
145 final UserInfo user = usersService.getUsers(correlationId, defaultUser(),
146 usersService.validateUsersQuery(correlationId, defaultUser(),
147 "role = USERMGR and username = full",
148 null,
149 0,
150 10,
151 null
152 )).getResults()[0];
153
154 assertEquals("full", user.getUsername());
155 }
156
157 @Test
158 public final void testCreateUser_null_password() throws Exception {
159
160 final String username = random40("USER-");
161 final String correlationId = setCorrelationId(newCorrelationId());
162
163 usersService.createUser(correlationId, defaultUser(), username, instantiate(UserCreate.class)
164 .setPassword(null)
165 .setRole(Role.USERMGR)
166 .setEnabled(true));
167
168 final UserInfo user = usersService.getUsers(correlationId, defaultUser(),
169 usersService.validateUsersQuery(correlationId, defaultUser(),
170 "role = USERMGR and username = " + username,
171 null,
172 0,
173 10,
174 null
175 )).getResults()[0];
176
177 assertEquals(username, user.getUsername());
178 assertSame(Role.USERMGR, user.getRole());
179 }
180
181 @Test
182 public final void testCreateDuplicateUser_crash() throws Exception {
183
184 final String username = random40("USER-");
185 final String password1 = random8();
186 final String password2 = random8();
187 final String correlationId = setCorrelationId(newCorrelationId());
188
189 usersService.createUser(correlationId, defaultUser(), username, instantiate(UserCreate.class)
190 .setPassword(password1)
191 .setRole(Role.REGULAR)
192 .setEnabled(true));
193
194 assertThrows(UsernameAlreadyExistsException.class, ()
195
196 -> usersService.createUser(correlationId, defaultUser(), username, instantiate(UserCreate.class)
197 .setPassword(password2)
198 .setRole(Role.REGULAR)
199 .setEnabled(true)));
200 }
201
202 @Test
203 public final void testCreateUser_getUserMe() throws Exception {
204
205 final String username = random40("USER-");
206 final String password = random8();
207 final String correlationId = setCorrelationId(newCorrelationId());
208
209 final int count0 = getUserCount();
210
211 final UserInfo created = usersService.createUser(correlationId, defaultUser(), username,
212 instantiate(UserCreate.class)
213 .setPassword(password)
214 .setRole(Role.REGULAR)
215 .setEnabled(true));
216
217 assertEquals(count0 + 1, getUserCount());
218
219 assertEquals(username, created.getUsername());
220 assertSame(Role.REGULAR, created.getRole());
221 assertNotNull(created.getCreatedAt());
222 assertNull(created.getLastActiveAt());
223 assertEquals(true, created.isEnabled());
224
225 final UserInfo user = usersService.getUserMe(correlationId, toUser(created));
226
227 assertEquals(username, user.getUsername());
228 assertSame(Role.REGULAR, user.getRole());
229 assertNotNull(user.getCreatedAt());
230 assertEquals(user.getCreatedAt(), created.getUpdatedAt());
231 assertEquals(true, user.isEnabled());
232 }
233
234 @Test
235 public final void testCreateUser_getUser() throws Exception {
236
237 final String username = random40("USER-");
238 final String password = random8();
239 final String correlationId = setCorrelationId(newCorrelationId());
240
241 final int count0 = getUserCount();
242
243 final UserInfo created = usersService.createUser(correlationId, defaultUser(), username,
244 instantiate(UserCreate.class)
245 .setPassword(password)
246 .setRole(Role.USERMGR)
247 .setEnabled(true));
248
249 assertEquals(count0 + 1, getUserCount());
250
251 assertEquals(username, created.getUsername());
252 assertSame(Role.USERMGR, created.getRole());
253 assertNotNull(created.getCreatedAt());
254 assertEquals(created.getCreatedAt(), created.getUpdatedAt());
255 assertNull(created.getLastActiveAt());
256 assertEquals(true, created.isEnabled());
257 assertEquals(1, created.getRevision());
258
259 final UserInfo user = usersService.getUser(correlationId, defaultUser(), username);
260
261 assertEquals(username, user.getUsername());
262 assertSame(Role.USERMGR, user.getRole());
263 assertNotNull(user.getCreatedAt());
264 assertNull(created.getLastActiveAt());
265 assertEquals(true, created.isEnabled());
266 assertEquals(1, created.getRevision());
267 }
268
269 @Test
270 public final void testGetInexistentUser() throws Exception {
271
272 final String username = random40("USER-");
273 final String correlationId = setCorrelationId(newCorrelationId());
274
275 assertThrows(UsernameNotFoundException.class, ()
276
277 -> usersService.getUser(correlationId, defaultUser(), username));
278 }
279
280 @Test
281 public final void testCreateUser_getUsers() throws Exception {
282
283 final String username = random40("USER-");
284 final String password = random8();
285 final String correlationId = setCorrelationId(newCorrelationId());
286
287 final int count0 = getUserCount();
288
289 usersService.createUser(correlationId, defaultUser(), username, instantiate(UserCreate.class)
290 .setPassword(password)
291 .setRole(Role.USERMGR)
292 .setEnabled(true));
293
294 final UsersInfo users = usersService.getUsers(correlationId, defaultUser(), null);
295
296 assertEquals(0, users.getStart());
297 assertEquals(10, users.getLimit());
298 assertNotEquals(0, users.getSize());
299 assertEquals(count0 + 1, users.getTotal());
300
301 assertNotNull(users.getResults()[0]);
302 }
303
304 @Test
305 public final void testCreateUser_getUsers_afterCreatedAt() throws Exception {
306
307 final String username1 = random40("USERb-");
308 final String username2 = random40("USERa-");
309 final String password = random8();
310 final String correlationId = setCorrelationId(newCorrelationId());
311
312 Thread.sleep(10);
313
314 final DateTime now1 = now();
315
316 deleteIllegalUsers(correlationId, now1);
317
318 usersService.createUser(correlationId, defaultUser(), username1, instantiate(UserCreate.class)
319 .setPassword(password)
320 .setRole(Role.USERMGR)
321 .setEnabled(true));
322
323 final UsersInfo users1 = usersService.getUsers(correlationId, defaultUser(), instantiate(UsersQuery.class)
324 .setFiltering(gte(CREATED_AT, now1)));
325
326 assertEquals(0, users1.getStart());
327 assertEquals(10, users1.getLimit());
328 assertEquals(1, users1.getSize());
329 assertEquals(1, users1.getTotal());
330
331 assertEquals(username1, users1.getResults()[0].getUsername());
332
333 Thread.sleep(10);
334
335 final DateTime now2 = now();
336
337 usersService.createUser(correlationId, defaultUser(), username2, instantiate(UserCreate.class)
338 .setPassword(password)
339 .setRole(Role.USERMGR)
340 .setEnabled(true));
341
342 final UsersInfo users2 = usersService.getUsers(correlationId, defaultUser(), instantiate(UsersQuery.class)
343 .setFiltering(gte(CREATED_AT, now2)));
344
345 assertEquals(0, users2.getStart());
346 assertEquals(10, users2.getLimit());
347 assertEquals(1, users2.getSize());
348 assertEquals(1, users2.getTotal());
349
350 assertEquals(username2, users2.getResults()[0].getUsername());
351
352 final UsersInfo users_1_2_sortByUsername = usersService.getUsers(correlationId, defaultUser(),
353 instantiate(UsersQuery.class)
354 .setFiltering(gte(CREATED_AT, now1)));
355
356 assertEquals(0, users_1_2_sortByUsername.getStart());
357 assertEquals(10, users_1_2_sortByUsername.getLimit());
358 assertEquals(2, users_1_2_sortByUsername.getSize());
359 assertEquals(2, users_1_2_sortByUsername.getTotal());
360
361 assertEquals(username2, users_1_2_sortByUsername.getResults()[0].getUsername());
362 assertEquals(username1, users_1_2_sortByUsername.getResults()[1].getUsername());
363
364 final UsersInfo users_1_2_sortByDate = usersService.getUsers(correlationId, defaultUser(),
365 instantiate(UsersQuery.class)
366 .setFiltering(gte(CREATED_AT, now1))
367 .setSortBys(SORT_BY_CREATED_AT));
368
369 assertEquals(0, users_1_2_sortByDate.getStart());
370 assertEquals(10, users_1_2_sortByDate.getLimit());
371 assertEquals(2, users_1_2_sortByDate.getSize());
372 assertEquals(2, users_1_2_sortByDate.getTotal());
373
374 assertEquals(username1, users_1_2_sortByDate.getResults()[0].getUsername());
375 assertEquals(username2, users_1_2_sortByDate.getResults()[1].getUsername());
376 }
377
378 @Test
379 public final void testCreateUser_getUsers_smallPagination() throws Exception {
380
381 final String username1 = random40("USERb-");
382 final String username2 = random40("USERa-");
383 final String password = random8();
384 final String correlationId = setCorrelationId(newCorrelationId());
385
386 for (int i = 0; i < 4; ++i) {
387
388 usersService.createUser(correlationId, defaultUser(), random40("USER-"), instantiate(UserCreate.class)
389 .setPassword(password)
390 .setRole(Role.USERMGR)
391 .setEnabled(true));
392 }
393
394 Thread.sleep(10);
395
396 final DateTime now = now();
397
398 deleteIllegalUsers(correlationId, now);
399
400 usersService.createUser(correlationId, defaultUser(), username1, instantiate(UserCreate.class)
401 .setPassword(password)
402 .setRole(Role.USERMGR)
403 .setEnabled(true));
404
405 Thread.sleep(10);
406
407 usersService.createUser(correlationId, defaultUser(), username2, instantiate(UserCreate.class)
408 .setPassword(password)
409 .setRole(Role.USERMGR)
410 .setEnabled(true));
411
412 final UsersInfo users2 = usersService.getUsers(correlationId, defaultUser(), instantiate(UsersQuery.class)
413 .setFiltering(gte(CREATED_AT, now))
414 .setSortBys(SORT_BY_CREATED_AT_DESC));
415
416 System.out.println("users2:");
417
418 System.out.println(users2.getSqlWhereClause());
419
420 for (final UserInfo userInfo : users2.getResults()) {
421 System.out.println(userInfo);
422 }
423
424 assertEquals(0, users2.getStart());
425 assertEquals(10, users2.getLimit());
426 assertEquals(2, users2.getSize());
427 assertEquals(2, users2.getTotal());
428
429 assertEquals(username2, users2.getResults()[0].getUsername());
430 assertEquals(username1, users2.getResults()[1].getUsername());
431
432 final UsersInfo users_1_2_page1 = usersService.getUsers(correlationId, defaultUser(),
433 instantiate(UsersQuery.class)
434 .setFiltering(gte(CREATED_AT, now))
435 .setStart(0)
436 .setLimit(1)
437 .setSortBys(SORT_BY_CREATED_AT));
438
439 assertEquals(0, users_1_2_page1.getStart());
440 assertEquals(1, users_1_2_page1.getLimit());
441 assertEquals(1, users_1_2_page1.getSize());
442 assertEquals(2, users_1_2_page1.getTotal());
443 assertEquals(1, users_1_2_page1.getResults().length);
444
445 assertEquals(username1, users_1_2_page1.getResults()[0].getUsername());
446
447 final UsersInfo users_1_2_page2 = usersService.getUsers(correlationId, defaultUser(),
448 instantiate(UsersQuery.class)
449 .setFiltering(gte(CREATED_AT, now))
450 .setStart(1)
451 .setLimit(1)
452 .setSortBys(SORT_BY_CREATED_AT));
453
454 assertEquals(1, users_1_2_page2.getStart());
455 assertEquals(1, users_1_2_page2.getLimit());
456 assertEquals(1, users_1_2_page2.getSize());
457 assertEquals(2, users_1_2_page2.getTotal());
458 assertEquals(1, users_1_2_page2.getResults().length);
459
460 assertEquals(username2, users_1_2_page2.getResults()[0].getUsername());
461
462 final UsersInfo users_1_2_page3 = usersService.getUsers(correlationId, defaultUser(),
463 instantiate(UsersQuery.class)
464 .setFiltering(gte(CREATED_AT, now))
465 .setStart(2)
466 .setLimit(1)
467 .setSortBys(SORT_BY_CREATED_AT));
468
469 assertEquals(2, users_1_2_page3.getStart());
470 assertEquals(1, users_1_2_page3.getLimit());
471 assertEquals(0, users_1_2_page3.getSize());
472 assertEquals(2, users_1_2_page3.getTotal());
473 assertEquals(0, users_1_2_page3.getResults().length);
474 }
475
476 @Test
477 public final void testCreateUser_getUsers_betweenCreatedAt() throws Exception {
478
479 final String username1 = random40("USERa-");
480 final String username2 = random40("USERb-");
481 final String username3 = random40("USERc-");
482 final String password = random8();
483 final String correlationId = setCorrelationId(newCorrelationId());
484
485 final DateTime now0 = now();
486
487 final int count0 = getUserCount();
488
489 Thread.sleep(10);
490
491
492
493 usersService.createUser(correlationId, defaultUser(), username1, instantiate(UserCreate.class)
494 .setPassword(password)
495 .setRole(Role.USERMGR)
496 .setEnabled(true));
497
498 Thread.sleep(10);
499
500
501
502 usersService.createUser(correlationId, defaultUser(), username2, instantiate(UserCreate.class)
503 .setPassword(password)
504 .setRole(Role.USERMGR)
505 .setEnabled(true));
506
507 Thread.sleep(10);
508
509 final DateTime now3 = now();
510
511 usersService.createUser(correlationId, defaultUser(), username3, instantiate(UserCreate.class)
512 .setPassword(password)
513 .setRole(Role.USERMGR)
514 .setEnabled(true));
515
516 assertEquals(count0 + 3, getUserCount());
517
518 Thread.sleep(10);
519
520
521
522 final UsersInfo users2 = usersService.getUsers(correlationId, defaultUser(), instantiate(UsersQuery.class)
523 .setFiltering(and(gt(CREATED_AT, now0), lt(CREATED_AT, now3))));
524
525 assertEquals(0, users2.getStart());
526 assertEquals(10, users2.getLimit());
527 assertEquals(2, users2.getSize());
528 assertEquals(2, users2.getTotal());
529
530 assertEquals(username1, users2.getResults()[0].getUsername());
531 assertEquals(username2, users2.getResults()[1].getUsername());
532 }
533
534 @Test
535 public final void test_validQuery_start_0() throws Exception {
536
537 final String correlationId = setCorrelationId(newCorrelationId());
538
539 final UsersQuery query1 = usersService.validateUsersQuery(correlationId, defaultUser(),
540 "created_at eq 2019-03-04", null, 0, null, null);
541
542 assertEquals(0, query1.getStart().intValue());
543
544 final UsersQuery query2 = usersService.validateUsersQuery(correlationId, defaultUser(), null, null, 2, null,
545 null);
546
547 assertEquals(2, query2.getStart().intValue());
548 }
549
550 @Test
551 public final void test_validQuery_limit_1() throws Exception {
552
553 final String correlationId = setCorrelationId(newCorrelationId());
554
555 final UsersQuery query1 = usersService.validateUsersQuery(correlationId, defaultUser(),
556 "created_at eq 2019-03-04", null, null, 1, null);
557
558 assertEquals(1, query1.getLimit().intValue());
559
560 final UsersQuery query2 = usersService.validateUsersQuery(correlationId, defaultUser(), null, null, null, 2,
561 null);
562
563 assertEquals(2, query2.getLimit().intValue());
564 }
565
566 @Test
567 public final void test_invalidQuery_start_minus1() throws Exception {
568
569 assertThrows(InvalidQueryFilteringException.class, ()
570
571 -> usersService.validateUsersQuery(newCorrelationId(), defaultUser(), null, null, -1, null, null));
572 }
573
574 @Test
575 public final void test_invalidQuery_limit_0() throws Exception {
576
577 usersService.validateUsersQuery(newCorrelationId(), defaultUser(), null, null, null, 0, null);
578 }
579
580 @Test
581 public final void test_invalidQuery_limit_minus1() throws Exception {
582
583 assertThrows(InvalidQueryFilteringException.class, ()
584
585 -> usersService.validateUsersQuery(newCorrelationId(), defaultUser(), null, null, null, -1, null));
586 }
587
588 @Test
589 public final void test_validQuery_sortBy_createdAt() throws Exception {
590
591 final UsersQuery query = usersService.validateUsersQuery(newCorrelationId(), defaultUser(), null, "+created_at",
592 null, null, null);
593
594 assertArrayEquals(new SortBy[] { SORT_BY_CREATED_AT }, query.getSortBys());
595 }
596
597 @Test
598 public final void test_validQuery_sortBy_m_createdAt_username() throws Exception {
599
600 final UsersQuery query = usersService.validateUsersQuery(newCorrelationId(), defaultUser(), null,
601 "-created_at,username", null, null, null);
602
603 assertArrayEquals(new SortBy[] { SORT_BY_CREATED_AT_DESC, SORT_BY_USERNAME }, query.getSortBys());
604 }
605
606 @Test
607 public final void test_validQuery_sortBy_role_m_role() throws Exception {
608
609 final UsersQuery query = usersService.validateUsersQuery(newCorrelationId(), defaultUser(), null,
610 "role,-role", null, null, null);
611
612 assertArrayEquals(new SortBy[] { SORT_BY_ROLE, SORT_BY_ROLE_DESC }, query.getSortBys());
613 }
614
615 private final void deleteIllegalUsers(final String correlationId, final DateTime now) throws ServiceException {
616
617
618
619
620 while (true) {
621
622 final UsersInfo usersK00 = usersService.getUsers(correlationId, defaultUser(), instantiate(UsersQuery.class)
623 .setFiltering(or(
624 gte(CREATED_AT, now),
625 gte(UPDATED_AT, now),
626 gte(LAST_ACTIVE_AT, now)))
627 .setSortBys(SORT_BY_LAST_ACTIVE_AT, SORT_BY_CREATED_AT));
628
629 if (usersK00.getTotal() == 0) {
630 break;
631 }
632
633 System.out.println("now: " + now);
634
635 System.out.println("usersK00: (" + usersK00.getTotal() + ")");
636
637 System.out.println(" sqlWhereClause: " + usersK00.getSqlWhereClause());
638
639 for (final UserInfo user : usersK00.getResults()) {
640
641 System.out.println("Deleting: " + user);
642
643 usersService.deleteUser(correlationId, defaultUser(), user.getUsername());
644 }
645 }
646 }
647
648 @Test
649 public final void testCreateUsers_getUsers_sortByXxx() throws Exception {
650
651 final String correlationId = setCorrelationId(newCorrelationId());
652
653 Thread.sleep(10);
654
655 final DateTime now = now();
656
657 deleteIllegalUsers(correlationId, now);
658
659
660
661 final String username1 = random40("USERa-");
662 final String username2 = random40("USERb-");
663 final String username3 = random40("USERc-");
664 final String username4 = random40("USERd-");
665 final String username5 = random40("USERe-");
666 final String username6 = random40("USERf-");
667
668 assertEquals(0, usersService.getUsers(correlationId, defaultUser(), instantiate(UsersQuery.class)
669 .setFiltering(gte(LAST_ACTIVE_AT, now))
670 .setSortBys(SORT_BY_LAST_ACTIVE_AT, SORT_BY_CREATED_AT)).getTotal());
671
672 final UserCreate create = instantiate(UserCreate.class)
673 .setEnabled(true)
674 .setPassword("xxx");
675
676 usersService.createUser(correlationId, defaultUser(), username1, create
677 .setEnabled(true)
678 .setRole(Role.ADMIN));
679
680 Thread.sleep(10);
681
682 usersService.createUser(correlationId, defaultUser(), username2, create
683 .setEnabled(true)
684 .setRole(Role.USERMGR));
685
686 Thread.sleep(10);
687
688 usersService.createUser(correlationId, defaultUser(), username3, create
689 .setEnabled(true)
690 .setRole(Role.USERMGR));
691
692 Thread.sleep(10);
693
694 usersService.createUser(correlationId, defaultUser(), username4, create
695 .setEnabled(true)
696 .setRole(Role.USERMGR));
697
698 Thread.sleep(10);
699
700 usersService.createUser(correlationId, defaultUser(), username5, create
701 .setEnabled(true)
702 .setRole(Role.USERMGR));
703
704 Thread.sleep(10);
705
706 usersService.createUser(correlationId, defaultUser(), username6, create
707 .setEnabled(true)
708 .setRole(Role.REGULAR));
709
710 final UsersInfo usersA = usersService.getUsers(correlationId, defaultUser(), instantiate(UsersQuery.class)
711 .setFiltering(gte(CREATED_AT, now))
712 .setSortBys(SORT_BY_USERNAME));
713
714 assertEquals(username1, usersA.getResults()[0].getUsername());
715 assertEquals(username2, usersA.getResults()[1].getUsername());
716 assertEquals(6, usersA.getTotal());
717
718 final UsersInfo usersB = usersService.getUsers(correlationId, defaultUser(), instantiate(UsersQuery.class)
719 .setFiltering(gte(CREATED_AT, now))
720 .setSortBys(SORT_BY_USERNAME_DESC));
721
722 assertEquals(username6, usersB.getResults()[0].getUsername());
723 assertEquals(username5, usersB.getResults()[1].getUsername());
724
725 final UsersInfo usersC = usersService.getUsers(correlationId, defaultUser(), instantiate(UsersQuery.class)
726 .setFiltering(gte(CREATED_AT, now))
727 .setSortBys(SORT_BY_ROLE, SORT_BY_CREATED_AT));
728
729 assertEquals(username1, usersC.getResults()[0].getUsername());
730 assertEquals(username6, usersC.getResults()[1].getUsername());
731
732 final UsersInfo usersD = usersService.getUsers(correlationId, defaultUser(), instantiate(UsersQuery.class)
733 .setFiltering(gte(CREATED_AT, now))
734 .setSortBys(SORT_BY_ROLE_DESC, SORT_BY_CREATED_AT));
735
736 assertEquals(username2, usersD.getResults()[0].getUsername());
737 assertEquals(username3, usersD.getResults()[1].getUsername());
738
739 final UsersInfo usersG = usersService.getUsers(correlationId, defaultUser(), instantiate(UsersQuery.class)
740 .setFiltering(gte(CREATED_AT, now))
741 .setSortBys(SORT_BY_CREATED_AT));
742
743 assertEquals(username1, usersG.getResults()[0].getUsername());
744 assertEquals(username2, usersG.getResults()[1].getUsername());
745
746 final UsersInfo usersH = usersService.getUsers(correlationId, defaultUser(), instantiate(UsersQuery.class)
747 .setFiltering(gte(CREATED_AT, now))
748 .setSortBys(SORT_BY_CREATED_AT_DESC));
749
750 assertEquals(username6, usersH.getResults()[0].getUsername());
751 assertEquals(username5, usersH.getResults()[1].getUsername());
752
753 final UsersInfo usersI = usersService.getUsers(correlationId, defaultUser(), instantiate(UsersQuery.class)
754 .setFiltering(gte(UPDATED_AT, now))
755 .setSortBys(SORT_BY_UPDATED_AT));
756
757 assertEquals(username1, usersI.getResults()[0].getUsername());
758 assertEquals(username2, usersI.getResults()[1].getUsername());
759
760 final UsersInfo usersJ = usersService.getUsers(correlationId, defaultUser(), instantiate(UsersQuery.class)
761 .setFiltering(gte(UPDATED_AT, now))
762 .setSortBys(SORT_BY_UPDATED_AT_DESC));
763
764 assertEquals(username6, usersJ.getResults()[0].getUsername());
765 assertEquals(username5, usersJ.getResults()[1].getUsername());
766
767 final UsersInfo usersK0 = usersService.getUsers(correlationId, defaultUser(), instantiate(UsersQuery.class)
768 .setFiltering(and(gte(CREATED_AT, now), gte(LAST_ACTIVE_AT, now)))
769 .setSortBys(SORT_BY_LAST_ACTIVE_AT, SORT_BY_CREATED_AT));
770
771 assertEquals(0, usersK0.getTotal());
772
773 authService.authenticate(correlationId, username1, "xxx");
774
775 Thread.sleep(10);
776
777 authService.authenticate(correlationId, username2, "xxx");
778
779 final UsersInfo usersK1 = usersService.getUsers(correlationId, defaultUser(), instantiate(UsersQuery.class)
780 .setFiltering(gte(LAST_ACTIVE_AT, now))
781 .setSortBys(SORT_BY_LAST_ACTIVE_AT, SORT_BY_CREATED_AT));
782
783 System.out.println("username1: " + username1);
784 System.out.println("username2: " + username2);
785 System.out.println("username3: " + username3);
786 System.out.println("username4: " + username4);
787 System.out.println("username5: " + username5);
788 System.out.println("username6: " + username6);
789 System.out.println("usersK1: (" + usersK1.getTotal() + ")");
790 System.out.println(" sqlWhereClause: " + usersK1.getSqlWhereClause());
791 for (final UserInfo user : usersK1.getResults()) {
792 System.out.println(" " + user);
793 }
794
795 assertEquals(2, usersK1.getTotal());
796
797
798 assertEquals(username1, usersK1.getResults()[0].getUsername());
799 assertEquals(username2, usersK1.getResults()[1].getUsername());
800
801 final UsersInfo usersL = usersService.getUsers(correlationId, defaultUser(), instantiate(UsersQuery.class)
802 .setFiltering(gte(LAST_ACTIVE_AT, now))
803 .setSortBys(SORT_BY_LAST_ACTIVE_AT_DESC));
804
805 assertEquals(username2, usersL.getResults()[0].getUsername());
806 assertEquals(username1, usersL.getResults()[1].getUsername());
807 }
808
809 @Test
810 public final void testCreateUser_authenticateSetLastActiveAt() throws Exception {
811
812 final String username = random40("USER-");
813 final String password1 = random8();
814 final String password2 = random8();
815 final String correlationId = setCorrelationId(newCorrelationId());
816
817 final UserInfo created = usersService.createUser(correlationId, defaultUser(), username,
818 instantiate(UserCreate.class)
819 .setPassword(password1)
820 .setRole(Role.USERMGR)
821 .setEnabled(true));
822
823 assertNull(created.getLastActiveAt());
824
825 final UserSession session1 = authService.authenticate(correlationId, username, password1);
826
827 assertNotNull(session1);
828
829 final UserInfo authenticated1 = usersService.getUser(correlationId, defaultUser(), username);
830
831 assertNotNull(authenticated1.getLastActiveAt());
832
833 Thread.sleep(10);
834
835 UserSession session_invalid;
836 try {
837 session_invalid = authService.authenticate(correlationId, username, password2);
838 } catch (final UnauthenticatedException e) {
839 session_invalid = null;
840 }
841
842 assertNull(session_invalid);
843
844 final UserInfo after_wrong_password = usersService.getUser(correlationId, defaultUser(), username);
845
846 assertEquals(authenticated1.getLastActiveAt(), after_wrong_password.getLastActiveAt());
847
848 final UserInfo updated = usersService.updateUser(correlationId, defaultUser(), username,
849 instantiate(UserUpdate.class)
850 .setPassword(password2)
851 .setRole(Role.ADMIN)
852 .setFromRevision(1)
853 .setEnabled(true));
854
855 assertEquals(authenticated1.getLastActiveAt(), updated.getLastActiveAt());
856
857 try {
858 session_invalid = authService.authenticate(correlationId, username, password1);
859 } catch (final UnauthenticatedException e) {
860 session_invalid = null;
861 }
862
863 assertNull(session_invalid);
864
865 Thread.sleep(10);
866
867 final UserSession session2 = authService.authenticate(correlationId, username, password2);
868
869 assertNotNull(session2);
870
871 final UserInfo authenticated2 = usersService.getUser(correlationId, defaultUser(), username);
872
873 assertNotNull(authenticated2.getLastActiveAt());
874
875 assertNotEquals(authenticated1.getLastActiveAt(), authenticated2.getLastActiveAt());
876 }
877
878 @Test
879 public final void testCreateUser_updateUser() throws Exception {
880
881 final String username = random40("USER-");
882 final String password = random8();
883 final String password2 = random8();
884 final String correlationId = setCorrelationId(newCorrelationId());
885
886 final UserInfo created = usersService.createUser(correlationId, defaultUser(), username,
887 instantiate(UserCreate.class)
888 .setPassword(password)
889 .setRole(Role.USERMGR)
890 .setEnabled(false));
891
892 assertEquals(username, created.getUsername());
893 assertSame(Role.USERMGR, created.getRole());
894 assertNotNull(created.getCreatedAt());
895 assertEquals(created.getCreatedAt(), created.getUpdatedAt());
896 assertNull(created.getLastActiveAt());
897 assertEquals(false, created.isEnabled());
898 assertEquals(1, created.getRevision());
899
900 Thread.sleep(10);
901
902 final UserInfo updated = usersService.updateUser(correlationId, defaultUser(), username,
903 instantiate(UserUpdate.class)
904 .setPassword(password2)
905 .setRole(Role.ADMIN)
906 .setFromRevision(1)
907 .setEnabled(true));
908
909 assertEquals(username, updated.getUsername());
910 assertSame(Role.ADMIN, updated.getRole());
911 assertNotNull(updated.getUpdatedAt());
912 assertEquals(created.getCreatedAt(), updated.getCreatedAt());
913 assertNotEquals(updated.getCreatedAt(), updated.getUpdatedAt());
914 assertNull(created.getLastActiveAt());
915 assertEquals(true, updated.isEnabled());
916 assertEquals(2, updated.getRevision());
917
918 final UserInfo user = usersService.getUser(correlationId, defaultUser(), username);
919
920 assertEquals(username, user.getUsername());
921 assertSame(Role.ADMIN, user.getRole());
922 assertNotNull(user.getUpdatedAt());
923 assertEquals(updated.getCreatedAt(), user.getCreatedAt());
924 assertEquals(updated.getUpdatedAt(), user.getUpdatedAt());
925 assertNull(user.getLastActiveAt());
926 assertEquals(true, updated.isEnabled());
927 assertEquals(2, updated.getRevision());
928 }
929
930 @Test
931 public final void testCreateUser_updateMe_wrongRole() throws Exception {
932
933 final String username = random40("USER-");
934 final String password = random8();
935 final String correlationId = setCorrelationId(newCorrelationId());
936
937 final UserInfo created = usersService.createUser(correlationId, defaultUser(), username,
938 instantiate(UserCreate.class)
939 .setPassword(password)
940 .setRole(Role.REGULAR)
941 .setEnabled(true));
942
943 assertEquals(username, created.getUsername());
944 assertSame(Role.REGULAR, created.getRole());
945
946 assertThrows(UnauthorizedException.class, ()
947
948 -> usersService.updateUser(correlationId, toUser(created), username, instantiate(UserUpdate.class)
949 .setPassword(null)
950 .setRole(Role.ADMIN)
951 .setFromRevision(1)
952 .setEnabled(true)));
953 }
954
955 @Test
956 public final void testCreateUser_updateFullMe_nullRole() throws Exception {
957
958 final String username = random40("USER-");
959 final String password = random8();
960 final String correlationId = setCorrelationId(newCorrelationId());
961
962 final UserInfo created = usersService.createUser(correlationId, defaultUser(), username,
963 instantiate(UserCreate.class)
964 .setPassword(password)
965 .setRole(Role.REGULAR)
966 .setEnabled(true));
967
968 assertEquals(username, created.getUsername());
969 assertSame(Role.REGULAR, created.getRole());
970
971 assertThrows(UnauthorizedException.class, ()
972
973 -> usersService.updateUser(correlationId, toUser(created), username, instantiate(UserUpdate.class)
974 .setPassword(null)
975 .setRole(null)
976 .setFromRevision(1)
977 .setEnabled(true)));
978 }
979
980 @Test
981 public final void testCreateUser_superadmin_update_nullRole() throws Exception {
982
983 final String username = random40("USER-");
984 final String password = random8();
985 final String correlationId = setCorrelationId(newCorrelationId());
986
987 final UserInfo created = usersService.createUser(correlationId, defaultUser(), username,
988 instantiate(UserCreate.class)
989 .setPassword(password)
990 .setRole(Role.REGULAR)
991 .setEnabled(true));
992
993 assertEquals(username, created.getUsername());
994 assertSame(Role.REGULAR, created.getRole());
995
996 final UserInfo updated = usersService.updateUser(correlationId, defaultUser(), username,
997 instantiate(UserUpdate.class)
998 .setPassword(null)
999 .setRole(null)
1000 .setFromRevision(1)
1001 .setEnabled(true));
1002
1003 assertEquals(username, updated.getUsername());
1004 assertSame(Role.REGULAR, updated.getRole());
1005 }
1006
1007 @Test
1008 public final void testCreateUser_updateUser_deleteUser() throws Exception {
1009
1010 final String username = random40("USER-");
1011 final String password = random8();
1012 final String password2 = random8();
1013 final String correlationId = setCorrelationId(newCorrelationId());
1014
1015 usersService.createUser(correlationId, defaultUser(), username, instantiate(UserCreate.class)
1016 .setPassword(password)
1017 .setRole(Role.USERMGR)
1018 .setEnabled(true));
1019
1020 usersService.updateUser(correlationId, defaultUser(), username, instantiate(UserUpdate.class)
1021 .setPassword(password2)
1022 .setRole(Role.ADMIN)
1023 .setFromRevision(1)
1024 .setEnabled(true));
1025
1026 usersService.deleteUser(correlationId, defaultUser(), username);
1027
1028 assertThrows(UsernameNotFoundException.class, ()
1029
1030 -> usersService.getUser(correlationId, defaultUser(), username));
1031 }
1032
1033 @Test
1034 public final void testCreateUser_updateUser_incorrectRevision_1_4() throws Exception {
1035
1036 final String username = random40("USER-");
1037 final String password = random8();
1038 final String password2 = random8();
1039 final String correlationId = setCorrelationId(newCorrelationId());
1040
1041 usersService.createUser(correlationId, defaultUser(), username, instantiate(UserCreate.class)
1042 .setPassword(password)
1043 .setRole(Role.USERMGR)
1044 .setEnabled(true));
1045
1046 assertThrows(IllegalStateUpdateException.class, ()
1047
1048 -> usersService.updateUser(correlationId, defaultUser(), username, instantiate(UserUpdate.class)
1049 .setPassword(password2)
1050 .setRole(Role.ADMIN)
1051 .setFromRevision(4)
1052 .setEnabled(true)));
1053 }
1054
1055 @Test
1056 public final void testCreateUser_updateUser_incorrectRevision_2_1() throws Exception {
1057
1058 final String username = random40("USER-");
1059 final String password = random8();
1060 final String password2 = random8();
1061 final String correlationId = setCorrelationId(newCorrelationId());
1062
1063 usersService.createUser(correlationId, defaultUser(), username, instantiate(UserCreate.class)
1064 .setPassword(password)
1065 .setRole(Role.USERMGR)
1066 .setEnabled(true));
1067
1068 usersService.updateUser(correlationId, defaultUser(), username, instantiate(UserUpdate.class)
1069 .setPassword(password2)
1070 .setRole(Role.ADMIN)
1071 .setFromRevision(1)
1072 .setEnabled(true));
1073
1074 assertThrows(IllegalStateUpdateException.class, ()
1075
1076 -> usersService.updateUser(correlationId, defaultUser(), username, instantiate(UserUpdate.class)
1077 .setPassword(password2)
1078 .setRole(Role.ADMIN)
1079 .setFromRevision(1)
1080 .setEnabled(true)));
1081 }
1082
1083 @Test
1084 public final void testCreateUser_updateUser_correctRevision() throws Exception {
1085
1086 final String username = random40("USER-");
1087 final String password = random8();
1088 final String password2 = random8();
1089 final String correlationId = setCorrelationId(newCorrelationId());
1090
1091 usersService.createUser(correlationId, defaultUser(), username, instantiate(UserCreate.class)
1092 .setPassword(password)
1093 .setRole(Role.USERMGR)
1094 .setEnabled(true));
1095
1096 usersService.updateUser(correlationId, defaultUser(), username, instantiate(UserUpdate.class)
1097 .setPassword(password2)
1098 .setRole(Role.ADMIN)
1099 .setFromRevision(1)
1100 .setEnabled(true));
1101
1102 usersService.updateUser(correlationId, defaultUser(), username, instantiate(UserUpdate.class)
1103 .setPassword(password2)
1104 .setRole(Role.ADMIN)
1105 .setFromRevision(2)
1106 .setEnabled(true));
1107 }
1108
1109 @Test
1110 public final void testDelete_superadmin() throws Exception {
1111
1112 assertThrows(ReservedUsernameException.class, ()
1113
1114 -> usersService.deleteUser(newCorrelationId(), defaultUser(), "superadmin"));
1115 }
1116
1117 @Test
1118 public final void testCreateUser_deleteMyself() throws Exception {
1119
1120 final String username = random40("USER-");
1121 final String password = random8();
1122 final String correlationId = setCorrelationId(newCorrelationId());
1123
1124 final UserInfo created = usersService.createUser(correlationId, defaultUser(), username,
1125 instantiate(UserCreate.class)
1126 .setPassword(password)
1127 .setRole(Role.USERMGR)
1128 .setEnabled(true));
1129
1130 final User user = toUser(created);
1131
1132 assertThrows(UnauthorizedException.class, ()
1133
1134 -> usersService.deleteUser(correlationId, user, username));
1135 }
1136
1137 @Test
1138 public final void testCreateUser_ANONYMOUS() throws Exception {
1139
1140 final String username = random40("USER-");
1141 final String password = random8();
1142 final String correlationId = setCorrelationId(newCorrelationId());
1143
1144 assertThrows(InvalidRoleException.class, ()
1145
1146 -> usersService.createUser(correlationId, defaultUser(), username, instantiate(UserCreate.class)
1147 .setPassword(password)
1148 .setRole(Role.ANONYMOUS)
1149 .setEnabled(true)));
1150 }
1151
1152 @Test
1153 public final void testCreateUser_SUPERADMIN() throws Exception {
1154
1155 final String username = random40("USER-");
1156 final String password = random8();
1157 final String correlationId = setCorrelationId(newCorrelationId());
1158
1159 assertThrows(InvalidRoleException.class, ()
1160
1161 -> usersService.createUser(correlationId, defaultUser(), username, instantiate(UserCreate.class)
1162 .setPassword(password)
1163 .setRole(Role.SUPERADMIN)
1164 .setEnabled(true)));
1165 }
1166
1167 @Test
1168 public final void testUpdateUser_SUPERADMIN() throws Exception {
1169
1170 final String username = random40("USER-");
1171 final String password = random8();
1172 final String correlationId = setCorrelationId(newCorrelationId());
1173
1174 usersService.createUser(correlationId, defaultUser(), username, instantiate(UserCreate.class)
1175 .setPassword(password)
1176 .setRole(Role.USERMGR)
1177 .setEnabled(true));
1178
1179 assertThrows(InvalidRoleException.class, ()
1180
1181 -> usersService.updateUser(correlationId, defaultUser(), username, instantiate(UserUpdate.class)
1182 .setPassword(password)
1183 .setRole(Role.SUPERADMIN)
1184 .setEnabled(true)));
1185 }
1186
1187 @Test
1188 public final void testUpdateullUser_ANONYMOUS() throws Exception {
1189
1190 final String username = random40("USER-");
1191 final String password = random8();
1192 final String correlationId = setCorrelationId(newCorrelationId());
1193
1194 usersService.createUser(correlationId, defaultUser(), username, instantiate(UserCreate.class)
1195 .setPassword(password)
1196 .setRole(Role.ADMIN)
1197 .setEnabled(true));
1198
1199 assertThrows(InvalidRoleException.class, ()
1200
1201 -> usersService.updateUser(correlationId, defaultUser(), username, instantiate(UserUpdate.class)
1202 .setPassword(password)
1203 .setRole(Role.ANONYMOUS)
1204 .setEnabled(true)));
1205 }
1206
1207 @Test
1208 public final void testQuery_sortBys_all() throws Exception {
1209
1210 final String correlationId = setCorrelationId(newCorrelationId());
1211
1212 ensureUsername(random40("U-1"));
1213 ensureUsername(random40("U-2"));
1214
1215 for (final SortBy sortBy : SortBy.values()) {
1216
1217 usersService.getUsers(correlationId, defaultUser(), instantiate(UsersQuery.class)
1218 .setSortBys(sortBy));
1219
1220 usersService.getUsers(correlationId, defaultUser(),
1221 usersService.validateUsersQuery(correlationId, defaultUser(),
1222 null,
1223 substringAfter(sortBy.name(), "SORT_BY_").toLowerCase(ENGLISH),
1224 0,
1225 10,
1226 null
1227 ));
1228 }
1229 }
1230
1231 @Test
1232 public final void testCreateUser_preferredLang_and_TimeZone() throws Exception {
1233
1234 final String username = random40("USER-");
1235 final String password = random8();
1236 final String correlationId = setCorrelationId(newCorrelationId());
1237
1238 final UserInfo created = usersService.createUser(correlationId, defaultUser(), username,
1239 instantiate(UserCreate.class)
1240 .setPassword(password)
1241 .setRole(Role.REGULAR)
1242 .setPreferredLang("EN")
1243 .setPreferredTimeZone("-04:00")
1244 .setEnabled(true));
1245
1246 assertEquals("EN", created.getPreferredLang());
1247 assertEquals("-04:00", created.getPreferredTimeZone());
1248 }
1249
1250 @Test
1251 public final void testCreateUser_updateUserMe_preferredLang_and_TimeZone() throws Exception {
1252
1253 final String username = random40("USER-");
1254 final String correlationId = setCorrelationId(newCorrelationId());
1255
1256 final UserInfo created = usersService.createUser(correlationId, defaultUser(), username,
1257 instantiate(UserCreate.class)
1258 .setRole(Role.REGULAR)
1259 .setEnabled(false));
1260
1261 assertSame(Role.REGULAR, created.getRole());
1262
1263 assertEquals(null, created.getPreferredLang());
1264 assertEquals(null, created.getPreferredTimeZone());
1265 assertEquals(false, created.isEnabled());
1266
1267 final UserInfo updated1 = usersService.updateUserMe(correlationId, toUser(created),
1268 instantiate(UserUpdate.class)
1269 .setPreferredTimeZone("-04:00")
1270 .setFromRevision(1));
1271
1272 assertEquals(null, updated1.getPreferredLang());
1273 assertEquals("-04:00", updated1.getPreferredTimeZone());
1274 assertEquals(false, updated1.isEnabled());
1275
1276 final UserInfo updated2 = usersService.updateUserMe(correlationId, toUser(created),
1277 instantiate(UserUpdate.class)
1278 .setPreferredLang("EN")
1279 .setEnabled(true)
1280 .setFromRevision(2));
1281
1282 assertEquals("EN", updated2.getPreferredLang());
1283 assertEquals("-04:00", updated2.getPreferredTimeZone());
1284 assertEquals(true, updated2.isEnabled());
1285 }
1286
1287 @Test
1288 public final void testCreateUser_updateUser_preferredLang_and_TimeZone() throws Exception {
1289
1290 final String username = random40("USER-");
1291 final String correlationId = setCorrelationId(newCorrelationId());
1292
1293 final UserInfo created = usersService.createUser(correlationId, defaultUser(), username,
1294 instantiate(UserCreate.class)
1295 .setRole(Role.REGULAR)
1296 .setEnabled(true));
1297
1298 assertEquals(true, created.isEnabled());
1299
1300 final UserInfo updated1 = usersService.updateUser(correlationId, defaultUser(), username,
1301 instantiate(UserUpdate.class)
1302 .setPreferredLang("EN")
1303 .setFromRevision(1));
1304
1305 assertEquals("EN", updated1.getPreferredLang());
1306 assertEquals(null, updated1.getPreferredTimeZone());
1307 assertEquals(true, updated1.isEnabled());
1308
1309 final UserInfo updated2 = usersService.updateUser(correlationId, defaultUser(), username,
1310 instantiate(UserUpdate.class)
1311 .setPreferredTimeZone("-04:00")
1312 .setEnabled(false)
1313 .setFromRevision(2));
1314
1315 assertEquals("EN", updated2.getPreferredLang());
1316 assertEquals("-04:00", updated2.getPreferredTimeZone());
1317 assertEquals(false, updated2.isEnabled());
1318 }
1319 }