001: /*
002: * Copyright 2001-2007 Geert Bevin <gbevin[remove] at uwyn dot com> and
003: * JR Boyens <gnu-jrb[remove] at gmx dot net>
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: TestGenericQueryManagerCallbacks.java 3634 2007-01-08 21:42:24Z gbevin $
008: */
009: package com.uwyn.rife.database.querymanagers.generic;
010:
011: import com.uwyn.rife.database.Datasource;
012: import com.uwyn.rife.database.querymanagers.generic.beans.CallbacksBean;
013: import com.uwyn.rife.database.querymanagers.generic.beans.CallbacksProviderBean;
014: import com.uwyn.rife.database.querymanagers.generic.beans.CallbacksSparseBean;
015: import com.uwyn.rife.tools.StringUtils;
016: import java.util.Iterator;
017: import java.util.List;
018: import java.util.Map;
019: import junit.framework.TestCase;
020:
021: public class TestGenericQueryManagerCallbacks extends TestCase {
022: private Datasource mDatasource = null;
023:
024: private GenericQueryManager<CallbacksBean> mCallbacksManager = null;
025: private GenericQueryManager<CallbacksSparseBean> mCallbacksSparseManager = null;
026: private GenericQueryManager<CallbacksProviderBean> mCallbacksProviderManager = null;
027:
028: public TestGenericQueryManagerCallbacks(Datasource datasource,
029: String datasourceName, String name) {
030: super (name);
031: mDatasource = datasource;
032: }
033:
034: protected void setUp() throws Exception {
035: mCallbacksManager = GenericQueryManagerFactory.getInstance(
036: mDatasource, CallbacksBean.class);
037: mCallbacksSparseManager = GenericQueryManagerFactory
038: .getInstance(mDatasource, CallbacksSparseBean.class);
039: mCallbacksProviderManager = GenericQueryManagerFactory
040: .getInstance(mDatasource, CallbacksProviderBean.class);
041:
042: int poolsize = mDatasource.getPoolsize();
043: // disabling pool for firebird
044: if ("org.firebirdsql.jdbc.FBDriver".equals(mDatasource
045: .getAliasedDriver())) {
046: mDatasource.setPoolsize(0);
047: }
048: try {
049: AggregatingCallbacksBeanListener listener = new AggregatingCallbacksBeanListener();
050: mCallbacksManager.addListener(listener);
051: mCallbacksManager.install();
052: assertEquals(1, listener.getHistory().size());
053: assertEquals("installed0", listener.getHistory().entrySet()
054: .iterator().next().getKey());
055:
056: mCallbacksSparseManager.install();
057: mCallbacksProviderManager.install();
058: } finally {
059: mCallbacksManager.removeListeners();
060:
061: if ("org.firebirdsql.jdbc.FBDriver".equals(mDatasource
062: .getAliasedDriver())) {
063: mDatasource.setPoolsize(poolsize);
064: }
065: }
066: }
067:
068: protected void tearDown() throws Exception {
069: int poolsize = mDatasource.getPoolsize();
070: // disabling pool for firebird
071: if ("org.firebirdsql.jdbc.FBDriver".equals(mDatasource
072: .getAliasedDriver())) {
073: mDatasource.setPoolsize(0);
074: }
075: try {
076: AggregatingCallbacksBeanListener listener = new AggregatingCallbacksBeanListener();
077: mCallbacksManager.addListener(listener);
078: mCallbacksManager.remove();
079: assertEquals(1, listener.getHistory().size());
080: assertEquals("removed0", listener.getHistory().entrySet()
081: .iterator().next().getKey());
082:
083: mCallbacksSparseManager.remove();
084: mCallbacksProviderManager.remove();
085: } finally {
086: mCallbacksManager.removeListeners();
087:
088: if ("org.firebirdsql.jdbc.FBDriver".equals(mDatasource
089: .getAliasedDriver())) {
090: mDatasource.setPoolsize(poolsize);
091: }
092: }
093: }
094:
095: public void testGetBaseClass() {
096: assertSame(CallbacksBean.class, mCallbacksManager
097: .getBaseClass());
098: assertSame(CallbacksSparseBean.class, mCallbacksSparseManager
099: .getBaseClass());
100: assertSame(CallbacksProviderBean.class,
101: mCallbacksProviderManager.getBaseClass());
102: }
103:
104: public void testInstallCustomQuery() {
105: int poolsize = mDatasource.getPoolsize();
106: // disabling pool for firebird
107: if ("org.firebirdsql.jdbc.FBDriver".equals(mDatasource
108: .getAliasedDriver())) {
109: mDatasource.setPoolsize(0);
110: }
111: try {
112: mCallbacksManager.remove();
113: mCallbacksSparseManager.remove();
114: mCallbacksProviderManager.remove();
115:
116: mCallbacksManager.install(mCallbacksManager
117: .getInstallTableQuery());
118: mCallbacksSparseManager.install(mCallbacksSparseManager
119: .getInstallTableQuery());
120: mCallbacksProviderManager.install(mCallbacksProviderManager
121: .getInstallTableQuery());
122: } finally {
123: if ("org.firebirdsql.jdbc.FBDriver".equals(mDatasource
124: .getAliasedDriver())) {
125: mDatasource.setPoolsize(poolsize);
126: }
127: }
128: }
129:
130: public void testValidateCallbacks() {
131: CallbacksBean.clearExecuteCallbacks();
132:
133: CallbacksBean bean = new CallbacksBean();
134:
135: bean.setTestString("This is my test string");
136:
137: mCallbacksManager.validate(bean);
138: assertEquals("beforeValidate -1;This is my test string\n"
139: + "afterValidate -1;This is my test string",
140: StringUtils.join(CallbacksBean.getExecutedCallbacks(),
141: "\n"));
142:
143: CallbacksBean.clearExecuteCallbacks();
144: assertEquals("", StringUtils.join(CallbacksBean
145: .getExecutedCallbacks(), "\n"));
146:
147: bean.setTestString("This is a new test string");
148:
149: mCallbacksManager.validate(bean);
150: assertEquals("beforeValidate -1;This is a new test string\n"
151: + "afterValidate -1;This is a new test string",
152: StringUtils.join(CallbacksBean.getExecutedCallbacks(),
153: "\n"));
154:
155: CallbacksBean.clearExecuteCallbacks();
156: assertEquals("", StringUtils.join(CallbacksBean
157: .getExecutedCallbacks(), "\n"));
158:
159: bean.setId(999999);
160: bean.setTestString("This is another test string");
161:
162: mCallbacksManager.validate(bean);
163: assertEquals(
164: "beforeValidate 999999;This is another test string\n"
165: + "afterValidate 999999;This is another test string",
166: StringUtils.join(CallbacksBean.getExecutedCallbacks(),
167: "\n"));
168:
169: CallbacksBean.clearExecuteCallbacks();
170: }
171:
172: public void testValidateCallbacksReturns() {
173: CallbacksBean.clearExecuteCallbacks();
174:
175: CallbacksBean bean = new CallbacksBean();
176:
177: bean.setTestString("This is my test string");
178:
179: bean.setBeforeValidateReturn(false);
180: mCallbacksManager.validate(bean);
181: assertEquals("beforeValidate -1;This is my test string",
182: StringUtils.join(CallbacksBean.getExecutedCallbacks(),
183: "\n"));
184:
185: CallbacksBean.clearExecuteCallbacks();
186: assertEquals("", StringUtils.join(CallbacksBean
187: .getExecutedCallbacks(), "\n"));
188:
189: bean.setBeforeValidateReturn(true);
190: bean.setAfterValidateReturn(false);
191: mCallbacksManager.validate(bean);
192: assertEquals("beforeValidate -1;This is my test string\n"
193: + "afterValidate -1;This is my test string",
194: StringUtils.join(CallbacksBean.getExecutedCallbacks(),
195: "\n"));
196:
197: CallbacksBean.clearExecuteCallbacks();
198: }
199:
200: public void testSaveCallbacks() {
201: CallbacksBean.clearExecuteCallbacks();
202:
203: CallbacksBean bean = new CallbacksBean();
204:
205: bean.setTestString("This is my test string");
206:
207: int id = mCallbacksManager.save(bean);
208: assertEquals("beforeSave -1;This is my test string\n"
209: + "beforeInsert -1;This is my test string\n"
210: + "afterInsert true " + id
211: + ";This is my test string\n" + "afterSave true " + id
212: + ";This is my test string", StringUtils.join(
213: CallbacksBean.getExecutedCallbacks(), "\n"));
214:
215: CallbacksBean.clearExecuteCallbacks();
216: assertEquals("", StringUtils.join(CallbacksBean
217: .getExecutedCallbacks(), "\n"));
218:
219: bean.setTestString("This is a new test string");
220:
221: id = mCallbacksManager.save(bean);
222: assertEquals(
223: "beforeSave " + id + ";This is a new test string\n"
224: + "beforeUpdate " + id
225: + ";This is a new test string\n"
226: + "afterUpdate true " + id
227: + ";This is a new test string\n"
228: + "afterSave true " + id
229: + ";This is a new test string", StringUtils
230: .join(CallbacksBean.getExecutedCallbacks(),
231: "\n"));
232:
233: CallbacksBean.clearExecuteCallbacks();
234: assertEquals("", StringUtils.join(CallbacksBean
235: .getExecutedCallbacks(), "\n"));
236:
237: bean.setId(999999);
238: bean.setTestString("This is another test string");
239:
240: id = mCallbacksManager.save(bean);
241: assertEquals(
242: "beforeSave 999999;This is another test string\n"
243: + "beforeUpdate 999999;This is another test string\n"
244: + "afterUpdate false 999999;This is another test string\n"
245: + "beforeInsert 999999;This is another test string\n"
246: + "afterInsert true " + id
247: + ";This is another test string\n"
248: + "afterSave true " + id
249: + ";This is another test string", StringUtils
250: .join(CallbacksBean.getExecutedCallbacks(),
251: "\n"));
252: }
253:
254: public void testSaveCallbacksReturns() {
255: CallbacksBean.clearExecuteCallbacks();
256:
257: CallbacksBean bean = new CallbacksBean();
258:
259: bean.setTestString("This is my test string");
260:
261: // test immediate inserts
262: bean.setBeforeSaveReturn(false);
263: mCallbacksManager.save(bean);
264: assertEquals("beforeSave -1;This is my test string",
265: StringUtils.join(CallbacksBean.getExecutedCallbacks(),
266: "\n"));
267: assertNull(mCallbacksManager.restore(1));
268:
269: CallbacksBean.clearExecuteCallbacks();
270: assertEquals("", StringUtils.join(CallbacksBean
271: .getExecutedCallbacks(), "\n"));
272:
273: bean.setBeforeSaveReturn(true);
274: bean.setBeforeInsertReturn(false);
275: mCallbacksManager.save(bean);
276: assertEquals("beforeSave -1;This is my test string\n"
277: + "beforeInsert -1;This is my test string", StringUtils
278: .join(CallbacksBean.getExecutedCallbacks(), "\n"));
279: assertNull(mCallbacksManager.restore(1));
280:
281: CallbacksBean.clearExecuteCallbacks();
282: assertEquals("", StringUtils.join(CallbacksBean
283: .getExecutedCallbacks(), "\n"));
284:
285: bean.setBeforeInsertReturn(true);
286: bean.setAfterInsertReturn(false);
287: int id = mCallbacksManager.save(bean);
288: assertEquals("beforeSave -1;This is my test string\n"
289: + "beforeInsert -1;This is my test string\n"
290: + "afterInsert true " + id + ";This is my test string",
291: StringUtils.join(CallbacksBean.getExecutedCallbacks(),
292: "\n"));
293: assertNotNull(mCallbacksManager.restore(id));
294:
295: // test updates
296: CallbacksBean.clearExecuteCallbacks();
297: assertEquals("", StringUtils.join(CallbacksBean
298: .getExecutedCallbacks(), "\n"));
299:
300: bean.setTestString("This is a new test string");
301:
302: bean.setBeforeUpdateReturn(false);
303: bean.setAfterInsertReturn(true);
304: assertEquals(-1, mCallbacksManager.save(bean));
305: assertEquals("beforeSave " + id
306: + ";This is a new test string\n" + "beforeUpdate " + id
307: + ";This is a new test string", StringUtils.join(
308: CallbacksBean.getExecutedCallbacks(), "\n"));
309: assertEquals("This is my test string", mCallbacksManager
310: .restore(id).getTestString());
311:
312: CallbacksBean.clearExecuteCallbacks();
313: assertEquals("", StringUtils.join(CallbacksBean
314: .getExecutedCallbacks(), "\n"));
315:
316: bean.setBeforeUpdateReturn(true);
317: bean.setAfterUpdateReturn(false);
318: assertEquals(id, mCallbacksManager.save(bean));
319: assertEquals("beforeSave " + id
320: + ";This is a new test string\n" + "beforeUpdate " + id
321: + ";This is a new test string\n" + "afterUpdate true "
322: + id + ";This is a new test string", StringUtils.join(
323: CallbacksBean.getExecutedCallbacks(), "\n"));
324: assertEquals("This is a new test string", mCallbacksManager
325: .restore(id).getTestString());
326:
327: // test insert after failed update
328: CallbacksBean.clearExecuteCallbacks();
329: assertEquals("", StringUtils.join(CallbacksBean
330: .getExecutedCallbacks(), "\n"));
331:
332: bean.setId(999999);
333: bean.setTestString("This is another test string");
334:
335: bean.setAfterUpdateReturn(true);
336: bean.setBeforeInsertReturn(false);
337:
338: assertEquals(-1, mCallbacksManager.save(bean));
339: assertEquals(
340: "beforeSave 999999;This is another test string\n"
341: + "beforeUpdate 999999;This is another test string\n"
342: + "afterUpdate false 999999;This is another test string\n"
343: + "beforeInsert 999999;This is another test string",
344: StringUtils.join(CallbacksBean.getExecutedCallbacks(),
345: "\n"));
346: assertNull(mCallbacksManager.restore(999999));
347: CallbacksBean.clearExecuteCallbacks();
348: assertEquals("", StringUtils.join(CallbacksBean
349: .getExecutedCallbacks(), "\n"));
350:
351: bean.setBeforeInsertReturn(true);
352: bean.setAfterInsertReturn(false);
353:
354: assertEquals(id + 1, mCallbacksManager.save(bean));
355: id = id + 1;
356: assertEquals(
357: "beforeSave 999999;This is another test string\n"
358: + "beforeUpdate 999999;This is another test string\n"
359: + "afterUpdate false 999999;This is another test string\n"
360: + "beforeInsert 999999;This is another test string\n"
361: + "afterInsert true " + id
362: + ";This is another test string", StringUtils
363: .join(CallbacksBean.getExecutedCallbacks(),
364: "\n"));
365: assertNotNull(mCallbacksManager.restore(id));
366: }
367:
368: public void testSaveCallbacksSparse() {
369: CallbacksSparseBean bean = new CallbacksSparseBean();
370:
371: bean.setId(1000);
372: bean.setTestString("Test String");
373:
374: int id = mCallbacksSparseManager.save(bean);
375: assertEquals("beforeSave " + id + ";Test String\n"
376: + "beforeInsert " + id + ";Test String\n"
377: + "afterInsert true " + id + ";Test String\n"
378: + "afterSave true " + id + ";Test String", StringUtils
379: .join(bean.getExecutedCallbacks(), "\n"));
380:
381: bean.clearExecuteCallbacks();
382: assertEquals("", StringUtils.join(bean.getExecutedCallbacks(),
383: "\n"));
384:
385: bean.setTestString("This is a new test string");
386:
387: id = mCallbacksSparseManager.save(bean);
388: assertEquals("beforeSave " + id
389: + ";This is a new test string\n" + "beforeInsert " + id
390: + ";This is a new test string\n" + "afterInsert false "
391: + id + ";This is a new test string\n" + "beforeUpdate "
392: + id + ";This is a new test string\n"
393: + "afterUpdate true " + id
394: + ";This is a new test string\n" + "afterSave true "
395: + id + ";This is a new test string", StringUtils.join(
396: bean.getExecutedCallbacks(), "\n"));
397: }
398:
399: public void testSaveCallbacksSparseReturns() {
400: CallbacksSparseBean bean = new CallbacksSparseBean();
401:
402: bean.setId(1000);
403: bean.setTestString("Test String");
404:
405: int id = 1000;
406:
407: // test immediate insert
408: bean.setBeforeSaveReturn(false);
409: assertEquals(-1, mCallbacksSparseManager.save(bean));
410: assertEquals("beforeSave " + id + ";Test String", StringUtils
411: .join(bean.getExecutedCallbacks(), "\n"));
412:
413: bean.clearExecuteCallbacks();
414: assertEquals("", StringUtils.join(bean.getExecutedCallbacks(),
415: "\n"));
416:
417: bean.setBeforeSaveReturn(true);
418: bean.setBeforeInsertReturn(false);
419:
420: assertEquals(-1, mCallbacksSparseManager.save(bean));
421: assertEquals("beforeSave " + id + ";Test String\n"
422: + "beforeInsert " + id + ";Test String", StringUtils
423: .join(bean.getExecutedCallbacks(), "\n"));
424:
425: bean.clearExecuteCallbacks();
426: assertEquals("", StringUtils.join(bean.getExecutedCallbacks(),
427: "\n"));
428:
429: bean.setBeforeInsertReturn(true);
430: bean.setAfterInsertReturn(false);
431:
432: assertEquals(id, mCallbacksSparseManager.save(bean));
433: assertEquals("beforeSave " + id + ";Test String\n"
434: + "beforeInsert " + id + ";Test String\n"
435: + "afterInsert true " + id + ";Test String",
436: StringUtils.join(bean.getExecutedCallbacks(), "\n"));
437:
438: bean.clearExecuteCallbacks();
439: assertEquals("", StringUtils.join(bean.getExecutedCallbacks(),
440: "\n"));
441:
442: // test update after failed insert
443: bean.setTestString("This is a new test string");
444:
445: bean.clearExecuteCallbacks();
446: assertEquals("", StringUtils.join(bean.getExecutedCallbacks(),
447: "\n"));
448:
449: bean.setAfterInsertReturn(true);
450: bean.setBeforeUpdateReturn(false);
451:
452: assertEquals(-1, mCallbacksSparseManager.save(bean));
453: assertEquals("beforeSave " + id
454: + ";This is a new test string\n" + "beforeInsert " + id
455: + ";This is a new test string\n" + "afterInsert false "
456: + id + ";This is a new test string\n" + "beforeUpdate "
457: + id + ";This is a new test string", StringUtils.join(
458: bean.getExecutedCallbacks(), "\n"));
459:
460: bean.clearExecuteCallbacks();
461: assertEquals("", StringUtils.join(bean.getExecutedCallbacks(),
462: "\n"));
463:
464: bean.setBeforeUpdateReturn(true);
465: bean.setAfterUpdateReturn(false);
466:
467: assertEquals(id, mCallbacksSparseManager.save(bean));
468: assertEquals("beforeSave " + id
469: + ";This is a new test string\n" + "beforeInsert " + id
470: + ";This is a new test string\n" + "afterInsert false "
471: + id + ";This is a new test string\n" + "beforeUpdate "
472: + id + ";This is a new test string\n"
473: + "afterUpdate true " + id
474: + ";This is a new test string", StringUtils.join(bean
475: .getExecutedCallbacks(), "\n"));
476: }
477:
478: public void testSaveListeners() {
479: CallbacksBean.clearExecuteCallbacks();
480:
481: AggregatingCallbacksBeanListener listener = new AggregatingCallbacksBeanListener();
482: mCallbacksManager.addListener(listener);
483: try {
484: CallbacksBean bean = new CallbacksBean();
485:
486: bean.setTestString("This is my test string");
487:
488: int id = mCallbacksManager.save(bean);
489: Map<String, Object> history = listener.getHistory();
490: assertEquals(1, history.size());
491: Map.Entry<String, Object> entry = history.entrySet()
492: .iterator().next();
493: assertEquals("inserted0", entry.getKey());
494: assertSame(bean, entry.getValue());
495: assertEquals("beforeSave -1;This is my test string\n"
496: + "beforeInsert -1;This is my test string\n"
497: + "afterInsert true " + id + ";listener inserted\n"
498: + "afterSave true " + id + ";listener inserted",
499: StringUtils.join(CallbacksBean
500: .getExecutedCallbacks(), "\n"));
501:
502: CallbacksBean.clearExecuteCallbacks();
503: listener.clearHistory();
504: assertEquals("", StringUtils.join(CallbacksBean
505: .getExecutedCallbacks(), "\n"));
506:
507: bean.setTestString("This is a new test string");
508:
509: id = mCallbacksManager.save(bean);
510: assertEquals(1, history.size());
511: entry = history.entrySet().iterator().next();
512: assertEquals("updated0", entry.getKey());
513: assertSame(bean, entry.getValue());
514: assertEquals("beforeSave " + id
515: + ";This is a new test string\n" + "beforeUpdate "
516: + id + ";This is a new test string\n"
517: + "afterUpdate true " + id + ";listener updated\n"
518: + "afterSave true " + id + ";listener updated",
519: StringUtils.join(CallbacksBean
520: .getExecutedCallbacks(), "\n"));
521:
522: CallbacksBean.clearExecuteCallbacks();
523: listener.clearHistory();
524: assertEquals("", StringUtils.join(CallbacksBean
525: .getExecutedCallbacks(), "\n"));
526:
527: bean.setId(999999);
528: bean.setTestString("This is another test string");
529:
530: id = mCallbacksManager.save(bean);
531: assertEquals(1, history.size());
532: entry = history.entrySet().iterator().next();
533: assertEquals("inserted0", entry.getKey());
534: assertSame(bean, entry.getValue());
535: assertEquals(
536: "beforeSave 999999;This is another test string\n"
537: + "beforeUpdate 999999;This is another test string\n"
538: + "afterUpdate false 999999;This is another test string\n"
539: + "beforeInsert 999999;This is another test string\n"
540: + "afterInsert true " + id
541: + ";listener inserted\n"
542: + "afterSave true " + id
543: + ";listener inserted", StringUtils.join(
544: CallbacksBean.getExecutedCallbacks(), "\n"));
545: } finally {
546: mCallbacksManager.removeListeners();
547: }
548: }
549:
550: public void testInsertCallbacks() {
551: CallbacksBean.clearExecuteCallbacks();
552:
553: CallbacksBean bean = new CallbacksBean();
554:
555: bean.setTestString("This is my test string");
556:
557: int id = mCallbacksManager.insert(bean);
558: assertEquals("beforeInsert -1;This is my test string\n"
559: + "afterInsert true " + id + ";This is my test string",
560: StringUtils.join(CallbacksBean.getExecutedCallbacks(),
561: "\n"));
562: }
563:
564: public void testInsertCallbacksReturns() {
565: CallbacksBean.clearExecuteCallbacks();
566:
567: CallbacksBean bean = new CallbacksBean();
568:
569: bean.setTestString("This is my test string");
570:
571: bean.setBeforeInsertReturn(false);
572: mCallbacksManager.insert(bean);
573: assertEquals("beforeInsert -1;This is my test string",
574: StringUtils.join(CallbacksBean.getExecutedCallbacks(),
575: "\n"));
576:
577: assertNull(mCallbacksManager.restore(1));
578: }
579:
580: public void testUpdateCallbacks() {
581: CallbacksBean.clearExecuteCallbacks();
582:
583: CallbacksBean bean = new CallbacksBean();
584:
585: bean.setTestString("This is my test string");
586:
587: mCallbacksManager.update(bean);
588: assertEquals("beforeUpdate -1;This is my test string\n"
589: + "afterUpdate false -1;This is my test string",
590: StringUtils.join(CallbacksBean.getExecutedCallbacks(),
591: "\n"));
592:
593: int id = mCallbacksManager.insert(bean);
594: CallbacksBean.clearExecuteCallbacks();
595: assertEquals("", StringUtils.join(CallbacksBean
596: .getExecutedCallbacks(), "\n"));
597:
598: bean.setTestString("This is a new test string");
599:
600: mCallbacksManager.update(bean);
601: assertEquals("beforeUpdate " + id
602: + ";This is a new test string\n" + "afterUpdate true "
603: + id + ";This is a new test string", StringUtils.join(
604: CallbacksBean.getExecutedCallbacks(), "\n"));
605: }
606:
607: public void testUpdateCallbacksReturns() {
608: CallbacksBean.clearExecuteCallbacks();
609:
610: CallbacksBean bean = new CallbacksBean();
611: bean.setTestString("This is my test string");
612:
613: int id = mCallbacksManager.insert(bean);
614: CallbacksBean.clearExecuteCallbacks();
615: assertEquals("", StringUtils.join(CallbacksBean
616: .getExecutedCallbacks(), "\n"));
617:
618: bean.setTestString("This is a new test string");
619:
620: bean.setBeforeUpdateReturn(false);
621: mCallbacksManager.update(bean);
622: assertEquals("beforeUpdate " + id
623: + ";This is a new test string", StringUtils.join(
624: CallbacksBean.getExecutedCallbacks(), "\n"));
625:
626: assertEquals("This is my test string", mCallbacksManager
627: .restore(id).getTestString());
628: }
629:
630: public void testDeleteCallbacks() {
631: CallbacksBean.clearExecuteCallbacks();
632:
633: CallbacksBean bean = new CallbacksBean();
634:
635: bean.setTestString("This is my test string");
636:
637: int id = mCallbacksManager.save(bean);
638:
639: CallbacksBean.clearExecuteCallbacks();
640: assertEquals("", StringUtils.join(CallbacksBean
641: .getExecutedCallbacks(), "\n"));
642:
643: mCallbacksManager.delete(id);
644: assertEquals("beforeDelete " + id + "\n" + "afterDelete true "
645: + id + "", StringUtils.join(CallbacksBean
646: .getExecutedCallbacks(), "\n"));
647: }
648:
649: public void testDeleteCallbacksReturns() {
650: CallbacksBean.clearExecuteCallbacks();
651:
652: CallbacksBean bean = new CallbacksBean();
653:
654: bean.setTestString("This is my test string");
655:
656: int id = mCallbacksManager.save(bean);
657:
658: CallbacksBean.clearExecuteCallbacks();
659: assertEquals("", StringUtils.join(CallbacksBean
660: .getExecutedCallbacks(), "\n"));
661:
662: CallbacksBean.setBeforeDeleteReturn(false);
663: mCallbacksManager.delete(id);
664: assertEquals("beforeDelete " + id + "", StringUtils.join(
665: CallbacksBean.getExecutedCallbacks(), "\n"));
666:
667: assertNotNull(mCallbacksManager.restore(id));
668:
669: CallbacksBean.setBeforeDeleteReturn(true);
670: }
671:
672: public void testDeleteListeners() {
673: CallbacksBean.clearExecuteCallbacks();
674:
675: CallbacksBean bean = new CallbacksBean();
676:
677: bean.setTestString("This is my test string");
678:
679: int id = mCallbacksManager.save(bean);
680:
681: CallbacksBean.clearExecuteCallbacks();
682: assertEquals("", StringUtils.join(CallbacksBean
683: .getExecutedCallbacks(), "\n"));
684:
685: AggregatingCallbacksBeanListener listener = new AggregatingCallbacksBeanListener();
686: try {
687: mCallbacksManager.addListener(listener);
688: mCallbacksManager.delete(id);
689: Map<String, Object> history = listener.getHistory();
690: assertEquals(1, history.size());
691: Map.Entry<String, Object> entry = history.entrySet()
692: .iterator().next();
693: assertEquals("deleted0", entry.getKey());
694: assertEquals(id, entry.getValue());
695: assertEquals("beforeDelete " + id + "\n"
696: + "afterDelete true " + id + "", StringUtils.join(
697: CallbacksBean.getExecutedCallbacks(), "\n"));
698: } finally {
699: mCallbacksManager.removeListeners();
700: }
701: }
702:
703: public void testRestoreCallbacks() {
704: CallbacksBean.clearExecuteCallbacks();
705:
706: CallbacksBean bean1 = new CallbacksBean();
707: CallbacksBean bean2 = new CallbacksBean();
708: CallbacksBean bean3 = new CallbacksBean();
709:
710: bean1.setTestString("This is bean1");
711: bean2.setTestString("This is bean2");
712: bean3.setTestString("This is bean3");
713:
714: int id1 = mCallbacksManager.save(bean1);
715: int id2 = mCallbacksManager.save(bean2);
716: int id3 = mCallbacksManager.save(bean3);
717:
718: CallbacksBean.clearExecuteCallbacks();
719:
720: // restore all beans
721: assertEquals(3, mCallbacksManager.restore(
722: mCallbacksManager.getRestoreQuery().orderBy("id"))
723: .size());
724:
725: assertEquals("afterRestore " + id1 + ";This is bean1\n"
726: + "afterRestore " + id2 + ";This is bean2\n"
727: + "afterRestore " + id3 + ";This is bean3", StringUtils
728: .join(CallbacksBean.getExecutedCallbacks(), "\n"));
729:
730: CallbacksBean.clearExecuteCallbacks();
731: assertEquals("", StringUtils.join(CallbacksBean
732: .getExecutedCallbacks(), "\n"));
733:
734: // restore a specific bean
735: mCallbacksManager.restore(bean2.getId());
736:
737: assertEquals("afterRestore " + id2 + ";This is bean2",
738: StringUtils.join(CallbacksBean.getExecutedCallbacks(),
739: "\n"));
740:
741: CallbacksBean.clearExecuteCallbacks();
742: assertEquals("", StringUtils.join(CallbacksBean
743: .getExecutedCallbacks(), "\n"));
744:
745: // restore the first bean
746: mCallbacksManager.restoreFirst(mCallbacksManager
747: .getRestoreQuery().orderBy("id"));
748:
749: assertEquals("afterRestore " + id1 + ";This is bean1",
750: StringUtils.join(CallbacksBean.getExecutedCallbacks(),
751: "\n"));
752:
753: CallbacksBean.clearExecuteCallbacks();
754: CallbacksBean.setAfterRestoreReturn(true);
755: }
756:
757: public void testRestoreCallbacksReturns() {
758: CallbacksBean.clearExecuteCallbacks();
759:
760: CallbacksBean bean1 = new CallbacksBean();
761: CallbacksBean bean2 = new CallbacksBean();
762: CallbacksBean bean3 = new CallbacksBean();
763:
764: bean1.setTestString("This is bean1");
765: bean2.setTestString("This is bean2");
766: bean3.setTestString("This is bean3");
767:
768: int id = mCallbacksManager.save(bean1);
769: mCallbacksManager.save(bean2);
770: mCallbacksManager.save(bean3);
771:
772: CallbacksBean.clearExecuteCallbacks();
773: CallbacksBean.setAfterRestoreReturn(false);
774:
775: assertEquals(1, mCallbacksManager.restore(
776: mCallbacksManager.getRestoreQuery().orderBy("id"))
777: .size());
778:
779: assertEquals("afterRestore " + id + ";This is bean1",
780: StringUtils.join(CallbacksBean.getExecutedCallbacks(),
781: "\n"));
782:
783: CallbacksBean.setAfterRestoreReturn(true);
784: }
785:
786: public void testRestoreListeners() {
787: CallbacksBean.clearExecuteCallbacks();
788:
789: CallbacksBean bean1 = new CallbacksBean();
790: CallbacksBean bean2 = new CallbacksBean();
791: CallbacksBean bean3 = new CallbacksBean();
792:
793: bean1.setTestString("This is bean1");
794: bean2.setTestString("This is bean2");
795: bean3.setTestString("This is bean3");
796:
797: int id1 = mCallbacksManager.save(bean1);
798: int id2 = mCallbacksManager.save(bean2);
799: int id3 = mCallbacksManager.save(bean3);
800:
801: CallbacksBean.clearExecuteCallbacks();
802:
803: AggregatingCallbacksBeanListener listener = new AggregatingCallbacksBeanListener();
804: mCallbacksManager.addListener(listener);
805: try {
806: // restore all beans
807: List<CallbacksBean> restored = mCallbacksManager
808: .restore(mCallbacksManager.getRestoreQuery()
809: .orderBy("id"));
810: assertEquals(3, restored.size());
811:
812: Map<String, Object> history;
813: Iterator<Map.Entry<String, Object>> it;
814: Map.Entry<String, Object> entry;
815:
816: history = listener.getHistory();
817: assertEquals(3, history.size());
818: it = history.entrySet().iterator();
819: entry = it.next();
820: assertEquals("restored0", entry.getKey());
821: assertSame(restored.get(0), entry.getValue());
822: entry = it.next();
823: assertEquals("restored1", entry.getKey());
824: assertSame(restored.get(1), entry.getValue());
825: entry = it.next();
826: assertEquals("restored2", entry.getKey());
827: assertSame(restored.get(2), entry.getValue());
828: assertEquals("afterRestore " + id1 + ";listener restored\n"
829: + "afterRestore " + id2 + ";listener restored\n"
830: + "afterRestore " + id3 + ";listener restored",
831: StringUtils.join(CallbacksBean
832: .getExecutedCallbacks(), "\n"));
833:
834: CallbacksBean.clearExecuteCallbacks();
835: listener.clearHistory();
836: assertEquals("", StringUtils.join(CallbacksBean
837: .getExecutedCallbacks(), "\n"));
838:
839: // restore a specific bean
840: CallbacksBean restored_specific = mCallbacksManager
841: .restore(bean2.getId());
842:
843: history = listener.getHistory();
844: assertEquals(1, history.size());
845: it = history.entrySet().iterator();
846: entry = it.next();
847: assertEquals("restored0", entry.getKey());
848: assertSame(restored_specific, entry.getValue());
849: assertEquals("afterRestore " + id2 + ";listener restored",
850: StringUtils.join(CallbacksBean
851: .getExecutedCallbacks(), "\n"));
852:
853: CallbacksBean.clearExecuteCallbacks();
854: listener.clearHistory();
855: assertEquals("", StringUtils.join(CallbacksBean
856: .getExecutedCallbacks(), "\n"));
857:
858: // restore the first bean
859: CallbacksBean restored_first = mCallbacksManager
860: .restoreFirst(mCallbacksManager.getRestoreQuery()
861: .orderBy("id"));
862:
863: history = listener.getHistory();
864: assertEquals(1, history.size());
865: it = history.entrySet().iterator();
866: entry = it.next();
867: assertEquals("restored0", entry.getKey());
868: assertSame(restored_first, entry.getValue());
869: assertEquals("afterRestore " + id1 + ";listener restored",
870: StringUtils.join(CallbacksBean
871: .getExecutedCallbacks(), "\n"));
872:
873: CallbacksBean.clearExecuteCallbacks();
874: listener.clearHistory();
875: CallbacksBean.setAfterRestoreReturn(true);
876: } finally {
877: mCallbacksManager.removeListeners();
878: }
879: }
880:
881: public void testCallbacksProvider() {
882: CallbacksProviderBean.clearExecuteCallbacks();
883:
884: CallbacksProviderBean bean = new CallbacksProviderBean();
885: CallbacksProviderBean newbean = null;
886:
887: bean.setTestString("This is my test string");
888:
889: int id1 = mCallbacksProviderManager.save(bean);
890:
891: newbean = mCallbacksProviderManager.restore(id1);
892:
893: assertTrue(newbean != null);
894: assertTrue(newbean != bean);
895: assertEquals(newbean.getTestString(), bean.getTestString());
896: assertEquals(newbean.getId(), id1);
897:
898: bean.setId(id1);
899: bean.setTestString("This is a new test string");
900:
901: assertEquals(mCallbacksProviderManager.save(bean), id1);
902: assertEquals(bean.getId(), id1);
903:
904: newbean = mCallbacksProviderManager.restore(id1);
905:
906: assertTrue(newbean != null);
907: assertTrue(newbean != bean);
908:
909: assertEquals(newbean.getTestString(),
910: "This is a new test string");
911:
912: bean.setId(999999);
913: bean.setTestString("This is another test string");
914:
915: int id2 = id1 + 1;
916:
917: assertEquals(id2, mCallbacksProviderManager.save(bean));
918: assertFalse(999999 == id2);
919: assertEquals(bean.getId(), id1 + 1);
920:
921: bean.setId(76876);
922: bean.setTestString("This is a last test string");
923:
924: int id3 = id2 + 1;
925: assertEquals(id3, mCallbacksProviderManager.insert(bean));
926:
927: bean.setTestString("This is an updated test string");
928: assertEquals(id3, mCallbacksProviderManager.update(bean));
929:
930: assertTrue(mCallbacksProviderManager.delete(id2));
931: assertEquals(2, mCallbacksProviderManager.restore().size());
932:
933: assertEquals(
934: "beforeSave -1;This is my test string\n"
935: + "beforeInsert -1;This is my test string\n"
936: + "afterInsert true "
937: + id1
938: + ";This is my test string\n"
939: + "afterSave true "
940: + id1
941: + ";This is my test string\n"
942: + "afterRestore "
943: + id1
944: + ";This is my test string\n"
945: + "beforeSave "
946: + id1
947: + ";This is a new test string\n"
948: + "beforeUpdate "
949: + id1
950: + ";This is a new test string\n"
951: + "afterUpdate true "
952: + id1
953: + ";This is a new test string\n"
954: + "afterSave true "
955: + id1
956: + ";This is a new test string\n"
957: + "afterRestore "
958: + id1
959: + ";This is a new test string\n"
960: + "beforeSave 999999;This is another test string\n"
961: + "beforeUpdate 999999;This is another test string\n"
962: + "afterUpdate false 999999;This is another test string\n"
963: + "beforeInsert 999999;This is another test string\n"
964: + "afterInsert true "
965: + id2
966: + ";This is another test string\n"
967: + "afterSave true "
968: + id2
969: + ";This is another test string\n"
970: + "beforeInsert 76876;This is a last test string\n"
971: + "afterInsert true "
972: + id3
973: + ";This is a last test string\n"
974: + "beforeUpdate "
975: + id3
976: + ";This is an updated test string\n"
977: + "afterUpdate true "
978: + id3
979: + ";This is an updated test string\n"
980: + "beforeDelete "
981: + id2
982: + "\n"
983: + "afterDelete true "
984: + id2
985: + "\n"
986: + "afterRestore "
987: + id1
988: + ";This is a new test string\n"
989: + "afterRestore "
990: + id3
991: + ";This is an updated test string",
992: StringUtils.join(CallbacksProviderBean
993: .getExecutedCallbacks(), "\n"));
994: }
995: }
|