001: /*
002: * Copyright 2001-2007 Geert Bevin <gbevin[remove] at uwyn dot com> and
003: * Steven Grimm <koreth[remove] at midwinter dot com>
004: * Distributed under the terms of either:
005: * - the common development and distribution license (CDDL), v1.0; or
006: * - the GNU Lesser General Public License, v2.1 or later
007: * $Id: TestDatabaseRemember.java 3643 2007-01-12 15:29:45Z gbevin $
008: */
009: package com.uwyn.rife.authentication.remembermanagers;
010:
011: import com.uwyn.rife.authentication.exceptions.RememberManagerException;
012: import com.uwyn.rife.database.Datasource;
013: import com.uwyn.rife.ioc.HierarchicalProperties;
014: import com.uwyn.rife.tools.ExceptionUtils;
015: import java.util.ArrayList;
016: import junit.framework.TestCase;
017:
018: public class TestDatabaseRemember extends TestCase {
019: private Datasource mDatasource = null;
020: private HierarchicalProperties mProperties = null;
021:
022: public TestDatabaseRemember(Datasource datasource,
023: String datasourceName, String name) {
024: super (name);
025: mDatasource = datasource;
026: mProperties = new HierarchicalProperties();
027: mProperties.put("datasource", mDatasource);
028: }
029:
030: public void testInstantiation() {
031: DatabaseRemember manager = new DatabaseRememberFactory()
032: .getRememberManager(mProperties);
033: assertNotNull(manager);
034: }
035:
036: public void testInstall() {
037: DatabaseRemember remember = new DatabaseRememberFactory()
038: .getRememberManager(mProperties);
039:
040: try {
041: assertTrue(true == remember.install());
042: } catch (RememberManagerException e) {
043: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
044: }
045: }
046:
047: public void testRemove() {
048: DatabaseRemember remember = new DatabaseRememberFactory()
049: .getRememberManager(mProperties);
050:
051: try {
052: assertTrue(true == remember.remove());
053: } catch (RememberManagerException e) {
054: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
055: }
056: }
057:
058: public void testCreateRememberId() {
059: DatabaseRemember remember = new DatabaseRememberFactory()
060: .getRememberManager(mProperties);
061:
062: int user_id = 143;
063:
064: String remember_id = null;
065: try {
066: remember.install();
067:
068: remember_id = remember.createRememberId(user_id,
069: "123.98.23.3");
070:
071: assertNotNull(remember_id);
072: assertTrue(remember_id.length() > 0);
073:
074: assertEquals(user_id, remember
075: .getRememberedUserId(remember_id));
076: } catch (RememberManagerException e) {
077: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
078: } finally {
079: try {
080: remember.remove();
081: } catch (RememberManagerException e) {
082: assertTrue(ExceptionUtils.getExceptionStackTrace(e),
083: false);
084: }
085: }
086: }
087:
088: public void testGetRememberedUserId() {
089: DatabaseRemember remember = new DatabaseRememberFactory()
090: .getRememberManager(mProperties);
091:
092: try {
093: remember.install();
094:
095: ArrayList<String> remember_ids1 = new ArrayList<String>();
096: ArrayList<String> remember_ids2 = new ArrayList<String>();
097: ArrayList<String> remember_ids3 = new ArrayList<String>();
098: remember_ids1.add(remember.createRememberId(232,
099: "123.98.23.3"));
100: remember_ids1.add(remember.createRememberId(232,
101: "123.98.23.32"));
102: remember_ids2.add(remember.createRememberId(23,
103: "123.98.23.3"));
104: remember_ids3.add(remember.createRememberId(53,
105: "123.98.23.3"));
106: remember_ids3.add(remember.createRememberId(53,
107: "123.98.23.3"));
108: remember_ids1.add(remember.createRememberId(232,
109: "123.98.23.34"));
110: remember_ids2.add(remember.createRememberId(23,
111: "123.98.23.3"));
112:
113: for (String remember_id : remember_ids1) {
114: assertEquals(232, remember
115: .getRememberedUserId(remember_id));
116: }
117:
118: for (String remember_id : remember_ids2) {
119: assertEquals(23, remember
120: .getRememberedUserId(remember_id));
121: }
122:
123: for (String remember_id : remember_ids3) {
124: assertEquals(53, remember
125: .getRememberedUserId(remember_id));
126: }
127: } catch (RememberManagerException e) {
128: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
129: } finally {
130: try {
131: remember.remove();
132: } catch (RememberManagerException e) {
133: assertTrue(ExceptionUtils.getExceptionStackTrace(e),
134: false);
135: }
136: }
137: }
138:
139: public void testEraseRememberId() {
140: DatabaseRemember remember = new DatabaseRememberFactory()
141: .getRememberManager(mProperties);
142:
143: int user_id = 93;
144:
145: try {
146: remember.install();
147:
148: String remember_id = null;
149: remember_id = remember.createRememberId(user_id,
150: "123.98.23.3");
151: assertEquals(user_id, remember
152: .getRememberedUserId(remember_id));
153: assertTrue(remember.eraseRememberId(remember_id));
154: assertEquals(-1, remember.getRememberedUserId(remember_id));
155: } catch (RememberManagerException e) {
156: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
157: } finally {
158: try {
159: remember.remove();
160: } catch (RememberManagerException e) {
161: assertTrue(ExceptionUtils.getExceptionStackTrace(e),
162: false);
163: }
164: }
165: }
166:
167: public void testEraseUnknownSession() {
168: DatabaseRemember remember = new DatabaseRememberFactory()
169: .getRememberManager(mProperties);
170:
171: String remember_id = "unknown";
172: try {
173: remember.install();
174:
175: assertTrue(false == remember.eraseRememberId(remember_id));
176: } catch (RememberManagerException e) {
177: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
178: } finally {
179: try {
180: remember.remove();
181: } catch (RememberManagerException e) {
182: assertTrue(ExceptionUtils.getExceptionStackTrace(e),
183: false);
184: }
185: }
186: }
187:
188: public void testEraseAllRememberIds() {
189: DatabaseRemember remember = new DatabaseRememberFactory()
190: .getRememberManager(mProperties);
191:
192: try {
193: remember.install();
194:
195: ArrayList<String> remember_ids = new ArrayList<String>();
196: remember_ids.add(remember.createRememberId(232,
197: "123.98.23.3"));
198: remember_ids.add(remember.createRememberId(232,
199: "123.98.23.34"));
200: remember_ids.add(remember.createRememberId(23,
201: "123.98.23.3"));
202: remember_ids.add(remember.createRememberId(53,
203: "123.98.23.3"));
204: remember_ids.add(remember.createRememberId(53,
205: "123.98.23.3"));
206: remember_ids.add(remember.createRememberId(232,
207: "123.98.23.31"));
208: remember_ids.add(remember.createRememberId(23,
209: "123.98.23.3"));
210:
211: for (String remember_id : remember_ids) {
212: assertTrue(remember.getRememberedUserId(remember_id) != -1);
213: }
214:
215: remember.eraseAllRememberIds();
216:
217: for (String remember_id : remember_ids) {
218: assertEquals(-1, remember
219: .getRememberedUserId(remember_id));
220: }
221: } catch (RememberManagerException e) {
222: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
223: } finally {
224: try {
225: remember.remove();
226: } catch (RememberManagerException e) {
227: assertTrue(ExceptionUtils.getExceptionStackTrace(e),
228: false);
229: }
230: }
231: }
232:
233: public void testEraseUserRememberIds() {
234: DatabaseRemember remember = new DatabaseRememberFactory()
235: .getRememberManager(mProperties);
236:
237: try {
238: remember.install();
239:
240: ArrayList<String> remember_ids = new ArrayList<String>();
241: remember_ids.add(remember.createRememberId(8433,
242: "123.98.23.3"));
243: remember_ids.add(remember.createRememberId(8433,
244: "123.98.23.33"));
245: remember_ids.add(remember.createRememberId(8432,
246: "123.98.23.31"));
247: remember_ids.add(remember.createRememberId(8431,
248: "123.98.23.3"));
249:
250: for (String remember_id : remember_ids) {
251: assertTrue(remember.getRememberedUserId(remember_id) != -1);
252: }
253:
254: assertTrue(remember.eraseUserRememberIds(8433));
255:
256: assertTrue(remember
257: .getRememberedUserId(remember_ids.get(0)) == -1);
258: assertTrue(remember
259: .getRememberedUserId(remember_ids.get(1)) == -1);
260: assertTrue(remember
261: .getRememberedUserId(remember_ids.get(2)) != -1);
262: assertTrue(remember
263: .getRememberedUserId(remember_ids.get(3)) != -1);
264: } catch (RememberManagerException e) {
265: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
266: } finally {
267: try {
268: remember.remove();
269: } catch (RememberManagerException e) {
270: assertTrue(ExceptionUtils.getExceptionStackTrace(e),
271: false);
272: }
273: }
274: }
275:
276: public void testEraseUnkownUserRememberIds() {
277: DatabaseRemember remember = new DatabaseRememberFactory()
278: .getRememberManager(mProperties);
279:
280: try {
281: remember.install();
282:
283: ArrayList<String> remember_ids = new ArrayList<String>();
284: remember_ids.add(remember.createRememberId(8432,
285: "123.98.23.3"));
286: remember_ids.add(remember.createRememberId(8431,
287: "123.98.23.3"));
288:
289: for (String remember_id : remember_ids) {
290: assertTrue(remember.getRememberedUserId(remember_id) != -1);
291: }
292:
293: assertFalse(remember.eraseUserRememberIds(8433));
294:
295: for (String remember_id : remember_ids) {
296: assertTrue(remember.getRememberedUserId(remember_id) != -1);
297: }
298: } catch (RememberManagerException e) {
299: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
300: } finally {
301: try {
302: remember.remove();
303: } catch (RememberManagerException e) {
304: assertTrue(ExceptionUtils.getExceptionStackTrace(e),
305: false);
306: }
307: }
308: }
309:
310: public void testPurgeRememberIds() {
311: DatabaseRemember remember = new DatabaseRememberFactory()
312: .getRememberManager(mProperties);
313: remember.setRememberDuration(2000);
314:
315: int user_id = 9478;
316:
317: try {
318: remember.install();
319:
320: remember.eraseAllRememberIds();
321:
322: String remember_id = remember.createRememberId(user_id,
323: "123.98.23.3");
324:
325: remember.purgeRememberIds();
326:
327: assertEquals(remember.getRememberedUserId(remember_id),
328: user_id);
329:
330: Thread.sleep(2010);
331:
332: remember.purgeRememberIds();
333:
334: assertEquals(remember.getRememberedUserId(remember_id), -1);
335: } catch (InterruptedException e) {
336: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
337: } catch (RememberManagerException e) {
338: assertTrue(ExceptionUtils.getExceptionStackTrace(e), false);
339: } finally {
340: try {
341: remember.remove();
342: } catch (RememberManagerException e) {
343: assertTrue(ExceptionUtils.getExceptionStackTrace(e),
344: false);
345: }
346: }
347: }
348: }
|