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