wamblee.org Git - utils/blob - test/enterprise/src/test/java/org/wamblee/test/transactions/SimpleTransactionManagerTest.java

   1 /*
   2  * Copyright 2005-2010 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 package org.wamblee.test.transactions;
  17
  18 import static junit.framework.Assert.*;
  19 import static org.mockito.Matchers.*;
  20 import static org.mockito.Mockito.*;
  21
  22 import java.util.ArrayList;
  23 import java.util.Arrays;
  24 import java.util.List;
  25
  26 import javax.transaction.SystemException;
  27 import javax.transaction.UserTransaction;
  28
  29 import org.junit.After;
  30 import org.junit.Before;
  31 import org.junit.Test;
  32 import org.mockito.invocation.InvocationOnMock;
  33 import org.mockito.stubbing.Answer;
  34 import org.wamblee.general.ValueHolder;
  35
  36 public class SimpleTransactionManagerTest {
  37
  38     private List<UserTransactionCallback> callbacks;
  39     private UserTransactionFactory factory;
  40     private SimpleTransactionManager manager;
  41
  42     @Before
  43     public void setUp() {
  44         callbacks = new ArrayList<UserTransactionCallback>();
  45         factory = mock(UserTransactionFactory.class);
  46         when(
  47             factory.create(any(UserTransactionCallback.class), any(List.class)))
  48             .thenAnswer(new Answer() {
  49                 @Override
  50                 public Object answer(InvocationOnMock aInvocation)
  51                     throws Throwable {
  52                     callbacks.add((UserTransactionCallback) aInvocation
  53                         .getArguments()[0]);
  54                     return mock(UserTransaction.class);
  55                 }
  56             });
  57         manager = new SimpleTransactionManager(factory);
  58     }
  59
  60     @After
  61     public void tearDown() {
  62         // Empty.
  63     }
  64
  65     @Test
  66     public void testTransactionsAreThreadSpecific() throws Exception {
  67         manager.getTransaction().getStatus();
  68         UserTransaction transaction = manager.getThreadSpecificTransaction();
  69         assertNotNull(transaction);
  70         assertSame(transaction, manager.getThreadSpecificTransaction());
  71         final ValueHolder<UserTransaction> transaction2 = new ValueHolder<UserTransaction>();
  72         Thread t = new Thread(new Runnable() {
  73             @Override
  74             public void run() {
  75                 try {
  76                     manager.getTransaction().getStatus();
  77                     transaction2.setValue(manager
  78                         .getThreadSpecificTransaction());
  79                 } catch (SystemException e) {
  80                     fail("exception ");
  81                 }
  82             }
  83         });
  84         t.start();
  85         t.join();
  86         assertNotNull(transaction);
  87         assertNotNull(transaction2.getValue());
  88         assertTrue(transaction != transaction2.getValue());
  89     }
  90
  91     @Test
  92     public void testTransactionLifeCycle() throws Exception {
  93         manager.getTransaction().getStatus();
  94         UserTransaction transaction = manager.getThreadSpecificTransaction();
  95
  96         assertNotNull(transaction);
  97         assertEquals(1, callbacks.size());
  98         callbacks.get(0).transactionFinished();
  99         manager.getTransaction().getStatus();
 100         UserTransaction transaction2 = manager.getThreadSpecificTransaction();
 101         assertNotNull(transaction2);
 102         assert (transaction != transaction2);
 103     }
 104
 105     @Test
 106     public void testVerifyResourcesArePassedToFactory() throws Exception {
 107
 108         final ValueHolder<Object[]> actual = new ValueHolder<Object[]>();
 109         when(factory.create(any(UserTransactionCallback.class), (List) any()))
 110             .thenAnswer(new Answer() {
 111                 @Override
 112                 public Object answer(InvocationOnMock aInvocation)
 113                     throws Throwable {
 114                     Object[] value = ((List) aInvocation.getArguments()[1])
 115                         .toArray();
 116                     actual.setValue(value);
 117                     return mock(UserTransaction.class);
 118                 }
 119             });
 120
 121         TransactionResource resource1 = mock(TransactionResource.class);
 122         TransactionResource resource2 = mock(TransactionResource.class);
 123         manager.addResource(resource1);
 124         manager.addResource(resource2);
 125
 126         manager.getTransaction().getStatus();
 127         Object[] expected = new Object[] { resource1, resource2 };
 128         assertTrue(Arrays.equals(expected, actual.getValue()));
 129     }
 130
 131     @Test
 132     public void testTwoTransactions() throws Exception {
 133         UserTransaction transaction = manager.getTransaction();
 134         transaction.begin();
 135         transaction.commit();
 136
 137         transaction.begin();
 138         transaction.commit();
 139     }
 140
 141 }