Skip to content

Commit 6b9160b

Browse files
philwebbphilwebb
committed
Restore transaction specific assertions
Revert 82d0e49 and instead create a `TransactionAssert` class. Closes gh-23022
1 parent 5a1217c commit 6b9160b

26 files changed

+174
-122
lines changed

‎spring-test/src/test/java/org/springframework/test/context/jdbc/DataSourceOnlySqlScriptsTests.java

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -32,9 +32,9 @@
3232
import org.springframework.test.context.ContextConfiguration;
3333
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
3434
import org.springframework.test.jdbc.JdbcTestUtils;
35-
import org.springframework.transaction.support.TransactionSynchronizationManager;
3635

3736
import static org.assertj.core.api.Assertions.assertThat;
37+
import static org.springframework.test.transaction.TransactionAssert.assertThatTransaction;
3838

3939
/**
4040
* Integration tests for {@link Sql @Sql} support with only a {@link DataSource}
@@ -61,15 +61,15 @@ public void setDataSource(DataSource dataSource) {
6161
@Test
6262
// test##_ prefix is required for @FixMethodOrder.
6363
public void test01_classLevelScripts() {
64-
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
64+
assertThatTransaction().isNotActive();
6565
assertNumUsers(1);
6666
}
6767

6868
@Test
6969
@Sql({ "drop-schema.sql", "schema.sql", "data.sql", "data-add-dogbert.sql" })
7070
// test##_ prefix is required for @FixMethodOrder.
7171
public void test02_methodLevelScripts() {
72-
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
72+
assertThatTransaction().isNotActive();
7373
assertNumUsers(2);
7474
}
7575

‎spring-test/src/test/java/org/springframework/test/context/jdbc/InferredDataSourceSqlScriptsTests.java

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -34,9 +34,9 @@
3434
import org.springframework.test.context.ContextConfiguration;
3535
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
3636
import org.springframework.transaction.PlatformTransactionManager;
37-
import org.springframework.transaction.support.TransactionSynchronizationManager;
3837

3938
import static org.assertj.core.api.Assertions.assertThat;
39+
import static org.springframework.test.transaction.TransactionAssert.assertThatTransaction;
4040

4141
/**
4242
* Integration tests for {@link Sql @Sql} that verify support for inferring
@@ -61,14 +61,14 @@ public class InferredDataSourceSqlScriptsTests {
6161
@Test
6262
@Sql(scripts = "data-add-dogbert.sql", config = @SqlConfig(transactionManager = "txMgr1"))
6363
public void database1() {
64-
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
64+
assertThatTransaction().isNotActive();
6565
assertUsers(new JdbcTemplate(dataSource1), "Dilbert", "Dogbert");
6666
}
6767

6868
@Test
6969
@Sql(scripts = "data-add-catbert.sql", config = @SqlConfig(transactionManager = "txMgr2"))
7070
public void database2() {
71-
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
71+
assertThatTransaction().isNotActive();
7272
assertUsers(new JdbcTemplate(dataSource2), "Dilbert", "Catbert");
7373
}
7474

‎spring-test/src/test/java/org/springframework/test/context/jdbc/InferredDataSourceTransactionalSqlScriptsTests.java

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -35,9 +35,9 @@
3535
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
3636
import org.springframework.transaction.PlatformTransactionManager;
3737
import org.springframework.transaction.annotation.Transactional;
38-
import org.springframework.transaction.support.TransactionSynchronizationManager;
3938

4039
import static org.assertj.core.api.Assertions.assertThat;
40+
import static org.springframework.test.transaction.TransactionAssert.assertThatTransaction;
4141

4242
/**
4343
* Exact copy of {@link InferredDataSourceSqlScriptsTests}, except that test
@@ -63,15 +63,15 @@ public class InferredDataSourceTransactionalSqlScriptsTests {
6363
@Transactional("txMgr1")
6464
@Sql(scripts = "data-add-dogbert.sql", config = @SqlConfig(transactionManager = "txMgr1"))
6565
public void database1() {
66-
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
66+
assertThatTransaction().isActive();
6767
assertUsers(new JdbcTemplate(dataSource1), "Dilbert", "Dogbert");
6868
}
6969

7070
@Test
7171
@Transactional("txMgr2")
7272
@Sql(scripts = "data-add-catbert.sql", config = @SqlConfig(transactionManager = "txMgr2"))
7373
public void database2() {
74-
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
74+
assertThatTransaction().isActive();
7575
assertUsers(new JdbcTemplate(dataSource2), "Dilbert", "Catbert");
7676
}
7777

‎spring-test/src/test/java/org/springframework/test/context/jdbc/PrimaryDataSourceTests.java

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -31,9 +31,9 @@
3131
import org.springframework.test.context.ContextConfiguration;
3232
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
3333
import org.springframework.test.jdbc.JdbcTestUtils;
34-
import org.springframework.transaction.support.TransactionSynchronizationManager;
3534

3635
import static org.assertj.core.api.Assertions.assertThat;
36+
import static org.springframework.test.transaction.TransactionAssert.assertThatTransaction;
3737

3838
/**
3939
* Integration tests that ensure that <em>primary</em> data sources are
@@ -81,7 +81,7 @@ public void setDataSource(DataSource dataSource) {
8181
@Test
8282
@Sql("data.sql")
8383
public void dataSourceTest() {
84-
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
84+
assertThatTransaction().isNotActive();
8585
assertThat(JdbcTestUtils.countRowsInTable(this.jdbcTemplate, "user")).as("Number of rows in the 'user' table.").isEqualTo(1);
8686
}
8787

‎spring-test/src/test/java/org/springframework/test/context/junit4/BeforeAndAfterTransactionAnnotationTests.java

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -32,9 +32,9 @@
3232
import org.springframework.test.context.transaction.BeforeTransaction;
3333
import org.springframework.transaction.annotation.Propagation;
3434
import org.springframework.transaction.annotation.Transactional;
35-
import org.springframework.transaction.support.TransactionSynchronizationManager;
3635

3736
import static org.assertj.core.api.Assertions.assertThat;
37+
import static org.springframework.test.transaction.TransactionAssert.assertThatTransaction;
3838

3939
/**
4040
* JUnit 4 based integration test which verifies
@@ -79,7 +79,7 @@ public static void afterClass() {
7979

8080
@BeforeTransaction
8181
void beforeTransaction() {
82-
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
82+
assertThatTransaction().isNotActive();
8383
this.inTransaction = true;
8484
BeforeAndAfterTransactionAnnotationTests.numBeforeTransactionCalls++;
8585
clearPersonTable(jdbcTemplate);
@@ -88,7 +88,7 @@ void beforeTransaction() {
8888

8989
@AfterTransaction
9090
void afterTransaction() {
91-
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
91+
assertThatTransaction().isNotActive();
9292
this.inTransaction = false;
9393
BeforeAndAfterTransactionAnnotationTests.numAfterTransactionCalls++;
9494
assertThat(deletePerson(jdbcTemplate, YODA)).as("Deleting yoda").isEqualTo(1);
@@ -105,7 +105,7 @@ public void before() {
105105

106106
private void assertShouldBeInTransaction() {
107107
boolean shouldBeInTransaction = !testName.getMethodName().equals("nonTransactionalMethod");
108-
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isEqualTo(shouldBeInTransaction);
108+
assertThatTransaction().isInTransaction(shouldBeInTransaction);
109109
}
110110

111111
@After
@@ -115,14 +115,14 @@ public void after() {
115115

116116
@Test
117117
public void transactionalMethod1() {
118-
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
118+
assertThatTransaction().isActive();
119119
assertThat(addPerson(jdbcTemplate, JANE)).as("Adding jane").isEqualTo(1);
120120
assertThat(countRowsInPersonTable(jdbcTemplate)).as("Verifying the number of rows in the person table within transactionalMethod1().").isEqualTo(2);
121121
}
122122

123123
@Test
124124
public void transactionalMethod2() {
125-
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
125+
assertThatTransaction().isActive();
126126
assertThat(addPerson(jdbcTemplate, JANE)).as("Adding jane").isEqualTo(1);
127127
assertThat(addPerson(jdbcTemplate, SUE)).as("Adding sue").isEqualTo(1);
128128
assertThat(countRowsInPersonTable(jdbcTemplate)).as("Verifying the number of rows in the person table within transactionalMethod2().").isEqualTo(3);
@@ -131,7 +131,7 @@ public void transactionalMethod2() {
131131
@Test
132132
@Transactional(propagation = Propagation.NOT_SUPPORTED)
133133
public void nonTransactionalMethod() {
134-
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
134+
assertThatTransaction().isNotActive();
135135
assertThat(addPerson(jdbcTemplate, LUKE)).as("Adding luke").isEqualTo(1);
136136
assertThat(addPerson(jdbcTemplate, LEIA)).as("Adding leia").isEqualTo(1);
137137
assertThat(addPerson(jdbcTemplate, YODA)).as("Adding yoda").isEqualTo(1);

‎spring-test/src/test/java/org/springframework/test/context/junit4/ClassLevelTransactionalSpringRunnerTests.java

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -32,9 +32,9 @@
3232
import org.springframework.test.context.transaction.TransactionalTestExecutionListener;
3333
import org.springframework.transaction.annotation.Propagation;
3434
import org.springframework.transaction.annotation.Transactional;
35-
import org.springframework.transaction.support.TransactionSynchronizationManager;
3635

3736
import static org.assertj.core.api.Assertions.assertThat;
37+
import static org.springframework.test.transaction.TransactionAssert.assertThatTransaction;
3838

3939
/**
4040
* JUnit 4 based integration test which verifies support of Spring's
@@ -82,7 +82,7 @@ public void verifyInitialTestData() {
8282

8383
@Test
8484
public void modifyTestDataWithinTransaction() {
85-
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
85+
assertThatTransaction().isActive();
8686
assertThat(deletePerson(jdbcTemplate, BOB)).as("Deleting bob").isEqualTo(1);
8787
assertThat(addPerson(jdbcTemplate, JANE)).as("Adding jane").isEqualTo(1);
8888
assertThat(addPerson(jdbcTemplate, SUE)).as("Adding sue").isEqualTo(1);
@@ -92,7 +92,7 @@ public void modifyTestDataWithinTransaction() {
9292
@Test
9393
@Transactional(propagation = Propagation.NOT_SUPPORTED)
9494
public void modifyTestDataWithoutTransaction() {
95-
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
95+
assertThatTransaction().isNotActive();
9696
assertThat(addPerson(jdbcTemplate, LUKE)).as("Adding luke").isEqualTo(1);
9797
assertThat(addPerson(jdbcTemplate, LEIA)).as("Adding leia").isEqualTo(1);
9898
assertThat(addPerson(jdbcTemplate, YODA)).as("Adding yoda").isEqualTo(1);

‎spring-test/src/test/java/org/springframework/test/context/junit4/ConcreteTransactionalJUnit4SpringContextTests.java

Lines changed: 12 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -32,9 +32,10 @@
3232
import org.springframework.tests.sample.beans.Pet;
3333
import org.springframework.transaction.annotation.Propagation;
3434
import org.springframework.transaction.annotation.Transactional;
35-
import org.springframework.transaction.support.TransactionSynchronizationManager;
3635

3736
import static org.assertj.core.api.Assertions.assertThat;
37+
import static org.springframework.test.transaction.TransactionAssert.assertThatTransaction;
38+
import static org.springframework.transaction.support.TransactionSynchronizationManager.isActualTransactionActive;
3839

3940
/**
4041
* Combined integration test for {@link AbstractJUnit4SpringContextTests} and
@@ -92,13 +93,13 @@ public void afterPropertiesSet() {
9293

9394
@Before
9495
public void setUp() {
95-
long expected = (TransactionSynchronizationManager.isActualTransactionActive() ? 2 : 1);
96+
long expected = (isActualTransactionActive() ? 2 : 1);
9697
assertThat(countRowsInPersonTable()).as("Verifying the number of rows in the person table before a test method.").isEqualTo(expected);
9798
}
9899

99100
@After
100101
public void tearDown() {
101-
long expected = (TransactionSynchronizationManager.isActualTransactionActive() ? 4 : 1);
102+
long expected = (isActualTransactionActive() ? 4 : 1);
102103
assertThat(countRowsInPersonTable()).as("Verifying the number of rows in the person table after a test method.").isEqualTo(expected);
103104
}
104105

@@ -118,29 +119,29 @@ public void afterTransaction() {
118119
@Test
119120
@Transactional(propagation = Propagation.NOT_SUPPORTED)
120121
public void verifyBeanNameSet() {
121-
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
122+
assertThatTransaction().isNotActive();
122123
assertThat(this.beanName.startsWith(getClass().getName())).as("The bean name of this test instance should have been set to the fully qualified class name " +
123124
"due to BeanNameAware semantics.").isTrue();
124125
}
125126

126127
@Test
127128
@Transactional(propagation = Propagation.NOT_SUPPORTED)
128129
public void verifyApplicationContext() {
129-
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
130+
assertThatTransaction().isNotActive();
130131
assertThat(super.applicationContext).as("The application context should have been set due to ApplicationContextAware semantics.").isNotNull();
131132
}
132133

133134
@Test
134135
@Transactional(propagation = Propagation.NOT_SUPPORTED)
135136
public void verifyBeanInitialized() {
136-
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
137+
assertThatTransaction().isNotActive();
137138
assertThat(this.beanInitialized).as("This test bean should have been initialized due to InitializingBean semantics.").isTrue();
138139
}
139140

140141
@Test
141142
@Transactional(propagation = Propagation.NOT_SUPPORTED)
142143
public void verifyAnnotationAutowiredFields() {
143-
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
144+
assertThatTransaction().isNotActive();
144145
assertThat(this.nonrequiredLong).as("The nonrequiredLong property should NOT have been autowired.").isNull();
145146
assertThat(this.pet).as("The pet field should have been autowired.").isNotNull();
146147
assertThat(this.pet.getName()).isEqualTo("Fido");
@@ -149,28 +150,28 @@ public void verifyAnnotationAutowiredFields() {
149150
@Test
150151
@Transactional(propagation = Propagation.NOT_SUPPORTED)
151152
public void verifyAnnotationAutowiredMethods() {
152-
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
153+
assertThatTransaction().isNotActive();
153154
assertThat(this.employee).as("The employee setter method should have been autowired.").isNotNull();
154155
assertThat(this.employee.getName()).isEqualTo("John Smith");
155156
}
156157

157158
@Test
158159
@Transactional(propagation = Propagation.NOT_SUPPORTED)
159160
public void verifyResourceAnnotationWiredFields() {
160-
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
161+
assertThatTransaction().isNotActive();
161162
assertThat(this.foo).as("The foo field should have been wired via @Resource.").isEqualTo("Foo");
162163
}
163164

164165
@Test
165166
@Transactional(propagation = Propagation.NOT_SUPPORTED)
166167
public void verifyResourceAnnotationWiredMethods() {
167-
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
168+
assertThatTransaction().isNotActive();
168169
assertThat(this.bar).as("The bar method should have been wired via @Resource.").isEqualTo("Bar");
169170
}
170171

171172
@Test
172173
public void modifyTestDataWithinTransaction() {
173-
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
174+
assertThatTransaction().isActive();
174175
assertThat(addPerson(JANE)).as("Adding jane").isEqualTo(1);
175176
assertThat(addPerson(SUE)).as("Adding sue").isEqualTo(1);
176177
assertThat(countRowsInPersonTable()).as("Verifying the number of rows in the person table in modifyTestDataWithinTransaction().").isEqualTo(4);

‎spring-test/src/test/java/org/springframework/test/context/junit4/DefaultRollbackFalseRollbackAnnotationTransactionalTests.java

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -28,9 +28,9 @@
2828
import org.springframework.test.annotation.Rollback;
2929
import org.springframework.test.context.ContextConfiguration;
3030
import org.springframework.transaction.annotation.Transactional;
31-
import org.springframework.transaction.support.TransactionSynchronizationManager;
3231

3332
import static org.assertj.core.api.Assertions.assertThat;
33+
import static org.springframework.test.transaction.TransactionAssert.assertThatTransaction;
3434

3535
/**
3636
* Integration test which verifies proper transactional behavior when the
@@ -69,7 +69,7 @@ public void verifyInitialTestData() {
6969

7070
@Test
7171
public void modifyTestDataWithinTransaction() {
72-
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
72+
assertThatTransaction().isActive();
7373
assertThat(deletePerson(jdbcTemplate, BOB)).as("Deleting bob").isEqualTo(1);
7474
assertThat(addPerson(jdbcTemplate, JANE)).as("Adding jane").isEqualTo(1);
7575
assertThat(addPerson(jdbcTemplate, SUE)).as("Adding sue").isEqualTo(1);

‎spring-test/src/test/java/org/springframework/test/context/junit4/DefaultRollbackTrueRollbackAnnotationTransactionalTests.java

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -28,9 +28,9 @@
2828
import org.springframework.test.annotation.Rollback;
2929
import org.springframework.test.context.ContextConfiguration;
3030
import org.springframework.transaction.annotation.Transactional;
31-
import org.springframework.transaction.support.TransactionSynchronizationManager;
3231

3332
import static org.assertj.core.api.Assertions.assertThat;
33+
import static org.springframework.test.transaction.TransactionAssert.assertThatTransaction;
3434

3535
/**
3636
* Integration test which verifies proper transactional behavior when the default
@@ -71,7 +71,7 @@ public void verifyInitialTestData() {
7171

7272
@Test(timeout = 1000)
7373
public void modifyTestDataWithinTransaction() {
74-
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
74+
assertThatTransaction().isActive();
7575
assertThat(addPerson(jdbcTemplate, JANE)).as("Adding jane").isEqualTo(1);
7676
assertThat(addPerson(jdbcTemplate, SUE)).as("Adding sue").isEqualTo(1);
7777
assertThat(countRowsInPersonTable(jdbcTemplate)).as("Verifying the number of rows in the person table within a transaction.").isEqualTo(3);

‎spring-test/src/test/java/org/springframework/test/context/junit4/MethodLevelTransactionalSpringRunnerTests.java

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -32,9 +32,9 @@
3232
import org.springframework.test.context.support.DirtiesContextTestExecutionListener;
3333
import org.springframework.test.context.transaction.TransactionalTestExecutionListener;
3434
import org.springframework.transaction.annotation.Transactional;
35-
import org.springframework.transaction.support.TransactionSynchronizationManager;
3635

3736
import static org.assertj.core.api.Assertions.assertThat;
37+
import static org.springframework.test.transaction.TransactionAssert.assertThatTransaction;
3838

3939
/**
4040
* JUnit 4 based integration test which verifies support of Spring's
@@ -85,7 +85,7 @@ public void verifyInitialTestData() {
8585
@Test
8686
@Transactional("transactionManager2")
8787
public void modifyTestDataWithinTransaction() {
88-
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
88+
assertThatTransaction().isActive();
8989
assertThat(deletePerson(jdbcTemplate, BOB)).as("Deleting bob").isEqualTo(1);
9090
assertThat(addPerson(jdbcTemplate, JANE)).as("Adding jane").isEqualTo(1);
9191
assertThat(addPerson(jdbcTemplate, SUE)).as("Adding sue").isEqualTo(1);
@@ -94,7 +94,7 @@ public void modifyTestDataWithinTransaction() {
9494

9595
@Test
9696
public void modifyTestDataWithoutTransaction() {
97-
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
97+
assertThatTransaction().isNotActive();
9898
assertThat(addPerson(jdbcTemplate, LUKE)).as("Adding luke").isEqualTo(1);
9999
assertThat(addPerson(jdbcTemplate, LEIA)).as("Adding leia").isEqualTo(1);
100100
assertThat(addPerson(jdbcTemplate, YODA)).as("Adding yoda").isEqualTo(1);

‎spring-test/src/test/java/org/springframework/test/context/junit4/RollbackOverrideDefaultRollbackFalseRollbackAnnotationTransactionalTests.java

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -25,9 +25,9 @@
2525
import org.springframework.beans.factory.annotation.Autowired;
2626
import org.springframework.jdbc.core.JdbcTemplate;
2727
import org.springframework.test.annotation.Rollback;
28-
import org.springframework.transaction.support.TransactionSynchronizationManager;
2928

3029
import static org.assertj.core.api.Assertions.assertThat;
30+
import static org.springframework.test.transaction.TransactionAssert.assertThatTransaction;
3131

3232
/**
3333
* Extension of {@link DefaultRollbackFalseRollbackAnnotationTransactionalTests}
@@ -64,7 +64,7 @@ public void verifyInitialTestData() {
6464
@Rollback
6565
@Override
6666
public void modifyTestDataWithinTransaction() {
67-
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
67+
assertThatTransaction().isActive();
6868
assertThat(deletePerson(jdbcTemplate, BOB)).as("Deleting bob").isEqualTo(1);
6969
assertThat(addPerson(jdbcTemplate, JANE)).as("Adding jane").isEqualTo(1);
7070
assertThat(addPerson(jdbcTemplate, SUE)).as("Adding sue").isEqualTo(1);

0 commit comments

Comments
 (0)