Package org.apache.aries.transaction.test

Examples of org.apache.aries.transaction.test.TestBean

27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
public class NotSupportedTranStrategyTest extends AbstractIntegrationTest {
 
  @Test
  public void testNotSupported() throws Exception {
      TestBean nsBean = getOsgiService(TestBean.class, "(tranStrategy=NotSupported)", DEFAULT_TIMEOUT);
      TestBean rBean = getOsgiService(TestBean.class, "(tranStrategy=Required)", DEFAULT_TIMEOUT);
      UserTransaction tran = getOsgiService(UserTransaction.class);
     
      //Test with client transaction - the insert fails because the bean delegates to another
      //bean with a transaction strategy of Mandatory, and no transaction is available, i.e.
      //the user transaction is not propagated, and there is no container transaction.
      int initialRows = nsBean.countRows();
     
      tran.begin();
     
      try {
          nsBean.insertRow("testWithClientTran", 1, true);
          fail("IllegalStateException not thrown");
      } catch (IllegalStateException e) {
          e.printStackTrace();
      }
     
      tran.commit();
     
      int finalRows = nsBean.countRows();
      assertTrue("Initial rows: " + initialRows + ", Final rows: " + finalRows, finalRows - initialRows == 0);
     
      //Test with client transaction and with application exception - the user transaction is not
      //marked for rollback and can still be committed
      initialRows = nsBean.countRows();
     
      tran.begin();
      rBean.insertRow("testWithClientTranAndWithAppException", 1);
     
      try {
          nsBean.throwApplicationException();
      } catch (SQLException e) {
          e.printStackTrace();
      }
     
      tran.commit();
     
      finalRows = nsBean.countRows();
      assertTrue("Initial rows: " + initialRows + ", Final rows: " + finalRows, finalRows - initialRows == 1);
     
      //Test with client transaction and with runtime exception - the user transaction is not
      //marked for rollback and can still be committed
      initialRows = nsBean.countRows();
     
      tran.begin();
      rBean.insertRow("testWithClientTranAndWithRuntimeException", 1);
     
      try {
          nsBean.throwRuntimeException();
      } catch (RuntimeException e) {
          e.printStackTrace();
View Full Code Here
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
public class MandatoryTranStrategyTest extends AbstractIntegrationTest {
 
  @Test
  public void testMandatory() throws Exception {
      TestBean bean = getOsgiService(TestBean.class, "(tranStrategy=Mandatory)", DEFAULT_TIMEOUT);
      UserTransaction tran = getOsgiService(UserTransaction.class);
     
      //Test with client transaction - the user transaction is used to insert a row
      int initialRows = bean.countRows();
     
      tran.begin();
      bean.insertRow("testWithClientTran", 1);
      tran.commit();
     
      int finalRows = bean.countRows();
      assertTrue("Initial rows: " + initialRows + ", Final rows: " + finalRows, finalRows - initialRows == 1);
 
      //Test with client transaction and application exception - the user transaction is not rolled back
      initialRows = bean.countRows();
     
      tran.begin();
      bean.insertRow("testWithClientTranAndWithAppException", 1);
     
      try {
          bean.insertRow("testWithClientTranAndWithAppException", 2, new SQLException("Dummy exception"));
      } catch (SQLException e) {
          e.printStackTrace();
      }
     
      tran.commit();
     
      finalRows = bean.countRows();
      assertTrue("Initial rows: " + initialRows + ", Final rows: " + finalRows, finalRows - initialRows == 2);
     
      //Test with client transaction and runtime exception - the user transaction is rolled back
      initialRows = bean.countRows();
     
      tran.begin();
      bean.insertRow("testWithClientTranAndWithRuntimeException", 1);
     
      try {
          bean.insertRow("testWithClientTranAndWithRuntimeException", 2, new RuntimeException("Dummy exception"));
      } catch (RuntimeException e) {
          e.printStackTrace();
      }
     
      try {
          tran.commit();
          fail("RollbackException not thrown");
      } catch (RollbackException e) {
          e.printStackTrace();
      }
     
      finalRows = bean.countRows();
      assertTrue("Initial rows: " + initialRows + ", Final rows: " + finalRows, finalRows - initialRows == 0);
     
      //Test without client transaction - an exception is thrown because a transaction is mandatory
      try {
          bean.insertRow("testWithoutClientTran", 1);
          fail("IllegalStateException not thrown");
      } catch (IllegalStateException e) {
          e.printStackTrace();
      }
  }
View Full Code Here
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
public class SupportsTranStrategyTest extends AbstractIntegrationTest {
 
  @Test
  public void testSupports() throws Exception {
      TestBean bean = getOsgiService(TestBean.class, "(tranStrategy=Supports)", DEFAULT_TIMEOUT);
      UserTransaction tran = getOsgiService(UserTransaction.class);
     
      //Test with client transaction - the insert succeeds because the bean delegates to
      //another bean with a transaction strategy of Mandatory, and the user transaction
      //is delegated
      int initialRows = bean.countRows();
     
      tran.begin();
      bean.insertRow("testWithClientTran", 1, true);
      tran.commit();
     
      int finalRows = bean.countRows();
      assertTrue("Initial rows: " + initialRows + ", Final rows: " + finalRows, finalRows - initialRows == 1);
     
      //Test with client transaction and application exception - the user transaction is not rolled back
      initialRows = bean.countRows();
     
      tran.begin();
      bean.insertRow("testWithClientTranAndWithAppException", 1);
     
      try {
          bean.insertRow("testWithClientTranAndWithAppException", 2, new SQLException());
      } catch (SQLException e) {
          // TODO Auto-generated catch block
          e.printStackTrace();
      }
     
      tran.commit();
     
      finalRows = bean.countRows();
      assertTrue("Initial rows: " + initialRows + ", Final rows: " + finalRows, finalRows - initialRows == 2);
     
      //Test with client transaction and runtime exception - the user transaction is rolled back
      initialRows = bean.countRows();
     
      tran.begin();
      bean.insertRow("testWithClientTranAndWithRuntimeException", 1);
     
      try {
          bean.insertRow("testWithClientTranAndWithRuntimeException", 2, new RuntimeException());
      } catch (RuntimeException e) {
          e.printStackTrace();
      }
     
      try {
          tran.commit();
          fail("RollbackException not thrown");
      } catch (RollbackException e) {
          e.printStackTrace();
      }
     
      finalRows = bean.countRows();
      assertTrue("Initial rows: " + initialRows + ", Final rows: " + finalRows, finalRows - initialRows == 0);
     
      //Test without client transaction - the insert fails because the bean delegates to
      //another bean with a transaction strategy of Mandatory, and no transaction is available
      initialRows = bean.countRows();
     
      try {
          bean.insertRow("testWithoutClientTran", 1, true);
          fail("Exception not thrown");
      } catch (Exception e) {
          e.printStackTrace();
      }
     
      finalRows = bean.countRows();
      assertTrue("Initial rows: " + initialRows + ", Final rows: " + finalRows, finalRows - initialRows == 0);
  }
View Full Code Here
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
public class InvalidTranStrategyTest extends AbstractIntegrationTest {
 
  @Test
  public void testInvalid() throws Exception {
      TestBean bean = getOsgiService(TestBean.class, "(tranStrategy=Invalid)", DEFAULT_TIMEOUT);
     
      //Test without client transaction - an exception is thrown because the bean is not
      //configured correctly, i.e. multiple transaction elements match to the same method
      //name.
      try {
          bean.insertRow("testWithoutClientTran", 1);
          fail("IllegalStateException not thrown");
      } catch (IllegalStateException e) {
          e.printStackTrace();
      }
  }
View Full Code Here
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
public class MandatoryTranAttributeTest extends AbstractIntegrationTest {
 
  @Test
  public void testMandatory() throws Exception {
      TestBean bean = context().getService(TestBean.class, "(tranAttribute=Mandatory)");
      UserTransaction tran = context().getService(UserTransaction.class);
     
      //Test with client transaction - the user transaction is used to insert a row
      int initialRows = bean.countRows();
     
      tran.begin();
      bean.insertRow("testWithClientTran", 1);
      tran.commit();
     
      int finalRows = bean.countRows();
      assertTrue("Initial rows: " + initialRows + ", Final rows: " + finalRows, finalRows - initialRows == 1);
 
      //Test with client transaction and application exception - the user transaction is not rolled back
      initialRows = bean.countRows();
     
      tran.begin();
      bean.insertRow("testWithClientTranAndWithAppException", 1);
     
      try {
          bean.insertRow("testWithClientTranAndWithAppException", 2, new SQLException("Dummy exception"));
      } catch (SQLException e) {
          e.printStackTrace();
      }
     
      tran.commit();
     
      finalRows = bean.countRows();
      assertTrue("Initial rows: " + initialRows + ", Final rows: " + finalRows, finalRows - initialRows == 2);
     
      //Test with client transaction and runtime exception - the user transaction is rolled back
      initialRows = bean.countRows();
     
      tran.begin();
      bean.insertRow("testWithClientTranAndWithRuntimeException", 1);
     
      try {
          bean.insertRow("testWithClientTranAndWithRuntimeException", 2, new RuntimeException("Dummy exception"));
      } catch (RuntimeException e) {
          e.printStackTrace();
      }
     
      try {
          tran.commit();
          fail("RollbackException not thrown");
      } catch (RollbackException e) {
          e.printStackTrace();
      }
     
      finalRows = bean.countRows();
      assertTrue("Initial rows: " + initialRows + ", Final rows: " + finalRows, finalRows - initialRows == 0);
     
      //Test without client transaction - an exception is thrown because a transaction is mandatory
      try {
          bean.insertRow("testWithoutClientTran", 1);
          fail("IllegalStateException not thrown");
      } catch (IllegalStateException e) {
          e.printStackTrace();
      }
  }
View Full Code Here
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
public class NotSupportedTranAttributeTest extends AbstractIntegrationTest {
 
  @Test
  public void testNotSupported() throws Exception {
      TestBean nsBean = context().getService(TestBean.class, "(tranAttribute=NotSupported)");
      TestBean rBean = context().getService(TestBean.class, "(tranAttribute=Required)");
      UserTransaction tran = context().getService(UserTransaction.class);
     
      //Test with client transaction - the insert fails because the bean delegates to another
      //bean with a transaction strategy of Mandatory, and no transaction is available, i.e.
      //the user transaction is not propagated, and there is no container transaction.
      int initialRows = nsBean.countRows();
     
      tran.begin();
     
      try {
          nsBean.insertRow("testWithClientTran", 1, true);
          fail("IllegalStateException not thrown");
      } catch (IllegalStateException e) {
          e.printStackTrace();
      }
     
      tran.commit();
     
      int finalRows = nsBean.countRows();
      assertTrue("Initial rows: " + initialRows + ", Final rows: " + finalRows, finalRows - initialRows == 0);
     
      //Test with client transaction and with application exception - the user transaction is not
      //marked for rollback and can still be committed
      initialRows = nsBean.countRows();
     
      tran.begin();
      rBean.insertRow("testWithClientTranAndWithAppException", 1);
     
      try {
          nsBean.throwApplicationException();
      } catch (SQLException e) {
          e.printStackTrace();
      }
     
      tran.commit();
     
      finalRows = nsBean.countRows();
      assertTrue("Initial rows: " + initialRows + ", Final rows: " + finalRows, finalRows - initialRows == 1);
     
      //Test with client transaction and with runtime exception - the user transaction is not
      //marked for rollback and can still be committed
      initialRows = nsBean.countRows();
     
      tran.begin();
      rBean.insertRow("testWithClientTranAndWithRuntimeException", 1);
     
      try {
          nsBean.throwRuntimeException();
      } catch (RuntimeException e) {
          e.printStackTrace();
View Full Code Here
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
public class RequiredTranAttributeTest extends AbstractIntegrationTest {
 
  @Test
  public void testRequired() throws Exception {
      TestBean bean = context().getService(TestBean.class, "(tranAttribute=Required)");
      UserTransaction tran = context().getService(UserTransaction.class);
     
      //Test with client transaction - the user transaction is used to insert a row
      int initialRows = bean.countRows();
     
      tran.begin();
      bean.insertRow("testWithClientTran", 1);
      tran.commit();
     
      int finalRows = bean.countRows();
      assertTrue("Initial rows: " + initialRows + ", Final rows: " + finalRows, finalRows - initialRows == 1);
     
      //Test with client transaction and application exception - the user transaction is not rolled back
      initialRows = bean.countRows();
     
      tran.begin();
      bean.insertRow("testWithClientTranAndWithAppException", 1);
     
      try {
          bean.insertRow("testWithClientTranAndWithAppException", 2, new SQLException());
      } catch (SQLException e) {
          e.printStackTrace();
      }
     
      tran.commit();
     
      finalRows = bean.countRows();
      assertTrue("Initial rows: " + initialRows + ", Final rows: " + finalRows, finalRows - initialRows == 2);
      
      //Test with client transaction and runtime exception - the user transaction is rolled back
      initialRows = bean.countRows();
     
      tran.begin();
      bean.insertRow("testWithClientTranAndWithRuntimeException", 1);
     
      try {
          bean.insertRow("testWithClientTranAndWithRuntimeException", 2, new RuntimeException());
      } catch (RuntimeException e) {
          e.printStackTrace();
      }
     
      try {
          tran.commit();
          fail("RollbackException not thrown");
      } catch (RollbackException e) {
          e.printStackTrace();
      }
     
      finalRows = bean.countRows();
      assertTrue("Initial rows: " + initialRows + ", Final rows: " + finalRows, finalRows - initialRows == 0);
     
      //Test without client exception - a container transaction is used to insert the row
      initialRows = bean.countRows();
     
      bean.insertRow("testWithoutClientTran", 1);
     
      finalRows = bean.countRows();
      assertTrue("Initial rows: " + initialRows + ", Final rows: " + finalRows, finalRows - initialRows == 1);
     
      //Test without client exception and with application exception - the container transaction is not rolled back
      initialRows = bean.countRows();
     
      try {
          bean.insertRow("testWithoutClientTranAndWithAppException", 1, new SQLException("Dummy exception"));
      } catch (Exception e) {
          e.printStackTrace();
      }
     
      finalRows = bean.countRows();
      assertTrue("Initial rows: " + initialRows + ", Final rows: " + finalRows, finalRows - initialRows == 1);
     
      //Test without client transaction and with runtime exception - the container transaction is rolled back
      initialRows = bean.countRows();
     
      try {
          bean.insertRow("testWithoutClientTranAndWithRuntimeException", 1, new RuntimeException("Dummy exception"));
      } catch (Exception e) {
          e.printStackTrace();
      }
     
      finalRows = bean.countRows();
      assertTrue("Initial rows: " + initialRows + ", Final rows: " + finalRows, finalRows - initialRows == 0);
  }
View Full Code Here
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
public class NeverTranAttributeTest extends AbstractIntegrationTest {
 
  @Test
  public void testNever() throws Exception {
      TestBean bean = context().getService(TestBean.class, "(tranAttribute=Never)");
      UserTransaction tran = context().getService(UserTransaction.class);
     
      //Test with client transaction - an exception is thrown because transactions are not allowed
      int initialRows = bean.countRows();
     
      tran.begin();
     
      try {
          bean.insertRow("testWithClientTran", 1);
          fail("IllegalStateException not thrown");
      } catch (IllegalStateException e) {
          e.printStackTrace();
      }
     
      tran.commit();
     
      int finalRows = bean.countRows();
      assertTrue("Initial rows: " + initialRows + ", Final rows: " + finalRows, finalRows - initialRows == 0);
     
      //Test without client transaction - the insert fails because the bean delegates to another
      //bean with a transaction strategy of Mandatory, and no transaction is available
      initialRows = bean.countRows();

      try {
          bean.insertRow("testWithoutClientTran", 1, true);
          fail("IllegalStateException not thrown");
      } catch (IllegalStateException e) {
          e.printStackTrace();
      }
     
      finalRows = bean.countRows();
      assertTrue("Initial rows: " + initialRows + ", Final rows: " + finalRows, finalRows - initialRows == 0);
  }
View Full Code Here
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
public class RequiresNewTranAttributeTest extends AbstractIntegrationTest {
 
  @Test
  public void testRequiresNew() throws Exception {
      TestBean rnBean = context().getService(TestBean.class, "(tranAttribute=RequiresNew)");
      TestBean rBean = context().getService(TestBean.class, "(tranAttribute=Required)");
      UserTransaction tran = context().getService(UserTransaction.class);
     
      //Test with client transaction - a container transaction is used to insert the row
      int initialRows = rnBean.countRows();
     
      tran.begin();
      rnBean.insertRow("testWithClientTran", 1);
      tran.rollback();
     
      int finalRows = rnBean.countRows();
      assertTrue("Initial rows: " + initialRows + ", Final rows: " + finalRows, finalRows - initialRows == 1);
     
      //Test with client transaction and application exception - the container transaction is committed,
      //the user transaction is not affected.
      initialRows = rnBean.countRows();
     
      tran.begin();
      rBean.insertRow("testWithClientTranAndWithAppException", 1);
     
      try {
          rnBean.insertRow("testWithClientTranAndWithAppException", 2, new SQLException("Dummy exception"));
      } catch (SQLException e) {
          e.printStackTrace();
      }
     
      tran.commit();
     
      finalRows = rnBean.countRows();
      assertTrue("Initial rows: " + initialRows + ", Final rows: " + finalRows, finalRows - initialRows == 2);
     
      //Test with client transaction and runtime exception - the container transaction is rolled back,
      //the user transaction is not affected
      initialRows = rnBean.countRows();
     
      tran.begin();
      rBean.insertRow("testWithClientTranAndWithRuntimeException", 1);
     
      try {
          rnBean.insertRow("testWithClientTranAndWithRuntimeException", 2, new RuntimeException("Dummy exception"));
      } catch (RuntimeException e) {
          e.printStackTrace();
View Full Code Here
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
public class SupportsTranAttributeTest extends AbstractIntegrationTest {
 
  @Test
  public void testSupports() throws Exception {
      TestBean bean = context().getService(TestBean.class, "(tranAttribute=Supports)");
      UserTransaction tran = context().getService(UserTransaction.class);
     
      //Test with client transaction - the insert succeeds because the bean delegates to
      //another bean with a transaction strategy of Mandatory, and the user transaction
      //is delegated
      int initialRows = bean.countRows();
     
      tran.begin();
      bean.insertRow("testWithClientTran", 1, true);
      tran.commit();
     
      int finalRows = bean.countRows();
      assertTrue("Initial rows: " + initialRows + ", Final rows: " + finalRows, finalRows - initialRows == 1);
     
      //Test with client transaction and application exception - the user transaction is not rolled back
      initialRows = bean.countRows();
     
      tran.begin();
      bean.insertRow("testWithClientTranAndWithAppException", 1);
     
      try {
          bean.insertRow("testWithClientTranAndWithAppException", 2, new SQLException());
      } catch (SQLException e) {
          // TODO Auto-generated catch block
          e.printStackTrace();
      }
     
      tran.commit();
     
      finalRows = bean.countRows();
      assertTrue("Initial rows: " + initialRows + ", Final rows: " + finalRows, finalRows - initialRows == 2);
     
      //Test with client transaction and runtime exception - the user transaction is rolled back
      initialRows = bean.countRows();
     
      tran.begin();
      bean.insertRow("testWithClientTranAndWithRuntimeException", 1);
     
      try {
          bean.insertRow("testWithClientTranAndWithRuntimeException", 2, new RuntimeException());
      } catch (RuntimeException e) {
          e.printStackTrace();
      }
     
      try {
          tran.commit();
          fail("RollbackException not thrown");
      } catch (RollbackException e) {
          e.printStackTrace();
      }
     
      finalRows = bean.countRows();
      assertTrue("Initial rows: " + initialRows + ", Final rows: " + finalRows, finalRows - initialRows == 0);
     
      //Test without client transaction - the insert fails because the bean delegates to
      //another bean with a transaction strategy of Mandatory, and no transaction is available
      initialRows = bean.countRows();
     
      try {
          bean.insertRow("testWithoutClientTran", 1, true);
          fail("Exception not thrown");
      } catch (Exception e) {
          e.printStackTrace();
      }
     
      finalRows = bean.countRows();
      assertTrue("Initial rows: " + initialRows + ", Final rows: " + finalRows, finalRows - initialRows == 0);
  }
View Full Code Here
TOP

Related Classes of org.apache.aries.transaction.test.TestBean

  • org.apache.aries.transaction.itests.InvalidTranAttributeTest
  • org.apache.aries.transaction.itests.InvalidTranStrategyTest
  • org.apache.aries.transaction.itests.MandatoryTranAttributeTest
  • org.apache.aries.transaction.itests.MandatoryTranStrategyTest
  • org.apache.aries.transaction.itests.NeverTranAttributeTest
  • org.apache.aries.transaction.itests.NeverTranStrategyTest
  • org.apache.aries.transaction.itests.NotSupportedTranAttributeTest
  • org.apache.aries.transaction.itests.NotSupportedTranStrategyTest
  • org.apache.aries.transaction.itests.RequiredTranAttributeTest
  • org.apache.aries.transaction.itests.RequiredTranStrategyTest
    • Copyright © 2018 www.massapicom. All rights reserved.
    All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.