From 82d0e49de96b085e8d1d2e4b9ded8e6d82cd535a Mon Sep 17 00:00:00 2001 From: Phillip Webb Date: Thu, 23 May 2019 13:51:49 -0700 Subject: [PATCH] Inline methods from TransactionTestUtils Delete `TransactionTestUtils` and inline AssertJ assertions instead. Closes gh-23022 --- .../jdbc/DataSourceOnlySqlScriptsTests.java | 6 +- .../InferredDataSourceSqlScriptsTests.java | 6 +- ...ataSourceTransactionalSqlScriptsTests.java | 6 +- .../context/jdbc/PrimaryDataSourceTests.java | 4 +- ...oreAndAfterTransactionAnnotationTests.java | 14 ++-- ...ssLevelTransactionalSpringRunnerTests.java | 6 +- ...TransactionalJUnit4SpringContextTests.java | 23 +++--- ...eRollbackAnnotationTransactionalTests.java | 4 +- ...eRollbackAnnotationTransactionalTests.java | 4 +- ...odLevelTransactionalSpringRunnerTests.java | 6 +- ...eRollbackAnnotationTransactionalTests.java | 4 +- ...efaultRollbackFalseTransactionalTests.java | 4 +- ...eRollbackAnnotationTransactionalTests.java | 4 +- ...DefaultRollbackTrueTransactionalTests.java | 4 +- .../TimedTransactionalSpringRunnerTests.java | 11 +-- .../orm/HibernateSessionFlushingTests.java | 4 +- .../TimedTransactionalSpringRuleTests.java | 7 +- ...ransactionalAnnotatedConfigClassTests.java | 9 +- ...TransactionalTestNGSpringContextTests.java | 14 ++-- ...TransactionalTestNGSpringContextTests.java | 28 +++---- ...TransactionalTestNGSpringContextTests.java | 5 +- ...TransactionalTestNGSpringContextTests.java | 7 +- .../ProgrammaticTxMgmtTestNGTests.java | 28 +++---- .../PrimaryTransactionManagerTests.java | 4 +- .../programmatic/ProgrammaticTxMgmtTests.java | 30 ++++--- .../transaction/TransactionTestUtils.java | 82 ------------------- 26 files changed, 121 insertions(+), 203 deletions(-) delete mode 100644 spring-test/src/test/java/org/springframework/test/transaction/TransactionTestUtils.java diff --git a/spring-test/src/test/java/org/springframework/test/context/jdbc/DataSourceOnlySqlScriptsTests.java b/spring-test/src/test/java/org/springframework/test/context/jdbc/DataSourceOnlySqlScriptsTests.java index 947e3b0d9ef..6cb0c6419dc 100644 --- a/spring-test/src/test/java/org/springframework/test/context/jdbc/DataSourceOnlySqlScriptsTests.java +++ b/spring-test/src/test/java/org/springframework/test/context/jdbc/DataSourceOnlySqlScriptsTests.java @@ -32,9 +32,9 @@ import org.springframework.test.annotation.DirtiesContext; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; import org.springframework.test.jdbc.JdbcTestUtils; +import org.springframework.transaction.support.TransactionSynchronizationManager; import static org.assertj.core.api.Assertions.assertThat; -import static org.springframework.test.transaction.TransactionTestUtils.assertInTransaction; /** * Integration tests for {@link Sql @Sql} support with only a {@link DataSource} @@ -61,7 +61,7 @@ public class DataSourceOnlySqlScriptsTests { @Test // test##_ prefix is required for @FixMethodOrder. public void test01_classLevelScripts() { - assertInTransaction(false); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); assertNumUsers(1); } @@ -69,7 +69,7 @@ public class DataSourceOnlySqlScriptsTests { @Sql({ "drop-schema.sql", "schema.sql", "data.sql", "data-add-dogbert.sql" }) // test##_ prefix is required for @FixMethodOrder. public void test02_methodLevelScripts() { - assertInTransaction(false); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); assertNumUsers(2); } diff --git a/spring-test/src/test/java/org/springframework/test/context/jdbc/InferredDataSourceSqlScriptsTests.java b/spring-test/src/test/java/org/springframework/test/context/jdbc/InferredDataSourceSqlScriptsTests.java index 8282d8f4ad5..cc50d927604 100644 --- a/spring-test/src/test/java/org/springframework/test/context/jdbc/InferredDataSourceSqlScriptsTests.java +++ b/spring-test/src/test/java/org/springframework/test/context/jdbc/InferredDataSourceSqlScriptsTests.java @@ -34,9 +34,9 @@ import org.springframework.test.annotation.DirtiesContext; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; import org.springframework.transaction.PlatformTransactionManager; +import org.springframework.transaction.support.TransactionSynchronizationManager; import static org.assertj.core.api.Assertions.assertThat; -import static org.springframework.test.transaction.TransactionTestUtils.assertInTransaction; /** * Integration tests for {@link Sql @Sql} that verify support for inferring @@ -61,14 +61,14 @@ public class InferredDataSourceSqlScriptsTests { @Test @Sql(scripts = "data-add-dogbert.sql", config = @SqlConfig(transactionManager = "txMgr1")) public void database1() { - assertInTransaction(false); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); assertUsers(new JdbcTemplate(dataSource1), "Dilbert", "Dogbert"); } @Test @Sql(scripts = "data-add-catbert.sql", config = @SqlConfig(transactionManager = "txMgr2")) public void database2() { - assertInTransaction(false); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); assertUsers(new JdbcTemplate(dataSource2), "Dilbert", "Catbert"); } diff --git a/spring-test/src/test/java/org/springframework/test/context/jdbc/InferredDataSourceTransactionalSqlScriptsTests.java b/spring-test/src/test/java/org/springframework/test/context/jdbc/InferredDataSourceTransactionalSqlScriptsTests.java index fdc58a524a3..6126725423b 100644 --- a/spring-test/src/test/java/org/springframework/test/context/jdbc/InferredDataSourceTransactionalSqlScriptsTests.java +++ b/spring-test/src/test/java/org/springframework/test/context/jdbc/InferredDataSourceTransactionalSqlScriptsTests.java @@ -35,9 +35,9 @@ import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; import org.springframework.transaction.PlatformTransactionManager; import org.springframework.transaction.annotation.Transactional; +import org.springframework.transaction.support.TransactionSynchronizationManager; import static org.assertj.core.api.Assertions.assertThat; -import static org.springframework.test.transaction.TransactionTestUtils.assertInTransaction; /** * Exact copy of {@link InferredDataSourceSqlScriptsTests}, except that test @@ -63,7 +63,7 @@ public class InferredDataSourceTransactionalSqlScriptsTests { @Transactional("txMgr1") @Sql(scripts = "data-add-dogbert.sql", config = @SqlConfig(transactionManager = "txMgr1")) public void database1() { - assertInTransaction(true); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); assertUsers(new JdbcTemplate(dataSource1), "Dilbert", "Dogbert"); } @@ -71,7 +71,7 @@ public class InferredDataSourceTransactionalSqlScriptsTests { @Transactional("txMgr2") @Sql(scripts = "data-add-catbert.sql", config = @SqlConfig(transactionManager = "txMgr2")) public void database2() { - assertInTransaction(true); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); assertUsers(new JdbcTemplate(dataSource2), "Dilbert", "Catbert"); } diff --git a/spring-test/src/test/java/org/springframework/test/context/jdbc/PrimaryDataSourceTests.java b/spring-test/src/test/java/org/springframework/test/context/jdbc/PrimaryDataSourceTests.java index ae81a0d0cb0..0a01e8fbf91 100644 --- a/spring-test/src/test/java/org/springframework/test/context/jdbc/PrimaryDataSourceTests.java +++ b/spring-test/src/test/java/org/springframework/test/context/jdbc/PrimaryDataSourceTests.java @@ -31,7 +31,7 @@ import org.springframework.test.annotation.DirtiesContext; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; import org.springframework.test.jdbc.JdbcTestUtils; -import org.springframework.test.transaction.TransactionTestUtils; +import org.springframework.transaction.support.TransactionSynchronizationManager; import static org.assertj.core.api.Assertions.assertThat; @@ -81,7 +81,7 @@ public class PrimaryDataSourceTests { @Test @Sql("data.sql") public void dataSourceTest() { - TransactionTestUtils.assertInTransaction(false); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); assertThat(JdbcTestUtils.countRowsInTable(this.jdbcTemplate, "user")).as("Number of rows in the 'user' table.").isEqualTo(1); } diff --git a/spring-test/src/test/java/org/springframework/test/context/junit4/BeforeAndAfterTransactionAnnotationTests.java b/spring-test/src/test/java/org/springframework/test/context/junit4/BeforeAndAfterTransactionAnnotationTests.java index dc6a459bb8b..f36695f1938 100644 --- a/spring-test/src/test/java/org/springframework/test/context/junit4/BeforeAndAfterTransactionAnnotationTests.java +++ b/spring-test/src/test/java/org/springframework/test/context/junit4/BeforeAndAfterTransactionAnnotationTests.java @@ -32,9 +32,9 @@ import org.springframework.test.context.transaction.AfterTransaction; import org.springframework.test.context.transaction.BeforeTransaction; import org.springframework.transaction.annotation.Propagation; import org.springframework.transaction.annotation.Transactional; +import org.springframework.transaction.support.TransactionSynchronizationManager; import static org.assertj.core.api.Assertions.assertThat; -import static org.springframework.test.transaction.TransactionTestUtils.assertInTransaction; /** * JUnit 4 based integration test which verifies @@ -79,7 +79,7 @@ public class BeforeAndAfterTransactionAnnotationTests extends AbstractTransactio @BeforeTransaction void beforeTransaction() { - assertInTransaction(false); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); this.inTransaction = true; BeforeAndAfterTransactionAnnotationTests.numBeforeTransactionCalls++; clearPersonTable(jdbcTemplate); @@ -88,7 +88,7 @@ public class BeforeAndAfterTransactionAnnotationTests extends AbstractTransactio @AfterTransaction void afterTransaction() { - assertInTransaction(false); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); this.inTransaction = false; BeforeAndAfterTransactionAnnotationTests.numAfterTransactionCalls++; assertThat(deletePerson(jdbcTemplate, YODA)).as("Deleting yoda").isEqualTo(1); @@ -105,7 +105,7 @@ public class BeforeAndAfterTransactionAnnotationTests extends AbstractTransactio private void assertShouldBeInTransaction() { boolean shouldBeInTransaction = !testName.getMethodName().equals("nonTransactionalMethod"); - assertInTransaction(shouldBeInTransaction); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isEqualTo(shouldBeInTransaction); } @After @@ -115,14 +115,14 @@ public class BeforeAndAfterTransactionAnnotationTests extends AbstractTransactio @Test public void transactionalMethod1() { - assertInTransaction(true); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); assertThat(addPerson(jdbcTemplate, JANE)).as("Adding jane").isEqualTo(1); assertThat(countRowsInPersonTable(jdbcTemplate)).as("Verifying the number of rows in the person table within transactionalMethod1().").isEqualTo(2); } @Test public void transactionalMethod2() { - assertInTransaction(true); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); assertThat(addPerson(jdbcTemplate, JANE)).as("Adding jane").isEqualTo(1); assertThat(addPerson(jdbcTemplate, SUE)).as("Adding sue").isEqualTo(1); assertThat(countRowsInPersonTable(jdbcTemplate)).as("Verifying the number of rows in the person table within transactionalMethod2().").isEqualTo(3); @@ -131,7 +131,7 @@ public class BeforeAndAfterTransactionAnnotationTests extends AbstractTransactio @Test @Transactional(propagation = Propagation.NOT_SUPPORTED) public void nonTransactionalMethod() { - assertInTransaction(false); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); assertThat(addPerson(jdbcTemplate, LUKE)).as("Adding luke").isEqualTo(1); assertThat(addPerson(jdbcTemplate, LEIA)).as("Adding leia").isEqualTo(1); assertThat(addPerson(jdbcTemplate, YODA)).as("Adding yoda").isEqualTo(1); diff --git a/spring-test/src/test/java/org/springframework/test/context/junit4/ClassLevelTransactionalSpringRunnerTests.java b/spring-test/src/test/java/org/springframework/test/context/junit4/ClassLevelTransactionalSpringRunnerTests.java index b533c0c2f13..59a6ec27af3 100644 --- a/spring-test/src/test/java/org/springframework/test/context/junit4/ClassLevelTransactionalSpringRunnerTests.java +++ b/spring-test/src/test/java/org/springframework/test/context/junit4/ClassLevelTransactionalSpringRunnerTests.java @@ -32,9 +32,9 @@ import org.springframework.test.context.support.DirtiesContextTestExecutionListe import org.springframework.test.context.transaction.TransactionalTestExecutionListener; import org.springframework.transaction.annotation.Propagation; import org.springframework.transaction.annotation.Transactional; +import org.springframework.transaction.support.TransactionSynchronizationManager; import static org.assertj.core.api.Assertions.assertThat; -import static org.springframework.test.transaction.TransactionTestUtils.assertInTransaction; /** * JUnit 4 based integration test which verifies support of Spring's @@ -82,7 +82,7 @@ public class ClassLevelTransactionalSpringRunnerTests extends AbstractTransactio @Test public void modifyTestDataWithinTransaction() { - assertInTransaction(true); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); assertThat(deletePerson(jdbcTemplate, BOB)).as("Deleting bob").isEqualTo(1); assertThat(addPerson(jdbcTemplate, JANE)).as("Adding jane").isEqualTo(1); assertThat(addPerson(jdbcTemplate, SUE)).as("Adding sue").isEqualTo(1); @@ -92,7 +92,7 @@ public class ClassLevelTransactionalSpringRunnerTests extends AbstractTransactio @Test @Transactional(propagation = Propagation.NOT_SUPPORTED) public void modifyTestDataWithoutTransaction() { - assertInTransaction(false); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); assertThat(addPerson(jdbcTemplate, LUKE)).as("Adding luke").isEqualTo(1); assertThat(addPerson(jdbcTemplate, LEIA)).as("Adding leia").isEqualTo(1); assertThat(addPerson(jdbcTemplate, YODA)).as("Adding yoda").isEqualTo(1); diff --git a/spring-test/src/test/java/org/springframework/test/context/junit4/ConcreteTransactionalJUnit4SpringContextTests.java b/spring-test/src/test/java/org/springframework/test/context/junit4/ConcreteTransactionalJUnit4SpringContextTests.java index b7c241e0239..ccb9fe50b45 100644 --- a/spring-test/src/test/java/org/springframework/test/context/junit4/ConcreteTransactionalJUnit4SpringContextTests.java +++ b/spring-test/src/test/java/org/springframework/test/context/junit4/ConcreteTransactionalJUnit4SpringContextTests.java @@ -32,10 +32,9 @@ import org.springframework.tests.sample.beans.Employee; import org.springframework.tests.sample.beans.Pet; import org.springframework.transaction.annotation.Propagation; import org.springframework.transaction.annotation.Transactional; +import org.springframework.transaction.support.TransactionSynchronizationManager; import static org.assertj.core.api.Assertions.assertThat; -import static org.springframework.test.transaction.TransactionTestUtils.assertInTransaction; -import static org.springframework.test.transaction.TransactionTestUtils.inTransaction; /** * Combined integration test for {@link AbstractJUnit4SpringContextTests} and @@ -93,13 +92,13 @@ public class ConcreteTransactionalJUnit4SpringContextTests extends AbstractTrans @Before public void setUp() { - long expected = (inTransaction() ? 2 : 1); + long expected = (TransactionSynchronizationManager.isActualTransactionActive() ? 2 : 1); assertThat(countRowsInPersonTable()).as("Verifying the number of rows in the person table before a test method.").isEqualTo(expected); } @After public void tearDown() { - long expected = (inTransaction() ? 4 : 1); + long expected = (TransactionSynchronizationManager.isActualTransactionActive() ? 4 : 1); assertThat(countRowsInPersonTable()).as("Verifying the number of rows in the person table after a test method.").isEqualTo(expected); } @@ -119,7 +118,7 @@ public class ConcreteTransactionalJUnit4SpringContextTests extends AbstractTrans @Test @Transactional(propagation = Propagation.NOT_SUPPORTED) public void verifyBeanNameSet() { - assertInTransaction(false); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); assertThat(this.beanName.startsWith(getClass().getName())).as("The bean name of this test instance should have been set to the fully qualified class name " + "due to BeanNameAware semantics.").isTrue(); } @@ -127,21 +126,21 @@ public class ConcreteTransactionalJUnit4SpringContextTests extends AbstractTrans @Test @Transactional(propagation = Propagation.NOT_SUPPORTED) public void verifyApplicationContext() { - assertInTransaction(false); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); assertThat(super.applicationContext).as("The application context should have been set due to ApplicationContextAware semantics.").isNotNull(); } @Test @Transactional(propagation = Propagation.NOT_SUPPORTED) public void verifyBeanInitialized() { - assertInTransaction(false); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); assertThat(this.beanInitialized).as("This test bean should have been initialized due to InitializingBean semantics.").isTrue(); } @Test @Transactional(propagation = Propagation.NOT_SUPPORTED) public void verifyAnnotationAutowiredFields() { - assertInTransaction(false); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); assertThat(this.nonrequiredLong).as("The nonrequiredLong property should NOT have been autowired.").isNull(); assertThat(this.pet).as("The pet field should have been autowired.").isNotNull(); assertThat(this.pet.getName()).isEqualTo("Fido"); @@ -150,7 +149,7 @@ public class ConcreteTransactionalJUnit4SpringContextTests extends AbstractTrans @Test @Transactional(propagation = Propagation.NOT_SUPPORTED) public void verifyAnnotationAutowiredMethods() { - assertInTransaction(false); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); assertThat(this.employee).as("The employee setter method should have been autowired.").isNotNull(); assertThat(this.employee.getName()).isEqualTo("John Smith"); } @@ -158,20 +157,20 @@ public class ConcreteTransactionalJUnit4SpringContextTests extends AbstractTrans @Test @Transactional(propagation = Propagation.NOT_SUPPORTED) public void verifyResourceAnnotationWiredFields() { - assertInTransaction(false); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); assertThat(this.foo).as("The foo field should have been wired via @Resource.").isEqualTo("Foo"); } @Test @Transactional(propagation = Propagation.NOT_SUPPORTED) public void verifyResourceAnnotationWiredMethods() { - assertInTransaction(false); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); assertThat(this.bar).as("The bar method should have been wired via @Resource.").isEqualTo("Bar"); } @Test public void modifyTestDataWithinTransaction() { - assertInTransaction(true); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); assertThat(addPerson(JANE)).as("Adding jane").isEqualTo(1); assertThat(addPerson(SUE)).as("Adding sue").isEqualTo(1); assertThat(countRowsInPersonTable()).as("Verifying the number of rows in the person table in modifyTestDataWithinTransaction().").isEqualTo(4); diff --git a/spring-test/src/test/java/org/springframework/test/context/junit4/DefaultRollbackFalseRollbackAnnotationTransactionalTests.java b/spring-test/src/test/java/org/springframework/test/context/junit4/DefaultRollbackFalseRollbackAnnotationTransactionalTests.java index cceaa26f42b..e9f503f01ed 100644 --- a/spring-test/src/test/java/org/springframework/test/context/junit4/DefaultRollbackFalseRollbackAnnotationTransactionalTests.java +++ b/spring-test/src/test/java/org/springframework/test/context/junit4/DefaultRollbackFalseRollbackAnnotationTransactionalTests.java @@ -28,9 +28,9 @@ import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.test.annotation.Rollback; import org.springframework.test.context.ContextConfiguration; import org.springframework.transaction.annotation.Transactional; +import org.springframework.transaction.support.TransactionSynchronizationManager; import static org.assertj.core.api.Assertions.assertThat; -import static org.springframework.test.transaction.TransactionTestUtils.assertInTransaction; /** * Integration test which verifies proper transactional behavior when the @@ -69,7 +69,7 @@ public class DefaultRollbackFalseRollbackAnnotationTransactionalTests extends Ab @Test public void modifyTestDataWithinTransaction() { - assertInTransaction(true); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); assertThat(deletePerson(jdbcTemplate, BOB)).as("Deleting bob").isEqualTo(1); assertThat(addPerson(jdbcTemplate, JANE)).as("Adding jane").isEqualTo(1); assertThat(addPerson(jdbcTemplate, SUE)).as("Adding sue").isEqualTo(1); diff --git a/spring-test/src/test/java/org/springframework/test/context/junit4/DefaultRollbackTrueRollbackAnnotationTransactionalTests.java b/spring-test/src/test/java/org/springframework/test/context/junit4/DefaultRollbackTrueRollbackAnnotationTransactionalTests.java index 388664b8671..271836eb5b2 100644 --- a/spring-test/src/test/java/org/springframework/test/context/junit4/DefaultRollbackTrueRollbackAnnotationTransactionalTests.java +++ b/spring-test/src/test/java/org/springframework/test/context/junit4/DefaultRollbackTrueRollbackAnnotationTransactionalTests.java @@ -28,9 +28,9 @@ import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.test.annotation.Rollback; import org.springframework.test.context.ContextConfiguration; import org.springframework.transaction.annotation.Transactional; +import org.springframework.transaction.support.TransactionSynchronizationManager; import static org.assertj.core.api.Assertions.assertThat; -import static org.springframework.test.transaction.TransactionTestUtils.assertInTransaction; /** * Integration test which verifies proper transactional behavior when the default @@ -71,7 +71,7 @@ public class DefaultRollbackTrueRollbackAnnotationTransactionalTests extends Abs @Test(timeout = 1000) public void modifyTestDataWithinTransaction() { - assertInTransaction(true); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); assertThat(addPerson(jdbcTemplate, JANE)).as("Adding jane").isEqualTo(1); assertThat(addPerson(jdbcTemplate, SUE)).as("Adding sue").isEqualTo(1); assertThat(countRowsInPersonTable(jdbcTemplate)).as("Verifying the number of rows in the person table within a transaction.").isEqualTo(3); diff --git a/spring-test/src/test/java/org/springframework/test/context/junit4/MethodLevelTransactionalSpringRunnerTests.java b/spring-test/src/test/java/org/springframework/test/context/junit4/MethodLevelTransactionalSpringRunnerTests.java index 739de585724..862cf0b8446 100644 --- a/spring-test/src/test/java/org/springframework/test/context/junit4/MethodLevelTransactionalSpringRunnerTests.java +++ b/spring-test/src/test/java/org/springframework/test/context/junit4/MethodLevelTransactionalSpringRunnerTests.java @@ -32,9 +32,9 @@ import org.springframework.test.context.support.DependencyInjectionTestExecution import org.springframework.test.context.support.DirtiesContextTestExecutionListener; import org.springframework.test.context.transaction.TransactionalTestExecutionListener; import org.springframework.transaction.annotation.Transactional; +import org.springframework.transaction.support.TransactionSynchronizationManager; import static org.assertj.core.api.Assertions.assertThat; -import static org.springframework.test.transaction.TransactionTestUtils.assertInTransaction; /** * JUnit 4 based integration test which verifies support of Spring's @@ -85,7 +85,7 @@ public class MethodLevelTransactionalSpringRunnerTests extends AbstractTransacti @Test @Transactional("transactionManager2") public void modifyTestDataWithinTransaction() { - assertInTransaction(true); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); assertThat(deletePerson(jdbcTemplate, BOB)).as("Deleting bob").isEqualTo(1); assertThat(addPerson(jdbcTemplate, JANE)).as("Adding jane").isEqualTo(1); assertThat(addPerson(jdbcTemplate, SUE)).as("Adding sue").isEqualTo(1); @@ -94,7 +94,7 @@ public class MethodLevelTransactionalSpringRunnerTests extends AbstractTransacti @Test public void modifyTestDataWithoutTransaction() { - assertInTransaction(false); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); assertThat(addPerson(jdbcTemplate, LUKE)).as("Adding luke").isEqualTo(1); assertThat(addPerson(jdbcTemplate, LEIA)).as("Adding leia").isEqualTo(1); assertThat(addPerson(jdbcTemplate, YODA)).as("Adding yoda").isEqualTo(1); diff --git a/spring-test/src/test/java/org/springframework/test/context/junit4/RollbackOverrideDefaultRollbackFalseRollbackAnnotationTransactionalTests.java b/spring-test/src/test/java/org/springframework/test/context/junit4/RollbackOverrideDefaultRollbackFalseRollbackAnnotationTransactionalTests.java index 303cfa24f41..11719d1d9be 100644 --- a/spring-test/src/test/java/org/springframework/test/context/junit4/RollbackOverrideDefaultRollbackFalseRollbackAnnotationTransactionalTests.java +++ b/spring-test/src/test/java/org/springframework/test/context/junit4/RollbackOverrideDefaultRollbackFalseRollbackAnnotationTransactionalTests.java @@ -25,9 +25,9 @@ import org.junit.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.test.annotation.Rollback; +import org.springframework.transaction.support.TransactionSynchronizationManager; import static org.assertj.core.api.Assertions.assertThat; -import static org.springframework.test.transaction.TransactionTestUtils.assertInTransaction; /** * Extension of {@link DefaultRollbackFalseRollbackAnnotationTransactionalTests} @@ -64,7 +64,7 @@ public class RollbackOverrideDefaultRollbackFalseRollbackAnnotationTransactional @Rollback @Override public void modifyTestDataWithinTransaction() { - assertInTransaction(true); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); assertThat(deletePerson(jdbcTemplate, BOB)).as("Deleting bob").isEqualTo(1); assertThat(addPerson(jdbcTemplate, JANE)).as("Adding jane").isEqualTo(1); assertThat(addPerson(jdbcTemplate, SUE)).as("Adding sue").isEqualTo(1); diff --git a/spring-test/src/test/java/org/springframework/test/context/junit4/RollbackOverrideDefaultRollbackFalseTransactionalTests.java b/spring-test/src/test/java/org/springframework/test/context/junit4/RollbackOverrideDefaultRollbackFalseTransactionalTests.java index c87e89f7979..eae19a1f744 100644 --- a/spring-test/src/test/java/org/springframework/test/context/junit4/RollbackOverrideDefaultRollbackFalseTransactionalTests.java +++ b/spring-test/src/test/java/org/springframework/test/context/junit4/RollbackOverrideDefaultRollbackFalseTransactionalTests.java @@ -25,9 +25,9 @@ import org.junit.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.test.annotation.Rollback; +import org.springframework.transaction.support.TransactionSynchronizationManager; import static org.assertj.core.api.Assertions.assertThat; -import static org.springframework.test.transaction.TransactionTestUtils.assertInTransaction; /** * Extension of {@link DefaultRollbackFalseRollbackAnnotationTransactionalTests} @@ -64,7 +64,7 @@ public class RollbackOverrideDefaultRollbackFalseTransactionalTests @Rollback @Override public void modifyTestDataWithinTransaction() { - assertInTransaction(true); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); assertThat(deletePerson(jdbcTemplate, BOB)).as("Deleting bob").isEqualTo(1); assertThat(addPerson(jdbcTemplate, JANE)).as("Adding jane").isEqualTo(1); assertThat(addPerson(jdbcTemplate, SUE)).as("Adding sue").isEqualTo(1); diff --git a/spring-test/src/test/java/org/springframework/test/context/junit4/RollbackOverrideDefaultRollbackTrueRollbackAnnotationTransactionalTests.java b/spring-test/src/test/java/org/springframework/test/context/junit4/RollbackOverrideDefaultRollbackTrueRollbackAnnotationTransactionalTests.java index 2386f1c0a4b..3ee5a1da5e6 100644 --- a/spring-test/src/test/java/org/springframework/test/context/junit4/RollbackOverrideDefaultRollbackTrueRollbackAnnotationTransactionalTests.java +++ b/spring-test/src/test/java/org/springframework/test/context/junit4/RollbackOverrideDefaultRollbackTrueRollbackAnnotationTransactionalTests.java @@ -25,9 +25,9 @@ import org.junit.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.test.annotation.Rollback; +import org.springframework.transaction.support.TransactionSynchronizationManager; import static org.assertj.core.api.Assertions.assertThat; -import static org.springframework.test.transaction.TransactionTestUtils.assertInTransaction; /** * Extension of {@link DefaultRollbackTrueRollbackAnnotationTransactionalTests} @@ -63,7 +63,7 @@ public class RollbackOverrideDefaultRollbackTrueRollbackAnnotationTransactionalT @Rollback(false) @Override public void modifyTestDataWithinTransaction() { - assertInTransaction(true); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); assertThat(addPerson(jdbcTemplate, JANE)).as("Adding jane").isEqualTo(1); assertThat(addPerson(jdbcTemplate, SUE)).as("Adding sue").isEqualTo(1); assertThat(countRowsInPersonTable(jdbcTemplate)).as("Verifying the number of rows in the person table within a transaction.").isEqualTo(3); diff --git a/spring-test/src/test/java/org/springframework/test/context/junit4/RollbackOverrideDefaultRollbackTrueTransactionalTests.java b/spring-test/src/test/java/org/springframework/test/context/junit4/RollbackOverrideDefaultRollbackTrueTransactionalTests.java index b57faf9d764..7d4c6360bed 100644 --- a/spring-test/src/test/java/org/springframework/test/context/junit4/RollbackOverrideDefaultRollbackTrueTransactionalTests.java +++ b/spring-test/src/test/java/org/springframework/test/context/junit4/RollbackOverrideDefaultRollbackTrueTransactionalTests.java @@ -25,9 +25,9 @@ import org.junit.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.test.annotation.Rollback; +import org.springframework.transaction.support.TransactionSynchronizationManager; import static org.assertj.core.api.Assertions.assertThat; -import static org.springframework.test.transaction.TransactionTestUtils.assertInTransaction; /** * Extension of {@link DefaultRollbackTrueRollbackAnnotationTransactionalTests} @@ -61,7 +61,7 @@ public class RollbackOverrideDefaultRollbackTrueTransactionalTests @Rollback(false) @Override public void modifyTestDataWithinTransaction() { - assertInTransaction(true); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); assertThat(addPerson(jdbcTemplate, JANE)).as("Adding jane").isEqualTo(1); assertThat(addPerson(jdbcTemplate, SUE)).as("Adding sue").isEqualTo(1); assertThat(countRowsInPersonTable(jdbcTemplate)).as("Verifying the number of rows in the person table within a transaction.").isEqualTo(3); diff --git a/spring-test/src/test/java/org/springframework/test/context/junit4/TimedTransactionalSpringRunnerTests.java b/spring-test/src/test/java/org/springframework/test/context/junit4/TimedTransactionalSpringRunnerTests.java index a3268b961a7..213acb66e1f 100644 --- a/spring-test/src/test/java/org/springframework/test/context/junit4/TimedTransactionalSpringRunnerTests.java +++ b/spring-test/src/test/java/org/springframework/test/context/junit4/TimedTransactionalSpringRunnerTests.java @@ -24,8 +24,9 @@ import org.springframework.test.annotation.Timed; import org.springframework.test.context.ContextConfiguration; import org.springframework.transaction.annotation.Propagation; import org.springframework.transaction.annotation.Transactional; +import org.springframework.transaction.support.TransactionSynchronizationManager; -import static org.springframework.test.transaction.TransactionTestUtils.assertInTransaction; +import static org.assertj.core.api.Assertions.assertThat; /** * JUnit 4 based integration test which verifies support of Spring's @@ -45,13 +46,13 @@ public class TimedTransactionalSpringRunnerTests { @Timed(millis = 10000) @Repeat(5) public void transactionalWithSpringTimeout() { - assertInTransaction(true); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); } @Test(timeout = 10000) @Repeat(5) public void transactionalWithJUnitTimeout() { - assertInTransaction(true); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); } @Test @@ -59,14 +60,14 @@ public class TimedTransactionalSpringRunnerTests { @Timed(millis = 10000) @Repeat(5) public void notTransactionalWithSpringTimeout() { - assertInTransaction(false); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); } @Test(timeout = 10000) @Transactional(propagation = Propagation.NOT_SUPPORTED) @Repeat(5) public void notTransactionalWithJUnitTimeout() { - assertInTransaction(false); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); } } diff --git a/spring-test/src/test/java/org/springframework/test/context/junit4/orm/HibernateSessionFlushingTests.java b/spring-test/src/test/java/org/springframework/test/context/junit4/orm/HibernateSessionFlushingTests.java index b9dc1e15bf6..05ef79e9fb8 100644 --- a/spring-test/src/test/java/org/springframework/test/context/junit4/orm/HibernateSessionFlushingTests.java +++ b/spring-test/src/test/java/org/springframework/test/context/junit4/orm/HibernateSessionFlushingTests.java @@ -31,10 +31,10 @@ import org.springframework.test.context.junit4.orm.domain.DriversLicense; import org.springframework.test.context.junit4.orm.domain.Person; import org.springframework.test.context.junit4.orm.service.PersonService; import org.springframework.transaction.annotation.Transactional; +import org.springframework.transaction.support.TransactionSynchronizationManager; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatExceptionOfType; -import static org.springframework.test.transaction.TransactionTestUtils.assertInTransaction; /** * Transactional integration tests regarding manual session flushing with @@ -60,7 +60,7 @@ public class HibernateSessionFlushingTests extends AbstractTransactionalJUnit4Sp @Before public void setup() { - assertInTransaction(true); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); assertThat(personService).as("PersonService should have been autowired.").isNotNull(); assertThat(sessionFactory).as("SessionFactory should have been autowired.").isNotNull(); } diff --git a/spring-test/src/test/java/org/springframework/test/context/junit4/rules/TimedTransactionalSpringRuleTests.java b/spring-test/src/test/java/org/springframework/test/context/junit4/rules/TimedTransactionalSpringRuleTests.java index 86e9599548c..d5b69ec5601 100644 --- a/spring-test/src/test/java/org/springframework/test/context/junit4/rules/TimedTransactionalSpringRuleTests.java +++ b/spring-test/src/test/java/org/springframework/test/context/junit4/rules/TimedTransactionalSpringRuleTests.java @@ -27,8 +27,9 @@ import org.junit.runners.JUnit4; import org.springframework.test.annotation.Repeat; import org.springframework.test.context.junit4.TimedTransactionalSpringRunnerTests; +import org.springframework.transaction.support.TransactionSynchronizationManager; -import static org.springframework.test.transaction.TransactionTestUtils.assertInTransaction; +import static org.assertj.core.api.Assertions.assertThat; /** * This class is an extension of {@link TimedTransactionalSpringRunnerTests} @@ -59,7 +60,7 @@ public class TimedTransactionalSpringRuleTests extends TimedTransactionalSpringR @Repeat(5) @Override public void transactionalWithJUnitTimeout() { - assertInTransaction(false); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); } /** @@ -67,7 +68,7 @@ public class TimedTransactionalSpringRuleTests extends TimedTransactionalSpringR */ @Test public void transactionalWithJUnitRuleBasedTimeout() { - assertInTransaction(true); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); } // All other tests are in superclass. diff --git a/spring-test/src/test/java/org/springframework/test/context/junit4/spr9051/AbstractTransactionalAnnotatedConfigClassTests.java b/spring-test/src/test/java/org/springframework/test/context/junit4/spr9051/AbstractTransactionalAnnotatedConfigClassTests.java index 5726f882b71..47e99bdcb23 100644 --- a/spring-test/src/test/java/org/springframework/test/context/junit4/spr9051/AbstractTransactionalAnnotatedConfigClassTests.java +++ b/spring-test/src/test/java/org/springframework/test/context/junit4/spr9051/AbstractTransactionalAnnotatedConfigClassTests.java @@ -33,10 +33,9 @@ import org.springframework.test.context.transaction.AfterTransaction; import org.springframework.test.context.transaction.BeforeTransaction; import org.springframework.tests.sample.beans.Employee; import org.springframework.transaction.annotation.Transactional; +import org.springframework.transaction.support.TransactionSynchronizationManager; import static org.assertj.core.api.Assertions.assertThat; -import static org.springframework.test.transaction.TransactionTestUtils.assertInTransaction; -import static org.springframework.test.transaction.TransactionTestUtils.inTransaction; /** * This set of tests (i.e., all concrete subclasses) investigates the claims made in @@ -109,13 +108,13 @@ public abstract class AbstractTransactionalAnnotatedConfigClassTests { @Before public void setUp() throws Exception { - assertNumRowsInPersonTable((inTransaction() ? 1 : 0), "before a test method"); + assertNumRowsInPersonTable((TransactionSynchronizationManager.isActualTransactionActive() ? 1 : 0), "before a test method"); } @Test @Transactional public void modifyTestDataWithinTransaction() { - assertInTransaction(true); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); assertAddPerson(JANE); assertAddPerson(SUE); assertNumRowsInPersonTable(3, "in modifyTestDataWithinTransaction()"); @@ -123,7 +122,7 @@ public abstract class AbstractTransactionalAnnotatedConfigClassTests { @After public void tearDown() throws Exception { - assertNumRowsInPersonTable((inTransaction() ? 3 : 0), "after a test method"); + assertNumRowsInPersonTable((TransactionSynchronizationManager.isActualTransactionActive() ? 3 : 0), "after a test method"); } @AfterTransaction diff --git a/spring-test/src/test/java/org/springframework/test/context/testng/AnnotationConfigTransactionalTestNGSpringContextTests.java b/spring-test/src/test/java/org/springframework/test/context/testng/AnnotationConfigTransactionalTestNGSpringContextTests.java index b5037b9448f..402fdcc2f70 100644 --- a/spring-test/src/test/java/org/springframework/test/context/testng/AnnotationConfigTransactionalTestNGSpringContextTests.java +++ b/spring-test/src/test/java/org/springframework/test/context/testng/AnnotationConfigTransactionalTestNGSpringContextTests.java @@ -37,9 +37,9 @@ import org.springframework.tests.sample.beans.Pet; import org.springframework.transaction.PlatformTransactionManager; import org.springframework.transaction.annotation.Propagation; import org.springframework.transaction.annotation.Transactional; +import org.springframework.transaction.support.TransactionSynchronizationManager; -import static org.springframework.test.transaction.TransactionTestUtils.assertInTransaction; -import static org.springframework.test.transaction.TransactionTestUtils.inTransaction; +import static org.assertj.core.api.Assertions.assertThat; import static org.testng.Assert.assertEquals; import static org.testng.Assert.assertNotNull; @@ -129,15 +129,15 @@ public class AnnotationConfigTransactionalTestNGSpringContextTests @BeforeMethod void setUp() throws Exception { numSetUpCalls++; - if (inTransaction()) { + if (TransactionSynchronizationManager.isActualTransactionActive()) { numSetUpCallsInTransaction++; } - assertNumRowsInPersonTable((inTransaction() ? 2 : 1), "before a test method"); + assertNumRowsInPersonTable((TransactionSynchronizationManager.isActualTransactionActive() ? 2 : 1), "before a test method"); } @Test void modifyTestDataWithinTransaction() { - assertInTransaction(true); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); assertAddPerson(JANE); assertAddPerson(SUE); assertNumRowsInPersonTable(4, "in modifyTestDataWithinTransaction()"); @@ -146,10 +146,10 @@ public class AnnotationConfigTransactionalTestNGSpringContextTests @AfterMethod void tearDown() throws Exception { numTearDownCalls++; - if (inTransaction()) { + if (TransactionSynchronizationManager.isActualTransactionActive()) { numTearDownCallsInTransaction++; } - assertNumRowsInPersonTable((inTransaction() ? 4 : 1), "after a test method"); + assertNumRowsInPersonTable((TransactionSynchronizationManager.isActualTransactionActive() ? 4 : 1), "after a test method"); } @AfterTransaction diff --git a/spring-test/src/test/java/org/springframework/test/context/testng/ConcreteTransactionalTestNGSpringContextTests.java b/spring-test/src/test/java/org/springframework/test/context/testng/ConcreteTransactionalTestNGSpringContextTests.java index 94527b98287..79cb87e7514 100644 --- a/spring-test/src/test/java/org/springframework/test/context/testng/ConcreteTransactionalTestNGSpringContextTests.java +++ b/spring-test/src/test/java/org/springframework/test/context/testng/ConcreteTransactionalTestNGSpringContextTests.java @@ -34,9 +34,9 @@ import org.springframework.tests.sample.beans.Employee; import org.springframework.tests.sample.beans.Pet; import org.springframework.transaction.annotation.Propagation; import org.springframework.transaction.annotation.Transactional; +import org.springframework.transaction.support.TransactionSynchronizationManager; -import static org.springframework.test.transaction.TransactionTestUtils.assertInTransaction; -import static org.springframework.test.transaction.TransactionTestUtils.inTransaction; +import static org.assertj.core.api.Assertions.assertThat; import static org.testng.Assert.assertEquals; import static org.testng.Assert.assertNotNull; import static org.testng.Assert.assertNull; @@ -124,19 +124,19 @@ public class ConcreteTransactionalTestNGSpringContextTests extends AbstractTrans @BeforeMethod void setUp() { numSetUpCalls++; - if (inTransaction()) { + if (TransactionSynchronizationManager.isActualTransactionActive()) { numSetUpCallsInTransaction++; } - assertNumRowsInPersonTable((inTransaction() ? 2 : 1), "before a test method"); + assertNumRowsInPersonTable((TransactionSynchronizationManager.isActualTransactionActive() ? 2 : 1), "before a test method"); } @AfterMethod void tearDown() { numTearDownCalls++; - if (inTransaction()) { + if (TransactionSynchronizationManager.isActualTransactionActive()) { numTearDownCallsInTransaction++; } - assertNumRowsInPersonTable((inTransaction() ? 4 : 1), "after a test method"); + assertNumRowsInPersonTable((TransactionSynchronizationManager.isActualTransactionActive() ? 4 : 1), "after a test method"); } @BeforeTransaction @@ -155,7 +155,7 @@ public class ConcreteTransactionalTestNGSpringContextTests extends AbstractTrans @Test @Transactional(propagation = Propagation.NOT_SUPPORTED) void verifyBeanNameSet() { - assertInTransaction(false); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); assertTrue(this.beanName.startsWith(getClass().getName()), "The bean name of this test instance " + "should have been set to the fully qualified class name due to BeanNameAware semantics."); } @@ -163,7 +163,7 @@ public class ConcreteTransactionalTestNGSpringContextTests extends AbstractTrans @Test @Transactional(propagation = Propagation.NOT_SUPPORTED) void verifyApplicationContextSet() { - assertInTransaction(false); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); assertNotNull(super.applicationContext, "The application context should have been set due to ApplicationContextAware semantics."); Employee employeeBean = (Employee) super.applicationContext.getBean("employee"); @@ -173,7 +173,7 @@ public class ConcreteTransactionalTestNGSpringContextTests extends AbstractTrans @Test @Transactional(propagation = Propagation.NOT_SUPPORTED) void verifyBeanInitialized() { - assertInTransaction(false); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); assertTrue(beanInitialized, "This test instance should have been initialized due to InitializingBean semantics."); } @@ -181,7 +181,7 @@ public class ConcreteTransactionalTestNGSpringContextTests extends AbstractTrans @Test @Transactional(propagation = Propagation.NOT_SUPPORTED) void verifyAnnotationAutowiredFields() { - assertInTransaction(false); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); assertNull(nonrequiredLong, "The nonrequiredLong field should NOT have been autowired."); assertNotNull(pet, "The pet field should have been autowired."); assertEquals(pet.getName(), "Fido", "pet's name."); @@ -190,7 +190,7 @@ public class ConcreteTransactionalTestNGSpringContextTests extends AbstractTrans @Test @Transactional(propagation = Propagation.NOT_SUPPORTED) void verifyAnnotationAutowiredMethods() { - assertInTransaction(false); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); assertNotNull(employee, "The setEmployee() method should have been autowired."); assertEquals(employee.getName(), "John Smith", "employee's name."); } @@ -198,20 +198,20 @@ public class ConcreteTransactionalTestNGSpringContextTests extends AbstractTrans @Test @Transactional(propagation = Propagation.NOT_SUPPORTED) void verifyResourceAnnotationInjectedFields() { - assertInTransaction(false); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); assertEquals(foo, "Foo", "The foo field should have been injected via @Resource."); } @Test @Transactional(propagation = Propagation.NOT_SUPPORTED) void verifyResourceAnnotationInjectedMethods() { - assertInTransaction(false); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); assertEquals(bar, "Bar", "The setBar() method should have been injected via @Resource."); } @Test void modifyTestDataWithinTransaction() { - assertInTransaction(true); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); assertAddPerson(JANE); assertAddPerson(SUE); assertNumRowsInPersonTable(4, "in modifyTestDataWithinTransaction()"); diff --git a/spring-test/src/test/java/org/springframework/test/context/testng/DirtiesContextTransactionalTestNGSpringContextTests.java b/spring-test/src/test/java/org/springframework/test/context/testng/DirtiesContextTransactionalTestNGSpringContextTests.java index 972e512c0c2..854cea7f3ae 100644 --- a/spring-test/src/test/java/org/springframework/test/context/testng/DirtiesContextTransactionalTestNGSpringContextTests.java +++ b/spring-test/src/test/java/org/springframework/test/context/testng/DirtiesContextTransactionalTestNGSpringContextTests.java @@ -22,8 +22,9 @@ import org.springframework.context.ApplicationContext; import org.springframework.test.annotation.DirtiesContext; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.TestContextManager; +import org.springframework.transaction.support.TransactionSynchronizationManager; -import static org.springframework.test.transaction.TransactionTestUtils.assertInTransaction; +import static org.assertj.core.api.Assertions.assertThat; import static org.testng.Assert.assertNotNull; import static org.testng.Assert.assertNotSame; import static org.testng.Assert.assertSame; @@ -55,7 +56,7 @@ public class DirtiesContextTransactionalTestNGSpringContextTests extends Abstrac private void performCommonAssertions() { - assertInTransaction(true); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); assertNotNull(super.applicationContext, "The application context should have been set due to ApplicationContextAware semantics."); assertNotNull(super.jdbcTemplate, diff --git a/spring-test/src/test/java/org/springframework/test/context/testng/TimedTransactionalTestNGSpringContextTests.java b/spring-test/src/test/java/org/springframework/test/context/testng/TimedTransactionalTestNGSpringContextTests.java index 103449cb6c2..5e64f436697 100644 --- a/spring-test/src/test/java/org/springframework/test/context/testng/TimedTransactionalTestNGSpringContextTests.java +++ b/spring-test/src/test/java/org/springframework/test/context/testng/TimedTransactionalTestNGSpringContextTests.java @@ -19,8 +19,9 @@ package org.springframework.test.context.testng; import org.testng.annotations.Test; import org.springframework.test.context.ContextConfiguration; +import org.springframework.transaction.support.TransactionSynchronizationManager; -import static org.springframework.test.transaction.TransactionTestUtils.assertInTransaction; +import static org.assertj.core.api.Assertions.assertThat; /** * Timed integration tests for @@ -36,13 +37,13 @@ public class TimedTransactionalTestNGSpringContextTests extends AbstractTransact @Test public void testWithoutTimeout() { - assertInTransaction(true); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); } // TODO Enable TestNG test with timeout once we have a solution. @Test(timeOut = 10000, enabled = false) public void testWithTimeout() { - assertInTransaction(true); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); } } diff --git a/spring-test/src/test/java/org/springframework/test/context/testng/transaction/programmatic/ProgrammaticTxMgmtTestNGTests.java b/spring-test/src/test/java/org/springframework/test/context/testng/transaction/programmatic/ProgrammaticTxMgmtTestNGTests.java index 41b5fd3944b..d030f9bdcb0 100644 --- a/spring-test/src/test/java/org/springframework/test/context/testng/transaction/programmatic/ProgrammaticTxMgmtTestNGTests.java +++ b/spring-test/src/test/java/org/springframework/test/context/testng/transaction/programmatic/ProgrammaticTxMgmtTestNGTests.java @@ -39,10 +39,10 @@ import org.springframework.test.context.transaction.programmatic.ProgrammaticTxM import org.springframework.transaction.PlatformTransactionManager; import org.springframework.transaction.annotation.Propagation; import org.springframework.transaction.annotation.Transactional; +import org.springframework.transaction.support.TransactionSynchronizationManager; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.fail; -import static org.springframework.test.transaction.TransactionTestUtils.assertInTransaction; /** * This class is a copy of the JUnit-based {@link ProgrammaticTxMgmtTests} class @@ -136,7 +136,7 @@ public class ProgrammaticTxMgmtTestNGTests extends AbstractTransactionalTestNGSp @Test public void commitTxAndStartNewTx() { - assertInTransaction(true); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); assertThat(TestTransaction.isActive()).isTrue(); assertUsers("Dilbert"); deleteFromTables("user"); @@ -146,7 +146,7 @@ public class ProgrammaticTxMgmtTestNGTests extends AbstractTransactionalTestNGSp TestTransaction.flagForCommit(); assertThat(TestTransaction.isFlaggedForRollback()).isFalse(); TestTransaction.end(); - assertInTransaction(false); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); assertThat(TestTransaction.isActive()).isFalse(); assertUsers(); @@ -154,13 +154,13 @@ public class ProgrammaticTxMgmtTestNGTests extends AbstractTransactionalTestNGSp assertUsers("Dogbert"); TestTransaction.start(); - assertInTransaction(true); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); assertThat(TestTransaction.isActive()).isTrue(); } @Test public void commitTxButDoNotStartNewTx() { - assertInTransaction(true); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); assertThat(TestTransaction.isActive()).isTrue(); assertUsers("Dilbert"); deleteFromTables("user"); @@ -171,7 +171,7 @@ public class ProgrammaticTxMgmtTestNGTests extends AbstractTransactionalTestNGSp assertThat(TestTransaction.isFlaggedForRollback()).isFalse(); TestTransaction.end(); assertThat(TestTransaction.isActive()).isFalse(); - assertInTransaction(false); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); assertUsers(); executeSqlScript("classpath:/org/springframework/test/context/jdbc/data-add-dogbert.sql", false); @@ -180,7 +180,7 @@ public class ProgrammaticTxMgmtTestNGTests extends AbstractTransactionalTestNGSp @Test public void rollbackTxAndStartNewTx() { - assertInTransaction(true); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); assertThat(TestTransaction.isActive()).isTrue(); assertUsers("Dilbert"); deleteFromTables("user"); @@ -190,12 +190,12 @@ public class ProgrammaticTxMgmtTestNGTests extends AbstractTransactionalTestNGSp assertThat(TestTransaction.isFlaggedForRollback()).isTrue(); TestTransaction.end(); assertThat(TestTransaction.isActive()).isFalse(); - assertInTransaction(false); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); assertUsers("Dilbert"); // Start new transaction with default rollback semantics TestTransaction.start(); - assertInTransaction(true); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); assertThat(TestTransaction.isFlaggedForRollback()).isTrue(); assertThat(TestTransaction.isActive()).isTrue(); @@ -205,7 +205,7 @@ public class ProgrammaticTxMgmtTestNGTests extends AbstractTransactionalTestNGSp @Test public void rollbackTxButDoNotStartNewTx() { - assertInTransaction(true); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); assertThat(TestTransaction.isActive()).isTrue(); assertUsers("Dilbert"); deleteFromTables("user"); @@ -215,14 +215,14 @@ public class ProgrammaticTxMgmtTestNGTests extends AbstractTransactionalTestNGSp assertThat(TestTransaction.isFlaggedForRollback()).isTrue(); TestTransaction.end(); assertThat(TestTransaction.isActive()).isFalse(); - assertInTransaction(false); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); assertUsers("Dilbert"); } @Test @Commit public void rollbackTxAndStartNewTxWithDefaultCommitSemantics() { - assertInTransaction(true); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); assertThat(TestTransaction.isActive()).isTrue(); assertUsers("Dilbert"); deleteFromTables("user"); @@ -233,12 +233,12 @@ public class ProgrammaticTxMgmtTestNGTests extends AbstractTransactionalTestNGSp assertThat(TestTransaction.isFlaggedForRollback()).isTrue(); TestTransaction.end(); assertThat(TestTransaction.isActive()).isFalse(); - assertInTransaction(false); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); assertUsers("Dilbert"); // Start new transaction with default commit semantics TestTransaction.start(); - assertInTransaction(true); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); assertThat(TestTransaction.isFlaggedForRollback()).isFalse(); assertThat(TestTransaction.isActive()).isTrue(); diff --git a/spring-test/src/test/java/org/springframework/test/context/transaction/PrimaryTransactionManagerTests.java b/spring-test/src/test/java/org/springframework/test/context/transaction/PrimaryTransactionManagerTests.java index 940c4c3ea16..f7efd7f4971 100644 --- a/spring-test/src/test/java/org/springframework/test/context/transaction/PrimaryTransactionManagerTests.java +++ b/spring-test/src/test/java/org/springframework/test/context/transaction/PrimaryTransactionManagerTests.java @@ -34,10 +34,10 @@ import org.springframework.test.annotation.DirtiesContext; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; import org.springframework.test.jdbc.JdbcTestUtils; -import org.springframework.test.transaction.TransactionTestUtils; import org.springframework.transaction.PlatformTransactionManager; import org.springframework.transaction.annotation.EnableTransactionManagement; import org.springframework.transaction.annotation.Transactional; +import org.springframework.transaction.support.TransactionSynchronizationManager; import static org.assertj.core.api.Assertions.assertThat; @@ -76,7 +76,7 @@ public final class PrimaryTransactionManagerTests { @Test @Transactional public void transactionalTest() { - TransactionTestUtils.assertInTransaction(true); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); ClassPathResource resource = new ClassPathResource("/org/springframework/test/context/jdbc/data.sql"); new ResourceDatabasePopulator(resource).execute(jdbcTemplate.getDataSource()); diff --git a/spring-test/src/test/java/org/springframework/test/context/transaction/programmatic/ProgrammaticTxMgmtTests.java b/spring-test/src/test/java/org/springframework/test/context/transaction/programmatic/ProgrammaticTxMgmtTests.java index ea286f9bd8b..acbd6a56d2b 100644 --- a/spring-test/src/test/java/org/springframework/test/context/transaction/programmatic/ProgrammaticTxMgmtTests.java +++ b/spring-test/src/test/java/org/springframework/test/context/transaction/programmatic/ProgrammaticTxMgmtTests.java @@ -46,10 +46,10 @@ import org.springframework.test.jdbc.JdbcTestUtils; import org.springframework.transaction.PlatformTransactionManager; import org.springframework.transaction.annotation.Propagation; import org.springframework.transaction.annotation.Transactional; +import org.springframework.transaction.support.TransactionSynchronizationManager; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.fail; -import static org.springframework.test.transaction.TransactionTestUtils.assertInTransaction; /** * JUnit-based integration tests that verify support for programmatic transaction @@ -154,7 +154,7 @@ public class ProgrammaticTxMgmtTests { @Test public void commitTxAndStartNewTx() { - assertInTransaction(true); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); assertThat(TestTransaction.isActive()).isTrue(); assertUsers("Dilbert"); deleteFromTables("user"); @@ -164,7 +164,7 @@ public class ProgrammaticTxMgmtTests { TestTransaction.flagForCommit(); assertThat(TestTransaction.isFlaggedForRollback()).isFalse(); TestTransaction.end(); - assertInTransaction(false); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); assertThat(TestTransaction.isActive()).isFalse(); assertUsers(); @@ -172,13 +172,13 @@ public class ProgrammaticTxMgmtTests { assertUsers("Dogbert"); TestTransaction.start(); - assertInTransaction(true); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); assertThat(TestTransaction.isActive()).isTrue(); } @Test public void commitTxButDoNotStartNewTx() { - assertInTransaction(true); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); assertThat(TestTransaction.isActive()).isTrue(); assertUsers("Dilbert"); deleteFromTables("user"); @@ -189,7 +189,7 @@ public class ProgrammaticTxMgmtTests { assertThat(TestTransaction.isFlaggedForRollback()).isFalse(); TestTransaction.end(); assertThat(TestTransaction.isActive()).isFalse(); - assertInTransaction(false); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); assertUsers(); executeSqlScript("classpath:/org/springframework/test/context/jdbc/data-add-dogbert.sql", false); @@ -198,7 +198,7 @@ public class ProgrammaticTxMgmtTests { @Test public void rollbackTxAndStartNewTx() { - assertInTransaction(true); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); assertThat(TestTransaction.isActive()).isTrue(); assertUsers("Dilbert"); deleteFromTables("user"); @@ -208,12 +208,12 @@ public class ProgrammaticTxMgmtTests { assertThat(TestTransaction.isFlaggedForRollback()).isTrue(); TestTransaction.end(); assertThat(TestTransaction.isActive()).isFalse(); - assertInTransaction(false); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); assertUsers("Dilbert"); // Start new transaction with default rollback semantics TestTransaction.start(); - assertInTransaction(true); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); assertThat(TestTransaction.isFlaggedForRollback()).isTrue(); assertThat(TestTransaction.isActive()).isTrue(); @@ -223,7 +223,7 @@ public class ProgrammaticTxMgmtTests { @Test public void rollbackTxButDoNotStartNewTx() { - assertInTransaction(true); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); assertThat(TestTransaction.isActive()).isTrue(); assertUsers("Dilbert"); deleteFromTables("user"); @@ -233,14 +233,14 @@ public class ProgrammaticTxMgmtTests { assertThat(TestTransaction.isFlaggedForRollback()).isTrue(); TestTransaction.end(); assertThat(TestTransaction.isActive()).isFalse(); - assertInTransaction(false); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); assertUsers("Dilbert"); } @Test @Commit public void rollbackTxAndStartNewTxWithDefaultCommitSemantics() { - assertInTransaction(true); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); assertThat(TestTransaction.isActive()).isTrue(); assertUsers("Dilbert"); deleteFromTables("user"); @@ -251,12 +251,12 @@ public class ProgrammaticTxMgmtTests { assertThat(TestTransaction.isFlaggedForRollback()).isTrue(); TestTransaction.end(); assertThat(TestTransaction.isActive()).isFalse(); - assertInTransaction(false); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); assertUsers("Dilbert"); // Start new transaction with default commit semantics TestTransaction.start(); - assertInTransaction(true); + assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); assertThat(TestTransaction.isFlaggedForRollback()).isFalse(); assertThat(TestTransaction.isActive()).isTrue(); @@ -264,8 +264,6 @@ public class ProgrammaticTxMgmtTests { assertUsers("Dilbert", "Dogbert"); } - // ------------------------------------------------------------------------- - protected int deleteFromTables(String... names) { return JdbcTestUtils.deleteFromTables(this.jdbcTemplate, names); } diff --git a/spring-test/src/test/java/org/springframework/test/transaction/TransactionTestUtils.java b/spring-test/src/test/java/org/springframework/test/transaction/TransactionTestUtils.java deleted file mode 100644 index 02ef2b92509..00000000000 --- a/spring-test/src/test/java/org/springframework/test/transaction/TransactionTestUtils.java +++ /dev/null @@ -1,82 +0,0 @@ -/* - * Copyright 2002-2012 the original author or authors. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * https://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.springframework.test.transaction; - -import org.springframework.transaction.support.TransactionSynchronizationManager; - -/** - * Collection of JDK 1.4+ utilities for tests involving transactions. Intended - * for internal use within the Spring testing suite. - * - *

All {@code assert*()} methods throw {@link AssertionError}s. - * - * @author Sam Brannen - * @since 2.5 - */ -public abstract class TransactionTestUtils { - - /** - * Convenience method for determining if a transaction is active for the - * current {@link Thread}. - * @return {@code true} if a transaction is currently active - */ - public static boolean inTransaction() { - return TransactionSynchronizationManager.isActualTransactionActive(); - } - - /** - * Asserts whether or not a transaction is active for the current - * {@link Thread}. - * @param transactionExpected whether or not a transaction is expected - * @throws AssertionError if the supplied assertion fails - * @see #inTransaction() - */ - public static void assertInTransaction(boolean transactionExpected) { - if (transactionExpected) { - assertCondition(inTransaction(), "The current thread should be associated with a transaction."); - } - else { - assertCondition(!inTransaction(), "The current thread should not be associated with a transaction"); - } - } - - /** - * Fails by throwing an {@code AssertionError} with the supplied - * {@code message}. - * @param message the exception message to use - * @see #assertCondition(boolean, String) - */ - private static void fail(String message) throws AssertionError { - throw new AssertionError(message); - } - - /** - * Assert the provided boolean {@code condition}, throwing - * {@code AssertionError} with the supplied {@code message} if - * the test result is {@code false}. - * @param condition a boolean expression - * @param message the exception message to use if the assertion fails - * @throws AssertionError if condition is {@code false} - * @see #fail(String) - */ - private static void assertCondition(boolean condition, String message) throws AssertionError { - if (!condition) { - fail(message); - } - } - -}