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;
26 * Test of user administration implementation.
28 * @author Erik Brakkee
30 public class UserAdministrationImplTest extends TestCase {
31 private static final Logger LOGGER = Logger
32 .getLogger(UserAdministrationImplTest.class.getName());
34 private static final String USER1 = "piet";
36 private static final String PASS1 = "passpiet";
38 private static final String USER2 = "kees";
40 private static final String PASS2 = "passkees";
42 private static final String GROUP1 = "cyclists";
44 private static final String GROUP2 = "runners";
46 private UserAdministration admin;
51 * @see junit.framework.TestCase#setUp()
54 protected void setUp() throws Exception {
56 admin = createAdmin();
59 protected UserAdministration createAdmin() {
60 UserSet users = new InMemoryUserSet(new RegexpNameValidator(
61 RegexpNameValidator.PASSWORD_PATTERN, Reason.INVALID_PASSWORD,
62 "Password must contain at least 6 characters"),
63 new Md5HexMessageDigester());
64 GroupSet groups = new InMemoryGroupSet();
66 return new UserAdministrationImpl(users, groups,
67 new RegexpNameValidator(RegexpNameValidator.ID_PATTERN,
68 Reason.INVALID_USERNAME, "Invalid user"),
69 new RegexpNameValidator(RegexpNameValidator.ID_PATTERN,
70 Reason.INVALID_GROUPNAME, "Invalid group"));
76 * Constructs the admin, verify it contains no users and no groups.
78 public void testConstruct() {
79 assertEquals(0, admin.getUsers().size());
80 assertEquals(0, admin.getGroups().size());
81 assertEquals(0, admin.getUserCount());
82 assertEquals(0, admin.getGroupCount());
86 // void createUser(String aUser, String aPassword);
87 // boolean checkUser(String aUser);
88 // int getUserCount();
89 // List<String> getUsers();
90 // void renameUser(String aOldUserName, String aUserName);
91 // void removeUser(String aUser);
92 public void testCreateUser() {
93 assertFalse(admin.checkUser(USER1));
94 admin.createUser(USER1, PASS1);
95 assertTrue(admin.checkUser(USER1));
96 assertEquals(1, admin.getUserCount());
97 assertTrue(admin.checkPassword(USER1, PASS1));
98 assertFalse(admin.checkPassword(USER1, PASS2));
101 public void testCreateDuplicateUser() {
102 admin.createUser(USER1, PASS1);
105 admin.createUser(USER1, PASS2);
107 } catch (UserMgtException e) {
108 assertEquals(UserMgtException.Reason.DUPLICATE_USER, e.getReason());
109 assertEquals(1, admin.getUserCount());
114 * Constructs users with invalid names. Verifies that the appropriate
115 * exception is thrown.
118 public void testCreateInvalidUserName() throws UserMgtException {
119 createInvalidUser("");
120 createInvalidUser("0abc"); // should not start with digits
121 createInvalidUser("a b"); // should not contain spaces
122 createInvalidUser(" aa");
123 createInvalidUser("aa ");
126 public void testRenameUser() {
127 admin.createUser(USER1, PASS1);
128 admin.renameUser(USER1, USER2);
129 List<String> users = admin.getUsers();
130 assertEquals(1, users.size());
131 assertTrue(users.contains(USER2));
134 public void testRenameUserInvalidUsername() {
135 admin.createUser(USER1, PASS1);
137 admin.renameUser(USER1, "a b");
139 } catch (UserMgtException e) {
140 assertEquals(e.getReason(), Reason.INVALID_USERNAME);
144 public void testRenameUserToItself() {
145 admin.createUser(USER1, PASS1);
146 admin.renameUser(USER1, USER1);
147 assertTrue(admin.checkUser(USER1));
150 public void testRenameUserDuplicateUser() {
151 admin.createUser(USER1, PASS1);
152 admin.createUser(USER2, PASS2);
154 admin.renameUser(USER1, USER2);
156 } catch (UserMgtException e) {
157 assertEquals(e.getReason(), Reason.DUPLICATE_USER);
161 // Basic group admin:
162 // void createGroup(String aName);
163 // boolean checkGroup(String aGroup);
164 // int getGroupCount();
165 // List<String> getGroups();
167 public void testCreateGroup() {
168 admin.createGroup(GROUP1);
169 List<String> groups = admin.getGroups();
170 assertEquals(1, groups.size());
171 assertEquals(1, admin.getGroupCount());
172 assertTrue(groups.contains(GROUP1));
175 public void testCreateGroupInvalidName() {
176 createInvalidGroup("");
177 createInvalidGroup("0abc"); // should not start with digits
178 createInvalidGroup("a b"); // should not contain spaces
179 createInvalidGroup(" aa");
180 createInvalidGroup("aa ");
183 public void testCreateGroupDuplicateGroup() {
184 admin.createGroup(GROUP1);
187 admin.createGroup(GROUP1);
188 } catch (UserMgtException e) {
189 assertEquals(UserMgtException.Reason.DUPLICATE_GROUP, e.getReason());
190 assertEquals(1, admin.getGroupCount());
199 // boolean checkPassword(String aUser, String aPassword);
200 // boolean changePassword(String aUser, String aOldPassword, String
202 // void setPassword(String aUser, String aPassword);
204 public void testChangePassword() {
205 admin.createUser(USER1, PASS1);
206 boolean changed = admin.changePassword(USER1, PASS1, PASS2);
208 assertTrue(admin.checkPassword(USER1, PASS2));
209 assertFalse(admin.checkPassword(USER1, PASS1));
212 public void testChangePasswordWrongPassword() {
213 admin.createUser(USER1, PASS1);
214 boolean changed = admin.changePassword(USER1, PASS2, PASS1);
215 assertFalse(changed);
216 assertFalse(admin.checkPassword(USER1, PASS2));
217 assertTrue(admin.checkPassword(USER1, PASS1));
220 public void testChangePasswordUnknownUser() {
221 admin.createUser(USER1, PASS1);
223 boolean changed = admin.changePassword(USER1 + "unknown", PASS2,
225 } catch (UserMgtException e) {
226 assertEquals(e.getReason(), Reason.UNKNOWN_USER);
230 public void testSetPassword() {
231 admin.createUser(USER1, PASS1);
232 admin.setPassword(USER1, PASS2);
233 assertTrue(admin.checkPassword(USER1, PASS2));
234 assertFalse(admin.checkPassword(USER1, PASS1));
237 public void testSetPasswordUnknownUser() {
238 admin.createUser(USER1, PASS1);
240 admin.setPassword(USER1 + "unknown", PASS2);
241 } catch (UserMgtException e) {
242 assertEquals(e.getReason(), Reason.UNKNOWN_USER);
247 // boolean isInGroup(String aUser, String aGroup);
248 // List<String> getUsers(String aGroup);
249 // void addUserToGroup(String aUser, String aGroup);
250 // void removeUserFromGroup(String aUser, String aGroup);}
252 public void testAddUserToGroup() {
253 admin.createUser(USER1, PASS1);
254 assertFalse(admin.isInGroup(USER1, GROUP1));
255 admin.createGroup(GROUP1);
256 admin.addUserToGroup(USER1, GROUP1);
257 assertTrue(admin.isInGroup(USER1, GROUP1));
258 List<String> users = admin.getUsers(GROUP1);
259 assertEquals(1, users.size());
260 assertTrue(users.contains(USER1));
263 public void testMultipleGroups() {
264 admin.createUser(USER1, PASS1);
265 admin.createGroup(GROUP1);
266 admin.createGroup(GROUP2);
267 assertFalse(admin.isInGroup(USER1, GROUP1));
268 assertFalse(admin.isInGroup(USER1, GROUP2));
269 admin.addUserToGroup(USER1, GROUP1);
270 admin.addUserToGroup(USER1, GROUP2);
271 assertTrue(admin.isInGroup(USER1, GROUP1));
272 assertTrue(admin.isInGroup(USER1, GROUP2));
275 public void testAddUserToGroupUnknownUser() {
276 admin.createGroup(GROUP2);
278 admin.addUserToGroup(USER1, GROUP2);
279 } catch (UserMgtException e) {
280 assertEquals(e.getReason(), Reason.UNKNOWN_USER);
285 public void testAddUserToGroupUnknownGroup() {
286 admin.createUser(USER1, PASS1);
288 admin.addUserToGroup(USER1, GROUP2);
289 } catch (UserMgtException e) {
290 assertEquals(e.getReason(), Reason.UNKNOWN_GROUP);
294 public void testRemoveUserFromGroup() {
295 admin.createUser(USER1, GROUP1);
296 admin.createGroup(GROUP1);
297 admin.addUserToGroup(USER1, GROUP1);
298 assertTrue(admin.isInGroup(USER1, GROUP1));
299 admin.removeUserFromGroup(USER1, GROUP1);
300 assertFalse(admin.isInGroup(USER1, GROUP1));
303 public void testRemoveUserFromGroupUserNotInGroup() {
304 admin.createUser(USER1, GROUP1);
305 admin.createGroup(GROUP1);
306 admin.createGroup(GROUP2);
307 admin.addUserToGroup(USER1, GROUP1);
309 admin.removeUserFromGroup(USER1, GROUP2);
311 } catch (UserMgtException e) {
312 assertEquals(Reason.USER_NOT_IN_GROUP, e.getReason());
316 public void testRemoveUserFromGroupUnknowUser() {
317 admin.createGroup(GROUP1);
319 admin.removeUserFromGroup(USER1, GROUP2);
321 } catch (UserMgtException e) {
322 assertEquals(Reason.UNKNOWN_USER, e.getReason());
326 public void testRemoveUserFromGroupUnknownGroup() {
327 admin.createUser(USER1, PASS1);
329 admin.removeUserFromGroup(USER1, GROUP2);
331 } catch (UserMgtException e) {
332 assertEquals(Reason.UNKNOWN_GROUP, e.getReason());
336 // void renameGroup(String aOldGroup, String aGroupName)
338 public void testRenameGroup() {
339 admin.createUser(USER1, PASS1);
340 admin.createGroup(GROUP1);
341 admin.addUserToGroup(USER1, GROUP1);
342 admin.renameGroup(GROUP1, GROUP2);
343 List<String> groups = admin.getGroups();
344 assertEquals(1, groups.size());
345 assertTrue(groups.contains(GROUP2));
346 assertTrue(admin.isInGroup(USER1, GROUP2));
347 assertFalse(admin.isInGroup(USER1, GROUP1));
350 public void testRenameGroupGroupNameInvalid() {
351 admin.createGroup(GROUP1);
353 admin.renameGroup(GROUP1, "a b");
355 } catch (UserMgtException e) {
356 assertEquals(Reason.INVALID_GROUPNAME, e.getReason());
360 public void testRenameGroupGroupAlreadyExists() {
361 admin.createGroup(GROUP1);
362 admin.createGroup(GROUP2);
364 admin.renameGroup(GROUP1, GROUP2);
366 } catch (UserMgtException e) {
367 assertEquals(Reason.DUPLICATE_GROUP, e.getReason());
371 // void removeGroup(String aGroup);
373 public void testRemoveGroup() {
374 admin.createGroup(GROUP1);
375 admin.removeGroup(GROUP1);
376 List<String> groups = admin.getGroups();
377 assertEquals(0, groups.size());
380 public void testRemoveGroupGroupDoesNotExist() {
382 admin.removeGroup(GROUP1);
384 } catch (UserMgtException e) {
385 assertEquals(e.getReason(), Reason.UNKNOWN_GROUP);
389 public void testRemoveGroupButStillUsersInGroup() {
390 admin.createUser(USER1, PASS1);
391 admin.createGroup(GROUP1);
392 admin.addUserToGroup(USER1, GROUP1);
394 admin.removeGroup(GROUP1);
395 } catch (UserMgtException e) {
396 assertEquals(e.getReason(), Reason.GROUP_STILL_OCCUPIED);
400 private void createInvalidGroup(String aUsername) {
402 admin.createGroup(aUsername);
404 } catch (UserMgtException e) {
405 assertEquals(UserMgtException.Reason.INVALID_GROUPNAME, e
407 assertEquals(0, admin.getGroupCount());
411 private void createInvalidUser(String aUsername) {
413 admin.createUser(aUsername, "pass");
415 } catch (UserMgtException e) {
416 assertEquals(UserMgtException.Reason.INVALID_USERNAME, e
418 assertEquals(0, admin.getUserCount());
423 * Gets the list of users and groups. Verifies that the correct suers and
424 * groups are returned. Verifies also that the relations from user to group
428 public void testGetUsersAndGroups() throws UserMgtException {
429 admin.createGroup(GROUP1);
430 admin.createGroup(GROUP2);
432 admin.createUser(USER1, PASS1);
433 admin.addUserToGroup(USER1, GROUP1);
434 admin.addUserToGroup(USER1, GROUP2);
436 admin.createUser(USER2, PASS2);
437 admin.addUserToGroup(USER2, GROUP2);
439 List<String> users = admin.getUsers();
440 assertEquals(2, users.size());
441 assertTrue(users.contains(USER1));
442 assertTrue(users.contains(USER2));
444 List<String> groups = admin.getGroups();
445 assertEquals(2, groups.size());
446 assertTrue(groups.contains(GROUP1));
447 assertTrue(groups.contains(GROUP2));
449 assertTrue(admin.isInGroup(USER1, GROUP1));
450 assertTrue(admin.isInGroup(USER1, GROUP2));
451 assertFalse(admin.isInGroup(USER2, GROUP1));
452 assertTrue(admin.isInGroup(USER2, GROUP2));
454 List<String> groups1 = admin.getGroups(USER1);
455 assertEquals(2, groups1.size());
457 List<String> groups2 = admin.getGroups(USER2);
458 assertEquals(1, groups2.size());
462 * Performance test. Finds a user by name.
465 public void testPerformanceFindUserByName() throws UserMgtException {
466 admin.createGroup(GROUP1);
467 admin.createUser(USER1, PASS1);
468 admin.addUserToGroup(USER1, GROUP1);
471 long time = System.currentTimeMillis();
473 for (int i = 0; i < n; i++) {
474 admin.checkUser(USER1);
477 LOGGER.info("Looked up a user " + n + " times in " +
478 ((float) (System.currentTimeMillis() - time) / 1000.0));