KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > springframework > orm > hibernate > HibernateJtaTransactionTests


1 /*
2  * Copyright 2002-2005 the original author or authors.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */

16
17 package org.springframework.orm.hibernate;
18
19 import java.util.ArrayList JavaDoc;
20 import java.util.List JavaDoc;
21
22 import javax.transaction.RollbackException JavaDoc;
23 import javax.transaction.Status JavaDoc;
24 import javax.transaction.Synchronization JavaDoc;
25 import javax.transaction.TransactionManager JavaDoc;
26 import javax.transaction.UserTransaction JavaDoc;
27
28 import junit.framework.TestCase;
29 import net.sf.hibernate.FlushMode;
30 import net.sf.hibernate.HibernateException;
31 import net.sf.hibernate.Session;
32 import net.sf.hibernate.SessionFactory;
33 import net.sf.hibernate.engine.SessionFactoryImplementor;
34 import net.sf.hibernate.engine.SessionImplementor;
35 import org.easymock.MockControl;
36
37 import org.springframework.dao.DataAccessException;
38 import org.springframework.transaction.MockJtaTransaction;
39 import org.springframework.transaction.TransactionDefinition;
40 import org.springframework.transaction.TransactionStatus;
41 import org.springframework.transaction.UnexpectedRollbackException;
42 import org.springframework.transaction.jta.JtaTransactionManager;
43 import org.springframework.transaction.support.TransactionCallback;
44 import org.springframework.transaction.support.TransactionCallbackWithoutResult;
45 import org.springframework.transaction.support.TransactionSynchronizationManager;
46 import org.springframework.transaction.support.TransactionTemplate;
47
48 /**
49  * @author Juergen Hoeller
50  * @since 08.07.2004
51  */

52 public class HibernateJtaTransactionTests extends TestCase {
53
54     public void testParticipatingJtaTransactionWithWithRequiresNew() throws Exception JavaDoc {
55         MockControl utControl = MockControl.createControl(UserTransaction JavaDoc.class);
56         UserTransaction JavaDoc ut = (UserTransaction JavaDoc) utControl.getMock();
57         MockControl tmControl = MockControl.createControl(TransactionManager JavaDoc.class);
58         TransactionManager JavaDoc tm = (TransactionManager JavaDoc) tmControl.getMock();
59         MockControl tx1Control = MockControl.createControl(javax.transaction.Transaction JavaDoc.class);
60         javax.transaction.Transaction JavaDoc tx1 = (javax.transaction.Transaction JavaDoc) tx1Control.getMock();
61         MockControl sfControl = MockControl.createControl(SessionFactory.class);
62         final SessionFactory sf = (SessionFactory) sfControl.getMock();
63         MockControl session1Control = MockControl.createControl(Session.class);
64         Session session1 = (Session) session1Control.getMock();
65         MockControl session2Control = MockControl.createControl(Session.class);
66         Session session2 = (Session) session2Control.getMock();
67
68         ut.getStatus();
69         utControl.setReturnValue(Status.STATUS_NO_TRANSACTION, 1);
70         ut.getStatus();
71         utControl.setReturnValue(Status.STATUS_ACTIVE, 3);
72         ut.begin();
73         utControl.setVoidCallable(2);
74         tm.suspend();
75         tmControl.setReturnValue(tx1, 1);
76         tm.resume(tx1);
77         tmControl.setVoidCallable(1);
78         ut.commit();
79         utControl.setVoidCallable(2);
80
81         sf.openSession();
82         sfControl.setReturnValue(session1, 1);
83         sf.openSession();
84         sfControl.setReturnValue(session2, 1);
85         session1.getSessionFactory();
86         session1Control.setReturnValue(sf, 1);
87         session2.getSessionFactory();
88         session2Control.setReturnValue(sf, 1);
89         session1.getFlushMode();
90         session1Control.setReturnValue(FlushMode.AUTO, 1);
91         session2.getFlushMode();
92         session2Control.setReturnValue(FlushMode.AUTO, 1);
93         session1.flush();
94         session1Control.setVoidCallable(1);
95         session2.flush();
96         session2Control.setVoidCallable(2);
97         session1.close();
98         session1Control.setReturnValue(null, 1);
99         session2.close();
100         session2Control.setReturnValue(null, 1);
101
102         utControl.replay();
103         tmControl.replay();
104         sfControl.replay();
105         session1Control.replay();
106         session2Control.replay();
107
108         JtaTransactionManager ptm = new JtaTransactionManager();
109         ptm.setUserTransaction(ut);
110         ptm.setTransactionManager(tm);
111         final TransactionTemplate tt = new TransactionTemplate(ptm);
112         tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
113
114         assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
115         tt.execute(new TransactionCallback() {
116             public Object JavaDoc doInTransaction(TransactionStatus status) {
117                 SessionFactoryUtils.getSession(sf, true);
118                 final SessionHolder holder = (SessionHolder) TransactionSynchronizationManager.getResource(sf);
119                 assertTrue("Has thread session", holder != null);
120                 tt.execute(new TransactionCallback() {
121                     public Object JavaDoc doInTransaction(TransactionStatus status) {
122                         HibernateTemplate ht = new HibernateTemplate(sf);
123                         ht.setFlushMode(HibernateTemplate.FLUSH_EAGER);
124                         return ht.executeFind(new HibernateCallback() {
125                             public Object JavaDoc doInHibernate(Session session) {
126                                 assertTrue("Not enclosing session", session != holder.getSession());
127                                 return null;
128                             }
129                         });
130                     }
131                 });
132                 assertTrue("Same thread session as before",
133                         holder.getSession() == SessionFactoryUtils.getSession(sf, false));
134                 return null;
135             }
136         });
137         assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
138
139         utControl.verify();
140         tmControl.verify();
141         sfControl.verify();
142         session1Control.verify();
143         session2Control.verify();
144     }
145
146     public void testJtaTransactionCommit() throws Exception JavaDoc {
147         doTestJtaTransactionCommit(Status.STATUS_NO_TRANSACTION, false);
148     }
149
150     public void testJtaTransactionCommitWithReadOnly() throws Exception JavaDoc {
151         doTestJtaTransactionCommit(Status.STATUS_NO_TRANSACTION, true);
152     }
153
154     public void testJtaTransactionCommitWithExisting() throws Exception JavaDoc {
155         doTestJtaTransactionCommit(Status.STATUS_ACTIVE, false);
156     }
157
158     public void testJtaTransactionCommitWithExistingAndReadOnly() throws Exception JavaDoc {
159         doTestJtaTransactionCommit(Status.STATUS_ACTIVE, true);
160     }
161
162     private void doTestJtaTransactionCommit(int status, final boolean readOnly) throws Exception JavaDoc {
163         MockControl utControl = MockControl.createControl(UserTransaction JavaDoc.class);
164         UserTransaction JavaDoc ut = (UserTransaction JavaDoc) utControl.getMock();
165         ut.getStatus();
166         utControl.setReturnValue(status, 1);
167         if (status == Status.STATUS_NO_TRANSACTION) {
168             ut.begin();
169             utControl.setVoidCallable(1);
170             ut.getStatus();
171             utControl.setReturnValue(Status.STATUS_ACTIVE, 1);
172             ut.commit();
173             utControl.setVoidCallable(1);
174         }
175         utControl.replay();
176
177         MockControl sfControl = MockControl.createControl(SessionFactory.class);
178         final SessionFactory sf = (SessionFactory) sfControl.getMock();
179         final MockControl sessionControl = MockControl.createControl(Session.class);
180         final Session session = (Session) sessionControl.getMock();
181         sf.openSession();
182         sfControl.setReturnValue(session, 1);
183         session.getSessionFactory();
184         sessionControl.setReturnValue(sf, 1);
185         if (readOnly) {
186             session.setFlushMode(FlushMode.NEVER);
187             sessionControl.setVoidCallable(1);
188         }
189         sfControl.replay();
190         sessionControl.replay();
191
192         JtaTransactionManager ptm = new JtaTransactionManager(ut);
193         TransactionTemplate tt = new TransactionTemplate(ptm);
194         tt.setReadOnly(readOnly);
195         final List JavaDoc l = new ArrayList JavaDoc();
196         l.add("test");
197         assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
198         assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
199
200         Object JavaDoc result = tt.execute(new TransactionCallback() {
201             public Object JavaDoc doInTransaction(TransactionStatus status) {
202                 try {
203                     assertTrue("JTA synchronizations active", TransactionSynchronizationManager.isSynchronizationActive());
204                     assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
205                     HibernateTemplate ht = new HibernateTemplate(sf);
206                     ht.setExposeNativeSession(true);
207                     List JavaDoc htl = ht.executeFind(new HibernateCallback() {
208                         public Object JavaDoc doInHibernate(Session sess) {
209                             assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
210                             assertEquals(session, sess);
211                             return l;
212                         }
213                     });
214                     ht = new HibernateTemplate(sf);
215                     ht.setExposeNativeSession(true);
216                     htl = ht.executeFind(new HibernateCallback() {
217                         public Object JavaDoc doInHibernate(Session sess) {
218                             assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
219                             assertEquals(session, sess);
220                             return l;
221                         }
222                     });
223                     assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
224                     sessionControl.verify();
225                     sessionControl.reset();
226                     try {
227                         if (!readOnly) {
228                             session.getFlushMode();
229                             sessionControl.setReturnValue(FlushMode.AUTO, 1);
230                             session.flush();
231                             sessionControl.setVoidCallable(1);
232                         }
233                         session.close();
234                         sessionControl.setReturnValue(null, 1);
235                     }
236                     catch (HibernateException e) {
237                     }
238                     sessionControl.replay();
239                     return htl;
240                 }
241                 catch (Error JavaDoc err) {
242                     err.printStackTrace();
243                     throw err;
244                 }
245             }
246         });
247
248         assertTrue("Correct result list", result == l);
249         assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
250         assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
251
252         utControl.verify();
253         sfControl.verify();
254         sessionControl.verify();
255     }
256
257     public void testJtaTransactionCommitWithJtaTm() throws Exception JavaDoc {
258         doTestJtaTransactionCommitWithJtaTm(Status.STATUS_NO_TRANSACTION);
259     }
260
261     public void testJtaTransactionCommitWithJtaTmAndExisting() throws Exception JavaDoc {
262         doTestJtaTransactionCommitWithJtaTm(Status.STATUS_ACTIVE);
263     }
264
265     private void doTestJtaTransactionCommitWithJtaTm(int status) throws Exception JavaDoc {
266         MockControl utControl = MockControl.createControl(UserTransaction JavaDoc.class);
267         UserTransaction JavaDoc ut = (UserTransaction JavaDoc) utControl.getMock();
268         ut.getStatus();
269         utControl.setReturnValue(status, 1);
270         if (status == Status.STATUS_NO_TRANSACTION) {
271             ut.begin();
272             utControl.setVoidCallable(1);
273             ut.getStatus();
274             utControl.setReturnValue(Status.STATUS_ACTIVE, 1);
275             ut.commit();
276             utControl.setVoidCallable(1);
277         }
278
279         MockControl tmControl = MockControl.createControl(TransactionManager JavaDoc.class);
280         TransactionManager JavaDoc tm = (TransactionManager JavaDoc) tmControl.getMock();
281         MockJtaTransaction transaction = new MockJtaTransaction();
282         tm.getStatus();
283         tmControl.setReturnValue(Status.STATUS_ACTIVE, 6);
284         tm.getTransaction();
285         tmControl.setReturnValue(transaction, 6);
286
287         MockControl sfControl = MockControl.createControl(SessionFactoryImplementor.class);
288         final SessionFactoryImplementor sf = (SessionFactoryImplementor) sfControl.getMock();
289         final MockControl sessionControl = MockControl.createControl(SessionImplementor.class);
290         final SessionImplementor session = (SessionImplementor) sessionControl.getMock();
291         sf.getConnectionProvider();
292         sfControl.setReturnValue(null, 2);
293         sf.getTransactionManager();
294         sfControl.setReturnValue(tm, 1);
295         sf.openSession();
296         sfControl.setReturnValue(session, 1);
297
298         utControl.replay();
299         tmControl.replay();
300         sfControl.replay();
301         sessionControl.replay();
302
303         JtaTransactionManager ptm = new JtaTransactionManager(ut);
304         TransactionTemplate tt = new TransactionTemplate(ptm);
305         final List JavaDoc l = new ArrayList JavaDoc();
306         l.add("test");
307         assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
308         assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
309
310         Object JavaDoc result = tt.execute(new TransactionCallback() {
311             public Object JavaDoc doInTransaction(TransactionStatus status) {
312                 try {
313                     assertTrue("JTA synchronizations active", TransactionSynchronizationManager.isSynchronizationActive());
314                     assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
315                     HibernateTemplate ht = new HibernateTemplate(sf);
316                     ht.setExposeNativeSession(true);
317                     List JavaDoc htl = ht.executeFind(new HibernateCallback() {
318                         public Object JavaDoc doInHibernate(Session sess) {
319                             assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
320                             assertEquals(session, sess);
321                             return l;
322                         }
323                     });
324                     ht = new HibernateTemplate(sf);
325                     ht.setExposeNativeSession(true);
326                     htl = ht.executeFind(new HibernateCallback() {
327                         public Object JavaDoc doInHibernate(Session sess) {
328                             assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
329                             assertEquals(session, sess);
330                             return l;
331                         }
332                     });
333                     assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
334                     sessionControl.verify();
335                     sessionControl.reset();
336                     try {
337                         session.getFlushMode();
338                         sessionControl.setReturnValue(FlushMode.AUTO, 1);
339                         session.flush();
340                         sessionControl.setVoidCallable(1);
341                         session.close();
342                         sessionControl.setReturnValue(null, 1);
343                     }
344                     catch (HibernateException e) {
345                     }
346                     sessionControl.replay();
347                     return htl;
348                 }
349                 catch (Error JavaDoc err) {
350                     err.printStackTrace();
351                     throw err;
352                 }
353             }
354         });
355
356         assertTrue("Correct result list", result == l);
357         assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
358         assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
359
360         utControl.verify();
361         sfControl.verify();
362         sessionControl.verify();
363     }
364
365     public void testJtaTransactionWithFlushFailure() throws Exception JavaDoc {
366         MockControl utControl = MockControl.createControl(UserTransaction JavaDoc.class);
367         UserTransaction JavaDoc ut = (UserTransaction JavaDoc) utControl.getMock();
368         ut.getStatus();
369         utControl.setReturnValue(Status.STATUS_NO_TRANSACTION, 1);
370         ut.begin();
371         utControl.setVoidCallable(1);
372         ut.rollback();
373         utControl.setVoidCallable(1);
374         utControl.replay();
375
376         MockControl sfControl = MockControl.createControl(SessionFactory.class);
377         final SessionFactory sf = (SessionFactory) sfControl.getMock();
378         final MockControl sessionControl = MockControl.createControl(Session.class);
379         final Session session = (Session) sessionControl.getMock();
380         sf.openSession();
381         sfControl.setReturnValue(session, 1);
382         session.getSessionFactory();
383         sessionControl.setReturnValue(sf, 1);
384         sfControl.replay();
385         sessionControl.replay();
386
387         JtaTransactionManager ptm = new JtaTransactionManager(ut);
388         TransactionTemplate tt = new TransactionTemplate(ptm);
389         final List JavaDoc l = new ArrayList JavaDoc();
390         l.add("test");
391         final HibernateException flushEx = new HibernateException("flush failure");
392         assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
393         assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
394
395         try {
396             tt.execute(new TransactionCallback() {
397                 public Object JavaDoc doInTransaction(TransactionStatus status) {
398                     try {
399                         assertTrue("JTA synchronizations active", TransactionSynchronizationManager.isSynchronizationActive());
400                         assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
401                         HibernateTemplate ht = new HibernateTemplate(sf);
402                         ht.setExposeNativeSession(true);
403                         List JavaDoc htl = ht.executeFind(new HibernateCallback() {
404                             public Object JavaDoc doInHibernate(Session sess) {
405                                 assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
406                                 assertEquals(session, sess);
407                                 return l;
408                             }
409                         });
410                         ht = new HibernateTemplate(sf);
411                         ht.setExposeNativeSession(true);
412                         htl = ht.executeFind(new HibernateCallback() {
413                             public Object JavaDoc doInHibernate(Session sess) {
414                                 assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
415                                 assertEquals(session, sess);
416                                 return l;
417                             }
418                         });
419                         assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
420                         sessionControl.verify();
421                         sessionControl.reset();
422                         try {
423                             session.getFlushMode();
424                             sessionControl.setReturnValue(FlushMode.AUTO, 1);
425                             session.flush();
426                             sessionControl.setThrowable(flushEx);
427                             session.close();
428                             sessionControl.setReturnValue(null, 1);
429                         }
430                         catch (HibernateException e) {
431                         }
432                         sessionControl.replay();
433                         return htl;
434                     }
435                     catch (Error JavaDoc err) {
436                         err.printStackTrace();
437                         throw err;
438                     }
439                 }
440             });
441         }
442         catch (DataAccessException ex) {
443             // expected
444
assertTrue(flushEx == ex.getCause());
445         }
446
447         assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
448         assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
449
450         utControl.verify();
451         sfControl.verify();
452         sessionControl.verify();
453     }
454
455     public void testJtaTransactionRollback() throws Exception JavaDoc {
456         MockControl utControl = MockControl.createControl(UserTransaction JavaDoc.class);
457         UserTransaction JavaDoc ut = (UserTransaction JavaDoc) utControl.getMock();
458         ut.getStatus();
459         utControl.setReturnValue(Status.STATUS_NO_TRANSACTION, 1);
460         ut.begin();
461         utControl.setVoidCallable(1);
462         ut.rollback();
463         utControl.setVoidCallable(1);
464         utControl.replay();
465
466         MockControl sfControl = MockControl.createControl(SessionFactory.class);
467         final SessionFactory sf = (SessionFactory) sfControl.getMock();
468         final MockControl sessionControl = MockControl.createControl(Session.class);
469         final Session session = (Session) sessionControl.getMock();
470         sf.openSession();
471         sfControl.setReturnValue(session, 1);
472         session.getSessionFactory();
473         sessionControl.setReturnValue(sf, 1);
474         sfControl.replay();
475         sessionControl.replay();
476
477         JtaTransactionManager ptm = new JtaTransactionManager(ut);
478         TransactionTemplate tt = new TransactionTemplate(ptm);
479         final List JavaDoc l = new ArrayList JavaDoc();
480         l.add("test");
481         assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
482
483         Object JavaDoc result = tt.execute(new TransactionCallback() {
484             public Object JavaDoc doInTransaction(TransactionStatus status) {
485                 try {
486                     assertTrue("JTA synchronizations active", TransactionSynchronizationManager.isSynchronizationActive());
487                     HibernateTemplate ht = new HibernateTemplate(sf);
488                     List JavaDoc htl = ht.executeFind(new HibernateCallback() {
489                         public Object JavaDoc doInHibernate(Session session) {
490                             return l;
491                         }
492                     });
493                     status.setRollbackOnly();
494                     sessionControl.verify();
495                     sessionControl.reset();
496                     try {
497                         session.close();
498                     }
499                     catch (HibernateException ex) {
500                     }
501                     sessionControl.setReturnValue(null, 1);
502                     sessionControl.replay();
503                     return htl;
504                 }
505                 catch (Error JavaDoc err) {
506                     err.printStackTrace();
507                     throw err;
508                 }
509             }
510         });
511         assertTrue("Correct result list", result == l);
512
513         assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
514         utControl.verify();
515         sfControl.verify();
516         sessionControl.verify();
517     }
518
519     public void testJtaTransactionCommitWithPreBound() throws Exception JavaDoc {
520         doTestJtaTransactionCommitWithPreBound(false, false, false);
521     }
522
523     public void testJtaTransactionCommitWithPreBoundAndReadOnly() throws Exception JavaDoc {
524         doTestJtaTransactionCommitWithPreBound(false, false, true);
525     }
526
527     public void testJtaTransactionCommitWithPreBoundAndFlushModeNever() throws Exception JavaDoc {
528         doTestJtaTransactionCommitWithPreBound(false, true, false);
529     }
530
531     public void testJtaTransactionCommitWithPreBoundAndFlushModeNeverAndReadOnly() throws Exception JavaDoc {
532         doTestJtaTransactionCommitWithPreBound(false, true, true);
533     }
534
535     public void testJtaTransactionCommitWithJtaTmAndPreBound() throws Exception JavaDoc {
536         doTestJtaTransactionCommitWithPreBound(true, false, false);
537     }
538
539     public void testJtaTransactionCommitWithJtaTmAndPreBoundAndReadOnly() throws Exception JavaDoc {
540         doTestJtaTransactionCommitWithPreBound(true, false, true);
541     }
542
543     public void testJtaTransactionCommitWithJtaTmAndPreBoundAndFlushModeNever() throws Exception JavaDoc {
544         doTestJtaTransactionCommitWithPreBound(true, true, false);
545     }
546
547     public void testJtaTransactionCommitWithJtaTmAndPreBoundAndFlushModeNeverAndReadOnly() throws Exception JavaDoc {
548         doTestJtaTransactionCommitWithPreBound(true, true, true);
549     }
550
551     protected void doTestJtaTransactionCommitWithPreBound(
552             boolean jtaTm, final boolean flushNever, final boolean readOnly) throws Exception JavaDoc {
553
554         MockControl utControl = MockControl.createControl(UserTransaction JavaDoc.class);
555         UserTransaction JavaDoc ut = (UserTransaction JavaDoc) utControl.getMock();
556         ut.getStatus();
557         utControl.setReturnValue(Status.STATUS_NO_TRANSACTION, 1);
558         ut.getStatus();
559         utControl.setReturnValue(Status.STATUS_ACTIVE, 1);
560         ut.begin();
561         utControl.setVoidCallable(1);
562         ut.commit();
563         utControl.setVoidCallable(1);
564
565         MockControl tmControl = MockControl.createControl(TransactionManager JavaDoc.class);
566         TransactionManager JavaDoc tm = (TransactionManager JavaDoc) tmControl.getMock();
567         if (jtaTm) {
568             MockJtaTransaction transaction = new MockJtaTransaction();
569             tm.getStatus();
570             tmControl.setReturnValue(Status.STATUS_ACTIVE, 1);
571             tm.getTransaction();
572             tmControl.setReturnValue(transaction, 1);
573         }
574
575         MockControl sfControl = MockControl.createControl(SessionFactoryImplementor.class);
576         final SessionFactoryImplementor sf = (SessionFactoryImplementor) sfControl.getMock();
577         final MockControl sessionControl = MockControl.createControl(SessionImplementor.class);
578         final SessionImplementor session = (SessionImplementor) sessionControl.getMock();
579         sf.getConnectionProvider();
580         sfControl.setReturnValue(null, 1);
581         sf.getTransactionManager();
582         sfControl.setReturnValue((jtaTm ? tm : null), 1);
583         session.getFlushMode();
584         if (flushNever) {
585             sessionControl.setReturnValue(FlushMode.NEVER, 1);
586             if (!readOnly) {
587                 session.setFlushMode(FlushMode.AUTO);
588                 sessionControl.setVoidCallable(1);
589             }
590         }
591         else {
592             sessionControl.setReturnValue(FlushMode.AUTO, 1);
593         }
594
595         utControl.replay();
596         tmControl.replay();
597         sfControl.replay();
598         sessionControl.replay();
599
600         TransactionSynchronizationManager.bindResource(sf, new SessionHolder(session));
601         try {
602             JtaTransactionManager ptm = new JtaTransactionManager(ut);
603             TransactionTemplate tt = new TransactionTemplate(ptm);
604             tt.setReadOnly(readOnly);
605             final List JavaDoc l = new ArrayList JavaDoc();
606             l.add("test");
607             assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
608             assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
609
610             Object JavaDoc result = tt.execute(new TransactionCallback() {
611                 public Object JavaDoc doInTransaction(TransactionStatus status) {
612                     try {
613                         assertTrue("JTA synchronizations active", TransactionSynchronizationManager.isSynchronizationActive());
614                         assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
615                         HibernateTemplate ht = new HibernateTemplate(sf);
616                         ht.setExposeNativeSession(true);
617                         List JavaDoc htl = null;
618                         for (int i = 0; i < 5; i++) {
619                             htl = ht.executeFind(new HibernateCallback() {
620                                 public Object JavaDoc doInHibernate(Session sess) {
621                                     assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
622                                     assertEquals(session, sess);
623                                     return l;
624                                 }
625                             });
626                             assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
627                         }
628                         sessionControl.verify();
629                         sessionControl.reset();
630                         try {
631                             if (!readOnly) {
632                                 session.getFlushMode();
633                                 sessionControl.setReturnValue(FlushMode.AUTO, 1);
634                                 session.flush();
635                                 sessionControl.setVoidCallable(1);
636                                 if (flushNever) {
637                                     session.setFlushMode(FlushMode.NEVER);
638                                     sessionControl.setVoidCallable(1);
639                                 }
640                             }
641                             session.afterTransactionCompletion(true);
642                             sessionControl.setVoidCallable(1);
643                         }
644                         catch (HibernateException e) {
645                         }
646                         sessionControl.replay();
647                         return htl;
648                     }
649                     catch (Error JavaDoc err) {
650                         err.printStackTrace();
651                         throw err;
652                     }
653                 }
654             });
655
656             assertTrue("Correct result list", result == l);
657             assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
658             assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
659         }
660         finally {
661             TransactionSynchronizationManager.unbindResource(sf);
662         }
663
664         utControl.verify();
665         tmControl.verify();
666         sfControl.verify();
667         sessionControl.verify();
668     }
669
670     public void testJtaTransactionRollbackWithPreBound() throws Exception JavaDoc {
671         MockControl utControl = MockControl.createControl(UserTransaction JavaDoc.class);
672         UserTransaction JavaDoc ut = (UserTransaction JavaDoc) utControl.getMock();
673         ut.getStatus();
674         utControl.setReturnValue(Status.STATUS_NO_TRANSACTION, 1);
675         ut.getStatus();
676         utControl.setReturnValue(Status.STATUS_ACTIVE, 1);
677         ut.getStatus();
678         utControl.setReturnValue(Status.STATUS_MARKED_ROLLBACK, 1);
679         ut.begin();
680         utControl.setVoidCallable(1);
681         ut.setRollbackOnly();
682         utControl.setVoidCallable(1);
683         RollbackException JavaDoc rex = new RollbackException JavaDoc();
684         ut.commit();
685         utControl.setThrowable(rex, 1);
686         utControl.replay();
687
688         MockControl sfControl = MockControl.createControl(SessionFactory.class);
689         final SessionFactory sf = (SessionFactory) sfControl.getMock();
690         final MockControl sessionControl = MockControl.createControl(Session.class);
691         final Session session = (Session) sessionControl.getMock();
692         session.getSessionFactory();
693         sessionControl.setReturnValue(sf, 1);
694         session.getFlushMode();
695         sessionControl.setReturnValue(FlushMode.AUTO, 1);
696         sfControl.replay();
697         sessionControl.replay();
698
699         TransactionSynchronizationManager.bindResource(sf, new SessionHolder(session));
700         try {
701             JtaTransactionManager ptm = new JtaTransactionManager(ut);
702             final TransactionTemplate tt = new TransactionTemplate(ptm);
703             assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
704             assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
705
706             tt.execute(new TransactionCallbackWithoutResult() {
707                 public void doInTransactionWithoutResult(TransactionStatus status) {
708                     tt.execute(new TransactionCallbackWithoutResult() {
709                         public void doInTransactionWithoutResult(TransactionStatus status) {
710                             status.setRollbackOnly();
711                             try {
712                                 assertTrue("JTA synchronizations active", TransactionSynchronizationManager.isSynchronizationActive());
713                                 assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
714                                 HibernateTemplate ht = new HibernateTemplate(sf);
715                                 ht.setExposeNativeSession(true);
716                                 for (int i = 0; i < 5; i++) {
717                                     ht.execute(new HibernateCallback() {
718                                         public Object JavaDoc doInHibernate(Session sess) {
719                                             assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
720                                             assertEquals(session, sess);
721                                             return null;
722                                         }
723                                     });
724                                     assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
725                                 }
726                                 sessionControl.verify();
727                                 sessionControl.reset();
728                                 session.getFlushMode();
729                                 sessionControl.setReturnValue(FlushMode.AUTO, 1);
730                                 session.flush();
731                                 sessionControl.setVoidCallable(1);
732                                 session.clear();
733                                 sessionControl.setVoidCallable(1);
734                                 sessionControl.replay();
735                             }
736                             catch (Exception JavaDoc ex) {
737                                 ex.printStackTrace();
738                             }
739                             catch (Error JavaDoc err) {
740                                 err.printStackTrace();
741                                 throw err;
742                             }
743                         }
744                     });
745                 }
746             });
747             fail("Should have thrown UnexpectedRollbackException");
748         }
749         catch (UnexpectedRollbackException ex) {
750             // expected
751
assertEquals(rex, ex.getCause());
752         }
753         finally {
754             TransactionSynchronizationManager.unbindResource(sf);
755         }
756
757         utControl.verify();
758         sfControl.verify();
759         sessionControl.verify();
760     }
761
762     public void testJtaSessionSynchronization() throws Exception JavaDoc {
763         MockControl tmControl = MockControl.createControl(TransactionManager JavaDoc.class);
764         TransactionManager JavaDoc tm = (TransactionManager JavaDoc) tmControl.getMock();
765         MockJtaTransaction transaction = new MockJtaTransaction();
766         tm.getStatus();
767         tmControl.setReturnValue(Status.STATUS_ACTIVE, 6);
768         tm.getTransaction();
769         tmControl.setReturnValue(transaction, 6);
770
771         MockControl sfControl = MockControl.createControl(SessionFactoryImplementor.class);
772         final SessionFactoryImplementor sf = (SessionFactoryImplementor) sfControl.getMock();
773         final MockControl sessionControl = MockControl.createControl(Session.class);
774         final Session session = (Session) sessionControl.getMock();
775         sf.getConnectionProvider();
776         sfControl.setReturnValue(null, 1);
777         sf.openSession();
778         sfControl.setReturnValue(session, 1);
779         sf.getTransactionManager();
780         sfControl.setReturnValue(tm, 6);
781         session.getFlushMode();
782         sessionControl.setReturnValue(FlushMode.AUTO, 1);
783         session.flush();
784         sessionControl.setVoidCallable(1);
785         session.close();
786         sessionControl.setReturnValue(null, 1);
787
788         tmControl.replay();
789         sfControl.replay();
790         sessionControl.replay();
791
792         assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
793         HibernateTemplate ht = new HibernateTemplate(sf);
794         ht.setExposeNativeSession(true);
795         for (int i = 0; i < 5; i++) {
796             ht.executeFind(new HibernateCallback() {
797                 public Object JavaDoc doInHibernate(Session sess) {
798                     assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
799                     assertEquals(session, sess);
800                     return null;
801                 }
802             });
803         }
804
805         Synchronization JavaDoc synchronization = transaction.getSynchronization();
806         assertTrue("JTA synchronization registered", synchronization != null);
807         synchronization.beforeCompletion();
808         synchronization.afterCompletion(Status.STATUS_COMMITTED);
809
810         assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
811         assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
812
813         tmControl.verify();
814         sfControl.verify();
815         sessionControl.verify();
816     }
817
818     public void testJtaSessionSynchronizationWithRollback() throws Exception JavaDoc {
819         MockControl tmControl = MockControl.createControl(TransactionManager JavaDoc.class);
820         TransactionManager JavaDoc tm = (TransactionManager JavaDoc) tmControl.getMock();
821         MockJtaTransaction transaction = new MockJtaTransaction();
822         tm.getStatus();
823         tmControl.setReturnValue(Status.STATUS_ACTIVE, 6);
824         tm.getTransaction();
825         tmControl.setReturnValue(transaction, 6);
826
827         MockControl sfControl = MockControl.createControl(SessionFactoryImplementor.class);
828         final SessionFactoryImplementor sf = (SessionFactoryImplementor) sfControl.getMock();
829         final MockControl sessionControl = MockControl.createControl(Session.class);
830         final Session session = (Session) sessionControl.getMock();
831         sf.getConnectionProvider();
832         sfControl.setReturnValue(null, 1);
833         sf.openSession();
834         sfControl.setReturnValue(session, 1);
835         sf.getTransactionManager();
836         sfControl.setReturnValue(tm, 6);
837         session.close();
838         sessionControl.setReturnValue(null, 1);
839
840         tmControl.replay();
841         sfControl.replay();
842         sessionControl.replay();
843
844         assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
845         HibernateTemplate ht = new HibernateTemplate(sf);
846         ht.setExposeNativeSession(true);
847         for (int i = 0; i < 5; i++) {
848             ht.executeFind(new HibernateCallback() {
849                 public Object JavaDoc doInHibernate(Session sess) {
850                     assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
851                     assertEquals(session, sess);
852                     return null;
853                 }
854             });
855         }
856
857         Synchronization JavaDoc synchronization = transaction.getSynchronization();
858         assertTrue("JTA synchronization registered", synchronization != null);
859         synchronization.afterCompletion(Status.STATUS_ROLLEDBACK);
860
861         assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
862         assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
863
864         tmControl.verify();
865         sfControl.verify();
866         sessionControl.verify();
867     }
868
869     public void testJtaSessionSynchronizationWithRollbackByOtherThread() throws Exception JavaDoc {
870         MockControl tmControl = MockControl.createControl(TransactionManager JavaDoc.class);
871         TransactionManager JavaDoc tm = (TransactionManager JavaDoc) tmControl.getMock();
872         MockJtaTransaction transaction = new MockJtaTransaction();
873         tm.getStatus();
874         tmControl.setReturnValue(Status.STATUS_ACTIVE, 6);
875         tm.getStatus();
876         tmControl.setReturnValue(Status.STATUS_NO_TRANSACTION, 2);
877         tm.getTransaction();
878         tmControl.setReturnValue(transaction, 6);
879
880         MockControl sfControl = MockControl.createControl(SessionFactoryImplementor.class);
881         final SessionFactoryImplementor sf = (SessionFactoryImplementor) sfControl.getMock();
882         final MockControl sessionControl = MockControl.createControl(Session.class);
883         final Session session = (Session) sessionControl.getMock();
884         sf.getConnectionProvider();
885         sfControl.setReturnValue(null, 1);
886         sf.openSession();
887         sfControl.setReturnValue(session, 2);
888         sf.getTransactionManager();
889         sfControl.setReturnValue(tm, 7);
890         session.setFlushMode(FlushMode.NEVER);
891         sessionControl.setVoidCallable(1);
892         session.close();
893         sessionControl.setReturnValue(null, 2);
894
895         tmControl.replay();
896         sfControl.replay();
897         sessionControl.replay();
898
899         assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
900         final HibernateTemplate ht = new HibernateTemplate(sf);
901         ht.setExposeNativeSession(true);
902         for (int i = 0; i < 5; i++) {
903             ht.executeFind(new HibernateCallback() {
904                 public Object JavaDoc doInHibernate(Session sess) {
905                     assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
906                     assertEquals(session, sess);
907                     return null;
908                 }
909             });
910         }
911
912         final Synchronization JavaDoc synchronization = transaction.getSynchronization();
913         assertTrue("JTA synchronization registered", synchronization != null);
914         Thread JavaDoc thread = new Thread JavaDoc() {
915             public void run() {
916                 synchronization.afterCompletion(Status.STATUS_ROLLEDBACK);
917             }
918         };
919         thread.start();
920         thread.join();
921
922         assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
923         assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
924
925         TransactionTemplate tt = new TransactionTemplate(new JtaTransactionManager(tm));
926         tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);
927         tt.setReadOnly(true);
928         tt.execute(new TransactionCallbackWithoutResult() {
929             protected void doInTransactionWithoutResult(TransactionStatus status) {
930                 assertTrue("JTA synchronizations active", TransactionSynchronizationManager.isSynchronizationActive());
931                 for (int i = 0; i < 5; i++) {
932                     ht.executeFind(new HibernateCallback() {
933                         public Object JavaDoc doInHibernate(Session sess) {
934                             assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
935                             assertEquals(session, sess);
936                             return null;
937                         }
938                     });
939                 }
940             }
941         });
942
943         assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
944         assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
945
946         tmControl.verify();
947         sfControl.verify();
948         sessionControl.verify();
949     }
950
951     public void testJtaSessionSynchronizationWithFlushFailure() throws Exception JavaDoc {
952         MockControl tmControl = MockControl.createControl(TransactionManager JavaDoc.class);
953         TransactionManager JavaDoc tm = (TransactionManager JavaDoc) tmControl.getMock();
954         MockJtaTransaction transaction = new MockJtaTransaction();
955         tm.getStatus();
956         tmControl.setReturnValue(Status.STATUS_ACTIVE, 6);
957         tm.getTransaction();
958         tmControl.setReturnValue(transaction, 6);
959         tm.setRollbackOnly();
960         tmControl.setVoidCallable(1);
961
962         final HibernateException flushEx = new HibernateException("flush failure");
963         MockControl sfControl = MockControl.createControl(SessionFactoryImplementor.class);
964         final SessionFactoryImplementor sf = (SessionFactoryImplementor) sfControl.getMock();
965         final MockControl sessionControl = MockControl.createControl(Session.class);
966         final Session session = (Session) sessionControl.getMock();
967         sf.getConnectionProvider();
968         sfControl.setReturnValue(null, 1);
969         sf.openSession();
970         sfControl.setReturnValue(session, 1);
971         sf.getTransactionManager();
972         sfControl.setReturnValue(tm, 6);
973         session.getFlushMode();
974         sessionControl.setReturnValue(FlushMode.AUTO, 1);
975         session.flush();
976         sessionControl.setThrowable(flushEx, 1);
977         session.close();
978         sessionControl.setReturnValue(null, 1);
979
980         tmControl.replay();
981         sfControl.replay();
982         sessionControl.replay();
983
984         assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
985         HibernateTemplate ht = new HibernateTemplate(sf);
986         ht.setExposeNativeSession(true);
987         for (int i = 0; i < 5; i++) {
988             ht.executeFind(new HibernateCallback() {
989                 public Object JavaDoc doInHibernate(Session sess) {
990                     assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
991                     assertEquals(session, sess);
992                     return null;
993                 }
994             });
995         }
996
997         Synchronization JavaDoc synchronization = transaction.getSynchronization();
998         assertTrue("JTA synchronization registered", synchronization != null);
999         synchronization.beforeCompletion();
1000        synchronization.afterCompletion(Status.STATUS_COMMITTED);
1001
1002        assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
1003        assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
1004
1005        tmControl.verify();
1006        sfControl.verify();
1007        sessionControl.verify();
1008    }
1009
1010    public void testJtaSessionSynchronizationWithSuspendedTransaction() throws Exception JavaDoc {
1011        MockControl tmControl = MockControl.createControl(TransactionManager JavaDoc.class);
1012        TransactionManager JavaDoc tm = (TransactionManager JavaDoc) tmControl.getMock();
1013        MockJtaTransaction transaction1 = new MockJtaTransaction();
1014        MockJtaTransaction transaction2 = new MockJtaTransaction();
1015        tm.getStatus();
1016        tmControl.setReturnValue(Status.STATUS_ACTIVE, 5);
1017        tm.getTransaction();
1018        tmControl.setReturnValue(transaction1, 2);
1019        tm.getTransaction();
1020        tmControl.setReturnValue(transaction2, 3);
1021
1022        MockControl sfControl = MockControl.createControl(SessionFactoryImplementor.class);
1023        final SessionFactoryImplementor sf = (SessionFactoryImplementor) sfControl.getMock();
1024        final MockControl session1Control = MockControl.createControl(Session.class);
1025        final Session session1 = (Session) session1Control.getMock();
1026        final MockControl session2Control = MockControl.createControl(Session.class);
1027        final Session session2 = (Session) session2Control.getMock();
1028        sf.getConnectionProvider();
1029        sfControl.setReturnValue(null, 1);
1030        sf.openSession();
1031        sfControl.setReturnValue(session1, 1);
1032        sf.openSession();
1033        sfControl.setReturnValue(session2, 1);
1034        sf.getTransactionManager();
1035        sfControl.setReturnValue(tm, 5);
1036        session1.getFlushMode();
1037        session1Control.setReturnValue(FlushMode.AUTO, 1);
1038        session2.getFlushMode();
1039        session2Control.setReturnValue(FlushMode.AUTO, 1);
1040        session1.flush();
1041        session1Control.setVoidCallable(1);
1042        session2.flush();
1043        session2Control.setVoidCallable(1);
1044        session1.close();
1045        session1Control.setReturnValue(null, 1);
1046        session2.close();
1047        session2Control.setReturnValue(null, 1);
1048
1049        tmControl.replay();
1050        sfControl.replay();
1051        session1Control.replay();
1052        session2Control.replay();
1053
1054        assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
1055        HibernateTemplate ht = new HibernateTemplate(sf);
1056        ht.setExposeNativeSession(true);
1057        ht.executeFind(new HibernateCallback() {
1058            public Object JavaDoc doInHibernate(Session sess) {
1059                assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
1060                assertEquals(session1, sess);
1061                return null;
1062            }
1063        });
1064        ht.executeFind(new HibernateCallback() {
1065            public Object JavaDoc doInHibernate(Session sess) {
1066                assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
1067                assertEquals(session2, sess);
1068                return null;
1069            }
1070        });
1071
1072        Synchronization JavaDoc synchronization2 = transaction2.getSynchronization();
1073        assertTrue("JTA synchronization registered", synchronization2 != null);
1074        synchronization2.beforeCompletion();
1075        synchronization2.afterCompletion(Status.STATUS_COMMITTED);
1076
1077        Synchronization JavaDoc synchronization1 = transaction1.getSynchronization();
1078        assertTrue("JTA synchronization registered", synchronization1 != null);
1079        synchronization1.beforeCompletion();
1080        synchronization1.afterCompletion(Status.STATUS_COMMITTED);
1081
1082        assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
1083        assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
1084
1085        tmControl.verify();
1086        sfControl.verify();
1087        session1Control.verify();
1088        session2Control.verify();
1089    }
1090
1091    public void testJtaSessionSynchronizationWithNonSessionFactoryImplementor() throws Exception JavaDoc {
1092        MockControl tmControl = MockControl.createControl(TransactionManager JavaDoc.class);
1093        TransactionManager JavaDoc tm = (TransactionManager JavaDoc) tmControl.getMock();
1094        MockJtaTransaction transaction = new MockJtaTransaction();
1095        tm.getStatus();
1096        tmControl.setReturnValue(Status.STATUS_ACTIVE, 6);
1097        tm.getTransaction();
1098        tmControl.setReturnValue(transaction, 6);
1099
1100        MockControl sfControl = MockControl.createControl(SessionFactory.class);
1101        final SessionFactory sf = (SessionFactory) sfControl.getMock();
1102        final MockControl sessionControl = MockControl.createControl(Session.class);
1103        final Session session = (Session) sessionControl.getMock();
1104        MockControl sfiControl = MockControl.createControl(SessionFactoryImplementor.class);
1105        final SessionFactoryImplementor sfi = (SessionFactoryImplementor) sfiControl.getMock();
1106        sf.openSession();
1107        sfControl.setReturnValue(session, 1);
1108        session.getSessionFactory();
1109        sessionControl.setReturnValue(sfi, 6);
1110        sfi.getTransactionManager();
1111        sfiControl.setReturnValue(tm, 6);
1112        session.getFlushMode();
1113        sessionControl.setReturnValue(FlushMode.AUTO, 1);
1114        session.flush();
1115        sessionControl.setVoidCallable(1);
1116        session.close();
1117        sessionControl.setReturnValue(null, 1);
1118
1119        tmControl.replay();
1120        sfControl.replay();
1121        sessionControl.replay();
1122        sfiControl.replay();
1123
1124        assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
1125        HibernateTemplate ht = new HibernateTemplate(sf);
1126        ht.setExposeNativeSession(true);
1127        for (int i = 0; i < 5; i++) {
1128            ht.executeFind(new HibernateCallback() {
1129                public Object JavaDoc doInHibernate(Session sess) {
1130                    assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
1131                    assertEquals(session, sess);
1132                    return null;
1133                }
1134            });
1135        }
1136
1137        Synchronization JavaDoc synchronization = transaction.getSynchronization();
1138        assertTrue("JTA Synchronization registered", synchronization != null);
1139        synchronization.beforeCompletion();
1140        synchronization.afterCompletion(Status.STATUS_COMMITTED);
1141
1142        assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
1143        assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
1144
1145        tmControl.verify();
1146        sfControl.verify();
1147        sessionControl.verify();
1148        sfiControl.verify();
1149    }
1150
1151    public void testJtaSessionSynchronizationWithSpringTransactionLaterOn() throws Exception JavaDoc {
1152        MockControl utControl = MockControl.createControl(UserTransaction JavaDoc.class);
1153        UserTransaction JavaDoc ut = (UserTransaction JavaDoc) utControl.getMock();
1154        MockControl tmControl = MockControl.createControl(TransactionManager JavaDoc.class);
1155        TransactionManager JavaDoc tm = (TransactionManager JavaDoc) tmControl.getMock();
1156        MockJtaTransaction transaction = new MockJtaTransaction();
1157        ut.getStatus();
1158        utControl.setReturnValue(Status.STATUS_ACTIVE, 1);
1159        tm.getStatus();
1160        tmControl.setReturnValue(Status.STATUS_ACTIVE, 6);
1161        tm.getTransaction();
1162        tmControl.setReturnValue(transaction, 6);
1163
1164        MockControl sfControl = MockControl.createControl(SessionFactoryImplementor.class);
1165        final SessionFactoryImplementor sf = (SessionFactoryImplementor) sfControl.getMock();
1166        final MockControl sessionControl = MockControl.createControl(Session.class);
1167        final Session session = (Session) sessionControl.getMock();
1168        sf.getConnectionProvider();
1169        sfControl.setReturnValue(null, 1);
1170        sf.openSession();
1171        sfControl.setReturnValue(session, 1);
1172        sf.getTransactionManager();
1173        sfControl.setReturnValue(tm, 6);
1174        session.getFlushMode();
1175        sessionControl.setReturnValue(FlushMode.AUTO, 1);
1176        session.flush();
1177        sessionControl.setVoidCallable(1);
1178        session.close();
1179        sessionControl.setReturnValue(null, 1);
1180
1181        utControl.replay();
1182        tmControl.replay();
1183        sfControl.replay();
1184        sessionControl.replay();
1185
1186        assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
1187        final HibernateTemplate ht = new HibernateTemplate(sf);
1188        ht.setExposeNativeSession(true);
1189        for (int i = 0; i < 2; i++) {
1190            ht.executeFind(new HibernateCallback() {
1191                public Object JavaDoc doInHibernate(Session sess) {
1192                    assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
1193                    assertEquals(session, sess);
1194                    return null;
1195                }
1196            });
1197        }
1198
1199        TransactionTemplate tt = new TransactionTemplate(new JtaTransactionManager(ut));
1200        tt.execute(new TransactionCallbackWithoutResult() {
1201            protected void doInTransactionWithoutResult(TransactionStatus status) {
1202                for (int i = 2; i < 5; i++) {
1203                    ht.executeFind(new HibernateCallback() {
1204                        public Object JavaDoc doInHibernate(Session sess) {
1205                            assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
1206                            assertEquals(session, sess);
1207                            return null;
1208                        }
1209                    });
1210                }
1211            }
1212        });
1213
1214        Synchronization JavaDoc synchronization = transaction.getSynchronization();
1215        assertTrue("JTA synchronization registered", synchronization != null);
1216        synchronization.beforeCompletion();
1217        synchronization.afterCompletion(Status.STATUS_COMMITTED);
1218
1219        assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
1220        assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
1221
1222        utControl.verify();
1223        tmControl.verify();
1224        sfControl.verify();
1225        sessionControl.verify();
1226    }
1227
1228    public void testJtaSessionSynchronizationWithPreBound() throws Exception JavaDoc {
1229        doTestJtaSessionSynchronizationWithPreBound(false);
1230    }
1231
1232    public void testJtaJtaSessionSynchronizationWithPreBoundAndFlushNever() throws Exception JavaDoc {
1233        doTestJtaSessionSynchronizationWithPreBound(true);
1234    }
1235
1236    private void doTestJtaSessionSynchronizationWithPreBound(boolean flushNever) throws Exception JavaDoc {
1237        MockControl tmControl = MockControl.createControl(TransactionManager JavaDoc.class);
1238        TransactionManager JavaDoc tm = (TransactionManager JavaDoc) tmControl.getMock();
1239        MockJtaTransaction transaction = new org.springframework.transaction.MockJtaTransaction();
1240        tm.getStatus();
1241        tmControl.setReturnValue(Status.STATUS_ACTIVE, 6);
1242        tm.getTransaction();
1243        tmControl.setReturnValue(transaction, 6);
1244
1245        MockControl sfControl = MockControl.createControl(SessionFactoryImplementor.class);
1246        final SessionFactoryImplementor sf = (SessionFactoryImplementor) sfControl.getMock();
1247        final MockControl sessionControl = MockControl.createControl(Session.class);
1248        final Session session = (Session) sessionControl.getMock();
1249        sf.getConnectionProvider();
1250        sfControl.setReturnValue(null, 1);
1251        sf.getTransactionManager();
1252        sfControl.setReturnValue(tm, 6);
1253        session.getFlushMode();
1254        if (flushNever) {
1255            sessionControl.setReturnValue(FlushMode.NEVER, 1);
1256            session.setFlushMode(FlushMode.AUTO);
1257            sessionControl.setVoidCallable(1);
1258        }
1259        else {
1260            sessionControl.setReturnValue(FlushMode.AUTO, 1);
1261        }
1262
1263        tmControl.replay();
1264        sfControl.replay();
1265        sessionControl.replay();
1266
1267        assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
1268        TransactionSynchronizationManager.bindResource(sf, new SessionHolder(session));
1269        try {
1270            assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
1271            HibernateTemplate ht = new HibernateTemplate(sf);
1272            ht.setExposeNativeSession(true);
1273            for (int i = 0; i < 5; i++) {
1274                ht.executeFind(new HibernateCallback() {
1275                    public Object JavaDoc doInHibernate(Session sess) {
1276                        assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
1277                        assertEquals(session, sess);
1278                        return null;
1279                    }
1280                });
1281            }
1282
1283            sessionControl.verify();
1284            sessionControl.reset();
1285            session.getFlushMode();
1286            sessionControl.setReturnValue(FlushMode.AUTO, 1);
1287            session.flush();
1288            sessionControl.setVoidCallable(1);
1289            if (flushNever) {
1290                session.setFlushMode(FlushMode.NEVER);
1291                sessionControl.setVoidCallable(1);
1292            }
1293            sessionControl.replay();
1294
1295            Synchronization JavaDoc synchronization = transaction.getSynchronization();
1296            assertTrue("JTA synchronization registered", synchronization != null);
1297            synchronization.beforeCompletion();
1298            synchronization.afterCompletion(Status.STATUS_COMMITTED);
1299            assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
1300        }
1301        finally {
1302            TransactionSynchronizationManager.unbindResource(sf);
1303        }
1304        assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
1305
1306        tmControl.verify();
1307        sfControl.verify();
1308        sessionControl.verify();
1309    }
1310
1311    public void testJtaSessionSynchronizationWithRemoteTransaction() throws Exception JavaDoc {
1312        MockControl tmControl = MockControl.createControl(TransactionManager JavaDoc.class);
1313        TransactionManager JavaDoc tm = (TransactionManager JavaDoc) tmControl.getMock();
1314        MockJtaTransaction transaction = new MockJtaTransaction();
1315
1316        MockControl sfControl = MockControl.createControl(SessionFactoryImplementor.class);
1317        final SessionFactoryImplementor sf = (SessionFactoryImplementor) sfControl.getMock();
1318        final MockControl sessionControl = MockControl.createControl(Session.class);
1319        final Session session = (Session) sessionControl.getMock();
1320
1321        for (int j = 0; j < 2; j++) {
1322            tmControl.reset();
1323            sfControl.reset();
1324            sessionControl.reset();
1325
1326            tm.getStatus();
1327            tmControl.setReturnValue(Status.STATUS_ACTIVE, 6);
1328            tm.getTransaction();
1329            tmControl.setReturnValue(transaction, 6);
1330
1331            sf.getConnectionProvider();
1332            sfControl.setReturnValue(null, 1);
1333            sf.openSession();
1334            sfControl.setReturnValue(session, 1);
1335            sf.getTransactionManager();
1336            sfControl.setReturnValue(tm, 6);
1337            session.getFlushMode();
1338            sessionControl.setReturnValue(FlushMode.AUTO, 1);
1339            session.flush();
1340            sessionControl.setVoidCallable(1);
1341            session.close();
1342            sessionControl.setReturnValue(null, 1);
1343
1344            tmControl.replay();
1345            sfControl.replay();
1346            sessionControl.replay();
1347
1348            if (j == 0) {
1349                assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(sf));
1350            }
1351            else {
1352                assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
1353            }
1354
1355            HibernateTemplate ht = new HibernateTemplate(sf);
1356            ht.setExposeNativeSession(true);
1357            for (int i = 0; i < 5; i++) {
1358                ht.executeFind(new HibernateCallback() {
1359                    public Object JavaDoc doInHibernate(Session sess) {
1360                        assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
1361                        assertEquals(session, sess);
1362                        return null;
1363                    }
1364                });
1365            }
1366
1367            final Synchronization JavaDoc synchronization = transaction.getSynchronization();
1368            assertTrue("JTA synchronization registered", synchronization != null);
1369
1370            // Call synchronization in a new thread, to simulate a synchronization
1371
// triggered by a new remote call from a remote transaction coordinator.
1372
Thread JavaDoc synch = new Thread JavaDoc() {
1373                public void run() {
1374                    synchronization.beforeCompletion();
1375                    synchronization.afterCompletion(Status.STATUS_COMMITTED);
1376                }
1377            };
1378            synch.start();
1379            synch.join();
1380
1381            assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(sf));
1382            SessionHolder sessionHolder = (SessionHolder) TransactionSynchronizationManager.getResource(sf);
1383            assertTrue("Thread session holder empty", sessionHolder.isEmpty());
1384            assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
1385
1386            tmControl.verify();
1387            sfControl.verify();
1388            sessionControl.verify();
1389        }
1390
1391        TransactionSynchronizationManager.unbindResource(sf);
1392    }
1393
1394    protected void tearDown() {
1395        assertTrue(TransactionSynchronizationManager.getResourceMap().isEmpty());
1396        assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
1397        assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
1398        assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
1399    }
1400
1401}
1402
Popular Tags