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: TestGenericQueryManagerSimple.java 3695 2007-03-16 09:26:50Z gbevin $
008: */
009: package com.uwyn.rife.database.querymanagers.generic;
010:
011: import java.sql.ResultSet;
012: import java.sql.SQLException;
013: import java.util.List;
014: import java.util.UUID;
015:
016: import junit.framework.TestCase;
017:
018: import com.uwyn.rife.database.Datasource;
019: import com.uwyn.rife.database.DbRowProcessor;
020: import com.uwyn.rife.database.SomeEnum;
021: import com.uwyn.rife.database.exceptions.DatabaseException;
022: import com.uwyn.rife.database.querymanagers.generic.beans.NoDefaultConstructorBean;
023: import com.uwyn.rife.database.querymanagers.generic.beans.SimpleBean;
024: import com.uwyn.rife.database.querymanagers.generic.beans.SparseBean;
025: import com.uwyn.rife.database.querymanagers.generic.exceptions.MissingDefaultConstructorException;
026:
027: public class TestGenericQueryManagerSimple extends TestCase {
028: private Datasource mDatasource = null;
029:
030: private GenericQueryManager<SimpleBean> mSimpleManager = null;
031:
032: public TestGenericQueryManagerSimple(Datasource datasource,
033: String datasourceName, String name) {
034: super (name);
035: mDatasource = datasource;
036: }
037:
038: protected void setUp() throws Exception {
039: mSimpleManager = GenericQueryManagerFactory.getInstance(
040: mDatasource, SimpleBean.class);
041:
042: int poolsize = mDatasource.getPoolsize();
043: // disabling pool for firebird
044: if ("org.firebirdsql.jdbc.FBDriver".equals(mDatasource
045: .getAliasedDriver())) {
046: mDatasource.setPoolsize(0);
047: }
048: try {
049: mSimpleManager.install();
050: } finally {
051: if ("org.firebirdsql.jdbc.FBDriver".equals(mDatasource
052: .getAliasedDriver())) {
053: mDatasource.setPoolsize(poolsize);
054: }
055: }
056: }
057:
058: protected void tearDown() throws Exception {
059: int poolsize = mDatasource.getPoolsize();
060: // disabling pool for firebird
061: if ("org.firebirdsql.jdbc.FBDriver".equals(mDatasource
062: .getAliasedDriver())) {
063: mDatasource.setPoolsize(0);
064: }
065: try {
066: mSimpleManager.remove();
067: } finally {
068: if ("org.firebirdsql.jdbc.FBDriver".equals(mDatasource
069: .getAliasedDriver())) {
070: mDatasource.setPoolsize(poolsize);
071: }
072: }
073: }
074:
075: public void testNoDefaultConstructor() {
076: try {
077: GenericQueryManagerFactory.getInstance(mDatasource,
078: NoDefaultConstructorBean.class);
079: fail("MissingDefaultConstructorException exception wasn't thrown");
080: } catch (MissingDefaultConstructorException e) {
081: assertSame(e.getBeanClass(), NoDefaultConstructorBean.class);
082: }
083: }
084:
085: public void testGetBaseClass() {
086: assertSame(SimpleBean.class, mSimpleManager.getBaseClass());
087: }
088:
089: public void testInstallCustomQuery() {
090: int poolsize = mDatasource.getPoolsize();
091: // disabling pool for firebird
092: if ("org.firebirdsql.jdbc.FBDriver".equals(mDatasource
093: .getAliasedDriver())) {
094: mDatasource.setPoolsize(0);
095: }
096: try {
097: mSimpleManager.remove();
098:
099: mSimpleManager.install(mSimpleManager
100: .getInstallTableQuery());
101: } finally {
102: if ("org.firebirdsql.jdbc.FBDriver".equals(mDatasource
103: .getAliasedDriver())) {
104: mDatasource.setPoolsize(poolsize);
105: }
106: }
107: }
108:
109: public void testSaveRestore() {
110: SimpleBean bean = new SimpleBean();
111: SimpleBean newbean = null;
112:
113: UUID uuid1 = UUID.randomUUID();
114: bean.setTestString("This is my test string");
115: bean.setUuid(uuid1);
116: bean.setEnum(SomeEnum.VALUE_TWO);
117:
118: int id = mSimpleManager.save(bean);
119:
120: newbean = mSimpleManager.restore(id);
121:
122: assertTrue(newbean != null);
123: assertTrue(newbean != bean);
124: assertEquals(newbean.getTestString(), bean.getTestString());
125: assertEquals(newbean.getId(), id);
126: assertEquals(newbean.getUuid(), uuid1);
127: assertEquals(newbean.getEnum(), SomeEnum.VALUE_TWO);
128:
129: UUID uuid2 = UUID.randomUUID();
130: bean.setId(id);
131: bean.setTestString("This is a new test string");
132: bean.setUuid(uuid2);
133: bean.setEnum(SomeEnum.VALUE_THREE);
134:
135: assertEquals(mSimpleManager.save(bean), id);
136: assertEquals(bean.getId(), id);
137:
138: newbean = mSimpleManager.restore(id);
139:
140: assertTrue(newbean != null);
141: assertTrue(newbean != bean);
142:
143: assertEquals(newbean.getTestString(),
144: "This is a new test string");
145: assertEquals(newbean.getUuid(), uuid2);
146: assertEquals(newbean.getEnum(), SomeEnum.VALUE_THREE);
147:
148: bean.setId(999999);
149: bean.setTestString("This is another test string");
150:
151: assertFalse(999999 == mSimpleManager.save(bean));
152: assertEquals(bean.getId(), id + 1);
153:
154: GenericQueryManager<SimpleBean> manager_othertable = GenericQueryManagerFactory
155: .getInstance(mDatasource, SimpleBean.class,
156: "othertable");
157: manager_othertable.install();
158:
159: SimpleBean bean2 = new SimpleBean();
160: bean2.setTestString("test");
161:
162: manager_othertable.save(bean2);
163:
164: SimpleBean bean3 = manager_othertable.restore(bean2.getId());
165:
166: assertEquals(bean3.getTestString(), bean2.getTestString());
167:
168: manager_othertable.remove();
169: }
170:
171: public void testSparseIdentifier() {
172: GenericQueryManager<SparseBean> manager_sparsebean = GenericQueryManagerFactory
173: .getInstance(mDatasource, SparseBean.class);
174: SparseBean sparse_bean = new SparseBean();
175:
176: manager_sparsebean.install();
177:
178: sparse_bean.setId(1000);
179: sparse_bean.setTestString("Test String");
180: assertTrue(1000 == manager_sparsebean.save(sparse_bean));
181:
182: SparseBean restored_sparsebean = manager_sparsebean
183: .restore(1000);
184: assertEquals(restored_sparsebean.getId(), 1000);
185: assertEquals(restored_sparsebean.getTestString(), "Test String");
186:
187: try {
188: manager_sparsebean.insert(sparse_bean);
189: assertFalse(true);
190: } catch (DatabaseException e) {
191: assertTrue(true);
192: }
193: assertTrue(1000 == manager_sparsebean.update(sparse_bean));
194:
195: sparse_bean.setId(1001);
196: assertTrue(-1 == manager_sparsebean.update(sparse_bean)); // not there; update should fail
197:
198: manager_sparsebean.remove();
199: }
200:
201: public void testDelete() {
202: SimpleBean bean = new SimpleBean();
203:
204: bean.setTestString("This is my test string");
205:
206: int id1 = mSimpleManager.save(bean);
207: assertTrue(mSimpleManager.restore(id1) != null);
208: mSimpleManager.delete(id1);
209: assertTrue(mSimpleManager.restoreFirst(mSimpleManager
210: .getRestoreQuery(id1)) == null);
211:
212: int id2 = mSimpleManager.save(bean);
213: assertTrue(mSimpleManager.restoreFirst(mSimpleManager
214: .getRestoreQuery(id2)) != null);
215: mSimpleManager.delete(mSimpleManager.getDeleteQuery(id2));
216: assertTrue(mSimpleManager.restore(id2) == null);
217: }
218:
219: public void testRestore() {
220: SimpleBean bean1 = new SimpleBean();
221: SimpleBean bean2 = new SimpleBean();
222: SimpleBean bean3 = new SimpleBean();
223:
224: UUID uuid1 = UUID.randomUUID();
225: UUID uuid2 = UUID.randomUUID();
226: UUID uuid3 = UUID.randomUUID();
227:
228: bean1.setTestString("This is bean1");
229: bean1.setUuid(uuid1);
230: bean1.setEnum(SomeEnum.VALUE_ONE);
231: bean2.setTestString("This is bean2");
232: bean2.setUuid(uuid2);
233: bean2.setEnum(SomeEnum.VALUE_TWO);
234: bean3.setTestString("This is bean3");
235: bean3.setUuid(uuid3);
236: bean3.setEnum(SomeEnum.VALUE_THREE);
237:
238: mSimpleManager.save(bean1);
239: mSimpleManager.save(bean2);
240: mSimpleManager.save(bean3);
241:
242: List<SimpleBean> list = mSimpleManager.restore();
243:
244: assertEquals(list.size(), 3);
245:
246: for (SimpleBean bean : list) {
247: assertTrue(bean != null);
248: assertTrue(bean != bean1 || bean != bean2 || bean != bean3);
249: assertTrue(bean.getTestString().equals("This is bean1")
250: && bean.getUuid().equals(uuid1)
251: && bean.getEnum().equals(SomeEnum.VALUE_ONE) ||
252:
253: bean.getTestString().equals("This is bean2")
254: && bean.getUuid().equals(uuid2)
255: && bean.getEnum().equals(SomeEnum.VALUE_TWO) ||
256:
257: bean.getTestString().equals("This is bean3")
258: && bean.getUuid().equals(uuid3)
259: && bean.getEnum().equals(SomeEnum.VALUE_THREE));
260: }
261: }
262:
263: public void testRestoreRowProcessor() {
264: SimpleBean bean1 = new SimpleBean();
265: SimpleBean bean2 = new SimpleBean();
266: SimpleBean bean3 = new SimpleBean();
267:
268: final UUID uuid1 = UUID.randomUUID();
269: final UUID uuid2 = UUID.randomUUID();
270: final UUID uuid3 = UUID.randomUUID();
271:
272: bean1.setTestString("This is bean1");
273: bean1.setUuid(uuid1);
274: bean1.setEnum(SomeEnum.VALUE_ONE);
275: bean2.setTestString("This is bean2");
276: bean2.setUuid(uuid2);
277: bean2.setEnum(SomeEnum.VALUE_TWO);
278: bean3.setTestString("This is bean3");
279: bean3.setUuid(uuid3);
280: bean3.setEnum(SomeEnum.VALUE_THREE);
281:
282: mSimpleManager.save(bean1);
283: mSimpleManager.save(bean2);
284: mSimpleManager.save(bean3);
285:
286: final int[] count = new int[] { 0 };
287: mSimpleManager.restore(new DbRowProcessor() {
288: public boolean processRow(ResultSet resultSet)
289: throws SQLException {
290: count[0]++;
291:
292: String test_string = resultSet.getString("testString");
293: assertTrue(test_string.equals("This is bean1")
294: || test_string.equals("This is bean2")
295: || test_string.equals("This is bean3"));
296:
297: String uuid = resultSet.getString("uuid");
298: assertTrue(uuid.equals(uuid1.toString())
299: || uuid.equals(uuid2.toString())
300: || uuid.equals(uuid3.toString()));
301:
302: return true;
303: }
304: });
305:
306: assertEquals(count[0], 3);
307: }
308:
309: public void testRestoreQueryRowProcessor() {
310: SimpleBean bean1 = new SimpleBean();
311: SimpleBean bean2 = new SimpleBean();
312: SimpleBean bean3 = new SimpleBean();
313:
314: final UUID uuid1 = UUID.randomUUID();
315: final UUID uuid2 = UUID.randomUUID();
316: final UUID uuid3 = UUID.randomUUID();
317:
318: bean1.setTestString("This is bean1");
319: bean1.setUuid(uuid1);
320: bean2.setTestString("This is bean2");
321: bean2.setUuid(uuid2);
322: bean3.setTestString("This is bean3");
323: bean3.setUuid(uuid3);
324:
325: mSimpleManager.save(bean1);
326: mSimpleManager.save(bean2);
327: mSimpleManager.save(bean3);
328:
329: final int[] count = new int[] { 0 };
330: mSimpleManager.restore(mSimpleManager.getRestoreQuery().where(
331: "testString", "LIKE", "%bean2"), new DbRowProcessor() {
332: public boolean processRow(ResultSet resultSet)
333: throws SQLException {
334: count[0]++;
335:
336: String test_string = resultSet.getString("testString");
337: assertTrue(test_string.equals("This is bean2"));
338:
339: String uuid = resultSet.getString("uuid");
340: assertTrue(uuid.equals(uuid2.toString()));
341:
342: return true;
343: }
344: });
345:
346: assertEquals(count[0], 1);
347: }
348:
349: public void testCount() {
350: SimpleBean bean1 = new SimpleBean();
351: SimpleBean bean2 = new SimpleBean();
352: SimpleBean bean3 = new SimpleBean();
353: SimpleBean bean4 = new SimpleBean();
354: SimpleBean bean5 = new SimpleBean();
355:
356: bean1.setTestString("bean set 1");
357: bean2.setTestString("bean set 1");
358: bean3.setTestString("bean set 1");
359: bean4.setTestString("bean set 2");
360: bean5.setTestString("bean set 2");
361:
362: mSimpleManager.save(bean1);
363: mSimpleManager.save(bean2);
364: mSimpleManager.save(bean3);
365: mSimpleManager.save(bean4);
366: mSimpleManager.save(bean5);
367:
368: assertEquals(mSimpleManager.count(), 5);
369:
370: mSimpleManager.delete(bean1.getId());
371: mSimpleManager.delete(bean2.getId());
372: mSimpleManager.delete(bean3.getId());
373:
374: assertEquals(mSimpleManager.count(), 2);
375: }
376:
377: }
|