JtaTransactionManagerTests


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.transaction;
18  
19  import javax.transaction.HeuristicMixedException  ;
20  import javax.transaction.HeuristicRollbackException  ;
21  import javax.transaction.NotSupportedException  ;
22  import javax.transaction.RollbackException  ;
23  import javax.transaction.Status  ;
24  import javax.transaction.SystemException  ;
25  import javax.transaction.Transaction  ;
26  import javax.transaction.TransactionManager  ;
27  import javax.transaction.UserTransaction  ;
28  
29  import junit.framework.TestCase;
30  import org.easymock.MockControl;
31  
32  import org.springframework.transaction.jta.JtaTransactionManager;
33  import org.springframework.transaction.support.DefaultTransactionDefinition;
34  import org.springframework.transaction.support.TransactionCallbackWithoutResult;
35  import org.springframework.transaction.support.TransactionSynchronization;
36  import org.springframework.transaction.support.TransactionSynchronizationAdapter;
37  import org.springframework.transaction.support.TransactionSynchronizationManager;
38  import org.springframework.transaction.support.TransactionTemplate;
39  
40  /**
41   * @author Juergen Hoeller
42   * @since 12.05.2003
43   */
44  public class JtaTransactionManagerTests extends TestCase {
45      
46      public void testJtaTransactionManagerWithCommit() throws Exception   {
47          MockControl utControl = MockControl.createControl(UserTransaction  .class);
48          UserTransaction   ut = (UserTransaction  ) utControl.getMock();
49          ut.getStatus();
50          utControl.setReturnValue(Status.STATUS_NO_TRANSACTION, 1);
51          ut.getStatus();
52          utControl.setReturnValue(Status.STATUS_ACTIVE, 1);
53          ut.begin();
54          utControl.setVoidCallable(1);
55          ut.commit();
56          utControl.setVoidCallable(1);
57          utControl.replay();
58  
59          MockControl synchControl = MockControl.createControl(TransactionSynchronization.class);
60          final TransactionSynchronization synch = (TransactionSynchronization) synchControl.getMock();
61          synch.beforeCommit(false);
62          synchControl.setVoidCallable(1);
63          synch.beforeCompletion();
64          synchControl.setVoidCallable(1);
65          synch.afterCompletion(TransactionSynchronization.STATUS_COMMITTED);
66          synchControl.setVoidCallable(1);
67          synchControl.replay();
68  
69          JtaTransactionManager ptm = new JtaTransactionManager(ut);
70          TransactionTemplate tt = new TransactionTemplate(ptm);
71          tt.setName("txName");
72  
73          assertEquals(JtaTransactionManager.SYNCHRONIZATION_ALWAYS, ptm.getTransactionSynchronization());
74          assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
75          assertNull(TransactionSynchronizationManager.getCurrentTransactionName());
76          assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
77          tt.execute(new TransactionCallbackWithoutResult() {
78              protected void doInTransactionWithoutResult(TransactionStatus status) {
79                  // something transactional
80                  assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
81                  TransactionSynchronizationManager.registerSynchronization(synch);
82                  assertEquals("txName", TransactionSynchronizationManager.getCurrentTransactionName());
83                  assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
84              }
85          });
86          assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
87          assertNull(TransactionSynchronizationManager.getCurrentTransactionName());
88          assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
89  
90          utControl.verify();
91          synchControl.verify();
92      }
93  
94      public void testJtaTransactionManagerWithCommitAndSynchronizationOnActual() throws Exception   {
95          MockControl utControl = MockControl.createControl(UserTransaction  .class);
96          UserTransaction   ut = (UserTransaction  ) utControl.getMock();
97          ut.getStatus();
98          utControl.setReturnValue(Status.STATUS_NO_TRANSACTION, 1);
99          ut.getStatus();
100         utControl.setReturnValue(Status.STATUS_ACTIVE, 1);
101         ut.begin();
102         utControl.setVoidCallable(1);
103         ut.commit();
104         utControl.setVoidCallable(1);
105         utControl.replay();
106 
107         MockControl synchControl = MockControl.createControl(TransactionSynchronization.class);
108         final TransactionSynchronization synch = (TransactionSynchronization) synchControl.getMock();
109         synch.beforeCommit(false);
110         synchControl.setVoidCallable(1);
111         synch.beforeCompletion();
112         synchControl.setVoidCallable(1);
113         synch.afterCompletion(TransactionSynchronization.STATUS_COMMITTED);
114         synchControl.setVoidCallable(1);
115         synchControl.replay();
116 
117         JtaTransactionManager ptm = new JtaTransactionManager(ut);
118         TransactionTemplate tt = new TransactionTemplate(ptm);
119         ptm.setTransactionSynchronization(JtaTransactionManager.SYNCHRONIZATION_ON_ACTUAL_TRANSACTION);
120         assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
121         tt.execute(new TransactionCallbackWithoutResult() {
122             protected void doInTransactionWithoutResult(TransactionStatus status) {
123                 // something transactional
124                 assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
125                 TransactionSynchronizationManager.registerSynchronization(synch);
126             }
127         });
128         assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
129 
130         utControl.verify();
131         synchControl.verify();
132     }
133 
134     public void testJtaTransactionManagerWithCommitAndSynchronizationNever() throws Exception   {
135         MockControl utControl = MockControl.createControl(UserTransaction  .class);
136         UserTransaction   ut = (UserTransaction  ) utControl.getMock();
137         ut.getStatus();
138         utControl.setReturnValue(Status.STATUS_NO_TRANSACTION, 1);
139         ut.getStatus();
140         utControl.setReturnValue(Status.STATUS_ACTIVE, 1);
141         ut.begin();
142         utControl.setVoidCallable(1);
143         ut.commit();
144         utControl.setVoidCallable(1);
145         utControl.replay();
146 
147         JtaTransactionManager ptm = new JtaTransactionManager(ut);
148         TransactionTemplate tt = new TransactionTemplate(ptm);
149         ptm.setTransactionSynchronization(JtaTransactionManager.SYNCHRONIZATION_NEVER);
150         assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
151         tt.execute(new TransactionCallbackWithoutResult() {
152             protected void doInTransactionWithoutResult(TransactionStatus status) {
153                 assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
154             }
155         });
156         assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
157 
158         utControl.verify();
159     }
160 
161     public void testJtaTransactionManagerWithRollback() throws Exception   {
162         MockControl utControl = MockControl.createControl(UserTransaction  .class);
163         UserTransaction   ut = (UserTransaction  ) utControl.getMock();
164         ut.getStatus();
165         utControl.setReturnValue(Status.STATUS_NO_TRANSACTION, 1);
166         ut.setTransactionTimeout(10);
167         utControl.setVoidCallable(1);
168         ut.begin();
169         utControl.setVoidCallable(1);
170         ut.rollback();
171         utControl.setVoidCallable(1);
172         utControl.replay();
173 
174         MockControl synchControl = MockControl.createControl(TransactionSynchronization.class);
175         final TransactionSynchronization synch = (TransactionSynchronization) synchControl.getMock();
176         synch.beforeCompletion();
177         synchControl.setVoidCallable(1);
178         synch.afterCompletion(TransactionSynchronization.STATUS_ROLLED_BACK);
179         synchControl.setVoidCallable(1);
180         synchControl.replay();
181 
182         JtaTransactionManager ptm = new JtaTransactionManager(ut);
183         TransactionTemplate tt = new TransactionTemplate(ptm);
184         tt.setTimeout(10);
185         tt.setName("txName");
186 
187         assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
188         assertNull(TransactionSynchronizationManager.getCurrentTransactionName());
189         assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
190         tt.execute(new TransactionCallbackWithoutResult() {
191             protected void doInTransactionWithoutResult(TransactionStatus status) {
192                 assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
193                 TransactionSynchronizationManager.registerSynchronization(synch);
194                 assertEquals("txName", TransactionSynchronizationManager.getCurrentTransactionName());
195                 assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
196                 status.setRollbackOnly();
197             }
198         });
199         assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
200         assertNull(TransactionSynchronizationManager.getCurrentTransactionName());
201         assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
202 
203         utControl.verify();
204         synchControl.verify();
205     }
206 
207     public void testJtaTransactionManagerWithRollbackAndSynchronizationOnActual() throws Exception   {
208         MockControl utControl = MockControl.createControl(UserTransaction  .class);
209         UserTransaction   ut = (UserTransaction  ) utControl.getMock();
210         ut.getStatus();
211         utControl.setReturnValue(Status.STATUS_NO_TRANSACTION, 1);
212         ut.setTransactionTimeout(10);
213         utControl.setVoidCallable(1);
214         ut.begin();
215         utControl.setVoidCallable(1);
216         ut.rollback();
217         utControl.setVoidCallable(1);
218         utControl.replay();
219 
220         MockControl synchControl = MockControl.createControl(TransactionSynchronization.class);
221         final TransactionSynchronization synch = (TransactionSynchronization) synchControl.getMock();
222         synch.beforeCompletion();
223         synchControl.setVoidCallable(1);
224         synch.afterCompletion(TransactionSynchronization.STATUS_ROLLED_BACK);
225         synchControl.setVoidCallable(1);
226         synchControl.replay();
227 
228         JtaTransactionManager ptm = new JtaTransactionManager(ut);
229         TransactionTemplate tt = new TransactionTemplate(ptm);
230         ptm.setTransactionSynchronization(JtaTransactionManager.SYNCHRONIZATION_ON_ACTUAL_TRANSACTION);
231         tt.setTimeout(10);
232         assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
233         tt.execute(new TransactionCallbackWithoutResult() {
234             protected void doInTransactionWithoutResult(TransactionStatus status) {
235                 assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
236                 TransactionSynchronizationManager.registerSynchronization(synch);
237                 status.setRollbackOnly();
238             }
239         });
240         assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
241 
242         utControl.verify();
243         synchControl.verify();
244     }
245 
246     public void testJtaTransactionManagerWithRollbackAndSynchronizationNever() throws Exception   {
247         MockControl utControl = MockControl.createControl(UserTransaction  .class);
248         UserTransaction   ut = (UserTransaction  ) utControl.getMock();
249         ut.getStatus();
250         utControl.setReturnValue(Status.STATUS_NO_TRANSACTION, 1);
251         ut.setTransactionTimeout(10);
252         utControl.setVoidCallable(1);
253         ut.begin();
254         utControl.setVoidCallable(1);
255         ut.rollback();
256         utControl.setVoidCallable(1);
257         utControl.replay();
258 
259         JtaTransactionManager ptm = new JtaTransactionManager(ut);
260         TransactionTemplate tt = new TransactionTemplate(ptm);
261         ptm.setTransactionSynchronizationName("SYNCHRONIZATION_NEVER");
262         tt.setTimeout(10);
263         assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
264         tt.execute(new TransactionCallbackWithoutResult() {
265             protected void doInTransactionWithoutResult(TransactionStatus status) {
266                 assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
267                 status.setRollbackOnly();
268             }
269         });
270         assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
271 
272         utControl.verify();
273     }
274 
275     public void testJtaTransactionManagerWithExistingTransaction() throws Exception   {
276         MockControl utControl = MockControl.createControl(UserTransaction  .class);
277         UserTransaction   ut = (UserTransaction  ) utControl.getMock();
278         ut.getStatus();
279         utControl.setReturnValue(Status.STATUS_ACTIVE, 1);
280         ut.setRollbackOnly();
281         utControl.setVoidCallable(1);
282         utControl.replay();
283 
284         MockControl synchControl = MockControl.createControl(TransactionSynchronization.class);
285         final TransactionSynchronization synch = (TransactionSynchronization) synchControl.getMock();
286         synch.beforeCompletion();
287         synchControl.setVoidCallable(1);
288         synch.afterCompletion(TransactionSynchronization.STATUS_UNKNOWN);
289         synchControl.setVoidCallable(1);
290         synchControl.replay();
291 
292         JtaTransactionManager ptm = new JtaTransactionManager(ut);
293         TransactionTemplate tt = new TransactionTemplate(ptm);
294         assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
295         tt.execute(new TransactionCallbackWithoutResult() {
296             protected void doInTransactionWithoutResult(TransactionStatus status) {
297                 assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
298                 TransactionSynchronizationManager.registerSynchronization(synch);
299                 status.setRollbackOnly();
300             }
301         });
302         assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
303 
304         utControl.verify();
305         synchControl.verify();
306     }
307 
308     public void testJtaTransactionManagerWithExistingTransactionAndJtaSynchronization() throws Exception   {
309         MockControl utControl = MockControl.createControl(UserTransaction  .class);
310         UserTransaction   ut = (UserTransaction  ) utControl.getMock();
311         MockControl tmControl = MockControl.createControl(TransactionManager  .class);
312         TransactionManager   tm = (TransactionManager  ) tmControl.getMock();
313         MockJtaTransaction tx = new MockJtaTransaction();
314 
315         ut.getStatus();
316         utControl.setReturnValue(Status.STATUS_ACTIVE, 1);
317         ut.setRollbackOnly();
318         utControl.setVoidCallable(1);
319         tm.getTransaction();
320         tmControl.setReturnValue(tx, 1);
321 
322         utControl.replay();
323         tmControl.replay();
324 
325         MockControl synchControl = MockControl.createControl(TransactionSynchronization.class);
326         final TransactionSynchronization synch = (TransactionSynchronization) synchControl.getMock();
327         synch.beforeCompletion();
328         synchControl.setVoidCallable(1);
329         synch.afterCompletion(TransactionSynchronization.STATUS_ROLLED_BACK);
330         synchControl.setVoidCallable(1);
331         synchControl.replay();
332 
333         JtaTransactionManager ptm = new JtaTransactionManager(ut, tm);
334         TransactionTemplate tt = new TransactionTemplate(ptm);
335         assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
336         tt.execute(new TransactionCallbackWithoutResult() {
337             protected void doInTransactionWithoutResult(TransactionStatus status) {
338                 assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
339                 TransactionSynchronizationManager.registerSynchronization(synch);
340                 status.setRollbackOnly();
341             }
342         });
343         assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
344         assertNotNull(tx.getSynchronization());
345         tx.getSynchronization().beforeCompletion();
346         tx.getSynchronization().afterCompletion(Status.STATUS_ROLLEDBACK);
347 
348         utControl.verify();
349         tmControl.verify();
350         synchControl.verify();
351     }
352 
353     public void testJtaTransactionManagerWithExistingTransactionAndSynchronizationOnActual() throws Exception   {
354         MockControl utControl = MockControl.createControl(UserTransaction  .class);
355         UserTransaction   ut = (UserTransaction  ) utControl.getMock();
356         ut.getStatus();
357         utControl.setReturnValue(Status.STATUS_ACTIVE, 1);
358         ut.setRollbackOnly();
359         utControl.setVoidCallable(1);
360         utControl.replay();
361 
362         MockControl synchControl = MockControl.createControl(TransactionSynchronization.class);
363         final TransactionSynchronization synch = (TransactionSynchronization) synchControl.getMock();
364         synch.beforeCompletion();
365         synchControl.setVoidCallable(1);
366         synch.afterCompletion(TransactionSynchronization.STATUS_UNKNOWN);
367         synchControl.setVoidCallable(1);
368         synchControl.replay();
369 
370         JtaTransactionManager ptm = new JtaTransactionManager(ut);
371         TransactionTemplate tt = new TransactionTemplate(ptm);
372         ptm.setTransactionSynchronization(JtaTransactionManager.SYNCHRONIZATION_ON_ACTUAL_TRANSACTION);
373         assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
374         tt.execute(new TransactionCallbackWithoutResult() {
375             protected void doInTransactionWithoutResult(TransactionStatus status) {
376                 assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
377                 TransactionSynchronizationManager.registerSynchronization(synch);
378                 status.setRollbackOnly();
379             }
380         });
381         assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
382 
383         utControl.verify();
384         synchControl.verify();
385     }
386 
387     public void testJtaTransactionManagerWithExistingTransactionAndSynchronizationNever() throws Exception   {
388         MockControl utControl = MockControl.createControl(UserTransaction  .class);
389         UserTransaction   ut = (UserTransaction  ) utControl.getMock();
390         ut.getStatus();
391         utControl.setReturnValue(Status.STATUS_ACTIVE, 1);
392         ut.setRollbackOnly();
393         utControl.setVoidCallable(1);
394         utControl.replay();
395 
396         JtaTransactionManager ptm = new JtaTransactionManager(ut);
397         TransactionTemplate tt = new TransactionTemplate(ptm);
398         ptm.setTransactionSynchronization(JtaTransactionManager.SYNCHRONIZATION_NEVER);
399         assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
400         tt.execute(new TransactionCallbackWithoutResult() {
401             protected void doInTransactionWithoutResult(TransactionStatus status) {
402                 assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
403                 status.setRollbackOnly();
404             }
405         });
406         assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
407 
408         utControl.verify();
409     }
410 
411     public void testJtaTransactionManagerWithExistingAndPropagationSupports() throws Exception   {
412         MockControl utControl = MockControl.createControl(UserTransaction  .class);
413         UserTransaction   ut = (UserTransaction  ) utControl.getMock();
414         ut.getStatus();
415         utControl.setReturnValue(Status.STATUS_ACTIVE, 1);
416         ut.setRollbackOnly();
417         utControl.setVoidCallable(1);
418         utControl.replay();
419 
420         MockControl synchControl = MockControl.createControl(TransactionSynchronization.class);
421         final TransactionSynchronization synch = (TransactionSynchronization) synchControl.getMock();
422         synch.beforeCompletion();
423         synchControl.setVoidCallable(1);
424         synch.afterCompletion(TransactionSynchronization.STATUS_UNKNOWN);
425         synchControl.setVoidCallable(1);
426         synchControl.replay();
427 
428         JtaTransactionManager ptm = new JtaTransactionManager(ut);
429         TransactionTemplate tt = new TransactionTemplate(ptm);
430         tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);
431         assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
432         tt.execute(new TransactionCallbackWithoutResult() {
433             protected void doInTransactionWithoutResult(TransactionStatus status) {
434                 assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
435                 TransactionSynchronizationManager.registerSynchronization(synch);
436                 status.setRollbackOnly();
437             }
438         });
439         assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
440 
441         utControl.verify();
442         synchControl.verify();
443     }
444 
445     public void testJtaTransactionManagerWithPropagationSupports() throws Exception   {
446         MockControl utControl = MockControl.createControl(UserTransaction  .class);
447         UserTransaction   ut = (UserTransaction  ) utControl.getMock();
448         ut.getStatus();
449         utControl.setReturnValue(Status.STATUS_NO_TRANSACTION, 1);
450         utControl.replay();
451 
452         MockControl synchControl = MockControl.createControl(TransactionSynchronization.class);
453         final TransactionSynchronization synch = (TransactionSynchronization) synchControl.getMock();
454         synch.beforeCompletion();
455         synchControl.setVoidCallable(1);
456         synch.afterCompletion(TransactionSynchronization.STATUS_ROLLED_BACK);
457         synchControl.setVoidCallable(1);
458         synchControl.replay();
459 
460         JtaTransactionManager ptm = new JtaTransactionManager(ut);
461         TransactionTemplate tt = new TransactionTemplate(ptm);
462         tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);
463         assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
464         tt.execute(new TransactionCallbackWithoutResult() {
465             protected void doInTransactionWithoutResult(TransactionStatus status) {
466                 assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
467                 TransactionSynchronizationManager.registerSynchronization(synch);
468                 status.setRollbackOnly();
469             }
470         });
471         assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
472 
473         utControl.verify();
474         synchControl.verify();
475     }
476 
477     public void testJtaTransactionManagerWithPropagationSupportsAndSynchronizationOnActual() throws Exception   {
478         MockControl utControl = MockControl.createControl(UserTransaction  .class);
479         UserTransaction   ut = (UserTransaction  ) utControl.getMock();
480         ut.getStatus();
481         utControl.setReturnValue(Status.STATUS_NO_TRANSACTION, 1);
482         utControl.replay();
483 
484         JtaTransactionManager ptm = new JtaTransactionManager(ut);
485         TransactionTemplate tt = new TransactionTemplate(ptm);
486         ptm.setTransactionSynchronization(JtaTransactionManager.SYNCHRONIZATION_ON_ACTUAL_TRANSACTION);
487         tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);
488         assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
489         tt.execute(new TransactionCallbackWithoutResult() {
490             protected void doInTransactionWithoutResult(TransactionStatus status) {
491                 assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
492                 status.setRollbackOnly();
493             }
494         });
495         assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
496 
497         utControl.verify();
498     }
499 
500     public void testJtaTransactionManagerWithPropagationSupportsAndSynchronizationNever() throws Exception   {
501         MockControl utControl = MockControl.createControl(UserTransaction  .class);
502         UserTransaction   ut = (UserTransaction  ) utControl.getMock();
503         ut.getStatus();
504         utControl.setReturnValue(Status.STATUS_NO_TRANSACTION, 1);
505         utControl.replay();
506 
507         JtaTransactionManager ptm = new JtaTransactionManager(ut);
508         TransactionTemplate tt = new TransactionTemplate(ptm);
509         ptm.setTransactionSynchronization(JtaTransactionManager.SYNCHRONIZATION_NEVER);
510         tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);
511         assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
512         tt.execute(new TransactionCallbackWithoutResult() {
513             protected void doInTransactionWithoutResult(TransactionStatus status) {
514                 assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
515                 status.setRollbackOnly();
516             }
517         });
518         assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
519 
520         utControl.verify();
521     }
522 
523     public void testJtaTransactionManagerWithPropagationNotSupported() throws Exception   {
524         MockControl utControl = MockControl.createControl(UserTransaction  .class);
525         UserTransaction   ut = (UserTransaction  ) utControl.getMock();
526         MockControl tmControl = MockControl.createControl(TransactionManager  .class);
527         TransactionManager   tm = (TransactionManager  ) tmControl.getMock();
528         MockControl txControl = MockControl.createControl(Transaction  .class);
529         Transaction   tx = (Transaction  ) txControl.getMock();
530         ut.getStatus();
531         utControl.setReturnValue(Status.STATUS_ACTIVE, 1);
532         tm.suspend();
533         tmControl.setReturnValue(tx, 1);
534         tm.resume(tx);
535         tmControl.setVoidCallable(1);
536         utControl.replay();
537         tmControl.replay();
538 
539         JtaTransactionManager ptm = new JtaTransactionManager(ut, tm);
540         TransactionTemplate tt = new TransactionTemplate(ptm);
541         tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NOT_SUPPORTED);
542         assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
543         tt.execute(new TransactionCallbackWithoutResult() {
544             protected void doInTransactionWithoutResult(TransactionStatus status) {
545                 assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
546                 status.setRollbackOnly();
547             }
548         });
549         assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
550 
551         utControl.verify();
552         tmControl.verify();
553     }
554 
555     public void testJtaTransactionManagerWithPropagationRequiresNew() throws Exception   {
556         MockControl utControl = MockControl.createControl(UserTransaction  .class);
557         UserTransaction   ut = (UserTransaction  ) utControl.getMock();
558         MockControl tmControl = MockControl.createControl(TransactionManager  .class);
559         TransactionManager   tm = (TransactionManager  ) tmControl.getMock();
560         MockControl txControl = MockControl.createControl(Transaction  .class);
561         Transaction   tx = (Transaction  ) txControl.getMock();
562         ut.getStatus();
563         utControl.setReturnValue(Status.STATUS_NO_TRANSACTION, 1);
564         ut.begin();
565         utControl.setVoidCallable(1);
566         ut.getStatus();
567         utControl.setReturnValue(Status.STATUS_ACTIVE, 3);
568         tm.suspend();
569         tmControl.setReturnValue(tx, 1);
570         ut.begin();
571         utControl.setVoidCallable(1);
572         ut.commit();
573         utControl.setVoidCallable(1);
574         tm.resume(tx);
575         tmControl.setVoidCallable(1);
576         ut.commit();
577         utControl.setVoidCallable(1);
578         utControl.replay();
579         tmControl.replay();
580 
581         final JtaTransactionManager ptm = new JtaTransactionManager(ut, tm);
582         TransactionTemplate tt = new TransactionTemplate(ptm);
583         tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
584         tt.setName("txName");
585 
586         assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
587         tt.execute(new TransactionCallbackWithoutResult() {
588             protected void doInTransactionWithoutResult(TransactionStatus status) {
589                 assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
590                 assertEquals("txName", TransactionSynchronizationManager.getCurrentTransactionName());
591                 assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
592 
593                 TransactionTemplate tt2 = new TransactionTemplate(ptm);
594                 tt2.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
595                 tt2.setReadOnly(true);
596                 tt2.setName("txName2");
597                 tt2.execute(new TransactionCallbackWithoutResult() {
598                     protected void doInTransactionWithoutResult(TransactionStatus status) {
599                         assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
600                         assertEquals("txName2", TransactionSynchronizationManager.getCurrentTransactionName());
601                         assertTrue(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
602                     }
603                 });
604 
605                 assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
606                 assertEquals("txName", TransactionSynchronizationManager.getCurrentTransactionName());
607                 assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
608             }
609         });
610         assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
611 
612         utControl.verify();
613         tmControl.verify();
614     }
615 
616     public void testJtaTransactionManagerWithPropagationRequiresNewAndExisting() throws Exception   {
617         MockControl utControl = MockControl.createControl(UserTransaction  .class);
618         UserTransaction   ut = (UserTransaction  ) utControl.getMock();
619         MockControl tmControl = MockControl.createControl(TransactionManager  .class);
620         TransactionManager   tm = (TransactionManager  ) tmControl.getMock();
621         MockControl txControl = MockControl.createControl(Transaction  .class);
622         Transaction   tx = (Transaction  ) txControl.getMock();
623         ut.getStatus();
624         utControl.setReturnValue(Status.STATUS_ACTIVE, 2);
625         tm.suspend();
626         tmControl.setReturnValue(tx, 1);
627         ut.begin();
628         utControl.setVoidCallable(1);
629         ut.commit();
630         utControl.setVoidCallable(1);
631         tm.resume(tx);
632         tmControl.setVoidCallable(1);
633         utControl.replay();
634         tmControl.replay();
635 
636         JtaTransactionManager ptm = new JtaTransactionManager(ut, tm);
637         TransactionTemplate tt = new TransactionTemplate(ptm);
638         tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
639         assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
640         tt.execute(new TransactionCallbackWithoutResult() {
641             protected void doInTransactionWithoutResult(TransactionStatus status) {
642                 assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
643             }
644         });
645         assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
646 
647         utControl.verify();
648         tmControl.verify();
649     }
650 
651     public void testJtaTransactionManagerWithPropagationRequiresNewAndAdapter() throws Exception   {
652         MockControl tmControl = MockControl.createControl(TransactionManager  .class);
653         TransactionManager   tm = (TransactionManager  ) tmControl.getMock();
654         MockControl txControl = MockControl.createControl(Transaction  .class);
655         Transaction   tx = (Transaction  ) txControl.getMock();
656         tm.getStatus();
657         tmControl.setReturnValue(Status.STATUS_ACTIVE, 2);
658         tm.suspend();