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: TestGenericQueryManagerManyToMany.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.database.DbQueryManager;
013: import com.uwyn.rife.database.queries.Select;
014: import com.uwyn.rife.database.querymanagers.generic.beans.MMFirstBean;
015: import com.uwyn.rife.database.querymanagers.generic.beans.MMSecondBean;
016: import com.uwyn.rife.site.ValidationError;
017: import java.util.ArrayList;
018: import java.util.Collection;
019: import junit.framework.TestCase;
020:
021: public class TestGenericQueryManagerManyToMany extends TestCase {
022: private Datasource mDatasource = null;
023:
024: private GenericQueryManager<MMFirstBean> mFirstManager = null;
025: private GenericQueryManager<MMSecondBean> mSecondManager = null;
026:
027: public TestGenericQueryManagerManyToMany(Datasource datasource,
028: String datasourceName, String name) {
029: super (name);
030: mDatasource = datasource;
031: }
032:
033: protected void setUp() throws Exception {
034: mFirstManager = GenericQueryManagerFactory.getInstance(
035: mDatasource, MMFirstBean.class);
036: mSecondManager = GenericQueryManagerFactory.getInstance(
037: mDatasource, MMSecondBean.class);
038:
039: int poolsize = mDatasource.getPoolsize();
040: // disabling pool for firebird
041: if ("org.firebirdsql.jdbc.FBDriver".equals(mDatasource
042: .getAliasedDriver())) {
043: mDatasource.setPoolsize(0);
044: }
045: try {
046: mSecondManager.install();
047: mFirstManager.install();
048: } finally {
049: if ("org.firebirdsql.jdbc.FBDriver".equals(mDatasource
050: .getAliasedDriver())) {
051: mDatasource.setPoolsize(poolsize);
052: }
053: }
054: }
055:
056: protected void tearDown() throws Exception {
057: int poolsize = mDatasource.getPoolsize();
058: // disabling pool for firebird
059: if ("org.firebirdsql.jdbc.FBDriver".equals(mDatasource
060: .getAliasedDriver())) {
061: mDatasource.setPoolsize(0);
062: }
063: try {
064: mFirstManager.remove();
065: mSecondManager.remove();
066: } finally {
067: if ("org.firebirdsql.jdbc.FBDriver".equals(mDatasource
068: .getAliasedDriver())) {
069: mDatasource.setPoolsize(poolsize);
070: }
071: }
072: }
073:
074: public void testGetBaseClass() {
075: assertSame(MMFirstBean.class, mFirstManager.getBaseClass());
076: assertSame(MMSecondBean.class, mSecondManager.getBaseClass());
077: }
078:
079: public void testInstallCustomQuery() {
080: int poolsize = mDatasource.getPoolsize();
081: // disabling pool for firebird
082: if ("org.firebirdsql.jdbc.FBDriver".equals(mDatasource
083: .getAliasedDriver())) {
084: mDatasource.setPoolsize(0);
085: }
086: try {
087: mFirstManager.remove();
088: mSecondManager.remove();
089:
090: mSecondManager.install(mSecondManager
091: .getInstallTableQuery());
092: mFirstManager.install(mFirstManager.getInstallTableQuery());
093: } finally {
094: if ("org.firebirdsql.jdbc.FBDriver".equals(mDatasource
095: .getAliasedDriver())) {
096: mDatasource.setPoolsize(poolsize);
097: }
098: }
099: }
100:
101: public void testSaveRestoreConstrained() {
102: MMFirstBean bean = new MMFirstBean();
103: MMFirstBean newbean = null;
104:
105: bean.setFirstString("This is my test string");
106:
107: // add the many to many relations to the bean instance
108: MMSecondBean bean2a = new MMSecondBean();
109: bean2a.setSecondString("MMSecondBeanA");
110:
111: MMSecondBean bean2b = new MMSecondBean();
112: bean2b.setSecondString("MMSecondBeanB");
113:
114: MMSecondBean bean2c = new MMSecondBean();
115: bean2c.setSecondString("MMSecondBeanC");
116:
117: Collection<MMSecondBean> secondbeans = new ArrayList<MMSecondBean>();
118: secondbeans.add(bean2a);
119: secondbeans.add(bean2b);
120: secondbeans.add(bean2c);
121: bean.setSecondBeans(secondbeans);
122:
123: // assert that the many to many relations have not been saved too
124: assertNull(bean2a.getIdentifier());
125: assertNull(bean2b.getIdentifier());
126: assertNull(bean2c.getIdentifier());
127:
128: // save the bean instance
129: Integer id = mFirstManager.save(bean);
130:
131: // assert that the many to many relations have been saved too
132: assertNotNull(bean2a.getIdentifier());
133: assertNotNull(bean2b.getIdentifier());
134: assertNotNull(bean2c.getIdentifier());
135:
136: // restore the bean instance
137: newbean = mFirstManager.restore(id);
138:
139: // assert that the bean has correctly been restored
140: assertTrue(newbean != null);
141: assertTrue(newbean != bean);
142: assertEquals(newbean.getFirstString(), bean.getFirstString());
143: assertEquals(newbean.getIdentifier(), id);
144:
145: // assert that the many to many relationships have correctly been restored
146: Collection<MMSecondBean> secondbeans_restored = newbean
147: .getSecondBeans();
148: boolean bean2a_found = false;
149: boolean bean2b_found = false;
150: boolean bean2c_found = false;
151: for (MMSecondBean secondbean : secondbeans_restored) {
152: if ("MMSecondBeanA".equals(secondbean.getSecondString())) {
153: assertFalse(bean2a_found);
154: assertEquals(bean2a.getIdentifier(), secondbean
155: .getIdentifier());
156: assertEquals(bean2a.getSecondString(), secondbean
157: .getSecondString());
158: bean2a_found = true;
159: } else if ("MMSecondBeanB".equals(secondbean
160: .getSecondString())) {
161: assertFalse(bean2b_found);
162: assertEquals(bean2b.getIdentifier(), secondbean
163: .getIdentifier());
164: assertEquals(bean2b.getSecondString(), secondbean
165: .getSecondString());
166: bean2b_found = true;
167: } else if ("MMSecondBeanC".equals(secondbean
168: .getSecondString())) {
169: assertFalse(bean2c_found);
170: assertEquals(bean2c.getIdentifier(), secondbean
171: .getIdentifier());
172: assertEquals(bean2c.getSecondString(), secondbean
173: .getSecondString());
174: bean2c_found = true;
175: }
176:
177: assertNotNull(secondbean.getFirstBeans());
178: assertEquals(1, secondbean.getFirstBeans().size());
179:
180: MMFirstBean firstbean = secondbean.getFirstBeans()
181: .iterator().next();
182: assertEquals(newbean.getIdentifier(), firstbean
183: .getIdentifier());
184: assertEquals(newbean.getFirstString(), firstbean
185: .getFirstString());
186: }
187: assertTrue(bean2a_found);
188: assertTrue(bean2b_found);
189: assertTrue(bean2c_found);
190:
191: // perform update with changed many to many relationships
192: // only the data of those that haven't been saved before will
193: // be stored
194: bean.setIdentifier(id);
195: bean.setFirstString("This is a new test string");
196:
197: bean2a.setSecondString("MMSecondBeanAUpdated");
198:
199: MMSecondBean bean2d = new MMSecondBean();
200: bean2d.setSecondString("MMSecondBeanD");
201: secondbeans = new ArrayList<MMSecondBean>();
202: secondbeans.add(bean2a);
203: secondbeans.add(bean2c);
204: secondbeans.add(bean2d);
205: bean.setSecondBeans(secondbeans);
206:
207: assertEquals(mFirstManager.save(bean), id.intValue());
208: assertEquals(bean.getIdentifier(), id);
209:
210: // restore the updated bean
211: newbean = mFirstManager.restore(id);
212:
213: assertTrue(newbean != null);
214: assertTrue(newbean != bean);
215:
216: // assert that the updated bean has been stored correctly
217: assertEquals(newbean.getFirstString(),
218: "This is a new test string");
219:
220: // assert that the many to many relationships have correctly been stored and restored
221: secondbeans_restored = newbean.getSecondBeans();
222: bean2a_found = false;
223: bean2b_found = false;
224: bean2c_found = false;
225: boolean bean2d_found = false;
226: for (MMSecondBean secondbean : secondbeans_restored) {
227: if ("MMSecondBeanA".equals(secondbean.getSecondString())) {
228: assertFalse(bean2a_found);
229: assertEquals(bean2a.getIdentifier(), secondbean
230: .getIdentifier());
231: // the data of this many to many association hasn't been updated since the entity already was saved before
232: assertFalse(bean2a.getSecondString().equals(
233: secondbean.getSecondString()));
234: bean2a_found = true;
235: } else if ("MMSecondBeanB".equals(secondbean
236: .getSecondString())) {
237: bean2b_found = true;
238: } else if ("MMSecondBeanC".equals(secondbean
239: .getSecondString())) {
240: assertFalse(bean2c_found);
241: assertEquals(bean2c.getIdentifier(), secondbean
242: .getIdentifier());
243: assertEquals(bean2c.getSecondString(), secondbean
244: .getSecondString());
245: bean2c_found = true;
246: } else if ("MMSecondBeanD".equals(secondbean
247: .getSecondString())) {
248: assertFalse(bean2d_found);
249: assertEquals(bean2d.getIdentifier(), secondbean
250: .getIdentifier());
251: assertEquals(bean2d.getSecondString(), secondbean
252: .getSecondString());
253: bean2d_found = true;
254: }
255:
256: assertNotNull(secondbean.getFirstBeans());
257: assertEquals(1, secondbean.getFirstBeans().size());
258:
259: MMFirstBean firstbean = secondbean.getFirstBeans()
260: .iterator().next();
261: assertEquals(newbean.getIdentifier(), firstbean
262: .getIdentifier());
263: assertEquals(newbean.getFirstString(), firstbean
264: .getFirstString());
265: }
266: assertTrue(bean2a_found);
267: assertFalse(bean2b_found);
268: assertTrue(bean2c_found);
269: assertTrue(bean2d_found);
270: }
271:
272: public void testDelete() {
273: MMFirstBean bean = new MMFirstBean();
274:
275: bean.setFirstString("This is my test string");
276:
277: // add the many to many relations to the bean instance
278: MMSecondBean bean2a = new MMSecondBean();
279: bean2a.setSecondString("MMSecondBeanA");
280:
281: MMSecondBean bean2b = new MMSecondBean();
282: bean2b.setSecondString("MMSecondBeanB");
283:
284: Collection<MMSecondBean> secondbeans = new ArrayList<MMSecondBean>();
285: secondbeans.add(bean2a);
286: secondbeans.add(bean2b);
287: bean.setSecondBeans(secondbeans);
288:
289: // save the bean instance
290: Integer id1 = mFirstManager.save(bean);
291:
292: // ensure that everything was saved correctly
293: assertTrue(mFirstManager.restore(id1) != null);
294: assertEquals(2, new DbQueryManager(mDatasource)
295: .executeGetFirstInt(new Select(mDatasource).field(
296: "count(*)").from("mmfirstbean_mmsecondbean")
297: .where("mmfirstbean_identifier", "=", id1)));
298: assertEquals(2, mSecondManager.count());
299:
300: // delete the first bean
301: mFirstManager.delete(id1);
302:
303: // ensure that everything was deleted correctly
304: assertNull(mFirstManager.restore(id1));
305: assertEquals(0, new DbQueryManager(mDatasource)
306: .executeGetFirstInt(new Select(mDatasource).field(
307: "count(*)").from("mmfirstbean_mmsecondbean")
308: .where("mmfirstbean_identifier", "=", id1)));
309: assertEquals(2, mSecondManager.count());
310:
311: // add another many to many relationship
312: MMSecondBean bean2c = new MMSecondBean();
313: bean2b.setSecondString("MMSecondBeanC");
314: secondbeans.add(bean2c);
315:
316: // save the bean instance again
317: Integer id2 = mFirstManager.save(bean);
318:
319: // ensure that everything was saved correctly
320: assertTrue(mFirstManager.restore(id2) != null);
321: assertEquals(3, new DbQueryManager(mDatasource)
322: .executeGetFirstInt(new Select(mDatasource).field(
323: "count(*)").from("mmfirstbean_mmsecondbean")
324: .where("mmfirstbean_identifier", "=", id2)));
325: assertEquals(3, mSecondManager.count());
326:
327: // delete the second bean
328: mFirstManager.delete(id2);
329:
330: // ensure that everything was deleted correctly
331: assertNull(mFirstManager.restore(id2));
332: assertEquals(0, new DbQueryManager(mDatasource)
333: .executeGetFirstInt(new Select(mDatasource).field(
334: "count(*)").from("mmfirstbean_mmsecondbean")
335: .where("mmfirstbean_identifier", "=", id2)));
336: assertEquals(3, mSecondManager.count());
337: }
338:
339: public void testValidationContextManyToMany() {
340: MMFirstBean bean = new MMFirstBean();
341:
342: bean.setFirstString("This is my test string");
343:
344: // add the many to many relations to the bean instance
345: MMSecondBean bean2a = new MMSecondBean();
346: bean2a.setIdentifier(23);
347: bean2a.setSecondString("MMSecondBeanA");
348:
349: MMSecondBean bean2b = new MMSecondBean();
350: bean2b.setIdentifier(24);
351: bean2b.setSecondString("MMSecondBeanB");
352:
353: Collection<MMSecondBean> secondbeans = new ArrayList<MMSecondBean>();
354: secondbeans.add(bean2a);
355: secondbeans.add(bean2b);
356: bean.setSecondBeans(secondbeans);
357:
358: // validate the bean instance
359: ValidationError error;
360: assertFalse(bean.validate(mFirstManager));
361: error = (ValidationError) bean.getValidationErrors().iterator()
362: .next();
363: assertEquals(error.getSubject(), "secondBeans");
364: assertEquals(error.getIdentifier(),
365: ValidationError.IDENTIFIER_INVALID);
366:
367: bean.resetValidation();
368:
369: // store the first associated bean
370: mSecondManager.save(bean2a);
371:
372: // validate the bean instance again
373: assertFalse(bean.validate(mFirstManager));
374: error = (ValidationError) bean.getValidationErrors().iterator()
375: .next();
376: assertEquals(error.getSubject(), "secondBeans");
377: assertEquals(error.getIdentifier(),
378: ValidationError.IDENTIFIER_INVALID);
379:
380: // store the second associated bean
381: mSecondManager.save(bean2b);
382:
383: bean.resetValidation();
384:
385: // validate the bean instance a last time
386: assertTrue(bean.validate(mFirstManager));
387: }
388:
389: public void testValidationContextManyToManyAssociation() {
390: MMSecondBean bean2 = new MMSecondBean();
391: bean2.setSecondString("This is my test string");
392:
393: // add the many to many association relations to the bean instance
394: MMFirstBean bean1a = new MMFirstBean();
395: bean1a.setIdentifier(23);
396: bean1a.setFirstString("MMFirstBeanA");
397:
398: MMFirstBean bean1b = new MMFirstBean();
399: bean1b.setIdentifier(24);
400: bean1b.setFirstString("MMFirstBeanB");
401:
402: Collection<MMFirstBean> firstbeans = new ArrayList<MMFirstBean>();
403: firstbeans.add(bean1a);
404: firstbeans.add(bean1b);
405: bean2.setFirstBeans(firstbeans);
406:
407: // validate the bean instance
408: ValidationError error;
409: assertFalse(bean2.validate(mSecondManager));
410: error = (ValidationError) bean2.getValidationErrors()
411: .iterator().next();
412: assertEquals(error.getSubject(), "firstBeans");
413: assertEquals(error.getIdentifier(),
414: ValidationError.IDENTIFIER_INVALID);
415:
416: bean2.resetValidation();
417:
418: // store the first associated bean
419: mFirstManager.save(bean1a);
420:
421: // validate the bean instance again
422: assertFalse(bean2.validate(mSecondManager));
423: error = (ValidationError) bean2.getValidationErrors()
424: .iterator().next();
425: assertEquals(error.getSubject(), "firstBeans");
426: assertEquals(error.getIdentifier(),
427: ValidationError.IDENTIFIER_INVALID);
428:
429: // store the second associated bean
430: mFirstManager.save(bean1b);
431:
432: bean2.resetValidation();
433:
434: // validate the bean instance a last time
435: assertTrue(bean2.validate(mSecondManager));
436: }
437: }
|