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