wamblee.org Git - utils/blob - security/src/test/java/org/wamblee/usermgt/InMemoryUserSetTest.java

   1 /*
   2  * Copyright 2005 the original author or authors.
   3  *
   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
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  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.
  15  */
  16 package org.wamblee.usermgt;
  17
  18 import junit.framework.TestCase;
  19
  20 import org.wamblee.security.encryption.Md5HexMessageDigester;
  21
  22 import org.wamblee.usermgt.UserMgtException.Reason;
  23
  24 import java.sql.SQLException;
  25
  26 import java.util.Set;
  27
  28 /**
  29  * Tests the inmemory user set. Intended to be subclassed for other
  30  * implementations of user set.
  31  */
  32 public class InMemoryUserSetTest extends TestCase {
  33     protected static final String PASSWORD = "abc123";
  34
  35     private UserSet users;
  36
  37     private GroupSet groups;
  38
  39     private Group group;
  40
  41     /**
  42      * This method must be overriden in subclasses.
  43      *
  44      * @return New user set object.
  45      */
  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());
  51     }
  52
  53     /**
  54      * This method must be overriden in subclasses.
  55      *
  56      * @return New group set object.
  57      */
  58     protected GroupSet createGroupSet() {
  59         return new InMemoryGroupSet();
  60     }
  61
  62     /*
  63      * (non-Javadoc)
  64      *
  65      * @see org.wamblee.test.SpringTestCase#setUp()
  66      */
  67     @Override
  68     protected void setUp() throws Exception {
  69         super.setUp();
  70         users = createUserSet();
  71         groups = createGroupSet();
  72         group = new Group("group0");
  73         groups.add(group);
  74         checkUserCount(0);
  75     }
  76
  77     protected UserSet getUsers() {
  78         return users;
  79     }
  80
  81     protected GroupSet getGroups() {
  82         return groups;
  83     }
  84
  85     protected Group createGroup(String aName) {
  86         return new Group(aName);
  87     }
  88
  89     protected User createUser(String aName, String aPassword, Group aGroup)
  90         throws UserMgtException {
  91         return UsermgtTestUtils.createUser(aName, aPassword, aGroup);
  92     }
  93
  94     protected void addUserToGroup(User aUser, Group aGroup)
  95         throws UserMgtException {
  96         aUser.addGroup(aGroup);
  97     }
  98
  99     protected void removeUserFromGroup(User aUser, Group aGroup)
 100         throws UserMgtException {
 101         aUser.removeGroup(aGroup);
 102     }
 103
 104     /**
 105      * Additional check to be implemented by a subclass.
 106      *
 107      * @param aUser
 108      *            User to check for existence.
 109      *
 110      */
 111     protected void checkUserExists(String aUser) throws SQLException {
 112         // Empty
 113     }
 114
 115     /**
 116      * Additional check to be implemented by a subclass.
 117      *
 118      * @param aUser
 119      *            User to check for non-existence.
 120      *
 121      */
 122     protected void checkUserNotExists(String aUser) throws SQLException {
 123         // Empty
 124     }
 125
 126     /**
 127      * Additional check to be implemented by a subclass.
 128      *
 129      * @param aSize
 130      *            Expected number of users.
 131      *
 132      */
 133     protected void checkUserCount(int aSize) throws SQLException {
 134         assertEquals(aSize, users.size());
 135     }
 136
 137     /**
 138      * Additional check to be implemented by a subclass.
 139      *
 140      * @param aUser
 141      *            User to check for existence.
 142      *
 143      */
 144     protected void checkGroupExists(String aUser) throws SQLException {
 145         // Empty
 146     }
 147
 148     /**
 149      * Additional check to be implemented by a subclass.
 150      *
 151      * @param aUser
 152      *            User to check for non-existence.
 153      *
 154      */
 155     protected void checkGroupNotExists(String aUser) throws SQLException {
 156         // Empty
 157     }
 158
 159     /**
 160      * Additional check to be implemented by a subclass.
 161      *
 162      * @param aSize
 163      *            Expected number of users.
 164      *
 165      */
 166     protected void checkGroupCount(int aSize) throws SQLException {
 167         // Empty
 168     }
 169
 170     /**
 171      * Adds a user and verifies that the user is added using find(), list(), and
 172      * contains().
 173      *
 174      */
 175     public void testAdd() throws SQLException, UserMgtException {
 176         User user = createUser("user1", PASSWORD, group);
 177         assertTrue(users.add(user));
 178         checkUserExists(user.getName());
 179         checkUserCount(1);
 180
 181         User user2 = users.find("user1");
 182         assertNotNull(user2);
 183         assertEquals(user.getName(), user2.getName());
 184
 185         Set<User> set = users.list();
 186         assertEquals(1, set.size());
 187         assertTrue(set.contains(user));
 188     }
 189
 190     /**
 191      * Tries to find a non-existing user. Verifies that null is returned.
 192      *
 193      */
 194     public void testFindUnknownUser() throws SQLException, UserMgtException {
 195         User user1 = createUser("user1", PASSWORD, group);
 196         User user2 = createUser("user2", PASSWORD, group);
 197         users.add(user1);
 198         users.add(user2);
 199         checkUserExists(user1.getName());
 200         checkUserExists(user2.getName());
 201
 202         assertNull(users.find("user3"));
 203         checkUserNotExists("user3");
 204     }
 205
 206     /**
 207      * Adds duplicate user. Verifies that the existing user is left untouched.
 208      *
 209      */
 210     public void testAddDuplicateUser() throws SQLException, UserMgtException {
 211         User user1 = createUser("user1", PASSWORD, group);
 212         users.add(user1);
 213
 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());
 219
 220         checkUserExists(user1.getName());
 221         checkUserCount(1);
 222     }
 223
 224     /**
 225      * Removes a user. Verifies that the user is removed and the return value is
 226      * true.
 227      *
 228      */
 229     public void testRemoveUser() throws SQLException, UserMgtException {
 230         User user1 = createUser("user1", PASSWORD, group);
 231         users.add(user1);
 232         assertTrue(users.contains(user1));
 233         checkUserCount(1);
 234
 235         assertTrue(users.remove(user1));
 236         assertFalse(users.contains(user1));
 237         assertNull(users.find(user1.getName()));
 238         assertEquals(0, users.list().size());
 239         checkUserCount(0);
 240     }
 241
 242     /**
 243      * Removes a non-existing user. Verifies that no users are removed an that
 244      * the return value is true.
 245      *
 246      */
 247     public void testRemoveNonExistingUser() throws SQLException,
 248         UserMgtException {
 249         User user1 = createUser("user1", PASSWORD, group);
 250         users.add(user1);
 251         checkUserCount(1);
 252
 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());
 259         checkUserCount(1);
 260     }
 261
 262     /**
 263      * Adds a number of users to the set and verifies that list() returns them
 264      * all.
 265      *
 266      */
 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));
 274
 275         checkUserExists(user1.getName());
 276         checkUserExists(user2.getName());
 277         checkUserExists(user3.getName());
 278
 279         Set<User> set = users.list();
 280         assertTrue(set.contains(user1));
 281         assertTrue(set.contains(user2));
 282         assertTrue(set.contains(user3));
 283
 284         checkUserCount(3);
 285     }
 286
 287     /**
 288      * Adds several users to different groups and verifies that the correct
 289      * users are returned when looking for users in different groups.
 290      *
 291      * @throws SQLException
 292      */
 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");
 297         groups.add(group1);
 298         groups.add(group2);
 299         groups.add(group3);
 300
 301         // user1 user2 user3
 302         // group1 y
 303         // group2 y y
 304         // group3 y y y
 305         User user1 = createUser("user1", PASSWORD, group1);
 306         user1.addGroup(group2);
 307         user1.addGroup(group3);
 308
 309         User user2 = createUser("user2", PASSWORD, group2);
 310         user2.addGroup(group3);
 311
 312         User user3 = createUser("user3", PASSWORD, group3);
 313         users.add(user1);
 314         users.add(user2);
 315         users.add(user3);
 316
 317         checkUserExists(user1.getName());
 318         checkUserExists(user2.getName());
 319         checkUserExists(user3.getName());
 320
 321         checkGroupExists(group1.getName());
 322         checkGroupExists(group2.getName());
 323         checkGroupExists(group3.getName());
 324
 325         checkUserCount(3);
 326         checkGroupCount(3 + 1); // also count the group that was created in the
 327                                 // setUp().
 328
 329         Set<User> list = users.list(group1);
 330         assertTrue(list.contains(user1));
 331         assertEquals(1, list.size());
 332
 333         list = users.list(group2);
 334         assertTrue(list.contains(user1));
 335         assertTrue(list.contains(user2));
 336         assertEquals(2, list.size());
 337
 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());
 343     }
 344 }