Removed SpringTestCase and SpringConfigFiles and subclasses.
[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.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 }