2 * Copyright 2005-2010 the original author or authors.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
16 package org.wamblee.usermgt;
18 import junit.framework.TestCase;
20 import org.apache.log4j.Logger;
22 import org.wamblee.security.encryption.Md5HexMessageDigester;
24 import org.wamblee.usermgt.UserMgtException.Reason;
29 * Test of user administration implementation.
31 * @author Erik Brakkee
33 public class UserAdministrationImplTest extends TestCase {
34 private static final Logger LOGGER = Logger
35 .getLogger(UserAdministrationImplTest.class);
37 private static final String USER1 = "piet";
39 private static final String PASS1 = "passpiet";
41 private static final String USER2 = "kees";
43 private static final String PASS2 = "passkees";
45 private static final String GROUP1 = "cyclists";
47 private static final String GROUP2 = "runners";
49 private UserAdministration admin;
54 * @see junit.framework.TestCase#setUp()
57 protected void setUp() throws Exception {
59 admin = createAdmin();
62 protected UserAdministration createAdmin() {
63 UserSet users = new InMemoryUserSet(new RegexpNameValidator(
64 RegexpNameValidator.PASSWORD_PATTERN, Reason.INVALID_PASSWORD,
65 "Password must contain at least 6 characters"),
66 new Md5HexMessageDigester());
67 GroupSet groups = new InMemoryGroupSet();
69 return new UserAdministrationImpl(users, groups,
70 new RegexpNameValidator(RegexpNameValidator.ID_PATTERN,
71 Reason.INVALID_USERNAME, "Invalid user"),
72 new RegexpNameValidator(RegexpNameValidator.ID_PATTERN,
73 Reason.INVALID_GROUPNAME, "Invalid group"));
76 protected User createUser(String aName, String aPassword, Group aGroup)
77 throws UserMgtException {
78 return UsermgtTestUtils.createUser(aName, aPassword, aGroup);
82 * Constructs the admin, verify it contains no users and no groups.
84 public void testConstruct() {
85 assertEquals(0, admin.getUsers().size());
86 assertEquals(0, admin.getGroups().size());
87 assertEquals(0, admin.getUserCount());
88 assertEquals(0, admin.getGroupCount());
92 * Creates a new group. Verifies the group is created correctly and that the
96 public void testCreateGroup() throws UserMgtException {
97 Group group = admin.createGroup(GROUP1);
99 assertEquals(GROUP1, group.getName());
101 Set<Group> groups = admin.getGroups();
102 assertEquals(1, groups.size());
103 assertEquals(1, admin.getGroupCount());
104 assertTrue(groups.contains(group));
107 private void createInvalidGroup(String aUsername) {
109 admin.createGroup(aUsername);
111 } catch (UserMgtException e) {
112 assertEquals(UserMgtException.Reason.INVALID_GROUPNAME, e
114 assertEquals(0, admin.getGroupCount());
119 * Creates a new group with an invalid name. Verifies that the appropriate
120 * exception is thrown.
122 * @throws UserMgtException
124 public void testCreateInvalidGroupName() throws UserMgtException {
125 createInvalidGroup("");
126 createInvalidGroup("0abc"); // should not start with digits
127 createInvalidGroup("a b"); // should not contain spaces
128 createInvalidGroup(" aa");
129 createInvalidGroup("aa ");
133 * Creates a new group which conflicts with an existing one. Verifies that
134 * the UserMgtException is thrown and that no group is added.
137 public void testCreateDuplicateGroup() throws UserMgtException {
138 admin.createGroup(GROUP1);
141 admin.createGroup(GROUP1);
142 } catch (UserMgtException e) {
143 assertEquals(UserMgtException.Reason.DUPLICATE_GROUP, e.getReason());
144 assertEquals(1, admin.getGroupCount());
153 * Creates a new user. Verifies the user is created correctly and that the
157 public void testCreateUser() throws UserMgtException {
158 Group group = admin.createGroup(GROUP1);
159 User user = admin.createUser(USER1, PASS1, group);
161 assertEquals(USER1, user.getName());
162 user.checkPassword(PASS1);
164 Set<User> users = admin.getUsers();
165 assertEquals(1, users.size());
166 assertEquals(1, admin.getUserCount());
167 assertTrue(users.contains(user));
170 private void createInvalidUser(String aUsername, Group aGroup) {
172 admin.createUser(aUsername, "pass", aGroup);
174 } catch (UserMgtException e) {
175 assertEquals(UserMgtException.Reason.INVALID_USERNAME, e
177 assertEquals(0, admin.getUserCount());
182 * Constructs users with invalid names. Verifies that the appropriate
183 * exception is thrown.
186 public void testCreateInvalidUserName() throws UserMgtException {
187 Group group = admin.createGroup(GROUP1);
188 createInvalidUser("", group);
189 createInvalidUser("0abc", group); // should not start with digits
190 createInvalidUser("a b", group); // should not contain spaces
191 createInvalidUser(" aa", group);
192 createInvalidUser("aa ", group);
196 * Creates a new user which conflicts with an existing one. Verifies that
197 * the UserMgtException is thrown and that no user is added.
200 public void testCreateDuplicateUser() throws UserMgtException {
201 Group group = admin.createGroup(GROUP1);
202 admin.createUser(USER1, PASS1, group);
205 admin.createUser(USER1, PASS2, group);
207 } catch (UserMgtException e) {
208 assertEquals(UserMgtException.Reason.DUPLICATE_USER, e.getReason());
209 assertEquals(1, admin.getUserCount());
214 * Gets a known user by name. Verifies the correct user is obtained.
215 * Verifies that null is returned when trying to obtain an unknown user.
218 public void testGetUser() throws UserMgtException {
219 Group group = admin.createGroup(GROUP1);
220 User user = admin.createUser(USER1, PASS1, group);
221 User user2 = admin.getUser(USER1);
222 assertTrue(user.equals(user2));
223 assertNull(admin.getUser(USER2));
227 * Gets a known group by name. Verifies the correct group is obtained.
228 * Verifies that null is returned when the group is not known.
231 public void testGetGroup() throws UserMgtException {
232 Group group = admin.createGroup(GROUP1);
233 Group group2 = admin.getGroup(GROUP1);
234 assertTrue(group.equals(group2));
235 assertNull(admin.getGroup(GROUP2));
239 * Adds a user to a group. Verifies that the user is added using several API
240 * calls. Verifies that an exception occurs if the user is not already part
244 public void testAddUserToGroup() throws UserMgtException {
245 Group group = admin.createGroup(GROUP1);
246 User user = admin.createUser(USER1, PASS1, group);
247 Group group2 = admin.createGroup(GROUP2);
248 assertTrue(user.isInGroup(group));
249 assertFalse(user.isInGroup(group2));
250 admin.addUserToGroup(user, group2);
251 assertTrue(user.isInGroup(group));
252 assertTrue(user.isInGroup(group2));
254 Set<User> users = admin.getUsers(group2);
255 assertNotNull(users);
256 assertEquals(1, users.size());
257 assertTrue(users.contains(user));
260 admin.addUserToGroup(user, group);
261 } catch (UserMgtException e) {
262 assertEquals(UserMgtException.Reason.USER_ALREADY_IN_GROUP, e
272 * Adds a user to a group where the user does not exist. Verifies that an
276 public void testAddUserToGroupUnknownUser() throws UserMgtException {
277 Group group = admin.createGroup(GROUP1);
278 User user = createUser(USER1, PASS1, group);
281 admin.addUserToGroup(user, group);
282 } catch (UserMgtException e) {
283 assertEquals(UserMgtException.Reason.UNKNOWN_USER, e.getReason());
292 * Adds a user to a group where the user does not exist. Verifies that an
296 public void testAddUserToGroupUnknownGroup() throws UserMgtException {
297 Group group = admin.createGroup(GROUP1);
298 User user = admin.createUser(USER1, PASS1, group);
299 Group group2 = new Group(GROUP2);
302 admin.addUserToGroup(user, group2);
303 } catch (UserMgtException e) {
304 assertEquals(UserMgtException.Reason.UNKNOWN_GROUP, e.getReason());
313 * Removes a user from a group. Verifies that the user is removed from the
314 * group using several API calls. Verifies that an exception occurs if the
315 * user not part of the group or if the user is only part of one group.
318 public void testRemoveUserFromGroup() throws UserMgtException {
319 Group group = admin.createGroup(GROUP1);
321 User user = admin.createUser(USER1, PASS1, group);
322 Group group2 = admin.createGroup(GROUP2);
323 admin.addUserToGroup(user, group2);
325 Set<Group> groups = user.getGroups();
326 assertEquals(2, groups.size());
327 assertTrue(groups.contains(group));
328 assertTrue(groups.contains(group2));
330 admin.removeUserFromGroup(user, group);
331 groups = user.getGroups();
332 assertEquals(1, groups.size());
333 assertTrue(groups.contains(group2));
334 assertFalse(groups.contains(group));
338 * Removes a user from a group where the user is not known. Verifies that an
339 * exception is thrown.
342 public void testRemoveUserFromGroupUnknownUser() throws UserMgtException {
343 Group group = admin.createGroup(GROUP1);
344 User user = createUser(USER1, GROUP1, group);
347 admin.removeUserFromGroup(user, group);
348 } catch (UserMgtException e) {
349 assertEquals(UserMgtException.Reason.UNKNOWN_USER, e.getReason());
354 * Removes a user from a group where the group is not known. Verifies that
355 * an exception is thrown.
358 public void testRemoveUserFromGroupUnknownGroup() throws UserMgtException {
359 Group group = admin.createGroup(GROUP1);
360 User user = admin.createUser(USER1, PASS1, group);
361 Group group2 = new Group(GROUP2);
364 admin.removeUserFromGroup(user, group2);
365 } catch (UserMgtException e) {
366 assertEquals(UserMgtException.Reason.UNKNOWN_GROUP, e.getReason());
371 * Removes a user from a group where the user is only part of one group.
372 * Verifies that an exception is thrown.
375 public void testRemoveUserFromGroupOnlyGroup() throws UserMgtException {
376 Group group = admin.createGroup(GROUP1);
377 User user = admin.createUser(USER1, PASS1, group);
380 admin.removeUserFromGroup(user, group);
381 } catch (UserMgtException e) {
382 assertEquals(UserMgtException.Reason.USER_MUST_BE_IN_A_GROUP, e
388 * Gets the list of users and groups. Verifies that the correct suers and
389 * groups are returned. Verifies also that the relations from user to group
393 public void testGetUsersAndGroups() throws UserMgtException {
394 Group group1 = admin.createGroup(GROUP1);
395 Group group2 = admin.createGroup(GROUP2);
397 User user1 = admin.createUser(USER1, PASS1, group1);
398 admin.addUserToGroup(user1, group2);
400 User user2 = admin.createUser(USER2, PASS2, group2);
402 Set<User> users = admin.getUsers();
403 assertEquals(2, users.size());
404 assertTrue(users.contains(user1));
405 assertTrue(users.contains(user2));
407 Set<Group> groups = admin.getGroups();
408 assertEquals(2, groups.size());
409 assertTrue(groups.contains(group1));
410 assertTrue(groups.contains(group2));
412 assertTrue(user1.isInGroup(group1));
413 assertTrue(user1.isInGroup(group2));
414 assertFalse(user2.isInGroup(group1));
415 assertTrue(user2.isInGroup(group2));
417 Set<Group> groups1 = user1.getGroups();
418 assertEquals(2, groups1.size());
420 Set<Group> groups2 = user2.getGroups();
421 assertEquals(1, groups2.size());
425 * Renames a user. Verifies that the user is renamed. Verifies that
426 * exceptions are thrown when an attempt is made to rename the user to
427 * itself or to another existing user, or when the group does not exist.
430 public void testRenameUser() throws UserMgtException {
431 Group group = admin.createGroup(GROUP1);
432 User user1 = admin.createUser(USER1, PASS1, group);
433 admin.renameUser(user1, USER2);
434 assertEquals(USER2, user1.getName());
435 assertEquals(user1, admin.getUser(USER2));
437 admin.createUser(USER1, PASS1, group);
440 admin.renameUser(user1, USER1);
441 } catch (UserMgtException e) {
442 assertEquals(UserMgtException.Reason.DUPLICATE_USER, e.getReason());
444 // do a trivial reanem
446 admin.renameUser(user1, user1.getName());
447 } catch (UserMgtException e2) {
448 assertEquals(UserMgtException.Reason.TRIVIAL_RENAME, e2
461 * Renames a user to a user with an invalid username. Verifies that the
462 * appropriate exception is thrown.
465 public void testRenameUserInvalidUsername() throws UserMgtException {
466 Group group = admin.createGroup(GROUP1);
467 User user1 = admin.createUser(USER1, PASS1, group);
470 admin.renameUser(user1, USER2);
471 } catch (UserMgtException e) {
472 assertEquals(e.getReason(), Reason.INVALID_USERNAME);
477 * Renames a group. Verifies that the group is renamed. Verifies that
478 * exceptions are thrown when an attempt is made to rename the group to
479 * itself or to another existing group or when the group does not exist.
482 public void testRenameGroup() throws UserMgtException {
483 Group group = admin.createGroup(GROUP1);
484 admin.renameGroup(group, GROUP2);
485 assertEquals(GROUP2, group.getName());
486 assertEquals(group, admin.getGroup(GROUP2));
488 admin.createGroup(GROUP1);
491 admin.renameGroup(group, GROUP1);
492 } catch (UserMgtException e) {
493 assertEquals(UserMgtException.Reason.DUPLICATE_GROUP, e.getReason());
495 // do a trivial reanem
497 admin.renameGroup(group, group.getName());
498 } catch (UserMgtException e2) {
499 assertEquals(UserMgtException.Reason.TRIVIAL_RENAME, e2
514 * Renames a group to a group with an invalid name. Verifies that the
515 * appropriate exception is thrown.
518 public void testRenameGroupInvalidGroupname() throws UserMgtException {
519 Group group = admin.createGroup(GROUP1);
522 admin.renameGroup(group, "a b");
523 } catch (UserMgtException e) {
524 assertEquals(e.getReason(), Reason.INVALID_GROUPNAME);
529 * Removes a user. Verifies that the user is removed. Verifies that the an
530 * exception is thrown when the user does not exist.
533 public void testRemoveUser() throws UserMgtException {
534 Group group = admin.createGroup(GROUP1);
535 User user = admin.createUser(USER1, PASS1, group);
537 assertEquals(1, admin.getUserCount());
538 admin.removeUser(user);
539 assertEquals(0, admin.getUserCount());
541 admin.createUser(USER1, PASS1, group);
542 assertEquals(1, admin.getUserCount());
544 User user2 = createUser(USER2, PASS2, group);
547 admin.removeUser(user2);
548 } catch (UserMgtException e) {
549 assertEquals(UserMgtException.Reason.UNKNOWN_USER, e.getReason());
554 * Removes a group. Verifies that the group is removed. Verifies that the an
555 * exception is thrown when the group does not exist or if there are still
556 * users in the group.
559 public void testRemoveGroup() throws UserMgtException {
560 Group group1 = admin.createGroup(GROUP1);
561 assertEquals(1, admin.getGroupCount());
562 admin.removeGroup(group1);
563 assertEquals(0, admin.getGroupCount());
564 group1 = admin.createGroup(GROUP1);
566 admin.createUser(USER1, PASS1, group1);
569 admin.removeGroup(group1);
570 } catch (UserMgtException e) {
571 assertEquals(UserMgtException.Reason.GROUP_STILL_OCCUPIED, e
581 * Tries to remove an unknown group. Verifies that an exception is thrown.
584 public void testRemoveGroupUnknownGroup() throws UserMgtException {
585 Group group = admin.createGroup(GROUP1);
586 Group group2 = new Group(GROUP2);
589 admin.removeGroup(group2);
590 } catch (UserMgtException e) {
591 assertEquals(UserMgtException.Reason.UNKNOWN_GROUP, e.getReason());
596 * Changes the password, verifies that this succeeds.
598 * @throws UserMgtException
600 public void testChangePassword() throws UserMgtException {
601 Group group = admin.createGroup(GROUP1);
602 User user = admin.createUser(USER1, PASS1, group);
603 user.changePassword(PASS1, PASS2);
605 // retrieve the user and verifies the password hasn't changed.
606 User user2 = admin.getUser(USER1);
609 user2.checkPassword(PASS2);
610 fail(); // password should not have changed already.
611 } catch (UserMgtException e) {
615 // now notify the admin of the change in the user
616 admin.userModified(user);
618 user2 = admin.getUser(USER1);
619 user2.checkPassword(PASS2); // this time it should succeed.
623 * Performance test. Finds a user by name.
626 public void testPerformanceFindUserByName() throws UserMgtException {
627 Group group = admin.createGroup(GROUP1);
628 admin.createUser(USER1, PASS1, group);
631 long time = System.currentTimeMillis();
633 for (int i = 0; i < n; i++) {
634 admin.getUser(USER1);
637 LOGGER.info("Looked up a user " + n + " times in " +
638 ((float) (System.currentTimeMillis() - time) / 1000.0));