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 package org.wamblee.usermgt.hibernate;
  17
  18 import org.wamblee.cache.EhCache;
  19
  20 import org.wamblee.system.adapters.DefaultContainer;
  21 import org.wamblee.system.adapters.ObjectConfiguration;
  22 import org.wamblee.system.core.Scope;
  23 import org.wamblee.system.spring.component.DatabaseTesterComponent;
  24
  25 import org.wamblee.usermgt.Group;
  26 import org.wamblee.usermgt.GroupSet;
  27 import org.wamblee.usermgt.InMemoryUserSetTest;
  28 import org.wamblee.usermgt.User;
  29 import org.wamblee.usermgt.UserMgtException;
  30 import org.wamblee.usermgt.UserSet;
  31
  32 import java.io.Serializable;
  33
  34 import java.sql.ResultSet;
  35 import java.sql.SQLException;
  36
  37 import java.util.Set;
  38
  39
  40 /**
  41  * Tests for {@link org.wamblee.usermgt.hibernate.HibernateGroupSet}
  42  *
  43  * @author Erik Brakkee
  44  */
  45 public class HibernateUserSetTest extends InMemoryUserSetTest {
  46     /**
  47      * DOCUMENT ME!
  48      */
  49     private static final String USER_TABLE = "USERS";
  50
  51     /**
  52      * DOCUMENT ME!
  53      */
  54     private static final String GROUP_TABLE = "GROUPS";
  55
  56     /**
  57      * DOCUMENT ME!
  58      */
  59     private static final String USER_QUERY = "select * from " + USER_TABLE
  60         + " where name = ?";
  61
  62     /**
  63      * DOCUMENT ME!
  64      */
  65     private static final String GROUP_QUERY = "select * from " + GROUP_TABLE
  66         + " where name = ?";
  67
  68     /**
  69      * DOCUMENT ME!
  70      */
  71     private DefaultContainer container;
  72
  73     /**
  74      * DOCUMENT ME!
  75      */
  76     private Scope scope;
  77
  78     /**
  79      * DOCUMENT ME!
  80      */
  81     private UserSet userset;
  82
  83     /**
  84      * DOCUMENT ME!
  85      */
  86     private GroupSet groupset;
  87
  88     /**
  89      * DOCUMENT ME!
  90      */
  91     private EhCache<Serializable, Serializable> userCache;
  92
  93     /**
  94      * DOCUMENT ME!
  95      */
  96     private DatabaseTesterComponent databaseTester;
  97
  98     /*
  99      * (non-Javadoc)
 100      *
 101      * @see org.wamblee.usermgt.InMemoryUserSetTest#setUp()
 102      */
 103     /**
 104      * DOCUMENT ME!
 105      *
 106      * @throws Exception DOCUMENT ME!
 107      */
 108     @Override
 109     protected void setUp() throws Exception {
 110         container = new UserMgtRepositoryTestContainer("top");
 111
 112         ObjectConfiguration config = new ObjectConfiguration(HibernateUserSetTest.class);
 113         config.getSetterConfig().clear().add("setUserset").add("setGroupset")
 114         .add("setDatabaseTester").add("setUserCache");
 115         container.addComponent("testcase", this, config);
 116
 117         scope = container.start();
 118
 119         clearUserCache();
 120         databaseTester.cleanDatabase();
 121
 122         super.setUp();
 123     }
 124
 125     /**
 126      * DOCUMENT ME!
 127      *
 128      * @param aUserset DOCUMENT ME!
 129      */
 130     public void setUserset(UserSet aUserset) {
 131         userset = aUserset;
 132     }
 133
 134     /**
 135      * DOCUMENT ME!
 136      *
 137      * @param aGroupset DOCUMENT ME!
 138      */
 139     public void setGroupset(GroupSet aGroupset) {
 140         groupset = aGroupset;
 141     }
 142
 143     /**
 144      * DOCUMENT ME!
 145      *
 146      * @param aUserCache DOCUMENT ME!
 147      */
 148     public void setUserCache(EhCache<Serializable, Serializable> aUserCache) {
 149         userCache = aUserCache;
 150     }
 151
 152     /**
 153      * DOCUMENT ME!
 154      *
 155      * @param aDatabaseTester DOCUMENT ME!
 156      */
 157     public void setDatabaseTester(DatabaseTesterComponent aDatabaseTester) {
 158         databaseTester = aDatabaseTester;
 159     }
 160
 161     /**
 162      * DOCUMENT ME!
 163      *
 164      * @throws Exception DOCUMENT ME!
 165      */
 166     @Override
 167     protected void tearDown() throws Exception {
 168         container.stop(scope);
 169         super.tearDown();
 170     }
 171
 172     /**
 173      * Clears the user cache.
 174      */
 175     private void clearUserCache() {
 176         userCache.clear();
 177     }
 178
 179     /*
 180      * (non-Javadoc)
 181      *
 182      * @see org.wamblee.usermgt.InMemoryGroupSetTest#checkGroupCount(int)
 183      */
 184     /**
 185      * DOCUMENT ME!
 186      *
 187      * @param aSize DOCUMENT ME!
 188      *
 189      * @throws SQLException DOCUMENT ME!
 190      */
 191     @Override
 192     protected void checkUserCount(int aSize) throws SQLException {
 193         databaseTester.flush();
 194         super.checkUserCount(aSize);
 195         assertEquals(aSize, databaseTester.getTableSize(USER_TABLE));
 196     }
 197
 198     /*
 199      * (non-Javadoc)
 200      *
 201      * @see org.wamblee.usermgt.InMemoryGroupSetTest#checkGroupExists(java.lang.String)
 202      */
 203     /**
 204      * DOCUMENT ME!
 205      *
 206      * @param aUser DOCUMENT ME!
 207      *
 208      * @throws SQLException DOCUMENT ME!
 209      */
 210     @Override
 211     protected void checkUserExists(String aUser) throws SQLException {
 212         databaseTester.flush();
 213
 214         ResultSet result = databaseTester.executeQuery(USER_QUERY, aUser);
 215         assertEquals(1, databaseTester.countResultSet(result));
 216     }
 217
 218     /*
 219      * (non-Javadoc)
 220      *
 221      * @see org.wamblee.usermgt.InMemoryGroupSetTest#checkGroupNotExists(java.lang.String)
 222      */
 223     /**
 224      * DOCUMENT ME!
 225      *
 226      * @param aUser DOCUMENT ME!
 227      *
 228      * @throws SQLException DOCUMENT ME!
 229      */
 230     @Override
 231     protected void checkUserNotExists(String aUser) throws SQLException {
 232         databaseTester.flush();
 233
 234         ResultSet result = databaseTester.executeQuery(USER_QUERY, aUser);
 235         assertEquals(0, databaseTester.countResultSet(result));
 236     }
 237
 238     /*
 239      * (non-Javadoc)
 240      *
 241      * @see org.wamblee.usermgt.InMemoryGroupSetTest#checkGroupCount(int)
 242      */
 243     /**
 244      * DOCUMENT ME!
 245      *
 246      * @param aSize DOCUMENT ME!
 247      *
 248      * @throws SQLException DOCUMENT ME!
 249      */
 250     @Override
 251     protected void checkGroupCount(int aSize) throws SQLException {
 252         databaseTester.flush();
 253         assertEquals(aSize, databaseTester.getTableSize(GROUP_TABLE));
 254     }
 255
 256     /*
 257      * (non-Javadoc)
 258      *
 259      * @see org.wamblee.usermgt.InMemoryGroupSetTest#checkGroupExists(java.lang.String)
 260      */
 261     /**
 262      * DOCUMENT ME!
 263      *
 264      * @param aGroup DOCUMENT ME!
 265      *
 266      * @throws SQLException DOCUMENT ME!
 267      */
 268     @Override
 269     protected void checkGroupExists(String aGroup) throws SQLException {
 270         databaseTester.flush();
 271
 272         ResultSet result = databaseTester.executeQuery(GROUP_QUERY, aGroup);
 273         assertEquals(1, databaseTester.countResultSet(result));
 274     }
 275
 276     /*
 277      * (non-Javadoc)
 278      *
 279      * @see org.wamblee.usermgt.InMemoryGroupSetTest#checkGroupNotExists(java.lang.String)
 280      */
 281     /**
 282      * DOCUMENT ME!
 283      *
 284      * @param aGroup DOCUMENT ME!
 285      *
 286      * @throws SQLException DOCUMENT ME!
 287      */
 288     @Override
 289     protected void checkGroupNotExists(String aGroup) throws SQLException {
 290         databaseTester.flush();
 291
 292         ResultSet result = databaseTester.executeQuery(GROUP_QUERY, aGroup);
 293         assertEquals(0, databaseTester.countResultSet(result));
 294     }
 295
 296     /*
 297      * (non-Javadoc)
 298      *
 299      * @see org.wamblee.usermgt.InMemoryGroupSetTest#createGroupSet()
 300      */
 301     /**
 302      * DOCUMENT ME!
 303      *
 304      * @return DOCUMENT ME!
 305      */
 306     @Override
 307     protected UserSet createUserSet() {
 308         return userset;
 309     }
 310
 311     /*
 312      * (non-Javadoc)
 313      *
 314      * @see org.wamblee.usermgt.InMemoryUserSetTest#createGroupSet()
 315      */
 316     /**
 317      * DOCUMENT ME!
 318      *
 319      * @return DOCUMENT ME!
 320      */
 321     @Override
 322     protected GroupSet createGroupSet() {
 323         return groupset;
 324     }
 325
 326     /**
 327      * Reproduction of a bug. Create a user which is in group1 Add it
 328      * to a second group group2. Remove the user from group1. Verify the user
 329      * is in group2.
 330      *
 331      * @throws SQLException DOCUMENT ME!
 332      * @throws UserMgtException DOCUMENT ME!
 333      */
 334     public void testVerifyAddRemove() throws SQLException, UserMgtException {
 335         databaseTester.cleanDatabase(); // just to be sure.
 336
 337         GroupSet groups = getGroups();
 338         assertEquals(0, groups.size());
 339
 340         Group group1 = createGroup("group1");
 341         Group group2 = createGroup("group2");
 342         groups.add(group1);
 343         groups.add(group2);
 344         checkGroupExists("group1");
 345         checkGroupExists("group2");
 346
 347         User user = createUser("user", PASSWORD, group1);
 348         getUsers().add(user);
 349         checkUserExists("user");
 350
 351         addUserToGroup(user, group2);
 352         getUsers().userModified(user);
 353         clearUserCache();
 354
 355         User       user2      = getUsers().find("user");
 356         Set<Group> userGroups = user2.getGroups();
 357         assertTrue(user2.isInGroup("group1"));
 358         assertTrue(user2.isInGroup("group2"));
 359         assertEquals(2, userGroups.size());
 360
 361         removeUserFromGroup(user, group1);
 362         getUsers().userModified(user);
 363         clearUserCache();
 364         user2          = getUsers().find("user");
 365         userGroups     = user2.getGroups();
 366         assertFalse(user2.isInGroup("group1"));
 367         assertTrue(user2.isInGroup("group2"));
 368         assertEquals(1, userGroups.size());
 369     }
 370 }