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

Restore transaction specific assertions 

Revert 82d0e49d and instead create a `TransactionAssert` class.

Closes gh-23022
This commit is contained in:
Phillip Webb 2019-05-24 11:09:44 -07:00
parent 5a1217cafe
commit 6b9160b3ae
26 changed files with 174 additions and 122 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.TransactionAssert.assertThatTransaction;
/**
* Integration tests for {@link Sql @Sql} support with only a {@link DataSource}
@ -61,7 +61,7 @@ public class DataSourceOnlySqlScriptsTests {
@Test
// test##_ prefix is required for @FixMethodOrder.
public void test01_classLevelScripts() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThatTransaction().isNotActive();
assertNumUsers(1);
}
@ -69,7 +69,7 @@ public class DataSourceOnlySqlScriptsTests {
@Sql({ "drop-schema.sql", "schema.sql", "data.sql", "data-add-dogbert.sql" })
// test##_ prefix is required for @FixMethodOrder.
public void test02_methodLevelScripts() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThatTransaction().isNotActive();
assertNumUsers(2);
}

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.TransactionAssert.assertThatTransaction;
/**
* Integration tests for {@link Sql @Sql} that verify support for inferring
@ -61,14 +61,14 @@ public class InferredDataSourceSqlScriptsTests {
@Test
@Sql(scripts = "data-add-dogbert.sql", config = @SqlConfig(transactionManager = "txMgr1"))
public void database1() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThatTransaction().isNotActive();
assertUsers(new JdbcTemplate(dataSource1), "Dilbert", "Dogbert");
}
@Test
@Sql(scripts = "data-add-catbert.sql", config = @SqlConfig(transactionManager = "txMgr2"))
public void database2() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThatTransaction().isNotActive();
assertUsers(new JdbcTemplate(dataSource2), "Dilbert", "Catbert");
}

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.TransactionAssert.assertThatTransaction;
/**
* Exact copy of {@link InferredDataSourceSqlScriptsTests}, except that test
@ -63,7 +63,7 @@ public class InferredDataSourceTransactionalSqlScriptsTests {
@Transactional("txMgr1")
@Sql(scripts = "data-add-dogbert.sql", config = @SqlConfig(transactionManager = "txMgr1"))
public void database1() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThatTransaction().isActive();
assertUsers(new JdbcTemplate(dataSource1), "Dilbert", "Dogbert");
}
@ -71,7 +71,7 @@ public class InferredDataSourceTransactionalSqlScriptsTests {
@Transactional("txMgr2")
@Sql(scripts = "data-add-catbert.sql", config = @SqlConfig(transactionManager = "txMgr2"))
public void database2() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThatTransaction().isActive();
assertUsers(new JdbcTemplate(dataSource2), "Dilbert", "Catbert");
}

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

@ -31,9 +31,9 @@ import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.jdbc.JdbcTestUtils;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.test.transaction.TransactionAssert.assertThatTransaction;
/**
* Integration tests that ensure that <em>primary</em> data sources are
@ -81,7 +81,7 @@ public class PrimaryDataSourceTests {
@Test
@Sql("data.sql")
public void dataSourceTest() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThatTransaction().isNotActive();
assertThat(JdbcTestUtils.countRowsInTable(this.jdbcTemplate, "user")).as("Number of rows in the 'user' table.").isEqualTo(1);
}

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.TransactionAssert.assertThatTransaction;
/**
* JUnit 4 based integration test which verifies
@ -79,7 +79,7 @@ public class BeforeAndAfterTransactionAnnotationTests extends AbstractTransactio
@BeforeTransaction
void beforeTransaction() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThatTransaction().isNotActive();
this.inTransaction = true;
BeforeAndAfterTransactionAnnotationTests.numBeforeTransactionCalls++;
clearPersonTable(jdbcTemplate);
@ -88,7 +88,7 @@ public class BeforeAndAfterTransactionAnnotationTests extends AbstractTransactio
@AfterTransaction
void afterTransaction() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThatTransaction().isNotActive();
this.inTransaction = false;
BeforeAndAfterTransactionAnnotationTests.numAfterTransactionCalls++;
assertThat(deletePerson(jdbcTemplate, YODA)).as("Deleting yoda").isEqualTo(1);
@ -105,7 +105,7 @@ public class BeforeAndAfterTransactionAnnotationTests extends AbstractTransactio
private void assertShouldBeInTransaction() {
boolean shouldBeInTransaction = !testName.getMethodName().equals("nonTransactionalMethod");
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isEqualTo(shouldBeInTransaction);
assertThatTransaction().isInTransaction(shouldBeInTransaction);
}
@After
@ -115,14 +115,14 @@ public class BeforeAndAfterTransactionAnnotationTests extends AbstractTransactio
@Test
public void transactionalMethod1() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThatTransaction().isActive();
assertThat(addPerson(jdbcTemplate, JANE)).as("Adding jane").isEqualTo(1);
assertThat(countRowsInPersonTable(jdbcTemplate)).as("Verifying the number of rows in the person table within transactionalMethod1().").isEqualTo(2);
}
@Test
public void transactionalMethod2() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThatTransaction().isActive();
assertThat(addPerson(jdbcTemplate, JANE)).as("Adding jane").isEqualTo(1);
assertThat(addPerson(jdbcTemplate, SUE)).as("Adding sue").isEqualTo(1);
assertThat(countRowsInPersonTable(jdbcTemplate)).as("Verifying the number of rows in the person table within transactionalMethod2().").isEqualTo(3);
@ -131,7 +131,7 @@ public class BeforeAndAfterTransactionAnnotationTests extends AbstractTransactio
@Test
@Transactional(propagation = Propagation.NOT_SUPPORTED)
public void nonTransactionalMethod() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThatTransaction().isNotActive();
assertThat(addPerson(jdbcTemplate, LUKE)).as("Adding luke").isEqualTo(1);
assertThat(addPerson(jdbcTemplate, LEIA)).as("Adding leia").isEqualTo(1);
assertThat(addPerson(jdbcTemplate, YODA)).as("Adding yoda").isEqualTo(1);

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.TransactionAssert.assertThatTransaction;
/**
* JUnit 4 based integration test which verifies support of Spring's
@ -82,7 +82,7 @@ public class ClassLevelTransactionalSpringRunnerTests extends AbstractTransactio
@Test
public void modifyTestDataWithinTransaction() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThatTransaction().isActive();
assertThat(deletePerson(jdbcTemplate, BOB)).as("Deleting bob").isEqualTo(1);
assertThat(addPerson(jdbcTemplate, JANE)).as("Adding jane").isEqualTo(1);
assertThat(addPerson(jdbcTemplate, SUE)).as("Adding sue").isEqualTo(1);
@ -92,7 +92,7 @@ public class ClassLevelTransactionalSpringRunnerTests extends AbstractTransactio
@Test
@Transactional(propagation = Propagation.NOT_SUPPORTED)
public void modifyTestDataWithoutTransaction() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThatTransaction().isNotActive();
assertThat(addPerson(jdbcTemplate, LUKE)).as("Adding luke").isEqualTo(1);
assertThat(addPerson(jdbcTemplate, LEIA)).as("Adding leia").isEqualTo(1);
assertThat(addPerson(jdbcTemplate, YODA)).as("Adding yoda").isEqualTo(1);

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

@ -32,9 +32,10 @@ import org.springframework.tests.sample.beans.Employee;
import org.springframework.tests.sample.beans.Pet;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.test.transaction.TransactionAssert.assertThatTransaction;
import static org.springframework.transaction.support.TransactionSynchronizationManager.isActualTransactionActive;
/**
* Combined integration test for {@link AbstractJUnit4SpringContextTests} and
@ -92,13 +93,13 @@ public class ConcreteTransactionalJUnit4SpringContextTests extends AbstractTrans
@Before
public void setUp() {
long expected = (TransactionSynchronizationManager.isActualTransactionActive() ? 2 : 1);
long expected = (isActualTransactionActive() ? 2 : 1);
assertThat(countRowsInPersonTable()).as("Verifying the number of rows in the person table before a test method.").isEqualTo(expected);
}
@After
public void tearDown() {
long expected = (TransactionSynchronizationManager.isActualTransactionActive() ? 4 : 1);
long expected = (isActualTransactionActive() ? 4 : 1);
assertThat(countRowsInPersonTable()).as("Verifying the number of rows in the person table after a test method.").isEqualTo(expected);
}
@ -118,7 +119,7 @@ public class ConcreteTransactionalJUnit4SpringContextTests extends AbstractTrans
@Test
@Transactional(propagation = Propagation.NOT_SUPPORTED)
public void verifyBeanNameSet() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThatTransaction().isNotActive();
assertThat(this.beanName.startsWith(getClass().getName())).as("The bean name of this test instance should have been set to the fully qualified class name " +
"due to BeanNameAware semantics.").isTrue();
}
@ -126,21 +127,21 @@ public class ConcreteTransactionalJUnit4SpringContextTests extends AbstractTrans
@Test
@Transactional(propagation = Propagation.NOT_SUPPORTED)
public void verifyApplicationContext() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThatTransaction().isNotActive();
assertThat(super.applicationContext).as("The application context should have been set due to ApplicationContextAware semantics.").isNotNull();
}
@Test
@Transactional(propagation = Propagation.NOT_SUPPORTED)
public void verifyBeanInitialized() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThatTransaction().isNotActive();
assertThat(this.beanInitialized).as("This test bean should have been initialized due to InitializingBean semantics.").isTrue();
}
@Test
@Transactional(propagation = Propagation.NOT_SUPPORTED)
public void verifyAnnotationAutowiredFields() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThatTransaction().isNotActive();
assertThat(this.nonrequiredLong).as("The nonrequiredLong property should NOT have been autowired.").isNull();
assertThat(this.pet).as("The pet field should have been autowired.").isNotNull();
assertThat(this.pet.getName()).isEqualTo("Fido");
@ -149,7 +150,7 @@ public class ConcreteTransactionalJUnit4SpringContextTests extends AbstractTrans
@Test
@Transactional(propagation = Propagation.NOT_SUPPORTED)
public void verifyAnnotationAutowiredMethods() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThatTransaction().isNotActive();
assertThat(this.employee).as("The employee setter method should have been autowired.").isNotNull();
assertThat(this.employee.getName()).isEqualTo("John Smith");
}
@ -157,20 +158,20 @@ public class ConcreteTransactionalJUnit4SpringContextTests extends AbstractTrans
@Test
@Transactional(propagation = Propagation.NOT_SUPPORTED)
public void verifyResourceAnnotationWiredFields() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThatTransaction().isNotActive();
assertThat(this.foo).as("The foo field should have been wired via @Resource.").isEqualTo("Foo");
}
@Test
@Transactional(propagation = Propagation.NOT_SUPPORTED)
public void verifyResourceAnnotationWiredMethods() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThatTransaction().isNotActive();
assertThat(this.bar).as("The bar method should have been wired via @Resource.").isEqualTo("Bar");
}
@Test
public void modifyTestDataWithinTransaction() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThatTransaction().isActive();
assertThat(addPerson(JANE)).as("Adding jane").isEqualTo(1);
assertThat(addPerson(SUE)).as("Adding sue").isEqualTo(1);
assertThat(countRowsInPersonTable()).as("Verifying the number of rows in the person table in modifyTestDataWithinTransaction().").isEqualTo(4);

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.TransactionAssert.assertThatTransaction;
/**
* Integration test which verifies proper transactional behavior when the
@ -69,7 +69,7 @@ public class DefaultRollbackFalseRollbackAnnotationTransactionalTests extends Ab
@Test
public void modifyTestDataWithinTransaction() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThatTransaction().isActive();
assertThat(deletePerson(jdbcTemplate, BOB)).as("Deleting bob").isEqualTo(1);
assertThat(addPerson(jdbcTemplate, JANE)).as("Adding jane").isEqualTo(1);
assertThat(addPerson(jdbcTemplate, SUE)).as("Adding sue").isEqualTo(1);

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.TransactionAssert.assertThatTransaction;
/**
* Integration test which verifies proper transactional behavior when the default
@ -71,7 +71,7 @@ public class DefaultRollbackTrueRollbackAnnotationTransactionalTests extends Abs
@Test(timeout = 1000)
public void modifyTestDataWithinTransaction() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThatTransaction().isActive();
assertThat(addPerson(jdbcTemplate, JANE)).as("Adding jane").isEqualTo(1);
assertThat(addPerson(jdbcTemplate, SUE)).as("Adding sue").isEqualTo(1);
assertThat(countRowsInPersonTable(jdbcTemplate)).as("Verifying the number of rows in the person table within a transaction.").isEqualTo(3);

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.TransactionAssert.assertThatTransaction;
/**
* JUnit 4 based integration test which verifies support of Spring's
@ -85,7 +85,7 @@ public class MethodLevelTransactionalSpringRunnerTests extends AbstractTransacti
@Test
@Transactional("transactionManager2")
public void modifyTestDataWithinTransaction() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThatTransaction().isActive();
assertThat(deletePerson(jdbcTemplate, BOB)).as("Deleting bob").isEqualTo(1);
assertThat(addPerson(jdbcTemplate, JANE)).as("Adding jane").isEqualTo(1);
assertThat(addPerson(jdbcTemplate, SUE)).as("Adding sue").isEqualTo(1);
@ -94,7 +94,7 @@ public class MethodLevelTransactionalSpringRunnerTests extends AbstractTransacti
@Test
public void modifyTestDataWithoutTransaction() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThatTransaction().isNotActive();
assertThat(addPerson(jdbcTemplate, LUKE)).as("Adding luke").isEqualTo(1);
assertThat(addPerson(jdbcTemplate, LEIA)).as("Adding leia").isEqualTo(1);
assertThat(addPerson(jdbcTemplate, YODA)).as("Adding yoda").isEqualTo(1);

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.TransactionAssert.assertThatTransaction;
/**
* Extension of {@link DefaultRollbackFalseRollbackAnnotationTransactionalTests}
@ -64,7 +64,7 @@ public class RollbackOverrideDefaultRollbackFalseRollbackAnnotationTransactional
@Rollback
@Override
public void modifyTestDataWithinTransaction() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThatTransaction().isActive();
assertThat(deletePerson(jdbcTemplate, BOB)).as("Deleting bob").isEqualTo(1);
assertThat(addPerson(jdbcTemplate, JANE)).as("Adding jane").isEqualTo(1);
assertThat(addPerson(jdbcTemplate, SUE)).as("Adding sue").isEqualTo(1);

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.TransactionAssert.assertThatTransaction;
/**
* Extension of {@link DefaultRollbackFalseRollbackAnnotationTransactionalTests}
@ -64,7 +64,7 @@ public class RollbackOverrideDefaultRollbackFalseTransactionalTests
@Rollback
@Override
public void modifyTestDataWithinTransaction() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThatTransaction().isActive();
assertThat(deletePerson(jdbcTemplate, BOB)).as("Deleting bob").isEqualTo(1);
assertThat(addPerson(jdbcTemplate, JANE)).as("Adding jane").isEqualTo(1);
assertThat(addPerson(jdbcTemplate, SUE)).as("Adding sue").isEqualTo(1);

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.TransactionAssert.assertThatTransaction;
/**
* Extension of {@link DefaultRollbackTrueRollbackAnnotationTransactionalTests}
@ -63,7 +63,7 @@ public class RollbackOverrideDefaultRollbackTrueRollbackAnnotationTransactionalT
@Rollback(false)
@Override
public void modifyTestDataWithinTransaction() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThatTransaction().isActive();
assertThat(addPerson(jdbcTemplate, JANE)).as("Adding jane").isEqualTo(1);
assertThat(addPerson(jdbcTemplate, SUE)).as("Adding sue").isEqualTo(1);
assertThat(countRowsInPersonTable(jdbcTemplate)).as("Verifying the number of rows in the person table within a transaction.").isEqualTo(3);

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.TransactionAssert.assertThatTransaction;
/**
* Extension of {@link DefaultRollbackTrueRollbackAnnotationTransactionalTests}
@ -61,7 +61,7 @@ public class RollbackOverrideDefaultRollbackTrueTransactionalTests
@Rollback(false)
@Override
public void modifyTestDataWithinTransaction() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThatTransaction().isActive();
assertThat(addPerson(jdbcTemplate, JANE)).as("Adding jane").isEqualTo(1);
assertThat(addPerson(jdbcTemplate, SUE)).as("Adding sue").isEqualTo(1);
assertThat(countRowsInPersonTable(jdbcTemplate)).as("Verifying the number of rows in the person table within a transaction.").isEqualTo(3);

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

@ -24,9 +24,8 @@ import org.springframework.test.annotation.Timed;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.test.transaction.TransactionAssert.assertThatTransaction;
/**
* JUnit 4 based integration test which verifies support of Spring's
@ -46,13 +45,13 @@ public class TimedTransactionalSpringRunnerTests {
@Timed(millis = 10000)
@Repeat(5)
public void transactionalWithSpringTimeout() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThatTransaction().isActive();
}
@Test(timeout = 10000)
@Repeat(5)
public void transactionalWithJUnitTimeout() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThatTransaction().isActive();
}
@Test
@ -60,14 +59,14 @@ public class TimedTransactionalSpringRunnerTests {
@Timed(millis = 10000)
@Repeat(5)
public void notTransactionalWithSpringTimeout() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThatTransaction().isNotActive();
}
@Test(timeout = 10000)
@Transactional(propagation = Propagation.NOT_SUPPORTED)
@Repeat(5)
public void notTransactionalWithJUnitTimeout() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThatTransaction().isNotActive();
}
}

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.TransactionAssert.assertThatTransaction;
/**
* Transactional integration tests regarding <i>manual</i> session flushing with
@ -60,7 +60,7 @@ public class HibernateSessionFlushingTests extends AbstractTransactionalJUnit4Sp
@Before
public void setup() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThatTransaction().isActive();
assertThat(personService).as("PersonService should have been autowired.").isNotNull();
assertThat(sessionFactory).as("SessionFactory should have been autowired.").isNotNull();
}

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

@ -27,9 +27,8 @@ import org.junit.runners.JUnit4;
import org.springframework.test.annotation.Repeat;
import org.springframework.test.context.junit4.TimedTransactionalSpringRunnerTests;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.test.transaction.TransactionAssert.assertThatTransaction;
/**
* This class is an extension of {@link TimedTransactionalSpringRunnerTests}
@ -60,7 +59,7 @@ public class TimedTransactionalSpringRuleTests extends TimedTransactionalSpringR
@Repeat(5)
@Override
public void transactionalWithJUnitTimeout() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThatTransaction().isNotActive();
}
/**
@ -68,7 +67,7 @@ public class TimedTransactionalSpringRuleTests extends TimedTransactionalSpringR
*/
@Test
public void transactionalWithJUnitRuleBasedTimeout() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThatTransaction().isActive();
}
// All other tests are in superclass.

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

@ -33,9 +33,10 @@ import org.springframework.test.context.transaction.AfterTransaction;
import org.springframework.test.context.transaction.BeforeTransaction;
import org.springframework.tests.sample.beans.Employee;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.test.transaction.TransactionAssert.assertThatTransaction;
import static org.springframework.transaction.support.TransactionSynchronizationManager.isActualTransactionActive;
/**
* This set of tests (i.e., all concrete subclasses) investigates the claims made in
@ -108,13 +109,13 @@ public abstract class AbstractTransactionalAnnotatedConfigClassTests {
@Before
public void setUp() throws Exception {
assertNumRowsInPersonTable((TransactionSynchronizationManager.isActualTransactionActive() ? 1 : 0), "before a test method");
assertNumRowsInPersonTable((isActualTransactionActive() ? 1 : 0), "before a test method");
}
@Test
@Transactional
public void modifyTestDataWithinTransaction() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThatTransaction().isActive();
assertAddPerson(JANE);
assertAddPerson(SUE);
assertNumRowsInPersonTable(3, "in modifyTestDataWithinTransaction()");
@ -122,7 +123,7 @@ public abstract class AbstractTransactionalAnnotatedConfigClassTests {
@After
public void tearDown() throws Exception {
assertNumRowsInPersonTable((TransactionSynchronizationManager.isActualTransactionActive() ? 3 : 0), "after a test method");
assertNumRowsInPersonTable((isActualTransactionActive() ? 3 : 0), "after a test method");
}
@AfterTransaction

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.assertj.core.api.Assertions.assertThat;
import static org.springframework.test.transaction.TransactionAssert.assertThatTransaction;
import static org.springframework.transaction.support.TransactionSynchronizationManager.isActualTransactionActive;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertNotNull;
@ -129,15 +129,15 @@ public class AnnotationConfigTransactionalTestNGSpringContextTests
@BeforeMethod
void setUp() throws Exception {
numSetUpCalls++;
if (TransactionSynchronizationManager.isActualTransactionActive()) {
if (isActualTransactionActive()) {
numSetUpCallsInTransaction++;
}
assertNumRowsInPersonTable((TransactionSynchronizationManager.isActualTransactionActive() ? 2 : 1), "before a test method");
assertNumRowsInPersonTable((isActualTransactionActive() ? 2 : 1), "before a test method");
}
@Test
void modifyTestDataWithinTransaction() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThatTransaction().isActive();
assertAddPerson(JANE);
assertAddPerson(SUE);
assertNumRowsInPersonTable(4, "in modifyTestDataWithinTransaction()");
@ -146,10 +146,10 @@ public class AnnotationConfigTransactionalTestNGSpringContextTests
@AfterMethod
void tearDown() throws Exception {
numTearDownCalls++;
if (TransactionSynchronizationManager.isActualTransactionActive()) {
if (isActualTransactionActive()) {
numTearDownCallsInTransaction++;
}
assertNumRowsInPersonTable((TransactionSynchronizationManager.isActualTransactionActive() ? 4 : 1), "after a test method");
assertNumRowsInPersonTable((isActualTransactionActive() ? 4 : 1), "after a test method");
}
@AfterTransaction

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

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

@ -22,9 +22,8 @@ import org.springframework.context.ApplicationContext;
import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.TestContextManager;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.test.transaction.TransactionAssert.assertThatTransaction;
import static org.testng.Assert.assertNotNull;
import static org.testng.Assert.assertNotSame;
import static org.testng.Assert.assertSame;
@ -56,7 +55,7 @@ public class DirtiesContextTransactionalTestNGSpringContextTests extends Abstrac
private void performCommonAssertions() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThatTransaction().isActive();
assertNotNull(super.applicationContext,
"The application context should have been set due to ApplicationContextAware semantics.");
assertNotNull(super.jdbcTemplate,

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

@ -19,9 +19,8 @@ package org.springframework.test.context.testng;
import org.testng.annotations.Test;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.test.transaction.TransactionAssert.assertThatTransaction;
/**
* Timed integration tests for
@ -37,13 +36,13 @@ public class TimedTransactionalTestNGSpringContextTests extends AbstractTransact
@Test
public void testWithoutTimeout() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThatTransaction().isActive();
}
// TODO Enable TestNG test with timeout once we have a solution.
@Test(timeOut = 10000, enabled = false)
public void testWithTimeout() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThatTransaction().isActive();
}
}

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.TransactionAssert.assertThatTransaction;
/**
* This class is a copy of the JUnit-based {@link ProgrammaticTxMgmtTests} class
@ -136,7 +136,7 @@ public class ProgrammaticTxMgmtTestNGTests extends AbstractTransactionalTestNGSp
@Test
public void commitTxAndStartNewTx() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThatTransaction().isActive();
assertThat(TestTransaction.isActive()).isTrue();
assertUsers("Dilbert");
deleteFromTables("user");
@ -146,7 +146,7 @@ public class ProgrammaticTxMgmtTestNGTests extends AbstractTransactionalTestNGSp
TestTransaction.flagForCommit();
assertThat(TestTransaction.isFlaggedForRollback()).isFalse();
TestTransaction.end();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThatTransaction().isNotActive();
assertThat(TestTransaction.isActive()).isFalse();
assertUsers();
@ -154,13 +154,13 @@ public class ProgrammaticTxMgmtTestNGTests extends AbstractTransactionalTestNGSp
assertUsers("Dogbert");
TestTransaction.start();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThatTransaction().isActive();
assertThat(TestTransaction.isActive()).isTrue();
}
@Test
public void commitTxButDoNotStartNewTx() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThatTransaction().isActive();
assertThat(TestTransaction.isActive()).isTrue();
assertUsers("Dilbert");
deleteFromTables("user");
@ -171,7 +171,7 @@ public class ProgrammaticTxMgmtTestNGTests extends AbstractTransactionalTestNGSp
assertThat(TestTransaction.isFlaggedForRollback()).isFalse();
TestTransaction.end();
assertThat(TestTransaction.isActive()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThatTransaction().isNotActive();
assertUsers();
executeSqlScript("classpath:/org/springframework/test/context/jdbc/data-add-dogbert.sql", false);
@ -180,7 +180,7 @@ public class ProgrammaticTxMgmtTestNGTests extends AbstractTransactionalTestNGSp
@Test
public void rollbackTxAndStartNewTx() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThatTransaction().isActive();
assertThat(TestTransaction.isActive()).isTrue();
assertUsers("Dilbert");
deleteFromTables("user");
@ -190,12 +190,12 @@ public class ProgrammaticTxMgmtTestNGTests extends AbstractTransactionalTestNGSp
assertThat(TestTransaction.isFlaggedForRollback()).isTrue();
TestTransaction.end();
assertThat(TestTransaction.isActive()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThatTransaction().isNotActive();
assertUsers("Dilbert");
// Start new transaction with default rollback semantics
TestTransaction.start();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThatTransaction().isActive();
assertThat(TestTransaction.isFlaggedForRollback()).isTrue();
assertThat(TestTransaction.isActive()).isTrue();
@ -205,7 +205,7 @@ public class ProgrammaticTxMgmtTestNGTests extends AbstractTransactionalTestNGSp
@Test
public void rollbackTxButDoNotStartNewTx() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThatTransaction().isActive();
assertThat(TestTransaction.isActive()).isTrue();
assertUsers("Dilbert");
deleteFromTables("user");
@ -215,14 +215,14 @@ public class ProgrammaticTxMgmtTestNGTests extends AbstractTransactionalTestNGSp
assertThat(TestTransaction.isFlaggedForRollback()).isTrue();
TestTransaction.end();
assertThat(TestTransaction.isActive()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThatTransaction().isNotActive();
assertUsers("Dilbert");
}
@Test
@Commit
public void rollbackTxAndStartNewTxWithDefaultCommitSemantics() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThatTransaction().isActive();
assertThat(TestTransaction.isActive()).isTrue();
assertUsers("Dilbert");
deleteFromTables("user");
@ -233,12 +233,12 @@ public class ProgrammaticTxMgmtTestNGTests extends AbstractTransactionalTestNGSp
assertThat(TestTransaction.isFlaggedForRollback()).isTrue();
TestTransaction.end();
assertThat(TestTransaction.isActive()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThatTransaction().isNotActive();
assertUsers("Dilbert");
// Start new transaction with default commit semantics
TestTransaction.start();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThatTransaction().isActive();
assertThat(TestTransaction.isFlaggedForRollback()).isFalse();
assertThat(TestTransaction.isActive()).isTrue();

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

@ -37,9 +37,9 @@ import org.springframework.test.jdbc.JdbcTestUtils;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.test.transaction.TransactionAssert.assertThatTransaction;
/**
* Integration tests that ensure that <em>primary</em> transaction managers
@ -76,7 +76,7 @@ public final class PrimaryTransactionManagerTests {
@Test
@Transactional
public void transactionalTest() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThatTransaction().isActive();
ClassPathResource resource = new ClassPathResource("/org/springframework/test/context/jdbc/data.sql");
new ResourceDatabasePopulator(resource).execute(jdbcTemplate.getDataSource());

29
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.TransactionAssert.assertThatTransaction;
/**
* JUnit-based integration tests that verify support for programmatic transaction
@ -154,7 +154,7 @@ public class ProgrammaticTxMgmtTests {
@Test
public void commitTxAndStartNewTx() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThatTransaction().isActive();
assertThat(TestTransaction.isActive()).isTrue();
assertUsers("Dilbert");
deleteFromTables("user");
@ -164,7 +164,7 @@ public class ProgrammaticTxMgmtTests {
TestTransaction.flagForCommit();
assertThat(TestTransaction.isFlaggedForRollback()).isFalse();
TestTransaction.end();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThatTransaction().isNotActive();
assertThat(TestTransaction.isActive()).isFalse();
assertUsers();
@ -172,13 +172,13 @@ public class ProgrammaticTxMgmtTests {
assertUsers("Dogbert");
TestTransaction.start();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThatTransaction().isActive();
assertThat(TestTransaction.isActive()).isTrue();
}
@Test
public void commitTxButDoNotStartNewTx() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThatTransaction().isActive();
assertThat(TestTransaction.isActive()).isTrue();
assertUsers("Dilbert");
deleteFromTables("user");
@ -189,7 +189,7 @@ public class ProgrammaticTxMgmtTests {
assertThat(TestTransaction.isFlaggedForRollback()).isFalse();
TestTransaction.end();
assertThat(TestTransaction.isActive()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThatTransaction().isNotActive();
assertUsers();
executeSqlScript("classpath:/org/springframework/test/context/jdbc/data-add-dogbert.sql", false);
@ -198,7 +198,7 @@ public class ProgrammaticTxMgmtTests {
@Test
public void rollbackTxAndStartNewTx() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThatTransaction().isActive();
assertThat(TestTransaction.isActive()).isTrue();
assertUsers("Dilbert");
deleteFromTables("user");
@ -208,12 +208,12 @@ public class ProgrammaticTxMgmtTests {
assertThat(TestTransaction.isFlaggedForRollback()).isTrue();
TestTransaction.end();
assertThat(TestTransaction.isActive()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThatTransaction().isNotActive();
assertUsers("Dilbert");
// Start new transaction with default rollback semantics
TestTransaction.start();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThatTransaction().isActive();
assertThat(TestTransaction.isFlaggedForRollback()).isTrue();
assertThat(TestTransaction.isActive()).isTrue();
@ -223,7 +223,7 @@ public class ProgrammaticTxMgmtTests {
@Test
public void rollbackTxButDoNotStartNewTx() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThatTransaction().isActive();
assertThat(TestTransaction.isActive()).isTrue();
assertUsers("Dilbert");
deleteFromTables("user");
@ -233,14 +233,14 @@ public class ProgrammaticTxMgmtTests {
assertThat(TestTransaction.isFlaggedForRollback()).isTrue();
TestTransaction.end();
assertThat(TestTransaction.isActive()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThatTransaction().isNotActive();
assertUsers("Dilbert");
}
@Test
@Commit
public void rollbackTxAndStartNewTxWithDefaultCommitSemantics() {
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThatTransaction().isActive();
assertThat(TestTransaction.isActive()).isTrue();
assertUsers("Dilbert");
deleteFromTables("user");
@ -251,12 +251,12 @@ public class ProgrammaticTxMgmtTests {
assertThat(TestTransaction.isFlaggedForRollback()).isTrue();
TestTransaction.end();
assertThat(TestTransaction.isActive()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThatTransaction().isNotActive();
assertUsers("Dilbert");
// Start new transaction with default commit semantics
TestTransaction.start();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThatTransaction().isActive();
assertThat(TestTransaction.isFlaggedForRollback()).isFalse();
assertThat(TestTransaction.isActive()).isTrue();
@ -281,7 +281,6 @@ public class ProgrammaticTxMgmtTests {
assertThat(actual).as("Users in database;").isEqualTo(expected);
}
// -------------------------------------------------------------------------
@Configuration
static class Config {

55
spring-test/src/test/java/org/springframework/test/transaction/TransactionAssert.java Normal file
View File

@ -0,0 +1,55 @@
/*
* Copyright 2002-2019 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.test.transaction;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Collection of assertions for tests involving transactions. Intended for
* internal use within the Spring testing suite.
*
* @author Sam Brannen
* @author Phillip Webb
* @since 5.2
*/
public class TransactionAssert {
private static final TransactionAssert instance = new TransactionAssert();
public TransactionAssert isActive() {
return isInTransaction(true);
}
public TransactionAssert isNotActive() {
return isInTransaction(false);
}
public TransactionAssert isInTransaction(boolean expected) {
assertThat(TransactionSynchronizationManager.isActualTransactionActive())
.as("active transaction")
.isEqualTo(expected);
return this;
}
public static TransactionAssert assertThatTransaction() {
return instance;
}
}