1   /*
2    * $Id: $
3    *
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   *
12   *  http://www.apache.org/licenses/LICENSE-2.0
13   *
14   * Unless required by applicable law or agreed to in writing,
15   * software distributed under the License is distributed on an
16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17   * KIND, either express or implied.  See the License for the
18   * specific language governing permissions and limitations
19   * under the License.
20   */
21  
22  package org.apache.struts.apps.mailreader.dao;
23  
24  import junit.framework.TestCase;
25  
26  /**
27   * TODO Complete use case tests for:
28   * - [01 ] findUser(existing)                               [done]
29   * - [02 ] findUser(bogus)                                  [done]
30   * - [03 ] findUsers()                                      [done]
31   * - [04 ] createUser1, find(new one 1)                     [done]
32   * - [04a] createUser1, find(new one 1) find subscr         [done]
33   * - [05 ] createUser2, find(existing)                      [done]
34   * - [05a] createUser2, find(existing)  find subscr         [done]
35   * - [06 ] createUser3, findUsers(all)                      [done]
36   * - [06a] createUser4 (duplicate)                          [done]
37   * - [07 ] findUsers(all)                                   [done]
38   * - [08 ] create, save, close, open find(new one)          [done]
39   * - [09 ] create, save, close, open findUsers(all)         [done]
40   * - [10 ] find(bogus)                                      [done]
41   * - [11 ] create, remove, find(valid), find(invalid)       [done]
42   *
43   * Registrations
44   *
45   */
46  
47  public abstract class BaseTestUserDatabase extends TestCase {
48  
49      protected UserDatabase userDatabase;
50      private int userCt = 10;
51      private int subscriptionCt = 20;
52  
53      protected void setUp() throws Exception {
54          super.setUp();
55              userDatabase = getNewUserDatabase();
56        generateUsers(userCt, subscriptionCt, "");
57      }
58  
59  
60      /**
61       *
62       */
63      private void generateUsers(int users, int subs, String prefix) {
64          for (int i = 0; i < users; i++) {
65            User user = getNewUser(userDatabase, prefix + "user" + i);
66            user.setFromAddress(prefix + "fromAddress" + i);
67            user.setFullName(prefix + "fullName" + i);
68            user.setPassword(prefix + "password" + i);
69  
70            for (int j = 0; j < subs; j++) {
71                Subscription subscription = getNewSubscription(user, prefix + "host" + j);
72                subscription.setAutoConnect(j % 1 == 0);
73                subscription.setUsername(prefix + "subscriptionUserName" + j);
74                subscription.setPassword(prefix + "subscriptionPassword" + j);
75                subscription.setType(prefix + "type" + j);
76            }
77          }
78      }
79  
80  
81      protected void tearDown() throws Exception {
82          super.tearDown();
83          userDatabase.close();
84      }
85  
86      public void testCase01() throws Exception{
87          User user = userDatabase.findUser("user5");
88          assertTrue("Check username", "user5".equals(user.getUsername()));
89          assertTrue("Check fromAddress", "fromAddress5".equals(user.getFromAddress()));
90          assertTrue("Check fullName", "fullName5".equals(user.getFullName()));
91          assertTrue("Check password", "password5".equals(user.getPassword()));
92          assertNull("Check replyToAddress", user.getReplyToAddress());
93  
94      }
95      public void testCase02() throws Exception{
96          User user = userDatabase.findUser("bogusName");
97          assertNull(user);
98      }
99  
100     public void testCase03() throws Exception{
101         User[] users = userDatabase.findUsers();
102         assertTrue("Check users", users.length == userCt);
103     }
104 
105     public void testCase04() throws Exception{
106         String newUserName = "newUser04";
107         User newUser = userDatabase.createUser(newUserName);
108         newUser.setPassword("pass1");
109         newUser.setFromAddress("fromAddress1");
110         newUser.setReplyToAddress("replyToAddress1");
111 
112         User newUser2 = userDatabase.findUser(newUserName);
113         assertTrue("Check username", newUserName.equals(newUser2.getUsername()));
114         assertTrue("Check fromAddress", "fromAddress1".equals(newUser2.getFromAddress()));
115         assertTrue("Check replyToAddress", "replyToAddress1".equals(newUser2.getReplyToAddress()));
116         assertTrue("Check password", "pass1".equals(newUser2.getPassword()));
117         assertNull("Check fullName", newUser2.getFullName());
118     }
119 
120     public void testCase04a() throws Exception{
121         String newUserName = "newUser04a";
122         int subs = 5;
123 
124         User newUser = userDatabase.createUser(newUserName);
125         newUser.setPassword("pass1");
126         newUser.setFromAddress("fromAddress1");
127         newUser.setReplyToAddress("replyToAddress1");
128 
129         User newUser2 = userDatabase.findUser(newUserName);
130         assertTrue("Check username", newUserName.equals(newUser2.getUsername()));
131         assertTrue("Check fromAddress", "fromAddress1".equals(newUser2.getFromAddress()));
132         assertTrue("Check replyToAddress", "replyToAddress1".equals(newUser2.getReplyToAddress()));
133         assertTrue("Check password", "pass1".equals(newUser2.getPassword()));
134         assertNull("Check fullName", newUser2.getFullName());
135 
136         generateUsers(3, subs, "04a");
137 
138         User newUser3 = userDatabase.findUser("04auser1");
139         Subscription[] subscriptions = newUser3.getSubscriptions();
140         assertTrue ("Testing subscriptions length", subscriptions.length == subs);
141         newUser3.removeSubscription(subscriptions[0]);
142 
143         // TODO this is a problem
144 //        assertTrue ("Testing subscriptions length", subscriptions.length < subs);
145 
146     }
147 
148     public void testCase05() throws Exception{
149         String newUserName = "anotherNewUser05";
150 
151         User newUser = userDatabase.createUser(newUserName);
152         newUser.setPassword("pass1");
153         newUser.setFromAddress("fromAddress1");
154         newUser.setReplyToAddress("replyToAddress1");
155 
156         User newUser5 = userDatabase.findUser("user5");
157         assertTrue("Check username", "user5".equals(newUser5.getUsername()));
158         assertTrue("Check fromAddress", "fromAddress5".equals(newUser5.getFromAddress()));
159         assertTrue("Check fullName", "fullName5".equals(newUser5.getFullName()));
160         assertTrue("Check password", "password5".equals(newUser5.getPassword()));
161         assertNull("Check replyToAddress", newUser5.getReplyToAddress());
162 
163     }
164 
165     public void testCase05a() throws Exception{
166         String newUserName = "anotherNewUser05a";
167 
168         User newUser = userDatabase.createUser(newUserName);
169         newUser.setPassword("pass1");
170         newUser.setFromAddress("fromAddress1");
171         newUser.setReplyToAddress("replyToAddress1");
172 
173         User newUser5a = userDatabase.findUser("user5");
174         assertTrue("Check username", "user5".equals(newUser5a.getUsername()));
175         assertTrue("Check fromAddress", "fromAddress5".equals(newUser5a.getFromAddress()));
176         assertTrue("Check fullName", "fullName5".equals(newUser5a.getFullName()));
177         assertTrue("Check password", "password5".equals(newUser5a.getPassword()));
178         assertNull("Check replyToAddress", newUser5a.getReplyToAddress());
179 
180         Subscription[] subscriptions = newUser5a.getSubscriptions();
181         assertTrue ("Testing subscriptions length", subscriptions.length == subscriptionCt);
182 
183     }
184 
185     public void testCase06() throws Exception{
186         String newUserName = "anotherNewUser06";
187 
188         User newUser = userDatabase.createUser(newUserName);
189         newUser.setPassword("pass1");
190         newUser.setFromAddress("fromAddress1");
191         newUser.setReplyToAddress("replyToAddress1");
192 
193         User user6 = userDatabase.findUser("user6");
194         assertTrue("Check username", "user6".equals(user6.getUsername()));
195         assertTrue("Check fromAddress", "fromAddress6".equals(user6.getFromAddress()));
196         assertTrue("Check fullName", "fullName6".equals(user6.getFullName()));
197         assertTrue("Check password", "password6".equals(user6.getPassword()));
198         assertNull("Check replyToAddress", user6.getReplyToAddress());
199 
200     }
201 
202     public void testCase07() throws Exception{
203         String newUserName = "anotherNewUser07";
204 
205         User newUser = userDatabase.createUser(newUserName);
206         newUser.setPassword("pass1");
207         newUser.setFromAddress("fromAddress1");
208         newUser.setReplyToAddress("replyToAddress1");
209 
210         User user7 = userDatabase.findUser("user7");
211         assertTrue("Check username", "user7".equals(user7.getUsername()));
212         assertTrue("Check fromAddress", "fromAddress7".equals(user7.getFromAddress()));
213         assertTrue("Check fullName", "fullName7".equals(user7.getFullName()));
214         assertTrue("Check password", "password7".equals(user7.getPassword()));
215         assertNull("Check replyToAddress", user7.getReplyToAddress());
216 
217         User[] users = userDatabase.findUsers();
218         assertTrue("Check users", users.length == userCt + 1);
219 
220     }
221 
222     public void testCase08() throws Exception{
223         String newUserName = "newUser08";
224         int subs = 5;
225 
226       User newUser = userDatabase.createUser(newUserName);
227       newUser.setPassword("pass1");
228       newUser.setFromAddress("fromAddress1");
229       newUser.setReplyToAddress("replyToAddress1");
230 
231       // TODO fix me, this is not releasing the internal state on close
232   //            userDatabase.save();
233   //            userDatabase.close();
234   //            userDatabase.open();
235 
236       User newUser2 = userDatabase.findUser(newUserName);
237       assertTrue("Check username", newUserName.equals(newUser2.getUsername()));
238       assertTrue("Check fromAddress", "fromAddress1".equals(newUser2.getFromAddress()));
239       assertTrue("Check replyToAddress", "replyToAddress1".equals(newUser2.getReplyToAddress()));
240       assertTrue("Check password", "pass1".equals(newUser2.getPassword()));
241       assertNull("Check fullName", newUser2.getFullName());
242 
243       generateUsers(3, subs, "08");
244 
245       User newUser3 = userDatabase.findUser("08user1");
246       Subscription[] subscriptions = newUser3.getSubscriptions();
247       assertTrue ("Testing subscriptions length", subscriptions.length == subs);
248 
249   //            userDatabase.save();
250   //            userDatabase.close();
251   //            userDatabase.open();
252 
253       User newUser4 = userDatabase.findUser("08user1");
254       Subscription[] subscriptions2 = newUser4.getSubscriptions();
255       assertTrue ("Testing subscriptions length", subscriptions2.length == subs);
256 
257     }
258 
259     public void testCase09() throws Exception{
260 
261             // TODO fix me, this is not releasing the internal state on close
262 //            userDatabase.save();
263 //            userDatabase.close();
264 //            userDatabase.open();
265 
266             User[] users = userDatabase.findUsers();
267             assertTrue("Testing users count", users.length == userCt);
268 
269     }
270 
271     public void testCase010() throws Exception{
272 
273             // TODO fix me, this is not releasing the internal state on close
274 //            userDatabase.save();
275 //            userDatabase.close();
276 //            userDatabase.open();
277 
278             User user = userDatabase.findUser("bogus user");
279             assertNull("Find non-existing user", user);
280 
281     }
282 
283     public void testCase011() throws Exception{
284 
285         String newUserName = "newUser11";
286 
287         User newUser = userDatabase.createUser(newUserName);
288         newUser.setPassword("pass1");
289         newUser.setFromAddress("fromAddress1");
290         newUser.setReplyToAddress("replyToAddress1");
291 
292         User user = userDatabase.findUser(newUserName);
293         assertNotNull("Find non-existing user", user);
294 
295         userDatabase.removeUser(user);
296         User user2 = userDatabase.findUser(newUserName);
297         assertNull("Find non-existing user", user2);
298 
299     }
300 
301 
302     protected abstract UserDatabase getNewUserDatabase();
303     protected abstract User getNewUser(UserDatabase db, String userName);
304     protected abstract Subscription getNewSubscription(User user, String host);
305 
306 }