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.security.authentication;
18 import java.util.List;
19 import java.util.logging.Logger;
21 import junit.framework.TestCase;
23 import org.wamblee.security.authentication.UserMgtException.Reason;
24 import org.wamblee.security.encryption.Md5HexMessageDigester;
27 * Test of user administration implementation.
29 * @author Erik Brakkee
31 public class UserAdministrationImplTest extends TestCase {
32 private static final Logger LOGGER = Logger
33 .getLogger(UserAdministrationImplTest.class.getName());
35 private static final String USER1 = "piet";
37 private static final String PASS1 = "passpiet";
39 private static final String USER2 = "kees";
41 private static final String PASS2 = "passkees";
43 private static final String GROUP1 = "cyclists";
45 private static final String GROUP2 = "runners";
47 private UserAdministration admin;
52 * @see junit.framework.TestCase#setUp()
55 protected void setUp() throws Exception {
57 admin = createAdmin();
60 protected UserAdministration createAdmin() {
61 UserSet users = new InMemoryUserSet(new RegexpNameValidator(
62 RegexpNameValidator.PASSWORD_PATTERN, Reason.INVALID_PASSWORD,
63 "Password must contain at least 6 characters"),
64 new Md5HexMessageDigester());
65 GroupSet groups = new InMemoryGroupSet();
67 return new UserAdministrationImpl(users, groups,
68 new RegexpNameValidator(RegexpNameValidator.ID_PATTERN,
69 Reason.INVALID_USERNAME, "Invalid user"),
70 new RegexpNameValidator(RegexpNameValidator.ID_PATTERN,
71 Reason.INVALID_GROUPNAME, "Invalid group"));
77 * Constructs the admin, verify it contains no users and no groups.
79 public void testConstruct() {
80 assertEquals(0, admin.getUsers().size());
81 assertEquals(0, admin.getGroups().size());
82 assertEquals(0, admin.getUserCount());
83 assertEquals(0, admin.getGroupCount());
87 // void createUser(String aUser, String aPassword);
88 // boolean checkUser(String aUser);
89 // int getUserCount();
90 // List<String> getUsers();
91 // void renameUser(String aOldUserName, String aUserName);
92 // void removeUser(String aUser);
93 public void testCreateUser() {
94 assertFalse(admin.checkUser(USER1));
95 admin.createUser(USER1, PASS1);
96 assertTrue(admin.checkUser(USER1));
97 assertEquals(1, admin.getUserCount());
98 assertTrue(admin.checkPassword(USER1, PASS1));
99 assertFalse(admin.checkPassword(USER1, PASS2));
102 public void testCreateDuplicateUser() {
103 admin.createUser(USER1, PASS1);
106 admin.createUser(USER1, PASS2);
108 } catch (UserMgtException e) {
109 assertEquals(UserMgtException.Reason.DUPLICATE_USER, e.getReason());
110 assertEquals(1, admin.getUserCount());
115 * Constructs users with invalid names. Verifies that the appropriate
116 * exception is thrown.
119 public void testCreateInvalidUserName() throws UserMgtException {
120 createInvalidUser("");
121 createInvalidUser("0abc"); // should not start with digits
122 createInvalidUser("a b"); // should not contain spaces
123 createInvalidUser(" aa");
124 createInvalidUser("aa ");
127 public void testRenameUser() {
128 admin.createUser(USER1, PASS1);
129 admin.renameUser(USER1, USER2);
130 List<String> users = admin.getUsers();
131 assertEquals(1, users.size());
132 assertTrue(users.contains(USER2));
135 public void testRenameUserInvalidUsername() {
136 admin.createUser(USER1, PASS1);
138 admin.renameUser(USER1, "a b");
140 } catch (UserMgtException e) {
141 assertEquals(e.getReason(), Reason.INVALID_USERNAME);
145 public void testRenameUserToItself() {
146 admin.createUser(USER1, PASS1);
147 admin.renameUser(USER1, USER1);
148 assertTrue(admin.checkUser(USER1));
151 public void testRenameUserDuplicateUser() {
152 admin.createUser(USER1, PASS1);
153 admin.createUser(USER2, PASS2);
155 admin.renameUser(USER1, USER2);
157 } catch (UserMgtException e) {
158 assertEquals(e.getReason(), Reason.DUPLICATE_USER);
162 // Basic group admin:
163 // void createGroup(String aName);
164 // boolean checkGroup(String aGroup);
165 // int getGroupCount();
166 // List<String> getGroups();
168 public void testCreateGroup() {
169 admin.createGroup(GROUP1);
170 List<String> groups = admin.getGroups();
171 assertEquals(1, groups.size());
172 assertEquals(1, admin.getGroupCount());
173 assertTrue(groups.contains(GROUP1));
176 public void testCreateGroupInvalidName() {
177 createInvalidGroup("");
178 createInvalidGroup("0abc"); // should not start with digits
179 createInvalidGroup("a b"); // should not contain spaces
180 createInvalidGroup(" aa");
181 createInvalidGroup("aa ");
184 public void testCreateGroupDuplicateGroup() {
185 admin.createGroup(GROUP1);
188 admin.createGroup(GROUP1);
189 } catch (UserMgtException e) {
190 assertEquals(UserMgtException.Reason.DUPLICATE_GROUP, e.getReason());
191 assertEquals(1, admin.getGroupCount());
200 // boolean checkPassword(String aUser, String aPassword);
201 // boolean changePassword(String aUser, String aOldPassword, String
203 // void setPassword(String aUser, String aPassword);
205 public void testChangePassword() {
206 admin.createUser(USER1, PASS1);
207 boolean changed = admin.changePassword(USER1, PASS1, PASS2);
209 assertTrue(admin.checkPassword(USER1, PASS2));
210 assertFalse(admin.checkPassword(USER1, PASS1));
213 public void testChangePasswordWrongPassword() {
214 admin.createUser(USER1, PASS1);
215 boolean changed = admin.changePassword(USER1, PASS2, PASS1);
216 assertFalse(changed);
217 assertFalse(admin.checkPassword(USER1, PASS2));
218 assertTrue(admin.checkPassword(USER1, PASS1));
221 public void testChangePasswordUnknownUser() {
222 admin.createUser(USER1, PASS1);
224 boolean changed = admin.changePassword(USER1 + "unknown", PASS2,
226 } catch (UserMgtException e) {
227 assertEquals(e.getReason(), Reason.UNKNOWN_USER);
231 public void testSetPassword() {
232 admin.createUser(USER1, PASS1);
233 admin.setPassword(USER1, PASS2);
234 assertTrue(admin.checkPassword(USER1, PASS2));
235 assertFalse(admin.checkPassword(USER1, PASS1));
238 public void testSetPasswordUnknownUser() {
239 admin.createUser(USER1, PASS1);
241 admin.setPassword(USER1 + "unknown", PASS2);
242 } catch (UserMgtException e) {
243 assertEquals(e.getReason(), Reason.UNKNOWN_USER);
248 // boolean isInGroup(String aUser, String aGroup);
249 // List<String> getUsers(String aGroup);
250 // void addUserToGroup(String aUser, String aGroup);
251 // void removeUserFromGroup(String aUser, String aGroup);}
253 public void testAddUserToGroup() {
254 admin.createUser(USER1, PASS1);
255 assertFalse(admin.isInGroup(USER1, GROUP1));
256 admin.createGroup(GROUP1);
257 admin.addUserToGroup(USER1, GROUP1);
258 assertTrue(admin.isInGroup(USER1, GROUP1));
259 List<String> users = admin.getUsers(GROUP1);
260 assertEquals(1, users.size());
261 assertTrue(users.contains(USER1));
264 public void testMultipleGroups() {
265 admin.createUser(USER1, PASS1);
266 admin.createGroup(GROUP1);
267 admin.createGroup(GROUP2);
268 assertFalse(admin.isInGroup(USER1, GROUP1));
269 assertFalse(admin.isInGroup(USER1, GROUP2));
270 admin.addUserToGroup(USER1, GROUP1);
271 admin.addUserToGroup(USER1, GROUP2);
272 assertTrue(admin.isInGroup(USER1, GROUP1));
273 assertTrue(admin.isInGroup(USER1, GROUP2));
276 public void testAddUserToGroupUnknownUser() {
277 admin.createGroup(GROUP2);
279 admin.addUserToGroup(USER1, GROUP2);
280 } catch (UserMgtException e) {
281 assertEquals(e.getReason(), Reason.UNKNOWN_USER);
286 public void testAddUserToGroupUnknownGroup() {
287 admin.createUser(USER1, PASS1);
289 admin.addUserToGroup(USER1, GROUP2);
290 } catch (UserMgtException e) {
291 assertEquals(e.getReason(), Reason.UNKNOWN_GROUP);
295 public void testRemoveUserFromGroup() {
296 admin.createUser(USER1, GROUP1);
297 admin.createGroup(GROUP1);
298 admin.addUserToGroup(USER1, GROUP1);
299 assertTrue(admin.isInGroup(USER1, GROUP1));
300 admin.removeUserFromGroup(USER1, GROUP1);
301 assertFalse(admin.isInGroup(USER1, GROUP1));
304 public void testRemoveUserFromGroupUserNotInGroup() {
305 admin.createUser(USER1, GROUP1);
306 admin.createGroup(GROUP1);
307 admin.createGroup(GROUP2);
308 admin.addUserToGroup(USER1, GROUP1);
310 admin.removeUserFromGroup(USER1, GROUP2);
312 } catch (UserMgtException e) {
313 assertEquals(Reason.USER_NOT_IN_GROUP, e.getReason());
317 public void testRemoveUserFromGroupUnknowUser() {
318 admin.createGroup(GROUP1);
320 admin.removeUserFromGroup(USER1, GROUP2);
322 } catch (UserMgtException e) {
323 assertEquals(Reason.UNKNOWN_USER, e.getReason());
327 public void testRemoveUserFromGroupUnknownGroup() {
328 admin.createUser(USER1, PASS1);
330 admin.removeUserFromGroup(USER1, GROUP2);
332 } catch (UserMgtException e) {
333 assertEquals(Reason.UNKNOWN_GROUP, e.getReason());
337 // void renameGroup(String aOldGroup, String aGroupName)
339 public void testRenameGroup() {
340 admin.createUser(USER1, PASS1);
341 admin.createGroup(GROUP1);
342 admin.addUserToGroup(USER1, GROUP1);
343 admin.renameGroup(GROUP1, GROUP2);
344 List<String> groups = admin.getGroups();
345 assertEquals(1, groups.size());
346 assertTrue(groups.contains(GROUP2));
347 assertTrue(admin.isInGroup(USER1, GROUP2));
348 assertFalse(admin.isInGroup(USER1, GROUP1));
351 public void testRenameGroupGroupNameInvalid() {
352 admin.createGroup(GROUP1);
354 admin.renameGroup(GROUP1, "a b");
356 } catch (UserMgtException e) {
357 assertEquals(Reason.INVALID_GROUPNAME, e.getReason());
361 public void testRenameGroupGroupAlreadyExists() {
362 admin.createGroup(GROUP1);
363 admin.createGroup(GROUP2);
365 admin.renameGroup(GROUP1, GROUP2);
367 } catch (UserMgtException e) {
368 assertEquals(Reason.DUPLICATE_GROUP, e.getReason());
372 // void removeGroup(String aGroup);
374 public void testRemoveGroup() {
375 admin.createGroup(GROUP1);
376 admin.removeGroup(GROUP1);
377 List<String> groups = admin.getGroups();
378 assertEquals(0, groups.size());
381 public void testRemoveGroupGroupDoesNotExist() {
383 admin.removeGroup(GROUP1);
385 } catch (UserMgtException e) {
386 assertEquals(e.getReason(), Reason.UNKNOWN_GROUP);
390 public void testRemoveGroupButStillUsersInGroup() {
391 admin.createUser(USER1, PASS1);
392 admin.createGroup(GROUP1);
393 admin.addUserToGroup(USER1, GROUP1);
395 admin.removeGroup(GROUP1);
396 } catch (UserMgtException e) {
397 assertEquals(e.getReason(), Reason.GROUP_STILL_OCCUPIED);
401 private void createInvalidGroup(String aUsername) {
403 admin.createGroup(aUsername);
405 } catch (UserMgtException e) {
406 assertEquals(UserMgtException.Reason.INVALID_GROUPNAME, e
408 assertEquals(0, admin.getGroupCount());
412 private void createInvalidUser(String aUsername) {
414 admin.createUser(aUsername, "pass");
416 } catch (UserMgtException e) {
417 assertEquals(UserMgtException.Reason.INVALID_USERNAME, e
419 assertEquals(0, admin.getUserCount());
424 * Gets the list of users and groups. Verifies that the correct suers and
425 * groups are returned. Verifies also that the relations from user to group
429 public void testGetUsersAndGroups() throws UserMgtException {
430 admin.createGroup(GROUP1);
431 admin.createGroup(GROUP2);
433 admin.createUser(USER1, PASS1);
434 admin.addUserToGroup(USER1, GROUP1);
435 admin.addUserToGroup(USER1, GROUP2);
437 admin.createUser(USER2, PASS2);
438 admin.addUserToGroup(USER2, GROUP2);
440 List<String> users = admin.getUsers();
441 assertEquals(2, users.size());
442 assertTrue(users.contains(USER1));
443 assertTrue(users.contains(USER2));
445 List<String> groups = admin.getGroups();
446 assertEquals(2, groups.size());
447 assertTrue(groups.contains(GROUP1));
448 assertTrue(groups.contains(GROUP2));
450 assertTrue(admin.isInGroup(USER1, GROUP1));
451 assertTrue(admin.isInGroup(USER1, GROUP2));
452 assertFalse(admin.isInGroup(USER2, GROUP1));
453 assertTrue(admin.isInGroup(USER2, GROUP2));
455 List<String> groups1 = admin.getGroups(USER1);
456 assertEquals(2, groups1.size());
458 List<String> groups2 = admin.getGroups(USER2);
459 assertEquals(1, groups2.size());
463 * Performance test. Finds a user by name.
466 public void testPerformanceFindUserByName() throws UserMgtException {
467 admin.createGroup(GROUP1);
468 admin.createUser(USER1, PASS1);
469 admin.addUserToGroup(USER1, GROUP1);
472 long time = System.currentTimeMillis();
474 for (int i = 0; i < n; i++) {
475 admin.checkUser(USER1);
478 LOGGER.info("Looked up a user " + n + " times in " +
479 ((float) (System.currentTimeMillis() - time) / 1000.0));