wamblee.org Git - utils/blob - security/jpatest/src/test/java/org/wamblee/usermgt/hibernate/HibernateUserSetTest.java

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