|
1 package org.apache.ojb.broker;
2
3 import java.io.Serializable  ;
4 import java.util.ArrayList ;
5 import java.util.Collection ;
6 import java.util.Collections ;
7 import java.util.Iterator ;
8 import java.util.List ;
9
10 import org.apache.commons.lang.SerializationUtils;
11 import org.apache.commons.lang.builder.EqualsBuilder;
12 import org.apache.commons.lang.builder.ToStringBuilder;
13 import org.apache.commons.lang.builder.ToStringStyle;
14 import org.apache.ojb.broker.metadata.ClassDescriptor;
15 import org.apache.ojb.broker.query.Criteria;
16 import org.apache.ojb.broker.query.Query;
17 import org.apache.ojb.broker.query.QueryByCriteria;
18 import org.apache.ojb.broker.query.QueryFactory;
19 import org.apache.ojb.broker.util.ObjectModification;
20 import org.apache.ojb.junit.PBTestCase;
21
22
30 public class InheritanceMultipleTableTest extends PBTestCase
31 {
32 public static void main(String [] args)
33 {
34 junit.textui.TestRunner.main(new String []{InheritanceMultipleTableTest.class.getName()});
35 }
36
37 public void testLookupByIdentity()
38 {
39 long timestamp = System.currentTimeMillis();
40 Long id_2 = new Long (timestamp);
41 String name = "testLookupByIdentity_" + timestamp;
42 Employee em1 = new Employee(id_2, "employee_" + name);
43 Executive ex1 = new Executive(id_2, "executive_" + name, "department_1", null);
44 Executive ex2 = new Executive(id_2, "executive_" + name, "department_2", null);
45 ArrayList list = new ArrayList ();
46 list.add(ex1);
47 list.add(ex2);
48 Manager m1 = new Manager(id_2, "manager_" + name);
49 m1.setExecutives(list);
50
51 broker.beginTransaction();
52 broker.store(em1);
53 broker.store(m1);
54 broker.commitTransaction();
55
56 Identity m1_oid = broker.serviceIdentity().buildIdentity(m1);
57 Identity ex1_oid = broker.serviceIdentity().buildIdentity(ex1);
58 Identity em1_oid = broker.serviceIdentity().buildIdentity(em1);
59
60 broker.clearCache();
61
62 Employee newEm1 = (Employee) broker.getObjectByIdentity(em1_oid);
63 Executive newEx1 = (Executive) broker.getObjectByIdentity(ex1_oid);
64 Manager newM1 = (Manager) broker.getObjectByIdentity(m1_oid);
65
66 assertNotNull(newEm1);
67 assertNotNull(newEx1);
68 assertNotNull(newM1);
69
70 assertEquals(em1.getId(), newEm1.getId());
71 assertEquals(em1.getId_2(), newEm1.getId_2());
72 assertEquals(2, newM1.getExecutives().size());
73
74 assertEquals(m1.getId(), newM1.getId());
75 assertEquals(m1.getId_2(), newM1.getId_2());
76 assertEquals(2, newM1.getExecutives().size());
77
78 assertEquals(ex1.getId(), newEx1.getId());
79 assertEquals(ex1.getId_2(), newEx1.getId_2());
80 assertEquals(ex1.getDepartment(), newEx1.getDepartment());
81 }
82
83 public void testLookupByQuery()
84 {
85 long timestamp = System.currentTimeMillis();
86 Long id_2 = new Long (timestamp);
87 String name = "testLookupByIdentity_" + timestamp;
88 Employee em1 = new Employee(id_2, "employee_" + name);
89 Executive ex1 = new Executive(id_2, "executive_" + name, "department_1", null);
90 Executive ex2 = new Executive(id_2, "executive_" + name, "department_2", null);
91 ArrayList list = new ArrayList ();
92 list.add(ex1);
93 list.add(ex2);
94 Manager m1 = new Manager(id_2, "manager_" + name);
95 m1.setExecutives(list);
96
97 broker.beginTransaction();
98 broker.store(em1);
99 broker.store(m1);
100 broker.commitTransaction();
101
102 Criteria crit = new Criteria();
103 crit.addEqualTo("name", "employee_" + name);
104 Query q = QueryFactory.newQuery(Employee.class, crit);
105 Employee newEm1 = (Employee) broker.getObjectByQuery(q);
106
107 crit = new Criteria();
108 crit.addEqualTo("name", "executive_" + name);
109 q = QueryFactory.newQuery(Employee.class, crit);
110 Executive newEx1 = (Executive) broker.getObjectByQuery(q);
111
112 crit = new Criteria();
113 crit.addEqualTo("name", "manager_" + name);
114 q = QueryFactory.newQuery(Employee.class, crit);
115 Manager newM1 = (Manager) broker.getObjectByQuery(q);
116
117 broker.clearCache();
118
119 assertNotNull(newEm1);
120 assertNotNull(newEx1);
121 assertNotNull(newM1);
122 assertEquals(2, newM1.getExecutives().size());
123 assertEquals(em1.getId(), newEm1.getId());
124 assertEquals(em1.getId_2(), newEm1.getId_2());
125
126 assertEquals(m1.getId(), newM1.getId());
127 assertEquals(m1.getId_2(), newM1.getId_2());
128
129 assertEquals(ex1.getId(), newEx1.getId());
130 assertEquals(ex1.getId_2(), newEx1.getId_2());
131 }
132
133 public void testQueryInheritancedObjects()
134 {
135 if(ojbSkipKnownIssueProblem("Classes mapped to multiple joined tables will always be instantiated " +
136 " with the class type of the query, instead of the real type"))
137 {
138 return;
139 }
140
141 long timestamp = System.currentTimeMillis();
142 String name = "testQueryInheritancedObjects_" + timestamp;
143 Company company = prepareTestDataWithCompany(name);
145 Long id_2 = company.getId();
146
147 Shareholder shareholder = new Shareholder(id_2, name);
149 shareholder.setShare(77);
150 shareholder.setDepartment("none");
151 AddressIF ad = new Address(name);
152 shareholder.setAddress(ad);
153
154 broker.beginTransaction();
155 broker.store(shareholder);
156 broker.commitTransaction();
157
158 broker.clearCache();
159 Criteria crit = new Criteria();
161 crit.addEqualTo("id_2", id_2);
162 crit.addLike("name", "%" + name + "%");
163 Query query = QueryFactory.newQuery(Employee.class, crit);
164 Collection result = broker.getCollectionByQuery(query);
165 assertEquals(7, result.size());
166 int employeeCount = 0;
167 int executiveCount = 0;
168 int managerCount = 0;
169 int shareholderCount = 0;
170 for(Iterator iterator = result.iterator(); iterator.hasNext();)
171 {
172 Object obj = iterator.next();
173 if(obj instanceof Employee) ++employeeCount;
174 if(obj instanceof Executive) ++executiveCount;
175 if(obj instanceof Manager) ++managerCount;
176 if(obj instanceof Shareholder) ++shareholderCount;
177 }
178 assertEquals(7, employeeCount);
179 assertEquals(6, executiveCount);
180 assertEquals(4, managerCount);
181 assertEquals(1, shareholderCount);
182
183 broker.clearCache();
184 crit = new Criteria();
186 crit.addEqualTo("id_2", id_2);
187 crit.addLike("name", "%" + name + "%");
188 query = QueryFactory.newQuery(Manager.class, crit);
189 result = broker.getCollectionByQuery(query);
190 assertEquals(4, result.size());
191 employeeCount = 0;
192 executiveCount = 0;
193 managerCount = 0;
194 shareholderCount = 0;
195 for(Iterator iterator = result.iterator(); iterator.hasNext();)
196 {
197 Object obj = iterator.next();
198 if(obj instanceof Employee) ++employeeCount;
199 if(obj instanceof Executive) ++executiveCount;
200 if(obj instanceof Manager) ++managerCount;
201 if(obj instanceof Shareholder) ++shareholderCount;
202 }
203 assertEquals(4, employeeCount);
204 assertEquals(4, executiveCount);
205 assertEquals(4, managerCount);
206 assertEquals(1, shareholderCount);
207
208 broker.clearCache();
209 crit = new Criteria();
211 crit.addEqualTo("id_2", id_2);
212 crit.addLike("name", "%" + name + "%");
213 query = QueryFactory.newQuery(Shareholder.class, crit);
214 result = broker.getCollectionByQuery(query);
215 assertEquals(1, result.size());
216 employeeCount = 0;
217 executiveCount = 0;
218 managerCount = 0;
219 shareholderCount = 0;
220 for(Iterator iterator = result.iterator(); iterator.hasNext();)
221 {
222 Object obj = iterator.next();
223 if(obj instanceof Employee) ++employeeCount;
224 if(obj instanceof Executive) ++executiveCount;
225 if(obj instanceof Manager) ++managerCount;
226 if(obj instanceof Shareholder) ++shareholderCount;
227 }
228 assertEquals(1, employeeCount);
229 assertEquals(1, executiveCount);
230 assertEquals(1, managerCount);
231 assertEquals(1, shareholderCount);
232 }
233
234 public void testQueryInheritancedObjectsById()
235 {
236 long timestamp = System.currentTimeMillis();
237 String name = "testQueryInheritancedObjectsByPk_" + timestamp;
238 Long id_2 = new Long (timestamp);
239
240 List insertedObjs = prepareForQueryTests(id_2, name);
241
242 Shareholder shareholder = new Shareholder(id_2, name);
244 shareholder.setShare(77);
245 shareholder.setDepartment("none");
246 AddressIF ad = new Address(name);
247 shareholder.setAddress(ad);
248
249 broker.beginTransaction();
250 broker.store(shareholder);
251 broker.commitTransaction();
252
253 broker.clearCache();
254
255 Employee emp1;
256 Identity ident;
257 Employee retrievedEmp;
258
259 emp1 = (Employee) insertedObjs.get(0);
261 ident = broker.serviceIdentity().buildIdentity(emp1);
262 retrievedEmp = (Employee) broker.getObjectByIdentity(ident);
263 assertNotNull(retrievedEmp);
264 assertSame(Manager.class, retrievedEmp.getClass());
265 assertEquals(emp1, retrievedEmp);
266
267 emp1 = (Employee) insertedObjs.get(3);
269 ident = broker.serviceIdentity().buildIdentity(emp1);
270 retrievedEmp = (Employee) broker.getObjectByIdentity(ident);
271 assertNotNull(retrievedEmp);
272 assertSame(Executive.class, retrievedEmp.getClass());
273 assertEquals(emp1, retrievedEmp);
274
275 emp1 = (Employee) insertedObjs.get(5);
277 ident = broker.serviceIdentity().buildIdentity(emp1);
278 retrievedEmp = (Employee) broker.getObjectByIdentity(ident);
279 assertNotNull(retrievedEmp);
280 assertSame(Employee.class, retrievedEmp.getClass());
281 assertEquals(emp1, retrievedEmp);
282
283 emp1 = shareholder;
285 ident = broker.serviceIdentity().buildIdentity(emp1);
286 retrievedEmp = (Employee) broker.getObjectByIdentity(ident);
287 assertNotNull(retrievedEmp);
288 assertSame(Shareholder.class, retrievedEmp.getClass());
289 assertEquals(emp1, retrievedEmp);
290 }
291
292 public void testJavaInheritance()
293 {
294 ojbSkipKnownIssueProblem("Declared inheritance (without java inheritance)" +
295 "of classes is currently not supported and will be difficult to implement");
296
297 String name = "testWithoutJavaInheritance_tmp" + System.currentTimeMillis();
298 Animal animal = new Animal(name, 55);
299 Food f1 = new Food(name + "fruit1");
300 Food f2 = new Food(name + "fruit2");
301 animal.addFood(f1);
302 animal.addFood(f2);
303
305 broker.beginTransaction();
306 broker.store(animal);
307 broker.commitTransaction();
308 Identity oid = broker.serviceIdentity().buildIdentity(animal);
309
310 broker.clearCache();
311 Animal newAnimal = (Animal) broker.getObjectByIdentity(oid);
312 assertTrue(animal.equals(newAnimal));
313
314 Criteria crit = new Criteria();
315 crit.addEqualTo("name", name);
316 Query q = QueryFactory.newQuery(Animal.class, crit);
317 Collection result = broker.getCollectionByQuery(q);
318 assertNotNull(result);
319 assertEquals(1, result.size());
320 newAnimal = (Animal) result.iterator().next();
321 assertTrue(animal.equals(newAnimal));
322 }
323
324 public void testInheritancedObjectsInCollectionReferences()
325 {
326 if(ojbSkipKnownIssueProblem("References of classes (1:1, 1:n) mapped to multiple joined tables only" +
327 " return base class type instances"))
328 {
329 return;
330 }
331
332 long timestamp = System.currentTimeMillis();
333 String name = "testInheritancedObjectsInCollectionReferences_" + timestamp;
334 Company company = prepareTestDataWithCompany(name);
335 Long id_2 = company.getId();
336
337 broker.clearCache();
338 Criteria crit = new Criteria();
339 crit.addEqualTo("id", id_2);
340 Query query = QueryFactory.newQuery(Company.class, crit);
341 Collection result = broker.getCollectionByQuery(query);
342 assertEquals(1, result.size());
343 Company newCompany = (Company) result.iterator().next();
344 List newEmployees = newCompany.getEmployees();
345 assertNotNull(newEmployees);
346 assertEquals(company.getEmployees().size(), newEmployees.size());
347
348 List newExecutives = newCompany.getExecutives();
349 assertNotNull(newExecutives);
350 assertEquals(company.getExecutives().size(), newExecutives.size());
351
352 int countEmployee = 0;
353 int countExecutive = 0;
354 int countManager = 0;
355 for(int i = 0; i < newEmployees.size(); i++)
356 {
357 Object o = newEmployees.get(i);
358 if(o instanceof Employee)
359 {
360 ++countEmployee;
361 }
362 if(o instanceof Executive)
363 {
364 ++countExecutive;
365 }
366 if(o instanceof Manager)
367 {
368 ++countManager;
369 }
370 }
371 assertEquals(6, countEmployee);
372 assertEquals(5, countExecutive);
373 assertEquals(3, countManager);
374 }
375
376 public void testInheritedReferences() throws Exception
377 {
378 if(ojbSkipKnownIssueProblem("[OJB-84] Will be fixed in next version")) return;
380
381 long timestamp = System.currentTimeMillis();
382 Long id_2 = new Long (timestamp);
383 String name = "testInheritedReferences_" + timestamp;
384 Shareholder s1 = new Shareholder(id_2, name + "_shareholder");
385 s1.setShare(23);
386 Shareholder s2 = new Shareholder(id_2, name + "_shareholder");
387 s2.setShare(24);
388 List sh = new ArrayList ();
389 sh.add(s1);
390 sh.add(s2);
391 Consortium consortium = new Consortium();
392 consortium.setName(name);
393 consortium.setShareholders(sh);
394
395 Identity oidCon;
396 Identity oidSH;
397 broker.beginTransaction();
398 broker.store(consortium);
399 broker.commitTransaction();
400 oidCon = broker.serviceIdentity().buildIdentity(consortium);
401 oidSH = broker.serviceIdentity().buildIdentity(s1);
402 broker.clearCache();
403 Consortium con = (Consortium) broker.getObjectByIdentity(oidCon);
404 assertNotNull(con);
405 assertNotNull(con.getShareholders());
406 assertEquals(2, con.getShareholders().size());
407
408 broker.clearCache();
409 Shareholder s1_new = (Shareholder) broker.getObjectByIdentity(oidSH);
410 assertNotNull(s1_new.getConsortiumKey());
411
412 broker.clearCache();
413 Criteria crit = new Criteria();
414 crit.addEqualTo("name", consortium.getName());
415 crit.addEqualTo("shareholders.share", new Integer (24));
416 crit.addEqualTo("shareholders.name", name + "_shareholder");
417 Query q = QueryFactory.newQuery(Consortium.class, crit);
418 Collection result = broker.getCollectionByQuery(q);
419 assertEquals(1, result.size());
420 assertEquals(consortium, result.iterator().next());
421 }
422
423 public void testQuery()
424 {
425 long timestamp = System.currentTimeMillis();
426 Long id_2 = new Long (timestamp);
427 String name = "testQuery_" + timestamp;
428 String s_name = name + "_Shareholder_3";
429
430 Shareholder shareholder = new Shareholder(id_2, s_name);
431 shareholder.setName(name);
432 shareholder.setShare(77);
433 shareholder.setDepartment("none");
434 AddressIF ad = new Address(name);
435 shareholder.setAddress(ad);
436
437 broker.beginTransaction();
438 broker.store(shareholder);
439 broker.commitTransaction();
440
441 Identity oid_shareholder = broker.serviceIdentity().buildIdentity(shareholder);
442 broker.clearCache();
443
444 Shareholder new_shareholder = (Shareholder) broker.getObjectByIdentity(oid_shareholder);
445 assertNotNull(new_shareholder);
446 assertEquals(shareholder, new_shareholder);
447
448 Criteria c = new Criteria();
449 c.addEqualTo("name", shareholder.getName());
450 c.addEqualTo("share", new Integer (shareholder.getShare()));
451 c.addEqualTo("department", shareholder.getDepartment());
452 c.addEqualTo("address.street", shareholder.getAddress().getStreet());
453 Query q = QueryFactory.newQuery(Shareholder.class, c);
454 Collection result = broker.getCollectionByQuery(q);
455 assertEquals(1, result.size());
456 assertEquals(shareholder, result.iterator().next());
457 }
458
459 public void testStoreDelete_2()
460 {
461 long timestamp = System.currentTimeMillis();
462 Long id_2 = new Long (timestamp);
463 String name = "testStoreDelete_" + timestamp;
464 String s_name = name + "_Shareholder_3";
465
466 Shareholder shareholder = new Shareholder(id_2, s_name);
467 shareholder.setShare(77);
468 shareholder.setDepartment("none");
469 AddressIF ad = new Address(name);
470 shareholder.setAddress(ad);
471
472 broker.beginTransaction();
473 broker.store(shareholder);
474 broker.commitTransaction();
475
476 Identity oid_shareholder = broker.serviceIdentity().buildIdentity(shareholder);
477 broker.clearCache();
478
479 Shareholder new_shareholder = (Shareholder) broker.getObjectByIdentity(oid_shareholder);
480 assertNotNull(new_shareholder);
481
482 assertEquals(s_name, new_shareholder.getName());
483 assertNotNull(new_shareholder.getAddress());
484 assertEquals(name, new_shareholder.getAddress().getStreet());
485 assertEquals(77, new_shareholder.getShare());
486
487 shareholder.getAddress().setStreet(name + "_updated");
488 shareholder.setShare(1313);
489 shareholder.setName(name + "_updated");
490
491 shareholder = (Shareholder) SerializationUtils.clone(shareholder);
493 broker.beginTransaction();
494 broker.store(shareholder);
495 broker.commitTransaction();
496
497 oid_shareholder = broker.serviceIdentity().buildIdentity(shareholder);
498 broker.clearCache();
499
500 new_shareholder = (Shareholder) broker.getObjectByIdentity(oid_shareholder);
501 assertNotNull(new_shareholder);
502
503 assertEquals(1313, new_shareholder.getShare());
504 assertEquals(name + "_updated", new_shareholder.getName());
505 assertNotNull(new_shareholder.getAddress());
506 assertEquals(name + "_updated", new_shareholder.getAddress().getStreet());
507
508 broker.beginTransaction();
509 broker.delete(shareholder);
510 broker.commitTransaction();
511
512 new_shareholder = (Shareholder) broker.getObjectByIdentity(oid_shareholder);
513 assertNull(new_shareholder);
514 }
515
516 public void testStoreDelete()
517 {
518
519 long timestamp = System.currentTimeMillis();
520 Long id_2 = new Long (timestamp);
521 String name = "testInheritancedObjectsInCollectionReferences_" + timestamp;
522 String m_name = name + "_manager_3";
523
524 Manager m = new Manager(id_2, m_name);
525 m.setDepartment("none");
526 AddressIF ad = new Address(name);
527 m.setAddress(ad);
528
529 String ex_name = name + "_executive";
530 Executive ex = new Executive(id_2, ex_name, "department_1", null);
531
532 String em_name = name + "_employee";
533 Employee em = new Employee(id_2, em_name);
534
535 broker.beginTransaction();
536 broker.store(em);
537 broker.store(ex);
538 broker.store(m);
539 broker.commitTransaction();
540
541 Identity oid_em = broker.serviceIdentity().buildIdentity(em);
542 Identity oid_ex = broker.serviceIdentity().buildIdentity(ex);
543 Identity oid_m = broker.serviceIdentity().buildIdentity(m);
544 broker.clearCache();
545
546 Employee new_em = (Employee) broker.getObjectByIdentity(oid_em);
547 Executive new_ex = (Executive) broker.getObjectByIdentity(oid_ex);
548 Manager new_m = (Manager) broker.getObjectByIdentity(oid_m);
549
550 assertNotNull(new_em);
551 assertNotNull(new_ex);
552 assertNotNull(new_m);
553
554 assertEquals(em_name, new_em.getName());
555 assertEquals(ex_name, new_ex.getName());
556 assertEquals(m_name, new_m.getName());
557 assertNotNull(new_m.getAddress());
558 assertEquals(name, new_m.getAddress().getStreet());
559
560 broker.beginTransaction();
561 broker.delete(m);
562 broker.delete(ex);
563 broker.delete(em);
564 broker.commitTransaction();
565
566 new_em = (Employee) broker.getObjectByIdentity(oid_em);
567 new_ex = (Executive) broker.getObjectByIdentity(oid_ex);
568 new_m = (Manager) broker.getObjectByIdentity(oid_m);
569
570 assertNull(new_em);
571 assertNull(new_ex);
572 assertNull(new_m);
573 }
574
575 public void testStoreUpdateQuerySerialized_2()
576 {
577 long timestamp = System.currentTimeMillis();
578 Long id_2 = new Long (timestamp);
579 String name = "testStoreUpdateQuerySerialized_" + timestamp;
580 Manager m_1 = new Manager(id_2, name + "_manager_1");
581 Manager m_2 = new Manager(id_2, name + "_manager_2");
582 Manager m_3 = new Manager(id_2, name + "_manager_3");
583 m_3.setDepartment("none");
584
585 Executive ex_1 = new Executive(id_2, name + "_executive", "department_1", null);
586 Executive ex_2 = new Executive(id_2, name + "_executive", "department_1", null);
587
588 Employee em = new Employee(id_2, name + "_employee");
589
590 broker.beginTransaction();
591 broker.store(em);
592 broker.store(m_1);
593 broker.store(m_3);
594 broker.store(ex_1);
595 broker.store(m_2);
596 broker.store(ex_2);
597 broker.commitTransaction();
598
599 broker.clearCache();
600 Criteria crit = new Criteria();
601 crit.addLike("name", name + "%");
602 crit.addLike("department", "none");
603 Query query = QueryFactory.newQuery(Manager.class, crit);
604 Collection result = broker.getCollectionByQuery(query);
605 assertEquals(1, result.size());
606
607 crit = new Criteria();
608 crit.addLike("name", name + "%");
609 query = QueryFactory.newQuery(Employee.class, crit);
610 result = broker.getCollectionByQuery(query);
611 assertEquals(6, result.size());
612
613 crit = new Criteria();
614 crit.addLike("name", name + "%");
615 query = QueryFactory.newQuery(Executive.class, crit);
616 result = broker.getCollectionByQuery(query);
617 assertEquals(5, result.size());
618
619 crit = new Criteria();
620 crit.addLike("name", name + "%");
621 query = QueryFactory.newQuery(Manager.class, crit);
622 result = broker.getCollectionByQuery(query);
623 assertEquals(3, result.size());
624
625 em = (Employee) SerializationUtils.clone(em);
626 m_1 = (Manager) SerializationUtils.clone(m_1);
627 m_2 = (Manager) SerializationUtils.clone(m_2);
628 m_3 = (Manager) SerializationUtils.clone(m_3);
629 ex_1 = (Executive) SerializationUtils.clone(ex_1);
630 ex_2 = (Executive) SerializationUtils.clone(ex_2);
631
632 em.setName(em.getName() + "_updated");
633 m_1.setName(m_1.getName() + "_updated");
634 m_1.setDepartment("_updated_Dep");
635 m_2.setName(m_2.getName() + "_updated");
636 m_3.setName(m_3.getName() + "_updated");
637 ex_1.setName(ex_1.getName() + "_updated");
638 ex_2.setName(ex_2.getName() + "_updated");
639
640 broker.clearCache();
641 broker.beginTransaction();
642 broker.store(em, ObjectModification.UPDATE);
645 broker.store(m_1, ObjectModification.UPDATE);
646 broker.store(m_3, ObjectModification.UPDATE);
647 broker.store(ex_1, ObjectModification.UPDATE);
648 broker.store(m_2, ObjectModification.UPDATE);
649 broker.store(ex_2, ObjectModification.UPDATE);
650 broker.commitTransaction();
652
653
657 broker.clearCache();
658
659 crit = new Criteria();
660 crit.addLike("name", name + "%");
661 crit.addLike("department", "_updated_Dep");
662 query = QueryFactory.newQuery(Manager.class, crit);
663 result = broker.getCollectionByQuery(query);
664 assertEquals("Expect the same number of objects as before update", 1, result.size());
665 Manager newMan = (Manager) result.iterator().next();
666 assertEquals(m_1.getName(), newMan.getName());
667 assertEquals(m_1.getDepartment(), newMan.getDepartment());
668
669 crit = new Criteria();
670 crit.addLike("name", name + "%");
671 crit.addLike("department", "none");
672 query = QueryFactory.newQuery(Manager.class, crit);
673 result = broker.getCollectionByQuery(query);
674 assertEquals("Expect the same number of objects as before update", 1, result.size());
675
676 crit = new Criteria();
677 crit.addLike("name", name + "%");
678 query = QueryFactory.newQuery(Employee.class, crit);
679 result = broker.getCollectionByQuery(query);
680 assertEquals("Expect the same number of objects as before update", 6, result.size());
681
682 crit = new Criteria();
683 crit.addLike("name", name + "%");
684 query = QueryFactory.newQuery(Executive.class, crit);
685 result = broker.getCollectionByQuery(query);
686 assertEquals("Expect the same number of objects as before update", 5, result.size());
687
688 crit = new Criteria();
689 crit.addLike("name", name + "%");
690 query = QueryFactory.newQuery(Manager.class, crit);
691 result = broker.getCollectionByQuery(query);
692 assertEquals("Expect the same number of objects as before update", 3, result.size());
693 }
694
695 public void testObjectExistence()
696 {
697 Manager target_1 = new Manager(new Long (1), "testObjectExistence");
698 Manager target_2 = new Manager(new Long (System.currentTimeMillis()), "testObjectExistence");
699
700 Identity oid_1 = broker.serviceIdentity().buildIdentity(target_1);
701 Identity oid_2 = broker.serviceIdentity().buildIdentity(target_2);
702
703 ClassDescriptor cld = broker.getClassDescriptor(Manager.class);
704
705 boolean b_1 = broker.serviceBrokerHelper().doesExist(cld, oid_1, target_1);
706 boolean b_2 = broker.serviceBrokerHelper().doesExist(cld, oid_2, target_2);
707 assertFalse(b_1);
708 assertFalse(b_2);
709 }
710
711 public void testStoreUpdateQuerySerialized()
712 {
713 long timestamp = System.currentTimeMillis();
714 Long id_2 = new Long (timestamp);
715 String name = "testStoreUpdateQuerySerialized_" + timestamp;
716 Manager m_1 = new Manager(id_2, name + "_manager_1");
717 Manager m_2 = new Manager(id_2, name + "_manager_2");
718 Manager m_3 = new Manager(id_2, name + "_manager_3");
719 m_3.setDepartment("none");
720
721 Executive ex_1 = new Executive(id_2, name + "_executive", "department_1", null);
722 Executive ex_2 = new Executive(id_2, name + "_executive", "department_1", null);
723
724 Employee em = new Employee(id_2, name + "_employee");
725
726 broker.beginTransaction();
727 broker.store(em);
728 broker.store(m_1);
729 broker.store(m_3);
730 broker.store(ex_1);
731 broker.store(m_2);
732 broker.store(ex_2);
733 broker.commitTransaction();
734
735 broker.clearCache();
736 Criteria crit = new Criteria();
737 crit.addLike("name", name + "%");
738 crit.addLike("department", "none");
739 Query query = QueryFactory.newQuery(Manager.class, crit);
740 Collection result = broker.getCollectionByQuery(query);
741 assertEquals(1, result.size());
742
743 crit = new Criteria();
744 crit.addLike("name", name + "%");
745 query = QueryFactory.newQuery(Employee.class, crit);
746 result = broker.getCollectionByQuery(query);
747 assertEquals(6, result.size());
748
749 crit = new Criteria();
750 crit.addLike("name", name + "%");
751 query = QueryFactory.newQuery(Executive.class, crit);
752 result = broker.getCollectionByQuery(query);
753 assertEquals(5, result.size());
754
755 crit = new Criteria();
756 crit.addLike("name", name + "%");
757 query = QueryFactory.newQuery(Manager.class, crit);
758 result = broker.getCollectionByQuery(query);
759 assertEquals(3, result.size());
760
761 em = (Employee) SerializationUtils.clone(em);
762 m_1 = (Manager) SerializationUtils.clone(m_1);
763 m_2 = (Manager) SerializationUtils.clone(m_2);
764 m_3 = (Manager) SerializationUtils.clone(m_3);
765 ex_1 = (Executive) SerializationUtils.clone(ex_1);
766 ex_2 = (Executive) SerializationUtils.clone(ex_2);
767
768 em.setName(em.getName() + "_updated");
769 m_1.setName(m_1.getName() + "_updated");
770 m_2.setName(m_2.getName() + "_updated");
771 m_3.setName(m_3.getName() + "_updated");
772 ex_1.setName(ex_1.getName() + "_updated");
773 ex_2.setName(ex_2.getName() + "_updated");
774
775 broker.clearCache();
776 broker.beginTransaction();
777 broker.store(em);
778 broker.store(m_1);
779 broker.store(m_3);
780 broker.store(ex_1);
781 broker.store(m_2);
782 broker.store(ex_2);
783 broker.commitTransaction();
784
785
789 broker.clearCache();
790 crit = new Criteria();
791 crit.addLike("name", name + "%");
792 crit.addLike("department", "none");
793 query = QueryFactory.newQuery(Manager.class, crit);
794 result = broker.getCollectionByQuery(query);
795 assertEquals("Expect the same number of objects as before update", 1, result.size());
796
797 crit = new Criteria();
798 crit.addLike("name", name + "%");
799 query = QueryFactory.newQuery(Employee.class, crit);
800 result = broker.getCollectionByQuery(query);
801 assertEquals("Expect the same number of objects as before update", 6, result.size());
802
803 crit = new Criteria();
804 crit.addLike("name", name + "%");
805 query = QueryFactory.newQuery(Executive.class, crit);
806 result = broker.getCollectionByQuery(query);
807 assertEquals("Expect the same number of objects as before update", 5, result.size());
808
809 crit = new Criteria();
810 crit.addLike("name", name + "%");
811 query = QueryFactory.newQuery(Manager.class, crit);
812 result = broker.getCollectionByQuery(query);
813 assertEquals("Expect the same number of objects as before update", 3, result.size());
814 }
815
816 private List prepareForQueryTests(Long id_2, String name)
817 {
818 List result = new ArrayList ();
819
820 Manager m_1 = new Manager(id_2, name + "_manager_1");
821 |
Java API By Example, From Geeks To Geeks.