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