package rename for test libraries.
[utils] / security / jpatest / src / test / java / org / wamblee / security / authentication / jpa / JpaUserSetTest.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.security.authentication.jpa;
17
18 import java.sql.Connection;
19 import java.sql.ResultSet;
20 import java.util.Set;
21
22 import org.wamblee.cache.EhCache;
23 import org.wamblee.io.ClassPathResource;
24 import org.wamblee.security.authentication.Group;
25 import org.wamblee.security.authentication.GroupSet;
26 import org.wamblee.security.authentication.InMemoryUserSetTest;
27 import org.wamblee.security.authentication.Md5HexMessageDigester;
28 import org.wamblee.security.authentication.MessageDigester;
29 import org.wamblee.security.authentication.NameValidator;
30 import org.wamblee.security.authentication.RegexpNameValidator;
31 import org.wamblee.security.authentication.User;
32 import org.wamblee.security.authentication.UserSet;
33 import org.wamblee.test.persistence.JpaTester;
34 import org.wamblee.test.persistence.TransactionProxyFactory;
35 import org.wamblee.test.persistence.DatabaseUtils.JdbcUnitOfWork;
36
37 /**
38  * Tests for {@link org.wamblee.usermgt.hibernate.HibernateGroupSet}
39  * 
40  * @author Erik Brakkee
41  */
42 public class JpaUserSetTest extends InMemoryUserSetTest {
43     private static final String USER_TABLE = "SEC_USER";
44
45     private static final String GROUP_TABLE = "SEC_GROUP";
46
47     private static final String USER_QUERY = "select * from " + USER_TABLE +
48         " where name = ?";
49
50     private static final String GROUP_QUERY = "select * from " + GROUP_TABLE +
51         " where name = ?";
52
53     private UserSet userset;
54
55     private GroupSet groupset;
56
57     private EhCache<String, User> userCache;
58
59     private JpaTester jpaTester; 
60
61     /*
62      * (non-Javadoc)
63      * 
64      * @see org.wamblee.usermgt.InMemoryUserSetTest#setUp()
65      */
66     @Override
67     protected void setUp() throws Exception {
68         jpaTester = new JpaTester(new SecurityPersistenceUnit());
69         jpaTester.start();
70
71         userCache = new EhCache<String, User>(
72             new ClassPathResource("properties/org.wamblee.security.ehcache.xml"), "users");
73      
74         userset = createUserSetImpl();
75         groupset = createGroupSetImpl();
76         
77         clearUserCache();
78
79         super.setUp();
80     }
81     
82     private UserSet createUserSetImpl() {
83         NameValidator passwordValidator = new RegexpNameValidator(
84             ".{5,}", "INVALID_PASSWORD", "Password must have at least 5 characters");
85         
86         MessageDigester passwordDigester = new Md5HexMessageDigester();
87         TransactionProxyFactory<UserSet> factory = new TransactionProxyFactory<UserSet>(
88             jpaTester.getJpaBuilder(), UserSet.class);
89         UserSet jpaUserset = new JpaUserSet(userCache, passwordValidator, passwordDigester,
90             factory.getTransactionScopedEntityManager());
91         return factory.getProxy(jpaUserset);
92     }
93     
94     private GroupSet createGroupSetImpl() {
95         TransactionProxyFactory<GroupSet> factory = new TransactionProxyFactory<GroupSet>(
96             jpaTester.getJpaBuilder(), GroupSet.class);
97         GroupSet groups = new JpaGroupSet(factory.getTransactionScopedEntityManager());
98         GroupSet proxy = factory.getProxy(groups);
99         return proxy;
100     }
101
102     @Override
103     protected void tearDown() throws Exception {
104         jpaTester.stop();
105         super.tearDown();
106     }
107
108     /**
109      * Clears the user cache.
110      */
111     private void clearUserCache() {
112         userCache.clear();
113     }
114
115     /*
116      * (non-Javadoc)
117      * 
118      * @see org.wamblee.usermgt.InMemoryGroupSetTest#checkGroupCount(int)
119      */
120     @Override
121     protected void checkUserCount(int aSize) throws Exception {
122         super.checkUserCount(aSize);
123         assertEquals(aSize, jpaTester.getDbUtils().getTableSize(USER_TABLE));
124     }
125
126     /*
127      * (non-Javadoc)
128      * 
129      * @see
130      * org.wamblee.usermgt.InMemoryGroupSetTest#checkGroupExists(java.lang.String
131      * )
132      */
133     @Override
134     protected void checkUserExists(final String aUser) throws Exception {
135         assertEquals(1, countUser(aUser));
136     }
137
138     private int countUser(final String aUser) throws Exception {
139         int count = jpaTester.getDbUtils().executeInTransaction(new JdbcUnitOfWork<Integer>() {
140             @Override
141             public Integer execute(Connection aConnection) throws Exception {
142                 ResultSet res = jpaTester.getDbUtils().executeQuery(aConnection, USER_QUERY, aUser);
143                 return jpaTester.getDbUtils().countResultSet(res);
144             }
145         });
146         return count;
147     }
148
149     /*
150      * (non-Javadoc)
151      * 
152      * @see
153      * org.wamblee.usermgt.InMemoryGroupSetTest#checkGroupNotExists(java.lang
154      * .String)
155      */
156     @Override
157     protected void checkUserNotExists(String aUser) throws Exception {
158         assertEquals(0, countUser(aUser));
159     }
160
161     /*
162      * (non-Javadoc)
163      * 
164      * @see org.wamblee.usermgt.InMemoryGroupSetTest#checkGroupCount(int)
165      */
166     @Override
167     protected void checkGroupCount(int aSize) throws Exception {
168         assertEquals(aSize, jpaTester.getDbUtils().getTableSize(GROUP_TABLE));
169     }
170     
171     private int countGroup(final String aGroup) throws Exception {
172         int count = jpaTester.getDbUtils().executeInTransaction(new JdbcUnitOfWork<Integer>() {
173             @Override
174             public Integer execute(Connection aConnection) throws Exception {
175                 ResultSet res = jpaTester.getDbUtils().executeQuery(aConnection, GROUP_QUERY, aGroup);
176                 return jpaTester.getDbUtils().countResultSet(res);
177             }
178         });
179         return count;
180     }
181
182     /*
183      * (non-Javadoc)
184      * 
185      * @see
186      * org.wamblee.usermgt.InMemoryGroupSetTest#checkGroupExists(java.lang.String
187      * )
188      */
189     @Override
190     protected void checkGroupExists(String aGroup) throws Exception {
191         assertEquals(1, countGroup(aGroup));
192     }
193
194     /*
195      * (non-Javadoc)
196      * 
197      * @see
198      * org.wamblee.usermgt.InMemoryGroupSetTest#checkGroupNotExists(java.lang
199      * .String)
200      */
201     @Override
202     protected void checkGroupNotExists(String aGroup) throws Exception {
203         assertEquals(0, countGroup(aGroup));
204     }
205
206     /*
207      * (non-Javadoc)
208      * 
209      * @see org.wamblee.usermgt.InMemoryGroupSetTest#createGroupSet()
210      */
211     @Override
212     protected UserSet createUserSet() {
213         return userset;
214     }
215
216     /*
217      * (non-Javadoc)
218      * 
219      * @see org.wamblee.usermgt.InMemoryUserSetTest#createGroupSet()
220      */
221     @Override
222     protected GroupSet createGroupSet() {
223         return groupset;
224     }
225
226     /**
227      * Reproduction of a bug. Create a user which is in group1 Add it to a
228      * second group group2. Remove the user from group1. Verify the user is in
229      * group2.
230      * 
231      */
232     public void testVerifyAddRemove() throws Exception {
233         jpaTester.getDbUtils().cleanDatabase(new SecurityTables()); // super class setup always creates one group. 
234         
235         GroupSet groups = getGroups();
236         assertEquals(0, groups.size());
237
238         Group group1 = createGroup("group1");
239         Group group2 = createGroup("group2");
240         groups.add(group1);
241         groups.add(group2);
242         checkGroupExists("group1");
243         checkGroupExists("group2");
244
245         User user = createUser("user", PASSWORD, group1);
246         getUsers().add(user);
247         checkUserExists("user");
248
249         addUserToGroup(user, group2);
250         getUsers().userModified(user);
251         clearUserCache();
252         
253         User user2 = getUsers().find("user");
254         
255         Set<Group> userGroups = user2.getGroups();
256         assertTrue(user2.isInGroup("group1"));
257         assertTrue(user2.isInGroup("group2"));
258         assertEquals(2, userGroups.size());
259
260         removeUserFromGroup(user, group1);
261         getUsers().userModified(user);
262         clearUserCache();
263         user2 = getUsers().find("user");
264         userGroups = user2.getGroups();
265         assertFalse(user2.isInGroup("group1"));
266         assertTrue(user2.isInGroup("group2"));
267         assertEquals(1, userGroups.size());
268     }
269 }