|
1
16
17 package org.springframework.orm.hibernate;
18
19 import java.io.IOException  ;
20 import java.sql.Connection ;
21 import java.sql.DatabaseMetaData ;
22 import java.sql.SQLException ;
23 import java.sql.Savepoint ;
24 import java.util.ArrayList ;
25 import java.util.List ;
26
27 import javax.sql.DataSource ;
28
29 import junit.framework.TestCase;
30 import net.sf.hibernate.FlushMode;
31 import net.sf.hibernate.HibernateException;
32 import net.sf.hibernate.Interceptor;
33 import net.sf.hibernate.JDBCException;
34 import net.sf.hibernate.Query;
35 import net.sf.hibernate.Session;
36 import net.sf.hibernate.SessionFactory;
37 import net.sf.hibernate.Transaction;
38 import org.easymock.MockControl;
39
40 import org.springframework.beans.factory.BeanFactory;
41 import org.springframework.core.JdkVersion;
42 import org.springframework.dao.DataIntegrityViolationException;
43 import org.springframework.jdbc.datasource.DriverManagerDataSource;
44 import org.springframework.jdbc.datasource.LazyConnectionDataSourceProxy;
45 import org.springframework.jdbc.support.SQLStateSQLExceptionTranslator;
46 import org.springframework.transaction.CannotCreateTransactionException;
47 import org.springframework.transaction.PlatformTransactionManager;
48 import org.springframework.transaction.TransactionDefinition;
49 import org.springframework.transaction.TransactionStatus;
50 import org.springframework.transaction.UnexpectedRollbackException;
51 import org.springframework.transaction.support.TransactionCallback;
52 import org.springframework.transaction.support.TransactionCallbackWithoutResult;
53 import org.springframework.transaction.support.TransactionSynchronizationManager;
54 import org.springframework.transaction.support.TransactionTemplate;
55
56
60 public class HibernateTransactionManagerTests extends TestCase {
61
62 public void testTransactionCommit() throws SQLException , HibernateException {
63 MockControl dsControl = MockControl.createControl(DataSource .class);
64 final DataSource ds = (DataSource ) dsControl.getMock();
65 MockControl conControl = MockControl.createControl(Connection .class);
66 Connection con = (Connection ) conControl.getMock();
67 MockControl sfControl = MockControl.createControl(SessionFactory.class);
68 final SessionFactory sf = (SessionFactory) sfControl.getMock();
69 MockControl sessionControl = MockControl.createControl(Session.class);
70 Session session = (Session) sessionControl.getMock();
71 MockControl txControl = MockControl.createControl(Transaction.class);
72 Transaction tx = (Transaction) txControl.getMock();
73 MockControl queryControl = MockControl.createControl(Query.class);
74 Query query = (Query) queryControl.getMock();
75
76 final List list = new ArrayList ();
77 list.add("test");
78 con.getTransactionIsolation();
79 conControl.setReturnValue(Connection.TRANSACTION_READ_COMMITTED);
80 con.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
81 conControl.setVoidCallable(1);
82 con.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
83 conControl.setVoidCallable(1);
84 con.isReadOnly();
85 conControl.setReturnValue(false, 1);
86 sf.openSession();
87 sfControl.setReturnValue(session, 1);
88 session.beginTransaction();
89 sessionControl.setReturnValue(tx, 1);
90 session.connection();
91 sessionControl.setReturnValue(con, 2);
92 session.createQuery("some query string");
93 sessionControl.setReturnValue(query, 1);
94 query.setTimeout(10);
95 queryControl.setReturnValue(query, 1);
96 query.list();
97 queryControl.setReturnValue(list, 1);
98 session.close();
99 sessionControl.setReturnValue(null, 1);
100 tx.commit();
101 txControl.setVoidCallable(1);
102 dsControl.replay();
103 conControl.replay();
104 sfControl.replay();
105 sessionControl.replay();
106 txControl.replay();
107 queryControl.replay();
108
109 HibernateTransactionManager tm = new HibernateTransactionManager();
110 tm.setJdbcExceptionTranslator(new SQLStateSQLExceptionTranslator());
111 tm.setSessionFactory(sf);
112 tm.setDataSource(ds);
113 TransactionTemplate tt = new TransactionTemplate(tm);
114 tt.setIsolationLevel(TransactionDefinition.ISOLATION_SERIALIZABLE);
115 tt.setTimeout(10);
116 assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
117 assertTrue("Hasn't thread connection", !TransactionSynchronizationManager.hasResource(ds));
118 assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
119
120 Object result = tt.execute(new TransactionCallback() {
121 public Object doInTransaction(TransactionStatus status) {
122 assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
123 assertTrue("Has thread connection", TransactionSynchronizationManager.hasResource(ds));
124 assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
125 assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
126 HibernateTemplate ht = new HibernateTemplate(sf);
127 return ht.find("some query string");
128 }
129 });
130 assertTrue("Correct result list", result == list);
131
132 assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
133 assertTrue("Hasn't thread connection", !TransactionSynchronizationManager.hasResource(ds));
134 assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
135 dsControl.verify();
136 conControl.verify();
137 sfControl.verify();
138 sessionControl.verify();
139 txControl.verify();
140 queryControl.verify();
141 }
142
143 public void testTransactionRollback() throws HibernateException, SQLException {
144 MockControl conControl = MockControl.createControl(Connection .class);
145 Connection con = (Connection ) conControl.getMock();
146 MockControl sfControl = MockControl.createControl(SessionFactory.class);
147 final SessionFactory sf = (SessionFactory) sfControl.getMock();
148 MockControl sessionControl = MockControl.createControl(Session.class);
149 Session session = (Session) sessionControl.getMock();
150 MockControl txControl = MockControl.createControl(Transaction.class);
151 Transaction tx = (Transaction) txControl.getMock();
152
153 sf.openSession();
154 sfControl.setReturnValue(session, 1);
155 session.beginTransaction();
156 sessionControl.setReturnValue(tx, 1);
157 session.close();
158 sessionControl.setReturnValue(null, 1);
159 tx.rollback();
160 txControl.setVoidCallable(1);
161 session.connection();
162 sessionControl.setReturnValue(con, 2);
163 con.isReadOnly();
164 conControl.setReturnValue(false, 1);
165 sfControl.replay();
166 sessionControl.replay();
167 txControl.replay();
168
169 PlatformTransactionManager tm = new HibernateTransactionManager(sf);
170 TransactionTemplate tt = new TransactionTemplate(tm);
171 assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
172 assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
173
174 try {
175 tt.execute(new TransactionCallback() {
176 public Object doInTransaction(TransactionStatus status) {
177 assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
178 HibernateTemplate ht = new HibernateTemplate(sf);
179 return ht.executeFind(new HibernateCallback() {
180 public Object doInHibernate(Session session) {
181 throw new RuntimeException ("application exception");
182 }
183 });
184 }
185 });
186 fail("Should have thrown RuntimeException");
187 }
188 catch (RuntimeException ex) {
189 }
191
192 assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
193 assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
194 sfControl.verify();
195 sessionControl.verify();
196 txControl.verify();
197 }
198
199 public void testTransactionRollbackOnly() throws HibernateException, SQLException {
200 MockControl conControl = MockControl.createControl(Connection .class);
201 Connection con = (Connection ) conControl.getMock();
202 MockControl sfControl = MockControl.createControl(SessionFactory.class);
203 final SessionFactory sf = (SessionFactory) sfControl.getMock();
204 MockControl sessionControl = MockControl.createControl(Session.class);
205 Session session = (Session) sessionControl.getMock();
206 MockControl txControl = MockControl.createControl(Transaction.class);
207 Transaction tx = (Transaction) txControl.getMock();
208
209 sf.openSession();
210 sfControl.setReturnValue(session, 1);
211 session.beginTransaction();
212 sessionControl.setReturnValue(tx, 1);
213 session.flush();
214 sessionControl.setVoidCallable(1);
215 session.close();
216 sessionControl.setReturnValue(null, 1);
217 tx.rollback();
218 txControl.setVoidCallable(1);
219 session.connection();
220 sessionControl.setReturnValue(con, 2);
221 con.isReadOnly();
222 conControl.setReturnValue(false, 1);
223 sfControl.replay();
224 sessionControl.replay();
225 txControl.replay();
226
227 PlatformTransactionManager tm = new HibernateTransactionManager(sf);
228 TransactionTemplate tt = new TransactionTemplate(tm);
229 assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
230
231 tt.execute(new TransactionCallback() {
232 public Object doInTransaction(TransactionStatus status) {
233 assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
234 HibernateTemplate ht = new HibernateTemplate(sf);
235 ht.setFlushMode(HibernateTemplate.FLUSH_EAGER);
236 ht.execute(new HibernateCallback() {
237 public Object doInHibernate(Session session) {
238 return null;
239 }
240 });
241 status.setRollbackOnly();
242 return null;
243 }
244 });
245
246 assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
247 sfControl.verify();
248 sessionControl.verify();
249 txControl.verify();
250 }
251
252 public void testParticipatingTransactionWithCommit() throws HibernateException, SQLException {
253 MockControl conControl = MockControl.createControl(Connection .class);
254 Connection con = (Connection ) conControl.getMock();
255 MockControl sfControl = MockControl.createControl(SessionFactory.class);
256 final SessionFactory sf = (SessionFactory) sfControl.getMock();
257 MockControl sessionControl = MockControl.createControl(Session.class);
258 Session session = (Session) sessionControl.getMock();
259 MockControl txControl = MockControl.createControl(Transaction.class);
260 Transaction tx = (Transaction) txControl.getMock();
261
262 sf.openSession();
263 sfControl.setReturnValue(session, 1);
264 session.beginTransaction();
265 sessionControl.setReturnValue(tx, 1);
266 session.flush();
267 sessionControl.setVoidCallable(1);
268 session.close();
269 sessionControl.setReturnValue(null, 1);
270 tx.commit();
271 txControl.setVoidCallable(1);
272 session.connection();
273 sessionControl.setReturnValue(con, 2);
274 con.isReadOnly();
275 conControl.setReturnValue(false, 1);
276 sfControl.replay();
277 sessionControl.replay();
278 txControl.replay();
279
280 PlatformTransactionManager tm = new HibernateTransactionManager(sf);
281 final TransactionTemplate tt = new TransactionTemplate(tm);
282 final List l = new ArrayList ();
283 l.add("test");
284
285 Object result = tt.execute(new TransactionCallback() {
286 public Object doInTransaction(TransactionStatus status) {
287 return tt.execute(new TransactionCallback() {
288 public Object doInTransaction(TransactionStatus status) {
289 HibernateTemplate ht = new HibernateTemplate(sf);
290 ht.setFlushMode(HibernateTemplate.FLUSH_EAGER);
291 return ht.executeFind(new HibernateCallback() {
292 public Object doInHibernate(Session session) {
293 return l;
294 }
295 });
296 }
297 });
298 }
299 });
300 assertTrue("Correct result list", result == l);
301
302 sfControl.verify();
303 sessionControl.verify();
304 txControl.verify();
305 }
306
307 public void testParticipatingTransactionWithRollback() throws HibernateException, SQLException {
308 MockControl conControl = MockControl.createControl(Connection .class);
309 Connection con = (Connection ) conControl.getMock();
310 MockControl sfControl = MockControl.createControl(SessionFactory.class);
311 final SessionFactory sf = (SessionFactory) sfControl.getMock();
312 MockControl sessionControl = MockControl.createControl(Session.class);
313 Session session = (Session) sessionControl.getMock();
314 MockControl txControl = MockControl.createControl(Transaction.class);
315 Transaction tx = (Transaction) txControl.getMock();
316
317 sf.openSession();
318 sfControl.setReturnValue(session, 1);
319 session.beginTransaction();
320 sessionControl.setReturnValue(tx, 1);
321 session.close();
322 sessionControl.setReturnValue(null, 1);
323 tx.rollback();
324 txControl.setVoidCallable(1);
325 session.connection();
326 sessionControl.setReturnValue(con, 2);
327 con.isReadOnly();
328 conControl.setReturnValue(false, 1);
329 sfControl.replay();
330 sessionControl.replay();
331 txControl.replay();
332
333 PlatformTransactionManager tm = new HibernateTransactionManager(sf);
334 final TransactionTemplate tt = new TransactionTemplate(tm);
335 try {
336 tt.execute(new TransactionCallback() {
337 public Object doInTransaction(TransactionStatus status) {
338 return tt.execute(new TransactionCallback() {
339 public Object doInTransaction(TransactionStatus status) {
340 HibernateTemplate ht = new HibernateTemplate(sf);
341 ht.setFlushMode(HibernateTemplate.FLUSH_EAGER);
342 return ht.executeFind(new HibernateCallback() {
343 public Object doInHibernate(Session session) {
344 throw new RuntimeException ("application exception");
345 }
346 });
347 }
348 });
349 }
350 });
351 fail("Should have thrown RuntimeException");
352 }
353 catch (RuntimeException ex) {
354 }
356
357 sfControl.verify();
358 sessionControl.verify();
359 txControl.verify();
360 }
361
362 public void testParticipatingTransactionWithRollbackOnly() throws HibernateException, SQLException {
363 MockControl conControl = MockControl.createControl(Connection .class);
364 Connection con = (Connection ) conControl.getMock();
365 MockControl sfControl = MockControl.createControl(SessionFactory.class);
366 final SessionFactory sf = (SessionFactory) sfControl.getMock();
367 MockControl sessionControl = MockControl.createControl(Session.class);
368 Session session = (Session) sessionControl.getMock();
369 MockControl txControl = MockControl.createControl(Transaction.class);
370 Transaction tx = (Transaction) txControl.getMock();
371
372 sf.openSession();
373 sfControl.setReturnValue(session, 1);
374 session.beginTransaction();
375 sessionControl.setReturnValue(tx, 1);
376 session.close();
377 sessionControl.setReturnValue(null, 1);
378 tx.rollback();
379 txControl.setVoidCallable(1);
380 session.connection();
381 sessionControl.setReturnValue(con, 2);
382 con.isReadOnly();
383 conControl.setReturnValue(false, 1);
384 sfControl.replay();
385 sessionControl.replay();
386 txControl.replay();
387
388 PlatformTransactionManager tm = new HibernateTransactionManager(sf);
389 final TransactionTemplate tt = new TransactionTemplate(tm);
390 final List l = new ArrayList ();
391 l.add("test");
392
393 try {
394 tt.execute(new TransactionCallback() {
395 public Object doInTransaction(TransactionStatus status) {
396 return tt.execute(new TransactionCallback() {
397 public Object doInTransaction(TransactionStatus status) {
398 HibernateTemplate ht = new HibernateTemplate(sf);
399 ht.execute(new HibernateCallback() {
400 public Object doInHibernate(Session session) {
401 return l;
402 }
403 });
404 status.setRollbackOnly();
405 return null;
406 }
407 });
408 }
409 });
410 fail("Should have thrown UnexpectedRollbackException");
411 }
412 catch (UnexpectedRollbackException ex) {
413 }
415
416 sfControl.verify();
417 sessionControl.verify();
418 txControl.verify();
419 }
420
421 public void testParticipatingTransactionWithWithRequiresNew() throws HibernateException, SQLException {
422 MockControl sfControl = MockControl.createControl(SessionFactory.class);
423 final SessionFactory sf = (SessionFactory) sfControl.getMock();
424 MockControl session1Control = MockControl.createControl(Session.class);
425 Session session1 = (Session) session1Control.getMock();
426 MockControl session2Control = MockControl.createControl(Session.class);
427 Session session2 = (Session) session2Control.getMock();
428 MockControl conControl = MockControl.createControl(Connection .class);
429 Connection con = (Connection ) conControl.getMock();
430 MockControl txControl = MockControl.createControl(Transaction.class);
431 Transaction tx = (Transaction) txControl.getMock();
432
433 sf.openSession();
434 sfControl.setReturnValue(session1, 1);
435 sf.openSession();
436 sfControl.setReturnValue(session2, 1);
437 session1.beginTransaction();
438 session1Control.setReturnValue(tx, 1);
439 session2.beginTransaction();
440 session2Control.setReturnValue(tx, 1);
441 session2.flush();
442 session2Control.setVoidCallable(1);
443 session1.close();
444 session1Control.setReturnValue(null, 1);
445 session2.close();
446 session2Control.setReturnValue(null, 1);
447 tx.commit();
448 txControl.setVoidCallable(2);
449 session1.connection();
450 session1Control.setReturnValue(con, 2);
451 session2.connection();
452 session2Control.setReturnValue(con, 2);
453 con.isReadOnly();
454 conControl.setReturnValue(false, 2);
455 sfControl.replay();
456 session1Control.replay();
457 session2Control.replay();
458 conControl.replay();
459 txControl.replay();
460
461 PlatformTransactionManager tm = new HibernateTransactionManager(sf);
462 final TransactionTemplate tt = new TransactionTemplate(tm);
463 tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
464
465 assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
466 tt.execute(new TransactionCallback() {
467 public Object doInTransaction(TransactionStatus status) {
468 final SessionHolder holder = (SessionHolder) TransactionSynchronizationManager.getResource(sf);
469 assertTrue("Has thread session", holder != null);
470 assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
471 assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
472 tt.execute(new TransactionCallback() {
473 public Object doInTransaction(TransactionStatus status) {
474 HibernateTemplate ht = new HibernateTemplate(sf);
475 ht.setFlushMode(HibernateTemplate.FLUSH_EAGER);
476 return ht.executeFind(new HibernateCallback() {
477 public Object doInHibernate(Session session) {
478 assertTrue("Not enclosing session", session != holder.getSession());
479 assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
480 assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
481 return null;
482 }
483 });
484 }
485 });
486 assertTrue("Same thread session as before",
487 holder.getSession() == SessionFactoryUtils.getSession(sf, false));
488 assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
489 assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
490 return null;
491 }
492 });
493 assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
494
495 sfControl.verify();
496 session1Control.verify();
497 session2Control.verify();
498 conControl.verify();
499 txControl.verify();
500 }
501
502 public void testParticipatingTransactionWithWithNotSupported() throws HibernateException, SQLException {
503 MockControl sfControl = MockControl.createControl(SessionFactory.class);
504 final SessionFactory sf = (SessionFactory) sfControl.getMock();
505 MockControl sessionControl = MockControl.createControl(Session.class);
506 Session session = (Session) sessionControl.getMock();
507 MockControl conControl = MockControl.createControl(Connection .class);
508 Connection con = (Connection ) conControl.getMock();
509 MockControl txControl = MockControl.createControl(Transaction.class);
510 Transaction tx = (Transaction) txControl.getMock();
511
512 sf.openSession();
513 sfControl.setReturnValue(session, 2);
514 session.getSessionFactory();
515 sessionControl.setReturnValue(sf, 1);
516 session.beginTransaction();
517 sessionControl.setReturnValue(tx, 1);
518 session.getFlushMode();
519 sessionControl.setReturnValue(FlushMode.AUTO, 1);
520 session.flush();
521 sessionControl.setVoidCallable(2);
522 session.close();
523 sessionControl.setReturnValue(null, 2);
524 tx.commit();
525 txControl.setVoidCallable(1);
526 session.connection();
527 sessionControl.setReturnValue(con, 2);
528 con.isReadOnly();
529 conControl.setReturnValue(false, 1);
530 sfControl.replay();
531 sessionControl.replay();
532 conControl.replay();
533 txControl.replay();
534
535 HibernateTransactionManager tm = new HibernateTransactionManager(sf);
536 final TransactionTemplate tt = new TransactionTemplate(tm);
537 tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
538
539 assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
540 tt.execute(new TransactionCallback() {
541 public Object doInTransaction(TransactionStatus status) {
542 SessionHolder holder = (SessionHolder) TransactionSynchronizationManager.getResource(sf);
543 assertTrue("Has thread session", holder != null);
544 assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
545 assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
546 tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NOT_SUPPORTED);
547 tt.execute(new TransactionCallback() {
548 public Object doInTransaction(TransactionStatus status) {
549 assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
550 assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
551 assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
552 HibernateTemplate ht = new HibernateTemplate(sf);
553 ht.setFlushMode(HibernateTemplate.FLUSH_EAGER);
554 return ht.executeFind(new HibernateCallback() {
555 public Object doInHibernate(Session session) {
556 return null;
557 }
558 });
559 }
560 });
561 assertTrue("Same thread session as before",
562 holder.getSession() == SessionFactoryUtils.getSession(sf, false));
563 assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
564 assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
565 return null;
566 }
567 });
568 assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
569
570 sfControl.verify();
571 sessionControl.verify();
572 txControl.verify();
573 }
574
575 public void testTransactionWithPropagationSupports() throws HibernateException, SQLException {
576 MockControl sfControl = MockControl.createControl(SessionFactory.class);
577 final SessionFactory sf = (SessionFactory) sfControl.getMock();
578 MockControl sessionControl = MockControl.createControl(Session.class);
579 Session session = (Session) sessionControl.getMock();
580 sf.openSession();
581 sfControl.setReturnValue(session, 1);
582 session.getSessionFactory();
583 sessionControl.setReturnValue(sf, 1);
584 session.getFlushMode();
585 sessionControl.setReturnValue(FlushMode.NEVER, 1);
586 session.flush();
587 sessionControl.setVoidCallable(1);
588 session.close();
589 sessionControl.setReturnValue(null, 1);
590 sfControl.replay();
591 sessionControl.replay();
592
593 PlatformTransactionManager tm = new HibernateTransactionManager(sf);
594 TransactionTemplate tt = new TransactionTemplate(tm);
595 tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);
596 assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
597
598 tt.execute(new TransactionCallback() {
599 public Object doInTransaction(TransactionStatus status) {
600 assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
601 assertTrue("Is not new transaction", !status.isNewTransaction());
602 assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
603 assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
604 HibernateTemplate ht = new HibernateTemplate(sf);
605 ht.setFlushMode(HibernateTemplate.FLUSH_EAGER);
606 ht.execute(new HibernateCallback() {
607 public Object doInHibernate(Session session) {
608 return null;
609 }
610 });
611 assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
612 return null;
613 }
614 });
615
616 assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
617 sfControl.verify();
618 sessionControl.verify();
619 }
620
621 public void testTransactionCommitWithEntityInterceptor() throws HibernateException, SQLException {
622 MockControl interceptorControl = MockControl.createControl(net.sf.hibernate.Interceptor.class);
623 Interceptor entityInterceptor = (Interceptor) interceptorControl.getMock();
624 interceptorControl.replay();
625 MockControl conControl = MockControl.createControl(Connection .class);
626 Connection con = (Connection ) conControl.getMock();
627 MockControl sfControl = MockControl.createControl(SessionFactory.class);
628 final SessionFactory sf = (SessionFactory) sfControl.getMock();
629 MockControl sessionControl = MockControl.createControl(Session.class);
630 Session session = (Session) sessionControl.getMock();
631 MockControl txControl = MockControl.createControl(Transaction.class);
632 Transaction tx = (Transaction) txControl.getMock();
633
634 sf.openSession(entityInterceptor);
635 sfControl.setReturnValue(session, 1);
636 session.beginTransaction();
637 sessionControl.setReturnValue(tx, 1);
638 session.close();
639 sessionControl.setReturnValue(null, 1);
640 tx.commit();
641 txControl.setVoidCallable(1);
642 session.connection();
643 sessionControl.setReturnValue(con, 2);
644 con.isReadOnly();
645 conControl.setReturnValue(false, 1);
646 sfControl.replay();
647 sessionControl.replay();
648 txControl.replay();
649 conControl.replay();
650
651 HibernateTransactionManager tm = new HibernateTransactionManager(sf);
652 tm
|
Java API By Example, From Geeks To Geeks.