wamblee.org Git - utils/blob - test/enterprise/src/test/java/org/wamblee/test/transactions/SimpleUserTransactionTest.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 javax.transaction.HeuristicMixedException;
  23 import javax.transaction.NotSupportedException;
  24 import javax.transaction.RollbackException;
  25 import javax.transaction.Status;
  26
  27 import org.junit.Before;
  28 import org.junit.Test;
  29
  30 public class SimpleUserTransactionTest {
  31
  32     private UserTransactionCallback callback;
  33     private TransactionResource resource1;
  34     private TransactionResource resource2;
  35     private Object tx1;
  36     private Object tx2;
  37
  38     private SimpleUserTransaction tx;
  39
  40     @Before
  41     public void setUp() {
  42         callback = mock(UserTransactionCallback.class);
  43         resource1 = mock(TransactionResource.class);
  44         resource2 = mock(TransactionResource.class);
  45         tx1 = mock(Object.class);
  46         tx2 = mock(Object.class);
  47         when(resource1.begin()).thenReturn(tx1);
  48         when(resource2.begin()).thenReturn(tx2);
  49     }
  50
  51     @Test
  52     public void testTransactionBegin() throws Exception {
  53         tx = new SimpleUserTransaction(callback, resource1);
  54         assertEquals(Status.STATUS_NO_TRANSACTION, tx.getStatus());
  55         tx.begin();
  56         verify(resource1).begin();
  57         verifyNoMoreInteractions(resource1);
  58         reset(resource1);
  59         assertEquals(Status.STATUS_ACTIVE, tx.getStatus());
  60
  61     }
  62
  63     @Test
  64     public void testTransactionCommit() throws Exception {
  65         testTransactionBegin();
  66         tx.commit();
  67         verify(resource1).commit(same(tx1));
  68         verifyNoMoreInteractions(resource1);
  69         verify(callback).transactionFinished();
  70         assertEquals(Status.STATUS_NO_TRANSACTION, tx.getStatus());
  71     }
  72
  73     @Test
  74     public void testTransactionRollback() throws Exception {
  75         testTransactionBegin();
  76         tx.rollback();
  77         verify(resource1).rollback(same(tx1));
  78         verifyNoMoreInteractions(resource1);
  79         assertEquals(Status.STATUS_NO_TRANSACTION, tx.getStatus());
  80         verify(callback).transactionFinished();
  81     }
  82
  83     @Test
  84     public void testTransactionStatusSetrollbackOnly() throws Exception {
  85         testTransactionBegin();
  86         tx.setRollbackOnly();
  87         assertEquals(Status.STATUS_MARKED_ROLLBACK, tx.getStatus());
  88         verifyNoMoreInteractions(callback);
  89     }
  90
  91     @Test
  92     public void testTransactionRollbackWhenSetRollbackOnly() throws Exception {
  93         testTransactionStatusSetrollbackOnly();
  94         tx.rollback();
  95         assertEquals(Status.STATUS_NO_TRANSACTION, tx.getStatus());
  96         verify(resource1).rollback(same(tx1));
  97         verifyNoMoreInteractions(resource1);
  98     }
  99
 100     @Test
 101     public void testTransactionCommitWhenSetRollbackOnly() throws Exception {
 102         testTransactionStatusSetrollbackOnly();
 103         try {
 104             tx.commit();
 105             fail();
 106         } catch (RollbackException e) {
 107             assertEquals(Status.STATUS_NO_TRANSACTION, tx.getStatus());
 108         }
 109     }
 110
 111     @Test
 112     public void testMultipleResources() throws Exception {
 113         tx = new SimpleUserTransaction(callback, resource1, resource2);
 114         tx.begin();
 115         verify(resource1).begin();
 116         verify(resource2).begin();
 117         verifyNoMoreInteractions(resource1, resource2);
 118         reset(resource1, resource2);
 119         assertEquals(Status.STATUS_ACTIVE, tx.getStatus());
 120         tx.commit();
 121         verify(resource1).commit(same(tx1));
 122         verify(resource2).commit(same(tx2));
 123
 124         verifyNoMoreInteractions(resource1, resource2);
 125         verify(callback).transactionFinished();
 126     }
 127
 128     @Test
 129     public void testSetTransactionTimeoutIgnored() throws Exception {
 130         testTransactionBegin();
 131         tx.setTransactionTimeout(1000);
 132     }
 133
 134     @Test(expected = NotSupportedException.class)
 135     public void testNestedTransaction() throws Exception {
 136         testTransactionBegin();
 137         tx.begin();
 138     }
 139
 140     @Test(expected = IllegalStateException.class)
 141     public void testCommitWhileNotInATransaction() throws Exception {
 142         tx = new SimpleUserTransaction(callback, resource1);
 143         tx.commit();
 144     }
 145
 146     @Test
 147     public void testCommitFailsOnSomeResources() throws Exception {
 148         tx = new SimpleUserTransaction(callback, resource1, resource2);
 149         tx.begin();
 150         doThrow(new RuntimeException("failed")).when(resource1).commit(any());
 151         try {
 152             tx.commit();
 153             fail();
 154         } catch (HeuristicMixedException e) {
 155             verify(resource2).rollback(same(tx2));
 156         }
 157     }
 158
 159     @Test(expected = IllegalStateException.class)
 160     public void testRollbackWhileNotInATransaction() throws Exception {
 161         tx = new SimpleUserTransaction(callback, resource1);
 162         tx.rollback();
 163     }
 164
 165     @Test(expected = IllegalStateException.class)
 166     public void testSetrollbackonlyWhileNotInATransaction() throws Exception {
 167         tx = new SimpleUserTransaction(callback, resource1);
 168         tx.setRollbackOnly();
 169     }
 170 }