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 junit.framework.TestCase;
20 import org.apache.log4j.Logger;
21 import org.junit.Test;
23 import org.wamblee.security.authentication.Group;
24 import org.wamblee.security.authentication.GroupSet;
25 import org.wamblee.security.authentication.InMemoryGroupSet;
26 import org.wamblee.security.authentication.InMemoryUserSet;
27 import org.wamblee.security.authentication.RegexpNameValidator;
28 import org.wamblee.security.authentication.User;
29 import org.wamblee.security.authentication.UserAdministration;
30 import org.wamblee.security.authentication.UserAdministrationImpl;
31 import org.wamblee.security.authentication.UserMgtException;
32 import org.wamblee.security.authentication.UserSet;
33 import org.wamblee.security.authentication.UserMgtException.Reason;
34 import org.wamblee.security.encryption.Md5HexMessageDigester;
36 import java.util.List;
40 * Test of user administration implementation.
42 * @author Erik Brakkee
44 public class UserAdministrationImplTest extends TestCase {
45 private static final Logger LOGGER = Logger
46 .getLogger(UserAdministrationImplTest.class);
48 private static final String USER1 = "piet";
50 private static final String PASS1 = "passpiet";
52 private static final String USER2 = "kees";
54 private static final String PASS2 = "passkees";
56 private static final String GROUP1 = "cyclists";
58 private static final String GROUP2 = "runners";
60 private UserAdministration admin;
65 * @see junit.framework.TestCase#setUp()
68 protected void setUp() throws Exception {
70 admin = createAdmin();
73 protected UserAdministration createAdmin() {
74 UserSet users = new InMemoryUserSet(new RegexpNameValidator(
75 RegexpNameValidator.PASSWORD_PATTERN, Reason.INVALID_PASSWORD,
76 "Password must contain at least 6 characters"),
77 new Md5HexMessageDigester());
78 GroupSet groups = new InMemoryGroupSet();
80 return new UserAdministrationImpl(users, groups,
81 new RegexpNameValidator(RegexpNameValidator.ID_PATTERN,
82 Reason.INVALID_USERNAME, "Invalid user"),
83 new RegexpNameValidator(RegexpNameValidator.ID_PATTERN,
84 Reason.INVALID_GROUPNAME, "Invalid group"));
90 * Constructs the admin, verify it contains no users and no groups.
92 public void testConstruct() {
93 assertEquals(0, admin.getUsers().size());
94 assertEquals(0, admin.getGroups().size());
95 assertEquals(0, admin.getUserCount());
96 assertEquals(0, admin.getGroupCount());
100 // void createUser(String aUser, String aPassword);
101 // boolean checkUser(String aUser);
102 // int getUserCount();
103 // List<String> getUsers();
104 // void renameUser(String aOldUserName, String aUserName);
105 // void removeUser(String aUser);
106 public void testCreateUser() {
107 assertFalse(admin.checkUser(USER1));
108 admin.createUser(USER1, PASS1);
109 assertTrue(admin.checkUser(USER1));
110 assertEquals(1, admin.getUserCount());
111 assertTrue(admin.checkPassword(USER1, PASS1));
112 assertFalse(admin.checkPassword(USER1, PASS2));
115 public void testCreateDuplicateUser() {
116 admin.createUser(USER1, PASS1);
119 admin.createUser(USER1, PASS2);
121 } catch (UserMgtException e) {
122 assertEquals(UserMgtException.Reason.DUPLICATE_USER, e.getReason());
123 assertEquals(1, admin.getUserCount());
128 * Constructs users with invalid names. Verifies that the appropriate
129 * exception is thrown.
132 public void testCreateInvalidUserName() throws UserMgtException {
133 createInvalidUser("");
134 createInvalidUser("0abc"); // should not start with digits
135 createInvalidUser("a b"); // should not contain spaces
136 createInvalidUser(" aa");
137 createInvalidUser("aa ");
140 public void testRenameUser() {
141 admin.createUser(USER1, PASS1);
142 admin.renameUser(USER1, USER2);
143 List<String> users = admin.getUsers();
144 assertEquals(1, users.size());
145 assertTrue(users.contains(USER2));
148 public void testRenameUserInvalidUsername() {
149 admin.createUser(USER1, PASS1);
151 admin.renameUser(USER1, "a b");
153 } catch (UserMgtException e) {
154 assertEquals(e.getReason(), Reason.INVALID_USERNAME);
158 public void testRenameUserToItself() {
159 admin.createUser(USER1, PASS1);
160 admin.renameUser(USER1, USER1);
161 assertTrue(admin.checkUser(USER1));
164 public void testRenameUserDuplicateUser() {
165 admin.createUser(USER1, PASS1);
166 admin.createUser(USER2, PASS2);
168 admin.renameUser(USER1, USER2);
170 } catch (UserMgtException e) {
171 assertEquals(e.getReason(), Reason.DUPLICATE_USER);
175 // Basic group admin:
176 // void createGroup(String aName);
177 // boolean checkGroup(String aGroup);
178 // int getGroupCount();
179 // List<String> getGroups();
181 public void testCreateGroup() {
182 admin.createGroup(GROUP1);
183 List<String> groups = admin.getGroups();
184 assertEquals(1, groups.size());
185 assertEquals(1, admin.getGroupCount());
186 assertTrue(groups.contains(GROUP1));
189 public void testCreateGroupInvalidName() {
190 createInvalidGroup("");
191 createInvalidGroup("0abc"); // should not start with digits
192 createInvalidGroup("a b"); // should not contain spaces
193 createInvalidGroup(" aa");
194 createInvalidGroup("aa ");
197 public void testCreateGroupDuplicateGroup() {
198 admin.createGroup(GROUP1);
201 admin.createGroup(GROUP1);
202 } catch (UserMgtException e) {
203 assertEquals(UserMgtException.Reason.DUPLICATE_GROUP, e.getReason());
204 assertEquals(1, admin.getGroupCount());
213 // boolean checkPassword(String aUser, String aPassword);
214 // boolean changePassword(String aUser, String aOldPassword, String
216 // void setPassword(String aUser, String aPassword);
218 public void testChangePassword() {
219 admin.createUser(USER1, PASS1);
220 boolean changed = admin.changePassword(USER1, PASS1, PASS2);
222 assertTrue(admin.checkPassword(USER1, PASS2));
223 assertFalse(admin.checkPassword(USER1, PASS1));
226 public void testChangePasswordWrongPassword() {
227 admin.createUser(USER1, PASS1);
228 boolean changed = admin.changePassword(USER1, PASS2, PASS1);
229 assertFalse(changed);
230 assertFalse(admin.checkPassword(USER1, PASS2));
231 assertTrue(admin.checkPassword(USER1, PASS1));
234 public void testChangePasswordUnknownUser() {
235 admin.createUser(USER1, PASS1);
237 boolean changed = admin.changePassword(USER1 + "unknown", PASS2,
239 } catch (UserMgtException e) {
240 assertEquals(e.getReason(), Reason.UNKNOWN_USER);
244 public void testSetPassword() {
245 admin.createUser(USER1, PASS1);
246 admin.setPassword(USER1, PASS2);
247 assertTrue(admin.checkPassword(USER1, PASS2));
248 assertFalse(admin.checkPassword(USER1, PASS1));
251 public void testSetPasswordUnknownUser() {
252 admin.createUser(USER1, PASS1);
254 admin.setPassword(USER1 + "unknown", PASS2);
255 } catch (UserMgtException e) {
256 assertEquals(e.getReason(), Reason.UNKNOWN_USER);
261 // boolean isInGroup(String aUser, String aGroup);
262 // List<String> getUsers(String aGroup);
263 // void addUserToGroup(String aUser, String aGroup);
264 // void removeUserFromGroup(String aUser, String aGroup);}
266 public void testAddUserToGroup() {
267 admin.createUser(USER1, PASS1);
268 assertFalse(admin.isInGroup(USER1, GROUP1));
269 admin.createGroup(GROUP1);
270 admin.addUserToGroup(USER1, GROUP1);
271 assertTrue(admin.isInGroup(USER1, GROUP1));
272 List<String> users = admin.getUsers(GROUP1);
273 assertEquals(1, users.size());
274 assertTrue(users.contains(USER1));
277 public void testMultipleGroups() {
278 admin.createUser(USER1, PASS1);
279 admin.createGroup(GROUP1);
280 admin.createGroup(GROUP2);
281 assertFalse(admin.isInGroup(USER1, GROUP1));
282 assertFalse(admin.isInGroup(USER1, GROUP2));
283 admin.addUserToGroup(USER1, GROUP1);
284 admin.addUserToGroup(USER1, GROUP2);
285 assertTrue(admin.isInGroup(USER1, GROUP1));
286 assertTrue(admin.isInGroup(USER1, GROUP2));
289 public void testAddUserToGroupUnknownUser() {
290 admin.createGroup(GROUP2);
292 admin.addUserToGroup(USER1, GROUP2);
293 } catch (UserMgtException e) {
294 assertEquals(e.getReason(), Reason.UNKNOWN_USER);
299 public void testAddUserToGroupUnknownGroup() {
300 admin.createUser(USER1, PASS1);
302 admin.addUserToGroup(USER1, GROUP2);
303 } catch (UserMgtException e) {
304 assertEquals(e.getReason(), Reason.UNKNOWN_GROUP);
308 public void testRemoveUserFromGroup() {
309 admin.createUser(USER1, GROUP1);
310 admin.createGroup(GROUP1);
311 admin.addUserToGroup(USER1, GROUP1);
312 assertTrue(admin.isInGroup(USER1, GROUP1));
313 admin.removeUserFromGroup(USER1, GROUP1);
314 assertFalse(admin.isInGroup(USER1, GROUP1));
317 public void testRemoveUserFromGroupUserNotInGroup() {
318 admin.createUser(USER1, GROUP1);
319 admin.createGroup(GROUP1);
320 admin.createGroup(GROUP2);
321 admin.addUserToGroup(USER1, GROUP1);
323 admin.removeUserFromGroup(USER1, GROUP2);
325 } catch (UserMgtException e) {
326 assertEquals(Reason.USER_NOT_IN_GROUP, e.getReason());
330 public void testRemoveUserFromGroupUnknowUser() {
331 admin.createGroup(GROUP1);
333 admin.removeUserFromGroup(USER1, GROUP2);
335 } catch (UserMgtException e) {
336 assertEquals(Reason.UNKNOWN_USER, e.getReason());
340 public void testRemoveUserFromGroupUnknownGroup() {
341 admin.createUser(USER1, PASS1);
343 admin.removeUserFromGroup(USER1, GROUP2);
345 } catch (UserMgtException e) {
346 assertEquals(Reason.UNKNOWN_GROUP, e.getReason());
350 // void renameGroup(String aOldGroup, String aGroupName)
352 public void testRenameGroup() {
353 admin.createUser(USER1, PASS1);
354 admin.createGroup(GROUP1);
355 admin.addUserToGroup(USER1, GROUP1);
356 admin.renameGroup(GROUP1, GROUP2);
357 List<String> groups = admin.getGroups();
358 assertEquals(1, groups.size());
359 assertTrue(groups.contains(GROUP2));
360 assertTrue(admin.isInGroup(USER1, GROUP2));
361 assertFalse(admin.isInGroup(USER1, GROUP1));
364 public void testRenameGroupGroupNameInvalid() {
365 admin.createGroup(GROUP1);
367 admin.renameGroup(GROUP1, "a b");
369 } catch (UserMgtException e) {
370 assertEquals(Reason.INVALID_GROUPNAME, e.getReason());
374 public void testRenameGroupGroupAlreadyExists() {
375 admin.createGroup(GROUP1);
376 admin.createGroup(GROUP2);
378 admin.renameGroup(GROUP1, GROUP2);
380 } catch (UserMgtException e) {
381 assertEquals(Reason.DUPLICATE_GROUP, e.getReason());
385 // void removeGroup(String aGroup);
387 public void testRemoveGroup() {
388 admin.createGroup(GROUP1);
389 admin.removeGroup(GROUP1);
390 List<String> groups = admin.getGroups();
391 assertEquals(0, groups.size());
394 public void testRemoveGroupGroupDoesNotExist() {
396 admin.removeGroup(GROUP1);
398 } catch (UserMgtException e) {
399 assertEquals(e.getReason(), Reason.UNKNOWN_GROUP);
403 public void testRemoveGroupButStillUsersInGroup() {
404 admin.createUser(USER1, PASS1);
405 admin.createGroup(GROUP1);
406 admin.addUserToGroup(USER1, GROUP1);
408 admin.removeGroup(GROUP1);
409 } catch (UserMgtException e) {
410 assertEquals(e.getReason(), Reason.GROUP_STILL_OCCUPIED);
414 private void createInvalidGroup(String aUsername) {
416 admin.createGroup(aUsername);
418 } catch (UserMgtException e) {
419 assertEquals(UserMgtException.Reason.INVALID_GROUPNAME, e
421 assertEquals(0, admin.getGroupCount());
425 private void createInvalidUser(String aUsername) {
427 admin.createUser(aUsername, "pass");
429 } catch (UserMgtException e) {
430 assertEquals(UserMgtException.Reason.INVALID_USERNAME, e
432 assertEquals(0, admin.getUserCount());
437 * Gets the list of users and groups. Verifies that the correct suers and
438 * groups are returned. Verifies also that the relations from user to group
442 public void testGetUsersAndGroups() throws UserMgtException {
443 admin.createGroup(GROUP1);
444 admin.createGroup(GROUP2);
446 admin.createUser(USER1, PASS1);
447 admin.addUserToGroup(USER1, GROUP1);
448 admin.addUserToGroup(USER1, GROUP2);
450 admin.createUser(USER2, PASS2);
451 admin.addUserToGroup(USER2, GROUP2);
453 List<String> users = admin.getUsers();
454 assertEquals(2, users.size());
455 assertTrue(users.contains(USER1));
456 assertTrue(users.contains(USER2));
458 List<String> groups = admin.getGroups();
459 assertEquals(2, groups.size());
460 assertTrue(groups.contains(GROUP1));
461 assertTrue(groups.contains(GROUP2));
463 assertTrue(admin.isInGroup(USER1, GROUP1));
464 assertTrue(admin.isInGroup(USER1, GROUP2));
465 assertFalse(admin.isInGroup(USER2, GROUP1));
466 assertTrue(admin.isInGroup(USER2, GROUP2));
468 List<String> groups1 = admin.getGroups(USER1);
469 assertEquals(2, groups1.size());
471 List<String> groups2 = admin.getGroups(USER2);
472 assertEquals(1, groups2.size());
476 * Performance test. Finds a user by name.
479 public void testPerformanceFindUserByName() throws UserMgtException {
480 admin.createGroup(GROUP1);
481 admin.createUser(USER1, PASS1);
482 admin.addUserToGroup(USER1, GROUP1);
485 long time = System.currentTimeMillis();
487 for (int i = 0; i < n; i++) {
488 admin.checkUser(USER1);
491 LOGGER.info("Looked up a user " + n + " times in " +
492 ((float) (System.currentTimeMillis() - time) / 1000.0));