001: /*
002: * Copyright 2001-2007 Geert Bevin <gbevin[remove] at uwyn dot com> and
003: * JR Boyens <gnu-jrb[remove] at gmx dot net>
004: * Distributed under the terms of either:
005: * - the common development and distribution license (CDDL), v1.0; or
006: * - the GNU Lesser General Public License, v2.1 or later
007: * $Id: TestGenericQueryManagerManyToOne.java 3735 2007-05-04 23:08:07Z gbevin $
008: */
009: package com.uwyn.rife.database.querymanagers.generic;
010:
011: import com.uwyn.rife.database.Datasource;
012: import com.uwyn.rife.site.ValidationError;
013: import com.uwyn.rifetestmodels.MOFirstBean;
014: import com.uwyn.rifetestmodels.MOSecondBean;
015: import com.uwyn.rifetestmodels.MOThirdBean;
016: import java.util.ArrayList;
017: import java.util.Collection;
018: import java.util.Iterator;
019: import java.util.List;
020: import junit.framework.TestCase;
021:
022: public class TestGenericQueryManagerManyToOne extends TestCase {
023: private Datasource mDatasource = null;
024:
025: private GenericQueryManager<MOFirstBean> mFirstManager = null;
026: private GenericQueryManager<MOSecondBean> mSecondManager = null;
027: private GenericQueryManager<MOThirdBean> mThirdManager = null;
028:
029: public TestGenericQueryManagerManyToOne(Datasource datasource,
030: String datasourceName, String name) {
031: super (name);
032: mDatasource = datasource;
033: }
034:
035: protected void setUp() throws Exception {
036: mFirstManager = GenericQueryManagerFactory.getInstance(
037: mDatasource, MOFirstBean.class);
038: mSecondManager = GenericQueryManagerFactory.getInstance(
039: mDatasource, MOSecondBean.class);
040: mThirdManager = GenericQueryManagerFactory.getInstance(
041: mDatasource, MOThirdBean.class);
042:
043: int poolsize = mDatasource.getPoolsize();
044: // disabling pool for firebird
045: if ("org.firebirdsql.jdbc.FBDriver".equals(mDatasource
046: .getAliasedDriver())) {
047: mDatasource.setPoolsize(0);
048: }
049: try {
050: mThirdManager.install();
051: mSecondManager.install();
052: mFirstManager.install();
053: } finally {
054: if ("org.firebirdsql.jdbc.FBDriver".equals(mDatasource
055: .getAliasedDriver())) {
056: mDatasource.setPoolsize(poolsize);
057: }
058: }
059: }
060:
061: protected void tearDown() throws Exception {
062: int poolsize = mDatasource.getPoolsize();
063: // disabling pool for firebird
064: if ("org.firebirdsql.jdbc.FBDriver".equals(mDatasource
065: .getAliasedDriver())) {
066: mDatasource.setPoolsize(0);
067: }
068: try {
069: mFirstManager.remove();
070: mSecondManager.remove();
071: mThirdManager.remove();
072: } finally {
073: if ("org.firebirdsql.jdbc.FBDriver".equals(mDatasource
074: .getAliasedDriver())) {
075: mDatasource.setPoolsize(poolsize);
076: }
077: }
078: }
079:
080: public void testGetBaseClass() {
081: assertSame(MOFirstBean.class, mFirstManager.getBaseClass());
082: assertSame(MOSecondBean.class, mSecondManager.getBaseClass());
083: }
084:
085: public void testInstallCustomQuery() {
086: int poolsize = mDatasource.getPoolsize();
087: // disabling pool for firebird
088: if ("org.firebirdsql.jdbc.FBDriver".equals(mDatasource
089: .getAliasedDriver())) {
090: mDatasource.setPoolsize(0);
091: }
092: try {
093: mFirstManager.remove();
094: mSecondManager.remove();
095:
096: mSecondManager.install(mSecondManager
097: .getInstallTableQuery());
098: mFirstManager.install(mFirstManager.getInstallTableQuery());
099: } finally {
100: if ("org.firebirdsql.jdbc.FBDriver".equals(mDatasource
101: .getAliasedDriver())) {
102: mDatasource.setPoolsize(poolsize);
103: }
104: }
105: }
106:
107: public void testSaveRestoreConstrained() {
108: MOFirstBean bean = new MOFirstBean();
109: MOFirstBean newbean = null;
110:
111: bean.setFirstString("This is my test string");
112:
113: // add the many-to-one relations to the bean instance
114: MOSecondBean bean2a = new MOSecondBean();
115: bean2a.setSecondString("MOSecondBeanA");
116:
117: MOSecondBean bean2b = new MOSecondBean();
118: bean2b.setSecondString("MOSecondBeanB");
119:
120: MOThirdBean bean3 = new MOThirdBean();
121: bean3.setThirdString("MOThirdBean");
122:
123: bean.setSecondBean(bean2a);
124: bean.setSecondBean2(bean2b);
125: bean.setThirdBean(bean3);
126:
127: // assert that the many-to-one relations have not been saved too
128: assertNull(bean2a.getIdentifier());
129: assertNull(bean2b.getIdentifier());
130: assertNull(bean3.getId());
131:
132: // save the bean instance
133: Integer id = mFirstManager.save(bean);
134:
135: // assert that the many-to-one relations have been saved too
136: assertNotNull(bean2a.getIdentifier());
137: assertNotNull(bean2b.getIdentifier());
138: assertNotNull(bean3.getId());
139:
140: // restore the bean instance
141: newbean = mFirstManager.restore(id);
142:
143: // assert that the bean has correctly been restored
144: assertTrue(newbean != null);
145: assertTrue(newbean != bean);
146: assertEquals(newbean.getFirstString(), bean.getFirstString());
147: assertEquals(newbean.getIdentifier(), id);
148:
149: // assert that the many-to-one relationships have correctly been restored
150: MOSecondBean secondbean = newbean.getSecondBean();
151: assertNotNull(secondbean);
152: assertEquals(bean2a.getIdentifier(), secondbean.getIdentifier());
153: assertEquals(bean2a.getSecondString(), secondbean
154: .getSecondString());
155:
156: // assert that exactly the same instance is returned the next time the property is retrieved
157: assertSame(secondbean, newbean.getSecondBean());
158: assertSame(secondbean, newbean.getSecondBean());
159:
160: // set the property to null to cause a new instance to be fetched
161: newbean.setSecondBean(null);
162: MOSecondBean secondbeanb = newbean.getSecondBean();
163: assertNotNull(secondbeanb);
164: assertEquals(secondbeanb.getIdentifier(), secondbean
165: .getIdentifier());
166: assertEquals(secondbeanb.getSecondString(), secondbean
167: .getSecondString());
168: assertNotSame(secondbeanb, secondbean);
169:
170: // assert that the other many-to-one relationships have correctly been restored
171: MOSecondBean secondbean2 = newbean.getSecondBean2();
172: assertNotNull(secondbean2);
173: assertEquals(bean2b.getIdentifier(), secondbean2
174: .getIdentifier());
175: assertEquals(bean2b.getSecondString(), secondbean2
176: .getSecondString());
177:
178: MOThirdBean thirdbean = newbean.getThirdBean();
179: assertNotNull(thirdbean);
180: assertEquals(bean3.getId(), thirdbean.getId());
181: assertEquals(bean3.getThirdString(), thirdbean.getThirdString());
182:
183: // perform update with changed many-to-one relationships
184: // only the data of those that haven't been saved before will
185: // be stored
186: bean.setIdentifier(id);
187: bean.setFirstString("This is a new test string");
188:
189: bean2a.setSecondString("MOSecondBeanAUpdated");
190:
191: MOSecondBean bean2c = new MOSecondBean();
192: bean2c.setSecondString("MOSecondBeanC");
193: bean.setSecondBean2(bean2c);
194:
195: assertEquals(mFirstManager.save(bean), id.intValue());
196: assertEquals(bean.getIdentifier(), id);
197:
198: // restore the updated bean
199: newbean = mFirstManager.restore(id);
200:
201: assertTrue(newbean != null);
202: assertTrue(newbean != bean);
203:
204: // assert that the updated bean has been stored correctly
205: assertEquals(newbean.getFirstString(),
206: "This is a new test string");
207:
208: // assert that the many-to-one relationships have correctly been stored and restored
209: secondbean = newbean.getSecondBean();
210: assertNotNull(secondbean);
211: assertEquals(bean2a.getIdentifier(), secondbean.getIdentifier());
212: // the data of this many-to-one association hasn't been updated since the entity already was saved before
213: assertFalse(bean2a.getSecondString().equals(
214: secondbean.getSecondString()));
215:
216: MOSecondBean secondbean3 = newbean.getSecondBean2();
217: assertNotNull(secondbean3);
218: assertEquals(bean2c.getIdentifier(), secondbean3
219: .getIdentifier());
220: assertEquals(bean2c.getSecondString(), secondbean3
221: .getSecondString());
222:
223: thirdbean = newbean.getThirdBean();
224: assertNotNull(thirdbean);
225: assertEquals(bean3.getId(), thirdbean.getId());
226: assertEquals(bean3.getThirdString(), thirdbean.getThirdString());
227: }
228:
229: public void testSaveRestoreConstrainedAssociation() {
230: MOFirstBean bean1a = new MOFirstBean();
231: bean1a.setFirstString("This is my test string");
232: MOSecondBean bean2 = new MOSecondBean();
233: bean2.setSecondString("MOSecondBeanA");
234: bean1a.setSecondBean(bean2);
235:
236: // save the bean instance
237: Integer id = mFirstManager.save(bean1a);
238:
239: // save a second instance of the first bean type
240: MOFirstBean bean1b = new MOFirstBean();
241: bean1b.setFirstString("This is my test string B");
242: bean1b.setSecondBean(bean2);
243: mFirstManager.save(bean1b);
244:
245: // restore the second bean
246: MOSecondBean secondbean = mSecondManager.restore(bean2
247: .getIdentifier());
248:
249: // assert that the second bean association links are correct
250: Collection<MOFirstBean> firstbeans = secondbean.getFirstBeans();
251: assertNotNull(firstbeans);
252: assertEquals(2, firstbeans.size());
253: for (MOFirstBean bean_assoc_restored : firstbeans) {
254: if (bean_assoc_restored.getIdentifier().equals(
255: bean1a.getIdentifier())) {
256: assertEquals(bean_assoc_restored.getFirstString(),
257: bean1a.getFirstString());
258: } else if (bean_assoc_restored.getIdentifier().equals(
259: bean1b.getIdentifier())) {
260: assertEquals(bean_assoc_restored.getFirstString(),
261: bean1b.getFirstString());
262: } else {
263: fail();
264: }
265: assertEquals(bean2.getIdentifier(), bean_assoc_restored
266: .getSecondBean().getIdentifier());
267: assertEquals(bean2.getSecondString(), bean_assoc_restored
268: .getSecondBean().getSecondString());
269: }
270:
271: // store the second bean with updated links
272: firstbeans.remove(firstbeans.iterator().next());
273: mSecondManager.save(secondbean);
274: secondbean = mSecondManager.restore(bean2.getIdentifier());
275: firstbeans = secondbean.getFirstBeans();
276: assertNotNull(firstbeans);
277: assertEquals(1, firstbeans.size());
278:
279: // save a third instance of the first bean type and an updated
280: // version of the first instance, which will not be saved
281: MOFirstBean bean1c = new MOFirstBean();
282: bean1b.setFirstString("This is my test string C");
283: assertNull(bean1c.getIdentifier());
284: List<MOFirstBean> firstbeans2 = new ArrayList<MOFirstBean>();
285: firstbeans2.add(bean1a);
286: bean1a.setFirstString("This is my test string updated");
287: firstbeans2.add(bean1c);
288: secondbean.setFirstBeans(firstbeans2);
289: mSecondManager.save(secondbean);
290: assertNotNull(bean1c.getIdentifier());
291:
292: secondbean = mSecondManager.restore(bean2.getIdentifier());
293: firstbeans = secondbean.getFirstBeans();
294: assertNotNull(firstbeans);
295: assertEquals(2, firstbeans.size());
296: for (MOFirstBean bean_assoc_restored : firstbeans) {
297: if (bean_assoc_restored.getIdentifier().equals(
298: bean1a.getIdentifier())) {
299: assertEquals(bean_assoc_restored.getFirstString(),
300: "This is my test string");
301: assertFalse(bean_assoc_restored.getFirstString()
302: .equals(bean1a.getFirstString()));
303: } else if (bean_assoc_restored.getIdentifier().equals(
304: bean1c.getIdentifier())) {
305: assertEquals(bean_assoc_restored.getFirstString(),
306: bean1c.getFirstString());
307: } else {
308: fail();
309: }
310: assertEquals(bean2.getIdentifier(), bean_assoc_restored
311: .getSecondBean().getIdentifier());
312: assertEquals(bean2.getSecondString(), bean_assoc_restored
313: .getSecondBean().getSecondString());
314: }
315: }
316:
317: public void testDelete() {
318: assertEquals(0, mSecondManager.count());
319: assertEquals(0, mThirdManager.count());
320:
321: MOFirstBean bean = new MOFirstBean();
322:
323: bean.setFirstString("This is my test string");
324:
325: // add the many-to-one relations to the bean instance
326: MOSecondBean bean2a = new MOSecondBean();
327: bean2a.setSecondString("MOSecondBeanA");
328:
329: MOThirdBean bean3 = new MOThirdBean();
330: bean3.setThirdString("MOThirdBean");
331:
332: bean.setSecondBean(bean2a);
333: bean.setThirdBean(bean3);
334:
335: // save the bean instance
336: Integer id1 = mFirstManager.save(bean);
337:
338: // ensure that everything was saved correctly
339: assertTrue(mFirstManager.restore(id1) != null);
340: assertEquals(1, mSecondManager.count());
341: assertEquals(1, mThirdManager.count());
342:
343: // delete the first bean
344: mFirstManager.delete(id1);
345:
346: // ensure that everything was deleted correctly
347: assertNull(mFirstManager.restore(id1));
348: assertEquals(1, mSecondManager.count());
349: assertEquals(1, mThirdManager.count());
350:
351: // add another many-to-one relationship
352: MOSecondBean bean2c = new MOSecondBean();
353: bean2c.setSecondString("MOSecondBeanC");
354:
355: bean.setSecondBean2(bean2c);
356:
357: // save the bean instance again
358: Integer id2 = mFirstManager.save(bean);
359:
360: // ensure that everything was saved correctly
361: assertTrue(mFirstManager.restore(id2) != null);
362: assertEquals(2, mSecondManager.count());
363: assertEquals(1, mThirdManager.count());
364:
365: // delete the second bean
366: mFirstManager.delete(id2);
367:
368: // ensure that everything was deleted correctly
369: assertNull(mFirstManager.restore(id2));
370: assertEquals(2, mSecondManager.count());
371: assertEquals(1, mThirdManager.count());
372: }
373:
374: public void testDeleteAssociation() {
375: final MOFirstBean bean1a = new MOFirstBean();
376: bean1a.setFirstString("This is my test string");
377:
378: final MOFirstBean bean1b = new MOFirstBean();
379: bean1b.setFirstString("This is my test string B");
380:
381: MOSecondBean bean2 = new MOSecondBean();
382: bean2.setSecondString("MOSecondBeanA");
383: bean2.setFirstBeans(new ArrayList<MOFirstBean>() {
384: {
385: add(bean1a);
386: add(bean1b);
387: }
388: });
389:
390: // save the second bean
391: assertTrue(mSecondManager.save(bean2) > -1);
392:
393: // restore the second bean
394: MOSecondBean secondbean = mSecondManager.restore(bean2
395: .getIdentifier());
396: assertEquals(2, secondbean.getFirstBeans().size());
397:
398: // delete the second bean
399: assertTrue(mSecondManager.delete(bean2.getIdentifier()));
400: }
401:
402: public void testValidationContextManyToOne() {
403: MOFirstBean bean = new MOFirstBean();
404:
405: bean.setFirstString("This is my test string");
406:
407: // add the many-to-one relations to the bean instance
408: MOSecondBean bean2a = new MOSecondBean();
409: bean2a.setIdentifier(23);
410: bean2a.setSecondString("MOSecondBeanA");
411:
412: MOSecondBean bean2b = new MOSecondBean();
413: bean2b.setIdentifier(24);
414: bean2b.setSecondString("MOSecondBeanB");
415:
416: bean.setSecondBean(bean2a);
417: bean.setSecondBean2(bean2b);
418:
419: // validate the bean instance
420: ValidationError error;
421: assertFalse(bean.validate(mFirstManager));
422: assertEquals(2, bean.getValidationErrors().size());
423: Iterator<ValidationError> error_it = bean.getValidationErrors()
424: .iterator();
425: error = (ValidationError) error_it.next();
426: assertEquals(error.getSubject(), "secondBean");
427: assertEquals(error.getIdentifier(),
428: ValidationError.IDENTIFIER_INVALID);
429: error = (ValidationError) error_it.next();
430: assertEquals(error.getSubject(), "secondBean2");
431: assertEquals(error.getIdentifier(),
432: ValidationError.IDENTIFIER_INVALID);
433: assertFalse(error_it.hasNext());
434:
435: bean.resetValidation();
436:
437: // store the first associated bean
438: mSecondManager.save(bean2a);
439:
440: // validate the bean instance again
441: assertFalse(bean.validate(mFirstManager));
442: assertEquals(1, bean.getValidationErrors().size());
443: error_it = bean.getValidationErrors().iterator();
444: error = (ValidationError) error_it.next();
445: assertEquals(error.getSubject(), "secondBean2");
446: assertEquals(error.getIdentifier(),
447: ValidationError.IDENTIFIER_INVALID);
448: assertFalse(error_it.hasNext());
449:
450: // store the second associated bean
451: mSecondManager.save(bean2b);
452:
453: bean.resetValidation();
454:
455: // validate the bean instance a last time
456: assertTrue(bean.validate(mFirstManager));
457: }
458:
459: public void testValidationContextManyToOneAssociation() {
460: final MOFirstBean bean1a = new MOFirstBean();
461: bean1a.setIdentifier(23);
462: bean1a.setFirstString("This is my test string");
463:
464: final MOFirstBean bean1b = new MOFirstBean();
465: bean1b.setIdentifier(27);
466: bean1b.setFirstString("This is my test string B");
467:
468: MOSecondBean bean2 = new MOSecondBean();
469: bean2.setSecondString("MOSecondBeanA");
470: bean2.setFirstBeans(new ArrayList<MOFirstBean>() {
471: {
472: add(bean1a);
473: add(bean1b);
474: }
475: });
476:
477: // validate the bean instance
478: ValidationError error;
479: assertFalse(bean2.validate(mSecondManager));
480: assertEquals(1, bean2.getValidationErrors().size());
481: Iterator<ValidationError> error_it = bean2
482: .getValidationErrors().iterator();
483: error = (ValidationError) error_it.next();
484: assertEquals(error.getSubject(), "firstBeans");
485: assertEquals(error.getIdentifier(),
486: ValidationError.IDENTIFIER_INVALID);
487: assertFalse(error_it.hasNext());
488:
489: bean2.resetValidation();
490:
491: // store the first associated bean
492: mFirstManager.save(bean1a);
493:
494: // validate the bean instance
495: assertFalse(bean2.validate(mSecondManager));
496: assertEquals(1, bean2.getValidationErrors().size());
497: error_it = bean2.getValidationErrors().iterator();
498: error = (ValidationError) error_it.next();
499: assertEquals(error.getSubject(), "firstBeans");
500: assertEquals(error.getIdentifier(),
501: ValidationError.IDENTIFIER_INVALID);
502: assertFalse(error_it.hasNext());
503:
504: bean2.resetValidation();
505:
506: // store the first associated bean
507: mFirstManager.save(bean1b);
508:
509: // validate the bean instance a last time
510: assertTrue(bean2.validate(mSecondManager));
511: }
512: }
|