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