|
1
16
17 package org.springframework.orm.hibernate;
18
19 import java.lang.reflect.Proxy  ;
20 import java.sql.Connection ;
21 import java.sql.SQLException ;
22 import java.util.ArrayList ;
23 import java.util.Arrays ;
24 import java.util.Collections ;
25 import java.util.Iterator ;
26 import java.util.List ;
27
28 import junit.framework.TestCase;
29 import net.sf.hibernate.Criteria;
30 import net.sf.hibernate.FlushMode;
31 import net.sf.hibernate.Hibernate;
32 import net.sf.hibernate.HibernateException;
33 import net.sf.hibernate.Interceptor;
34 import net.sf.hibernate.JDBCException;
35 import net.sf.hibernate.LockMode;
36 import net.sf.hibernate.ObjectDeletedException;
37 import net.sf.hibernate.ObjectNotFoundException;
38 import net.sf.hibernate.PersistentObjectException;
39 import net.sf.hibernate.Query;
40 import net.sf.hibernate.QueryException;
41 import net.sf.hibernate.Session;
42 import net.sf.hibernate.SessionFactory;
43 import net.sf.hibernate.StaleObjectStateException;
44 import net.sf.hibernate.TransientObjectException;
45 import net.sf.hibernate.WrongClassException;
46 import net.sf.hibernate.type.Type;
47 import org.easymock.ArgumentsMatcher;
48 import org.easymock.MockControl;
49
50 import org.springframework.beans.TestBean;
51 import org.springframework.dao.DataIntegrityViolationException;
52 import org.springframework.dao.InvalidDataAccessApiUsageException;
53 import org.springframework.transaction.support.TransactionSynchronizationManager;
54
55
59 public class HibernateTemplateTests extends TestCase {
60
61 private MockControl sfControl;
62 private SessionFactory sf;
63 private MockControl sessionControl;
64 private Session session;
65
66 protected void setUp() {
67 sfControl = MockControl.createControl(SessionFactory.class);
68 sf = (SessionFactory) sfControl.getMock();
69 sessionControl = MockControl.createControl(Session.class);
70 session = (Session) sessionControl.getMock();
71 }
72
73 public void testExecuteWithNewSession() throws HibernateException {
74 sf.openSession();
75 sfControl.setReturnValue(session, 1);
76 session.getSessionFactory();
77 sessionControl.setReturnValue(sf, 1);
78 session.flush();
79 sessionControl.setVoidCallable(1);
80 session.close();
81 sessionControl.setReturnValue(null, 1);
82 sfControl.replay();
83 sessionControl.replay();
84
85 HibernateTemplate ht = new HibernateTemplate(sf);
86 assertTrue("Correct allowCreate default", ht.isAllowCreate());
87 assertTrue("Correct flushMode default", ht.getFlushMode() == HibernateTemplate.FLUSH_AUTO);
88 final List l = new ArrayList ();
89 l.add("test");
90 List result = ht.executeFind(new HibernateCallback() {
91 public Object doInHibernate(Session session) throws HibernateException {
92 return l;
93 }
94 });
95 assertTrue("Correct result list", result == l);
96 }
97
98 public void testExecuteWithNewSessionAndFlushNever() throws HibernateException {
99 sf.openSession();
100 sfControl.setReturnValue(session, 1);
101 session.getSessionFactory();
102 sessionControl.setReturnValue(sf, 1);
103 session.setFlushMode(FlushMode.NEVER);
104 sessionControl.setVoidCallable(1);
105 session.close();
106 sessionControl.setReturnValue(null, 1);
107 sfControl.replay();
108 sessionControl.replay();
109
110 HibernateTemplate ht = new HibernateTemplate(sf);
111 ht.setFlushMode(HibernateTemplate.FLUSH_NEVER);
112 final List l = new ArrayList ();
113 l.add("test");
114 List result = ht.executeFind(new HibernateCallback() {
115 public Object doInHibernate(Session session) throws HibernateException {
116 return l;
117 }
118 });
119 assertTrue("Correct result list", result == l);
120 }
121
122 public void testExecuteWithNotAllowCreate() {
123 HibernateTemplate ht = new HibernateTemplate();
124 ht.setSessionFactory(sf);
125 ht.setAllowCreate(false);
126 try {
127 ht.execute(new HibernateCallback() {
128 public Object doInHibernate(Session session) throws HibernateException{
129 return null;
130 }
131 });
132 fail("Should have thrown IllegalStateException");
133 }
134 catch (IllegalStateException ex) {
135 }
137 }
138
139 public void testExecuteWithNotAllowCreateAndThreadBound() {
140 session.getSessionFactory();
141 sessionControl.setReturnValue(sf, 1);
142 sfControl.replay();
143 sessionControl.replay();
144
145 HibernateTemplate ht = new HibernateTemplate(sf);
146 ht.setAllowCreate(false);
147
148 TransactionSynchronizationManager.bindResource(sf, new SessionHolder(session));
149 try {
150 final List l = new ArrayList ();
151 l.add("test");
152 List result = ht.executeFind(new HibernateCallback() {
153 public Object doInHibernate(Session session) throws HibernateException {
154 return l;
155 }
156 });
157 assertTrue("Correct result list", result == l);
158 }
159 finally {
160 TransactionSynchronizationManager.unbindResource(sf);
161 }
162 }
163
164 public void testExecuteWithThreadBoundAndFlushEager() throws HibernateException {
165 session.getSessionFactory();
166 sessionControl.setReturnValue(sf, 1);
167 session.flush();
168 sessionControl.setVoidCallable(1);
169 sfControl.replay();
170 sessionControl.replay();
171
172 HibernateTemplate ht = new HibernateTemplate(sf);
173 ht.setFlushModeName("FLUSH_EAGER");
174 ht.setAllowCreate(false);
175
176 TransactionSynchronizationManager.bindResource(sf, new SessionHolder(session));
177 try {
178 final List l = new ArrayList ();
179 l.add("test");
180 List result = ht.executeFind(new HibernateCallback() {
181 public Object doInHibernate(Session session) throws HibernateException {
182 return l;
183 }
184 });
185 assertTrue("Correct result list", result == l);
186 }
187 finally {
188 TransactionSynchronizationManager.unbindResource(sf);
189 }
190 }
191
192 public void testExecuteWithThreadBoundAndNewSession() throws HibernateException {
193 MockControl conControl = MockControl.createControl(Connection .class);
194 Connection con = (Connection ) conControl.getMock();
195 MockControl session2Control = MockControl.createControl(Session.class);
196 Session session2 = (Session) session2Control.getMock();
197
198 session2.connection();
199 session2Control.setReturnValue(con, 1);
200 sf.openSession(con);
201 sfControl.setReturnValue(session, 1);
202 session.flush();
203 sessionControl.setVoidCallable(1);
204 session.close();
205 sessionControl.setReturnValue(null, 1);
206 sfControl.replay();
207 sessionControl.replay();
208 session2Control.replay();
209
210 HibernateTemplate ht = new HibernateTemplate(sf);
211 ht.setAlwaysUseNewSession(true);
212
213 TransactionSynchronizationManager.bindResource(sf, new SessionHolder(session2));
214 try {
215 final List l = new ArrayList ();
216 l.add("test");
217 List result = ht.executeFind(new HibernateCallback() {
218 public Object doInHibernate(Session session) throws HibernateException {
219 return l;
220 }
221 });
222 assertTrue("Correct result list", result == l);
223 }
224 finally {
225 TransactionSynchronizationManager.unbindResource(sf);
226 }
227 }
228
229 public void testExecuteWithThreadBoundAndNewSessionAndEntityInterceptor() throws HibernateException {
230 MockControl interceptorControl = MockControl.createControl(net.sf.hibernate.Interceptor.class);
231 Interceptor entityInterceptor = (Interceptor) interceptorControl.getMock();
232
233 MockControl conControl = MockControl.createControl(Connection .class);
234 Connection con = (Connection ) conControl.getMock();
235 MockControl session2Control = MockControl.createControl(Session.class);
236 Session session2 = (Session) session2Control.getMock();
237
238 session2.connection();
239 session2Control.setReturnValue(con, 1);
240 sf.openSession(con, entityInterceptor);
241 sfControl.setReturnValue(session, 1);
242 session.flush();
243 sessionControl.setVoidCallable(1);
244 session.close();
245 sessionControl.setReturnValue(null, 1);
246 sfControl.replay();
247 sessionControl.replay();
248 session2Control.replay();
249
250 HibernateTemplate ht = new HibernateTemplate(sf);
251 ht.setAlwaysUseNewSession(true);
252 ht.setEntityInterceptor(entityInterceptor);
253
254 TransactionSynchronizationManager.bindResource(sf, new SessionHolder(session2));
255 try {
256 final List l = new ArrayList ();
257 l.add("test");
258 List result = ht.executeFind(new HibernateCallback() {
259 public Object doInHibernate(Session session) throws HibernateException {
260 return l;
261 }
262 });
263 assertTrue("Correct result list", result == l);
264 }
265 finally {
266 TransactionSynchronizationManager.unbindResource(sf);
267 }
268 }
269
270 public void testExecuteWithEntityInterceptor() throws HibernateException {
271 MockControl interceptorControl = MockControl.createControl(net.sf.hibernate.Interceptor.class);
272 Interceptor entityInterceptor = (Interceptor) interceptorControl.getMock();
273
274 sf.openSession(entityInterceptor);
275 sfControl.setReturnValue(session, 1);
276 session.getSessionFactory();
277 sessionControl.setReturnValue(sf, 1);
278 session.flush();
279 sessionControl.setVoidCallable(1);
280 session.close();
281 sessionControl.setReturnValue(null, 1);
282 sfControl.replay();
283 sessionControl.replay();
284
285 HibernateTemplate ht = new HibernateTemplate(sf);
286 ht.setEntityInterceptor(entityInterceptor);
287 final List l = new ArrayList ();
288 l.add("test");
289 List result = ht.executeFind(new HibernateCallback() {
290 public Object doInHibernate(Session session) throws HibernateException {
291 return l;
292 }
293 });
294 assertTrue("Correct result list", result == l);
295 }
296
297 public void testExecuteWithCacheQueries() throws HibernateException {
298 MockControl query1Control = MockControl.createControl(Query.class);
299 Query query1 = (Query) query1Control.getMock();
300 MockControl query2Control = MockControl.createControl(Query.class);
301 Query query2 = (Query) query2Control.getMock();
302 MockControl criteriaControl = MockControl.createControl(Criteria.class);
303 Criteria criteria = (Criteria) criteriaControl.getMock();
304
305 sf.openSession();
306 sfControl.setReturnValue(session, 1);
307 session.getSessionFactory();
308 sessionControl.setReturnValue(sf, 1);
309 session.createQuery("some query");
310 sessionControl.setReturnValue(query1);
311 query1.setCacheable(true);
312 query1Control.setReturnValue(query1, 1);
313 session.getNamedQuery("some query name");
314 sessionControl.setReturnValue(query2);
315 query2.setCacheable(true);
316 query2Control.setReturnValue(query2, 1);
317 session.createCriteria(TestBean.class);
318 sessionControl.setReturnValue(criteria, 1);
319 criteria.setCacheable(true);
320 criteriaControl.setReturnValue(criteria, 1);
321 session.flush();
322 sessionControl.setVoidCallable(1);
323 session.close();
324 sessionControl.setReturnValue(null, 1);
325 sfControl.replay();
326 sessionControl.replay();
327 query1Control.replay();
328 query2Control.replay();
329 criteriaControl.replay();
330
331 HibernateTemplate ht = new HibernateTemplate(sf);
332 ht.setCacheQueries(true);
333 ht.execute(new HibernateCallback() {
334 public Object doInHibernate(Session sess) throws HibernateException {
335 assertNotSame(session, sess);
336 assertTrue(Proxy.isProxyClass(sess.getClass()));
337 sess.createQuery("some query");
338 sess.getNamedQuery("some query name");
339 sess.createCriteria(TestBean.class);
340 sess.close();
342 return null;
343 }
344 });
345
346 query1Control.verify();
347 query2Control.verify();
348 criteriaControl.verify();
349 }
350
351 public void testExecuteWithCacheQueriesAndCacheRegion() throws HibernateException {
352 MockControl query1Control = MockControl.createControl(Query.class);
353 Query query1 = (Query) query1Control.getMock();
354 MockControl query2Control = MockControl.createControl(Query.class);
355 Query query2 = (Query) query2Control.getMock();
356 MockControl criteriaControl = MockControl.createControl(Criteria.class);
357 Criteria criteria = (Criteria) criteriaControl.getMock();
358
359 sf.openSession();
360 sfControl.setReturnValue(session, 1);
361 session.getSessionFactory();
362 sessionControl.setReturnValue(sf, 1);
363 session.createQuery("some query");
364 sessionControl.setReturnValue(query1);
365 query1.setCacheable(true);
366 query1Control.setReturnValue(query1, 1);
367 query1.setCacheRegion("myRegion");
368 query1Control.setReturnValue(query1, 1);
369 session.getNamedQuery("some query name");
370 sessionControl.setReturnValue(query2);
371 query2.setCacheable(true);
372 query2Control.setReturnValue(query2, 1);
373 query2.setCacheRegion("myRegion");
374 query2Control.setReturnValue(query2, 1);
375 session.createCriteria(TestBean.class);
376 sessionControl.setReturnValue(criteria, 1);
377 criteria.setCacheable(true);
378 criteriaControl.setReturnValue(criteria, 1);
379 criteria.setCacheRegion("myRegion");
380 criteriaControl.setReturnValue(criteria, 1);
381 session.flush();
382 sessionControl.setVoidCallable(1);
383 session.close();
384 sessionControl.setReturnValue(null, 1);
385 sfControl.replay();
386 sessionControl.replay();
387 query1Control.replay();
388 query2Control.replay();
389 criteriaControl.replay();
390
391 HibernateTemplate ht = new HibernateTemplate(sf);
392 ht.setCacheQueries(true);
393 ht.setQueryCacheRegion("myRegion");
394 ht.execute(new HibernateCallback() {
395 public Object doInHibernate(Session sess) throws HibernateException {
396 assertNotSame(session, sess);
397 assertTrue(Proxy.isProxyClass(sess.getClass()));
398 sess.createQuery("some query");
399 sess.getNamedQuery("some query name");
400 sess.createCriteria(TestBean.class);
401 sess.close();
403 return null;
404 }
405 });
406
407 query1Control.verify();
408 query2Control.verify();
409 criteriaControl.verify();
410 }
411
412 public void testExecuteWithCacheQueriesAndCacheRegionAndNativeSession() throws HibernateException {
413 MockControl query1Control = MockControl.createControl(Query.class);
414 Query query1 = (Query) query1Control.getMock();
415 MockControl query2Control = MockControl.createControl(Query.class);
416 Query query2 = (Query) query2Control.getMock();
417 MockControl criteriaControl = MockControl.createControl(Criteria.class);
418 Criteria criteria = (Criteria) criteriaControl.getMock();
419
420 sf.openSession();
421 sfControl.setReturnValue(session, 1);
422 session.getSessionFactory();
423 sessionControl.setReturnValue(sf, 1);
424 session.createQuery("some query");
425 sessionControl.setReturnValue(query1);
426 session.getNamedQuery("some query name");
427 sessionControl.setReturnValue(query2);
428 session.createCriteria(TestBean.class);
429 sessionControl.setReturnValue(criteria, 1);
430 session.flush();
431 sessionControl.setVoidCallable(1);
432 session.close();
433 sessionControl.setReturnValue(null, 1);
434 sfControl.replay();
435 sessionControl.replay();
436 query1Control.replay();
437 query2Control.replay();
438 criteriaControl.replay();
439
440 HibernateTemplate ht = new HibernateTemplate(sf);
441 ht.setExposeNativeSession(true);
442 ht.setCacheQueries(true);
443 ht.setQueryCacheRegion("myRegion");
444 ht.execute(new HibernateCallback() {
445 public Object doInHibernate(Session sess) throws HibernateException {
446 assertSame(session, sess);
447 sess.createQuery("some query");
448 sess.getNamedQuery("some query name");
449 sess.createCriteria(TestBean.class);
450 return null;
451 }
452 });
453
454 query1Control.verify();
455 query2Control.verify();
456 criteriaControl.verify();
457 }
458
459 public void testGet() throws HibernateException {
460 TestBean tb = new TestBean();
461 sf.openSession();
462 sfControl.setReturnValue(session, 1);
463 session.getSessionFactory();
464 sessionControl.setReturnValue(sf, 1);
465 session.get(TestBean.class, "");
466 sessionControl.setReturnValue(tb, 1);
467 session.flush();
468 sessionControl.setVoidCallable(1);
469 session.close();
470 sessionControl.setReturnValue(null, 1);
471 sfControl.replay();
472 sessionControl.replay();
473
474 HibernateTemplate ht = new HibernateTemplate(sf);
475 Object result = ht.get(TestBean.class, "");
476 assertTrue("Correct result", result == tb);
477 }
478
479 public void testGetWithLockMode() throws HibernateException {
480 TestBean tb = new TestBean();
481 sf.openSession();
482 sfControl.setReturnValue(session, 1);
483 session.getSessionFactory();
484 sessionControl.setReturnValue(sf, 1);
485 session.get(TestBean.class, "", LockMode.UPGRADE_NOWAIT);
486 sessionControl.setReturnValue(tb, 1);
487 session.flush();
488 sessionControl.setVoidCallable(1);
489 session.close();
490 sessionControl.setReturnValue(null, 1);
491 sfControl.replay();
492 sessionControl.replay();
493
494 HibernateTemplate ht = new HibernateTemplate(sf);
495 Object result = ht.get(TestBean.class, "", LockMode.UPGRADE_NOWAIT);
496 assertTrue("Correct result", result == tb);
497 }
498
499 public void testLoad() throws HibernateException {
500 TestBean tb = new TestBean();
501
502 sf.openSession();
503 sfControl.setReturnValue(session, 1);
504 session.getSessionFactory();
505 sessionControl.setReturnValue(sf, 1);
506 session.load(TestBean.class, "");
507 sessionControl.setReturnValue(tb, 1);
508 session.flush();
509 sessionControl.setVoidCallable(1);
510 session.close();
511 sessionControl.setReturnValue(null, 1);
512 sfControl.replay();
513 sessionControl.replay();
514
515 HibernateTemplate ht = new HibernateTemplate(sf);
516 Object result = ht.load(TestBean.class, "");
517 assertTrue("Correct result", result == tb);
518 }
519
520 public void testLoadWithNotFound() throws HibernateException {
521 sf.openSession();
522 sfControl.setReturnValue(session, 1);
523 session.getSessionFactory();
524 sessionControl.setReturnValue(sf, 1);
525 session.load(TestBean.class, "id");
526 ObjectNotFoundException onfex = new ObjectNotFoundException("id", TestBean.class);
527 sessionControl.setThrowable(onfex);
528 session.close();
529 sessionControl.setReturnValue(null, 1);
530 sfControl.replay();
531 sessionControl.replay();
532
533 HibernateTemplate ht = new HibernateTemplate(sf);
534 try {
535 ht.load(TestBean.class, "id");
536 fail("Should have thrown HibernateObjectRetrievalFailureException");
537 }
538 catch (HibernateObjectRetrievalFailureException ex) {
539 assertEquals(TestBean.class, ex.getPersistentClass());
541 assertEquals("id", ex.getIdentifier());
542 assertEquals(onfex, ex.getCause());
543 }
544 }
545
546 public void testLoadWithLockMode() throws HibernateException {
547 TestBean tb = new TestBean();
548
549 sf.openSession();
550 sfControl.setReturnValue(session, 1);
551 session.getSessionFactory();
552 sessionControl.setReturnValue(sf, 1);
553 session.load(TestBean.class, "", LockMode.UPGRADE);
554 sessionControl.setReturnValue(tb, 1);
555 session.flush();
556 sessionControl.setVoidCallable(1);
557 session.close();
558 sessionControl.setReturnValue(null, 1);
559 sfControl.replay();
560 sessionControl.replay();
561
562 HibernateTemplate ht = new HibernateTemplate(sf);
563 Object result = ht.load(TestBean.class, "", LockMode.UPGRADE);
564 assertTrue("Correct result", result == tb);
565 }
566
567 public void testLoadWithObject() throws HibernateException {
568 TestBean tb = new TestBean();
569 sf.openSession();
570 sfControl.setReturnValue(session, 1);
571 session.getSessionFactory();
572 sessionControl.setReturnValue(sf, 1);
573 session.load(tb, "");
574 sessionControl.setVoidCallable(1);
575 session.flush();
576 sessionControl.setVoidCallable(1);
577 session.close();
578 sessionControl.setReturnValue(null, 1);
579 sfControl.replay();
580 sessionControl.replay();
581
582 HibernateTemplate ht = new HibernateTemplate(sf);
583 ht.load(tb, "");
584 }
585
586 public void testLoadAll() throws HibernateException {
587 MockControl criteriaControl = MockControl.createControl(Criteria.class);
588 Criteria criteria = (Criteria) criteriaControl.getMock();
589 List list = new ArrayList ();
590
591 sf.openSession();
592 sfControl.setReturnValue(session, 1);
593 session.getSessionFactory();
594 sessionControl.setReturnValue(sf, 1);
595 session.createCriteria(TestBean.class);
596 sessionControl.setReturnValue(criteria, 1);
597 criteria.list();
598 criteriaControl.setReturnValue(list, 1);
599 session.flush();
600 sessionControl.setVoidCallable(1);
601 session.close();
602 sessionControl.setReturnValue(null, 1);
603 sfControl.replay();
604 sessionControl.replay();
605 criteriaControl.replay();
606
607 HibernateTemplate ht = new HibernateTemplate(sf);
608 List result = ht.loadAll(TestBean.class);
609 assertTrue("Correct result", result == list);
610
611 criteriaControl.verify();
612 }
613
614 public void testLoadAllWithCacheable() throws HibernateException {
615 MockControl criteriaControl = MockControl.createControl(Criteria.class);
616 Criteria criteria = (Criteria) criteriaControl.getMock();
617 List list = new ArrayList ();
618
619 sf.openSession();
620 sfControl.setReturnValue(session, 1);
621 session.getSessionFactory();
622 sessionControl.setReturnValue(sf, 1);
623 session.createCriteria(TestBean.class);
624 sessionControl.setReturnValue(criteria, 1);
625 criteria.setCacheable(true);
626 criteriaControl.setReturnValue(criteria, 1);
627 criteria.list();
628 criteriaControl.setReturnValue(list, 1);
629 session.flush();
630 sessionControl.setVoidCallable(1);
631 session.close();
632 sessionControl.setReturnValue(null, 1);
633 sfControl.replay();
634 sessionControl.replay();
635 criteriaControl.replay();
636
637 HibernateTemplate ht = new HibernateTemplate(sf);
638 ht.setCacheQueries(true);
639 List result = ht.loadAll(TestBean.class);
640 assertTrue("Correct result", result == list);
641
642 criteriaControl.verify();
643 }
644
645 public void testLoadAllWithCacheableAndCacheRegion() throws HibernateException {
646 MockControl criteriaControl = MockControl.createControl(Criteria.class);
647 Criteria criteria = (Criteria) criteriaControl.getMock();
648 List list = new ArrayList ();
649
650 sf.openSession();
651 sfControl.setReturnValue(session, 1);
652 session.getSessionFactory();
653 sessionControl.setReturnValue(sf, 1);
654 session.createCriteria(TestBean.class);
655 sessionControl.setReturnValue(criteria, 1);
656 criteria.setCacheable(true);
657 criteriaControl.setReturnValue(criteria, 1);
658 criteria.setCacheRegion("myCacheRegion");
659 criteriaControl.setReturnValue(criteria, 1);
660 criteria.list();
661 criteriaControl.setReturnValue(list, 1);
662 session.flush();
663 sessionControl.setVoidCallable(1);
664 session.close();
665 sessionControl.setReturnValue(null, 1);
666 sfControl.replay();
667 sessionControl.replay();
668 criteriaControl.replay();
669
670 HibernateTemplate ht = new HibernateTemplate(sf);
671 ht.setCacheQueries(true);
672 ht.setQueryCacheRegion("myCacheRegion");
673 List result = ht.loadAll(TestBean.class);
674 assertTrue("Correct result", result == list);
675
676 criteriaControl.verify();
677 }
678
679 public void testRefresh() throws HibernateException {
680 TestBean tb = new TestBean();
681 sf.openSession();
682 sfControl.setReturnValue(session, 1);
683 session.getSessionFactory();
684 sessionControl.setReturnValue(sf, 1);
685 session.refresh(tb);
686 sessionControl.setVoidCallable(1);
687 session.flush();
688 sessionControl.setVoidCallable(1);
689 session.close();
690 sessionControl.setReturnValue(null, 1);
691 sfControl.replay();
692 sessionControl.replay();
693
694 HibernateTemplate ht = new HibernateTemplate(sf);
695 ht.refresh(tb);
696 }
697
698 public void testContains() throws HibernateException {
699 TestBean tb = new TestBean();
700 sf.openSession();
701 sfControl.setReturnValue(session, 1);
702 session.getSessionFactory();
703 sessionControl.setReturnValue(sf, 1);
704 session.contains(tb);
705 sessionControl.setReturnValue(true, 1);
706 session.flush();
707 sessionControl.setVoidCallable(1);
708 session.close();
709 sessionControl.setReturnValue(null, 1);
710 sfControl.replay();
711 sessionControl.replay();
712
713 HibernateTemplate ht = new HibernateTemplate(sf);
714 assertTrue(ht.contains(tb));
715 }
716
717 public void testEvict() throws HibernateException {
718 TestBean tb = new TestBean();
719 sf.openSession();
720 sfControl.setReturnValue(session, 1);
721 session.getSessionFactory();
722 sessionControl.setReturnValue(sf, 1);
723 session.evict(tb);
724 sessionControl.setVoidCallable(1);
725 session.flush();
726 sessionControl.setVoidCallable(1);
727 session.close();
728 sessionControl.setReturnValue(null, 1);
729 sfControl.replay();
730 sessionControl.replay();
731
732 HibernateTemplate ht = new HibernateTemplate(sf);
733 ht.evict(tb);
734 }
735
736 public void testLock() throws HibernateException {
737 TestBean tb = new TestBean();
738 sf.openSession();
739 sfControl.setReturnValue(session, 1);
740 session.getSessionFactory();
741 sessionControl.setReturnValue(sf, 1);
742 session.lock(tb, LockMode.WRITE);
743 sessionControl.setVoidCallable(1);
744 session.flush();
745 sessionControl.setVoidCallable(1);
746 session.close();
747 sessionControl.setReturnValue(null, 1);
748 sfControl.replay();
749 sessionControl.replay();
750
751 HibernateTemplate ht = new HibernateTemplate(sf);
752 ht.lock(tb, LockMode.WRITE);
753 }
754
755 public void testSave() throws HibernateException {
756 TestBean tb = new TestBean();
757 sf.openSession();
758 sfControl.setReturnValue(session, 1);
759 session.getSessionFactory();
760 sessionControl.setReturnValue(sf, 1);
761 session.getFlushMode();
762 sessionControl.setReturnValue(FlushMode.AUTO);
763 session.save(tb);
764 sessionControl.setReturnValue(new Integer (0), 1);
765 session.flush();
766 sessionControl.setVoidCallable(1);
767 session.close();
768 sessionControl.setReturnValue(null, 1);
769 sfControl.replay();
770 sessionControl.replay();
771
772 HibernateTemplate ht = new HibernateTemplate(sf);
773 assertEquals("Correct return value", ht.save(tb), new Integer (0));
774 }
775
776 public void testSaveWithId() throws HibernateException {
777 TestBean tb = new TestBean();
778 sf.openSession();
779 sfControl.setReturnValue(session, 1);
780 session.getSessionFactory();
781 sessionControl.setReturnValue(sf, 1);
782 &
|
Java API By Example, From Geeks To Geeks.