GitHub-Spring
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Remove test prefixes and avoid warnings in JDBC and TX tests

pull/35641/head
Sam Brannen 2 months ago
parent
d216236aac
commit
c2ef11e1fc
6 changed files with 844 additions and 1182 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 64
      spring-jdbc/src/test/java/org/springframework/jdbc/datasource/DataSourceJtaTransactionTests.java
  2. 1221
      spring-jdbc/src/test/java/org/springframework/jdbc/datasource/DataSourceTransactionManagerTests.java
  3. 83
      spring-jdbc/src/test/java/org/springframework/jdbc/support/JdbcTransactionManagerTests.java
  4. 48
      spring-tx/src/test/java/org/springframework/transaction/JndiJtaTransactionManagerTests.java
  5. 605
      spring-tx/src/test/java/org/springframework/transaction/JtaTransactionManagerTests.java
  6. 5
      spring-tx/src/test/java/org/springframework/transaction/support/TransactionSupportTests.java

64
spring-jdbc/src/test/java/org/springframework/jdbc/datasource/DataSourceJtaTransactionTests.java
Unescape View File

@ -90,15 +90,16 @@ class DataSourceJtaTransactionTests { @@ -90,15 +90,16 @@ class DataSourceJtaTransactionTests {
@Test
void testJtaTransactionCommit() throws Exception {
void jtaTransactionCommit() throws Exception {
doTestJtaTransaction(false);
}
@Test
void testJtaTransactionRollback() throws Exception {
void jtaTransactionRollback() throws Exception {
doTestJtaTransaction(true);
}
@SuppressWarnings("deprecation")
private void doTestJtaTransaction(final boolean rollback) throws Exception {
if (rollback) {
given(userTransaction.getStatus()).willReturn(
@ -145,55 +146,56 @@ class DataSourceJtaTransactionTests { @@ -145,55 +146,56 @@ class DataSourceJtaTransactionTests {
}
@Test
void testJtaTransactionCommitWithPropagationRequiresNew() throws Exception {
void jtaTransactionCommitWithPropagationRequiresNew() throws Exception {
doTestJtaTransactionWithPropagationRequiresNew(false, false, false, false);
}
@Test
void testJtaTransactionCommitWithPropagationRequiresNewWithAccessAfterResume() throws Exception {
void jtaTransactionCommitWithPropagationRequiresNewWithAccessAfterResume() throws Exception {
doTestJtaTransactionWithPropagationRequiresNew(false, false, true, false);
}
@Test
void testJtaTransactionCommitWithPropagationRequiresNewWithOpenOuterConnection() throws Exception {
void jtaTransactionCommitWithPropagationRequiresNewWithOpenOuterConnection() throws Exception {
doTestJtaTransactionWithPropagationRequiresNew(false, true, false, false);
}
@Test
void testJtaTransactionCommitWithPropagationRequiresNewWithOpenOuterConnectionAccessed() throws Exception {
void jtaTransactionCommitWithPropagationRequiresNewWithOpenOuterConnectionAccessed() throws Exception {
doTestJtaTransactionWithPropagationRequiresNew(false, true, true, false);
}
@Test
void testJtaTransactionCommitWithPropagationRequiresNewWithTransactionAwareDataSource() throws Exception {
void jtaTransactionCommitWithPropagationRequiresNewWithTransactionAwareDataSource() throws Exception {
doTestJtaTransactionWithPropagationRequiresNew(false, false, true, true);
}
@Test
void testJtaTransactionRollbackWithPropagationRequiresNew() throws Exception {
void jtaTransactionRollbackWithPropagationRequiresNew() throws Exception {
doTestJtaTransactionWithPropagationRequiresNew(true, false, false, false);
}
@Test
void testJtaTransactionRollbackWithPropagationRequiresNewWithAccessAfterResume() throws Exception {
void jtaTransactionRollbackWithPropagationRequiresNewWithAccessAfterResume() throws Exception {
doTestJtaTransactionWithPropagationRequiresNew(true, false, true, false);
}
@Test
void testJtaTransactionRollbackWithPropagationRequiresNewWithOpenOuterConnection() throws Exception {
void jtaTransactionRollbackWithPropagationRequiresNewWithOpenOuterConnection() throws Exception {
doTestJtaTransactionWithPropagationRequiresNew(true, true, false, false);
}
@Test
void testJtaTransactionRollbackWithPropagationRequiresNewWithOpenOuterConnectionAccessed() throws Exception {
void jtaTransactionRollbackWithPropagationRequiresNewWithOpenOuterConnectionAccessed() throws Exception {
doTestJtaTransactionWithPropagationRequiresNew(true, true, true, false);
}
@Test
void testJtaTransactionRollbackWithPropagationRequiresNewWithTransactionAwareDataSource() throws Exception {
void jtaTransactionRollbackWithPropagationRequiresNewWithTransactionAwareDataSource() throws Exception {
doTestJtaTransactionWithPropagationRequiresNew(true, false, true, true);
}
@SuppressWarnings("deprecation")
private void doTestJtaTransactionWithPropagationRequiresNew(
final boolean rollback, final boolean openOuterConnection, final boolean accessAfterResume,
final boolean useTransactionAwareDataSource) throws Exception {
@ -316,25 +318,26 @@ class DataSourceJtaTransactionTests { @@ -316,25 +318,26 @@ class DataSourceJtaTransactionTests {
}
@Test
void testJtaTransactionCommitWithPropagationRequiredWithinSupports() throws Exception {
void jtaTransactionCommitWithPropagationRequiredWithinSupports() throws Exception {
doTestJtaTransactionCommitWithNewTransactionWithinEmptyTransaction(false, false);
}
@Test
void testJtaTransactionCommitWithPropagationRequiredWithinNotSupported() throws Exception {
void jtaTransactionCommitWithPropagationRequiredWithinNotSupported() throws Exception {
doTestJtaTransactionCommitWithNewTransactionWithinEmptyTransaction(false, true);
}
@Test
void testJtaTransactionCommitWithPropagationRequiresNewWithinSupports() throws Exception {
void jtaTransactionCommitWithPropagationRequiresNewWithinSupports() throws Exception {
doTestJtaTransactionCommitWithNewTransactionWithinEmptyTransaction(true, false);
}
@Test
void testJtaTransactionCommitWithPropagationRequiresNewWithinNotSupported() throws Exception {
void jtaTransactionCommitWithPropagationRequiresNewWithinNotSupported() throws Exception {
doTestJtaTransactionCommitWithNewTransactionWithinEmptyTransaction(true, true);
}
@SuppressWarnings("deprecation")
private void doTestJtaTransactionCommitWithNewTransactionWithinEmptyTransaction(
final boolean requiresNew, boolean notSupported) throws Exception {
@ -405,45 +408,46 @@ class DataSourceJtaTransactionTests { @@ -405,45 +408,46 @@ class DataSourceJtaTransactionTests {
}
@Test
void testJtaTransactionCommitWithPropagationRequiresNewAndSuspendException() throws Exception {
void jtaTransactionCommitWithPropagationRequiresNewAndSuspendException() throws Exception {
doTestJtaTransactionWithPropagationRequiresNewAndBeginException(true, false, false);
}
@Test
void testJtaTransactionCommitWithPropagationRequiresNewWithOpenOuterConnectionAndSuspendException() throws Exception {
void jtaTransactionCommitWithPropagationRequiresNewWithOpenOuterConnectionAndSuspendException() throws Exception {
doTestJtaTransactionWithPropagationRequiresNewAndBeginException(true, true, false);
}
@Test
void testJtaTransactionCommitWithPropagationRequiresNewWithTransactionAwareDataSourceAndSuspendException() throws Exception {
void jtaTransactionCommitWithPropagationRequiresNewWithTransactionAwareDataSourceAndSuspendException() throws Exception {
doTestJtaTransactionWithPropagationRequiresNewAndBeginException(true, false, true);
}
@Test
void testJtaTransactionCommitWithPropagationRequiresNewWithOpenOuterConnectionAndTransactionAwareDataSourceAndSuspendException() throws Exception {
void jtaTransactionCommitWithPropagationRequiresNewWithOpenOuterConnectionAndTransactionAwareDataSourceAndSuspendException() throws Exception {
doTestJtaTransactionWithPropagationRequiresNewAndBeginException(true, true, true);
}
@Test
void testJtaTransactionCommitWithPropagationRequiresNewAndBeginException() throws Exception {
void jtaTransactionCommitWithPropagationRequiresNewAndBeginException() throws Exception {
doTestJtaTransactionWithPropagationRequiresNewAndBeginException(false, false, false);
}
@Test
void testJtaTransactionCommitWithPropagationRequiresNewWithOpenOuterConnectionAndBeginException() throws Exception {
void jtaTransactionCommitWithPropagationRequiresNewWithOpenOuterConnectionAndBeginException() throws Exception {
doTestJtaTransactionWithPropagationRequiresNewAndBeginException(false, true, false);
}
@Test
void testJtaTransactionCommitWithPropagationRequiresNewWithOpenOuterConnectionAndTransactionAwareDataSourceAndBeginException() throws Exception {
void jtaTransactionCommitWithPropagationRequiresNewWithOpenOuterConnectionAndTransactionAwareDataSourceAndBeginException() throws Exception {
doTestJtaTransactionWithPropagationRequiresNewAndBeginException(false, true, true);
}
@Test
void testJtaTransactionCommitWithPropagationRequiresNewWithTransactionAwareDataSourceAndBeginException() throws Exception {
void jtaTransactionCommitWithPropagationRequiresNewWithTransactionAwareDataSourceAndBeginException() throws Exception {
doTestJtaTransactionWithPropagationRequiresNewAndBeginException(false, false, true);
}
@SuppressWarnings("deprecation")
private void doTestJtaTransactionWithPropagationRequiresNewAndBeginException(boolean suspendException,
final boolean openOuterConnection, final boolean useTransactionAwareDataSource) throws Exception {
@ -544,8 +548,9 @@ class DataSourceJtaTransactionTests { @@ -544,8 +548,9 @@ class DataSourceJtaTransactionTests {
}
}
@SuppressWarnings("deprecation")
@Test
void testJtaTransactionWithConnectionHolderStillBound() throws Exception {
void jtaTransactionWithConnectionHolderStillBound() throws Exception {
@SuppressWarnings("serial")
JtaTransactionManager ptm = new JtaTransactionManager(userTransaction) {
@ -601,8 +606,9 @@ class DataSourceJtaTransactionTests { @@ -601,8 +606,9 @@ class DataSourceJtaTransactionTests {
verify(connection, times(3)).close();
}
@SuppressWarnings("deprecation")
@Test
void testJtaTransactionWithIsolationLevelDataSourceAdapter() throws Exception {
void jtaTransactionWithIsolationLevelDataSourceAdapter() throws Exception {
given(userTransaction.getStatus()).willReturn(
Status.STATUS_NO_TRANSACTION,
Status.STATUS_ACTIVE,
@ -649,15 +655,16 @@ class DataSourceJtaTransactionTests { @@ -649,15 +655,16 @@ class DataSourceJtaTransactionTests {
}
@Test
void testJtaTransactionWithIsolationLevelDataSourceRouter() throws Exception {
void jtaTransactionWithIsolationLevelDataSourceRouter() throws Exception {
doTestJtaTransactionWithIsolationLevelDataSourceRouter(false);
}
@Test
void testJtaTransactionWithIsolationLevelDataSourceRouterWithDataSourceLookup() throws Exception {
void jtaTransactionWithIsolationLevelDataSourceRouterWithDataSourceLookup() throws Exception {
doTestJtaTransactionWithIsolationLevelDataSourceRouter(true);
}
@SuppressWarnings("deprecation")
private void doTestJtaTransactionWithIsolationLevelDataSourceRouter(boolean dataSourceLookup) throws Exception {
given(userTransaction.getStatus())
.willReturn(Status.STATUS_NO_TRANSACTION, Status.STATUS_ACTIVE, Status.STATUS_ACTIVE, Status.STATUS_NO_TRANSACTION, Status.STATUS_ACTIVE, Status.STATUS_ACTIVE);
@ -717,4 +724,5 @@ class DataSourceJtaTransactionTests { @@ -717,4 +724,5 @@ class DataSourceJtaTransactionTests {
verify(connection1).close();
verify(connection2).close();
}
}

1221
spring-jdbc/src/test/java/org/springframework/jdbc/datasource/DataSourceTransactionManagerTests.java
View File

File diff suppressed because it is too large Load Diff

83
spring-jdbc/src/test/java/org/springframework/jdbc/support/JdbcTransactionManagerTests.java
Unescape View File

@ -25,9 +25,7 @@ import org.mockito.InOrder; @@ -25,9 +25,7 @@ import org.mockito.InOrder;
import org.springframework.dao.ConcurrencyFailureException;
import org.springframework.jdbc.datasource.DataSourceTransactionManagerTests;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.TransactionSystemException;
import org.springframework.transaction.support.TransactionCallbackWithoutResult;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import org.springframework.transaction.support.TransactionTemplate;
@ -53,36 +51,30 @@ class JdbcTransactionManagerTests extends DataSourceTransactionManagerTests { @@ -53,36 +51,30 @@ class JdbcTransactionManagerTests extends DataSourceTransactionManagerTests {
@Override
@Test
protected void testTransactionWithExceptionOnCommit() throws Exception {
protected void transactionWithExceptionOnCommit() throws Exception {
willThrow(new SQLException("Cannot commit")).given(con).commit();
TransactionTemplate tt = new TransactionTemplate(tm);
// plain TransactionSystemException
assertThatExceptionOfType(TransactionSystemException.class).isThrownBy(() ->
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
tt.executeWithoutResult(status -> {
// something transactional
}
}));
}));
assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse();
verify(con).close();
}
@Test
void testTransactionWithDataAccessExceptionOnCommit() throws Exception {
void transactionWithDataAccessExceptionOnCommit() throws Exception {
willThrow(new SQLException("Cannot commit")).given(con).commit();
((JdbcTransactionManager) tm).setExceptionTranslator((task, sql, ex) -> new ConcurrencyFailureException(task));
TransactionTemplate tt = new TransactionTemplate(tm);
// specific ConcurrencyFailureException
assertThatExceptionOfType(ConcurrencyFailureException.class).isThrownBy(() ->
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
// something transactional
}
tt.executeWithoutResult(status -> {
// something transactional
}));
assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse();
@ -90,17 +82,14 @@ class JdbcTransactionManagerTests extends DataSourceTransactionManagerTests { @@ -90,17 +82,14 @@ class JdbcTransactionManagerTests extends DataSourceTransactionManagerTests {
}
@Test
void testTransactionWithDataAccessExceptionOnCommitFromLazyExceptionTranslator() throws Exception {
void transactionWithDataAccessExceptionOnCommitFromLazyExceptionTranslator() throws Exception {
willThrow(new SQLException("Cannot commit", "40")).given(con).commit();
TransactionTemplate tt = new TransactionTemplate(tm);
// specific ConcurrencyFailureException
assertThatExceptionOfType(ConcurrencyFailureException.class).isThrownBy(() ->
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
// something transactional
}
tt.executeWithoutResult(status -> {
// something transactional
}));
assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse();
@ -109,7 +98,7 @@ class JdbcTransactionManagerTests extends DataSourceTransactionManagerTests { @@ -109,7 +98,7 @@ class JdbcTransactionManagerTests extends DataSourceTransactionManagerTests {
@Override
@Test
protected void testTransactionWithExceptionOnCommitAndRollbackOnCommitFailure() throws Exception {
protected void transactionWithExceptionOnCommitAndRollbackOnCommitFailure() throws Exception {
willThrow(new SQLException("Cannot commit")).given(con).commit();
tm.setRollbackOnCommitFailure(true);
@ -117,12 +106,9 @@ class JdbcTransactionManagerTests extends DataSourceTransactionManagerTests { @@ -117,12 +106,9 @@ class JdbcTransactionManagerTests extends DataSourceTransactionManagerTests {
// plain TransactionSystemException
assertThatExceptionOfType(TransactionSystemException.class).isThrownBy(() ->
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
tt.executeWithoutResult(status -> {
// something transactional
}
}));
}));
assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse();
verify(con).rollback();
@ -131,16 +117,14 @@ class JdbcTransactionManagerTests extends DataSourceTransactionManagerTests { @@ -131,16 +117,14 @@ class JdbcTransactionManagerTests extends DataSourceTransactionManagerTests {
@Override
@Test
protected void testTransactionWithExceptionOnRollback() throws Exception {
protected void transactionWithExceptionOnRollback() throws Exception {
given(con.getAutoCommit()).willReturn(true);
willThrow(new SQLException("Cannot rollback")).given(con).rollback();
TransactionTemplate tt = new TransactionTemplate(tm);
// plain TransactionSystemException
assertThatExceptionOfType(TransactionSystemException.class).isThrownBy(() ->
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
tt.executeWithoutResult(status -> {
assertThat(status.getTransactionName()).isEmpty();
assertThat(status.hasTransaction()).isTrue();
assertThat(status.isNewTransaction()).isTrue();
@ -151,8 +135,7 @@ class JdbcTransactionManagerTests extends DataSourceTransactionManagerTests { @@ -151,8 +135,7 @@ class JdbcTransactionManagerTests extends DataSourceTransactionManagerTests {
status.setRollbackOnly();
assertThat(status.isRollbackOnly()).isTrue();
assertThat(status.isCompleted()).isFalse();
}
}));
}));
assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse();
InOrder ordered = inOrder(con);
@ -163,7 +146,7 @@ class JdbcTransactionManagerTests extends DataSourceTransactionManagerTests { @@ -163,7 +146,7 @@ class JdbcTransactionManagerTests extends DataSourceTransactionManagerTests {
}
@Test
void testTransactionWithDataAccessExceptionOnRollback() throws Exception {
void transactionWithDataAccessExceptionOnRollback() throws Exception {
given(con.getAutoCommit()).willReturn(true);
willThrow(new SQLException("Cannot rollback")).given(con).rollback();
((JdbcTransactionManager) tm).setExceptionTranslator((task, sql, ex) -> new ConcurrencyFailureException(task));
@ -171,12 +154,7 @@ class JdbcTransactionManagerTests extends DataSourceTransactionManagerTests { @@ -171,12 +154,7 @@ class JdbcTransactionManagerTests extends DataSourceTransactionManagerTests {
// specific ConcurrencyFailureException
assertThatExceptionOfType(ConcurrencyFailureException.class).isThrownBy(() ->
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
status.setRollbackOnly();
}
}));
tt.executeWithoutResult(status -> status.setRollbackOnly()));
assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse();
InOrder ordered = inOrder(con);
@ -187,27 +165,24 @@ class JdbcTransactionManagerTests extends DataSourceTransactionManagerTests { @@ -187,27 +165,24 @@ class JdbcTransactionManagerTests extends DataSourceTransactionManagerTests {
}
@Test
void testTransactionWithDataAccessExceptionOnRollbackFromLazyExceptionTranslator() throws Exception {
void transactionWithDataAccessExceptionOnRollbackFromLazyExceptionTranslator() throws Exception {
given(con.getAutoCommit()).willReturn(true);
willThrow(new SQLException("Cannot rollback", "40")).given(con).rollback();
TransactionTemplate tt = new TransactionTemplate(tm);
// specific ConcurrencyFailureException
assertThatExceptionOfType(ConcurrencyFailureException.class).isThrownBy(() ->
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
assertThat(status.getTransactionName()).isEmpty();
assertThat(status.hasTransaction()).isTrue();
assertThat(status.isNewTransaction()).isTrue();
assertThat(status.isNested()).isFalse();
assertThat(status.hasSavepoint()).isFalse();
assertThat(status.isReadOnly()).isFalse();
assertThat(status.isRollbackOnly()).isFalse();
status.setRollbackOnly();
assertThat(status.isRollbackOnly()).isTrue();
assertThat(status.isCompleted()).isFalse();
}
tt.executeWithoutResult(status -> {
assertThat(status.getTransactionName()).isEmpty();
assertThat(status.hasTransaction()).isTrue();
assertThat(status.isNewTransaction()).isTrue();
assertThat(status.isNested()).isFalse();
assertThat(status.hasSavepoint()).isFalse();
assertThat(status.isReadOnly()).isFalse();
assertThat(status.isRollbackOnly()).isFalse();
status.setRollbackOnly();
assertThat(status.isRollbackOnly()).isTrue();
assertThat(status.isCompleted()).isFalse();
}));
assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse();

48
spring-tx/src/test/java/org/springframework/transaction/JndiJtaTransactionManagerTests.java
Unescape View File

@ -25,7 +25,6 @@ import org.junit.jupiter.api.Test; @@ -25,7 +25,6 @@ import org.junit.jupiter.api.Test;
import org.springframework.context.testfixture.jndi.ExpectedLookupTemplate;
import org.springframework.transaction.jta.JtaTransactionManager;
import org.springframework.transaction.jta.UserTransactionAdapter;
import org.springframework.transaction.support.TransactionCallbackWithoutResult;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import org.springframework.transaction.support.TransactionTemplate;
@ -102,13 +101,10 @@ class JndiJtaTransactionManagerTests { @@ -102,13 +101,10 @@ class JndiJtaTransactionManagerTests {
boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition1).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
// something transactional
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
}
tt.executeWithoutResult(status -> {
// something transactional
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
});
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
@ -149,13 +145,10 @@ class JndiJtaTransactionManagerTests { @@ -149,13 +145,10 @@ class JndiJtaTransactionManagerTests {
boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition1).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
// something transactional
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
}
tt.executeWithoutResult(status -> {
// something transactional
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
});
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
@ -185,26 +178,19 @@ class JndiJtaTransactionManagerTests { @@ -185,26 +178,19 @@ class JndiJtaTransactionManagerTests {
boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition1).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
// something transactional
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
}
tt.executeWithoutResult(status -> {
// something transactional
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
});
ptm.setJndiTemplate(new ExpectedLookupTemplate("java:comp/UserTransaction", ut2));
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
// something transactional
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
}
tt.executeWithoutResult(status -> {
// something transactional
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
});
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
verify(ut).begin();

605
spring-tx/src/test/java/org/springframework/transaction/JtaTransactionManagerTests.java
Unescape View File

@ -31,7 +31,6 @@ import org.junit.jupiter.api.Test; @@ -31,7 +31,6 @@ import org.junit.jupiter.api.Test;
import org.springframework.dao.OptimisticLockingFailureException;
import org.springframework.transaction.jta.JtaTransactionManager;
import org.springframework.transaction.support.DefaultTransactionDefinition;
import org.springframework.transaction.support.TransactionCallbackWithoutResult;
import org.springframework.transaction.support.TransactionSynchronization;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import org.springframework.transaction.support.TransactionTemplate;
@ -69,22 +68,19 @@ class JtaTransactionManagerTests { @@ -69,22 +68,19 @@ class JtaTransactionManagerTests {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isNull();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
// something transactional
assertThat(status.getTransactionName()).isEqualTo("txName");
assertThat(status.hasTransaction()).isTrue();
assertThat(status.isNewTransaction()).isTrue();
assertThat(status.isNested()).isFalse();
assertThat(status.isReadOnly()).isFalse();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.registerSynchronization(synch);
assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isEqualTo("txName");
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertThat(status.isRollbackOnly()).isFalse();
assertThat(status.isCompleted()).isFalse();
}
tt.executeWithoutResult(status -> {
// something transactional
assertThat(status.getTransactionName()).isEqualTo("txName");
assertThat(status.hasTransaction()).isTrue();
assertThat(status.isNewTransaction()).isTrue();
assertThat(status.isNested()).isFalse();
assertThat(status.isReadOnly()).isFalse();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.registerSynchronization(synch);
assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isEqualTo("txName");
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertThat(status.isRollbackOnly()).isFalse();
assertThat(status.isCompleted()).isFalse();
});
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isNull();
@ -109,20 +105,17 @@ class JtaTransactionManagerTests { @@ -109,20 +105,17 @@ class JtaTransactionManagerTests {
TransactionTemplate tt = new TransactionTemplate(ptm);
ptm.setTransactionSynchronization(JtaTransactionManager.SYNCHRONIZATION_ON_ACTUAL_TRANSACTION);
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
// something transactional
assertThat(status.getTransactionName()).isEmpty();
assertThat(status.hasTransaction()).isTrue();
assertThat(status.isNewTransaction()).isTrue();
assertThat(status.isNested()).isFalse();
assertThat(status.isReadOnly()).isFalse();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.registerSynchronization(synch);
assertThat(status.isRollbackOnly()).isFalse();
assertThat(status.isCompleted()).isFalse();
}
tt.executeWithoutResult(status -> {
// something transactional
assertThat(status.getTransactionName()).isEmpty();
assertThat(status.hasTransaction()).isTrue();
assertThat(status.isNewTransaction()).isTrue();
assertThat(status.isNested()).isFalse();
assertThat(status.isReadOnly()).isFalse();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.registerSynchronization(synch);
assertThat(status.isRollbackOnly()).isFalse();
assertThat(status.isCompleted()).isFalse();
});
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
@ -146,18 +139,15 @@ class JtaTransactionManagerTests { @@ -146,18 +139,15 @@ class JtaTransactionManagerTests {
ptm.afterPropertiesSet();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertThat(status.getTransactionName()).isEmpty();
assertThat(status.hasTransaction()).isTrue();
assertThat(status.isNewTransaction()).isTrue();
assertThat(status.isNested()).isFalse();
assertThat(status.isReadOnly()).isFalse();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(status.isRollbackOnly()).isFalse();
assertThat(status.isCompleted()).isFalse();
}
tt.executeWithoutResult(status -> {
assertThat(status.getTransactionName()).isEmpty();
assertThat(status.hasTransaction()).isTrue();
assertThat(status.isNewTransaction()).isTrue();
assertThat(status.isNested()).isFalse();
assertThat(status.isReadOnly()).isFalse();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(status.isRollbackOnly()).isFalse();
assertThat(status.isCompleted()).isFalse();
});
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
@ -179,22 +169,19 @@ class JtaTransactionManagerTests { @@ -179,22 +169,19 @@ class JtaTransactionManagerTests {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isNull();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertThat(status.getTransactionName()).isEqualTo("txName");
assertThat(status.hasTransaction()).isTrue();
assertThat(status.isNewTransaction()).isTrue();
assertThat(status.isNested()).isFalse();
assertThat(status.isReadOnly()).isFalse();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.registerSynchronization(synch);
assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isEqualTo("txName");
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
status.setRollbackOnly();
assertThat(status.isRollbackOnly()).isTrue();
assertThat(status.isCompleted()).isFalse();
}
tt.executeWithoutResult(status -> {
assertThat(status.getTransactionName()).isEqualTo("txName");
assertThat(status.hasTransaction()).isTrue();
assertThat(status.isNewTransaction()).isTrue();
assertThat(status.isNested()).isFalse();
assertThat(status.isReadOnly()).isFalse();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.registerSynchronization(synch);
assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isEqualTo("txName");
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
status.setRollbackOnly();
assertThat(status.isRollbackOnly()).isTrue();
assertThat(status.isCompleted()).isFalse();
});
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isNull();
@ -218,20 +205,17 @@ class JtaTransactionManagerTests { @@ -218,20 +205,17 @@ class JtaTransactionManagerTests {
ptm.setTransactionSynchronization(JtaTransactionManager.SYNCHRONIZATION_ON_ACTUAL_TRANSACTION);
tt.setTimeout(10);
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertThat(status.getTransactionName()).isEmpty();
assertThat(status.hasTransaction()).isTrue();
assertThat(status.isNewTransaction()).isTrue();
assertThat(status.isNested()).isFalse();
assertThat(status.isReadOnly()).isFalse();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.registerSynchronization(synch);
status.setRollbackOnly();
assertThat(status.isRollbackOnly()).isTrue();
assertThat(status.isCompleted()).isFalse();
}
tt.executeWithoutResult(status -> {
assertThat(status.getTransactionName()).isEmpty();
assertThat(status.hasTransaction()).isTrue();
assertThat(status.isNewTransaction()).isTrue();
assertThat(status.isNested()).isFalse();
assertThat(status.isReadOnly()).isFalse();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.registerSynchronization(synch);
status.setRollbackOnly();
assertThat(status.isRollbackOnly()).isTrue();
assertThat(status.isCompleted()).isFalse();
});
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
@ -254,20 +238,17 @@ class JtaTransactionManagerTests { @@ -254,20 +238,17 @@ class JtaTransactionManagerTests {
ptm.afterPropertiesSet();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertThat(status.getTransactionName()).isEmpty();
assertThat(status.hasTransaction()).isTrue();
assertThat(status.isNewTransaction()).isTrue();
assertThat(status.isNested()).isFalse();
assertThat(status.isReadOnly()).isFalse();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(status.isRollbackOnly()).isFalse();
status.setRollbackOnly();
assertThat(status.isRollbackOnly()).isTrue();
assertThat(status.isCompleted()).isFalse();
}
tt.executeWithoutResult(status -> {
assertThat(status.getTransactionName()).isEmpty();
assertThat(status.hasTransaction()).isTrue();
assertThat(status.isNewTransaction()).isTrue();
assertThat(status.isNested()).isFalse();
assertThat(status.isReadOnly()).isFalse();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(status.isRollbackOnly()).isFalse();
status.setRollbackOnly();
assertThat(status.isRollbackOnly()).isTrue();
assertThat(status.isCompleted()).isFalse();
});
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
@ -287,13 +268,10 @@ class JtaTransactionManagerTests { @@ -287,13 +268,10 @@ class JtaTransactionManagerTests {
JtaTransactionManager ptm = newJtaTransactionManager(ut);
TransactionTemplate tt = new TransactionTemplate(ptm);
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.registerSynchronization(synch);
status.setRollbackOnly();
}
tt.executeWithoutResult(status -> {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.registerSynchronization(synch);
status.setRollbackOnly();
});
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
@ -313,13 +291,10 @@ class JtaTransactionManagerTests { @@ -313,13 +291,10 @@ class JtaTransactionManagerTests {
TransactionTemplate tt = new TransactionTemplate(ptm);
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThatIllegalStateException().isThrownBy(() ->
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.registerSynchronization(synch);
throw new IllegalStateException("I want a rollback");
}
tt.executeWithoutResult(status -> {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.registerSynchronization(synch);
throw new IllegalStateException("I want a rollback");
}));
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
@ -340,12 +315,9 @@ class JtaTransactionManagerTests { @@ -340,12 +315,9 @@ class JtaTransactionManagerTests {
TransactionTemplate tt = new TransactionTemplate(ptm);
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThatExceptionOfType(OptimisticLockingFailureException.class).isThrownBy(() ->
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.registerSynchronization(synch);
}
tt.executeWithoutResult(status -> {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.registerSynchronization(synch);
}));
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
@ -365,13 +337,10 @@ class JtaTransactionManagerTests { @@ -365,13 +337,10 @@ class JtaTransactionManagerTests {
ptm.setGlobalRollbackOnParticipationFailure(false);
TransactionTemplate tt = new TransactionTemplate(ptm);
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.registerSynchronization(synch);
status.setRollbackOnly();
}
tt.executeWithoutResult(status -> {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.registerSynchronization(synch);
status.setRollbackOnly();
});
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
@ -391,13 +360,10 @@ class JtaTransactionManagerTests { @@ -391,13 +360,10 @@ class JtaTransactionManagerTests {
TransactionTemplate tt = new TransactionTemplate(ptm);
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThatIllegalStateException().isThrownBy(() ->
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.registerSynchronization(synch);
throw new IllegalStateException("I want a rollback");
}
tt.executeWithoutResult(status -> {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.registerSynchronization(synch);
throw new IllegalStateException("I want a rollback");
}));
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
@ -419,13 +385,10 @@ class JtaTransactionManagerTests { @@ -419,13 +385,10 @@ class JtaTransactionManagerTests {
JtaTransactionManager ptm = newJtaTransactionManager(ut, tm);
TransactionTemplate tt = new TransactionTemplate(ptm);
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.registerSynchronization(synch);
status.setRollbackOnly();
}
tt.executeWithoutResult(status -> {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.registerSynchronization(synch);
status.setRollbackOnly();
});
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(tx.getSynchronization()).isNotNull();
@ -448,13 +411,10 @@ class JtaTransactionManagerTests { @@ -448,13 +411,10 @@ class JtaTransactionManagerTests {
TransactionTemplate tt = new TransactionTemplate(ptm);
ptm.setTransactionSynchronization(JtaTransactionManager.SYNCHRONIZATION_ON_ACTUAL_TRANSACTION);
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.registerSynchronization(synch);
status.setRollbackOnly();
}
tt.executeWithoutResult(status -> {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.registerSynchronization(synch);
status.setRollbackOnly();
});
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
@ -474,12 +434,9 @@ class JtaTransactionManagerTests { @@ -474,12 +434,9 @@ class JtaTransactionManagerTests {
ptm.afterPropertiesSet();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
status.setRollbackOnly();
}
tt.executeWithoutResult(status -> {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
status.setRollbackOnly();
});
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
@ -497,13 +454,10 @@ class JtaTransactionManagerTests { @@ -497,13 +454,10 @@ class JtaTransactionManagerTests {
TransactionTemplate tt = new TransactionTemplate(ptm);
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.registerSynchronization(synch);
status.setRollbackOnly();
}
tt.executeWithoutResult(status -> {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.registerSynchronization(synch);
status.setRollbackOnly();
});
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
@ -523,13 +477,10 @@ class JtaTransactionManagerTests { @@ -523,13 +477,10 @@ class JtaTransactionManagerTests {
TransactionTemplate tt = new TransactionTemplate(ptm);
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.registerSynchronization(synch);
status.setRollbackOnly();
}
tt.executeWithoutResult(status -> {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.registerSynchronization(synch);
status.setRollbackOnly();
});
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
@ -549,12 +500,9 @@ class JtaTransactionManagerTests { @@ -549,12 +500,9 @@ class JtaTransactionManagerTests {
ptm.afterPropertiesSet();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
status.setRollbackOnly();
}
tt.executeWithoutResult(status -> {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
status.setRollbackOnly();
});
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
}
@ -571,12 +519,9 @@ class JtaTransactionManagerTests { @@ -571,12 +519,9 @@ class JtaTransactionManagerTests {
ptm.afterPropertiesSet();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
status.setRollbackOnly();
}
tt.executeWithoutResult(status -> {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
status.setRollbackOnly();
});
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
}
@ -593,12 +538,9 @@ class JtaTransactionManagerTests { @@ -593,12 +538,9 @@ class JtaTransactionManagerTests {
TransactionTemplate tt = new TransactionTemplate(ptm);
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NOT_SUPPORTED);
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
status.setRollbackOnly();
}
tt.executeWithoutResult(status -> {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
status.setRollbackOnly();
});
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
@ -621,30 +563,24 @@ class JtaTransactionManagerTests { @@ -621,30 +563,24 @@ class JtaTransactionManagerTests {
tt.setName("txName");
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
tt.executeWithoutResult(status1 -> {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isEqualTo("txName");
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
TransactionTemplate tt2 = new TransactionTemplate(ptm);
tt2.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
tt2.setReadOnly(true);
tt2.setName("txName2");
tt2.executeWithoutResult(status2 -> {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isEqualTo("txName");
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
TransactionTemplate tt2 = new TransactionTemplate(ptm);
tt2.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
tt2.setReadOnly(true);
tt2.setName("txName2");
tt2.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isEqualTo("txName2");
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isTrue();
}
});
assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isEqualTo("txName2");
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isTrue();
});
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isEqualTo("txName");
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
}
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isEqualTo("txName");
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
});
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
@ -664,28 +600,22 @@ class JtaTransactionManagerTests { @@ -664,28 +600,22 @@ class JtaTransactionManagerTests {
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
tt.executeWithoutResult(status1 -> {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
TransactionTemplate tt2 = new TransactionTemplate(ptm);
tt2.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
tt2.executeWithoutResult(status2 -> {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
TransactionTemplate tt2 = new TransactionTemplate(ptm);
tt2.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
tt2.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
}
});
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
});
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
}
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
});
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
@ -705,12 +635,8 @@ class JtaTransactionManagerTests { @@ -705,12 +635,8 @@ class JtaTransactionManagerTests {
TransactionTemplate tt = new TransactionTemplate(ptm);
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
}
});
tt.executeWithoutResult(status ->
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
verify(ut).begin();
@ -730,12 +656,8 @@ class JtaTransactionManagerTests { @@ -730,12 +656,8 @@ class JtaTransactionManagerTests {
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThatExceptionOfType(TransactionSystemException.class).isThrownBy(() ->
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
}
}));
tt.executeWithoutResult(status ->
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue()));
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
}
@ -753,12 +675,8 @@ class JtaTransactionManagerTests { @@ -753,12 +675,8 @@ class JtaTransactionManagerTests {
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThatExceptionOfType(CannotCreateTransactionException.class).isThrownBy(() ->
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
}
}));
tt.executeWithoutResult(status ->
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue()));
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
verify(tm).resume(tx);
}
@ -774,12 +692,8 @@ class JtaTransactionManagerTests { @@ -774,12 +692,8 @@ class JtaTransactionManagerTests {
TransactionTemplate tt = new TransactionTemplate(ptm);
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
}
});
tt.executeWithoutResult(status ->
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
verify(tm).begin();
@ -797,10 +711,8 @@ class JtaTransactionManagerTests { @@ -797,10 +711,8 @@ class JtaTransactionManagerTests {
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThatExceptionOfType(TransactionSuspensionNotSupportedException.class).isThrownBy(() ->
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
}
tt.executeWithoutResult(status -> {
// something transactional
}));
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
}
@ -814,11 +726,8 @@ class JtaTransactionManagerTests { @@ -814,11 +726,8 @@ class JtaTransactionManagerTests {
JtaTransactionManager ptm = newJtaTransactionManager(ut);
TransactionTemplate tt = new TransactionTemplate(ptm);
tt.setIsolationLevel(TransactionDefinition.ISOLATION_SERIALIZABLE);
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
// something transactional
}
tt.executeWithoutResult(status -> {
// something transactional
});
});
}
@ -831,11 +740,8 @@ class JtaTransactionManagerTests { @@ -831,11 +740,8 @@ class JtaTransactionManagerTests {
assertThatExceptionOfType(TransactionSystemException.class).isThrownBy(() -> {
JtaTransactionManager ptm = newJtaTransactionManager(ut);
TransactionTemplate tt = new TransactionTemplate(ptm);
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
// something transactional
}
tt.executeWithoutResult(status -> {
// something transactional
});
});
}
@ -848,18 +754,15 @@ class JtaTransactionManagerTests { @@ -848,18 +754,15 @@ class JtaTransactionManagerTests {
JtaTransactionManager ptm = newJtaTransactionManager(ut);
TransactionTemplate tt = new TransactionTemplate(ptm);
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED);
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
// something transactional
assertThat(status.getTransactionName()).isEmpty();
assertThat(status.hasTransaction()).isTrue();
assertThat(status.isNewTransaction()).isTrue();
assertThat(status.isNested()).isTrue();
assertThat(status.isReadOnly()).isFalse();
assertThat(status.isRollbackOnly()).isFalse();
assertThat(status.isCompleted()).isFalse();
}
tt.executeWithoutResult(status -> {
// something transactional
assertThat(status.getTransactionName()).isEmpty();
assertThat(status.hasTransaction()).isTrue();
assertThat(status.isNewTransaction()).isTrue();
assertThat(status.isNested()).isTrue();
assertThat(status.isReadOnly()).isFalse();
assertThat(status.isRollbackOnly()).isFalse();
assertThat(status.isCompleted()).isFalse();
});
verify(ut).begin();
@ -876,11 +779,8 @@ class JtaTransactionManagerTests { @@ -876,11 +779,8 @@ class JtaTransactionManagerTests {
JtaTransactionManager ptm = newJtaTransactionManager(ut);
TransactionTemplate tt = new TransactionTemplate(ptm);
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED);
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
// something transactional
}
tt.executeWithoutResult(status -> {
// something transactional
});
});
}
@ -895,11 +795,8 @@ class JtaTransactionManagerTests { @@ -895,11 +795,8 @@ class JtaTransactionManagerTests {
JtaTransactionManager ptm = newJtaTransactionManager(ut);
TransactionTemplate tt = new TransactionTemplate(ptm);
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED);
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
// something transactional
}
tt.executeWithoutResult(status -> {
// something transactional
});
});
}
@ -915,12 +812,8 @@ class JtaTransactionManagerTests { @@ -915,12 +812,8 @@ class JtaTransactionManagerTests {
ptm.addListener(tl);
assertThatExceptionOfType(CannotCreateTransactionException.class).isThrownBy(() -> {
TransactionTemplate tt = new TransactionTemplate(ptm);
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
// something transactional
}
new TransactionTemplate(ptm).executeWithoutResult(status -> {
// something transactional
});
});
@ -948,18 +841,15 @@ class JtaTransactionManagerTests { @@ -948,18 +841,15 @@ class JtaTransactionManagerTests {
assertThatExceptionOfType(UnexpectedRollbackException.class).isThrownBy(() -> {
TransactionTemplate tt = new TransactionTemplate(ptm);
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
// something transactional
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
@Override
public void afterCompletion(int status) {
assertThat(status).as("Correct completion status")
.isEqualTo(TransactionSynchronization.STATUS_ROLLED_BACK);
}
});
}
tt.executeWithoutResult(status -> {
// something transactional
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
@Override
public void afterCompletion(int status) {
assertThat(status).as("Correct completion status")
.isEqualTo(TransactionSynchronization.STATUS_ROLLED_BACK);
}
});
});
});
@ -1003,18 +893,15 @@ class JtaTransactionManagerTests { @@ -1003,18 +893,15 @@ class JtaTransactionManagerTests {
assertThat(ts.isNewTransaction()).as("Is new transaction").isTrue();
TransactionTemplate tt = new TransactionTemplate(tm);
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
// something transactional
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
@Override
public void afterCompletion(int status) {
assertThat(status).as("Correct completion status")
.isEqualTo(TransactionSynchronization.STATUS_ROLLED_BACK);
}
});
}
tt.executeWithoutResult(status -> {
// something transactional
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
@Override
public void afterCompletion(int status) {
assertThat(status).as("Correct completion status")
.isEqualTo(TransactionSynchronization.STATUS_ROLLED_BACK);
}
});
});
outerTransactionBoundaryReached = true;
@ -1049,17 +936,15 @@ class JtaTransactionManagerTests { @@ -1049,17 +936,15 @@ class JtaTransactionManagerTests {
assertThatExceptionOfType(HeuristicCompletionException.class).isThrownBy(() -> {
JtaTransactionManager ptm = newJtaTransactionManager(ut);
TransactionTemplate tt = new TransactionTemplate(ptm);
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
// something transactional
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
@Override
public void afterCompletion(int status) {
assertThat(status == TransactionSynchronization.STATUS_UNKNOWN).as("Correct completion status").isTrue();
}
});
}
tt.executeWithoutResult(status -> {
// something transactional
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
@Override
public void afterCompletion(int status) {
assertThat(status).as("Correct completion status")
.isEqualTo(TransactionSynchronization.STATUS_UNKNOWN);
}
});
});
}).satisfies(ex -> assertThat(ex.getOutcomeState()).isEqualTo(HeuristicCompletionException.STATE_MIXED));
@ -1076,17 +961,15 @@ class JtaTransactionManagerTests { @@ -1076,17 +961,15 @@ class JtaTransactionManagerTests {
assertThatExceptionOfType(HeuristicCompletionException.class).isThrownBy(() -> {
JtaTransactionManager ptm = newJtaTransactionManager(ut);
TransactionTemplate tt = new TransactionTemplate(ptm);
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
// something transactional
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
@Override
public void afterCompletion(int status) {
assertThat(status == TransactionSynchronization.STATUS_UNKNOWN).as("Correct completion status").isTrue();
}
});
}
tt.executeWithoutResult(status -> {
// something transactional
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
@Override
public void afterCompletion(int status) {
assertThat(status).as("Correct completion status")
.isEqualTo(TransactionSynchronization.STATUS_UNKNOWN);
}
});
});
}).satisfies(ex -> assertThat(ex.getOutcomeState()).isEqualTo(HeuristicCompletionException.STATE_ROLLED_BACK));
@ -1106,18 +989,15 @@ class JtaTransactionManagerTests { @@ -1106,18 +989,15 @@ class JtaTransactionManagerTests {
assertThatExceptionOfType(TransactionSystemException.class).isThrownBy(() -> {
TransactionTemplate tt = new TransactionTemplate(ptm);
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
// something transactional
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
@Override
public void afterCompletion(int status) {
assertThat(status).as("Correct completion status")
.isEqualTo(TransactionSynchronization.STATUS_UNKNOWN);
}
});
}
tt.executeWithoutResult(status -> {
// something transactional
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
@Override
public void afterCompletion(int status) {
assertThat(status).as("Correct completion status")
.isEqualTo(TransactionSynchronization.STATUS_UNKNOWN);
}
});
});
});
@ -1146,18 +1026,15 @@ class JtaTransactionManagerTests { @@ -1146,18 +1026,15 @@ class JtaTransactionManagerTests {
assertThatExceptionOfType(TransactionSystemException.class).isThrownBy(() -> {
TransactionTemplate tt = new TransactionTemplate(ptm);
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
@Override
public void afterCompletion(int status) {
assertThat(status).as("Correct completion status")
.isEqualTo(TransactionSynchronization.STATUS_UNKNOWN);
}
});
status.setRollbackOnly();
}
tt.executeWithoutResult(status -> {
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
@Override
public void afterCompletion(int status) {
assertThat(status).as("Correct completion status")
.isEqualTo(TransactionSynchronization.STATUS_UNKNOWN);
}
});
status.setRollbackOnly();
});
});
@ -1183,12 +1060,7 @@ class JtaTransactionManagerTests { @@ -1183,12 +1060,7 @@ class JtaTransactionManagerTests {
assertThatExceptionOfType(TransactionSystemException.class).isThrownBy(() -> {
JtaTransactionManager ptm = newJtaTransactionManager(ut);
TransactionTemplate tt = new TransactionTemplate(ptm);
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
status.setRollbackOnly();
}
});
tt.executeWithoutResult(TransactionExecution::setRollbackOnly);
});
}
@ -1201,18 +1073,15 @@ class JtaTransactionManagerTests { @@ -1201,18 +1073,15 @@ class JtaTransactionManagerTests {
assertThatExceptionOfType(TransactionSystemException.class).isThrownBy(() -> {
JtaTransactionManager ptm = newJtaTransactionManager(ut);
TransactionTemplate tt = new TransactionTemplate(ptm);
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
status.setRollbackOnly();
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
@Override
public void afterCompletion(int status) {
assertThat(status).as("Correct completion status")
.isEqualTo(TransactionSynchronization.STATUS_UNKNOWN);
}
});
}
tt.executeWithoutResult(status -> {
status.setRollbackOnly();
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
@Override
public void afterCompletion(int status) {
assertThat(status).as("Correct completion status")
.isEqualTo(TransactionSynchronization.STATUS_UNKNOWN);
}
});
});
});
}

5
spring-tx/src/test/java/org/springframework/transaction/support/TransactionSupportTests.java
Unescape View File

@ -233,6 +233,7 @@ class TransactionSupportTests { @@ -233,6 +233,7 @@ class TransactionSupportTests {
}
@Test
@SuppressWarnings("deprecation")
void transactionTemplate() {
TestTransactionManager tm = new TestTransactionManager(false, true);
TransactionTemplate template = new TransactionTemplate(tm);
@ -249,6 +250,7 @@ class TransactionSupportTests { @@ -249,6 +250,7 @@ class TransactionSupportTests {
}
@Test
@SuppressWarnings("deprecation")
void transactionTemplateWithCallbackPreference() {
MockCallbackPreferringTransactionManager ptm = new MockCallbackPreferringTransactionManager();
TransactionTemplate template = new TransactionTemplate(ptm);
@ -263,6 +265,7 @@ class TransactionSupportTests { @@ -263,6 +265,7 @@ class TransactionSupportTests {
}
@Test
@SuppressWarnings("deprecation")
void transactionTemplateWithException() {
TestTransactionManager tm = new TestTransactionManager(false, true);
TransactionTemplate template = new TransactionTemplate(tm);
@ -281,10 +284,10 @@ class TransactionSupportTests { @@ -281,10 +284,10 @@ class TransactionSupportTests {
assertThat(tm.rollbackOnly).as("no rollbackOnly").isFalse();
}
@SuppressWarnings("serial")
@Test
void transactionTemplateWithRollbackException() {
final TransactionSystemException tex = new TransactionSystemException("system exception");
@SuppressWarnings("serial")
TestTransactionManager tm = new TestTransactionManager(false, true) {
@Override
protected void doRollback(DefaultTransactionStatus status) {

Write Preview
Loading…
Cancel
Save