This project has retired. For details please refer to its
Attic page.
1 package org.apache.archiva.redback.users.provider.test;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import junit.framework.TestCase;
23 import org.apache.archiva.redback.policy.UserSecurityPolicy;
24 import org.apache.archiva.redback.users.PermanentUserException;
25 import org.apache.archiva.redback.users.User;
26 import org.apache.archiva.redback.users.UserManager;
27 import org.apache.archiva.redback.users.UserManagerException;
28 import org.apache.archiva.redback.users.UserNotFoundException;
29 import org.apache.archiva.redback.users.UserQuery;
30 import org.junit.Test;
31 import org.junit.runner.RunWith;
32 import org.springframework.test.annotation.DirtiesContext;
33 import org.springframework.test.context.ContextConfiguration;
34 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
35
36 import javax.inject.Inject;
37 import java.util.List;
38
39
40
41
42
43
44 @RunWith(SpringJUnit4ClassRunner.class)
45 @ContextConfiguration(locations = { "classpath*:/META-INF/spring-context.xml", "classpath*:/spring-context.xml" })
46 @DirtiesContext(classMode = DirtiesContext.ClassMode.AFTER_EACH_TEST_METHOD)
47 public class AbstractUserManagerTestCase
48 extends TestCase
49 {
50
51
52
53
54
55 private UserManager userManager;
56
57 @Inject
58 private UserSecurityPolicy securityPolicy;
59
60 private UserManagerEventTracker eventTracker;
61
62
63 private static final int EVENTTRACKERCOUNT = 2;
64
65
66
67
68
69 public UserManager getUserManager()
70 {
71 return userManager;
72 }
73
74 public void setUserManager( UserManager um )
75 {
76 this.userManager = um;
77 if ( this.userManager != null )
78 {
79 this.eventTracker = new UserManagerEventTracker();
80 this.userManager.addUserManagerListener( this.eventTracker );
81 }
82 }
83
84 public void setUp()
85 throws Exception
86 {
87 super.setUp();
88 }
89
90 public void tearDown()
91 throws Exception
92 {
93 super.tearDown();
94 }
95
96 protected void assertCleanUserManager()
97 throws UserManagerException
98 {
99
100 getUserManager().eraseDatabase();
101 getEventTracker().userManagerInit( true );
102 assertNotNull( getUserManager() );
103
104 assertEquals( "New UserManager should contain no users. " + userManager.getUsers(), 0,
105 userManager.getUsers().size() );
106 }
107
108 @Test
109 public void testFindUserByNullPrincipal()
110 throws UserManagerException
111 {
112 try
113 {
114 Object obj = null;
115 getUserManager().findUser( null );
116 fail( "findUser() with null Object Should have thrown a UserNotFoundException." );
117 }
118 catch ( UserNotFoundException e )
119 {
120
121 }
122 }
123
124 @Test
125 public void testFindUserByEmptyUsername()
126 throws UserManagerException
127 {
128 try
129 {
130 String username = null;
131 getUserManager().findUser( username );
132 fail( "findUser() with null username Should have thrown a UserNotFoundException." );
133 }
134 catch ( UserNotFoundException e )
135 {
136
137 }
138
139 try
140 {
141 String username = "";
142 getUserManager().findUser( username );
143 fail( "findUser() with empty username Should have thrown a UserNotFoundException." );
144 }
145 catch ( UserNotFoundException e )
146 {
147
148 }
149
150 try
151 {
152 String username = " ";
153 getUserManager().findUser( username );
154 fail( "findUser() with all whitespace username Should have thrown a UserNotFoundException." );
155 }
156 catch ( UserNotFoundException e )
157 {
158
159 }
160 }
161
162 @Test
163 public void testAddFindUserByPrincipal()
164 throws UserNotFoundException, UserManagerException
165 {
166 assertCleanUserManager();
167 securityPolicy.setEnabled( false );
168
169 User smcqueen = getUserManager().createUser( "smcqueen", "Steve McQueen", "the cooler king" );
170
171
172
173
174 User added = userManager.addUser( smcqueen );
175
176 assertEquals( 1, userManager.getUsers().size() );
177
178
179 User actual = userManager.findUser( added.getUsername() );
180 assertEquals( added, actual );
181
182
183 assertEquals( EVENTTRACKERCOUNT, getEventTracker().countInit );
184 assertNotNull( getEventTracker().lastDbFreshness );
185 assertTrue( getEventTracker().lastDbFreshness.booleanValue() );
186
187 assertEquals( 1, getEventTracker().addedUsernames.size() );
188 assertEquals( 0, getEventTracker().removedUsernames.size() );
189 assertEquals( 0, getEventTracker().updatedUsernames.size() );
190 }
191
192 @Test
193 public void testAddFindUserLockedStatus()
194 throws UserNotFoundException, UserManagerException
195 {
196 assertCleanUserManager();
197 securityPolicy.setEnabled( false );
198
199 User smcqueen = getUserManager().createUser( "smcqueen", "Steve McQueen", "the cooler king" );
200
201 smcqueen.setLocked( true );
202
203
204
205
206
207 User added = userManager.addUser( smcqueen );
208
209 assertTrue( added.isLocked() );
210
211 assertEquals( 1, userManager.getUsers().size() );
212
213
214 User actual = userManager.findUser( added.getUsername() );
215 assertEquals( added, actual );
216
217 assertTrue( actual.isLocked() );
218
219
220 assertEquals( EVENTTRACKERCOUNT, getEventTracker().countInit );
221 assertNotNull( getEventTracker().lastDbFreshness );
222 assertTrue( getEventTracker().lastDbFreshness.booleanValue() );
223
224 assertEquals( 1, getEventTracker().addedUsernames.size() );
225 assertEquals( 0, getEventTracker().removedUsernames.size() );
226 assertEquals( 0, getEventTracker().updatedUsernames.size() );
227 }
228
229 @Test
230 public void testAddFindUserByUsername()
231 throws UserNotFoundException, UserManagerException
232 {
233 assertCleanUserManager();
234 securityPolicy.setEnabled( false );
235
236 User smcqueen = getUserManager().createUser( "smcqueen", "Steve McQueen", "the cooler king" );
237
238 User added = userManager.addUser( smcqueen );
239
240 assertEquals( 1, userManager.getUsers().size() );
241
242 User actual = userManager.findUser( "smcqueen" );
243 assertEquals( added, actual );
244
245
246 assertEquals( EVENTTRACKERCOUNT, getEventTracker().countInit );
247 assertNotNull( getEventTracker().lastDbFreshness );
248 assertTrue( getEventTracker().lastDbFreshness.booleanValue() );
249
250 assertEquals( 1, getEventTracker().addedUsernames.size() );
251 assertEquals( 0, getEventTracker().removedUsernames.size() );
252 assertEquals( 0, getEventTracker().updatedUsernames.size() );
253 }
254
255 @Test
256 public void testCreateUser()
257 throws Exception
258 {
259 assertCleanUserManager();
260 securityPolicy.setEnabled( false );
261
262 UserManager um = getUserManager();
263 User user = um.createUser( "admin", "Administrator", "admin@somedomain.com" );
264 user.setPassword( "adminpass" );
265 um.addUser( user );
266
267 assertEquals( 1, um.getUsers().size() );
268
269
270 assertEquals( EVENTTRACKERCOUNT, getEventTracker().countInit );
271 assertNotNull( getEventTracker().lastDbFreshness );
272 assertTrue( getEventTracker().lastDbFreshness.booleanValue() );
273
274 assertEquals( 1, getEventTracker().addedUsernames.size() );
275 assertEquals( 0, getEventTracker().removedUsernames.size() );
276 assertEquals( 0, getEventTracker().updatedUsernames.size() );
277 }
278
279 @Test
280 public void testAddUser()
281 throws Exception
282 {
283 assertCleanUserManager();
284 securityPolicy.setEnabled( false );
285
286 UserManager um = getUserManager();
287 assertNotNull( um.getUsers() );
288 assertEquals( 0, um.getUsers().size() );
289
290 User user = um.createUser( "tommy123", "Tommy Traddles", "tommy.traddles@somedomain.com" );
291 user.setPassword( "hillybilly" );
292 um.addUser( user );
293
294 assertNotNull( um.getUsers() );
295 assertEquals( 1, um.getUsers().size() );
296
297
298 assertEquals( EVENTTRACKERCOUNT, getEventTracker().countInit );
299 assertNotNull( getEventTracker().lastDbFreshness );
300 assertTrue( getEventTracker().lastDbFreshness.booleanValue() );
301
302 assertEquals( 1, getEventTracker().addedUsernames.size() );
303 assertEquals( 0, getEventTracker().removedUsernames.size() );
304 assertEquals( 0, getEventTracker().updatedUsernames.size() );
305 }
306
307 @Test
308 public void testDeleteUser()
309 throws Exception
310 {
311 assertCleanUserManager();
312 securityPolicy.setEnabled( false );
313
314 UserManager um = getUserManager();
315 User user = um.createUser( "admin", "Administrator", "admin@somedomain.com" );
316 user.setPassword( "adminpass" );
317 um.addUser( user );
318
319 assertEquals( 1, um.getUsers().size() );
320
321 um.deleteUser( user.getUsername() );
322 assertEquals( 0, um.getUsers().size() );
323
324
325 try
326 {
327 um.findUser( "admin" );
328 fail( "Expected UserNotFoundException!" );
329 }
330 catch ( UserNotFoundException e )
331 {
332
333 }
334
335
336 assertEquals( EVENTTRACKERCOUNT, getEventTracker().countInit );
337 assertNotNull( getEventTracker().lastDbFreshness );
338 assertTrue( getEventTracker().lastDbFreshness.booleanValue() );
339
340 assertEquals( 1, getEventTracker().addedUsernames.size() );
341 assertEquals( 1, getEventTracker().removedUsernames.size() );
342 assertEquals( 0, getEventTracker().updatedUsernames.size() );
343 }
344
345 @Test
346 public void testFindUser()
347 throws Exception
348 {
349 assertCleanUserManager();
350 securityPolicy.setEnabled( false );
351
352 UserManager um = getUserManager();
353
354
355 User u1 = um.createUser( "admin", "Administrator", "admin@somedomain.com" );
356 u1.setPassword( "adminpass" );
357 um.addUser( u1 );
358
359 u1 = um.createUser( "administrator", "Administrator User", "administrator@somedomain.com" );
360 u1.setPassword( "password" );
361 um.addUser( u1 );
362
363 u1 = um.createUser( "root", "Root User", "root@somedomain.com" );
364 u1.setPassword( "rootpass" );
365 um.addUser( u1 );
366
367 assertEquals( 3, um.getUsers().size() );
368
369
370 User user = um.findUser( "root" );
371 assertNotNull( user );
372 assertEquals( "root@somedomain.com", user.getEmail() );
373 assertEquals( "root", user.getUsername() );
374 assertEquals( "Root User", user.getFullName() );
375
376 assertNull( user.getPassword() );
377
378 assertTrue( securityPolicy.getPasswordEncoder().isPasswordValid( user.getEncodedPassword(), "rootpass" ) );
379
380
381 try
382 {
383 um.findUser( "non-existent" );
384 fail( "Expected UserNotFoundException!" );
385 }
386 catch ( UserNotFoundException e )
387 {
388
389 }
390
391
392 assertEquals( EVENTTRACKERCOUNT, getEventTracker().countInit );
393 assertNotNull( getEventTracker().lastDbFreshness );
394 assertTrue( getEventTracker().lastDbFreshness.booleanValue() );
395
396 assertEquals( 3, getEventTracker().addedUsernames.size() );
397 assertEquals( 0, getEventTracker().removedUsernames.size() );
398 assertEquals( 0, getEventTracker().updatedUsernames.size() );
399 }
400
401 @Test
402 public void testFindUsersByQuery()
403 throws UserManagerException
404 {
405 assertCleanUserManager();
406 securityPolicy.setEnabled( false );
407
408 UserManager um = getUserManager();
409
410
411 User u1 = um.createUser( "admin", "Administrator", "admin@somedomain.com" );
412 u1.setPassword( "adminpass" );
413 um.addUser( u1 );
414
415 u1 = um.createUser( "administrator", "Administrator User", "administrator@somedomain.com" );
416 u1.setPassword( "password" );
417 um.addUser( u1 );
418
419 u1 = um.createUser( "root", "Root User", "root@somedomain.com" );
420 u1.setPassword( "rootpass" );
421 um.addUser( u1 );
422
423 assertEquals( 3, um.getUsers().size() );
424
425
426 UserQuery query = um.createUserQuery();
427 query.setUsername( "Admin" );
428 assertEquals( 2, um.findUsersByQuery( query ).size() );
429
430
431 query = um.createUserQuery();
432 query.setFullName( "Admin" );
433 assertEquals( 2, um.findUsersByQuery( query ).size() );
434
435 query = um.createUserQuery();
436 query.setFullName( "Administrator" );
437 assertEquals( 2, um.findUsersByQuery( query ).size() );
438
439 query = um.createUserQuery();
440 query.setFullName( "r User" );
441 assertEquals( 1, um.findUsersByQuery( query ).size() );
442
443
444 query = um.createUserQuery();
445 query.setEmail( "somedomain" );
446 assertEquals( 3, um.findUsersByQuery( query ).size() );
447
448
449 query = um.createUserQuery();
450 query.setEmail( "root@" );
451 assertEquals( 1, um.findUsersByQuery( query ).size() );
452
453
454 query = um.createUserQuery();
455 try
456 {
457 query.setOrderBy( "unknownString" );
458 fail( "Expected IllegalArgumentException" );
459 }
460 catch ( IllegalArgumentException e )
461 {
462
463 }
464
465
466 query = um.createUserQuery();
467 query.setOrderBy( UserQuery.ORDER_BY_EMAIL );
468 List<User> users = um.findUsersByQuery( query );
469 assertEquals( 3, users.size() );
470 assertEquals( "admin@somedomain.com", ( (User) users.get( 0 ) ).getEmail() );
471
472
473 query = um.createUserQuery();
474 query.setOrderBy( UserQuery.ORDER_BY_EMAIL );
475 query.setAscending( false );
476 users = um.findUsersByQuery( query );
477 assertEquals( 3, users.size() );
478 assertEquals( "root@somedomain.com", ( (User) users.get( 0 ) ).getEmail() );
479
480
481 query = um.createUserQuery();
482 query.setOrderBy( UserQuery.ORDER_BY_EMAIL );
483 query.setAscending( false );
484 query.setMaxResults( 2 );
485 users = um.findUsersByQuery( query );
486 assertEquals( 2, users.size() );
487 assertEquals( "root@somedomain.com", ( (User) users.get( 0 ) ).getEmail() );
488
489
490 query = um.createUserQuery();
491 query.setOrderBy( UserQuery.ORDER_BY_EMAIL );
492 query.setAscending( false );
493 query.setMaxResults( 2 );
494 query.setFirstResult( 2 );
495 users = um.findUsersByQuery( query );
496 assertEquals( 1, users.size() );
497 assertEquals( "admin@somedomain.com", ( (User) users.get( 0 ) ).getEmail() );
498
499
500 query = um.createUserQuery();
501 query.setOrderBy( UserQuery.ORDER_BY_EMAIL );
502 query.setFullName( "admin" );
503 query.setEmail( "admin@" );
504 users = um.findUsersByQuery( query );
505 assertEquals( 1, users.size() );
506 assertEquals( "admin@somedomain.com", ( (User) users.get( 0 ) ).getEmail() );
507 }
508
509 @Test
510 public void testUserExists()
511 throws Exception
512 {
513 assertCleanUserManager();
514 securityPolicy.setEnabled( false );
515
516 UserManager um = getUserManager();
517
518
519 User u1 = um.createUser( "admin", "Administrator", "admin@somedomain.com" );
520 u1.setPassword( "adminpass" );
521 um.addUser( u1 );
522
523 assertTrue( um.userExists( "admin" ) );
524 assertFalse( um.userExists( "voodoohatrack" ) );
525
526
527 assertEquals( EVENTTRACKERCOUNT, getEventTracker().countInit );
528 assertNotNull( getEventTracker().lastDbFreshness );
529 assertTrue( getEventTracker().lastDbFreshness.booleanValue() );
530
531 assertEquals( 1, getEventTracker().addedUsernames.size() );
532 assertEquals( 0, getEventTracker().removedUsernames.size() );
533 assertEquals( 0, getEventTracker().updatedUsernames.size() );
534 }
535
536 @Test
537 public void testUpdateUser()
538 throws Exception
539 {
540 assertCleanUserManager();
541 securityPolicy.setEnabled( false );
542
543 UserManager um = getUserManager();
544
545
546 User u1 = um.createUser( "root", "Root User", "root@somedomain.com" );
547 u1.setPassword( "rootpass" );
548 u1 = um.addUser( u1 );
549
550
551 User user = um.findUser( "root" );
552 assertNotNull( user );
553 assertEquals( u1, user );
554
555 user.setEmail( "superuser@somedomain.com" );
556 user.setPassword( "superpass" );
557 user.setFullName( "Super User" );
558
559 um.updateUser( user );
560
561
562 user = um.findUser( "root" );
563 assertNotNull( user );
564 assertEquals( "superuser@somedomain.com", user.getEmail() );
565 assertEquals( "Super User", user.getFullName() );
566 assertTrue( securityPolicy.getPasswordEncoder().isPasswordValid( user.getEncodedPassword(), "superpass" ) );
567
568
569 assertEquals( EVENTTRACKERCOUNT, getEventTracker().countInit );
570 assertNotNull( getEventTracker().lastDbFreshness );
571 assertTrue( getEventTracker().lastDbFreshness.booleanValue() );
572
573 assertEquals( 1, getEventTracker().addedUsernames.size() );
574 assertEquals( 0, getEventTracker().removedUsernames.size() );
575 assertEquals( 1, getEventTracker().updatedUsernames.size() );
576 }
577
578 @Test
579 public void testDeletePermanentUser()
580 throws UserNotFoundException, UserManagerException
581 {
582 assertCleanUserManager();
583 securityPolicy.setEnabled( false );
584
585 UserManager um = getUserManager();
586 User user = um.createUser( "admin", "Administrator", "admin@somedomain.com" );
587 user.setPassword( "adminpass" );
588 user.setPermanent( true );
589 user = um.addUser( user );
590
591 assertEquals( 1, um.getUsers().size() );
592
593 try
594 {
595 um.deleteUser( user.getUsername() );
596 fail( "Deleting permanent user shold throw PermanentUserException." );
597 }
598 catch ( PermanentUserException e )
599 {
600
601 }
602
603 assertEquals( 1, um.getUsers().size() );
604
605
606 User admin = um.findUser( "admin" );
607 assertNotNull( admin );
608 assertEquals( user.getEmail(), admin.getEmail() );
609 assertEquals( user.getFullName(), admin.getFullName() );
610
611
612 assertEquals( EVENTTRACKERCOUNT, getEventTracker().countInit );
613 assertNotNull( getEventTracker().lastDbFreshness );
614 assertTrue( getEventTracker().lastDbFreshness.booleanValue() );
615
616 assertEquals( 1, getEventTracker().addedUsernames.size() );
617 assertEquals( 0, getEventTracker().removedUsernames.size() );
618 assertEquals( 0, getEventTracker().updatedUsernames.size() );
619 }
620
621 public UserManagerEventTracker getEventTracker()
622 {
623 return eventTracker;
624 }
625
626 public void setEventTracker( UserManagerEventTracker eventTracker )
627 {
628 this.eventTracker = eventTracker;
629 }
630 }