Moving around a lot of files to work towards production components.
[utils] / 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 }