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