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