wamblee.org Git - utils/blob

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