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