From c2ef11e1fc81b32e32db09633ef0d11853d8413c Mon Sep 17 00:00:00 2001 From: Sam Brannen <104798+sbrannen@users.noreply.github.com> Date: Mon, 13 Oct 2025 14:48:03 +0200 Subject: [PATCH] Remove test prefixes and avoid warnings in JDBC and TX tests --- .../DataSourceJtaTransactionTests.java | 64 +- .../DataSourceTransactionManagerTests.java | 1295 +++++++---------- .../support/JdbcTransactionManagerTests.java | 139 +- .../JndiJtaTransactionManagerTests.java | 48 +- .../JtaTransactionManagerTests.java | 605 +++----- .../support/TransactionSupportTests.java | 5 +- 6 files changed, 909 insertions(+), 1247 deletions(-) diff --git a/spring-jdbc/src/test/java/org/springframework/jdbc/datasource/DataSourceJtaTransactionTests.java b/spring-jdbc/src/test/java/org/springframework/jdbc/datasource/DataSourceJtaTransactionTests.java index 5bb008fc5d3..16b50f43b13 100644 --- a/spring-jdbc/src/test/java/org/springframework/jdbc/datasource/DataSourceJtaTransactionTests.java +++ b/spring-jdbc/src/test/java/org/springframework/jdbc/datasource/DataSourceJtaTransactionTests.java @@ -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 { } @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 { } @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 { } @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 { } } + @SuppressWarnings("deprecation") @Test - void testJtaTransactionWithConnectionHolderStillBound() throws Exception { + void jtaTransactionWithConnectionHolderStillBound() throws Exception { @SuppressWarnings("serial") JtaTransactionManager ptm = new JtaTransactionManager(userTransaction) { @@ -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 { } @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 { verify(connection1).close(); verify(connection2).close(); } + } diff --git a/spring-jdbc/src/test/java/org/springframework/jdbc/datasource/DataSourceTransactionManagerTests.java b/spring-jdbc/src/test/java/org/springframework/jdbc/datasource/DataSourceTransactionManagerTests.java index bbcf092724a..d126a3f7d2b 100644 --- a/spring-jdbc/src/test/java/org/springframework/jdbc/datasource/DataSourceTransactionManagerTests.java +++ b/spring-jdbc/src/test/java/org/springframework/jdbc/datasource/DataSourceTransactionManagerTests.java @@ -44,7 +44,6 @@ import org.springframework.transaction.TransactionSystemException; import org.springframework.transaction.TransactionTimedOutException; import org.springframework.transaction.UnexpectedRollbackException; 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; @@ -98,35 +97,36 @@ public class DataSourceTransactionManagerTests { @Test - void testTransactionCommitWithAutoCommitTrue() throws Exception { + void transactionCommitWithAutoCommitTrue() throws Exception { doTestTransactionCommitRestoringAutoCommit(true, false, false); } @Test - void testTransactionCommitWithAutoCommitFalse() throws Exception { + void transactionCommitWithAutoCommitFalse() throws Exception { doTestTransactionCommitRestoringAutoCommit(false, false, false); } @Test - void testTransactionCommitWithAutoCommitTrueAndLazyConnection() throws Exception { + void transactionCommitWithAutoCommitTrueAndLazyConnection() throws Exception { doTestTransactionCommitRestoringAutoCommit(true, true, false); } @Test - void testTransactionCommitWithAutoCommitFalseAndLazyConnection() throws Exception { + void transactionCommitWithAutoCommitFalseAndLazyConnection() throws Exception { doTestTransactionCommitRestoringAutoCommit(false, true, false); } @Test - void testTransactionCommitWithAutoCommitTrueAndLazyConnectionAndStatementCreated() throws Exception { + void transactionCommitWithAutoCommitTrueAndLazyConnectionAndStatementCreated() throws Exception { doTestTransactionCommitRestoringAutoCommit(true, true, true); } @Test - void testTransactionCommitWithAutoCommitFalseAndLazyConnectionAndStatementCreated() throws Exception { + void transactionCommitWithAutoCommitFalseAndLazyConnectionAndStatementCreated() throws Exception { doTestTransactionCommitRestoringAutoCommit(false, true, true); } + @SuppressWarnings("deprecation") private void doTestTransactionCommitRestoringAutoCommit( boolean autoCommit, boolean lazyConnection, boolean createStatement) throws Exception { @@ -143,28 +143,25 @@ public class DataSourceTransactionManagerTests { assertThat(TransactionSynchronizationManager.hasResource(dsToUse)).isFalse(); assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse(); - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - assertThat(TransactionSynchronizationManager.hasResource(dsToUse)).isTrue(); - assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue(); - assertThat(status.isNewTransaction()).isTrue(); - assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse(); - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); - Connection tCon = DataSourceUtils.getConnection(dsToUse); - try { - if (createStatement) { - tCon.createStatement(); - } - else { - tCon.getWarnings(); - tCon.clearWarnings(); - } + tt.executeWithoutResult(status -> { + assertThat(TransactionSynchronizationManager.hasResource(dsToUse)).isTrue(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue(); + assertThat(status.isNewTransaction()).isTrue(); + assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse(); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + Connection tCon = DataSourceUtils.getConnection(dsToUse); + try { + if (createStatement) { + tCon.createStatement(); } - catch (SQLException ex) { - throw new UncategorizedSQLException("", "", ex); + else { + tCon.getWarnings(); + tCon.clearWarnings(); } } + catch (SQLException ex) { + throw new UncategorizedSQLException("", "", ex); + } }); assertThat(TransactionSynchronizationManager.hasResource(dsToUse)).isFalse(); @@ -185,35 +182,36 @@ public class DataSourceTransactionManagerTests { } @Test - void testTransactionRollbackWithAutoCommitTrue() throws Exception { + void transactionRollbackWithAutoCommitTrue() throws Exception { doTestTransactionRollbackRestoringAutoCommit(true, false, false); } @Test - void testTransactionRollbackWithAutoCommitFalse() throws Exception { + void transactionRollbackWithAutoCommitFalse() throws Exception { doTestTransactionRollbackRestoringAutoCommit(false, false, false); } @Test - void testTransactionRollbackWithAutoCommitTrueAndLazyConnection() throws Exception { + void transactionRollbackWithAutoCommitTrueAndLazyConnection() throws Exception { doTestTransactionRollbackRestoringAutoCommit(true, true, false); } @Test - void testTransactionRollbackWithAutoCommitFalseAndLazyConnection() throws Exception { + void transactionRollbackWithAutoCommitFalseAndLazyConnection() throws Exception { doTestTransactionRollbackRestoringAutoCommit(false, true, false); } @Test - void testTransactionRollbackWithAutoCommitTrueAndLazyConnectionAndCreateStatement() throws Exception { + void transactionRollbackWithAutoCommitTrueAndLazyConnectionAndCreateStatement() throws Exception { doTestTransactionRollbackRestoringAutoCommit(true, true, true); } @Test - void testTransactionRollbackWithAutoCommitFalseAndLazyConnectionAndCreateStatement() throws Exception { + void transactionRollbackWithAutoCommitFalseAndLazyConnectionAndCreateStatement() throws Exception { doTestTransactionRollbackRestoringAutoCommit(false, true, true); } + @SuppressWarnings("deprecation") private void doTestTransactionRollbackRestoringAutoCommit( boolean autoCommit, boolean lazyConnection, boolean createStatement) throws Exception { @@ -231,23 +229,20 @@ public class DataSourceTransactionManagerTests { RuntimeException ex = new RuntimeException("Application exception"); assertThatRuntimeException().isThrownBy(() -> - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - assertThat(TransactionSynchronizationManager.hasResource(dsToUse)).isTrue(); - assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue(); - assertThat(status.isNewTransaction()).isTrue(); - Connection con = DataSourceUtils.getConnection(dsToUse); - if (createStatement) { - try { - con.createStatement(); - } - catch (SQLException ex) { - throw new UncategorizedSQLException("", "", ex); - } + tt.executeWithoutResult(status -> { + assertThat(TransactionSynchronizationManager.hasResource(dsToUse)).isTrue(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue(); + assertThat(status.isNewTransaction()).isTrue(); + Connection con = DataSourceUtils.getConnection(dsToUse); + if (createStatement) { + try { + con.createStatement(); + } + catch (SQLException sqlException) { + throw new UncategorizedSQLException("", "", sqlException); } - throw ex; } + throw ex; })) .isEqualTo(ex); @@ -268,8 +263,9 @@ public class DataSourceTransactionManagerTests { } } + @SuppressWarnings("deprecation") @Test - void testTransactionRollbackOnly() { + void transactionRollbackOnly() { tm.setTransactionSynchronization(DataSourceTransactionManager.SYNCHRONIZATION_NEVER); TransactionTemplate tt = new TransactionTemplate(tm); assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); @@ -279,14 +275,11 @@ public class DataSourceTransactionManagerTests { TransactionSynchronizationManager.bindResource(ds, conHolder); RuntimeException ex = new RuntimeException("Application exception"); try { - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - assertThat(TransactionSynchronizationManager.hasResource(ds)).isTrue(); - assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse(); - assertThat(status.isNewTransaction()).isFalse(); - throw ex; - } + tt.executeWithoutResult(status -> { + assertThat(TransactionSynchronizationManager.hasResource(ds)).isTrue(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse(); + assertThat(status.isNewTransaction()).isFalse(); + throw ex; }); fail("Should have thrown RuntimeException"); } @@ -303,15 +296,16 @@ public class DataSourceTransactionManagerTests { } @Test - void testParticipatingTransactionWithRollbackOnly() throws Exception { + void participatingTransactionWithRollbackOnly() throws Exception { doTestParticipatingTransactionWithRollbackOnly(false); } @Test - void testParticipatingTransactionWithRollbackOnlyAndFailEarly() throws Exception { + void participatingTransactionWithRollbackOnlyAndFailEarly() throws Exception { doTestParticipatingTransactionWithRollbackOnly(true); } + @SuppressWarnings("deprecation") private void doTestParticipatingTransactionWithRollbackOnly(boolean failEarly) throws Exception { given(con.isReadOnly()).willReturn(false); if (failEarly) { @@ -330,23 +324,17 @@ public class DataSourceTransactionManagerTests { assertThat(ts.isNewTransaction()).isTrue(); TransactionTemplate tt = new TransactionTemplate(tm); - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - assertThat(status.isNewTransaction()).isFalse(); - assertThat(status.isRollbackOnly()).isFalse(); - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - assertThat(TransactionSynchronizationManager.hasResource(ds)).isTrue(); - assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue(); - assertThat(status.isNewTransaction()).isFalse(); - status.setRollbackOnly(); - } - }); - assertThat(status.isNewTransaction()).isFalse(); - assertThat(status.isRollbackOnly()).isTrue(); - } + tt.executeWithoutResult(status1 -> { + assertThat(status1.isNewTransaction()).isFalse(); + assertThat(status1.isRollbackOnly()).isFalse(); + tt.executeWithoutResult(status2 -> { + assertThat(TransactionSynchronizationManager.hasResource(ds)).isTrue(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue(); + assertThat(status2.isNewTransaction()).isFalse(); + status2.setRollbackOnly(); + }); + assertThat(status1.isNewTransaction()).isFalse(); + assertThat(status1.isRollbackOnly()).isTrue(); }); outerTransactionBoundaryReached = true; @@ -376,8 +364,9 @@ public class DataSourceTransactionManagerTests { verify(con).close(); } + @SuppressWarnings("deprecation") @Test - void testParticipatingTransactionWithIncompatibleIsolationLevel() throws Exception { + void participatingTransactionWithIncompatibleIsolationLevel() throws Exception { tm.setValidateExistingTransaction(true); assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); @@ -388,18 +377,10 @@ public class DataSourceTransactionManagerTests { TransactionTemplate tt2 = new TransactionTemplate(tm); tt2.setIsolationLevel(TransactionDefinition.ISOLATION_SERIALIZABLE); - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - assertThat(status.isRollbackOnly()).isFalse(); - tt2.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - status.setRollbackOnly(); - } - }); - assertThat(status.isRollbackOnly()).isTrue(); - } + tt.executeWithoutResult(status -> { + assertThat(status.isRollbackOnly()).isFalse(); + tt2.executeWithoutResult(status2 -> status2.setRollbackOnly()); + assertThat(status.isRollbackOnly()).isTrue(); }); }); @@ -409,7 +390,7 @@ public class DataSourceTransactionManagerTests { } @Test - void testParticipatingTransactionWithIncompatibleReadOnly() throws Exception { + void participatingTransactionWithIncompatibleReadOnly() throws Exception { willThrow(new SQLException("read-only not supported")).given(con).setReadOnly(true); tm.setValidateExistingTransaction(true); @@ -422,18 +403,10 @@ public class DataSourceTransactionManagerTests { TransactionTemplate tt2 = new TransactionTemplate(tm); tt2.setReadOnly(false); - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - assertThat(status.isRollbackOnly()).isFalse(); - tt2.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - status.setRollbackOnly(); - } - }); - assertThat(status.isRollbackOnly()).isTrue(); - } + tt.executeWithoutResult(status -> { + assertThat(status.isRollbackOnly()).isFalse(); + tt2.executeWithoutResult(status2 -> status2.setRollbackOnly()); + assertThat(status.isRollbackOnly()).isTrue(); }); }); @@ -443,7 +416,7 @@ public class DataSourceTransactionManagerTests { } @Test - void testParticipatingTransactionWithTransactionStartedFromSynch() throws Exception { + void participatingTransactionWithTransactionStartedFromSynch() throws Exception { assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse(); @@ -455,21 +428,14 @@ public class DataSourceTransactionManagerTests { @Override protected void doAfterCompletion(int status) { super.doAfterCompletion(status); - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) { - } + tt.executeWithoutResult(status2 -> { }); TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {}); } }; - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - TransactionSynchronizationManager.registerSynchronization(synch); - } - }); + tt.executeWithoutResult(status -> + TransactionSynchronizationManager.registerSynchronization(synch)); assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); assertThat(synch.beforeCommitCalled).isTrue(); @@ -482,7 +448,7 @@ public class DataSourceTransactionManagerTests { } @Test - void testParticipatingTransactionWithDifferentConnectionObtainedFromSynch() throws Exception { + void participatingTransactionWithDifferentConnectionObtainedFromSynch() throws Exception { DataSource ds2 = mock(); Connection con2 = mock(); given(ds2.getConnection()).willReturn(con2); @@ -502,12 +468,8 @@ public class DataSourceTransactionManagerTests { } }; - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - TransactionSynchronizationManager.registerSynchronization(synch); - } - }); + tt.executeWithoutResult(status -> + TransactionSynchronizationManager.registerSynchronization(synch)); assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); assertThat(synch.beforeCommitCalled).isTrue(); @@ -521,7 +483,7 @@ public class DataSourceTransactionManagerTests { } @Test - void testParticipatingTransactionWithRollbackOnlyAndInnerSynch() throws Exception { + void participatingTransactionWithRollbackOnlyAndInnerSynch() throws Exception { tm.setTransactionSynchronization(DataSourceTransactionManager.SYNCHRONIZATION_NEVER); DataSourceTransactionManager tm2 = createTransactionManager(ds); // tm has no synch enabled (used at outer level), tm2 has synch enabled (inner level) @@ -536,24 +498,18 @@ public class DataSourceTransactionManagerTests { assertThatExceptionOfType(UnexpectedRollbackException.class).isThrownBy(() -> { assertThat(ts.isNewTransaction()).isTrue(); TransactionTemplate tt = new TransactionTemplate(tm2); - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - assertThat(status.isNewTransaction()).isFalse(); - assertThat(status.isRollbackOnly()).isFalse(); - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - assertThat(TransactionSynchronizationManager.hasResource(ds)).isTrue(); - assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue(); - assertThat(status.isNewTransaction()).isFalse(); - status.setRollbackOnly(); - } - }); - assertThat(status.isNewTransaction()).isFalse(); - assertThat(status.isRollbackOnly()).isTrue(); - TransactionSynchronizationManager.registerSynchronization(synch); - } + tt.executeWithoutResult(status -> { + assertThat(status.isNewTransaction()).isFalse(); + assertThat(status.isRollbackOnly()).isFalse(); + tt.executeWithoutResult(status2 -> { + assertThat(TransactionSynchronizationManager.hasResource(ds)).isTrue(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue(); + assertThat(status2.isNewTransaction()).isFalse(); + status2.setRollbackOnly(); + }); + assertThat(status.isNewTransaction()).isFalse(); + assertThat(status.isRollbackOnly()).isTrue(); + TransactionSynchronizationManager.registerSynchronization(synch); }); tm.commit(ts); @@ -569,34 +525,28 @@ public class DataSourceTransactionManagerTests { } @Test - void testPropagationRequiresNewWithExistingTransaction() throws Exception { + void propagationRequiresNewWithExistingTransaction() throws Exception { TransactionTemplate tt = new TransactionTemplate(tm); tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW); assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse(); - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - assertThat(status.isNewTransaction()).isTrue(); + tt.executeWithoutResult(status -> { + assertThat(status.isNewTransaction()).isTrue(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue(); + assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse(); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + tt.executeWithoutResult(status2 -> { + assertThat(TransactionSynchronizationManager.hasResource(ds)).isTrue(); assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue(); + assertThat(status2.isNewTransaction()).isTrue(); assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse(); assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - assertThat(TransactionSynchronizationManager.hasResource(ds)).isTrue(); - assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue(); - assertThat(status.isNewTransaction()).isTrue(); - assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse(); - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); - status.setRollbackOnly(); - } - }); - assertThat(status.isNewTransaction()).isTrue(); - assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse(); - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); - } + status2.setRollbackOnly(); + }); + assertThat(status.isNewTransaction()).isTrue(); + assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse(); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); }); assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); @@ -606,7 +556,7 @@ public class DataSourceTransactionManagerTests { } @Test - void testPropagationRequiresNewWithExistingTransactionAndUnrelatedDataSource() throws Exception { + void propagationRequiresNewWithExistingTransactionAndUnrelatedDataSource() throws Exception { Connection con2 = mock(); DataSource ds2 = mock(); given(ds2.getConnection()).willReturn(con2); @@ -622,28 +572,22 @@ public class DataSourceTransactionManagerTests { assertThat(TransactionSynchronizationManager.hasResource(ds2)).isFalse(); assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse(); - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - assertThat(status.isNewTransaction()).isTrue(); + tt.executeWithoutResult(status -> { + assertThat(status.isNewTransaction()).isTrue(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue(); + assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse(); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + tt2.executeWithoutResult(status2 -> { + assertThat(TransactionSynchronizationManager.hasResource(ds)).isTrue(); assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue(); + assertThat(status2.isNewTransaction()).isTrue(); assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse(); assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); - tt2.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - assertThat(TransactionSynchronizationManager.hasResource(ds)).isTrue(); - assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue(); - assertThat(status.isNewTransaction()).isTrue(); - assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse(); - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); - status.setRollbackOnly(); - } - }); - assertThat(status.isNewTransaction()).isTrue(); - assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse(); - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); - } + status2.setRollbackOnly(); + }); + assertThat(status.isNewTransaction()).isTrue(); + assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse(); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); }); assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); @@ -655,7 +599,7 @@ public class DataSourceTransactionManagerTests { } @Test - void testPropagationRequiresNewWithExistingTransactionAndUnrelatedFailingDataSource() throws Exception { + void propagationRequiresNewWithExistingTransactionAndUnrelatedFailingDataSource() throws Exception { DataSource ds2 = mock(); SQLException failure = new SQLException(); given(ds2.getConnection()).willThrow(failure); @@ -673,24 +617,16 @@ public class DataSourceTransactionManagerTests { assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse(); assertThatExceptionOfType(CannotCreateTransactionException.class).isThrownBy(() -> - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue(); - assertThat(status.hasTransaction()).isTrue(); - assertThat(status.isNewTransaction()).isTrue(); - assertThat(status.isNested()).isFalse(); - assertThat(status.isReadOnly()).isFalse(); - assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse(); - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); - tt2.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - status.setRollbackOnly(); - } - }); - } - })).withCause(failure); + tt.executeWithoutResult(status -> { + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue(); + assertThat(status.hasTransaction()).isTrue(); + assertThat(status.isNewTransaction()).isTrue(); + assertThat(status.isNested()).isFalse(); + assertThat(status.isReadOnly()).isFalse(); + assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse(); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + tt2.executeWithoutResult(status2 -> status2.setRollbackOnly()); + })).withCause(failure); assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); assertThat(TransactionSynchronizationManager.hasResource(ds2)).isFalse(); @@ -699,39 +635,33 @@ public class DataSourceTransactionManagerTests { } @Test - void testPropagationNotSupportedWithExistingTransaction() throws Exception { + void propagationNotSupportedWithExistingTransaction() throws Exception { TransactionTemplate tt = new TransactionTemplate(tm); tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW); assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse(); - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - assertThat(status.hasTransaction()).isTrue(); - assertThat(status.isNewTransaction()).isTrue(); - assertThat(status.isNested()).isFalse(); + tt.executeWithoutResult(status -> { + assertThat(status.hasTransaction()).isTrue(); + assertThat(status.isNewTransaction()).isTrue(); + assertThat(status.isNested()).isFalse(); + assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse(); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NOT_SUPPORTED); + tt.executeWithoutResult(status2 -> { + assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue(); + assertThat(status2.hasTransaction()).isFalse(); + assertThat(status2.isNewTransaction()).isFalse(); + assertThat(status2.isNested()).isFalse(); + assertThat(status2.isReadOnly()).isFalse(); assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse(); - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); - tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NOT_SUPPORTED); - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); - assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue(); - assertThat(status.hasTransaction()).isFalse(); - assertThat(status.isNewTransaction()).isFalse(); - assertThat(status.isNested()).isFalse(); - assertThat(status.isReadOnly()).isFalse(); - assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse(); - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); - status.setRollbackOnly(); - } - }); - assertThat(status.isNewTransaction()).isTrue(); - assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse(); - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); - } + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); + status2.setRollbackOnly(); + }); + assertThat(status.isNewTransaction()).isTrue(); + assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse(); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); }); assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); @@ -740,28 +670,21 @@ public class DataSourceTransactionManagerTests { } @Test - void testPropagationNeverWithExistingTransaction() throws Exception { + void propagationNeverWithExistingTransaction() throws Exception { TransactionTemplate tt = new TransactionTemplate(tm); tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW); assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse(); assertThatExceptionOfType(IllegalTransactionStateException.class).isThrownBy(() -> - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - assertThat(status.hasTransaction()).isTrue(); - assertThat(status.isNewTransaction()).isTrue(); - assertThat(status.isNested()).isFalse(); - tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NEVER); - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - fail("Should have thrown IllegalTransactionStateException"); - } - }); - fail("Should have thrown IllegalTransactionStateException"); - } + tt.executeWithoutResult(status -> { + assertThat(status.hasTransaction()).isTrue(); + assertThat(status.isNewTransaction()).isTrue(); + assertThat(status.isNested()).isFalse(); + tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NEVER); + tt.executeWithoutResult(status2 -> + fail("Should have thrown IllegalTransactionStateException")); + fail("Should have thrown IllegalTransactionStateException"); })); assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); @@ -770,34 +693,28 @@ public class DataSourceTransactionManagerTests { } @Test - void testPropagationSupportsAndRequiresNew() throws Exception { + void propagationSupportsAndRequiresNew() throws Exception { TransactionTemplate tt = new TransactionTemplate(tm); tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS); assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse(); - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { + tt.executeWithoutResult(status -> { + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue(); + assertThat(status.hasTransaction()).isFalse(); + assertThat(status.isNewTransaction()).isFalse(); + assertThat(status.isNested()).isFalse(); + TransactionTemplate tt2 = new TransactionTemplate(tm); + tt2.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW); + tt2.executeWithoutResult(status2 -> { + assertThat(TransactionSynchronizationManager.hasResource(ds)).isTrue(); assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue(); - assertThat(status.hasTransaction()).isFalse(); - assertThat(status.isNewTransaction()).isFalse(); - assertThat(status.isNested()).isFalse(); - TransactionTemplate tt2 = new TransactionTemplate(tm); - tt2.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW); - tt2.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - assertThat(TransactionSynchronizationManager.hasResource(ds)).isTrue(); - assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue(); - assertThat(status.hasTransaction()).isTrue(); - assertThat(status.isNewTransaction()).isTrue(); - assertThat(status.isNested()).isFalse(); - assertThat(DataSourceUtils.getConnection(ds)).isSameAs(con); - assertThat(DataSourceUtils.getConnection(ds)).isSameAs(con); - } - }); - } + assertThat(status2.hasTransaction()).isTrue(); + assertThat(status2.isNewTransaction()).isTrue(); + assertThat(status2.isNested()).isFalse(); + assertThat(DataSourceUtils.getConnection(ds)).isSameAs(con); + assertThat(DataSourceUtils.getConnection(ds)).isSameAs(con); + }); }); assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); @@ -806,7 +723,7 @@ public class DataSourceTransactionManagerTests { } @Test - void testPropagationSupportsAndRequiresNewWithEarlyAccess() throws Exception { + void propagationSupportsAndRequiresNewWithEarlyAccess() throws Exception { Connection con1 = mock(); Connection con2 = mock(); given(ds.getConnection()).willReturn(con1, con2); @@ -816,31 +733,25 @@ public class DataSourceTransactionManagerTests { assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse(); - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { + tt.executeWithoutResult(status -> { + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue(); + assertThat(DataSourceUtils.getConnection(ds)).isSameAs(con1); + assertThat(DataSourceUtils.getConnection(ds)).isSameAs(con1); + assertThat(status.hasTransaction()).isFalse(); + assertThat(status.isNewTransaction()).isFalse(); + assertThat(status.isNested()).isFalse(); + TransactionTemplate tt2 = new TransactionTemplate(tm); + tt2.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW); + tt2.executeWithoutResult(status2 -> { + assertThat(TransactionSynchronizationManager.hasResource(ds)).isTrue(); assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue(); - assertThat(DataSourceUtils.getConnection(ds)).isSameAs(con1); - assertThat(DataSourceUtils.getConnection(ds)).isSameAs(con1); - assertThat(status.hasTransaction()).isFalse(); - assertThat(status.isNewTransaction()).isFalse(); - assertThat(status.isNested()).isFalse(); - TransactionTemplate tt2 = new TransactionTemplate(tm); - tt2.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW); - tt2.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - assertThat(TransactionSynchronizationManager.hasResource(ds)).isTrue(); - assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue(); - assertThat(DataSourceUtils.getConnection(ds)).isSameAs(con2); - assertThat(DataSourceUtils.getConnection(ds)).isSameAs(con2); - assertThat(status.hasTransaction()).isTrue(); - assertThat(status.isNewTransaction()).isTrue(); - assertThat(status.isNested()).isFalse(); - } - }); - assertThat(DataSourceUtils.getConnection(ds)).isSameAs(con1); - } + assertThat(DataSourceUtils.getConnection(ds)).isSameAs(con2); + assertThat(DataSourceUtils.getConnection(ds)).isSameAs(con2); + assertThat(status2.hasTransaction()).isTrue(); + assertThat(status2.isNewTransaction()).isTrue(); + assertThat(status2.isNested()).isFalse(); + }); + assertThat(DataSourceUtils.getConnection(ds)).isSameAs(con1); }); assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); @@ -850,7 +761,7 @@ public class DataSourceTransactionManagerTests { } @Test - void testTransactionWithIsolationAndReadOnly() throws Exception { + void transactionWithIsolationAndReadOnly() throws Exception { given(con.getTransactionIsolation()).willReturn(Connection.TRANSACTION_READ_UNCOMMITTED); given(con.getAutoCommit()).willReturn(true); @@ -871,7 +782,7 @@ public class DataSourceTransactionManagerTests { } @Test - void testTransactionWithEnforceReadOnly() throws Exception { + void transactionWithEnforceReadOnly() throws Exception { tm.setEnforceReadOnly(true); given(con.getAutoCommit()).willReturn(true); @@ -895,7 +806,7 @@ public class DataSourceTransactionManagerTests { } @Test - void testTransactionWithLazyConnectionDataSourceAndStatement() throws Exception { + void transactionWithLazyConnectionDataSourceAndStatement() throws Exception { LazyConnectionDataSourceProxy dsProxy = new LazyConnectionDataSourceProxy(); dsProxy.setTargetDataSource(ds); dsProxy.setDefaultAutoCommit(true); @@ -918,7 +829,7 @@ public class DataSourceTransactionManagerTests { } @Test - void testTransactionWithLazyConnectionDataSourceNoStatement() { + void transactionWithLazyConnectionDataSourceNoStatement() { LazyConnectionDataSourceProxy dsProxy = new LazyConnectionDataSourceProxy(); dsProxy.setTargetDataSource(ds); dsProxy.setDefaultAutoCommit(true); @@ -931,7 +842,7 @@ public class DataSourceTransactionManagerTests { } @Test - void testTransactionWithReadOnlyDataSourceAndStatement() throws Exception { + void transactionWithReadOnlyDataSourceAndStatement() throws Exception { LazyConnectionDataSourceProxy dsProxy = new LazyConnectionDataSourceProxy(); dsProxy.setReadOnlyDataSource(ds); dsProxy.setDefaultAutoCommit(false); @@ -950,7 +861,7 @@ public class DataSourceTransactionManagerTests { } @Test - void testTransactionWithReadOnlyDataSourceNoStatement() { + void transactionWithReadOnlyDataSourceNoStatement() { LazyConnectionDataSourceProxy dsProxy = new LazyConnectionDataSourceProxy(); dsProxy.setReadOnlyDataSource(ds); dsProxy.setDefaultAutoCommit(false); @@ -971,27 +882,24 @@ public class DataSourceTransactionManagerTests { assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) { - // something transactional - assertThat(status.getTransactionName()).isEqualTo("my-transaction"); - assertThat(status.hasTransaction()).isTrue(); - assertThat(status.isNewTransaction()).isTrue(); - assertThat(status.isNested()).isFalse(); - assertThat(status.hasSavepoint()).isFalse(); - assertThat(status.isReadOnly()).isTrue(); - assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isTrue(); - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); - assertThat(status.isRollbackOnly()).isFalse(); - assertThat(status.isCompleted()).isFalse(); - if (withStatement) { - try { - DataSourceUtils.getConnection(tm.getDataSource()).createStatement(); - } - catch (SQLException ex) { - throw new IllegalStateException(ex); - } + tt.executeWithoutResult(status -> { + // something transactional + assertThat(status.getTransactionName()).isEqualTo("my-transaction"); + assertThat(status.hasTransaction()).isTrue(); + assertThat(status.isNewTransaction()).isTrue(); + assertThat(status.isNested()).isFalse(); + assertThat(status.hasSavepoint()).isFalse(); + assertThat(status.isReadOnly()).isTrue(); + assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isTrue(); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + assertThat(status.isRollbackOnly()).isFalse(); + assertThat(status.isCompleted()).isFalse(); + if (withStatement) { + try { + DataSourceUtils.getConnection(tm.getDataSource()).createStatement(); + } + catch (SQLException ex) { + throw new IllegalStateException(ex); } } }); @@ -1012,22 +920,19 @@ public class DataSourceTransactionManagerTests { assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); try { - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) { - try { - Thread.sleep(1500); - } - catch (InterruptedException ex) { - } - try { - Connection con = DataSourceUtils.getConnection(ds); - PreparedStatement ps = con.prepareStatement("some SQL statement"); - DataSourceUtils.applyTransactionTimeout(ps, ds); - } - catch (SQLException ex) { - throw new DataAccessResourceFailureException("", ex); - } + tt.executeWithoutResult(status -> { + try { + Thread.sleep(1500); + } + catch (InterruptedException ex) { + } + try { + Connection con = DataSourceUtils.getConnection(ds); + PreparedStatement ps2 = con.prepareStatement("some SQL statement"); + DataSourceUtils.applyTransactionTimeout(ps2, ds); + } + catch (SQLException ex) { + throw new DataAccessResourceFailureException("", ex); } }); if (timeout <= 1) { @@ -1058,29 +963,26 @@ public class DataSourceTransactionManagerTests { } @Test - void testTransactionAwareDataSourceProxy() throws Exception { + void transactionAwareDataSourceProxy() throws Exception { given(con.getAutoCommit()).willReturn(true); given(con.getWarnings()).willThrow(new SQLException()); TransactionTemplate tt = new TransactionTemplate(tm); assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) { - // something transactional - assertThat(DataSourceUtils.getConnection(ds)).isEqualTo(con); - TransactionAwareDataSourceProxy dsProxy = new TransactionAwareDataSourceProxy(ds); - try { - Connection tCon = dsProxy.getConnection(); - tCon.getWarnings(); - tCon.clearWarnings(); - assertThat(((ConnectionProxy) tCon).getTargetConnection()).isEqualTo(con); - // should be ignored - tCon.close(); - } - catch (SQLException ex) { - throw new UncategorizedSQLException("", "", ex); - } + tt.executeWithoutResult(status -> { + // something transactional + assertThat(DataSourceUtils.getConnection(ds)).isEqualTo(con); + TransactionAwareDataSourceProxy dsProxy = new TransactionAwareDataSourceProxy(ds); + try { + Connection tCon = dsProxy.getConnection(); + tCon.getWarnings(); + tCon.clearWarnings(); + assertThat(((ConnectionProxy) tCon).getTargetConnection()).isEqualTo(con); + // should be ignored + tCon.close(); + } + catch (SQLException ex) { + throw new UncategorizedSQLException("", "", ex); } }); @@ -1093,30 +995,27 @@ public class DataSourceTransactionManagerTests { } @Test - void testTransactionAwareDataSourceProxyWithLazyFalse() throws Exception { + void transactionAwareDataSourceProxyWithLazyFalse() throws Exception { given(con.getAutoCommit()).willReturn(true); given(con.getWarnings()).willThrow(new SQLException()); TransactionTemplate tt = new TransactionTemplate(tm); assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) { - // something transactional - assertThat(DataSourceUtils.getConnection(ds)).isEqualTo(con); - TransactionAwareDataSourceProxy dsProxy = new TransactionAwareDataSourceProxy(ds); - dsProxy.setLazyTransactionalConnections(false); - try { - Connection tCon = dsProxy.getConnection(); - assertThatExceptionOfType(SQLException.class).isThrownBy(tCon::getWarnings); - tCon.clearWarnings(); - assertThat(((ConnectionProxy) tCon).getTargetConnection()).isEqualTo(con); - // should be ignored - tCon.close(); - } - catch (SQLException ex) { - throw new UncategorizedSQLException("", "", ex); - } + tt.executeWithoutResult(status -> { + // something transactional + assertThat(DataSourceUtils.getConnection(ds)).isEqualTo(con); + TransactionAwareDataSourceProxy dsProxy = new TransactionAwareDataSourceProxy(ds); + dsProxy.setLazyTransactionalConnections(false); + try { + Connection tCon = dsProxy.getConnection(); + assertThatExceptionOfType(SQLException.class).isThrownBy(tCon::getWarnings); + tCon.clearWarnings(); + assertThat(((ConnectionProxy) tCon).getTargetConnection()).isEqualTo(con); + // should be ignored + tCon.close(); + } + catch (SQLException ex) { + throw new UncategorizedSQLException("", "", ex); } }); @@ -1129,7 +1028,7 @@ public class DataSourceTransactionManagerTests { } @Test - void testTransactionAwareDataSourceProxyWithEarlyConnection() throws Exception { + void transactionAwareDataSourceProxyWithEarlyConnection() throws Exception { given(ds.getConnection()).willReturn(mock(Connection.class), con); given(con.getAutoCommit()).willReturn(true); given(con.getWarnings()).willThrow(new SQLException()); @@ -1140,18 +1039,15 @@ public class DataSourceTransactionManagerTests { TransactionTemplate tt = new TransactionTemplate(tm); assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) { - // something transactional - assertThat(DataSourceUtils.getConnection(ds)).isEqualTo(con); - try { - // should close the early Connection obtained before the transaction - tCon.close(); - } - catch (SQLException ex) { - throw new UncategorizedSQLException("", "", ex); - } + tt.executeWithoutResult(status -> { + // something transactional + assertThat(DataSourceUtils.getConnection(ds)).isEqualTo(con); + try { + // should close the early Connection obtained before the transaction + tCon.close(); + } + catch (SQLException ex) { + throw new UncategorizedSQLException("", "", ex); } }); @@ -1165,19 +1061,29 @@ public class DataSourceTransactionManagerTests { } @Test - void testTransactionAwareDataSourceProxyWithSuspension() throws Exception { + void transactionAwareDataSourceProxyWithSuspension() throws Exception { given(con.getAutoCommit()).willReturn(true); TransactionTemplate tt = new TransactionTemplate(tm); tt.setPropagationBehavior(TransactionTemplate.PROPAGATION_REQUIRES_NEW); assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) { + tt.executeWithoutResult(status -> { + // something transactional + assertThat(DataSourceUtils.getConnection(ds)).isEqualTo(con); + TransactionAwareDataSourceProxy dsProxy = new TransactionAwareDataSourceProxy(ds); + try { + assertThat(((ConnectionProxy) dsProxy.getConnection()).getTargetConnection()).isEqualTo(con); + // should be ignored + dsProxy.getConnection().close(); + } + catch (SQLException ex) { + throw new UncategorizedSQLException("", "", ex); + } + + tt.executeWithoutResult(status2 -> { // something transactional assertThat(DataSourceUtils.getConnection(ds)).isEqualTo(con); - TransactionAwareDataSourceProxy dsProxy = new TransactionAwareDataSourceProxy(ds); try { assertThat(((ConnectionProxy) dsProxy.getConnection()).getTargetConnection()).isEqualTo(con); // should be ignored @@ -1186,31 +1092,15 @@ public class DataSourceTransactionManagerTests { catch (SQLException ex) { throw new UncategorizedSQLException("", "", ex); } + }); - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) { - // something transactional - assertThat(DataSourceUtils.getConnection(ds)).isEqualTo(con); - try { - assertThat(((ConnectionProxy) dsProxy.getConnection()).getTargetConnection()).isEqualTo(con); - // should be ignored - dsProxy.getConnection().close(); - } - catch (SQLException ex) { - throw new UncategorizedSQLException("", "", ex); - } - } - }); - - try { - assertThat(((ConnectionProxy) dsProxy.getConnection()).getTargetConnection()).isEqualTo(con); - // should be ignored - dsProxy.getConnection().close(); - } - catch (SQLException ex) { - throw new UncategorizedSQLException("", "", ex); - } + try { + assertThat(((ConnectionProxy) dsProxy.getConnection()).getTargetConnection()).isEqualTo(con); + // should be ignored + dsProxy.getConnection().close(); + } + catch (SQLException ex) { + throw new UncategorizedSQLException("", "", ex); } }); @@ -1223,20 +1113,30 @@ public class DataSourceTransactionManagerTests { } @Test - void testTransactionAwareDataSourceProxyWithSuspensionAndReobtaining() throws Exception { + void transactionAwareDataSourceProxyWithSuspensionAndReobtaining() throws Exception { given(con.getAutoCommit()).willReturn(true); TransactionTemplate tt = new TransactionTemplate(tm); tt.setPropagationBehavior(TransactionTemplate.PROPAGATION_REQUIRES_NEW); assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) { + tt.executeWithoutResult(status -> { + // something transactional + assertThat(DataSourceUtils.getConnection(ds)).isEqualTo(con); + TransactionAwareDataSourceProxy dsProxy = new TransactionAwareDataSourceProxy(ds); + dsProxy.setReobtainTransactionalConnections(true); + try { + assertThat(((ConnectionProxy) dsProxy.getConnection()).getTargetConnection()).isEqualTo(con); + // should be ignored + dsProxy.getConnection().close(); + } + catch (SQLException ex) { + throw new UncategorizedSQLException("", "", ex); + } + + tt.executeWithoutResult(status2 -> { // something transactional assertThat(DataSourceUtils.getConnection(ds)).isEqualTo(con); - TransactionAwareDataSourceProxy dsProxy = new TransactionAwareDataSourceProxy(ds); - dsProxy.setReobtainTransactionalConnections(true); try { assertThat(((ConnectionProxy) dsProxy.getConnection()).getTargetConnection()).isEqualTo(con); // should be ignored @@ -1245,31 +1145,15 @@ public class DataSourceTransactionManagerTests { catch (SQLException ex) { throw new UncategorizedSQLException("", "", ex); } + }); - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) { - // something transactional - assertThat(DataSourceUtils.getConnection(ds)).isEqualTo(con); - try { - assertThat(((ConnectionProxy) dsProxy.getConnection()).getTargetConnection()).isEqualTo(con); - // should be ignored - dsProxy.getConnection().close(); - } - catch (SQLException ex) { - throw new UncategorizedSQLException("", "", ex); - } - } - }); - - try { - assertThat(((ConnectionProxy) dsProxy.getConnection()).getTargetConnection()).isEqualTo(con); - // should be ignored - dsProxy.getConnection().close(); - } - catch (SQLException ex) { - throw new UncategorizedSQLException("", "", ex); - } + try { + assertThat(((ConnectionProxy) dsProxy.getConnection()).getTargetConnection()).isEqualTo(con); + // should be ignored + dsProxy.getConnection().close(); + } + catch (SQLException ex) { + throw new UncategorizedSQLException("", "", ex); } }); @@ -1285,16 +1169,13 @@ public class DataSourceTransactionManagerTests { * Test behavior if the first operation on a connection (getAutoCommit) throws SQLException. */ @Test - void testTransactionWithExceptionOnBegin() throws Exception { + void transactionWithExceptionOnBegin() throws Exception { willThrow(new SQLException("Cannot begin")).given(con).getAutoCommit(); TransactionTemplate tt = new TransactionTemplate(tm); assertThatExceptionOfType(CannotCreateTransactionException.class).isThrownBy(() -> - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) { - // something transactional - } + tt.executeWithoutResult(status -> { + // something transactional })); assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); @@ -1302,16 +1183,13 @@ public class DataSourceTransactionManagerTests { } @Test - protected void testTransactionWithExceptionOnCommit() throws Exception { + protected void transactionWithExceptionOnCommit() throws Exception { willThrow(new SQLException("Cannot commit")).given(con).commit(); TransactionTemplate tt = new TransactionTemplate(tm); assertThatExceptionOfType(TransactionSystemException.class).isThrownBy(() -> - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) { - // something transactional - } + tt.executeWithoutResult(status -> { + // something transactional })); assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); @@ -1319,17 +1197,14 @@ public class DataSourceTransactionManagerTests { } @Test - protected void testTransactionWithExceptionOnCommitAndRollbackOnCommitFailure() throws Exception { + protected void transactionWithExceptionOnCommitAndRollbackOnCommitFailure() throws Exception { willThrow(new SQLException("Cannot commit")).given(con).commit(); tm.setRollbackOnCommitFailure(true); TransactionTemplate tt = new TransactionTemplate(tm); assertThatExceptionOfType(TransactionSystemException.class).isThrownBy(() -> - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) { - // something transactional - } + tt.executeWithoutResult(status -> { + // something transactional })); assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); @@ -1338,26 +1213,23 @@ public class DataSourceTransactionManagerTests { } @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); assertThatExceptionOfType(TransactionSystemException.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(); @@ -1369,65 +1241,56 @@ public class DataSourceTransactionManagerTests { } @Test - void testTransactionWithPropagationSupports() { + void transactionWithPropagationSupports() { TransactionTemplate tt = new TransactionTemplate(tm); tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS); assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); - assertThat(status.isNewTransaction()).isFalse(); - assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse(); - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); - } + tt.executeWithoutResult(status -> { + assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); + assertThat(status.isNewTransaction()).isFalse(); + assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse(); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); }); assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); } @Test - void testTransactionWithPropagationNotSupported() { + void transactionWithPropagationNotSupported() { TransactionTemplate tt = new TransactionTemplate(tm); tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NOT_SUPPORTED); assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); - assertThat(status.isNewTransaction()).isFalse(); - } + tt.executeWithoutResult(status -> { + assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); + assertThat(status.isNewTransaction()).isFalse(); }); assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); } @Test - void testTransactionWithPropagationNever() { + void transactionWithPropagationNever() { TransactionTemplate tt = new TransactionTemplate(tm); tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NEVER); assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); - assertThat(status.isNewTransaction()).isFalse(); - } + tt.executeWithoutResult(status -> { + assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); + assertThat(status.isNewTransaction()).isFalse(); }); assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); } @Test - void testExistingTransactionWithPropagationNested() throws Exception { + void existingTransactionWithPropagationNested() throws Exception { doTestExistingTransactionWithPropagationNested(1); } @Test - void testExistingTransactionWithPropagationNestedTwice() throws Exception { + void existingTransactionWithPropagationNestedTwice() throws Exception { doTestExistingTransactionWithPropagationNested(2); } @@ -1446,36 +1309,30 @@ public class DataSourceTransactionManagerTests { assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse(); - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - assertThat(status.hasTransaction()).isTrue(); - assertThat(status.isNewTransaction()).isTrue(); - assertThat(status.isNested()).isFalse(); - assertThat(status.hasSavepoint()).isFalse(); - TestSavepointSynchronization synch = new TestSavepointSynchronization(); - TransactionSynchronizationManager.registerSynchronization(synch); - for (int i = 0; i < count; i++) { - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - assertThat(TransactionSynchronizationManager.hasResource(ds)).isTrue(); - assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue(); - assertThat(status.hasTransaction()).isTrue(); - assertThat(status.isNewTransaction()).isFalse(); - assertThat(status.isNested()).isTrue(); - assertThat(status.hasSavepoint()).isTrue(); - assertThat(synch.savepointCalled).isTrue(); - } - }); - assertThat(synch.savepointRollbackCalled).isFalse(); - synch.savepointCalled = false; - } - assertThat(status.hasTransaction()).isTrue(); - assertThat(status.isNewTransaction()).isTrue(); - assertThat(status.isNested()).isFalse(); - assertThat(status.hasSavepoint()).isFalse(); + tt.executeWithoutResult(status -> { + assertThat(status.hasTransaction()).isTrue(); + assertThat(status.isNewTransaction()).isTrue(); + assertThat(status.isNested()).isFalse(); + assertThat(status.hasSavepoint()).isFalse(); + TestSavepointSynchronization synch = new TestSavepointSynchronization(); + TransactionSynchronizationManager.registerSynchronization(synch); + for (int i = 0; i < count; i++) { + tt.executeWithoutResult(status2 -> { + assertThat(TransactionSynchronizationManager.hasResource(ds)).isTrue(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue(); + assertThat(status2.hasTransaction()).isTrue(); + assertThat(status2.isNewTransaction()).isFalse(); + assertThat(status2.isNested()).isTrue(); + assertThat(status2.hasSavepoint()).isTrue(); + assertThat(synch.savepointCalled).isTrue(); + }); + assertThat(synch.savepointRollbackCalled).isFalse(); + synch.savepointCalled = false; } + assertThat(status.hasTransaction()).isTrue(); + assertThat(status.isNewTransaction()).isTrue(); + assertThat(status.isNested()).isFalse(); + assertThat(status.hasSavepoint()).isFalse(); }); assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); @@ -1485,7 +1342,7 @@ public class DataSourceTransactionManagerTests { } @Test - void testExistingTransactionWithPropagationNestedAndRollback() throws Exception { + void existingTransactionWithPropagationNestedAndRollback() throws Exception { DatabaseMetaData md = mock(); Savepoint sp = mock(); @@ -1498,165 +1355,85 @@ public class DataSourceTransactionManagerTests { assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse(); - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - assertThat(status.hasTransaction()).isTrue(); - assertThat(status.isNewTransaction()).isTrue(); - assertThat(status.isNested()).isFalse(); - assertThat(status.hasSavepoint()).isFalse(); - TestSavepointSynchronization synch = new TestSavepointSynchronization(); - TransactionSynchronizationManager.registerSynchronization(synch); - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { + tt.executeWithoutResult(status -> { + assertThat(status.hasTransaction()).isTrue(); + assertThat(status.isNewTransaction()).isTrue(); + assertThat(status.isNested()).isFalse(); + assertThat(status.hasSavepoint()).isFalse(); + TestSavepointSynchronization synch = new TestSavepointSynchronization(); + TransactionSynchronizationManager.registerSynchronization(synch); + tt.executeWithoutResult(status2 -> { + assertThat(TransactionSynchronizationManager.hasResource(ds)).isTrue(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue(); + assertThat(status2.hasTransaction()).isTrue(); + assertThat(status2.isNewTransaction()).isFalse(); + assertThat(status2.isNested()).isTrue(); + assertThat(status2.hasSavepoint()).isTrue(); + assertThat(synch.savepointCalled).isTrue(); + assertThat(synch.savepointRollbackCalled).isFalse(); + status2.setRollbackOnly(); + }); + assertThat(synch.savepointRollbackCalled).isTrue(); + assertThat(status.hasTransaction()).isTrue(); + assertThat(status.isNewTransaction()).isTrue(); + assertThat(status.isNested()).isFalse(); + assertThat(status.hasSavepoint()).isFalse(); + }); + + assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); + verify(con).rollback(sp); + verify(con).releaseSavepoint(sp); + verify(con).commit(); + verify(con).close(); + } + + @Test + void existingTransactionWithPropagationNestedAndRequiredRollback() throws Exception { + DatabaseMetaData md = mock(); + Savepoint sp = mock(); + + given(md.supportsSavepoints()).willReturn(true); + given(con.getMetaData()).willReturn(md); + given(con.setSavepoint("SAVEPOINT_1")).willReturn(sp); + + TransactionTemplate tt = new TransactionTemplate(tm); + tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED); + assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse(); + + tt.executeWithoutResult(status -> { + assertThat(status.hasTransaction()).isTrue(); + assertThat(status.isNewTransaction()).isTrue(); + assertThat(status.isNested()).isFalse(); + assertThat(status.hasSavepoint()).isFalse(); + TestSavepointSynchronization synch = new TestSavepointSynchronization(); + TransactionSynchronizationManager.registerSynchronization(synch); + assertThatIllegalStateException().isThrownBy(() -> + tt.executeWithoutResult(status2 -> { assertThat(TransactionSynchronizationManager.hasResource(ds)).isTrue(); assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue(); - assertThat(status.hasTransaction()).isTrue(); - assertThat(status.isNewTransaction()).isFalse(); - assertThat(status.isNested()).isTrue(); - assertThat(status.hasSavepoint()).isTrue(); + assertThat(status2.hasTransaction()).isTrue(); + assertThat(status2.isNewTransaction()).isFalse(); + assertThat(status2.isNested()).isTrue(); + assertThat(status2.hasSavepoint()).isTrue(); assertThat(synch.savepointCalled).isTrue(); assertThat(synch.savepointRollbackCalled).isFalse(); - status.setRollbackOnly(); - } - }); - assertThat(synch.savepointRollbackCalled).isTrue(); - assertThat(status.hasTransaction()).isTrue(); - assertThat(status.isNewTransaction()).isTrue(); - assertThat(status.isNested()).isFalse(); - assertThat(status.hasSavepoint()).isFalse(); - } - }); - - assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); - verify(con).rollback(sp); - verify(con).releaseSavepoint(sp); - verify(con).commit(); - verify(con).close(); - } - - @Test - void testExistingTransactionWithPropagationNestedAndRequiredRollback() throws Exception { - DatabaseMetaData md = mock(); - Savepoint sp = mock(); - - given(md.supportsSavepoints()).willReturn(true); - given(con.getMetaData()).willReturn(md); - given(con.setSavepoint("SAVEPOINT_1")).willReturn(sp); - - TransactionTemplate tt = new TransactionTemplate(tm); - tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED); - assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); - assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse(); - - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - assertThat(status.hasTransaction()).isTrue(); - assertThat(status.isNewTransaction()).isTrue(); - assertThat(status.isNested()).isFalse(); - assertThat(status.hasSavepoint()).isFalse(); - TestSavepointSynchronization synch = new TestSavepointSynchronization(); - TransactionSynchronizationManager.registerSynchronization(synch); - assertThatIllegalStateException().isThrownBy(() -> - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - assertThat(TransactionSynchronizationManager.hasResource(ds)).isTrue(); - assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue(); - assertThat(status.hasTransaction()).isTrue(); - assertThat(status.isNewTransaction()).isFalse(); - assertThat(status.isNested()).isTrue(); - assertThat(status.hasSavepoint()).isTrue(); - assertThat(synch.savepointCalled).isTrue(); - assertThat(synch.savepointRollbackCalled).isFalse(); - TransactionTemplate ntt = new TransactionTemplate(tm); - ntt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - assertThat(TransactionSynchronizationManager.hasResource(ds)).isTrue(); - assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue(); - assertThat(status.hasTransaction()).isTrue(); - assertThat(status.isNewTransaction()).isFalse(); - assertThat(status.isNested()).isFalse(); - assertThat(status.hasSavepoint()).isFalse(); - throw new IllegalStateException(); - } - }); - } - })); - assertThat(synch.savepointRollbackCalled).isTrue(); - assertThat(status.hasTransaction()).isTrue(); - assertThat(status.isNewTransaction()).isTrue(); - assertThat(status.isNested()).isFalse(); - assertThat(status.hasSavepoint()).isFalse(); - } - }); - - assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); - verify(con).rollback(sp); - verify(con).releaseSavepoint(sp); - verify(con).commit(); - verify(con).close(); - } - - @Test - void testExistingTransactionWithPropagationNestedAndRequiredRollbackOnly() throws Exception { - DatabaseMetaData md = mock(); - Savepoint sp = mock(); - - given(md.supportsSavepoints()).willReturn(true); - given(con.getMetaData()).willReturn(md); - given(con.setSavepoint("SAVEPOINT_1")).willReturn(sp); - - TransactionTemplate tt = new TransactionTemplate(tm); - tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED); - assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); - assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse(); - - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - assertThat(status.hasTransaction()).isTrue(); - assertThat(status.isNewTransaction()).isTrue(); - assertThat(status.isNested()).isFalse(); - assertThat(status.hasSavepoint()).isFalse(); - TestSavepointSynchronization synch = new TestSavepointSynchronization(); - TransactionSynchronizationManager.registerSynchronization(synch); - assertThatExceptionOfType(UnexpectedRollbackException.class).isThrownBy(() -> - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { + TransactionTemplate ntt = new TransactionTemplate(tm); + ntt.executeWithoutResult(status3 -> { assertThat(TransactionSynchronizationManager.hasResource(ds)).isTrue(); assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue(); - assertThat(status.hasTransaction()).isTrue(); - assertThat(status.isNewTransaction()).isFalse(); - assertThat(status.isNested()).isTrue(); - assertThat(status.hasSavepoint()).isTrue(); - assertThat(synch.savepointCalled).isTrue(); - assertThat(synch.savepointRollbackCalled).isFalse(); - TransactionTemplate ntt = new TransactionTemplate(tm); - ntt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - assertThat(TransactionSynchronizationManager.hasResource(ds)).isTrue(); - assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue(); - assertThat(status.hasTransaction()).isTrue(); - assertThat(status.isNewTransaction()).isFalse(); - assertThat(status.isNested()).isFalse(); - assertThat(status.hasSavepoint()).isFalse(); - status.setRollbackOnly(); - } - }); - } + assertThat(status3.hasTransaction()).isTrue(); + assertThat(status3.isNewTransaction()).isFalse(); + assertThat(status3.isNested()).isFalse(); + assertThat(status3.hasSavepoint()).isFalse(); + throw new IllegalStateException(); + }); })); assertThat(synch.savepointRollbackCalled).isTrue(); - assertThat(status.hasTransaction()).isTrue(); - assertThat(status.isNewTransaction()).isTrue(); - assertThat(status.isNested()).isFalse(); - assertThat(status.hasSavepoint()).isFalse(); - } + assertThat(status.hasTransaction()).isTrue(); + assertThat(status.isNewTransaction()).isTrue(); + assertThat(status.isNested()).isFalse(); + assertThat(status.hasSavepoint()).isFalse(); }); assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); @@ -1667,7 +1444,7 @@ public class DataSourceTransactionManagerTests { } @Test - void testExistingTransactionWithManualSavepoint() throws Exception { + void existingTransactionWithPropagationNestedAndRequiredRollbackOnly() throws Exception { DatabaseMetaData md = mock(); Savepoint sp = mock(); @@ -1680,20 +1457,73 @@ public class DataSourceTransactionManagerTests { assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse(); - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - assertThat(status.hasTransaction()).isTrue(); - assertThat(status.isNewTransaction()).isTrue(); - assertThat(status.isNested()).isFalse(); - assertThat(status.hasSavepoint()).isFalse(); - TestSavepointSynchronization synch = new TestSavepointSynchronization(); - TransactionSynchronizationManager.registerSynchronization(synch); - Object savepoint = status.createSavepoint(); - assertThat(synch.savepointCalled).isTrue(); - status.releaseSavepoint(savepoint); - assertThat(synch.savepointRollbackCalled).isFalse(); - } + tt.executeWithoutResult(status1 -> { + assertThat(status1.hasTransaction()).isTrue(); + assertThat(status1.isNewTransaction()).isTrue(); + assertThat(status1.isNested()).isFalse(); + assertThat(status1.hasSavepoint()).isFalse(); + TestSavepointSynchronization synch = new TestSavepointSynchronization(); + TransactionSynchronizationManager.registerSynchronization(synch); + assertThatExceptionOfType(UnexpectedRollbackException.class).isThrownBy(() -> + tt.executeWithoutResult(status2 -> { + assertThat(TransactionSynchronizationManager.hasResource(ds)).isTrue(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue(); + assertThat(status2.hasTransaction()).isTrue(); + assertThat(status2.isNewTransaction()).isFalse(); + assertThat(status2.isNested()).isTrue(); + assertThat(status2.hasSavepoint()).isTrue(); + assertThat(synch.savepointCalled).isTrue(); + assertThat(synch.savepointRollbackCalled).isFalse(); + TransactionTemplate ntt = new TransactionTemplate(tm); + ntt.executeWithoutResult(status3 -> { + assertThat(TransactionSynchronizationManager.hasResource(ds)).isTrue(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue(); + assertThat(status3.hasTransaction()).isTrue(); + assertThat(status3.isNewTransaction()).isFalse(); + assertThat(status3.isNested()).isFalse(); + assertThat(status3.hasSavepoint()).isFalse(); + status3.setRollbackOnly(); + }); + })); + assertThat(synch.savepointRollbackCalled).isTrue(); + assertThat(status1.hasTransaction()).isTrue(); + assertThat(status1.isNewTransaction()).isTrue(); + assertThat(status1.isNested()).isFalse(); + assertThat(status1.hasSavepoint()).isFalse(); + }); + + assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); + verify(con).rollback(sp); + verify(con).releaseSavepoint(sp); + verify(con).commit(); + verify(con).close(); + } + + @Test + void existingTransactionWithManualSavepoint() throws Exception { + DatabaseMetaData md = mock(); + Savepoint sp = mock(); + + given(md.supportsSavepoints()).willReturn(true); + given(con.getMetaData()).willReturn(md); + given(con.setSavepoint("SAVEPOINT_1")).willReturn(sp); + + TransactionTemplate tt = new TransactionTemplate(tm); + tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED); + assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); + assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse(); + + tt.executeWithoutResult(status -> { + assertThat(status.hasTransaction()).isTrue(); + assertThat(status.isNewTransaction()).isTrue(); + assertThat(status.isNested()).isFalse(); + assertThat(status.hasSavepoint()).isFalse(); + TestSavepointSynchronization synch = new TestSavepointSynchronization(); + TransactionSynchronizationManager.registerSynchronization(synch); + Object savepoint = status.createSavepoint(); + assertThat(synch.savepointCalled).isTrue(); + status.releaseSavepoint(savepoint); + assertThat(synch.savepointRollbackCalled).isFalse(); }); assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); @@ -1704,7 +1534,7 @@ public class DataSourceTransactionManagerTests { } @Test - void testExistingTransactionWithManualSavepointAndRollback() throws Exception { + void existingTransactionWithManualSavepointAndRollback() throws Exception { DatabaseMetaData md = mock(); Savepoint sp = mock(); @@ -1717,21 +1547,18 @@ public class DataSourceTransactionManagerTests { assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse(); - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException { - assertThat(status.hasTransaction()).isTrue(); - assertThat(status.isNewTransaction()).isTrue(); - assertThat(status.isNested()).isFalse(); - assertThat(status.hasSavepoint()).isFalse(); - TestSavepointSynchronization synch = new TestSavepointSynchronization(); - TransactionSynchronizationManager.registerSynchronization(synch); - Object savepoint = status.createSavepoint(); - assertThat(synch.savepointCalled).isTrue(); - assertThat(synch.savepointRollbackCalled).isFalse(); - status.rollbackToSavepoint(savepoint); - assertThat(synch.savepointRollbackCalled).isTrue(); - } + tt.executeWithoutResult(status -> { + assertThat(status.hasTransaction()).isTrue(); + assertThat(status.isNewTransaction()).isTrue(); + assertThat(status.isNested()).isFalse(); + assertThat(status.hasSavepoint()).isFalse(); + TestSavepointSynchronization synch = new TestSavepointSynchronization(); + TransactionSynchronizationManager.registerSynchronization(synch); + Object savepoint = status.createSavepoint(); + assertThat(synch.savepointCalled).isTrue(); + assertThat(synch.savepointRollbackCalled).isFalse(); + status.rollbackToSavepoint(savepoint); + assertThat(synch.savepointRollbackCalled).isTrue(); }); assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); @@ -1741,24 +1568,21 @@ public class DataSourceTransactionManagerTests { } @Test - void testTransactionWithPropagationNested() throws Exception { + void transactionWithPropagationNested() throws Exception { TransactionTemplate tt = new TransactionTemplate(tm); tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED); assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse(); - 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(); - 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(); + assertThat(status.isCompleted()).isFalse(); }); assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); @@ -1767,26 +1591,23 @@ public class DataSourceTransactionManagerTests { } @Test - void testTransactionWithPropagationNestedAndRollback() throws Exception { + void transactionWithPropagationNestedAndRollback() throws Exception { TransactionTemplate tt = new TransactionTemplate(tm); tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED); assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse(); - 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(); diff --git a/spring-jdbc/src/test/java/org/springframework/jdbc/support/JdbcTransactionManagerTests.java b/spring-jdbc/src/test/java/org/springframework/jdbc/support/JdbcTransactionManagerTests.java index 7dc516e875b..7405f622f64 100644 --- a/spring-jdbc/src/test/java/org/springframework/jdbc/support/JdbcTransactionManagerTests.java +++ b/spring-jdbc/src/test/java/org/springframework/jdbc/support/JdbcTransactionManagerTests.java @@ -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,14 @@ 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 { - 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 - } })); assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); @@ -90,17 +66,30 @@ class JdbcTransactionManagerTests extends DataSourceTransactionManagerTests { } @Test - void testTransactionWithDataAccessExceptionOnCommitFromLazyExceptionTranslator() 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.executeWithoutResult(status -> { + // something transactional + })); + + assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); + verify(con).close(); + } + + @Test + 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 { @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 { // 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 { @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,31 +135,6 @@ class JdbcTransactionManagerTests extends DataSourceTransactionManagerTests { status.setRollbackOnly(); assertThat(status.isRollbackOnly()).isTrue(); assertThat(status.isCompleted()).isFalse(); - } - })); - - assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); - InOrder ordered = inOrder(con); - ordered.verify(con).setAutoCommit(false); - ordered.verify(con).rollback(); - ordered.verify(con).setAutoCommit(true); - verify(con).close(); - } - - @Test - void testTransactionWithDataAccessExceptionOnRollback() throws Exception { - given(con.getAutoCommit()).willReturn(true); - willThrow(new SQLException("Cannot rollback")).given(con).rollback(); - ((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) throws RuntimeException { - status.setRollbackOnly(); - } })); assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); @@ -187,27 +146,43 @@ class JdbcTransactionManagerTests extends DataSourceTransactionManagerTests { } @Test - void testTransactionWithDataAccessExceptionOnRollbackFromLazyExceptionTranslator() 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)); + TransactionTemplate tt = new TransactionTemplate(tm); + + // specific ConcurrencyFailureException + assertThatExceptionOfType(ConcurrencyFailureException.class).isThrownBy(() -> + tt.executeWithoutResult(status -> status.setRollbackOnly())); + + assertThat(TransactionSynchronizationManager.hasResource(ds)).isFalse(); + InOrder ordered = inOrder(con); + ordered.verify(con).setAutoCommit(false); + ordered.verify(con).rollback(); + ordered.verify(con).setAutoCommit(true); + verify(con).close(); + } + + @Test + 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(); diff --git a/spring-tx/src/test/java/org/springframework/transaction/JndiJtaTransactionManagerTests.java b/spring-tx/src/test/java/org/springframework/transaction/JndiJtaTransactionManagerTests.java index c2e69b719af..8b4959c3e1b 100644 --- a/spring-tx/src/test/java/org/springframework/transaction/JndiJtaTransactionManagerTests.java +++ b/spring-tx/src/test/java/org/springframework/transaction/JndiJtaTransactionManagerTests.java @@ -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 { 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 { 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 { 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(); diff --git a/spring-tx/src/test/java/org/springframework/transaction/JtaTransactionManagerTests.java b/spring-tx/src/test/java/org/springframework/transaction/JtaTransactionManagerTests.java index b0b7d64f14f..a7c8d99dba2 100644 --- a/spring-tx/src/test/java/org/springframework/transaction/JtaTransactionManagerTests.java +++ b/spring-tx/src/test/java/org/springframework/transaction/JtaTransactionManagerTests.java @@ -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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { tt.setName("txName"); assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse(); - tt.execute(new TransactionCallbackWithoutResult() { - @Override - protected void doInTransactionWithoutResult(TransactionStatus status) { - 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(); - } - }); + 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(); - } + 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()).isFalse(); @@ -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(); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + }); - 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.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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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 { 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); + } + }); }); }); } diff --git a/spring-tx/src/test/java/org/springframework/transaction/support/TransactionSupportTests.java b/spring-tx/src/test/java/org/springframework/transaction/support/TransactionSupportTests.java index eebc5f52c8b..1f997b32d07 100644 --- a/spring-tx/src/test/java/org/springframework/transaction/support/TransactionSupportTests.java +++ b/spring-tx/src/test/java/org/springframework/transaction/support/TransactionSupportTests.java @@ -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 { } @Test + @SuppressWarnings("deprecation") void transactionTemplateWithCallbackPreference() { MockCallbackPreferringTransactionManager ptm = new MockCallbackPreferringTransactionManager(); TransactionTemplate template = new TransactionTemplate(ptm); @@ -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 { 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) {