KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > ojb > broker > ReferenceTest


1 package org.apache.ojb.broker;
2
3 import java.io.Serializable JavaDoc;
4 import java.util.Collection JavaDoc;
5 import java.util.Iterator JavaDoc;
6 import java.util.List JavaDoc;
7 import java.util.ArrayList JavaDoc;
8
9 import org.apache.ojb.broker.metadata.ClassDescriptor;
10 import org.apache.ojb.broker.metadata.ObjectReferenceDescriptor;
11 import org.apache.ojb.broker.query.Criteria;
12 import org.apache.ojb.broker.query.Query;
13 import org.apache.ojb.broker.query.QueryFactory;
14 import org.apache.ojb.junit.PBTestCase;
15 import org.apache.commons.lang.builder.ToStringBuilder;
16
17 /**
18  * Test case for checking the management of references.
19  *
20  * @author <a HREF="mailto:armin@codeAuLait.de">Armin Waibel</a>
21  * @version $Id: ReferenceTest.java,v 1.17.2.4 2005/10/06 15:21:41 arminw Exp $
22  */

23 public class ReferenceTest extends PBTestCase
24 {
25     private static String JavaDoc REF_TEST_STRING = "refTest";
26
27     public static void main(String JavaDoc[] args)
28     {
29         String JavaDoc[] arr = {ReferenceTest.class.getName()};
30         junit.textui.TestRunner.main(arr);
31     }
32
33     public void tearDown()
34     {
35         if(broker != null)
36         {
37             changeRepositoryAutoSetting("ref", true, ObjectReferenceDescriptor.CASCADE_OBJECT, ObjectReferenceDescriptor.CASCADE_OBJECT);
38             changeRepositoryAutoSetting("refA", true, ObjectReferenceDescriptor.CASCADE_OBJECT, ObjectReferenceDescriptor.CASCADE_OBJECT);
39             changeRepositoryAutoSetting("refB", true, ObjectReferenceDescriptor.CASCADE_OBJECT, ObjectReferenceDescriptor.CASCADE_OBJECT);
40             changeRepositoryAutoSetting("animal", true, ObjectReferenceDescriptor.CASCADE_OBJECT, ObjectReferenceDescriptor.CASCADE_OBJECT);
41             broker.close();
42         }
43     }
44
45     /**
46      * Test for OJB-49
47      */

48     public void testQueryExtentsWithAutoRefreshEnabled() throws Exception JavaDoc
49     {
50         String JavaDoc name = "testQueryExtentsWithAutoRefreshEnabled_"+ System.currentTimeMillis();
51
52         int cascadeObject = ObjectReferenceDescriptor.CASCADE_OBJECT;
53         ojbChangeReferenceSetting(ObjA.class, "ref", true, cascadeObject, cascadeObject, false);
54         ojbChangeReferenceSetting(ObjB.class, "ref", true, cascadeObject, cascadeObject, false);
55
56         ClassDescriptor cldA = broker.getClassDescriptor(ObjA.class);
57         ClassDescriptor cldB = broker.getClassDescriptor(ObjB.class);
58         boolean oldRefreshA = cldA.isAlwaysRefresh();
59         boolean oldRefreshB = cldB.isAlwaysRefresh();
60         cldA.setAlwaysRefresh(true);
61         cldB.setAlwaysRefresh(true);
62
63         try
64         {
65             ObjA objA = new ObjA();
66             objA.setName(name);
67             ObjB objB = new ObjB();
68             objB.setName(name);
69             ObjC objC = new ObjC();
70             objC.setName(name);
71
72             ObjA objA2 = new ObjA();
73             objA2.setName(name);
74             ObjB objB2 = new ObjB();
75             objB2.setName(name);
76             ObjC objC2 = new ObjC();
77             objC2.setName(name);
78
79             List JavaDoc refs = new ArrayList JavaDoc();
80             refs.add(objA2);
81             refs.add(objB2);
82
83             objA.setRef(objB);
84             objC2.setReferences(refs);
85             objB.setRef(objC);
86             objC2.setRef(objA);
87
88             broker.beginTransaction();
89             broker.store(objA);
90             broker.store(objC2);
91             broker.commitTransaction();
92
93             Criteria crit = new Criteria();
94             crit.addLike("name", name);
95             Query q = QueryFactory.newQuery(RefObject.class, crit);
96             Collection JavaDoc result = broker.getCollectionByQuery(q);
97             assertEquals(6, result.size());
98         }
99         finally
100         {
101             cldA.setAlwaysRefresh(oldRefreshA);
102             cldB.setAlwaysRefresh(oldRefreshB);
103         }
104     }
105
106     /**
107      * Test the usage of interface as class-ref in collection-descriptor
108      * when using inheritance.
109      */

110     public void testInterfaceAsCollectionRef_1()
111     {
112         // if(skipKnownIssueProblem("query using path via reference, like 'ref1.ref2.name'")) return;
113
String JavaDoc name = "testQueryWithCollectionRef_" + System.currentTimeMillis();
114         RefObject a = new ObjA();
115         RefObject a2 = new ObjA();
116         RefObject b = new ObjB();
117         RefObject b2 = new ObjB();
118         // this object has a 1:n relation
119
ObjC c1 = new ObjC();
120         // only used in the c object reference collection
121
RefObject d1 = new ObjC();
122         RefObject d2 = new ObjC();
123         ObjC c2 = new ObjC();
124
125         c1.setName(name+"_third");
126         b.setName(name+"_second_1");
127         b2.setName(name+"_second_2");
128         a.setName(name+"_first_1");
129         a2.setName(name+"_first_2");
130         d1.setName(name+"_d1");
131         d2.setName(name+"_d2");
132         c2.setName(name + "_c2");
133
134         c1.setNameC(name + "_1");
135         c2.setNameC(name + "_2");
136
137         a.setRef(b);
138         b.setRef(c1);
139         a2.setRef(b2);
140
141         List JavaDoc refList = new ArrayList JavaDoc();
142         refList.add(a);
143         refList.add(b2);
144         refList.add(d1);
145         c1.setReferences(refList);
146         List JavaDoc refList2 = new ArrayList JavaDoc();
147         refList2.add(d2);
148         c2.setReferences(refList2);
149
150         broker.beginTransaction();
151         broker.store(a);
152         broker.store(a2);
153         broker.store(c2);
154         broker.commitTransaction();
155
156         // check existence of objects
157
Criteria crit = new Criteria();
158         crit.addLike("name", name + "%");
159         Query q = QueryFactory.newQuery(RefObject.class, crit);
160         Collection JavaDoc result = broker.getCollectionByQuery(q);
161         assertEquals(8, result.size());
162
163         // expect all 'C' objects with 1:n reference object
164
// with name '..._d1' --> 'c1'
165
crit = new Criteria();
166         crit.addEqualTo("references.name", name+"_d1");
167         q = QueryFactory.newQuery(ObjC.class, crit);
168         result = broker.getCollectionByQuery(q);
169         assertEquals(1, result.size());
170         ObjC newC = (ObjC) result.iterator().next();
171         assertEquals(name + "_1", newC.getNameC());
172
173         // expect all 'C' objects with 1:n reference object
174
// with nameC '..._%' --> 'c1' 'c2'
175
crit = new Criteria();
176         crit.addLike("nameC", name+"_%");
177         q = QueryFactory.newQuery(ObjC.class, crit);
178         result = broker.getCollectionByQuery(q);
179         assertEquals(2, result.size());
180
181         // expect all 'B' objects with 1:1 to an RefObject which
182
// has an 1:n reference object
183
// with name '..._d1' --> 'b'
184
crit = new Criteria();
185         crit.addEqualTo("ref.references.name", name+"_d1");
186         // add this because only 'C' objects have a 1:n reference
187
crit.addPathClass("ref", ObjC.class);
188         q = QueryFactory.newQuery(ObjB.class, crit);
189         result = broker.getCollectionByQuery(q);
190         assertEquals(1, result.size());
191         ObjB newB = (ObjB) result.iterator().next();
192         assertNotNull(newB.getRef());
193         assertTrue(newB.getRef() instanceof ObjC);
194         newC = (ObjC) newB.getRef();
195         assertEquals(3, newC.getReferences().size());
196
197         // expect all 'B' objects with 1:1 to an RefObject which
198
// has an 1:n reference object
199
// with name '..._d1' --> 'b'
200
crit = new Criteria();
201         crit.addLike("ref.nameC", name+"_%");
202         // add this because only 'C' objects have a 1:n reference
203
crit.addPathClass("ref", ObjC.class);
204         q = QueryFactory.newQuery(ObjB.class, crit);
205         result = broker.getCollectionByQuery(q);
206         assertEquals(1, result.size());
207         newB = (ObjB) result.iterator().next();
208         assertNotNull(newB.getRef());
209         assertTrue(newB.getRef() instanceof ObjC);
210         newC = (ObjC) newB.getRef();
211         assertEquals(3, newC.getReferences().size());
212
213         // expect all A's which have a B called '_second_1'
214
crit = new Criteria();
215         crit.addLike("name", name+"_%");
216         crit.addEqualTo("ref.name", name+"_second_1");
217         crit.addPathClass("ref", ObjB.class);
218         q = QueryFactory.newQuery(ObjA.class, crit);
219         result = broker.getCollectionByQuery(q);
220         assertEquals(1, result.size());
221
222         // expect all A's which have a B called '_second_1' and
223
// a C called '_third'
224
crit = new Criteria();
225         crit.addLike("name", name+"_%");
226         crit.addEqualTo("ref.name", name+"_second_1");
227         crit.addEqualTo("ref.ref.name", name+"_third");
228         crit.addPathClass("ref", ObjB.class);
229         crit.addPathClass("ref.ref", ObjC.class);
230         q = QueryFactory.newQuery(ObjA.class, crit);
231         result = broker.getCollectionByQuery(q);
232         assertEquals(1, result.size());
233
234         // expect all A's which third level 'ref' has a 'references'
235
// field collection, this is only valid for 'C' class objects
236
// and references contain '..._d1' object --> 'a'
237
crit = new Criteria();
238         crit.addLike("name", name+"_%");
239         crit.addEqualTo("ref.ref.references.name", name+"_d1");
240         crit.addPathClass("ref", ObjB.class);
241         crit.addPathClass("ref.ref", ObjC.class);
242         q = QueryFactory.newQuery(ObjA.class, crit);
243         result = broker.getCollectionByQuery(q);
244         assertEquals(1, result.size());
245         for(Iterator JavaDoc iterator = result.iterator(); iterator.hasNext();)
246         {
247             RefObject ref = (RefObject) iterator.next();
248             assertTrue(ref instanceof ObjA);
249             String JavaDoc refName = ref.getName();
250             assertTrue(!(refName.indexOf(name)<0));
251         }
252
253         // expect all A's with reference object named '_second%' and
254
// which third level 'ref' has a 'references'
255
// field collection, this is only valid for 'C' class objects
256
// and references contain '..._second%' objects --> 'a'
257
crit = new Criteria();
258         crit.addLike("name", name+"_%");
259         crit.addLike("ref.name", name+"_second%");
260         crit.addLike("ref.ref.references.name", name+"_second%");
261         crit.addPathClass("ref", ObjB.class);
262         crit.addPathClass("ref.ref", ObjC.class);
263         q = QueryFactory.newQuery(ObjA.class, crit);
264         result = broker.getCollectionByQuery(q);
265         assertEquals(1, result.size());
266         for(Iterator JavaDoc iterator = result.iterator(); iterator.hasNext();)
267         {
268             RefObject ref = (RefObject) iterator.next();
269             assertTrue(ref instanceof ObjA);
270             String JavaDoc refName = ref.getName();
271             assertTrue(!(refName.indexOf(name)<0));
272         }
273     }
274
275     /**
276      * Test the usage of interface as class-ref in collection-descriptor
277      * when using inheritance.
278      */

279     public void testInterfaceAsCollectionRef_2()
280     {
281         // if(skipKnownIssueProblem("query using path via reference, like 'ref1.ref2.name'")) return;
282
String JavaDoc name = "testQueryWithCollectionRef_" + System.currentTimeMillis();
283         RefObject a = new ObjA();
284         RefObject a2 = new ObjA();
285         RefObject b = new ObjB();
286         RefObject b2 = new ObjB();
287         // this object has a 1:n relation
288
ObjC c = new ObjC();
289         // only used in the c object reference collection
290
RefObject d = new ObjC();
291
292         c.setName(name+"_third");
293         b.setName(name+"_second_1");
294         b2.setName(name+"_second_2");
295         a.setName(name+"_first_1");
296         a2.setName(name+"_first_2");
297         d.setName(name+"_none");
298
299         a.setRef(b);
300         b.setRef(c);
301         a2.setRef(b2);
302
303         List JavaDoc refList = new ArrayList JavaDoc();
304         refList.add(a);
305         refList.add(b2);
306         refList.add(d);
307         c.setReferences(refList);
308
309         broker.beginTransaction();
310         broker.store(a);
311         broker.store(a2);
312         broker.commitTransaction();
313
314         // check existence of objects
315
Criteria crit = new Criteria();
316         crit.addEqualTo("name", name+"_third");
317         Query q = QueryFactory.newQuery(RefObject.class, crit);
318         Collection JavaDoc result = broker.getCollectionByQuery(q);
319         assertEquals(1, result.size());
320         ObjC newC = (ObjC) result.iterator().next();
321         assertNotNull(newC.getReferences());
322         assertEquals(3, newC.getReferences().size());
323
324         // test n-level depth
325
//*****************************************
326
crit = new Criteria();
327         crit.addEqualTo("ref.ref.name", name+"_third");
328         q = QueryFactory.newQuery(ObjA.class, crit);
329         result = broker.getCollectionByQuery(q);
330         assertEquals(1, result.size());
331         //*****************************************
332

333         crit = new Criteria();
334         crit.addLike("references.name", name+"_first%");
335         q = QueryFactory.newQuery(ObjC.class, crit);
336         result = broker.getCollectionByQuery(q);
337         assertEquals(1, result.size());
338
339         // expect all A's with name "_first_2" or with second
340
// level 'ref' "_third" in this case object 'a' and 'a2'
341
crit = new Criteria();
342         crit.addEqualTo("name", name+"_first_2");
343         Criteria critOr = new Criteria();
344         critOr.addEqualTo("ref.ref.name", name+"_third");
345         crit.addOrCriteria(critOr);
346         q = QueryFactory.newQuery(ObjA.class, crit);
347         result = broker.getCollectionByQuery(q);
348         assertEquals(2, result.size());
349         for(Iterator JavaDoc iterator = result.iterator(); iterator.hasNext();)
350         {
351             RefObject ref = (RefObject) iterator.next();
352             assertTrue(ref instanceof ObjA);
353             String JavaDoc refName = ref.getName();
354             assertTrue(!(refName.indexOf(name)<0));
355         }
356
357         // expect all A's which second level 'ref' is "_third"
358
// in this case object 'a'
359
crit = new Criteria();
360         crit.addLike("name", name+"_%");
361         Criteria critAnd = new Criteria();
362         critAnd.addEqualTo("ref.ref.name", name+"_third");
363         crit.addAndCriteria(critAnd);
364         q = QueryFactory.newQuery(ObjA.class, crit);
365         result = broker.getCollectionByQuery(q);
366         assertEquals(1, result.size());
367         for(Iterator JavaDoc iterator = result.iterator(); iterator.hasNext();)
368         {
369             RefObject ref = (RefObject) iterator.next();
370             assertTrue(ref instanceof ObjA);
371             String JavaDoc refName = ref.getName();
372             assertTrue(!(refName.indexOf(name)<0));
373         }
374
375         // expect all A's with first level 'ref' "_second%"
376
// in this case object 'a' and 'a2'
377
crit = new Criteria();
378         crit.addLike("ref.name", name+"_second%");
379         critAnd = new Criteria();
380         critAnd.addLike("name", name+"%");
381         crit.addAndCriteria(critAnd);
382         q = QueryFactory.newQuery(ObjA.class, crit);
383         result = broker.getCollectionByQuery(q);
384         assertEquals(2, result.size());
385         for(Iterator JavaDoc iterator = result.iterator(); iterator.hasNext();)
386         {
387             RefObject ref = (RefObject) iterator.next();
388             assertTrue(ref instanceof ObjA);
389             String JavaDoc refName = ref.getName();
390             assertTrue(!(refName.indexOf(name)<0));
391         }
392     }
393
394     public void testDeepPathQuery()
395     {
396         // if(skipKnownIssueProblem("query using path via reference, like 'ref1.ref2.name'")) return;
397
String JavaDoc name = "testDeepPathQuery_" + System.currentTimeMillis();
398         RefObject a = new ObjA();
399         RefObject a2 = new ObjA();
400         RefObject b = new ObjB();
401         RefObject b2 = new ObjB();
402         ObjC c = new ObjC();
403
404         c.setName(name+"_third");
405         b.setName(name+"_second_1");
406         b2.setName(name+"_second_2");
407         a.setName(name+"_first_1");
408         a2.setName(name+"_first_2");
409
410         a.setRef(b);
411         b.setRef(c);
412         a2.setRef(b2);
413
414         List JavaDoc refList = new ArrayList JavaDoc();
415         refList.add(a);
416         refList.add(b2);
417         c.setReferences(refList);
418
419         broker.beginTransaction();
420         broker.store(a);
421         broker.store(a2);
422         broker.commitTransaction();
423
424         // check existence of objects
425
Criteria crit = new Criteria();
426         crit.addLike("name", name+"%");
427         Query q = QueryFactory.newQuery(ObjA.class, crit);
428         Collection JavaDoc result = broker.getCollectionByQuery(q);
429         assertEquals(2, result.size());
430
431         // check existence of object
432
crit = new Criteria();
433         crit.addLike("name", name+"_third%");
434         q = QueryFactory.newQuery(ObjC.class, crit);
435         result = broker.getCollectionByQuery(q);
436         assertEquals(1, result.size());
437
438         // check existence of object
439
crit = new Criteria();
440         crit.addLike("name", name+"%");
441         q = QueryFactory.newQuery(ObjC.class, crit);
442         result = broker.getCollectionByQuery(q);
443         assertEquals(1, result.size());
444
445         // test one level depth
446
crit = new Criteria();
447         crit.addLike("ref.name", name+"_second%");
448         q = QueryFactory.newQuery(ObjA.class, crit);
449         result = broker.getCollectionByQuery(q);
450         assertEquals(2, result.size());
451
452         // check existence of objects
453
crit = new Criteria();
454         crit.addLike("name", name+"%");
455         q = QueryFactory.newQuery(RefObject.class, crit);
456         result = broker.getCollectionByQuery(q);
457         assertEquals(5, result.size());
458
459         // test n-level depth
460
//*****************************************
461
crit = new Criteria();
462         crit.addEqualTo("ref.ref.name", name+"_third");
463         q = QueryFactory.newQuery(ObjA.class, crit);
464         result = broker.getCollectionByQuery(q);
465         assertEquals(1, result.size());
466         //*****************************************
467

468         // similar but more complex query
469
crit = new Criteria();
470         crit.addEqualTo("name", name+"_first_2");
471         Criteria critOr = new Criteria();
472         critOr.addEqualTo("ref.ref.name", name+"_third");
473         crit.addOrCriteria(critOr);
474         q = QueryFactory.newQuery(ObjA.class, crit);
475         result = broker.getCollectionByQuery(q);
476         assertEquals(2, result.size());
477         for(Iterator JavaDoc iterator = result.iterator(); iterator.hasNext();)
478         {
479             RefObject ref = (RefObject) iterator.next();
480             assertTrue(ref instanceof ObjA);
481             String JavaDoc refName = ref.getName();
482             assertTrue(!(refName.indexOf(name)<0));
483         }
484     }
485
486     public void testAutoUpdateDeleteSettings()
487     {
488         changeRepositoryAutoSetting("ref", true, false, false);
489         ObjectReferenceDescriptor ord = broker.getClassDescriptor(Repository.class)
490                 .getObjectReferenceDescriptorByName("ref");
491         assertEquals(ObjectReferenceDescriptor.CASCADE_LINK, ord.getCascadingStore());
492         assertEquals(ObjectReferenceDescriptor.CASCADE_NONE, ord.getCascadingDelete());
493         assertEquals(false, ord.getCascadeStore());
494         assertEquals(false, ord.getCascadeDelete());
495
496         changeRepositoryAutoSetting("ref", true, true, true);
497         ord = broker.getClassDescriptor(Repository.class).getObjectReferenceDescriptorByName("ref");
498         assertEquals(ObjectReferenceDescriptor.CASCADE_OBJECT, ord.getCascadingStore());
499         assertEquals(ObjectReferenceDescriptor.CASCADE_OBJECT, ord.getCascadingDelete());
500         assertEquals(true, ord.getCascadeStore());
501         assertEquals(true, ord.getCascadeDelete());
502     }
503
504     /**
505      * not really a reference test, here we check handling of objects
506      * with multiple PK fields. Such an object was used in following
507      * reference tests.
508      */

509     public void testHandlingOfMultiplePKFields() throws Exception JavaDoc
510     {
511         String JavaDoc timestamp = "testLookupWithMultiplePK_" + System.currentTimeMillis();
512         String JavaDoc regionName = "baden_" + timestamp;
513         String JavaDoc countryName = "germany_" + timestamp;
514         /*
515         Wine has a 1:1 reference with Region, we set the reference object in
516         Wine class. We don't set the FK fields in Wine, this should be done by OJB
517         automatic
518         */

519         Region region = new Region(regionName, countryName, "original");
520
521         broker.beginTransaction();
522         broker.store(region);
523         broker.commitTransaction();
524
525         Identity oid = new Identity(region, broker);
526         broker.clearCache();
527         Region loadedRegion = (Region) broker.getObjectByIdentity(oid);
528
529         assertNotNull(loadedRegion);
530         assertEquals(region.getName(), loadedRegion.getName());
531
532         loadedRegion.setDescription("update_1");
533         broker.beginTransaction();
534         broker.store(loadedRegion);
535         broker.commitTransaction();
536         broker.clearCache();
537         loadedRegion = (Region) broker.getObjectByIdentity(oid);
538         assertNotNull(loadedRegion);
539         assertEquals("update_1", loadedRegion.getDescription());
540
541         loadedRegion.setDescription("update_2");
542         broker.beginTransaction();
543         broker.store(loadedRegion);
544         broker.commitTransaction();
545         broker.clearCache();
546         loadedRegion = (Region) broker.getObjectByIdentity(oid);
547         assertNotNull(loadedRegion);
548         assertEquals("update_2", loadedRegion.getDescription());
549
550         Criteria crit = new Criteria();
551         crit.addLike("name", regionName);
552         Query q = QueryFactory.newQuery(Region.class, crit);
553         Collection JavaDoc result = broker.getCollectionByQuery(q);
554         assertEquals(1, result.size());
555     }
556
557     public void testStoreWithMultiplePK_1() throws Exception JavaDoc
558     {
559         String JavaDoc timestamp = "testStoreWithMultiplePK_1_" + System.currentTimeMillis();
560         String JavaDoc regionName = "baden_1" + timestamp;
561         String JavaDoc countryName = "germany_1" + timestamp;
562         Region region = new Region(regionName, countryName, "brrr");
563         Wine wine = new Wine(timestamp, "silvaner", "2003", regionName, countryName);
564
565         broker.beginTransaction();
566         broker.store(region);
567         broker.commitTransaction();
568
569         /*
570         class Wine has a 1:1 reference with Region, we set set the FK in Wine but don't
571         set the Region reference object in Wine. But retriveAllReferences materialize
572         the reference object before store.
573         */

574         broker.beginTransaction();
575         broker.retrieveAllReferences(wine);
576         broker.store(wine);
577         broker.commitTransaction();
578
579         Identity oid = new Identity(wine, broker);
580         broker.clearCache();
581         Wine loadedWine = (Wine) broker.getObjectByIdentity(oid);
582         assertNotNull(loadedWine);
583         assertEquals(wine.getGrape(), loadedWine.getGrape());
584         assertNotNull(loadedWine.getRegion());
585         assertEquals(wine.getRegion().getCountry(), loadedWine.getRegion().getCountry());
586     }
587
588     public void testStoreWithMultiplePK_2() throws Exception JavaDoc
589     {
590         String JavaDoc timestamp = "testStoreWithMultiplePK_2_" + System.currentTimeMillis();
591         String JavaDoc regionName = "baden_2" + timestamp;
592         String JavaDoc countryName = "germany_2" + timestamp;
593         /*
594         Wine has a 1:1 reference with Region, we set the reference object in
595         Wine class. We don't set the FK fields in Wine, this should be done by OJB
596         automatic
597         */

598         Region region = new Region(regionName, countryName, "brrr");
599         Wine wine = new Wine(timestamp, "silvaner", "2003", null, null);
600         wine.setRegion(region);
601
602         broker.beginTransaction();
603         broker.store(region);
604         broker.commitTransaction();
605
606         broker.beginTransaction();
607         broker.store(wine);
608         broker.commitTransaction();
609
610         Identity oid = new Identity(wine, broker);
611         broker.clearCache();
612         Wine loadedWine = (Wine) broker.getObjectByIdentity(oid);
613         assertNotNull(loadedWine);
614         assertEquals(wine.getGrape(), loadedWine.getGrape());
615         assertNotNull(loadedWine.getRegion());
616         assertEquals(wine.getRegion().getCountry(), loadedWine.getRegion().getCountry());
617     }
618
619     public void testDeleteWithMultiplePK()
620     {
621         String JavaDoc timestamp = "testDeleteWithMultiplePK_" + System.currentTimeMillis();
622         String JavaDoc regionName = "baden_2" + timestamp;
623         String JavaDoc countryName = "germany_2" + timestamp;
624
625         /*
626         Wine has a 1:1 reference with Region, we set the reference object in
627         Wine class. We don't set the FK fields in Wine, this should be done by OJB
628         automatic
629         */

630         Region region = new Region(regionName, countryName, "brrr");
631         Wine wine = new Wine(timestamp, "silvaner", "2003", null, null);
632         wine.setRegion(region);
633
634         broker.beginTransaction();
635         broker.store(region);
636         broker.commitTransaction();
637
638         broker.beginTransaction();
639         broker.store(wine);
640         broker.commitTransaction();
641
642         Identity oid = new Identity(wine, broker);
643         Identity oidRegion = new Identity(region, broker);
644         broker.clearCache();
645         Wine loadedWine = (Wine) broker.getObjectByIdentity(oid);
646         assertNotNull(loadedWine);
647         assertEquals(wine.getGrape(), loadedWine.getGrape());
648         assertNotNull(loadedWine.getRegion());
649         assertEquals(wine.getRegion().getCountry(), loadedWine.getRegion().getCountry());
650
651         broker.beginTransaction();
652         broker.delete(wine);
653         broker.commitTransaction();
654
655         loadedWine = (Wine) broker.getObjectByIdentity(oid);
656         assertNull(loadedWine);
657         Region loadedregion = (Region) broker.getObjectByIdentity(oidRegion);
658         assertNotNull(loadedregion);
659
660         broker.clearCache();
661         loadedWine = (Wine) broker.getObjectByIdentity(oid);
662         assertNull(loadedWine);
663         loadedregion = (Region) broker.getObjectByIdentity(oidRegion);
664         assertNotNull(loadedregion);
665     }
666
667     public void testStoreWithMultiplePK_3() throws Exception JavaDoc
668     {
669         String JavaDoc timestamp = "testStoreWithMultiplePK_3_" + System.currentTimeMillis();
670         String JavaDoc regionName = "baden_3" + timestamp;
671         String JavaDoc countryName = "germany_3" + timestamp;
672         /*
673         Wine has a 1:1 reference with Region, we set set the FK fields
674         of an existing Region object in Wine
675         but don't set the Region reference object itself in Wine object
676         */

677         Region region = new Region(regionName, countryName, "brrr");
678         Wine wine = new Wine(timestamp, "silvaner", "2003", regionName, countryName);
679         wine.setRegion(region);
680
681         broker.beginTransaction();
682         broker.store(region);
683         broker.commitTransaction();
684
685         broker.beginTransaction();
686         broker.store(wine);
687         broker.commitTransaction();
688
689         Identity oid = new Identity(wine, broker);
690         broker.clearCache();
691         Wine loadedWine = (Wine) broker.getObjectByIdentity(oid);
692         assertNotNull(loadedWine);
693         assertEquals(wine.getGrape(), loadedWine.getGrape());
694         assertNotNull(loadedWine.getRegion());
695         assertEquals(wine.getRegion().getCountry(), loadedWine.getRegion().getCountry());
696     }
697
698     public void testStoreReferencesMappedToSameTable()
699     {
700         String JavaDoc referenceNamePrefix = "testStoreReferencesMappedToSameTable" + System.currentTimeMillis();
701         Repository[] repository = prepareRepository(referenceNamePrefix);
702
703         broker.beginTransaction();
704         broker.store(repository[0]);
705         broker.store(repository[1]);
706         broker.store(repository[2]);
707         broker.commitTransaction();
708
709         broker.clearCache();
710         Identity oid = new Identity(repository[0], broker);
711
712         Repository rep = (Repository) broker.getObjectByIdentity(oid);
713         assertNotNull(rep.getRef());
714         assertNotNull(rep.getRefA());
715         assertNotNull(rep.getRefB());
716         // lookup reference name, set in prepareRepository method
717
assertEquals(rep.getRefB().getRefNameB(), REF_TEST_STRING);
718     }
719
720     public void testGetReferencesByIdentityMappedToSameTable()
721     {
722         String JavaDoc referenceNamePrefix = "testGetReferencesByIdentityMappedToSameTable" + System.currentTimeMillis();
723         Repository[] repository = prepareRepository(referenceNamePrefix);
724
725         broker.beginTransaction();
726         broker.store(repository[0]);
727         broker.store(repository[1]);
728         broker.store(repository[2]);
729         broker.commitTransaction();
730
731         assertNotNull(repository[0].getRef());
732         assertNotNull(repository[0].getRefA());
733         assertNotNull(repository[0].getRefB());
734
735         Identity oid_ref = new Identity(repository[0].getRef(), broker);
736         Identity oid_refA = new Identity(repository[0].getRefA(), broker);
737         Identity oid_refB = new Identity(repository[0].getRefB(), broker);
738
739         broker.clearCache();
740         Object JavaDoc result;
741         result = broker.getObjectByIdentity(oid_ref);
742         assertTrue(result instanceof Reference);
743         result = broker.getObjectByIdentity(oid_refA);
744         assertTrue(result instanceof ReferenceA);
745         result = broker.getObjectByIdentity(oid_refB);
746         assertTrue(result instanceof ReferenceB);
747
748         broker.clearCache();
749         Identity repOID = new Identity(repository[0], broker);
750         Repository repositoryObj = (Repository) broker.getObjectByIdentity(repOID);
751         assertNotNull(repositoryObj);
752         ReferenceBIF refB = repositoryObj.getRefB();
753         assertNotNull(refB);
754         assertEquals(refB.getRefNameB(), REF_TEST_STRING);
755     }
756
757     public void testQueryReferencesMappedToSameTable()
758     {
759         String JavaDoc referenceNamePrefix = "testQueryReferencesMappedToSameTable" + System.currentTimeMillis();
760         Repository[] repository = prepareRepository(referenceNamePrefix);
761
762         broker.beginTransaction();
763         broker.store(repository[0]);
764         broker.store(repository[1]);
765         broker.store(repository[2]);
766         broker.commitTransaction();
767
768         broker.clearCache();
769         Criteria criteria = new Criteria();
770         criteria.addLike("name", referenceNamePrefix + "%");
771         Query query = QueryFactory.newQuery(ReferenceIF.class, criteria);
772         Collection JavaDoc result = broker.getCollectionByQuery(query);
773
774         assertEquals("Wrong number of References", 9, result.size());
775         int ref_count = 0;
776         int refA_count = 0;
777         int refB_count = 0;
778         Iterator JavaDoc it = result.iterator();
779         Object JavaDoc obj;
780         while(it.hasNext())
781         {
782             obj = it.next();
783             if(obj instanceof ReferenceA)
784                 refA_count++;
785             else if(obj instanceof ReferenceB)
786                 refB_count++;
787             else if(obj instanceof Reference) ref_count++;
788         }
789         assertEquals("Wrong number of RefernceA", 3, refA_count);
790         assertEquals("Wrong number of RefernceB", 3, refB_count);
791         assertEquals("Wrong number of Refernce", 3, ref_count);
792
793         result = broker.getCollectionByQuery(query);
794         it = result.iterator();
795         while(it.hasNext())
796         {
797             obj = it.next();
798             if(obj instanceof ReferenceA)
799             {
800                 assertNotNull(((ReferenceA) obj).getRefNameA());
801                 assertNotNull(((ReferenceA) obj).getName());
802             }
803             else if(obj instanceof ReferenceB)
804             {
805                 assertNotNull(((ReferenceB) obj).getRefNameB());
806                 assertNotNull(((ReferenceB) obj).getName());
807             }
808             else if(obj instanceof Reference)
809             {
810                 assertNotNull(((Reference) obj).getName());
811             }
812         }
813     }
814
815     public void testDeleteReferencesMappedToSameTable()
816     {
817         String JavaDoc referenceNamePrefix = "testDeleteReferencesMappedToSameTable" + System.currentTimeMillis();
818         Repository[] repository = prepareRepository(referenceNamePrefix);
819
820         broker.beginTransaction();
821         broker.store(repository[0]);
822         broker.store(repository[1]);
823         broker.store(repository[2]);
824         broker.commitTransaction();
825
826         Criteria criteria = new Criteria();
827         criteria.addLike("name", referenceNamePrefix + "%");
828         Query query = QueryFactory.newQuery(ReferenceIF.class, criteria);
829         Collection JavaDoc result = broker.getCollectionByQuery(query);
830
831         assertEquals("Wrong number of References", 9, result.size());
832
833         broker.beginTransaction();
834         broker.delete(repository[0]);
835         broker.delete(repository[1]);
836         broker.delete(repository[2]);
837         broker.commitTransaction();
838
839         result = broker.getCollectionByQuery(query);
840         assertEquals("Wrong number of References", 0, result.size());
841     }
842
843     public void testDeleteReferencesMappedToSameTable_2()
844     {
845         String JavaDoc referenceNamePrefix = "testDeleteReferencesMappedToSameTable_2" + System.currentTimeMillis();
846         changeRepositoryAutoSetting("ref", true, true, false);
847         changeRepositoryAutoSetting("refA", true, true, false);
848         changeRepositoryAutoSetting("refB", true, true, false);
849
850         Repository[] repository = prepareRepository(referenceNamePrefix);
851
852         broker.beginTransaction();
853         broker.store(repository[0]);
854         broker.store(repository[1]);
855         broker.store(repository[2]);
856         broker.commitTransaction();
857
858         Criteria criteria = new Criteria();
859         criteria.addLike("name", referenceNamePrefix + "%");
860         Query query = QueryFactory.newQuery(ReferenceIF.class, criteria);
861         Collection JavaDoc result = broker.getCollectionByQuery(query);
862
863         assertEquals("Wrong number of References", 9, result.size());
864
865         broker.beginTransaction();
866         broker.delete(repository[0]);
867         broker.delete(repository[1]);
868         broker.delete(repository[2]);
869         broker.commitTransaction();
870
871         result = broker.getCollectionByQuery(query);
872         assertEquals("Wrong number of References", 9, result.size());
873     }
874
875     public void testDeleteReferencesMappedToSameTable_3()
876     {
877         String JavaDoc referenceNamePrefix = "testDeleteReferencesMappedToSameTable_3" + System.currentTimeMillis();
878         changeRepositoryAutoSetting("ref", true, true, false);
879         changeRepositoryAutoSetting("refA", true, true, true);
880         changeRepositoryAutoSetting("refB", true, true, false);
881
882         Repository[] repository = prepareRepository(referenceNamePrefix);
883
884         broker.beginTransaction();
885         broker.store(repository[0]);
886         broker.store(repository[1]);
887         broker.store(repository[2]);
888         broker.commitTransaction();
889
890         Criteria criteria = new Criteria();
891         criteria.addLike("name", referenceNamePrefix + "%");
892         Query query = QueryFactory.newQuery(ReferenceIF.class, criteria);
893         Collection JavaDoc result = broker.getCollectionByQuery(query);
894
895         assertEquals("Wrong number of References", 9, result.size());
896
897         broker.beginTransaction();
898         broker.delete(repository[0]);
899         broker.delete(repository[1]);
900         broker.delete(repository[2]);
901         broker.commitTransaction();
902
903         result = broker.getCollectionByQuery(query);
904         assertEquals("Wrong number of References", 6, result.size());
905     }
906
907     private void changeRepositoryAutoSetting(String JavaDoc attributeName, boolean retrieve, int update, int delete)
908     {
909         ClassDescriptor cld = broker.getClassDescriptor(Repository.class);
910         ObjectReferenceDescriptor ord = cld.getObjectReferenceDescriptorByName(attributeName);
911         ord.setCascadeRetrieve(retrieve);
912         ord.setCascadingStore(update);
913         ord.setCascadingDelete(delete);
914     }
915
916     private void changeRepositoryAutoSetting(String JavaDoc attributeName, boolean retrieve, boolean update, boolean delete)
917     {
918         ClassDescriptor cld = broker.getClassDescriptor(Repository.class);
919         ObjectReferenceDescriptor ord = cld.getObjectReferenceDescriptorByName(attributeName);
920         ord.setCascadeRetrieve(retrieve);
921         ord.setCascadeStore(update);
922         ord.setCascadeDelete(delete);
923     }
924
925     /**
926      * This test does the same as the {@link #testRepositoryFKStore},
927      * but the used mapping data differ.
928      * {@link RepositoryFK} defines all the reference fields as
929      * primary key in field-descriptors. Further on the used
930      * database table declares the reference fields as PK too.
931      * Based on a user post:
932      * > The following fails to be stored by PersistenceBroker:
933      >
934      > I have a class ACL which has two primary keys: objectId and userFK, and
935      > userFK is also a foreign key tied to a reference of type User. If I do
936      this:
937      >
938      > persistentBroker.beginTransaction();
939      > ACL acl = new ACL();
940      > acl.setObjectId( 100 );
941      > acl.setUser( currentUser );
942      > persistentBroker.store(acl);
943      > persistentBroker.commitTransaction();
944      >
945      > Acl will not be saved. The reason seems to be because in the storeToDb()
946      > method of the PersistentBroker, there first comes an assertion of the
947      > PrimaryKeys and afterwards comes the assignment of all the foreign keys.
948      In
949      > the scenario above the assertion of the primary keys will fail, because
950      the
951      > userFK has not been assigned yet, so we have an incomplete set of primary
952      > keys. This does work with the ODMG layer, probably because of a different
953      > sequence of events during the storing of the object.
954      >
955      > I wonder if there should be a check whether a primary key is shared by the
956      > foreign key and allow that assignment before the assertion of the primary
957      > keys is performed. Any ideas?
958      >
959      > Cheers,
960      > --Bill.
961      */

962     public void testRepositoryFKStore()
963     {
964         String JavaDoc referenceNamePrefix = "testReferenceStore" + System.currentTimeMillis();
965         RepositoryFK[] repository = prepareRepositoryFK(referenceNamePrefix);
966
967         broker.beginTransaction();
968         broker.store(repository[0]);
969         broker.store(repository[1]);
970         broker.store(repository[2]);
971         broker.commitTransaction();
972
973         Identity oid = new Identity(repository[0], broker);
974         RepositoryFK repFK = (RepositoryFK) broker.getObjectByIdentity(oid);
975
976         assertNotNull("We should found a RepositoryFK object, but doesn't.", repFK);
977         assertNotNull(repFK.getRef());
978         assertNotNull(repFK.getRefA());
979         assertNotNull(repFK.getRefB());
980     }
981
982     /**
983      * this test case use an abstract class as reference
984      * @throws Exception
985      */

986     public void testAbstractReferenceStore() throws Exception JavaDoc
987     {
988         String JavaDoc name = "testAbstractReferenceStore_" + System.currentTimeMillis();
989         /*
990         create some animals
991         */

992         Bird bird_1 = new Bird();
993         bird_1.setName(name);
994         bird_1.setWingspan(new Double JavaDoc(2.33));
995         Bird bird_2 = new Bird();
996         bird_2.setName(name);
997         bird_2.setWingspan(new Double JavaDoc(0.99));
998
999         Mammal mammal_1 = new Mammal();
1000        mammal_1.setName(name);
1001        mammal_1.setHeight(new Double JavaDoc(1.88));
1002        Mammal mammal_2 = new Mammal();
1003        mammal_2.setName(name);
1004        mammal_2.setHeight(new Double JavaDoc(19.13));
1005
1006        Fish fish_1 = new Fish();
1007        fish_1.setName(name);
1008        fish_1.setLength(new Double JavaDoc(0.033));
1009        Fish fish_2 = new Fish();
1010        fish_2.setName(name);
1011        fish_2.setLength(new Double JavaDoc(37.89));
1012
1013        Repository rep_1 = new Repository();
1014        rep_1.setAnimal(mammal_1);
1015        Repository rep_2 = new Repository();
1016        rep_2.setAnimal(bird_1);
1017        Repository rep_3 = new Repository();
1018        rep_3.setAnimal(fish_1);
1019
1020        /*
1021        store Repository instances and dummy animals
1022        */

1023        broker.beginTransaction();
1024        // store some dummy objects
1025
broker.store(bird_2);
1026        broker.store(mammal_2);
1027        broker.store(fish_2);
1028        // now store the main objects
1029
broker.store(rep_1);
1030        broker.store(rep_2);
1031        broker.store(rep_3);
1032        broker.commitTransaction();
1033
1034        Identity oid_mammal = new Identity(mammal_1, broker);
1035        Identity oid_bird = new Identity(bird_1, broker);
1036        Identity oid_fish = new Identity(fish_1, broker);
1037        Identity oid_rep_1 = new Identity(rep_1, broker);
1038        Identity oid_rep_2 = new Identity(rep_2, broker);
1039        Identity oid_rep_3 = new Identity(rep_3, broker);
1040
1041        broker.clearCache();
1042        // check the references
1043
Mammal lookup_mammal = (Mammal) broker.getObjectByIdentity(oid_mammal);
1044        Bird lookup_bird = (Bird) broker.getObjectByIdentity(oid_bird);
1045        Fish lookup_fish = (Fish) broker.getObjectByIdentity(oid_fish);
1046        assertEquals(mammal_1, lookup_mammal);
1047        assertEquals(bird_1, lookup_bird);
1048        assertEquals(fish_1, lookup_fish);
1049
1050        broker.clearCache();
1051        // check the main objects
1052
Repository lookup_rep_1 = (Repository) broker.getObjectByIdentity(oid_rep_1);
1053        Repository lookup_rep_2 = (Repository) broker.getObjectByIdentity(oid_rep_2);
1054        Repository lookup_rep_3 = (Repository) broker.getObjectByIdentity(oid_rep_3);
1055
1056        assertNotNull(lookup_rep_1.getAnimal());
1057        assertTrue("Expected instance of Mammal, found " + lookup_rep_1.getAnimal(),
1058                lookup_rep_1.getAnimal() instanceof Mammal);
1059        assertEquals(mammal_1, lookup_rep_1.getAnimal());
1060
1061        assertNotNull(lookup_rep_2.getAnimal());
1062        assertTrue("Expected instance of Bird, found " + lookup_rep_2.getAnimal(),
1063                lookup_rep_2.getAnimal() instanceof Bird);
1064        assertEquals(bird_1, lookup_rep_2.getAnimal());
1065
1066        assertNotNull(lookup_rep_3.getAnimal());
1067        assertTrue("Expected instance of Fish, found " + lookup_rep_3.getAnimal(),
1068                lookup_rep_3.getAnimal() instanceof Fish);
1069        assertEquals(fish_1, lookup_rep_3.getAnimal());
1070    }
1071
1072    public void testAbstractReferenceQuery() throws Exception JavaDoc
1073    {
1074        String JavaDoc name = "testAbstractReferenceQuery_" + System.currentTimeMillis();
1075        /*
1076        create some animals
1077        */

1078        Bird bird_1 = new Bird();
1079        bird_1.setName(name);
1080        bird_1.setWingspan(new Double JavaDoc(2.33));
1081        Bird bird_2 = new Bird();
1082        bird_2.setName(name);
1083        bird_2.setWingspan(new Double JavaDoc(0.99));
1084
1085        Mammal mammal_1 = new Mammal();
1086        mammal_1.setName(name);
1087        mammal_1.setHeight(new Double JavaDoc(1.88));
1088        Mammal mammal_2 = new Mammal();
1089        mammal_2.setName(name);
1090        mammal_2.setHeight(new Double JavaDoc(19.13));
1091
1092        Fish fish_1 = new Fish();
1093        fish_1.setName(name);
1094        fish_1.setLength(new Double JavaDoc(0.033));
1095        Fish fish_2 = new Fish();
1096        fish_2.setName(name);
1097        fish_2.setLength(new Double JavaDoc(37.89));
1098
1099        Repository rep_1 = new Repository();
1100        rep_1.setAnimal(mammal_1);
1101        Repository rep_2 = new Repository();
1102        rep_2.setAnimal(bird_1);
1103        Repository rep_3 = new Repository();
1104        rep_3.setAnimal(fish_1);
1105
1106        /*
1107        store Repository instances and dummy animals
1108        */

1109        broker.beginTransaction();
1110        // store some dummy objects
1111
broker.store(bird_2);
1112        broker.store(mammal_2);
1113        broker.store(fish_2);
1114        // now store the main objects
1115
broker.store(rep_1);
1116        broker.store(rep_2);
1117        broker.store(rep_3);
1118        broker.commitTransaction();
1119
1120        Identity oid_rep_1 = new Identity(rep_1, broker);
1121        Identity oid_rep_2 = new Identity(rep_2, broker);
1122        Identity oid_rep_3 = new Identity(rep_3, broker);
1123
1124        broker.clearCache();
1125        // check the main objects
1126
Repository lookup_rep_1 = (Repository) broker.getObjectByIdentity(oid_rep_1);
1127        Repository lookup_rep_2 = (Repository) broker.getObjectByIdentity(oid_rep_2);
1128        Repository lookup_rep_3 = (Repository) broker.getObjectByIdentity(oid_rep_3);
1129
1130        assertNotNull(lookup_rep_1.getAnimal());
1131        assertTrue("Expected instance of Mammal, found " + lookup_rep_1.getAnimal(),
1132                lookup_rep_1.getAnimal() instanceof Mammal);
1133        assertEquals(mammal_1, lookup_rep_1.getAnimal());
1134
1135        assertNotNull(lookup_rep_2.getAnimal());
1136        assertTrue("Expected instance of Bird, found " + lookup_rep_2.getAnimal(),
1137                lookup_rep_2.getAnimal() instanceof Bird);
1138        assertEquals(bird_1, lookup_rep_2.getAnimal());
1139
1140        assertNotNull(lookup_rep_3.getAnimal());
1141        assertTrue("Expected instance of Fish, found " + lookup_rep_3.getAnimal(),
1142                lookup_rep_3.getAnimal() instanceof Fish);
1143        assertEquals(fish_1, lookup_rep_3.getAnimal());
1144
1145        broker.clearCache();
1146        // query the references
1147
Criteria crit = new Criteria();
1148        crit.addEqualTo("name", name);
1149        Query query = QueryFactory.newQuery(Animal.class, crit);
1150        Collection JavaDoc result = broker.getCollectionByQuery(query);
1151        assertNotNull(result);
1152        int[] mammalBirdFish = new int[3];
1153        for(Iterator JavaDoc iterator = result.iterator(); iterator.hasNext();)
1154        {
1155            Object JavaDoc o = iterator.next();
1156            if(o instanceof Mammal) ++mammalBirdFish[0];
1157            if(o instanceof Bird) ++mammalBirdFish[1];
1158            if(o instanceof Fish) ++mammalBirdFish[2];
1159        }
1160        assertEquals(2, mammalBirdFish[0]);
1161        assertEquals(2, mammalBirdFish[1]);
1162        assertEquals(2, mammalBirdFish[2]);
1163    }
1164
1165    /**
1166     * this test case use an abstract class as reference
1167     * @throws Exception
1168     */

1169    public void testAbstractReferenceDelete() throws Exception JavaDoc
1170    {
1171        String JavaDoc name = "testAbstractReferenceDelete_" + System.currentTimeMillis();
1172        /*
1173        create some animals
1174        */

1175        Bird bird_1 = new Bird();
1176        bird_1.setName(name);
1177        bird_1.setWingspan(new Double JavaDoc(2.33));
1178        Bird bird_2 = new Bird();
1179        bird_2.setName(name);
1180        bird_2.setWingspan(new Double JavaDoc(0.99));
1181
1182        Mammal mammal_1 = new Mammal();
1183        mammal_1.setName(name);
1184        mammal_1.setHeight(new Double JavaDoc(1.88));
1185        Mammal mammal_2 = new Mammal();
1186        mammal_2.setName(name);
1187        mammal_2.setHeight(new Double JavaDoc(19.13));
1188
1189        Fish fish_1 = new Fish();
1190        fish_1.setName(name);
1191        fish_1.setLength(new Double JavaDoc(0.033));
1192        Fish fish_2 = new Fish();
1193        fish_2.setName(name);
1194        fish_2.setLength(new Double JavaDoc(37.89));
1195
1196        Repository rep_1 = new Repository();
1197        rep_1.setAnimal(mammal_1);
1198        Repository rep_2 = new Repository();
1199        rep_2.setAnimal(bird_1);
1200        Repository rep_3 = new Repository();
1201        rep_3.setAnimal(fish_1);
1202
1203        /*
1204        store Repository instances and dummy animals
1205        */

1206        broker.beginTransaction();
1207        // store some dummy objects
1208
broker.store(bird_2);
1209        broker.store(mammal_2);
1210        broker.store(fish_2);
1211        // now store the main objects
1212
broker.store(rep_1);
1213        broker.store(rep_2);
1214        broker.store(rep_3);
1215        broker.commitTransaction();
1216
1217        Identity oid_rep_1 = new Identity(rep_1, broker);
1218        Identity oid_rep_2 = new Identity(rep_2, broker);
1219        Identity oid_rep_3 = new Identity(rep_3, broker);
1220
1221        broker.clearCache();
1222        // check the main objects
1223
Repository lookup_rep_1 = (Repository) broker.getObjectByIdentity(oid_rep_1);
1224        Repository lookup_rep_2 = (Repository) broker.getObjectByIdentity(oid_rep_2);
1225        Repository lookup_rep_3 = (Repository) broker.getObjectByIdentity(oid_rep_3);
1226
1227        assertNotNull(lookup_rep_1.getAnimal());
1228        assertTrue("Expected instance of Mammal, found " + lookup_rep_1.getAnimal(),
1229                lookup_rep_1.getAnimal() instanceof Mammal);
1230        assertEquals(mammal_1, lookup_rep_1.getAnimal());
1231
1232        assertNotNull(lookup_rep_2.getAnimal());
1233        assertTrue("Expected instance of Bird, found " + lookup_rep_2.getAnimal(),
1234                lookup_rep_2.getAnimal() instanceof Bird);
1235        assertEquals(bird_1, lookup_rep_2.getAnimal());
1236
1237        assertNotNull(lookup_rep_3.getAnimal());
1238        assertTrue("Expected instance of Fish, found " + lookup_rep_3.getAnimal(),
1239                lookup_rep_3.getAnimal() instanceof Fish);
1240        assertEquals(fish_1, lookup_rep_3.getAnimal());
1241
1242        broker.clearCache();
1243
1244        broker.beginTransaction();
1245        broker.delete(rep_1);
1246        broker.delete(rep_2);
1247        broker.delete(rep_3);
1248        broker.commitTransaction();
1249
1250        lookup_rep_1 = (Repository) broker.getObjectByIdentity(oid_rep_1);
1251        lookup_rep_2 = (Repository) broker.getObjectByIdentity(oid_rep_2);
1252        lookup_rep_3 = (Repository) broker.getObjectByIdentity(oid_rep_3);
1253        assertNull(lookup_rep_1);
1254        assertNull(lookup_rep_2);
1255        assertNull(lookup_rep_3);
1256
1257    }
1258
1259    private Repository[] prepareRepository(String JavaDoc referenceNamePrefix)
1260    {
1261        Reference[] ref = new Reference[]{
1262            new Reference(referenceNamePrefix + "ref_1"),
1263            new Reference(referenceNamePrefix + "ref_2"),
1264            new Reference(referenceNamePrefix + "ref_3")};
1265        ReferenceA[] refA = new ReferenceA[]{
1266            new ReferenceA(referenceNamePrefix + "refA_1", "a1"),
1267            new ReferenceA(referenceNamePrefix + "refA_2", "a2"),
1268            new ReferenceA(referenceNamePrefix + "refA_3", "a3")};
1269        ReferenceB[] refB = new ReferenceB[]{
1270            new ReferenceB(referenceNamePrefix + "refB_1", REF_TEST_STRING),
1271            new ReferenceB(referenceNamePrefix + "refB_2", "b2"),
1272            new ReferenceB(referenceNamePrefix + "refB_3", "b3")};
1273
1274        Repository repository = new Repository();
1275        repository.setRef(ref[0]);
1276        repository.setRefA(refA[0]);
1277        repository.setRefB(refB[0]);
1278
1279        Repository repository2 = new Repository();
1280        repository2.setRef(ref[1]);
1281        repository2.setRefA(refA[1]);
1282        repository2.setRefB(refB[1]);
1283
1284        Repository repository3 = new Repository();
1285        repository3.setRef(ref[2]);
1286        repository3.setRefA(refA[2]);
1287        repository3.setRefB(refB[2]);
1288
1289        return new Repository[]{repository, repository2, repository3};
1290    }
1291
1292    private RepositoryFK[] prepareRepositoryFK(String JavaDoc referenceNamePrefix)
1293    {
1294        Reference[] ref = new Reference[]{
1295            new Reference(referenceNamePrefix + "ref_1"),
1296            new Reference(referenceNamePrefix + "ref_2"),
1297            new Reference(referenceNamePrefix + "ref_3")};
1298        ReferenceA[] refA = new ReferenceA[]{
1299            new ReferenceA(referenceNamePrefix + "refA_1", "a1"),
1300            new ReferenceA(referenceNamePrefix + "refA_2", "a2"),
1301            new ReferenceA(referenceNamePrefix + "refA_3", "a3")};
1302        ReferenceB[] refB = new ReferenceB[]{
1303            new ReferenceB(referenceNamePrefix + "refB_1", REF_TEST_STRING),
1304            new ReferenceB(referenceNamePrefix + "refB_2", "b2"),
1305            new ReferenceB(referenceNamePrefix + "refB_3", "b3")};
1306
1307        RepositoryFK repository = new RepositoryFK();
1308        repository.setRef(ref[0]);
1309        repository.setRefA(refA[0]);
1310        repository.setRefB(refB[0]);
1311
1312        RepositoryFK repository2 = new RepositoryFK();
1313        repository2.setRef(ref[1]);
1314        repository2.setRefA(refA[1]);
1315        repository2.setRefB(refB[1]);
1316
1317        RepositoryFK repository3 = new RepositoryFK();
1318        repository3.setRef(ref[2]);
1319        repository3.setRefA(refA[2]);
1320        repository3.setRefB(refB[2]);
1321
1322        return new RepositoryFK[]{repository, repository2, repository3};
1323    }
1324
1325    public void testMassOperations()
1326    {
1327        broker.beginTransaction();
1328        for (int i = 1; i < 100; i++)
1329        {
1330
1331            ProductGroup pg = new ProductGroup();
1332            pg.setGroupName("1-1 test productgroup_" + i);
1333            broker.store(pg);
1334
1335            Article article = Article.createInstance();
1336            article.setArticleName("1-1 test article_" + i);
1337            article.setProductGroupId(pg.getGroupId());
1338
1339            broker.retrieveReference(article, "productGroup");
1340            broker.store(article);
1341        }
1342        broker.commitTransaction();
1343    }
1344
1345
1346
1347
1348//***************************************************************************
1349
// Inner classes used by the test case
1350
//***************************************************************************
1351

1352    public static class Repository implements Serializable JavaDoc
1353    {
1354        private Integer JavaDoc repId;
1355
1356        private Integer JavaDoc refId;
1357        private Integer JavaDoc refAId;
1358        private Integer JavaDoc refBId;
1359
1360        private ReferenceIF ref;
1361        private ReferenceAIF refA;
1362        private ReferenceBIF refB;
1363
1364        private Animal animal;
1365        private Integer JavaDoc animalId;
1366
1367        public Repository()
1368        {
1369        }
1370
1371        public Integer JavaDoc getRefId()
1372        {
1373            return refId;
1374        }
1375
1376        public void setRefId(Integer JavaDoc refId)
1377        {
1378            this.refId = refId;
1379        }
1380
1381        public Integer JavaDoc getRefAId()
1382        {
1383            return refAId;
1384        }
1385
1386        public void setRefAId(Integer JavaDoc refAId)
1387        {
1388            this.refAId = refAId;
1389        }
1390
1391        public Integer JavaDoc getRefBId()
1392        {
1393            return refBId;
1394        }
1395
1396        public void setRefBId(Integer JavaDoc refBId)
1397        {
1398            this.refBId = refBId;
1399        }
1400
1401        public Animal getAnimal()
1402        {
1403            return animal;
1404        }
1405
1406        public void setAnimal(Animal animal)
1407        {
1408            this.animal = animal;
1409        }
1410
1411        public Integer JavaDoc getAnimalId()
1412        {
1413            return animalId;
1414        }
1415
1416        public void setAnimalId(Integer JavaDoc animalId)
1417        {
1418            this.animalId = animalId;
1419        }
1420
1421        public ReferenceIF getRef()
1422        {
1423            return ref;
1424        }
1425
1426        public void setRef(ReferenceIF ref)
1427        {
1428            this.ref = ref;
1429        }
1430
1431        public ReferenceAIF getRefA()
1432        {
1433            return refA;
1434        }
1435
1436        public void setRefA(ReferenceAIF refA)
1437        {
1438            this.refA = refA;
1439        }
1440
1441        public ReferenceBIF getRefB()
1442        {
1443            return refB;
1444        }
1445
1446        public void setRefB(ReferenceBIF refB)
1447        {
1448            this.refB = refB;
1449        }
1450
1451        public Integer JavaDoc getRepId()
1452        {
1453            return repId;
1454        }
1455
1456        public void setRepId(Integer JavaDoc repId)
1457        {
1458            this.repId = repId;
1459        }
1460    }
1461
1462    //***************************************************************
1463
// classes mapped to one table
1464
//***************************************************************
1465

1466    public static class RepositoryFK extends Repository
1467    {
1468    }
1469
1470    public static interface ReferenceIF extends Serializable JavaDoc
1471    {
1472        Integer JavaDoc getRefId();
1473
1474        void setRefId(Integer JavaDoc refId);
1475
1476        String JavaDoc getName();
1477
1478        void setName(String JavaDoc name);
1479    }
1480
1481    public static interface ReferenceAIF extends Serializable JavaDoc
1482    {
1483        String JavaDoc getRefNameA();
1484
1485        void setRefNameA(String JavaDoc name);
1486    }
1487
1488    public static interface ReferenceBIF extends Serializable JavaDoc
1489    {
1490        String JavaDoc getRefNameB();
1491
1492        void setRefNameB(String JavaDoc name);
1493    }
1494
1495    public static class Reference implements ReferenceIF
1496    {
1497        protected String JavaDoc ojbConcreteClass;
1498        private Integer JavaDoc refId;
1499        private String JavaDoc name;
1500
1501        public Reference()
1502        {
1503            this(null);
1504        }
1505
1506        public Reference(String JavaDoc name)
1507        {
1508            this.name = name;
1509            ojbConcreteClass = this.getClass().getName();
1510        }
1511
1512        public String JavaDoc getOjbConcreteClass()
1513        {
1514            return ojbConcreteClass;
1515        }
1516
1517        public void setOjbConcreteClass(String JavaDoc ojbConcreteClass)
1518        {
1519            this.ojbConcreteClass = ojbConcreteClass;
1520        }
1521
1522        public Integer JavaDoc getRefId()
1523        {
1524            return refId;
1525        }
1526
1527        public void setRefId(Integer JavaDoc refId)
1528        {
1529            this.refId = refId;
1530        }
1531
1532        public String JavaDoc getName()
1533        {
1534            return name;
1535        }
1536
1537        public void setName(String JavaDoc name)
1538        {
1539            this.name = name;
1540        }
1541    }
1542
1543    public static class ReferenceA extends Reference implements ReferenceAIF
1544    {
1545        private String JavaDoc refNameA;
1546
1547        public ReferenceA()
1548        {
1549            super();
1550        }
1551
1552        public ReferenceA(String JavaDoc name, String JavaDoc refNameA)
1553        {
1554            super(name);
1555            this.refNameA = refNameA;
1556        }
1557
1558        public String JavaDoc getRefNameA()
1559        {
1560            return refNameA;
1561        }
1562
1563        public void setRefNameA(String JavaDoc refName)
1564        {
1565            this.refNameA = refName;
1566        }
1567    }
1568
1569    public static class ReferenceB extends Reference implements ReferenceBIF
1570    {
1571        private String JavaDoc refNameB;
1572
1573        public ReferenceB()
1574        {
1575            super();
1576        }
1577
1578        public ReferenceB(String JavaDoc name, String JavaDoc refNameB)
1579        {
1580            super(name);
1581            this.refNameB = refNameB;
1582        }
1583
1584        public String JavaDoc getRefNameB()
1585        {
1586            return refNameB;
1587        }
1588
1589        public void setRefNameB(String JavaDoc refName)
1590        {
1591            this.refNameB = refName;
1592        }
1593    }
1594
1595    //***************************************************************
1596
// classes mapped to multiple tables
1597
//***************************************************************
1598

1599    public static abstract class Animal
1600    {
1601        private Integer JavaDoc id;
1602        private String JavaDoc name;
1603
1604        public Integer JavaDoc getId()
1605        {
1606            return id;
1607        }
1608
1609        public void setId(Integer JavaDoc id)
1610        {
1611            this.id = id;
1612        }
1613
1614        public String JavaDoc getName()
1615        {
1616            return name;
1617        }
1618
1619        public void setName(String JavaDoc name)
1620        {
1621            this.name = name;
1622        }
1623
1624        public boolean equals(Object JavaDoc obj)
1625        {
1626            if(!(obj instanceof Animal)) return false;
1627            Animal animal = (Animal) obj;
1628            boolean result;
1629            result = name == null ? (animal.getName() == null) : name.equals(animal.getName());
1630            result = result && (id == null ? animal.getId() == null : id.equals(animal.getId()));
1631            return result;
1632        }
1633    }
1634
1635    public static class Mammal extends Animal
1636    {
1637        private Double JavaDoc height;
1638        private String JavaDoc ojbConcreteClass;
1639
1640        public Mammal()
1641        {
1642            ojbConcreteClass = Mammal.class.getName();
1643        }
1644
1645        public Double JavaDoc getHeight()
1646        {
1647            return height;
1648        }
1649
1650        public void setHeight(Double JavaDoc height)
1651        {
1652            this.height = height;
1653        }
1654
1655        public String JavaDoc getOjbConcreteClass()
1656        {
1657            return ojbConcreteClass;
1658        }
1659
1660        public void setOjbConcreteClass(String JavaDoc ojbConcreteClass)
1661        {
1662            this.ojbConcreteClass = ojbConcreteClass;
1663        }
1664
1665        public boolean equals(Object JavaDoc obj)
1666        {
1667            if(!(obj instanceof Mammal)) return false;
1668            Mammal m = (Mammal) obj;
1669            boolean result = super.equals(obj);
1670            result = result && (height == null ? m.getHeight() == null : height.equals(m.getHeight()));
1671            return result;
1672        }
1673    }
1674
1675    public static class Bird extends Animal
1676    {
1677        private Double JavaDoc wingspan;
1678        private String JavaDoc ojbConcreteClass;
1679
1680        public Bird()
1681        {
1682            ojbConcreteClass = Bird.class.getName();
1683        }
1684
1685        public boolean equals(Object JavaDoc obj)
1686        {
1687            if(!(obj instanceof Bird)) return false;
1688            Bird m = (Bird) obj;
1689            boolean result = super.equals(obj);
1690            result = result && (wingspan == null ? m.getWingspan() == null : wingspan.equals(m.getWingspan()));
1691            return result;
1692        }
1693
1694        public Double JavaDoc getWingspan()
1695        {
1696            return wingspan;
1697        }
1698
1699        public void setWingspan(Double JavaDoc wingspan)
1700        {
1701            this.wingspan = wingspan;
1702        }
1703
1704        public String JavaDoc getOjbConcreteClass()
1705        {
1706            return ojbConcreteClass;
1707        }
1708
1709        public void setOjbConcreteClass(String JavaDoc ojbConcreteClass)
1710        {
1711            this.ojbConcreteClass = ojbConcreteClass;
1712        }
1713    }
1714
1715    public static class Fish extends Animal
1716    {
1717        private Double JavaDoc length;
1718        private String JavaDoc ojbConcreteClass;
1719
1720        public Fish()
1721        {
1722            ojbConcreteClass = Fish.class.getName();
1723        }
1724
1725        public boolean equals(Object JavaDoc obj)
1726        {
1727            if(!(obj instanceof Fish)) return false;
1728            Fish m = (Fish) obj;
1729            boolean result = super.equals(obj);
1730            result = result && (length == null ? m.getLength() == null : length.equals(m.getLength()));
1731            return result;
1732        }
1733
1734        public String JavaDoc getOjbConcreteClass()
1735        {
1736            return ojbConcreteClass;
1737        }
1738
1739        public void setOjbConcreteClass(String JavaDoc ojbConcreteClass)
1740        {
1741            this.ojbConcreteClass = ojbConcreteClass;
1742        }
1743
1744        public Double JavaDoc getLength()
1745        {
1746            return length;
1747        }
1748
1749        public void setLength(Double JavaDoc length)
1750        {
1751            this.length = length;
1752        }
1753    }
1754
1755
1756    //***************************************************************
1757
// classes for test with multiple, non-autoincrement PK
1758
//***************************************************************
1759
public static class Wine
1760    {
1761        private String JavaDoc id;
1762        private String JavaDoc grape;
1763        private String JavaDoc year;
1764        private String JavaDoc regionName;
1765        private String JavaDoc regionCountry;
1766        private Region region;
1767
1768        public Wine()
1769        {
1770        }
1771
1772        public Wine(String JavaDoc id, String JavaDoc grape, String JavaDoc year, String JavaDoc regionName, String JavaDoc regionCountry)
1773        {
1774            this.id = id;
1775            this.grape = grape;
1776            this.year = year;
1777            this.regionName = regionName;
1778            this.regionCountry = regionCountry;
1779        }
1780
1781        public Region getRegion()
1782        {
1783            return region;
1784        }
1785
1786        public void setRegion(Region region)
1787        {
1788            this.region = region;
1789        }
1790
1791        public String JavaDoc getId()
1792        {
1793            return id;
1794        }
1795
1796        public void setId(String JavaDoc id)
1797        {
1798            this.id = id;
1799        }
1800
1801        public String JavaDoc getGrape()
1802        {
1803            return grape;
1804        }
1805
1806        public void setGrape(String JavaDoc grape)
1807        {
1808            this.grape = grape;
1809        }
1810
1811        public String JavaDoc getYear()
1812        {
1813            return year;
1814        }
1815
1816        public void setYear(String JavaDoc year)
1817        {
1818            this.year = year;
1819        }
1820
1821        public String JavaDoc getRegionName()
1822        {
1823            return regionName;
1824        }
1825
1826        public void setRegionName(String JavaDoc regionName)
1827        {
1828            this.regionName = regionName;
1829        }
1830
1831        public String JavaDoc getRegionCountry()
1832        {
1833            return regionCountry;
1834        }
1835
1836        public void setRegionCountry(String JavaDoc regionCountry)
1837        {
1838            this.regionCountry = regionCountry;
1839        }
1840
1841        public String JavaDoc toString()
1842        {
1843            return new ToStringBuilder(this)
1844                    .append("id", id)
1845                    .append("grape", grape)
1846                    .append("regionCountry", regionCountry)
1847                    .append("regionName", regionName)
1848                    .append("year", year)
1849                    .append("region", region)
1850                    .toString();
1851        }
1852    }
1853
1854    public static class Region
1855    {
1856        private String JavaDoc name;
1857        private String JavaDoc country;
1858        private String JavaDoc description;
1859
1860        public Region()
1861        {
1862        }
1863
1864        public Region(String JavaDoc name, String JavaDoc country, String JavaDoc description)
1865        {
1866            this.name = name;
1867            this.country = country;
1868            this.description = description;
1869        }
1870
1871        public String JavaDoc getName()
1872        {
1873            return name;
1874        }
1875
1876        public void setName(String JavaDoc name)
1877        {
1878            this.name = name;
1879        }
1880
1881        public String JavaDoc getCountry()
1882        {
1883            return country;
1884        }
1885
1886        public void setCountry(String JavaDoc country)
1887        {
1888            this.country = country;
1889        }
1890
1891        public String JavaDoc getDescription()
1892        {
1893            return description;
1894        }
1895
1896        public void setDescription(String JavaDoc description)
1897        {
1898            this.description = description;
1899        }
1900
1901        public String JavaDoc toString()
1902        {
1903            return new ToStringBuilder(this)
1904                    .append("country", country)
1905                    .append("name", name)
1906                    .append("description", description)
1907                    .toString();
1908        }
1909    }
1910
1911    public static interface RefObject
1912    {
1913        Integer JavaDoc getId();
1914        void setId(Integer JavaDoc id);
1915        String JavaDoc getName();
1916        void setName(String JavaDoc name);
1917        RefObject getRef();
1918        void setRef(RefObject ref);
1919        Integer JavaDoc getFkColRef();
1920        void setFkColRef(Integer JavaDoc id);
1921    }
1922
1923    public static class ObjA implements RefObject
1924    {
1925        Integer JavaDoc id;
1926        String JavaDoc name;
1927        RefObject ref;
1928        Integer JavaDoc fkColRef;
1929
1930        public Integer JavaDoc getId()
1931        {
1932            return id;
1933        }
1934
1935        public void setId(Integer JavaDoc id)
1936        {
1937            this.id = id;
1938        }
1939
1940        public String JavaDoc getName()
1941        {
1942            return name;
1943        }
1944
1945        public void setName(String JavaDoc name)
1946        {
1947            this.name = name;
1948        }
1949
1950        public Integer JavaDoc getFkColRef()
1951        {
1952            return fkColRef;
1953        }
1954
1955        public void setFkColRef(Integer JavaDoc fkColRef)
1956        {
1957            this.fkColRef = fkColRef;
1958        }
1959
1960        public RefObject getRef()
1961        {
1962            return ref;
1963        }
1964
1965        public void setRef(RefObject ref)
1966        {
1967            this.ref = ref;
1968        }
1969    }
1970
1971    public static class ObjB extends ObjA
1972    {
1973
1974    }
1975
1976    public static class ObjC extends ObjA
1977    {
1978        String JavaDoc nameC;
1979        List JavaDoc references;
1980
1981        public String JavaDoc getNameC()
1982        {
1983            return nameC;
1984        }
1985
1986        public void setNameC(String JavaDoc nameC)
1987        {
1988            this.nameC = nameC;
1989        }
1990
1991        public List JavaDoc getReferences()
1992        {
1993            return references;
1994        }
1995
1996        public void setReferences(List JavaDoc references)
1997        {
1998            this.references = references;
1999        }
2000    }
2001}
2002
Popular Tags