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