001: package org.apache.ojb.broker;
002:
003: import org.apache.commons.lang.builder.ToStringBuilder;
004: import org.apache.ojb.junit.PBTestCase;
005: import org.apache.ojb.broker.query.Criteria;
006: import org.apache.ojb.broker.query.QueryByCriteria;
007: import org.apache.ojb.broker.query.QueryFactory;
008:
009: import java.io.Serializable;
010: import java.util.List;
011: import java.util.ArrayList;
012: import java.util.Collection;
013: import java.util.Iterator;
014:
015: /**
016: * This TestClass tests OJB facilities to work with persistence
017: * aware instances.
018: */
019: public class PBListenerTest extends PBTestCase {
020: public static void main(String[] args) {
021: String[] arr = { PBListenerTest.class.getName() };
022: junit.textui.TestRunner.main(arr);
023: }
024:
025: public PBListenerTest(String name) {
026: super (name);
027: }
028:
029: /**
030: * Test for OJB-68
031: * tests the callbacks beforeStore() and afterStore().
032: */
033: public void testStoreAndQuery() throws Exception {
034: String name = "testStoreAndQuery_" + System.currentTimeMillis();
035:
036: PBAwareObject pba_1 = new PBAwareObject(name);
037: pba_1.setRefObject(new RefObj(name));
038: pba_1.addCollObject(new CollObj(name));
039: pba_1.addCollObject(new CollObj(name));
040: pba_1.addCollObject(new CollObj(name));
041:
042: PBAwareObject pba_2 = new PBAwareObject(name);
043: pba_2.setRefObject(new RefObj(name));
044: pba_2.addCollObject(new CollObj(name));
045: pba_2.addCollObject(new CollObj(name));
046: pba_2.addCollObject(new CollObj(name));
047:
048: PBAwareObject pba_3 = new PBAwareObject(name);
049: pba_3.setRefObject(new RefObj(name));
050: pba_3.addCollObject(new CollObj(name));
051: pba_3.addCollObject(new CollObj(name));
052: pba_3.addCollObject(new CollObj(name));
053:
054: broker.beginTransaction();
055: broker.store(pba_1);
056: broker.store(pba_2);
057: broker.store(pba_3);
058: broker.commitTransaction();
059:
060: Identity oid_1 = broker.serviceIdentity().buildIdentity(pba_1);
061: Identity oid_2 = broker.serviceIdentity().buildIdentity(pba_2);
062:
063: broker.clearCache();
064:
065: PBAwareObject pba_1_new = (PBAwareObject) broker
066: .getObjectByIdentity(oid_1);
067: PBAwareObject pba_2_new = (PBAwareObject) broker
068: .getObjectByIdentity(oid_2);
069:
070: assertNotNull(pba_1_new);
071: assertNotNull(pba_2_new);
072: assertNotNull(pba_1_new.getRefObject());
073: assertNotNull(pba_2_new.getRefObject());
074: assertEquals(3, pba_1_new.getCollObjects().size());
075: assertEquals(3, pba_2_new.getCollObjects().size());
076: assertTrue(pba_1_new.isAfterLookupRefObjectPopulated());
077: assertTrue(pba_1_new.isAfterLookupCollObjectsPopulated());
078: assertTrue(pba_2_new.isAfterLookupRefObjectPopulated());
079: assertTrue(pba_2_new.isAfterLookupCollObjectsPopulated());
080:
081: broker.clearCache();
082:
083: Criteria criteria = new Criteria();
084: criteria.addEqualTo("name", name);
085: QueryByCriteria query = QueryFactory.newQuery(
086: PBAwareObject.class, criteria);
087: Collection result = broker.getCollectionByQuery(query);
088: assertEquals(3, result.size());
089: for (Iterator iterator = result.iterator(); iterator.hasNext();) {
090: PBAwareObject pba = (PBAwareObject) iterator.next();
091: assertNotNull(pba);
092: assertNotNull(pba.getRefObject());
093: assertEquals(3, pba.getCollObjects().size());
094: assertTrue(pba.isAfterLookupRefObjectPopulated());
095: assertTrue(pba.isAfterLookupCollObjectsPopulated());
096: }
097: }
098:
099: /**
100: * tests the callbacks beforeStore() and afterStore().
101: */
102: public void testStoreCallbacks() throws Exception {
103: PBAwareObject obj = new PBAwareObject();
104: assertEquals(false, obj.getCalledBeforeUpdate());
105: assertEquals(false, obj.getCalledAfterUpdate());
106: assertEquals(false, obj.getCalledBeforeStore());
107: assertEquals(false, obj.getCalledAfterStore());
108: broker.beginTransaction();
109: broker.store(obj);
110: assertEquals(true, obj.getCalledBeforeStore());
111: assertEquals(true, obj.getCalledAfterStore());
112: assertEquals(false, obj.getCalledBeforeUpdate());
113: assertEquals(false, obj.getCalledAfterUpdate());
114: broker.commitTransaction();
115: }
116:
117: /**
118: * tests the callbacks beforeStore() and afterStore().
119: */
120: public void testUpdateCallbacks() throws Exception {
121: PBAwareObject obj = new PBAwareObject();
122: broker.beginTransaction();
123: broker.store(obj);
124: broker.commitTransaction();
125: Identity oid = new Identity(obj, broker);
126:
127: PBAwareObject lookedUp = (PBAwareObject) broker
128: .getObjectByIdentity(oid);
129: lookedUp.setName("testUpdateCallbacks");
130: assertEquals(false, obj.getCalledBeforeUpdate());
131: assertEquals(false, obj.getCalledAfterUpdate());
132: broker.beginTransaction();
133: broker.store(lookedUp);
134: broker.commitTransaction();
135: assertEquals(true, lookedUp.getCalledBeforeUpdate());
136: assertEquals(true, lookedUp.getCalledAfterUpdate());
137: }
138:
139: /**
140: * tests the callbacks beforeDelete() and afterDelete().
141: */
142: public void testDeleteCallbacks() throws Exception {
143: PBAwareObject obj = new PBAwareObject();
144: broker.beginTransaction();
145: broker.store(obj);
146: broker.commitTransaction();
147:
148: assertEquals(false, obj.getCalledBeforeDelete());
149: assertEquals(false, obj.getCalledAfterDelete());
150: broker.beginTransaction();
151: broker.delete(obj);
152: assertEquals(true, obj.getCalledBeforeDelete());
153: assertEquals(true, obj.getCalledAfterDelete());
154: broker.commitTransaction();
155: }
156:
157: /**
158: * tests the callback afterLookup()
159: */
160: public void testLookupCallback() throws Exception {
161: PBAwareObject obj = new PBAwareObject();
162: Identity oid = new Identity(obj, broker);
163: broker.beginTransaction();
164: broker.store(obj);
165: broker.commitTransaction();
166: assertEquals(false, obj.getCalledAfterLookup());
167:
168: PBAwareObject lookedUp = (PBAwareObject) broker
169: .getObjectByIdentity(oid);
170:
171: assertEquals(true, lookedUp.getCalledAfterLookup());
172: }
173:
174: public void testLifeCycleListener() {
175: PBAwareObject obj = new PBAwareObject();
176: obj.setName("testLifeCycleListener");
177: Identity oid = new Identity(obj, broker);
178:
179: // now we add the listener
180: PBLifeCycleListenerObject listener = new PBLifeCycleListenerObject();
181: broker.addListener(listener);
182:
183: broker.beginTransaction();
184: broker.store(obj);
185: assertEquals("insert listener call failed", 6, listener
186: .evaluateTest());
187: broker.commitTransaction();
188:
189: broker.clearCache();
190: PBAwareObject lookedUp = (PBAwareObject) broker
191: .getObjectByIdentity(oid);
192: assertEquals("lookup listener call failed", 30, listener
193: .evaluateTest());
194: lookedUp.setName("testLifeCycleListener_updated");
195: broker.beginTransaction();
196: broker.store(lookedUp);
197: assertEquals("update listener call failed", 2310, listener
198: .evaluateTest());
199: broker.commitTransaction();
200:
201: broker.beginTransaction();
202: broker.delete(obj);
203: assertEquals("delete listener call failed", 510510, listener
204: .evaluateTest());
205: broker.commitTransaction();
206: }
207:
208: public void testPBStateListener() {
209: // This test need its own broker instance
210: PersistenceBroker pb = PersistenceBrokerFactory
211: .defaultPersistenceBroker();
212: PBStateListenerObject listener;
213: PBStateListenerObject listener_2 = null;
214: try {
215: listener = new PBStateListenerObject();
216: pb.addListener(listener);
217:
218: // we could not check after open method
219: listener.afterOpen(new PBStateEvent(pb,
220: PBStateEvent.Type.AFTER_OPEN));
221: assertEquals("afterOpen listener call failed", 2, listener
222: .evaluateTest());
223:
224: pb.beginTransaction();
225: assertEquals("beforeBegin/afterBegin listener call failed",
226: 30, listener.evaluateTest());
227:
228: pb.commitTransaction();
229: assertEquals(
230: "beforeCommit/afterCommit listener call failed",
231: 2310, listener.evaluateTest());
232:
233: listener_2 = new PBStateListenerObject();
234: pb.addListener(listener_2);
235:
236: // we could not check after open method
237: listener_2.afterOpen(new PBStateEvent(pb,
238: PBStateEvent.Type.AFTER_OPEN));
239: assertEquals("afterOpen listener call failed", 2,
240: listener_2.evaluateTest());
241:
242: pb.beginTransaction();
243: assertEquals("beforeBegin/afterBegin listener call failed",
244: 30, listener_2.evaluateTest());
245:
246: pb.abortTransaction();
247: assertEquals(
248: "beforeRollback/afterRollback listener call failed",
249: 6630, listener_2.evaluateTest());
250: } finally {
251: pb.close();
252: if (listener_2 != null)
253: assertEquals("beforeClose listener call failed",
254: 125970, listener_2.evaluateTest());
255: else
256: fail("Something wrong with test");
257: }
258: }
259:
260: //************************************************************************
261: // test classes
262: //************************************************************************
263: public static class PBLifeCycleListenerObject implements
264: PBLifeCycleListener {
265: int beforeInsert = 1, afterInsert = 1, beforeUpdate = 1,
266: afterUpdate = 1, beforeDelete = 1, afterDelete = 1,
267: afterLookup = 1;
268:
269: public void beforeInsert(PBLifeCycleEvent event)
270: throws PersistenceBrokerException {
271: if (!(event.getTarget() instanceof PBAwareObject))
272: return;
273: beforeInsert *= 2;
274: }
275:
276: public void afterInsert(PBLifeCycleEvent event)
277: throws PersistenceBrokerException {
278: if (!(event.getTarget() instanceof PBAwareObject))
279: return;
280: afterInsert *= 3;
281: }
282:
283: public void afterLookup(PBLifeCycleEvent event)
284: throws PersistenceBrokerException {
285: if (!(event.getTarget() instanceof PBAwareObject))
286: return;
287: afterLookup *= 5;
288: }
289:
290: public void beforeUpdate(PBLifeCycleEvent event)
291: throws PersistenceBrokerException {
292: if (!(event.getTarget() instanceof PBAwareObject))
293: return;
294: beforeUpdate *= 7;
295: }
296:
297: public void afterUpdate(PBLifeCycleEvent event)
298: throws PersistenceBrokerException {
299: if (!(event.getTarget() instanceof PBAwareObject))
300: return;
301: afterUpdate *= 11;
302: }
303:
304: public void beforeDelete(PBLifeCycleEvent event)
305: throws PersistenceBrokerException {
306: if (!(event.getTarget() instanceof PBAwareObject))
307: return;
308: beforeDelete *= 13;
309: }
310:
311: public void afterDelete(PBLifeCycleEvent event)
312: throws PersistenceBrokerException {
313: if (!(event.getTarget() instanceof PBAwareObject))
314: return;
315: afterDelete *= 17;
316: }
317:
318: public int evaluateTest() {
319: return beforeInsert * afterInsert * beforeUpdate
320: * afterUpdate * beforeDelete * afterDelete
321: * afterLookup;
322: }
323: }
324:
325: public static class PBStateListenerObject implements
326: PBStateListener {
327: int afterOpen = 1, beforeBegin = 1, afterBegin = 1,
328: beforeCommit = 1, afterCommit = 1, beforeRollback = 1,
329: afterRollback = 1, beforeClose = 1;
330:
331: public void afterOpen(PBStateEvent event) {
332: afterOpen *= 2;
333: }
334:
335: public void beforeBegin(PBStateEvent event) {
336: beforeBegin *= 3;
337: }
338:
339: public void afterBegin(PBStateEvent event) {
340: afterBegin *= 5;
341: }
342:
343: public void beforeCommit(PBStateEvent event) {
344: beforeCommit *= 7;
345: }
346:
347: public void afterCommit(PBStateEvent event) {
348: afterCommit *= 11;
349: }
350:
351: public void beforeRollback(PBStateEvent event) {
352: beforeRollback *= 13;
353: }
354:
355: public void afterRollback(PBStateEvent event) {
356: afterRollback *= 17;
357: }
358:
359: public void beforeClose(PBStateEvent event) {
360: beforeClose *= 19;
361: }
362:
363: public int evaluateTest() {
364: return afterOpen * beforeBegin * afterBegin * beforeCommit
365: * afterCommit * beforeRollback * afterRollback
366: * beforeClose;
367: }
368: }
369:
370: /**
371: * persistence capable class
372: */
373: public static class PBAwareObject implements
374: PersistenceBrokerAware, Serializable {
375: private int id;
376: private String name;
377: private RefObj refObject;
378: private List collObjects;
379:
380: private boolean calledBeforeInsert = false;
381: private boolean calledAfterInsert = false;
382: private boolean calledBeforeDelete = false;
383: private boolean calledAfterDelete = false;
384: private boolean calledAfterLookup = false;
385: private boolean calledAfterUpdate = false;
386: private boolean calledBeforeUpdate = false;
387: private boolean afterLookupRefObjectPopulated = false;
388: private boolean afterLookupCollObjectsPopulated = false;
389:
390: public PBAwareObject() {
391: }
392:
393: public PBAwareObject(String name) {
394: this .name = name;
395: }
396:
397: public void beforeUpdate(PersistenceBroker broker)
398: throws PersistenceBrokerException {
399: calledBeforeUpdate = true;
400: }
401:
402: public void afterUpdate(PersistenceBroker broker)
403: throws PersistenceBrokerException {
404: calledAfterUpdate = true;
405: }
406:
407: public void beforeInsert(PersistenceBroker broker)
408: throws PersistenceBrokerException {
409: //System.out.println("beforeStore()");
410: calledBeforeInsert = true;
411: }
412:
413: public void afterInsert(PersistenceBroker broker)
414: throws PersistenceBrokerException {
415: //System.out.println("afterStore()");
416: if (calledBeforeInsert) {
417: calledAfterInsert = true;
418: }
419: }
420:
421: public void beforeDelete(PersistenceBroker broker)
422: throws PersistenceBrokerException {
423: //System.out.println("beforeDelete()");
424: calledBeforeDelete = true;
425: }
426:
427: public void afterDelete(PersistenceBroker broker)
428: throws PersistenceBrokerException {
429: //System.out.println("afterDelete()");
430: if (calledBeforeDelete) {
431: calledAfterDelete = true;
432: }
433: }
434:
435: public void afterLookup(PersistenceBroker broker)
436: throws PersistenceBrokerException {
437: //System.out.println("afterLookup()");
438: calledAfterLookup = true;
439: if (refObject != null)
440: afterLookupRefObjectPopulated = true;
441: if (collObjects != null)
442: afterLookupCollObjectsPopulated = true;
443: // System.out.println("## " + refObject);
444: // System.out.println("## " + collObjects);
445: // if(refObject == null)
446: // {
447: // try{throw new Exception();}catch(Exception e)
448: // {
449: // e.printStackTrace();
450: // }
451: // }
452: }
453:
454: public boolean getCalledAfterUpdate() {
455: return calledAfterUpdate;
456: }
457:
458: public void setCalledAfterUpdate(boolean calledAfterUpdate) {
459: this .calledAfterUpdate = calledAfterUpdate;
460: }
461:
462: public boolean getCalledBeforeUpdate() {
463: return calledBeforeUpdate;
464: }
465:
466: public void setCalledBeforeUpdate(boolean calledBeforeUpdate) {
467: this .calledBeforeUpdate = calledBeforeUpdate;
468: }
469:
470: public boolean getCalledAfterDelete() {
471: return calledAfterDelete;
472: }
473:
474: public void setCalledAfterDelete(boolean calledAfterDelete) {
475: this .calledAfterDelete = calledAfterDelete;
476: }
477:
478: public boolean getCalledAfterLookup() {
479: return calledAfterLookup;
480: }
481:
482: public void setCalledAfterLookup(boolean calledAfterLookup) {
483: this .calledAfterLookup = calledAfterLookup;
484: }
485:
486: public boolean getCalledAfterStore() {
487: return calledAfterInsert;
488: }
489:
490: public void setCalledAfterStore(boolean calledAfterStore) {
491: this .calledAfterInsert = calledAfterStore;
492: }
493:
494: public boolean getCalledBeforeDelete() {
495: return calledBeforeDelete;
496: }
497:
498: public void setCalledBeforeDelete(boolean calledBeforeDelete) {
499: this .calledBeforeDelete = calledBeforeDelete;
500: }
501:
502: public boolean getCalledBeforeStore() {
503: return calledBeforeInsert;
504: }
505:
506: public void setCalledBeforeStore(boolean calledBeforeStore) {
507: this .calledBeforeInsert = calledBeforeStore;
508: }
509:
510: public boolean isCalledBeforeInsert() {
511: return calledBeforeInsert;
512: }
513:
514: public void setCalledBeforeInsert(boolean calledBeforeInsert) {
515: this .calledBeforeInsert = calledBeforeInsert;
516: }
517:
518: public boolean isCalledAfterInsert() {
519: return calledAfterInsert;
520: }
521:
522: public void setCalledAfterInsert(boolean calledAfterInsert) {
523: this .calledAfterInsert = calledAfterInsert;
524: }
525:
526: public boolean isAfterLookupRefObjectPopulated() {
527: return afterLookupRefObjectPopulated;
528: }
529:
530: public void setAfterLookupRefObjectPopulated(
531: boolean afterLookupRefObjectPopulated) {
532: this .afterLookupRefObjectPopulated = afterLookupRefObjectPopulated;
533: }
534:
535: public boolean isAfterLookupCollObjectsPopulated() {
536: return afterLookupCollObjectsPopulated;
537: }
538:
539: public void setAfterLookupCollObjectsPopulated(
540: boolean afterLookupCollObjectsPopulated) {
541: this .afterLookupCollObjectsPopulated = afterLookupCollObjectsPopulated;
542: }
543:
544: public String getName() {
545: return name;
546: }
547:
548: public void setName(String name) {
549: this .name = name;
550: }
551:
552: public int getId() {
553: return id;
554: }
555:
556: public void setId(int id) {
557: this .id = id;
558: }
559:
560: public RefObj getRefObject() {
561: return refObject;
562: }
563:
564: public void setRefObject(RefObj refObj) {
565: this .refObject = refObj;
566: }
567:
568: public List getCollObjects() {
569: return collObjects;
570: }
571:
572: public void addCollObject(CollObj obj) {
573: if (collObjects == null) {
574: collObjects = new ArrayList();
575: }
576: collObjects.add(obj);
577: }
578:
579: public void setCollObjects(List collObjects) {
580: this .collObjects = collObjects;
581: }
582:
583: public String toString() {
584: return ToStringBuilder.reflectionToString(this );
585: }
586: }
587:
588: public static class RefObj implements Serializable {
589: private Integer id;
590: private String name;
591:
592: public RefObj() {
593: }
594:
595: public RefObj(Integer id, String name) {
596: this .id = id;
597: this .name = name;
598: }
599:
600: public RefObj(String name) {
601: this .name = name;
602: }
603:
604: public Integer getId() {
605: return id;
606: }
607:
608: public void setId(Integer id) {
609: this .id = id;
610: }
611:
612: public String getName() {
613: return name;
614: }
615:
616: public void setName(String name) {
617: this .name = name;
618: }
619: }
620:
621: public static class CollObj extends RefObj {
622: private Integer fkPBAwareObject;
623:
624: public CollObj() {
625: }
626:
627: public CollObj(Integer id, String name) {
628: super (id, name);
629: }
630:
631: public CollObj(String name) {
632: super (name);
633: }
634:
635: public Integer getFkPBAwareObject() {
636: return fkPBAwareObject;
637: }
638:
639: public void setFkPBAwareObject(Integer fkPBAwareObject) {
640: this.fkPBAwareObject = fkPBAwareObject;
641: }
642: }
643:
644: }
|