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 6cb0c6419dc..e65b750a87c 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.TransactionAssert.assertThatTransaction; /** * 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() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); + assertThatTransaction().isNotActive(); 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() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); + assertThatTransaction().isNotActive(); 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 cc50d927604..5101e75f46c 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.TransactionAssert.assertThatTransaction; /** * 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() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); + assertThatTransaction().isNotActive(); assertUsers(new JdbcTemplate(dataSource1), "Dilbert", "Dogbert"); } @Test @Sql(scripts = "data-add-catbert.sql", config = @SqlConfig(transactionManager = "txMgr2")) public void database2() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); + assertThatTransaction().isNotActive(); 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 6126725423b..91871e8f38f 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.TransactionAssert.assertThatTransaction; /** * 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() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + assertThatTransaction().isActive(); 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() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + assertThatTransaction().isActive(); 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 0a01e8fbf91..225c766e2ca 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,9 +31,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.TransactionAssert.assertThatTransaction; /** * Integration tests that ensure that primary data sources are @@ -81,7 +81,7 @@ public class PrimaryDataSourceTests { @Test @Sql("data.sql") public void dataSourceTest() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); + assertThatTransaction().isNotActive(); 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 f36695f1938..fdf02dbbd84 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.TransactionAssert.assertThatTransaction; /** * JUnit 4 based integration test which verifies @@ -79,7 +79,7 @@ public class BeforeAndAfterTransactionAnnotationTests extends AbstractTransactio @BeforeTransaction void beforeTransaction() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); + assertThatTransaction().isNotActive(); this.inTransaction = true; BeforeAndAfterTransactionAnnotationTests.numBeforeTransactionCalls++; clearPersonTable(jdbcTemplate); @@ -88,7 +88,7 @@ public class BeforeAndAfterTransactionAnnotationTests extends AbstractTransactio @AfterTransaction void afterTransaction() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); + assertThatTransaction().isNotActive(); 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"); - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isEqualTo(shouldBeInTransaction); + assertThatTransaction().isInTransaction(shouldBeInTransaction); } @After @@ -115,14 +115,14 @@ public class BeforeAndAfterTransactionAnnotationTests extends AbstractTransactio @Test public void transactionalMethod1() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + assertThatTransaction().isActive(); 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() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + assertThatTransaction().isActive(); 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() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); + assertThatTransaction().isNotActive(); 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 59a6ec27af3..a72d3064971 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.TransactionAssert.assertThatTransaction; /** * JUnit 4 based integration test which verifies support of Spring's @@ -82,7 +82,7 @@ public class ClassLevelTransactionalSpringRunnerTests extends AbstractTransactio @Test public void modifyTestDataWithinTransaction() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + assertThatTransaction().isActive(); 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() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); + assertThatTransaction().isNotActive(); 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 ccb9fe50b45..1a1df45c172 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,9 +32,10 @@ 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.TransactionAssert.assertThatTransaction; +import static org.springframework.transaction.support.TransactionSynchronizationManager.isActualTransactionActive; /** * Combined integration test for {@link AbstractJUnit4SpringContextTests} and @@ -92,13 +93,13 @@ public class ConcreteTransactionalJUnit4SpringContextTests extends AbstractTrans @Before public void setUp() { - long expected = (TransactionSynchronizationManager.isActualTransactionActive() ? 2 : 1); + long expected = (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 = (TransactionSynchronizationManager.isActualTransactionActive() ? 4 : 1); + long expected = (isActualTransactionActive() ? 4 : 1); assertThat(countRowsInPersonTable()).as("Verifying the number of rows in the person table after a test method.").isEqualTo(expected); } @@ -118,7 +119,7 @@ public class ConcreteTransactionalJUnit4SpringContextTests extends AbstractTrans @Test @Transactional(propagation = Propagation.NOT_SUPPORTED) public void verifyBeanNameSet() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); + assertThatTransaction().isNotActive(); 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(); } @@ -126,21 +127,21 @@ public class ConcreteTransactionalJUnit4SpringContextTests extends AbstractTrans @Test @Transactional(propagation = Propagation.NOT_SUPPORTED) public void verifyApplicationContext() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); + assertThatTransaction().isNotActive(); 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() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); + assertThatTransaction().isNotActive(); 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() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); + assertThatTransaction().isNotActive(); 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"); @@ -149,7 +150,7 @@ public class ConcreteTransactionalJUnit4SpringContextTests extends AbstractTrans @Test @Transactional(propagation = Propagation.NOT_SUPPORTED) public void verifyAnnotationAutowiredMethods() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); + assertThatTransaction().isNotActive(); assertThat(this.employee).as("The employee setter method should have been autowired.").isNotNull(); assertThat(this.employee.getName()).isEqualTo("John Smith"); } @@ -157,20 +158,20 @@ public class ConcreteTransactionalJUnit4SpringContextTests extends AbstractTrans @Test @Transactional(propagation = Propagation.NOT_SUPPORTED) public void verifyResourceAnnotationWiredFields() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); + assertThatTransaction().isNotActive(); assertThat(this.foo).as("The foo field should have been wired via @Resource.").isEqualTo("Foo"); } @Test @Transactional(propagation = Propagation.NOT_SUPPORTED) public void verifyResourceAnnotationWiredMethods() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); + assertThatTransaction().isNotActive(); assertThat(this.bar).as("The bar method should have been wired via @Resource.").isEqualTo("Bar"); } @Test public void modifyTestDataWithinTransaction() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + assertThatTransaction().isActive(); 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 e9f503f01ed..01606bc62df 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.TransactionAssert.assertThatTransaction; /** * Integration test which verifies proper transactional behavior when the @@ -69,7 +69,7 @@ public class DefaultRollbackFalseRollbackAnnotationTransactionalTests extends Ab @Test public void modifyTestDataWithinTransaction() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + assertThatTransaction().isActive(); 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 271836eb5b2..280ee36bd41 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.TransactionAssert.assertThatTransaction; /** * 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() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + assertThatTransaction().isActive(); 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 862cf0b8446..1c959ac6712 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.TransactionAssert.assertThatTransaction; /** * 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() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + assertThatTransaction().isActive(); 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() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); + assertThatTransaction().isNotActive(); 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 11719d1d9be..433bf43bda4 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.TransactionAssert.assertThatTransaction; /** * Extension of {@link DefaultRollbackFalseRollbackAnnotationTransactionalTests} @@ -64,7 +64,7 @@ public class RollbackOverrideDefaultRollbackFalseRollbackAnnotationTransactional @Rollback @Override public void modifyTestDataWithinTransaction() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + assertThatTransaction().isActive(); 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 eae19a1f744..deb69f9ea47 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.TransactionAssert.assertThatTransaction; /** * Extension of {@link DefaultRollbackFalseRollbackAnnotationTransactionalTests} @@ -64,7 +64,7 @@ public class RollbackOverrideDefaultRollbackFalseTransactionalTests @Rollback @Override public void modifyTestDataWithinTransaction() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + assertThatTransaction().isActive(); 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 3ee5a1da5e6..b9b11774f9f 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.TransactionAssert.assertThatTransaction; /** * Extension of {@link DefaultRollbackTrueRollbackAnnotationTransactionalTests} @@ -63,7 +63,7 @@ public class RollbackOverrideDefaultRollbackTrueRollbackAnnotationTransactionalT @Rollback(false) @Override public void modifyTestDataWithinTransaction() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + assertThatTransaction().isActive(); 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 7d4c6360bed..60a6183def0 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.TransactionAssert.assertThatTransaction; /** * Extension of {@link DefaultRollbackTrueRollbackAnnotationTransactionalTests} @@ -61,7 +61,7 @@ public class RollbackOverrideDefaultRollbackTrueTransactionalTests @Rollback(false) @Override public void modifyTestDataWithinTransaction() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + assertThatTransaction().isActive(); 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 213acb66e1f..99737d3ca67 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,9 +24,8 @@ 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.assertj.core.api.Assertions.assertThat; +import static org.springframework.test.transaction.TransactionAssert.assertThatTransaction; /** * JUnit 4 based integration test which verifies support of Spring's @@ -46,13 +45,13 @@ public class TimedTransactionalSpringRunnerTests { @Timed(millis = 10000) @Repeat(5) public void transactionalWithSpringTimeout() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + assertThatTransaction().isActive(); } @Test(timeout = 10000) @Repeat(5) public void transactionalWithJUnitTimeout() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + assertThatTransaction().isActive(); } @Test @@ -60,14 +59,14 @@ public class TimedTransactionalSpringRunnerTests { @Timed(millis = 10000) @Repeat(5) public void notTransactionalWithSpringTimeout() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); + assertThatTransaction().isNotActive(); } @Test(timeout = 10000) @Transactional(propagation = Propagation.NOT_SUPPORTED) @Repeat(5) public void notTransactionalWithJUnitTimeout() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); + assertThatTransaction().isNotActive(); } } 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 05ef79e9fb8..6c0dc92e900 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.TransactionAssert.assertThatTransaction; /** * Transactional integration tests regarding manual session flushing with @@ -60,7 +60,7 @@ public class HibernateSessionFlushingTests extends AbstractTransactionalJUnit4Sp @Before public void setup() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + assertThatTransaction().isActive(); 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 d5b69ec5601..834ac9a72e4 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,9 +27,8 @@ 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.assertj.core.api.Assertions.assertThat; +import static org.springframework.test.transaction.TransactionAssert.assertThatTransaction; /** * This class is an extension of {@link TimedTransactionalSpringRunnerTests} @@ -60,7 +59,7 @@ public class TimedTransactionalSpringRuleTests extends TimedTransactionalSpringR @Repeat(5) @Override public void transactionalWithJUnitTimeout() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); + assertThatTransaction().isNotActive(); } /** @@ -68,7 +67,7 @@ public class TimedTransactionalSpringRuleTests extends TimedTransactionalSpringR */ @Test public void transactionalWithJUnitRuleBasedTimeout() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + assertThatTransaction().isActive(); } // 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 47e99bdcb23..116674b3ed8 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,9 +33,10 @@ 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.TransactionAssert.assertThatTransaction; +import static org.springframework.transaction.support.TransactionSynchronizationManager.isActualTransactionActive; /** * This set of tests (i.e., all concrete subclasses) investigates the claims made in @@ -108,13 +109,13 @@ public abstract class AbstractTransactionalAnnotatedConfigClassTests { @Before public void setUp() throws Exception { - assertNumRowsInPersonTable((TransactionSynchronizationManager.isActualTransactionActive() ? 1 : 0), "before a test method"); + assertNumRowsInPersonTable((isActualTransactionActive() ? 1 : 0), "before a test method"); } @Test @Transactional public void modifyTestDataWithinTransaction() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + assertThatTransaction().isActive(); assertAddPerson(JANE); assertAddPerson(SUE); assertNumRowsInPersonTable(3, "in modifyTestDataWithinTransaction()"); @@ -122,7 +123,7 @@ public abstract class AbstractTransactionalAnnotatedConfigClassTests { @After public void tearDown() throws Exception { - assertNumRowsInPersonTable((TransactionSynchronizationManager.isActualTransactionActive() ? 3 : 0), "after a test method"); + assertNumRowsInPersonTable((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 402fdcc2f70..12c2171d1e9 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.assertj.core.api.Assertions.assertThat; +import static org.springframework.test.transaction.TransactionAssert.assertThatTransaction; +import static org.springframework.transaction.support.TransactionSynchronizationManager.isActualTransactionActive; 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 (TransactionSynchronizationManager.isActualTransactionActive()) { + if (isActualTransactionActive()) { numSetUpCallsInTransaction++; } - assertNumRowsInPersonTable((TransactionSynchronizationManager.isActualTransactionActive() ? 2 : 1), "before a test method"); + assertNumRowsInPersonTable((isActualTransactionActive() ? 2 : 1), "before a test method"); } @Test void modifyTestDataWithinTransaction() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + assertThatTransaction().isActive(); assertAddPerson(JANE); assertAddPerson(SUE); assertNumRowsInPersonTable(4, "in modifyTestDataWithinTransaction()"); @@ -146,10 +146,10 @@ public class AnnotationConfigTransactionalTestNGSpringContextTests @AfterMethod void tearDown() throws Exception { numTearDownCalls++; - if (TransactionSynchronizationManager.isActualTransactionActive()) { + if (isActualTransactionActive()) { numTearDownCallsInTransaction++; } - assertNumRowsInPersonTable((TransactionSynchronizationManager.isActualTransactionActive() ? 4 : 1), "after a test method"); + assertNumRowsInPersonTable((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 79cb87e7514..b737e0af11a 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.assertj.core.api.Assertions.assertThat; +import static org.springframework.test.transaction.TransactionAssert.assertThatTransaction; +import static org.springframework.transaction.support.TransactionSynchronizationManager.isActualTransactionActive; 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 (TransactionSynchronizationManager.isActualTransactionActive()) { + if (isActualTransactionActive()) { numSetUpCallsInTransaction++; } - assertNumRowsInPersonTable((TransactionSynchronizationManager.isActualTransactionActive() ? 2 : 1), "before a test method"); + assertNumRowsInPersonTable((isActualTransactionActive() ? 2 : 1), "before a test method"); } @AfterMethod void tearDown() { numTearDownCalls++; - if (TransactionSynchronizationManager.isActualTransactionActive()) { + if (isActualTransactionActive()) { numTearDownCallsInTransaction++; } - assertNumRowsInPersonTable((TransactionSynchronizationManager.isActualTransactionActive() ? 4 : 1), "after a test method"); + assertNumRowsInPersonTable((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() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); + assertThatTransaction().isNotActive(); 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() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); + assertThatTransaction().isNotActive(); 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() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); + assertThatTransaction().isNotActive(); 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() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); + assertThatTransaction().isNotActive(); 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() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); + assertThatTransaction().isNotActive(); 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() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); + assertThatTransaction().isNotActive(); assertEquals(foo, "Foo", "The foo field should have been injected via @Resource."); } @Test @Transactional(propagation = Propagation.NOT_SUPPORTED) void verifyResourceAnnotationInjectedMethods() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); + assertThatTransaction().isNotActive(); assertEquals(bar, "Bar", "The setBar() method should have been injected via @Resource."); } @Test void modifyTestDataWithinTransaction() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + assertThatTransaction().isActive(); 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 854cea7f3ae..d0e761ffe99 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,9 +22,8 @@ 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.assertj.core.api.Assertions.assertThat; +import static org.springframework.test.transaction.TransactionAssert.assertThatTransaction; import static org.testng.Assert.assertNotNull; import static org.testng.Assert.assertNotSame; import static org.testng.Assert.assertSame; @@ -56,7 +55,7 @@ public class DirtiesContextTransactionalTestNGSpringContextTests extends Abstrac private void performCommonAssertions() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + assertThatTransaction().isActive(); 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 5e64f436697..0d0ff990b75 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,9 +19,8 @@ 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.assertj.core.api.Assertions.assertThat; +import static org.springframework.test.transaction.TransactionAssert.assertThatTransaction; /** * Timed integration tests for @@ -37,13 +36,13 @@ public class TimedTransactionalTestNGSpringContextTests extends AbstractTransact @Test public void testWithoutTimeout() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + assertThatTransaction().isActive(); } // TODO Enable TestNG test with timeout once we have a solution. @Test(timeOut = 10000, enabled = false) public void testWithTimeout() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + assertThatTransaction().isActive(); } } 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 d030f9bdcb0..e6d74c801a0 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.TransactionAssert.assertThatTransaction; /** * 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() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + assertThatTransaction().isActive(); 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(); - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); + assertThatTransaction().isNotActive(); assertThat(TestTransaction.isActive()).isFalse(); assertUsers(); @@ -154,13 +154,13 @@ public class ProgrammaticTxMgmtTestNGTests extends AbstractTransactionalTestNGSp assertUsers("Dogbert"); TestTransaction.start(); - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + assertThatTransaction().isActive(); assertThat(TestTransaction.isActive()).isTrue(); } @Test public void commitTxButDoNotStartNewTx() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + assertThatTransaction().isActive(); 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(); - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); + assertThatTransaction().isNotActive(); 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() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + assertThatTransaction().isActive(); 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(); - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); + assertThatTransaction().isNotActive(); assertUsers("Dilbert"); // Start new transaction with default rollback semantics TestTransaction.start(); - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + assertThatTransaction().isActive(); assertThat(TestTransaction.isFlaggedForRollback()).isTrue(); assertThat(TestTransaction.isActive()).isTrue(); @@ -205,7 +205,7 @@ public class ProgrammaticTxMgmtTestNGTests extends AbstractTransactionalTestNGSp @Test public void rollbackTxButDoNotStartNewTx() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + assertThatTransaction().isActive(); 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(); - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); + assertThatTransaction().isNotActive(); assertUsers("Dilbert"); } @Test @Commit public void rollbackTxAndStartNewTxWithDefaultCommitSemantics() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + assertThatTransaction().isActive(); 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(); - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); + assertThatTransaction().isNotActive(); assertUsers("Dilbert"); // Start new transaction with default commit semantics TestTransaction.start(); - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + assertThatTransaction().isActive(); 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 f7efd7f4971..247b60208de 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 @@ -37,9 +37,9 @@ import org.springframework.test.jdbc.JdbcTestUtils; 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; +import static org.springframework.test.transaction.TransactionAssert.assertThatTransaction; /** * Integration tests that ensure that primary transaction managers @@ -76,7 +76,7 @@ public final class PrimaryTransactionManagerTests { @Test @Transactional public void transactionalTest() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + assertThatTransaction().isActive(); 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 acbd6a56d2b..74012a21e9a 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.TransactionAssert.assertThatTransaction; /** * JUnit-based integration tests that verify support for programmatic transaction @@ -154,7 +154,7 @@ public class ProgrammaticTxMgmtTests { @Test public void commitTxAndStartNewTx() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + assertThatTransaction().isActive(); assertThat(TestTransaction.isActive()).isTrue(); assertUsers("Dilbert"); deleteFromTables("user"); @@ -164,7 +164,7 @@ public class ProgrammaticTxMgmtTests { TestTransaction.flagForCommit(); assertThat(TestTransaction.isFlaggedForRollback()).isFalse(); TestTransaction.end(); - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); + assertThatTransaction().isNotActive(); assertThat(TestTransaction.isActive()).isFalse(); assertUsers(); @@ -172,13 +172,13 @@ public class ProgrammaticTxMgmtTests { assertUsers("Dogbert"); TestTransaction.start(); - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + assertThatTransaction().isActive(); assertThat(TestTransaction.isActive()).isTrue(); } @Test public void commitTxButDoNotStartNewTx() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + assertThatTransaction().isActive(); 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(); - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); + assertThatTransaction().isNotActive(); assertUsers(); executeSqlScript("classpath:/org/springframework/test/context/jdbc/data-add-dogbert.sql", false); @@ -198,7 +198,7 @@ public class ProgrammaticTxMgmtTests { @Test public void rollbackTxAndStartNewTx() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + assertThatTransaction().isActive(); 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(); - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); + assertThatTransaction().isNotActive(); assertUsers("Dilbert"); // Start new transaction with default rollback semantics TestTransaction.start(); - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + assertThatTransaction().isActive(); assertThat(TestTransaction.isFlaggedForRollback()).isTrue(); assertThat(TestTransaction.isActive()).isTrue(); @@ -223,7 +223,7 @@ public class ProgrammaticTxMgmtTests { @Test public void rollbackTxButDoNotStartNewTx() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + assertThatTransaction().isActive(); 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(); - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); + assertThatTransaction().isNotActive(); assertUsers("Dilbert"); } @Test @Commit public void rollbackTxAndStartNewTxWithDefaultCommitSemantics() { - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + assertThatTransaction().isActive(); 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(); - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse(); + assertThatTransaction().isNotActive(); assertUsers("Dilbert"); // Start new transaction with default commit semantics TestTransaction.start(); - assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue(); + assertThatTransaction().isActive(); assertThat(TestTransaction.isFlaggedForRollback()).isFalse(); assertThat(TestTransaction.isActive()).isTrue(); @@ -281,7 +281,6 @@ public class ProgrammaticTxMgmtTests { assertThat(actual).as("Users in database;").isEqualTo(expected); } - // ------------------------------------------------------------------------- @Configuration static class Config { diff --git a/spring-test/src/test/java/org/springframework/test/transaction/TransactionAssert.java b/spring-test/src/test/java/org/springframework/test/transaction/TransactionAssert.java new file mode 100644 index 00000000000..39b9d1eeb45 --- /dev/null +++ b/spring-test/src/test/java/org/springframework/test/transaction/TransactionAssert.java @@ -0,0 +1,55 @@ +/* + * Copyright 2002-2019 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; + +import static org.assertj.core.api.Assertions.assertThat; + +/** + * Collection of assertions for tests involving transactions. Intended for + * internal use within the Spring testing suite. + * + * @author Sam Brannen + * @author Phillip Webb + * @since 5.2 + */ +public class TransactionAssert { + + private static final TransactionAssert instance = new TransactionAssert(); + + public TransactionAssert isActive() { + return isInTransaction(true); + } + + public TransactionAssert isNotActive() { + return isInTransaction(false); + + } + + public TransactionAssert isInTransaction(boolean expected) { + assertThat(TransactionSynchronizationManager.isActualTransactionActive()) + .as("active transaction") + .isEqualTo(expected); + return this; + } + + public static TransactionAssert assertThatTransaction() { + return instance; + } + +}