Source Code Cross Referenced for TestGenericQueryManagerCallbacks.java in  » Web-Framework » rife-1.6.1 » com » uwyn » rife » database » querymanagers » generic » Java Source Code / Java DocumentationJava Source Code and Java Documentation

Java Source Code / Java Documentation
1. 6.0 JDK Core
2. 6.0 JDK Modules
3. 6.0 JDK Modules com.sun
4. 6.0 JDK Modules com.sun.java
5. 6.0 JDK Modules sun
6. 6.0 JDK Platform
7. Ajax
8. Apache Harmony Java SE
9. Aspect oriented
10. Authentication Authorization
11. Blogger System
12. Build
13. Byte Code
14. Cache
15. Chart
16. Chat
17. Code Analyzer
18. Collaboration
19. Content Management System
20. Database Client
21. Database DBMS
22. Database JDBC Connection Pool
23. Database ORM
24. Development
25. EJB Server geronimo
26. EJB Server GlassFish
27. EJB Server JBoss 4.2.1
28. EJB Server resin 3.1.5
29. ERP CRM Financial
30. ESB
31. Forum
32. GIS
33. Graphic Library
34. Groupware
35. HTML Parser
36. IDE
37. IDE Eclipse
38. IDE Netbeans
39. Installer
40. Internationalization Localization
41. Inversion of Control
42. Issue Tracking
43. J2EE
44. JBoss
45. JMS
46. JMX
47. Library
48. Mail Clients
49. Net
50. Parser
51. PDF
52. Portal
53. Profiler
54. Project Management
55. Report
56. RSS RDF
57. Rule Engine
58. Science
59. Scripting
60. Search Engine
61. Security
62. Sevlet Container
63. Source Control
64. Swing Library
65. Template Engine
66. Test Coverage
67. Testing
68. UML
69. Web Crawler
70. Web Framework
71. Web Mail
72. Web Server
73. Web Services
74. Web Services apache cxf 2.0.1
75. Web Services AXIS2
76. Wiki Engine
77. Workflow Engines
78. XML
79. XML UI
Java
Java Tutorial
Java Open Source
Jar File Download
Java Articles
Java Products
Java by API
Photoshop Tutorials
Maya Tutorials
Flash Tutorials
3ds-Max Tutorials
Illustrator Tutorials
GIMP Tutorials
C# / C Sharp
C# / CSharp Tutorial
C# / CSharp Open Source
ASP.Net
ASP.NET Tutorial
JavaScript DHTML
JavaScript Tutorial
JavaScript Reference
HTML / CSS
HTML CSS Reference
C / ANSI-C
C Tutorial
C++
C++ Tutorial
Ruby
PHP
Python
Python Tutorial
Python Open Source
SQL Server / T-SQL
SQL Server / T-SQL Tutorial
Oracle PL / SQL
Oracle PL/SQL Tutorial
PostgreSQL
SQL / MySQL
MySQL Tutorial
VB.Net
VB.Net Tutorial
Flash / Flex / ActionScript
VBA / Excel / Access / Word
XML
XML Tutorial
Microsoft Office PowerPoint 2007 Tutorial
Microsoft Office Excel 2007 Tutorial
Microsoft Office Word 2007 Tutorial
Java Source Code / Java Documentation » Web Framework » rife 1.6.1 » com.uwyn.rife.database.querymanagers.generic 
Source Cross Referenced  Class Diagram Java Document (Java Doc) 


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: TestGenericQueryManagerCallbacks.java 3634 2007-01-08 21:42:24Z gbevin $
008:         */
009:        package com.uwyn.rife.database.querymanagers.generic;
010:
011:        import com.uwyn.rife.database.Datasource;
012:        import com.uwyn.rife.database.querymanagers.generic.beans.CallbacksBean;
013:        import com.uwyn.rife.database.querymanagers.generic.beans.CallbacksProviderBean;
014:        import com.uwyn.rife.database.querymanagers.generic.beans.CallbacksSparseBean;
015:        import com.uwyn.rife.tools.StringUtils;
016:        import java.util.Iterator;
017:        import java.util.List;
018:        import java.util.Map;
019:        import junit.framework.TestCase;
020:
021:        public class TestGenericQueryManagerCallbacks extends TestCase {
022:            private Datasource mDatasource = null;
023:
024:            private GenericQueryManager<CallbacksBean> mCallbacksManager = null;
025:            private GenericQueryManager<CallbacksSparseBean> mCallbacksSparseManager = null;
026:            private GenericQueryManager<CallbacksProviderBean> mCallbacksProviderManager = null;
027:
028:            public TestGenericQueryManagerCallbacks(Datasource datasource,
029:                    String datasourceName, String name) {
030:                super (name);
031:                mDatasource = datasource;
032:            }
033:
034:            protected void setUp() throws Exception {
035:                mCallbacksManager = GenericQueryManagerFactory.getInstance(
036:                        mDatasource, CallbacksBean.class);
037:                mCallbacksSparseManager = GenericQueryManagerFactory
038:                        .getInstance(mDatasource, CallbacksSparseBean.class);
039:                mCallbacksProviderManager = GenericQueryManagerFactory
040:                        .getInstance(mDatasource, CallbacksProviderBean.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:                    AggregatingCallbacksBeanListener listener = new AggregatingCallbacksBeanListener();
050:                    mCallbacksManager.addListener(listener);
051:                    mCallbacksManager.install();
052:                    assertEquals(1, listener.getHistory().size());
053:                    assertEquals("installed0", listener.getHistory().entrySet()
054:                            .iterator().next().getKey());
055:
056:                    mCallbacksSparseManager.install();
057:                    mCallbacksProviderManager.install();
058:                } finally {
059:                    mCallbacksManager.removeListeners();
060:
061:                    if ("org.firebirdsql.jdbc.FBDriver".equals(mDatasource
062:                            .getAliasedDriver())) {
063:                        mDatasource.setPoolsize(poolsize);
064:                    }
065:                }
066:            }
067:
068:            protected void tearDown() throws Exception {
069:                int poolsize = mDatasource.getPoolsize();
070:                // disabling pool for firebird
071:                if ("org.firebirdsql.jdbc.FBDriver".equals(mDatasource
072:                        .getAliasedDriver())) {
073:                    mDatasource.setPoolsize(0);
074:                }
075:                try {
076:                    AggregatingCallbacksBeanListener listener = new AggregatingCallbacksBeanListener();
077:                    mCallbacksManager.addListener(listener);
078:                    mCallbacksManager.remove();
079:                    assertEquals(1, listener.getHistory().size());
080:                    assertEquals("removed0", listener.getHistory().entrySet()
081:                            .iterator().next().getKey());
082:
083:                    mCallbacksSparseManager.remove();
084:                    mCallbacksProviderManager.remove();
085:                } finally {
086:                    mCallbacksManager.removeListeners();
087:
088:                    if ("org.firebirdsql.jdbc.FBDriver".equals(mDatasource
089:                            .getAliasedDriver())) {
090:                        mDatasource.setPoolsize(poolsize);
091:                    }
092:                }
093:            }
094:
095:            public void testGetBaseClass() {
096:                assertSame(CallbacksBean.class, mCallbacksManager
097:                        .getBaseClass());
098:                assertSame(CallbacksSparseBean.class, mCallbacksSparseManager
099:                        .getBaseClass());
100:                assertSame(CallbacksProviderBean.class,
101:                        mCallbacksProviderManager.getBaseClass());
102:            }
103:
104:            public void testInstallCustomQuery() {
105:                int poolsize = mDatasource.getPoolsize();
106:                // disabling pool for firebird
107:                if ("org.firebirdsql.jdbc.FBDriver".equals(mDatasource
108:                        .getAliasedDriver())) {
109:                    mDatasource.setPoolsize(0);
110:                }
111:                try {
112:                    mCallbacksManager.remove();
113:                    mCallbacksSparseManager.remove();
114:                    mCallbacksProviderManager.remove();
115:
116:                    mCallbacksManager.install(mCallbacksManager
117:                            .getInstallTableQuery());
118:                    mCallbacksSparseManager.install(mCallbacksSparseManager
119:                            .getInstallTableQuery());
120:                    mCallbacksProviderManager.install(mCallbacksProviderManager
121:                            .getInstallTableQuery());
122:                } finally {
123:                    if ("org.firebirdsql.jdbc.FBDriver".equals(mDatasource
124:                            .getAliasedDriver())) {
125:                        mDatasource.setPoolsize(poolsize);
126:                    }
127:                }
128:            }
129:
130:            public void testValidateCallbacks() {
131:                CallbacksBean.clearExecuteCallbacks();
132:
133:                CallbacksBean bean = new CallbacksBean();
134:
135:                bean.setTestString("This is my test string");
136:
137:                mCallbacksManager.validate(bean);
138:                assertEquals("beforeValidate -1;This is my test string\n"
139:                        + "afterValidate -1;This is my test string",
140:                        StringUtils.join(CallbacksBean.getExecutedCallbacks(),
141:                                "\n"));
142:
143:                CallbacksBean.clearExecuteCallbacks();
144:                assertEquals("", StringUtils.join(CallbacksBean
145:                        .getExecutedCallbacks(), "\n"));
146:
147:                bean.setTestString("This is a new test string");
148:
149:                mCallbacksManager.validate(bean);
150:                assertEquals("beforeValidate -1;This is a new test string\n"
151:                        + "afterValidate -1;This is a new test string",
152:                        StringUtils.join(CallbacksBean.getExecutedCallbacks(),
153:                                "\n"));
154:
155:                CallbacksBean.clearExecuteCallbacks();
156:                assertEquals("", StringUtils.join(CallbacksBean
157:                        .getExecutedCallbacks(), "\n"));
158:
159:                bean.setId(999999);
160:                bean.setTestString("This is another test string");
161:
162:                mCallbacksManager.validate(bean);
163:                assertEquals(
164:                        "beforeValidate 999999;This is another test string\n"
165:                                + "afterValidate 999999;This is another test string",
166:                        StringUtils.join(CallbacksBean.getExecutedCallbacks(),
167:                                "\n"));
168:
169:                CallbacksBean.clearExecuteCallbacks();
170:            }
171:
172:            public void testValidateCallbacksReturns() {
173:                CallbacksBean.clearExecuteCallbacks();
174:
175:                CallbacksBean bean = new CallbacksBean();
176:
177:                bean.setTestString("This is my test string");
178:
179:                bean.setBeforeValidateReturn(false);
180:                mCallbacksManager.validate(bean);
181:                assertEquals("beforeValidate -1;This is my test string",
182:                        StringUtils.join(CallbacksBean.getExecutedCallbacks(),
183:                                "\n"));
184:
185:                CallbacksBean.clearExecuteCallbacks();
186:                assertEquals("", StringUtils.join(CallbacksBean
187:                        .getExecutedCallbacks(), "\n"));
188:
189:                bean.setBeforeValidateReturn(true);
190:                bean.setAfterValidateReturn(false);
191:                mCallbacksManager.validate(bean);
192:                assertEquals("beforeValidate -1;This is my test string\n"
193:                        + "afterValidate -1;This is my test string",
194:                        StringUtils.join(CallbacksBean.getExecutedCallbacks(),
195:                                "\n"));
196:
197:                CallbacksBean.clearExecuteCallbacks();
198:            }
199:
200:            public void testSaveCallbacks() {
201:                CallbacksBean.clearExecuteCallbacks();
202:
203:                CallbacksBean bean = new CallbacksBean();
204:
205:                bean.setTestString("This is my test string");
206:
207:                int id = mCallbacksManager.save(bean);
208:                assertEquals("beforeSave -1;This is my test string\n"
209:                        + "beforeInsert -1;This is my test string\n"
210:                        + "afterInsert true " + id
211:                        + ";This is my test string\n" + "afterSave true " + id
212:                        + ";This is my test string", StringUtils.join(
213:                        CallbacksBean.getExecutedCallbacks(), "\n"));
214:
215:                CallbacksBean.clearExecuteCallbacks();
216:                assertEquals("", StringUtils.join(CallbacksBean
217:                        .getExecutedCallbacks(), "\n"));
218:
219:                bean.setTestString("This is a new test string");
220:
221:                id = mCallbacksManager.save(bean);
222:                assertEquals(
223:                        "beforeSave " + id + ";This is a new test string\n"
224:                                + "beforeUpdate " + id
225:                                + ";This is a new test string\n"
226:                                + "afterUpdate true " + id
227:                                + ";This is a new test string\n"
228:                                + "afterSave true " + id
229:                                + ";This is a new test string", StringUtils
230:                                .join(CallbacksBean.getExecutedCallbacks(),
231:                                        "\n"));
232:
233:                CallbacksBean.clearExecuteCallbacks();
234:                assertEquals("", StringUtils.join(CallbacksBean
235:                        .getExecutedCallbacks(), "\n"));
236:
237:                bean.setId(999999);
238:                bean.setTestString("This is another test string");
239:
240:                id = mCallbacksManager.save(bean);
241:                assertEquals(
242:                        "beforeSave 999999;This is another test string\n"
243:                                + "beforeUpdate 999999;This is another test string\n"
244:                                + "afterUpdate false 999999;This is another test string\n"
245:                                + "beforeInsert 999999;This is another test string\n"
246:                                + "afterInsert true " + id
247:                                + ";This is another test string\n"
248:                                + "afterSave true " + id
249:                                + ";This is another test string", StringUtils
250:                                .join(CallbacksBean.getExecutedCallbacks(),
251:                                        "\n"));
252:            }
253:
254:            public void testSaveCallbacksReturns() {
255:                CallbacksBean.clearExecuteCallbacks();
256:
257:                CallbacksBean bean = new CallbacksBean();
258:
259:                bean.setTestString("This is my test string");
260:
261:                // test immediate inserts
262:                bean.setBeforeSaveReturn(false);
263:                mCallbacksManager.save(bean);
264:                assertEquals("beforeSave -1;This is my test string",
265:                        StringUtils.join(CallbacksBean.getExecutedCallbacks(),
266:                                "\n"));
267:                assertNull(mCallbacksManager.restore(1));
268:
269:                CallbacksBean.clearExecuteCallbacks();
270:                assertEquals("", StringUtils.join(CallbacksBean
271:                        .getExecutedCallbacks(), "\n"));
272:
273:                bean.setBeforeSaveReturn(true);
274:                bean.setBeforeInsertReturn(false);
275:                mCallbacksManager.save(bean);
276:                assertEquals("beforeSave -1;This is my test string\n"
277:                        + "beforeInsert -1;This is my test string", StringUtils
278:                        .join(CallbacksBean.getExecutedCallbacks(), "\n"));
279:                assertNull(mCallbacksManager.restore(1));
280:
281:                CallbacksBean.clearExecuteCallbacks();
282:                assertEquals("", StringUtils.join(CallbacksBean
283:                        .getExecutedCallbacks(), "\n"));
284:
285:                bean.setBeforeInsertReturn(true);
286:                bean.setAfterInsertReturn(false);
287:                int id = mCallbacksManager.save(bean);
288:                assertEquals("beforeSave -1;This is my test string\n"
289:                        + "beforeInsert -1;This is my test string\n"
290:                        + "afterInsert true " + id + ";This is my test string",
291:                        StringUtils.join(CallbacksBean.getExecutedCallbacks(),
292:                                "\n"));
293:                assertNotNull(mCallbacksManager.restore(id));
294:
295:                // test updates
296:                CallbacksBean.clearExecuteCallbacks();
297:                assertEquals("", StringUtils.join(CallbacksBean
298:                        .getExecutedCallbacks(), "\n"));
299:
300:                bean.setTestString("This is a new test string");
301:
302:                bean.setBeforeUpdateReturn(false);
303:                bean.setAfterInsertReturn(true);
304:                assertEquals(-1, mCallbacksManager.save(bean));
305:                assertEquals("beforeSave " + id
306:                        + ";This is a new test string\n" + "beforeUpdate " + id
307:                        + ";This is a new test string", StringUtils.join(
308:                        CallbacksBean.getExecutedCallbacks(), "\n"));
309:                assertEquals("This is my test string", mCallbacksManager
310:                        .restore(id).getTestString());
311:
312:                CallbacksBean.clearExecuteCallbacks();
313:                assertEquals("", StringUtils.join(CallbacksBean
314:                        .getExecutedCallbacks(), "\n"));
315:
316:                bean.setBeforeUpdateReturn(true);
317:                bean.setAfterUpdateReturn(false);
318:                assertEquals(id, mCallbacksManager.save(bean));
319:                assertEquals("beforeSave " + id
320:                        + ";This is a new test string\n" + "beforeUpdate " + id
321:                        + ";This is a new test string\n" + "afterUpdate true "
322:                        + id + ";This is a new test string", StringUtils.join(
323:                        CallbacksBean.getExecutedCallbacks(), "\n"));
324:                assertEquals("This is a new test string", mCallbacksManager
325:                        .restore(id).getTestString());
326:
327:                // test insert after failed update
328:                CallbacksBean.clearExecuteCallbacks();
329:                assertEquals("", StringUtils.join(CallbacksBean
330:                        .getExecutedCallbacks(), "\n"));
331:
332:                bean.setId(999999);
333:                bean.setTestString("This is another test string");
334:
335:                bean.setAfterUpdateReturn(true);
336:                bean.setBeforeInsertReturn(false);
337:
338:                assertEquals(-1, mCallbacksManager.save(bean));
339:                assertEquals(
340:                        "beforeSave 999999;This is another test string\n"
341:                                + "beforeUpdate 999999;This is another test string\n"
342:                                + "afterUpdate false 999999;This is another test string\n"
343:                                + "beforeInsert 999999;This is another test string",
344:                        StringUtils.join(CallbacksBean.getExecutedCallbacks(),
345:                                "\n"));
346:                assertNull(mCallbacksManager.restore(999999));
347:                CallbacksBean.clearExecuteCallbacks();
348:                assertEquals("", StringUtils.join(CallbacksBean
349:                        .getExecutedCallbacks(), "\n"));
350:
351:                bean.setBeforeInsertReturn(true);
352:                bean.setAfterInsertReturn(false);
353:
354:                assertEquals(id + 1, mCallbacksManager.save(bean));
355:                id = id + 1;
356:                assertEquals(
357:                        "beforeSave 999999;This is another test string\n"
358:                                + "beforeUpdate 999999;This is another test string\n"
359:                                + "afterUpdate false 999999;This is another test string\n"
360:                                + "beforeInsert 999999;This is another test string\n"
361:                                + "afterInsert true " + id
362:                                + ";This is another test string", StringUtils
363:                                .join(CallbacksBean.getExecutedCallbacks(),
364:                                        "\n"));
365:                assertNotNull(mCallbacksManager.restore(id));
366:            }
367:
368:            public void testSaveCallbacksSparse() {
369:                CallbacksSparseBean bean = new CallbacksSparseBean();
370:
371:                bean.setId(1000);
372:                bean.setTestString("Test String");
373:
374:                int id = mCallbacksSparseManager.save(bean);
375:                assertEquals("beforeSave " + id + ";Test String\n"
376:                        + "beforeInsert " + id + ";Test String\n"
377:                        + "afterInsert true " + id + ";Test String\n"
378:                        + "afterSave true " + id + ";Test String", StringUtils
379:                        .join(bean.getExecutedCallbacks(), "\n"));
380:
381:                bean.clearExecuteCallbacks();
382:                assertEquals("", StringUtils.join(bean.getExecutedCallbacks(),
383:                        "\n"));
384:
385:                bean.setTestString("This is a new test string");
386:
387:                id = mCallbacksSparseManager.save(bean);
388:                assertEquals("beforeSave " + id
389:                        + ";This is a new test string\n" + "beforeInsert " + id
390:                        + ";This is a new test string\n" + "afterInsert false "
391:                        + id + ";This is a new test string\n" + "beforeUpdate "
392:                        + id + ";This is a new test string\n"
393:                        + "afterUpdate true " + id
394:                        + ";This is a new test string\n" + "afterSave true "
395:                        + id + ";This is a new test string", StringUtils.join(
396:                        bean.getExecutedCallbacks(), "\n"));
397:            }
398:
399:            public void testSaveCallbacksSparseReturns() {
400:                CallbacksSparseBean bean = new CallbacksSparseBean();
401:
402:                bean.setId(1000);
403:                bean.setTestString("Test String");
404:
405:                int id = 1000;
406:
407:                // test immediate insert
408:                bean.setBeforeSaveReturn(false);
409:                assertEquals(-1, mCallbacksSparseManager.save(bean));
410:                assertEquals("beforeSave " + id + ";Test String", StringUtils
411:                        .join(bean.getExecutedCallbacks(), "\n"));
412:
413:                bean.clearExecuteCallbacks();
414:                assertEquals("", StringUtils.join(bean.getExecutedCallbacks(),
415:                        "\n"));
416:
417:                bean.setBeforeSaveReturn(true);
418:                bean.setBeforeInsertReturn(false);
419:
420:                assertEquals(-1, mCallbacksSparseManager.save(bean));
421:                assertEquals("beforeSave " + id + ";Test String\n"
422:                        + "beforeInsert " + id + ";Test String", StringUtils
423:                        .join(bean.getExecutedCallbacks(), "\n"));
424:
425:                bean.clearExecuteCallbacks();
426:                assertEquals("", StringUtils.join(bean.getExecutedCallbacks(),
427:                        "\n"));
428:
429:                bean.setBeforeInsertReturn(true);
430:                bean.setAfterInsertReturn(false);
431:
432:                assertEquals(id, mCallbacksSparseManager.save(bean));
433:                assertEquals("beforeSave " + id + ";Test String\n"
434:                        + "beforeInsert " + id + ";Test String\n"
435:                        + "afterInsert true " + id + ";Test String",
436:                        StringUtils.join(bean.getExecutedCallbacks(), "\n"));
437:
438:                bean.clearExecuteCallbacks();
439:                assertEquals("", StringUtils.join(bean.getExecutedCallbacks(),
440:                        "\n"));
441:
442:                // test update after failed insert
443:                bean.setTestString("This is a new test string");
444:
445:                bean.clearExecuteCallbacks();
446:                assertEquals("", StringUtils.join(bean.getExecutedCallbacks(),
447:                        "\n"));
448:
449:                bean.setAfterInsertReturn(true);
450:                bean.setBeforeUpdateReturn(false);
451:
452:                assertEquals(-1, mCallbacksSparseManager.save(bean));
453:                assertEquals("beforeSave " + id
454:                        + ";This is a new test string\n" + "beforeInsert " + id
455:                        + ";This is a new test string\n" + "afterInsert false "
456:                        + id + ";This is a new test string\n" + "beforeUpdate "
457:                        + id + ";This is a new test string", StringUtils.join(
458:                        bean.getExecutedCallbacks(), "\n"));
459:
460:                bean.clearExecuteCallbacks();
461:                assertEquals("", StringUtils.join(bean.getExecutedCallbacks(),
462:                        "\n"));
463:
464:                bean.setBeforeUpdateReturn(true);
465:                bean.setAfterUpdateReturn(false);
466:
467:                assertEquals(id, mCallbacksSparseManager.save(bean));
468:                assertEquals("beforeSave " + id
469:                        + ";This is a new test string\n" + "beforeInsert " + id
470:                        + ";This is a new test string\n" + "afterInsert false "
471:                        + id + ";This is a new test string\n" + "beforeUpdate "
472:                        + id + ";This is a new test string\n"
473:                        + "afterUpdate true " + id
474:                        + ";This is a new test string", StringUtils.join(bean
475:                        .getExecutedCallbacks(), "\n"));
476:            }
477:
478:            public void testSaveListeners() {
479:                CallbacksBean.clearExecuteCallbacks();
480:
481:                AggregatingCallbacksBeanListener listener = new AggregatingCallbacksBeanListener();
482:                mCallbacksManager.addListener(listener);
483:                try {
484:                    CallbacksBean bean = new CallbacksBean();
485:
486:                    bean.setTestString("This is my test string");
487:
488:                    int id = mCallbacksManager.save(bean);
489:                    Map<String, Object> history = listener.getHistory();
490:                    assertEquals(1, history.size());
491:                    Map.Entry<String, Object> entry = history.entrySet()
492:                            .iterator().next();
493:                    assertEquals("inserted0", entry.getKey());
494:                    assertSame(bean, entry.getValue());
495:                    assertEquals("beforeSave -1;This is my test string\n"
496:                            + "beforeInsert -1;This is my test string\n"
497:                            + "afterInsert true " + id + ";listener inserted\n"
498:                            + "afterSave true " + id + ";listener inserted",
499:                            StringUtils.join(CallbacksBean
500:                                    .getExecutedCallbacks(), "\n"));
501:
502:                    CallbacksBean.clearExecuteCallbacks();
503:                    listener.clearHistory();
504:                    assertEquals("", StringUtils.join(CallbacksBean
505:                            .getExecutedCallbacks(), "\n"));
506:
507:                    bean.setTestString("This is a new test string");
508:
509:                    id = mCallbacksManager.save(bean);
510:                    assertEquals(1, history.size());
511:                    entry = history.entrySet().iterator().next();
512:                    assertEquals("updated0", entry.getKey());
513:                    assertSame(bean, entry.getValue());
514:                    assertEquals("beforeSave " + id
515:                            + ";This is a new test string\n" + "beforeUpdate "
516:                            + id + ";This is a new test string\n"
517:                            + "afterUpdate true " + id + ";listener updated\n"
518:                            + "afterSave true " + id + ";listener updated",
519:                            StringUtils.join(CallbacksBean
520:                                    .getExecutedCallbacks(), "\n"));
521:
522:                    CallbacksBean.clearExecuteCallbacks();
523:                    listener.clearHistory();
524:                    assertEquals("", StringUtils.join(CallbacksBean
525:                            .getExecutedCallbacks(), "\n"));
526:
527:                    bean.setId(999999);
528:                    bean.setTestString("This is another test string");
529:
530:                    id = mCallbacksManager.save(bean);
531:                    assertEquals(1, history.size());
532:                    entry = history.entrySet().iterator().next();
533:                    assertEquals("inserted0", entry.getKey());
534:                    assertSame(bean, entry.getValue());
535:                    assertEquals(
536:                            "beforeSave 999999;This is another test string\n"
537:                                    + "beforeUpdate 999999;This is another test string\n"
538:                                    + "afterUpdate false 999999;This is another test string\n"
539:                                    + "beforeInsert 999999;This is another test string\n"
540:                                    + "afterInsert true " + id
541:                                    + ";listener inserted\n"
542:                                    + "afterSave true " + id
543:                                    + ";listener inserted", StringUtils.join(
544:                                    CallbacksBean.getExecutedCallbacks(), "\n"));
545:                } finally {
546:                    mCallbacksManager.removeListeners();
547:                }
548:            }
549:
550:            public void testInsertCallbacks() {
551:                CallbacksBean.clearExecuteCallbacks();
552:
553:                CallbacksBean bean = new CallbacksBean();
554:
555:                bean.setTestString("This is my test string");
556:
557:                int id = mCallbacksManager.insert(bean);
558:                assertEquals("beforeInsert -1;This is my test string\n"
559:                        + "afterInsert true " + id + ";This is my test string",
560:                        StringUtils.join(CallbacksBean.getExecutedCallbacks(),
561:                                "\n"));
562:            }
563:
564:            public void testInsertCallbacksReturns() {
565:                CallbacksBean.clearExecuteCallbacks();
566:
567:                CallbacksBean bean = new CallbacksBean();
568:
569:                bean.setTestString("This is my test string");
570:
571:                bean.setBeforeInsertReturn(false);
572:                mCallbacksManager.insert(bean);
573:                assertEquals("beforeInsert -1;This is my test string",
574:                        StringUtils.join(CallbacksBean.getExecutedCallbacks(),
575:                                "\n"));
576:
577:                assertNull(mCallbacksManager.restore(1));
578:            }
579:
580:            public void testUpdateCallbacks() {
581:                CallbacksBean.clearExecuteCallbacks();
582:
583:                CallbacksBean bean = new CallbacksBean();
584:
585:                bean.setTestString("This is my test string");
586:
587:                mCallbacksManager.update(bean);
588:                assertEquals("beforeUpdate -1;This is my test string\n"
589:                        + "afterUpdate false -1;This is my test string",
590:                        StringUtils.join(CallbacksBean.getExecutedCallbacks(),
591:                                "\n"));
592:
593:                int id = mCallbacksManager.insert(bean);
594:                CallbacksBean.clearExecuteCallbacks();
595:                assertEquals("", StringUtils.join(CallbacksBean
596:                        .getExecutedCallbacks(), "\n"));
597:
598:                bean.setTestString("This is a new test string");
599:
600:                mCallbacksManager.update(bean);
601:                assertEquals("beforeUpdate " + id
602:                        + ";This is a new test string\n" + "afterUpdate true "
603:                        + id + ";This is a new test string", StringUtils.join(
604:                        CallbacksBean.getExecutedCallbacks(), "\n"));
605:            }
606:
607:            public void testUpdateCallbacksReturns() {
608:                CallbacksBean.clearExecuteCallbacks();
609:
610:                CallbacksBean bean = new CallbacksBean();
611:                bean.setTestString("This is my test string");
612:
613:                int id = mCallbacksManager.insert(bean);
614:                CallbacksBean.clearExecuteCallbacks();
615:                assertEquals("", StringUtils.join(CallbacksBean
616:                        .getExecutedCallbacks(), "\n"));
617:
618:                bean.setTestString("This is a new test string");
619:
620:                bean.setBeforeUpdateReturn(false);
621:                mCallbacksManager.update(bean);
622:                assertEquals("beforeUpdate " + id
623:                        + ";This is a new test string", StringUtils.join(
624:                        CallbacksBean.getExecutedCallbacks(), "\n"));
625:
626:                assertEquals("This is my test string", mCallbacksManager
627:                        .restore(id).getTestString());
628:            }
629:
630:            public void testDeleteCallbacks() {
631:                CallbacksBean.clearExecuteCallbacks();
632:
633:                CallbacksBean bean = new CallbacksBean();
634:
635:                bean.setTestString("This is my test string");
636:
637:                int id = mCallbacksManager.save(bean);
638:
639:                CallbacksBean.clearExecuteCallbacks();
640:                assertEquals("", StringUtils.join(CallbacksBean
641:                        .getExecutedCallbacks(), "\n"));
642:
643:                mCallbacksManager.delete(id);
644:                assertEquals("beforeDelete " + id + "\n" + "afterDelete true "
645:                        + id + "", StringUtils.join(CallbacksBean
646:                        .getExecutedCallbacks(), "\n"));
647:            }
648:
649:            public void testDeleteCallbacksReturns() {
650:                CallbacksBean.clearExecuteCallbacks();
651:
652:                CallbacksBean bean = new CallbacksBean();
653:
654:                bean.setTestString("This is my test string");
655:
656:                int id = mCallbacksManager.save(bean);
657:
658:                CallbacksBean.clearExecuteCallbacks();
659:                assertEquals("", StringUtils.join(CallbacksBean
660:                        .getExecutedCallbacks(), "\n"));
661:
662:                CallbacksBean.setBeforeDeleteReturn(false);
663:                mCallbacksManager.delete(id);
664:                assertEquals("beforeDelete " + id + "", StringUtils.join(
665:                        CallbacksBean.getExecutedCallbacks(), "\n"));
666:
667:                assertNotNull(mCallbacksManager.restore(id));
668:
669:                CallbacksBean.setBeforeDeleteReturn(true);
670:            }
671:
672:            public void testDeleteListeners() {
673:                CallbacksBean.clearExecuteCallbacks();
674:
675:                CallbacksBean bean = new CallbacksBean();
676:
677:                bean.setTestString("This is my test string");
678:
679:                int id = mCallbacksManager.save(bean);
680:
681:                CallbacksBean.clearExecuteCallbacks();
682:                assertEquals("", StringUtils.join(CallbacksBean
683:                        .getExecutedCallbacks(), "\n"));
684:
685:                AggregatingCallbacksBeanListener listener = new AggregatingCallbacksBeanListener();
686:                try {
687:                    mCallbacksManager.addListener(listener);
688:                    mCallbacksManager.delete(id);
689:                    Map<String, Object> history = listener.getHistory();
690:                    assertEquals(1, history.size());
691:                    Map.Entry<String, Object> entry = history.entrySet()
692:                            .iterator().next();
693:                    assertEquals("deleted0", entry.getKey());
694:                    assertEquals(id, entry.getValue());
695:                    assertEquals("beforeDelete " + id + "\n"
696:                            + "afterDelete true " + id + "", StringUtils.join(
697:                            CallbacksBean.getExecutedCallbacks(), "\n"));
698:                } finally {
699:                    mCallbacksManager.removeListeners();
700:                }
701:            }
702:
703:            public void testRestoreCallbacks() {
704:                CallbacksBean.clearExecuteCallbacks();
705:
706:                CallbacksBean bean1 = new CallbacksBean();
707:                CallbacksBean bean2 = new CallbacksBean();
708:                CallbacksBean bean3 = new CallbacksBean();
709:
710:                bean1.setTestString("This is bean1");
711:                bean2.setTestString("This is bean2");
712:                bean3.setTestString("This is bean3");
713:
714:                int id1 = mCallbacksManager.save(bean1);
715:                int id2 = mCallbacksManager.save(bean2);
716:                int id3 = mCallbacksManager.save(bean3);
717:
718:                CallbacksBean.clearExecuteCallbacks();
719:
720:                // restore all beans
721:                assertEquals(3, mCallbacksManager.restore(
722:                        mCallbacksManager.getRestoreQuery().orderBy("id"))
723:                        .size());
724:
725:                assertEquals("afterRestore " + id1 + ";This is bean1\n"
726:                        + "afterRestore " + id2 + ";This is bean2\n"
727:                        + "afterRestore " + id3 + ";This is bean3", StringUtils
728:                        .join(CallbacksBean.getExecutedCallbacks(), "\n"));
729:
730:                CallbacksBean.clearExecuteCallbacks();
731:                assertEquals("", StringUtils.join(CallbacksBean
732:                        .getExecutedCallbacks(), "\n"));
733:
734:                // restore a specific bean
735:                mCallbacksManager.restore(bean2.getId());
736:
737:                assertEquals("afterRestore " + id2 + ";This is bean2",
738:                        StringUtils.join(CallbacksBean.getExecutedCallbacks(),
739:                                "\n"));
740:
741:                CallbacksBean.clearExecuteCallbacks();
742:                assertEquals("", StringUtils.join(CallbacksBean
743:                        .getExecutedCallbacks(), "\n"));
744:
745:                // restore the first bean
746:                mCallbacksManager.restoreFirst(mCallbacksManager
747:                        .getRestoreQuery().orderBy("id"));
748:
749:                assertEquals("afterRestore " + id1 + ";This is bean1",
750:                        StringUtils.join(CallbacksBean.getExecutedCallbacks(),
751:                                "\n"));
752:
753:                CallbacksBean.clearExecuteCallbacks();
754:                CallbacksBean.setAfterRestoreReturn(true);
755:            }
756:
757:            public void testRestoreCallbacksReturns() {
758:                CallbacksBean.clearExecuteCallbacks();
759:
760:                CallbacksBean bean1 = new CallbacksBean();
761:                CallbacksBean bean2 = new CallbacksBean();
762:                CallbacksBean bean3 = new CallbacksBean();
763:
764:                bean1.setTestString("This is bean1");
765:                bean2.setTestString("This is bean2");
766:                bean3.setTestString("This is bean3");
767:
768:                int id = mCallbacksManager.save(bean1);
769:                mCallbacksManager.save(bean2);
770:                mCallbacksManager.save(bean3);
771:
772:                CallbacksBean.clearExecuteCallbacks();
773:                CallbacksBean.setAfterRestoreReturn(false);
774:
775:                assertEquals(1, mCallbacksManager.restore(
776:                        mCallbacksManager.getRestoreQuery().orderBy("id"))
777:                        .size());
778:
779:                assertEquals("afterRestore " + id + ";This is bean1",
780:                        StringUtils.join(CallbacksBean.getExecutedCallbacks(),
781:                                "\n"));
782:
783:                CallbacksBean.setAfterRestoreReturn(true);
784:            }
785:
786:            public void testRestoreListeners() {
787:                CallbacksBean.clearExecuteCallbacks();
788:
789:                CallbacksBean bean1 = new CallbacksBean();
790:                CallbacksBean bean2 = new CallbacksBean();
791:                CallbacksBean bean3 = new CallbacksBean();
792:
793:                bean1.setTestString("This is bean1");
794:                bean2.setTestString("This is bean2");
795:                bean3.setTestString("This is bean3");
796:
797:                int id1 = mCallbacksManager.save(bean1);
798:                int id2 = mCallbacksManager.save(bean2);
799:                int id3 = mCallbacksManager.save(bean3);
800:
801:                CallbacksBean.clearExecuteCallbacks();
802:
803:                AggregatingCallbacksBeanListener listener = new AggregatingCallbacksBeanListener();
804:                mCallbacksManager.addListener(listener);
805:                try {
806:                    // restore all beans
807:                    List<CallbacksBean> restored = mCallbacksManager
808:                            .restore(mCallbacksManager.getRestoreQuery()
809:                                    .orderBy("id"));
810:                    assertEquals(3, restored.size());
811:
812:                    Map<String, Object> history;
813:                    Iterator<Map.Entry<String, Object>> it;
814:                    Map.Entry<String, Object> entry;
815:
816:                    history = listener.getHistory();
817:                    assertEquals(3, history.size());
818:                    it = history.entrySet().iterator();
819:                    entry = it.next();
820:                    assertEquals("restored0", entry.getKey());
821:                    assertSame(restored.get(0), entry.getValue());
822:                    entry = it.next();
823:                    assertEquals("restored1", entry.getKey());
824:                    assertSame(restored.get(1), entry.getValue());
825:                    entry = it.next();
826:                    assertEquals("restored2", entry.getKey());
827:                    assertSame(restored.get(2), entry.getValue());
828:                    assertEquals("afterRestore " + id1 + ";listener restored\n"
829:                            + "afterRestore " + id2 + ";listener restored\n"
830:                            + "afterRestore " + id3 + ";listener restored",
831:                            StringUtils.join(CallbacksBean
832:                                    .getExecutedCallbacks(), "\n"));
833:
834:                    CallbacksBean.clearExecuteCallbacks();
835:                    listener.clearHistory();
836:                    assertEquals("", StringUtils.join(CallbacksBean
837:                            .getExecutedCallbacks(), "\n"));
838:
839:                    // restore a specific bean
840:                    CallbacksBean restored_specific = mCallbacksManager
841:                            .restore(bean2.getId());
842:
843:                    history = listener.getHistory();
844:                    assertEquals(1, history.size());
845:                    it = history.entrySet().iterator();
846:                    entry = it.next();
847:                    assertEquals("restored0", entry.getKey());
848:                    assertSame(restored_specific, entry.getValue());
849:                    assertEquals("afterRestore " + id2 + ";listener restored",
850:                            StringUtils.join(CallbacksBean
851:                                    .getExecutedCallbacks(), "\n"));
852:
853:                    CallbacksBean.clearExecuteCallbacks();
854:                    listener.clearHistory();
855:                    assertEquals("", StringUtils.join(CallbacksBean
856:                            .getExecutedCallbacks(), "\n"));
857:
858:                    // restore the first bean
859:                    CallbacksBean restored_first = mCallbacksManager
860:                            .restoreFirst(mCallbacksManager.getRestoreQuery()
861:                                    .orderBy("id"));
862:
863:                    history = listener.getHistory();
864:                    assertEquals(1, history.size());
865:                    it = history.entrySet().iterator();
866:                    entry = it.next();
867:                    assertEquals("restored0", entry.getKey());
868:                    assertSame(restored_first, entry.getValue());
869:                    assertEquals("afterRestore " + id1 + ";listener restored",
870:                            StringUtils.join(CallbacksBean
871:                                    .getExecutedCallbacks(), "\n"));
872:
873:                    CallbacksBean.clearExecuteCallbacks();
874:                    listener.clearHistory();
875:                    CallbacksBean.setAfterRestoreReturn(true);
876:                } finally {
877:                    mCallbacksManager.removeListeners();
878:                }
879:            }
880:
881:            public void testCallbacksProvider() {
882:                CallbacksProviderBean.clearExecuteCallbacks();
883:
884:                CallbacksProviderBean bean = new CallbacksProviderBean();
885:                CallbacksProviderBean newbean = null;
886:
887:                bean.setTestString("This is my test string");
888:
889:                int id1 = mCallbacksProviderManager.save(bean);
890:
891:                newbean = mCallbacksProviderManager.restore(id1);
892:
893:                assertTrue(newbean != null);
894:                assertTrue(newbean != bean);
895:                assertEquals(newbean.getTestString(), bean.getTestString());
896:                assertEquals(newbean.getId(), id1);
897:
898:                bean.setId(id1);
899:                bean.setTestString("This is a new test string");
900:
901:                assertEquals(mCallbacksProviderManager.save(bean), id1);
902:                assertEquals(bean.getId(), id1);
903:
904:                newbean = mCallbacksProviderManager.restore(id1);
905:
906:                assertTrue(newbean != null);
907:                assertTrue(newbean != bean);
908:
909:                assertEquals(newbean.getTestString(),
910:                        "This is a new test string");
911:
912:                bean.setId(999999);
913:                bean.setTestString("This is another test string");
914:
915:                int id2 = id1 + 1;
916:
917:                assertEquals(id2, mCallbacksProviderManager.save(bean));
918:                assertFalse(999999 == id2);
919:                assertEquals(bean.getId(), id1 + 1);
920:
921:                bean.setId(76876);
922:                bean.setTestString("This is a last test string");
923:
924:                int id3 = id2 + 1;
925:                assertEquals(id3, mCallbacksProviderManager.insert(bean));
926:
927:                bean.setTestString("This is an updated test string");
928:                assertEquals(id3, mCallbacksProviderManager.update(bean));
929:
930:                assertTrue(mCallbacksProviderManager.delete(id2));
931:                assertEquals(2, mCallbacksProviderManager.restore().size());
932:
933:                assertEquals(
934:                        "beforeSave -1;This is my test string\n"
935:                                + "beforeInsert -1;This is my test string\n"
936:                                + "afterInsert true "
937:                                + id1
938:                                + ";This is my test string\n"
939:                                + "afterSave true "
940:                                + id1
941:                                + ";This is my test string\n"
942:                                + "afterRestore "
943:                                + id1
944:                                + ";This is my test string\n"
945:                                + "beforeSave "
946:                                + id1
947:                                + ";This is a new test string\n"
948:                                + "beforeUpdate "
949:                                + id1
950:                                + ";This is a new test string\n"
951:                                + "afterUpdate true "
952:                                + id1
953:                                + ";This is a new test string\n"
954:                                + "afterSave true "
955:                                + id1
956:                                + ";This is a new test string\n"
957:                                + "afterRestore "
958:                                + id1
959:                                + ";This is a new test string\n"
960:                                + "beforeSave 999999;This is another test string\n"
961:                                + "beforeUpdate 999999;This is another test string\n"
962:                                + "afterUpdate false 999999;This is another test string\n"
963:                                + "beforeInsert 999999;This is another test string\n"
964:                                + "afterInsert true "
965:                                + id2
966:                                + ";This is another test string\n"
967:                                + "afterSave true "
968:                                + id2
969:                                + ";This is another test string\n"
970:                                + "beforeInsert 76876;This is a last test string\n"
971:                                + "afterInsert true "
972:                                + id3
973:                                + ";This is a last test string\n"
974:                                + "beforeUpdate "
975:                                + id3
976:                                + ";This is an updated test string\n"
977:                                + "afterUpdate true "
978:                                + id3
979:                                + ";This is an updated test string\n"
980:                                + "beforeDelete "
981:                                + id2
982:                                + "\n"
983:                                + "afterDelete true "
984:                                + id2
985:                                + "\n"
986:                                + "afterRestore "
987:                                + id1
988:                                + ";This is a new test string\n"
989:                                + "afterRestore "
990:                                + id3
991:                                + ";This is an updated test string",
992:                        StringUtils.join(CallbacksProviderBean
993:                                .getExecutedCallbacks(), "\n"));
994:            }
995:        }
www.java2java.com | Contact Us
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.