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

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