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.wamblee.security.encryption.Md5HexMessageDigester;
22 import org.wamblee.usermgt.UserMgtException.Reason;
24 import java.sql.SQLException;
29 * Tests the inmemory user set. Intended to be subclassed for other
30 * implementations of user set.
32 public class InMemoryUserSetTest extends TestCase {
33 protected static final String PASSWORD = "abc123";
35 private UserSet users;
37 private GroupSet groups;
42 * This method must be overriden in subclasses.
44 * @return New user set object.
46 protected UserSet createUserSet() {
47 return new InMemoryUserSet(new RegexpNameValidator(
48 RegexpNameValidator.PASSWORD_PATTERN, Reason.INVALID_PASSWORD,
49 "Password must contain at least 6 characters"),
50 new Md5HexMessageDigester());
54 * This method must be overriden in subclasses.
56 * @return New group set object.
58 protected GroupSet createGroupSet() {
59 return new InMemoryGroupSet();
65 * @see org.wamblee.test.SpringTestCase#setUp()
68 protected void setUp() throws Exception {
70 users = createUserSet();
71 groups = createGroupSet();
72 group = new Group("group0");
77 protected UserSet getUsers() {
81 protected GroupSet getGroups() {
85 protected Group createGroup(String aName) {
86 return new Group(aName);
89 protected User createUser(String aName, String aPassword, Group aGroup)
90 throws UserMgtException {
91 return UsermgtTestUtils.createUser(aName, aPassword, aGroup);
94 protected void addUserToGroup(User aUser, Group aGroup)
95 throws UserMgtException {
96 aUser.addGroup(aGroup);
99 protected void removeUserFromGroup(User aUser, Group aGroup)
100 throws UserMgtException {
101 aUser.removeGroup(aGroup);
105 * Additional check to be implemented by a subclass.
108 * User to check for existence.
111 protected void checkUserExists(String aUser) throws SQLException {
116 * Additional check to be implemented by a subclass.
119 * User to check for non-existence.
122 protected void checkUserNotExists(String aUser) throws SQLException {
127 * Additional check to be implemented by a subclass.
130 * Expected number of users.
133 protected void checkUserCount(int aSize) throws SQLException {
134 assertEquals(aSize, users.size());
138 * Additional check to be implemented by a subclass.
141 * User to check for existence.
144 protected void checkGroupExists(String aUser) throws SQLException {
149 * Additional check to be implemented by a subclass.
152 * User to check for non-existence.
155 protected void checkGroupNotExists(String aUser) throws SQLException {
160 * Additional check to be implemented by a subclass.
163 * Expected number of users.
166 protected void checkGroupCount(int aSize) throws SQLException {
171 * Adds a user and verifies that the user is added using find(), list(), and
175 public void testAdd() throws SQLException, UserMgtException {
176 User user = createUser("user1", PASSWORD, group);
177 assertTrue(users.add(user));
178 checkUserExists(user.getName());
181 User user2 = users.find("user1");
182 assertNotNull(user2);
183 assertEquals(user.getName(), user2.getName());
185 Set<User> set = users.list();
186 assertEquals(1, set.size());
187 assertTrue(set.contains(user));
191 * Tries to find a non-existing user. Verifies that null is returned.
194 public void testFindUnknownUser() throws SQLException, UserMgtException {
195 User user1 = createUser("user1", PASSWORD, group);
196 User user2 = createUser("user2", PASSWORD, group);
199 checkUserExists(user1.getName());
200 checkUserExists(user2.getName());
202 assertNull(users.find("user3"));
203 checkUserNotExists("user3");
207 * Adds duplicate user. Verifies that the existing user is left untouched.
210 public void testAddDuplicateUser() throws SQLException, UserMgtException {
211 User user1 = createUser("user1", PASSWORD, group);
214 assertEquals(1, users.list().size());
215 assertTrue(users.contains(user1));
216 user1 = createUser("user1", PASSWORD, group);
217 assertFalse(users.add(user1));
218 assertEquals(1, users.list().size());
220 checkUserExists(user1.getName());
225 * Removes a user. Verifies that the user is removed and the return value is
229 public void testRemoveUser() throws SQLException, UserMgtException {
230 User user1 = createUser("user1", PASSWORD, group);
232 assertTrue(users.contains(user1));
235 assertTrue(users.remove(user1));
236 assertFalse(users.contains(user1));
237 assertNull(users.find(user1.getName()));
238 assertEquals(0, users.list().size());
243 * Removes a non-existing user. Verifies that no users are removed an that
244 * the return value is true.
247 public void testRemoveNonExistingUser() throws SQLException,
249 User user1 = createUser("user1", PASSWORD, group);
253 User nonExistingUser = createUser("user2", PASSWORD, group);
254 nonExistingUser.setPrimaryKey(new Long(1000));
255 nonExistingUser.setPersistedVersion(10);
256 assertFalse(users.remove(nonExistingUser));
257 assertTrue(users.contains(user1));
258 assertEquals(1, users.list().size());
263 * Adds a number of users to the set and verifies that list() returns them
267 public void testList() throws SQLException, UserMgtException {
268 User user1 = createUser("user1", PASSWORD, group);
269 User user2 = createUser("user2", PASSWORD, group);
270 User user3 = createUser("user3", PASSWORD, group);
271 assertTrue(users.add(user1));
272 assertTrue(users.add(user2));
273 assertTrue(users.add(user3));
275 checkUserExists(user1.getName());
276 checkUserExists(user2.getName());
277 checkUserExists(user3.getName());
279 Set<User> set = users.list();
280 assertTrue(set.contains(user1));
281 assertTrue(set.contains(user2));
282 assertTrue(set.contains(user3));
288 * Adds several users to different groups and verifies that the correct
289 * users are returned when looking for users in different groups.
291 * @throws SQLException
293 public void testListByGroup() throws SQLException, UserMgtException {
294 Group group1 = new Group("group1");
295 Group group2 = new Group("group2");
296 Group group3 = new Group("group3");
305 User user1 = createUser("user1", PASSWORD, group1);
306 user1.addGroup(group2);
307 user1.addGroup(group3);
309 User user2 = createUser("user2", PASSWORD, group2);
310 user2.addGroup(group3);
312 User user3 = createUser("user3", PASSWORD, group3);
317 checkUserExists(user1.getName());
318 checkUserExists(user2.getName());
319 checkUserExists(user3.getName());
321 checkGroupExists(group1.getName());
322 checkGroupExists(group2.getName());
323 checkGroupExists(group3.getName());
326 checkGroupCount(3 + 1); // also count the group that was created in the
329 Set<User> list = users.list(group1);
330 assertTrue(list.contains(user1));
331 assertEquals(1, list.size());
333 list = users.list(group2);
334 assertTrue(list.contains(user1));
335 assertTrue(list.contains(user2));
336 assertEquals(2, list.size());
338 list = users.list(group3);
339 assertTrue(list.contains(user1));
340 assertTrue(list.contains(user2));
341 assertTrue(list.contains(user3));
342 assertEquals(3, list.size());