wamblee.org Git - utils/blob - security/src/test/java/org/wamblee/usermgt/hibernate/HibernateUserSetTest.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.hibernate;
  17
  18 import org.wamblee.cache.EhCache;
  19
  20 import org.wamblee.system.adapters.DefaultContainer;
  21 import org.wamblee.system.adapters.ObjectConfiguration;
  22 import org.wamblee.system.core.Scope;
  23 import org.wamblee.system.spring.component.DatabaseTesterComponent;
  24
  25 import org.wamblee.usermgt.Group;
  26 import org.wamblee.usermgt.GroupSet;
  27 import org.wamblee.usermgt.InMemoryUserSetTest;
  28 import org.wamblee.usermgt.User;
  29 import org.wamblee.usermgt.UserMgtException;
  30 import org.wamblee.usermgt.UserSet;
  31
  32 import java.io.Serializable;
  33
  34 import java.sql.ResultSet;
  35 import java.sql.SQLException;
  36
  37 import java.util.Set;
  38
  39 /**
  40  * Tests for {@link org.wamblee.usermgt.hibernate.HibernateGroupSet}
  41  *
  42  * @author Erik Brakkee
  43  */
  44 public class HibernateUserSetTest extends InMemoryUserSetTest {
  45     private static final String USER_TABLE = "USERS";
  46
  47     private static final String GROUP_TABLE = "GROUPS";
  48
  49     private static final String USER_QUERY = "select * from " + USER_TABLE +
  50         " where name = ?";
  51
  52     private static final String GROUP_QUERY = "select * from " + GROUP_TABLE +
  53         " where name = ?";
  54
  55     private DefaultContainer container;
  56
  57     private Scope scope;
  58
  59     private UserSet userset;
  60
  61     private GroupSet groupset;
  62
  63     private EhCache<Serializable, Serializable> userCache;
  64
  65     private DatabaseTesterComponent databaseTester;
  66
  67     /*
  68      * (non-Javadoc)
  69      *
  70      * @see org.wamblee.usermgt.InMemoryUserSetTest#setUp()
  71      */
  72     @Override
  73     protected void setUp() throws Exception {
  74         container = new UserMgtRepositoryTestContainer("top");
  75
  76         ObjectConfiguration config = new ObjectConfiguration(
  77             HibernateUserSetTest.class);
  78         config.getSetterConfig().clear().add("setUserset").add("setGroupset")
  79             .add("setDatabaseTester").add("setUserCache");
  80         container.addComponent("testcase", this, config);
  81
  82         scope = container.start();
  83
  84         clearUserCache();
  85         databaseTester.cleanDatabase();
  86
  87         super.setUp();
  88     }
  89
  90     public void setUserset(UserSet aUserset) {
  91         userset = aUserset;
  92     }
  93
  94     public void setGroupset(GroupSet aGroupset) {
  95         groupset = aGroupset;
  96     }
  97
  98     public void setUserCache(EhCache<Serializable, Serializable> aUserCache) {
  99         userCache = aUserCache;
 100     }
 101
 102     public void setDatabaseTester(DatabaseTesterComponent aDatabaseTester) {
 103         databaseTester = aDatabaseTester;
 104     }
 105
 106     @Override
 107     protected void tearDown() throws Exception {
 108         container.stop(scope);
 109         super.tearDown();
 110     }
 111
 112     /**
 113      * Clears the user cache.
 114      */
 115     private void clearUserCache() {
 116         userCache.clear();
 117     }
 118
 119     /*
 120      * (non-Javadoc)
 121      *
 122      * @see org.wamblee.usermgt.InMemoryGroupSetTest#checkGroupCount(int)
 123      */
 124     @Override
 125     protected void checkUserCount(int aSize) throws SQLException {
 126         databaseTester.flush();
 127         super.checkUserCount(aSize);
 128         assertEquals(aSize, databaseTester.getTableSize(USER_TABLE));
 129     }
 130
 131     /*
 132      * (non-Javadoc)
 133      *
 134      * @see
 135      * org.wamblee.usermgt.InMemoryGroupSetTest#checkGroupExists(java.lang.String
 136      * )
 137      */
 138     @Override
 139     protected void checkUserExists(String aUser) throws SQLException {
 140         databaseTester.flush();
 141
 142         ResultSet result = databaseTester.executeQuery(USER_QUERY, aUser);
 143         assertEquals(1, databaseTester.countResultSet(result));
 144     }
 145
 146     /*
 147      * (non-Javadoc)
 148      *
 149      * @see
 150      * org.wamblee.usermgt.InMemoryGroupSetTest#checkGroupNotExists(java.lang
 151      * .String)
 152      */
 153     @Override
 154     protected void checkUserNotExists(String aUser) throws SQLException {
 155         databaseTester.flush();
 156
 157         ResultSet result = databaseTester.executeQuery(USER_QUERY, aUser);
 158         assertEquals(0, databaseTester.countResultSet(result));
 159     }
 160
 161     /*
 162      * (non-Javadoc)
 163      *
 164      * @see org.wamblee.usermgt.InMemoryGroupSetTest#checkGroupCount(int)
 165      */
 166     @Override
 167     protected void checkGroupCount(int aSize) throws SQLException {
 168         databaseTester.flush();
 169         assertEquals(aSize, databaseTester.getTableSize(GROUP_TABLE));
 170     }
 171
 172     /*
 173      * (non-Javadoc)
 174      *
 175      * @see
 176      * org.wamblee.usermgt.InMemoryGroupSetTest#checkGroupExists(java.lang.String
 177      * )
 178      */
 179     @Override
 180     protected void checkGroupExists(String aGroup) throws SQLException {
 181         databaseTester.flush();
 182
 183         ResultSet result = databaseTester.executeQuery(GROUP_QUERY, aGroup);
 184         assertEquals(1, databaseTester.countResultSet(result));
 185     }
 186
 187     /*
 188      * (non-Javadoc)
 189      *
 190      * @see
 191      * org.wamblee.usermgt.InMemoryGroupSetTest#checkGroupNotExists(java.lang
 192      * .String)
 193      */
 194     @Override
 195     protected void checkGroupNotExists(String aGroup) throws SQLException {
 196         databaseTester.flush();
 197
 198         ResultSet result = databaseTester.executeQuery(GROUP_QUERY, aGroup);
 199         assertEquals(0, databaseTester.countResultSet(result));
 200     }
 201
 202     /*
 203      * (non-Javadoc)
 204      *
 205      * @see org.wamblee.usermgt.InMemoryGroupSetTest#createGroupSet()
 206      */
 207     @Override
 208     protected UserSet createUserSet() {
 209         return userset;
 210     }
 211
 212     /*
 213      * (non-Javadoc)
 214      *
 215      * @see org.wamblee.usermgt.InMemoryUserSetTest#createGroupSet()
 216      */
 217     @Override
 218     protected GroupSet createGroupSet() {
 219         return groupset;
 220     }
 221
 222     /**
 223      * Reproduction of a bug. Create a user which is in group1 Add it to a
 224      * second group group2. Remove the user from group1. Verify the user is in
 225      * group2.
 226      *
 227      */
 228     public void testVerifyAddRemove() throws SQLException, UserMgtException {
 229         databaseTester.cleanDatabase(); // just to be sure.
 230
 231         GroupSet groups = getGroups();
 232         assertEquals(0, groups.size());
 233
 234         Group group1 = createGroup("group1");
 235         Group group2 = createGroup("group2");
 236         groups.add(group1);
 237         groups.add(group2);
 238         checkGroupExists("group1");
 239         checkGroupExists("group2");
 240
 241         User user = createUser("user", PASSWORD, group1);
 242         getUsers().add(user);
 243         checkUserExists("user");
 244
 245         addUserToGroup(user, group2);
 246         getUsers().userModified(user);
 247         clearUserCache();
 248
 249         User user2 = getUsers().find("user");
 250         Set<Group> userGroups = user2.getGroups();
 251         assertTrue(user2.isInGroup("group1"));
 252         assertTrue(user2.isInGroup("group2"));
 253         assertEquals(2, userGroups.size());
 254
 255         removeUserFromGroup(user, group1);
 256         getUsers().userModified(user);
 257         clearUserCache();
 258         user2 = getUsers().find("user");
 259         userGroups = user2.getGroups();
 260         assertFalse(user2.isInGroup("group1"));
 261         assertTrue(user2.isInGroup("group2"));
 262         assertEquals(1, userGroups.size());
 263     }
 264 }