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


1 package org.apache.ojb.broker;
2
3 import java.io.Serializable ;
4 import java.util.Collection ;
5 import java.util.Iterator ;
6 import java.util.List ;
7 import java.util.ArrayList ;
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 REF_TEST_STRING = "refTest";
26
27     public static void main(String [] args)
28     {
29         String [] 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
49     {
50         String 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 refs = new ArrayList ();
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 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 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 refList = new ArrayList ();
142         refList.add(a);
143         refList.add(b2);
144         refList.add(d1);
145         c1.setReferences(refList);
146         List refList2 = new ArrayList ();
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 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 iterator = result.iterator(); iterator.hasNext();)
246         {
247             RefObject ref = (RefObject) iterator.next();
248             assertTrue(ref instanceof ObjA);
249             String 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 iterator = result.iterator(); iterator.hasNext();)
267         {
268             RefObject ref = (RefObject) iterator.next();
269             assertTrue(ref instanceof ObjA);
270             String 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 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 refList = new ArrayList ();
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 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 iterator = result.iterator(); iterator.hasNext();)
350         {
351             RefObject ref = (RefObject) iterator.next();
352             assertTrue(ref instanceof ObjA);
353             String 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 iterator = result.iterator(); iterator.hasNext();)
368         {
369             RefObject ref = (RefObject) iterator.next();
370             assertTrue(ref instanceof ObjA);
371             String 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 iterator = result.iterator(); iterator.hasNext();)
386         {
387             RefObject ref = (RefObject) iterator.next();
388             assertTrue(ref instanceof ObjA);
389             String 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 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 refList = new ArrayList ();
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 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 iterator = result.iterator(); iterator.hasNext();)
478         {
479             RefObject ref = (RefObject) iterator.next();
480             assertTrue(ref instanceof ObjA);
481             String 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
510     {
511         String timestamp = "testLookupWithMultiplePK_" + System.currentTimeMillis();
512         String regionName = "baden_" + timestamp;
513         String 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 result = broker.getCollectionByQuery(q);
554         assertEquals(1, result.size());
555     }
556
557     public void testStoreWithMultiplePK_1() throws Exception
558     {
559         String timestamp = "testStoreWithMultiplePK_1_" + System.currentTimeMillis();
560         String regionName = "baden_1" + timestamp;
561         String 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
589     {
590         String timestamp = "testStoreWithMultiplePK_2_" + System.currentTimeMillis();
591         String regionName = "baden_2" + timestamp;
592         String 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 timestamp = "testDeleteWithMultiplePK_" + System.currentTimeMillis();
622         String regionName = "baden_2" + timestamp;
623         String 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
668     {
669         String timestamp = "testStoreWithMultiplePK_3_" + System.currentTimeMillis();
670         String regionName = "baden_3" + timestamp;
671         String 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 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 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 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 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 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 it = result.iterator();
779         Object 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 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[