root
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Actions 8 Packages Projects Releases Wiki Activity

Inline methods from TransactionTestUtils 

Delete `TransactionTestUtils` and inline AssertJ assertions
instead.

Closes gh-23022
This commit is contained in:
Phillip Webb 2019-05-23 13:51:49 -07:00
parent 9d74da006c
commit 82d0e49de9
26 changed files with 121 additions and 203 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
spring-test/src/test/java/org/springframework/test/context/jdbc/DataSourceOnlySqlScriptsTests.java
View File

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

6
spring-test/src/test/java/org/springframework/test/context/jdbc/InferredDataSourceSqlScriptsTests.java
View File

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

6
spring-test/src/test/java/org/springframework/test/context/jdbc/InferredDataSourceTransactionalSqlScriptsTests.java
View File

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

4
spring-test/src/test/java/org/springframework/test/context/jdbc/PrimaryDataSourceTests.java
View File

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

14
spring-test/src/test/java/org/springframework/test/context/junit4/BeforeAndAfterTransactionAnnotationTests.java
View File

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

6
spring-test/src/test/java/org/springframework/test/context/junit4/ClassLevelTransactionalSpringRunnerTests.java
View File

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

23
spring-test/src/test/java/org/springframework/test/context/junit4/ConcreteTransactionalJUnit4SpringContextTests.java
View File

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

4
spring-test/src/test/java/org/springframework/test/context/junit4/DefaultRollbackFalseRollbackAnnotationTransactionalTests.java
View File

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

4
spring-test/src/test/java/org/springframework/test/context/junit4/DefaultRollbackTrueRollbackAnnotationTransactionalTests.java
View File

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

6
spring-test/src/test/java/org/springframework/test/context/junit4/MethodLevelTransactionalSpringRunnerTests.java
View File

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

4
spring-test/src/test/java/org/springframework/test/context/junit4/RollbackOverrideDefaultRollbackFalseRollbackAnnotationTransactionalTests.java
View File

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

4
spring-test/src/test/java/org/springframework/test/context/junit4/RollbackOverrideDefaultRollbackFalseTransactionalTests.java
View File

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

4
spring-test/src/test/java/org/springframework/test/context/junit4/RollbackOverrideDefaultRollbackTrueRollbackAnnotationTransactionalTests.java
View File

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

4
spring-test/src/test/java/org/springframework/test/context/junit4/RollbackOverrideDefaultRollbackTrueTransactionalTests.java
View File

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

11
spring-test/src/test/java/org/springframework/test/context/junit4/TimedTransactionalSpringRunnerTests.java
View File

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

4
spring-test/src/test/java/org/springframework/test/context/junit4/orm/HibernateSessionFlushingTests.java
View File

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

7
spring-test/src/test/java/org/springframework/test/context/junit4/rules/TimedTransactionalSpringRuleTests.java
View File

@ -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.

9
spring-test/src/test/java/org/springframework/test/context/junit4/spr9051/AbstractTransactionalAnnotatedConfigClassTests.java
View File

@ -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

14
spring-test/src/test/java/org/springframework/test/context/testng/AnnotationConfigTransactionalTestNGSpringContextTests.java
View File

@ -37,9 +37,9 @@ import org.springframework.tests.sample.beans.Pet;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import static org.springframework.test.transaction.TransactionTestUtils.assertInTransaction;
import static org.springframework.test.transaction.TransactionTestUtils.inTransaction;
import static org.assertj.core.api.Assertions.assertThat;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertNotNull;
@ -129,15 +129,15 @@ public class AnnotationConfigTransactionalTestNGSpringContextTests
@BeforeMethod
void setUp() throws Exception {
numSetUpCalls++;
if (inTransaction()) {
if (TransactionSynchronizationManager.isActualTransactionActive()) {
numSetUpCallsInTransaction++;
}
assertNumRowsInPersonTable((inTransaction() ? 2 : 1), "before a test method");
assertNumRowsInPersonTable((TransactionSynchronizationManager.isActualTransactionActive() ? 2 : 1), "before a test method");
}
@Test
void modifyTestDataWithinTransaction() {
assertInTransaction(true);
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertAddPerson(JANE);
assertAddPerson(SUE);
assertNumRowsInPersonTable(4, "in modifyTestDataWithinTransaction()");
@ -146,10 +146,10 @@ public class AnnotationConfigTransactionalTestNGSpringContextTests
@AfterMethod
void tearDown() throws Exception {
numTearDownCalls++;
if (inTransaction()) {
if (TransactionSynchronizationManager.isActualTransactionActive()) {
numTearDownCallsInTransaction++;
}
assertNumRowsInPersonTable((inTransaction() ? 4 : 1), "after a test method");
assertNumRowsInPersonTable((TransactionSynchronizationManager.isActualTransactionActive() ? 4 : 1), "after a test method");
}
@AfterTransaction

28
spring-test/src/test/java/org/springframework/test/context/testng/ConcreteTransactionalTestNGSpringContextTests.java
View File

@ -34,9 +34,9 @@ import org.springframework.tests.sample.beans.Employee;
import org.springframework.tests.sample.beans.Pet;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import static org.springframework.test.transaction.TransactionTestUtils.assertInTransaction;
import static org.springframework.test.transaction.TransactionTestUtils.inTransaction;
import static org.assertj.core.api.Assertions.assertThat;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertNotNull;
import static org.testng.Assert.assertNull;
@ -124,19 +124,19 @@ public class ConcreteTransactionalTestNGSpringContextTests extends AbstractTrans
@BeforeMethod
void setUp() {
numSetUpCalls++;
if (inTransaction()) {
if (TransactionSynchronizationManager.isActualTransactionActive()) {
numSetUpCallsInTransaction++;
}
assertNumRowsInPersonTable((inTransaction() ? 2 : 1), "before a test method");
assertNumRowsInPersonTable((TransactionSynchronizationManager.isActualTransactionActive() ? 2 : 1), "before a test method");
}
@AfterMethod
void tearDown() {
numTearDownCalls++;
if (inTransaction()) {
if (TransactionSynchronizationManager.isActualTransactionActive()) {
numTearDownCallsInTransaction++;
}
assertNumRowsInPersonTable((inTransaction() ? 4 : 1), "after a test method");
assertNumRowsInPersonTable((TransactionSynchronizationManager.isActualTransactionActive() ? 4 : 1), "after a test method");
}
@BeforeTransaction
@ -155,7 +155,7 @@ public class ConcreteTransactionalTestNGSpringContextTests extends AbstractTrans
@Test
@Transactional(propagation = Propagation.NOT_SUPPORTED)
void verifyBeanNameSet() {
assertInTransaction(false);
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertTrue(this.beanName.startsWith(getClass().getName()), "The bean name of this test instance " +
"should have been set to the fully qualified class name due to BeanNameAware semantics.");
}
@ -163,7 +163,7 @@ public class ConcreteTransactionalTestNGSpringContextTests extends AbstractTrans
@Test
@Transactional(propagation = Propagation.NOT_SUPPORTED)
void verifyApplicationContextSet() {
assertInTransaction(false);
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertNotNull(super.applicationContext,
"The application context should have been set due to ApplicationContextAware semantics.");
Employee employeeBean = (Employee) super.applicationContext.getBean("employee");
@ -173,7 +173,7 @@ public class ConcreteTransactionalTestNGSpringContextTests extends AbstractTrans
@Test
@Transactional(propagation = Propagation.NOT_SUPPORTED)
void verifyBeanInitialized() {
assertInTransaction(false);
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertTrue(beanInitialized,
"This test instance should have been initialized due to InitializingBean semantics.");
}
@ -181,7 +181,7 @@ public class ConcreteTransactionalTestNGSpringContextTests extends AbstractTrans
@Test
@Transactional(propagation = Propagation.NOT_SUPPORTED)
void verifyAnnotationAutowiredFields() {
assertInTransaction(false);
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertNull(nonrequiredLong, "The nonrequiredLong field should NOT have been autowired.");
assertNotNull(pet, "The pet field should have been autowired.");
assertEquals(pet.getName(), "Fido", "pet's name.");
@ -190,7 +190,7 @@ public class ConcreteTransactionalTestNGSpringContextTests extends AbstractTrans
@Test
@Transactional(propagation = Propagation.NOT_SUPPORTED)
void verifyAnnotationAutowiredMethods() {
assertInTransaction(false);
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertNotNull(employee, "The setEmployee() method should have been autowired.");
assertEquals(employee.getName(), "John Smith", "employee's name.");
}
@ -198,20 +198,20 @@ public class ConcreteTransactionalTestNGSpringContextTests extends AbstractTrans
@Test
@Transactional(propagation = Propagation.NOT_SUPPORTED)
void verifyResourceAnnotationInjectedFields() {
assertInTransaction(false);
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertEquals(foo, "Foo", "The foo field should have been injected via @Resource.");
}
@Test
@Transactional(propagation = Propagation.NOT_SUPPORTED)
void verifyResourceAnnotationInjectedMethods() {
assertInTransaction(false);
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertEquals(bar, "Bar", "The setBar() method should have been injected via @Resource.");
}
@Test
void modifyTestDataWithinTransaction() {
assertInTransaction(true);
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertAddPerson(JANE);
assertAddPerson(SUE);
assertNumRowsInPersonTable(4, "in modifyTestDataWithinTransaction()");

5
spring-test/src/test/java/org/springframework/test/context/testng/DirtiesContextTransactionalTestNGSpringContextTests.java
View File

@ -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,

7
spring-test/src/test/java/org/springframework/test/context/testng/TimedTransactionalTestNGSpringContextTests.java
View File

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

28
spring-test/src/test/java/org/springframework/test/context/testng/transaction/programmatic/ProgrammaticTxMgmtTestNGTests.java
View File

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

4
spring-test/src/test/java/org/springframework/test/context/transaction/PrimaryTransactionManagerTests.java
View File

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

30
spring-test/src/test/java/org/springframework/test/context/transaction/programmatic/ProgrammaticTxMgmtTests.java
View File

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

82
spring-test/src/test/java/org/springframework/test/transaction/TransactionTestUtils.java
View File

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