Inline methods from TransactionTestUtils

Delete `TransactionTestUtils` and inline AssertJ assertions
instead.

Closes gh-23022

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);
 	}
 

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");
 	}
 

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");
 	}
 

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);
 	}
 

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);

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);

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);

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);

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);

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);

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);

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);

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);

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);

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();
 	}
 
 }

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 <i>manual</i> 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();
 	}

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.

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

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.assertj.core.api.Assertions.assertThat;
-import static org.springframework.test.transaction.TransactionTestUtils.inTransaction;
 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

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.assertj.core.api.Assertions.assertThat;
-import static org.springframework.test.transaction.TransactionTestUtils.inTransaction;
 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()");

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,

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();
 	}
 
 }

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();
 

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());

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);
 	}

spring-test/src/test/java/org/springframework/test/transaction/TransactionTestUtils.java

@@ -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.
- *
- * <p>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);
-		}
-	}
-
-}