KickJava   Java API By Example, From Geeks To Geeks.

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


1 package org.apache.ojb.broker;
2
3 import junit.framework.Assert;
4 import junit.framework.TestCase;
5 import org.apache.ojb.broker.query.Criteria;
6 import org.apache.ojb.broker.query.QueryByCriteria;
7 import org.apache.ojb.broker.metadata.MetadataManager;
8 import org.apache.ojb.broker.metadata.ConnectionRepository;
9 import org.apache.ojb.broker.metadata.JdbcConnectionDescriptor;
10 import org.apache.commons.lang.builder.ToStringBuilder;
11 import org.apache.commons.lang.builder.ToStringStyle;
12
13 import java.sql.Connection JavaDoc;
14 import java.util.Collection JavaDoc;
15
16 /**
17  * Test to check support for multiple DB.
18  *
19  * @author <a HREF="mailto:armin@codeAuLait.de">Armin Waibel</a>
20  */

21 public class MultipleDBTest extends TestCase
22 {
23     private static final String JavaDoc REFERENCE_NAME = "Test reference";
24
25     public MultipleDBTest(String JavaDoc s)
26     {
27         super(s);
28     }
29
30     protected void setUp() throws Exception JavaDoc
31     {
32         super.setUp();
33         MetadataManager mm = MetadataManager.getInstance();
34         JdbcConnectionDescriptor jcd = mm.connectionRepository().getDescriptor(TestHelper.FAR_AWAY_KEY);
35         if(jcd == null)
36         {
37             ConnectionRepository cr = mm.readConnectionRepository(TestHelper.FAR_AWAY_CONNECTION_REPOSITORY);
38             mm.connectionRepository().addDescriptor(cr.getDescriptor(TestHelper.FAR_AWAY_KEY));
39         }
40     }
41
42     protected void tearDown() throws Exception JavaDoc
43     {
44         MetadataManager mm = MetadataManager.getInstance();
45         JdbcConnectionDescriptor jcd = mm.connectionRepository().getDescriptor(TestHelper.FAR_AWAY_KEY);
46         mm.connectionRepository().removeDescriptor(jcd);
47         super.tearDown();
48     }
49
50     public static void main(String JavaDoc[] args)
51     {
52         String JavaDoc[] arr = {MultipleDBTest.class.getName()};
53         junit.textui.TestRunner.main(arr);
54     }
55
56     /**
57      * This test show how it is possible to materialize an object
58      * with a collection of objects retrieved from a different DB
59      * NOTE: This is not a recommended design, but it works.
60      */

61     public void testMaterializeFromDifferentDB()
62     {
63         String JavaDoc name = "testMaterializeFromDifferentDB" + System.currentTimeMillis();
64         PersistenceBroker broker = PersistenceBrokerFactory.defaultPersistenceBroker();
65         PersistenceBroker brokerFarAway = PersistenceBrokerFactory.createPersistenceBroker(TestHelper.FAR_AWAY_KEY);
66
67         MultipleObject obj = new MultipleObject();
68         obj.setName(name);
69         broker.beginTransaction();
70         broker.store(obj);
71         broker.commitTransaction();
72
73         Identity oid = new Identity(obj, broker);
74
75         MultipleObjectRef ref_1 = new MultipleObjectRef();
76         MultipleObjectRef ref_2 = new MultipleObjectRef();
77         ref_1.setName(name);
78         ref_1.setRefId(obj.getId());
79         ref_2.setName(name);
80         ref_2.setRefId(obj.getId());
81
82         brokerFarAway.beginTransaction();
83         brokerFarAway.store(ref_1);
84         brokerFarAway.store(ref_2);
85         brokerFarAway.commitTransaction();
86
87         broker.clearCache();
88         brokerFarAway.clearCache();
89
90         MultipleObject newObj = (MultipleObject)broker.getObjectByIdentity(oid);
91         brokerFarAway.retrieveAllReferences(newObj);
92
93         assertNotNull(newObj.getReferences());
94         assertEquals(2, newObj.getReferences().size());
95         // System.out.println("## " + newObj);
96
}
97
98     /**
99      * test PB instance lookup using different
100      * PBKey constructors + databases
101      */

102     public void testLookupByPBKey()
103     {
104         PBKey pb_1a = new PBKey(TestHelper.DEF_JCD_ALIAS);
105         PBKey pb_1b = new PBKey(TestHelper.DEF_JCD_ALIAS, null, null);
106         PBKey pb_1c = new PBKey(TestHelper.DEF_JCD_ALIAS, TestHelper.DEF_USER, TestHelper.DEF_PASSWORD);
107
108         PBKey pb_2a = new PBKey(TestHelper.FAR_AWAY_JCD_ALIAS);
109         PBKey pb_2b = new PBKey(TestHelper.FAR_AWAY_JCD_ALIAS, null, null);
110
111         PersistenceBroker b1a = PersistenceBrokerFactory.createPersistenceBroker(pb_1a);
112         PersistenceBroker b1b = PersistenceBrokerFactory.createPersistenceBroker(pb_1b);
113         PersistenceBroker b1c = PersistenceBrokerFactory.createPersistenceBroker(pb_1c);
114         PersistenceBroker b2a = PersistenceBrokerFactory.createPersistenceBroker(pb_2a);
115         PersistenceBroker b2b = PersistenceBrokerFactory.createPersistenceBroker(pb_2b);
116
117         assertNotNull(b1a);
118         assertNotNull(b1b);
119         assertNotNull(b1c);
120         assertNotNull(b2a);
121         assertNotNull(b2b);
122
123         if(b1a != null) b1a.close();
124         if(b1b != null) b1b.close();
125         if(b1c != null) b1c.close();
126         if(b2a != null) b2a.close();
127         if(b2b != null) b2b.close();
128     }
129
130     public void testPBLookupConnection() throws Exception JavaDoc
131     {
132         PBKey key = new PBKey(TestHelper.FAR_AWAY_JCD_ALIAS);
133         PersistenceBroker broker = PersistenceBrokerFactory.createPersistenceBroker(key);
134         // get connection to check lookup
135
Connection JavaDoc con = broker.serviceConnectionManager().getConnection();
136         con.isClosed();
137         assertNotNull(broker);
138         assertEquals(key.getAlias(), broker.getPBKey().getAlias());
139         broker.close();
140
141         key = new PBKey(TestHelper.DEF_JCD_ALIAS);
142         broker = PersistenceBrokerFactory.createPersistenceBroker(key);
143         // get connection to check lookup
144
con = broker.serviceConnectionManager().getConnection();
145         con.isClosed();
146         assertNotNull(broker);
147         assertEquals(key.getAlias(), broker.getPBKey().getAlias());
148         broker.close();
149     }
150
151     public void testPBCreation() throws Exception JavaDoc
152     {
153         PersistenceBroker defPB = null;
154         PersistenceBroker secPB = null;
155
156         try
157         {
158             defPB = PersistenceBrokerFactory.defaultPersistenceBroker();
159             PBKey secKey = TestHelper.FAR_AWAY_KEY;
160             secPB = PersistenceBrokerFactory.createPersistenceBroker(secKey);
161
162             Assert.assertNotNull("Cannot lookup default PB", defPB);
163             Assert.assertNotNull("Cannot lookup PB for PBKey: " + secKey, secPB);
164             Assert.assertEquals("Different repository files for second db",
165                     secPB.getPBKey().getAlias(), secKey.getAlias());
166         }
167         finally
168         {
169             if (defPB != null) defPB.close();
170             if (secPB != null) secPB.close();
171         }
172
173     }
174
175     /**
176      * Insert/delete the same object with given id in two different DB
177      */

178     public void testInsertDeleteNoAutoSequence() throws Exception JavaDoc
179     {
180         Article article = createArticleWithId(Integer.MAX_VALUE - 1001);
181         PBKey secKey = TestHelper.FAR_AWAY_KEY;
182
183         FarAwayClass fa = createFarAwayObjectWithId(Integer.MAX_VALUE - 1002);
184         PersistenceBroker secPB = PersistenceBrokerFactory.createPersistenceBroker(secKey);
185         secPB.beginTransaction();
186         secPB.store(fa);
187         secPB.commitTransaction();
188         secPB.close();
189
190         PersistenceBroker defPB = PersistenceBrokerFactory.defaultPersistenceBroker();
191         defPB.beginTransaction();
192         defPB.store(article);
193         defPB.commitTransaction();
194         defPB.close();
195
196
197
198         secPB = PersistenceBrokerFactory.createPersistenceBroker(secKey);
199         secPB.clearCache();
200         Object JavaDoc[] pks = {new Integer JavaDoc(fa.getId())};
201         Identity oid = new Identity(FarAwayClass.class, FarAwayClass.class, pks);
202         FarAwayClass fa2 = (FarAwayClass) secPB.getObjectByIdentity(oid);
203         Assert.assertNotNull("Lookup for article in second DB failed", fa2);
204         Assert.assertEquals(fa.toString(), fa2.toString());
205         secPB.close();
206
207         defPB = PersistenceBrokerFactory.defaultPersistenceBroker();
208         defPB.clearCache();
209         Identity oid2 = defPB.serviceIdentity().buildIdentity(Article.class, article.getArticleId());
210         Article article2 = (Article) defPB.getObjectByIdentity(oid2);
211         Assert.assertNotNull("Lookup for article in default DB failed", article2);
212         defPB.close();
213
214         secPB = PersistenceBrokerFactory.createPersistenceBroker(secKey);
215         secPB.beginTransaction();
216         secPB.delete(fa);
217         secPB.commitTransaction();
218         secPB.close();
219
220         defPB = PersistenceBrokerFactory.defaultPersistenceBroker();
221         defPB.beginTransaction();
222         defPB.delete(article);
223         defPB.commitTransaction();
224         defPB.close();
225     }
226
227     /**
228      * Insert/delete objects in two different DB, use auto-generated keys
229      */

230     public void testInsertDeleteAutoSequenceClearCache() throws Exception JavaDoc
231     {
232         Article article = createArticle();
233         PBKey secKey = TestHelper.FAR_AWAY_KEY;
234
235         FarAwayClass fa = createFarAwayObject();
236         PersistenceBroker farAwayPB = PersistenceBrokerFactory.createPersistenceBroker(secKey);
237         farAwayPB.clearCache();
238         farAwayPB.beginTransaction();
239         farAwayPB.store(fa);
240         farAwayPB.commitTransaction();
241         farAwayPB.close();
242
243         PersistenceBroker defaultPB = PersistenceBrokerFactory.defaultPersistenceBroker();
244         defaultPB.clearCache();
245         defaultPB.beginTransaction();
246         defaultPB.store(article);
247         defaultPB.commitTransaction();
248         defaultPB.close();
249
250         farAwayPB = PersistenceBrokerFactory.createPersistenceBroker(secKey);
251         farAwayPB.clearCache();
252         Object JavaDoc[] pks = {new Integer JavaDoc(fa.getId())};
253         Identity oid = new Identity(FarAwayClass.class, FarAwayClass.class, pks);
254         FarAwayClass fa2 = (FarAwayClass) farAwayPB.getObjectByIdentity(oid);
255         Assert.assertNotNull("Lookup for article in second DB failed", fa2);
256         Assert.assertEquals(fa.toString(), fa2.toString());
257         farAwayPB.close();
258
259         defaultPB = PersistenceBrokerFactory.defaultPersistenceBroker();
260         defaultPB.clearCache();
261         Identity oid2 = defaultPB.serviceIdentity().buildIdentity(Article.class, article.getArticleId());
262         Article article2 = (Article) defaultPB.getObjectByIdentity(oid2);
263         Assert.assertNotNull("Lookup for article in default DB failed", article2);
264         defaultPB.close();
265
266         farAwayPB = PersistenceBrokerFactory.createPersistenceBroker(secKey);
267         farAwayPB.clearCache();
268         farAwayPB.beginTransaction();
269         farAwayPB.delete(fa);
270         farAwayPB.commitTransaction();
271         farAwayPB.close();
272
273         defaultPB = PersistenceBrokerFactory.defaultPersistenceBroker();
274         defaultPB.clearCache();
275         defaultPB.beginTransaction();
276         defaultPB.delete(article);
277         defaultPB.commitTransaction();
278         defaultPB.close();
279     }
280
281     /**
282      * Insert/delete objects in two different DB, use auto-generated keys
283      */

284     public void testInsertDeleteAutoSequence() throws Exception JavaDoc
285     {
286         Article article = createArticle();
287         PBKey secKey = TestHelper.FAR_AWAY_KEY;
288
289         PersistenceBroker defaultPB = PersistenceBrokerFactory.defaultPersistenceBroker();
290         defaultPB.beginTransaction();
291         defaultPB.store(article);
292         defaultPB.commitTransaction();
293         defaultPB.close();
294
295         FarAwayClass fa = createFarAwayObject();
296         PersistenceBroker farAwayPB = PersistenceBrokerFactory.createPersistenceBroker(secKey);
297         farAwayPB.beginTransaction();
298         farAwayPB.store(fa);
299         farAwayPB.commitTransaction();
300         farAwayPB.close();
301
302         farAwayPB = PersistenceBrokerFactory.createPersistenceBroker(secKey);
303         Object JavaDoc[] pks = {new Integer JavaDoc(fa.getId())};
304         Identity oid = new Identity(FarAwayClass.class, FarAwayClass.class, pks);
305         FarAwayClass fa2 = (FarAwayClass) farAwayPB.getObjectByIdentity(oid);
306         Assert.assertNotNull("Lookup for article in second DB failed", fa2);
307         Assert.assertEquals(fa.toString(), fa2.toString());
308         farAwayPB.close();
309
310         defaultPB = PersistenceBrokerFactory.defaultPersistenceBroker();
311         Identity oid2 = defaultPB.serviceIdentity().buildIdentity(Article.class, article.getArticleId());
312         Article article2 = (Article) defaultPB.getObjectByIdentity(oid2);
313         Assert.assertNotNull("Lookup for article in default DB failed", article2);
314         defaultPB.close();
315
316         farAwayPB = PersistenceBrokerFactory.createPersistenceBroker(secKey);
317         farAwayPB.beginTransaction();
318         farAwayPB.delete(fa);
319         farAwayPB.commitTransaction();
320         farAwayPB.close();
321
322         defaultPB = PersistenceBrokerFactory.defaultPersistenceBroker();
323         defaultPB.beginTransaction();
324         defaultPB.delete(article);
325         defaultPB.commitTransaction();
326         defaultPB.close();
327     }
328
329     /**
330      * tests if references work on second database
331      */

332     public void testWithReference() throws Exception JavaDoc
333     {
334         PBKey secKey = TestHelper.FAR_AWAY_KEY;
335         FarAwayClass f1 = doReferenceMatchingStore(secKey);
336         FarAwayClass f2 = doReferenceMatchingStore(secKey);
337
338         PersistenceBroker broker = null;
339         try
340         {
341             broker = PersistenceBrokerFactory.createPersistenceBroker(secKey);
342             broker.clearCache();
343             Identity oid = new Identity(f1,broker);
344             FarAwayClass fac = (FarAwayClass) broker.getObjectByIdentity(oid);
345             FarAwayReferenceIF ref = fac.getReference();
346             assertNotNull(ref);
347             assertEquals(REFERENCE_NAME, ref.getName());
348         }
349         finally
350         {
351             if(broker != null) broker.close();
352         }
353
354         doReferenceMatchingDelete(secKey, f1);
355         doReferenceMatchingDelete(secKey, f2);
356     }
357
358     private FarAwayClass doReferenceMatchingStore(PBKey key) throws Exception JavaDoc
359     {
360         FarAwayClass fa = createFarAwayObject();
361         FarAwayReferenceIF ref = new FarAwayReference();
362         ref.setName(REFERENCE_NAME);
363
364         PersistenceBroker farAwayPB = PersistenceBrokerFactory.createPersistenceBroker(key);
365         farAwayPB.beginTransaction();
366         farAwayPB.store(ref);
367         fa.setReference(ref);
368         farAwayPB.store(fa);
369         farAwayPB.commitTransaction();
370         farAwayPB.close();
371
372         farAwayPB = PersistenceBrokerFactory.createPersistenceBroker(key);
373         Criteria criteria = new Criteria();
374         criteria.addEqualTo("id", new Integer JavaDoc(fa.getId()));
375         FarAwayClass result = (FarAwayClass)farAwayPB.getObjectByQuery(
376                 new QueryByCriteria(FarAwayClass.class, criteria));
377         farAwayPB.close();
378
379         int refId = result.getReference().getId();
380         assertEquals(ref.getId(), refId);
381         return result;
382     }
383
384     private void doReferenceMatchingDelete(PBKey key, FarAwayClass farAwayClass) throws Exception JavaDoc
385     {
386         Integer JavaDoc refId = farAwayClass.getReferenceId();
387         Integer JavaDoc mainId = new Integer JavaDoc(farAwayClass.getId());
388         PersistenceBroker broker = PersistenceBrokerFactory.createPersistenceBroker(key);
389         try
390         {
391             Criteria criteria = new Criteria();
392             criteria.addEqualTo("id", mainId);
393             FarAwayClass result = (FarAwayClass) broker.getObjectByQuery(
394                     new QueryByCriteria(FarAwayClass.class, criteria));
395             assertNotNull("Object not found", result);
396
397             Criteria criteriaRef = new Criteria();
398             criteriaRef.addEqualTo("id", refId);
399             FarAwayReferenceIF resultRef = (FarAwayReferenceIF) broker.getObjectByQuery(
400                     new QueryByCriteria(FarAwayReference.class, criteriaRef));
401             assertNotNull("Object not found", result);
402
403             broker.beginTransaction();
404             broker.delete(farAwayClass);
405             broker.commitTransaction();
406
407             criteria = new Criteria();
408             criteria.addEqualTo("id", mainId);
409             result = (FarAwayClass) broker.getObjectByQuery(
410                     new QueryByCriteria(FarAwayClass.class, criteria));
411             assertNull("Object was not deleted", result);
412
413             criteriaRef = new Criteria();
414             criteriaRef.addEqualTo("id", refId);
415             resultRef = (FarAwayReferenceIF) broker.getObjectByQuery(
416                     new QueryByCriteria(FarAwayReference.class, criteriaRef));
417             assertNull("Reference object was not deleted", resultRef);
418         }
419         finally
420         {
421             if(broker != null) broker.close();
422         }
423     }
424
425
426     /**
427      * factory method that createa an PerformanceArticle
428      * @return the created PerformanceArticle object
429      * @param id the primary key value for the new object
430      */

431     private Article createArticleWithId(int id)
432     {
433         Article ret = createArticle();
434         ret.setArticleId(new Integer JavaDoc(id));
435         return ret;
436     }
437
438     private FarAwayClass createFarAwayObjectWithId(int id)
439     {
440         FarAwayClass fa = createFarAwayObject();
441         fa.setId(id);
442         return fa;
443     }
444
445     private FarAwayClass createFarAwayObject()
446     {
447         FarAwayClass fa = new FarAwayClass();
448         fa.setName("away from " + counter);
449         fa.setDescription("so far away from " + counter);
450         return fa;
451     }
452
453     private static int counter;
454
455     /**
456      * factory method that createa an PerformanceArticle
457      * @return the created PerformanceArticle object
458      */

459     private Article createArticle()
460     {
461         Article a = new Article();
462         a.setArticleName("New Performance Article " + (++counter));
463         a.setMinimumStock(100);
464         a.setOrderedUnits(17);
465         a.setPrice(0.45);
466         a.setStock(234);
467         a.setSupplierId(4);
468         a.setUnit("bottle");
469         return a;
470     }
471
472     //***********************************************************************
473
// inner classes used by test case
474
//***********************************************************************
475
public static class MultipleObject
476     {
477         Integer JavaDoc id;
478         String JavaDoc name;
479         Collection JavaDoc references;
480
481         public MultipleObject()
482         {
483         }
484
485         public Integer JavaDoc getId()
486         {
487             return id;
488         }
489
490         public void setId(Integer JavaDoc id)
491         {
492             this.id = id;
493         }
494
495         public String JavaDoc getName()
496         {
497             return name;
498         }
499
500         public void setName(String JavaDoc name)
501         {
502             this.name = name;
503         }
504
505         public Collection JavaDoc getReferences()
506         {
507             return references;
508         }
509
510         public void setReferences(Collection JavaDoc references)
511         {
512             this.references = references;
513         }
514
515         public String JavaDoc toString()
516         {
517             return ToStringBuilder.reflectionToString(this, ToStringStyle.MULTI_LINE_STYLE);
518         }
519     }
520
521     public static class MultipleObjectRef
522     {
523         Integer JavaDoc id;
524         Integer JavaDoc refId;
525         String JavaDoc name;
526
527         public MultipleObjectRef()
528         {
529         }
530
531         public Integer JavaDoc getId()
532         {
533             return id;
534         }
535
536         public void setId(Integer JavaDoc id)
537         {
538             this.id = id;
539         }
540
541         public Integer JavaDoc getRefId()
542         {
543             return refId;
544         }
545
546         public void setRefId(Integer JavaDoc refId)
547         {
548             this.refId = refId;
549         }
550
551         public String JavaDoc getName()
552         {
553             return name;
554         }
555
556         public void setName(String JavaDoc name)
557         {
558             this.name = name;
559         }
560
561         public String JavaDoc toString()
562         {
563             return ToStringBuilder.reflectionToString(this, ToStringStyle.DEFAULT_STYLE);
564         }
565     }
566 }
567
Popular Tags