Spring/spring-framework
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Migrate JUnit 4 assertions to AssertJ

Browse Source 
Migrate all existing JUnit 4 `assert...` based assertions to AssertJ
and add a checkstyle rule to ensure they don't return.

See gh-23022
This commit is contained in:
Phillip Webb
2019-05-23 15:51:39 -07:00
parent 95a9d46a87
commit 9d74da006c
1636 changed files with 37861 additions and 40390 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
spring-tx/src/test/java/org/springframework/dao/annotation/PersistenceExceptionTranslationPostProcessorTests.java
View File

@@ -39,8 +39,6 @@ import org.springframework.stereotype.Repository;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
/**
* @author Rod Johnson
@@ -68,15 +66,15 @@ public class PersistenceExceptionTranslationPostProcessorTests {
gac.refresh();
RepositoryInterface shouldNotBeProxied = (RepositoryInterface) gac.getBean("notProxied");
assertFalse(AopUtils.isAopProxy(shouldNotBeProxied));
assertThat(AopUtils.isAopProxy(shouldNotBeProxied)).isFalse();
RepositoryInterface shouldBeProxied = (RepositoryInterface) gac.getBean("proxied");
assertTrue(AopUtils.isAopProxy(shouldBeProxied));
assertThat(AopUtils.isAopProxy(shouldBeProxied)).isTrue();
RepositoryWithoutInterface rwi = (RepositoryWithoutInterface) gac.getBean("classProxied");
assertTrue(AopUtils.isAopProxy(rwi));
assertThat(AopUtils.isAopProxy(rwi)).isTrue();
checkWillTranslateExceptions(rwi);
Additional rwi2 = (Additional) gac.getBean("classProxiedAndAdvised");
assertTrue(AopUtils.isAopProxy(rwi2));
assertThat(AopUtils.isAopProxy(rwi2)).isTrue();
rwi2.additionalMethod(false);
checkWillTranslateExceptions(rwi2);
assertThatExceptionOfType(DataAccessResourceFailureException.class).isThrownBy(() ->

19
spring-tx/src/test/java/org/springframework/dao/support/ChainedPersistenceExceptionTranslatorTests.java
View File

@@ -22,8 +22,7 @@ import org.springframework.dao.InvalidDataAccessApiUsageException;
import org.springframework.dao.OptimisticLockingFailureException;
import org.springframework.dao.support.DataAccessUtilsTests.MapPersistenceExceptionTranslator;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.assertj.core.api.Assertions.assertThat;
/**
* @author Rod Johnson
@@ -36,7 +35,7 @@ public class ChainedPersistenceExceptionTranslatorTests {
ChainedPersistenceExceptionTranslator pet = new ChainedPersistenceExceptionTranslator();
//MapPersistenceExceptionTranslator mpet = new MapPersistenceExceptionTranslator();
RuntimeException in = new RuntimeException("in");
assertSame(in, DataAccessUtils.translateIfNecessary(in, pet));
assertThat(DataAccessUtils.translateIfNecessary(in, pet)).isSameAs(in);
}
@Test
@@ -48,30 +47,28 @@ public class ChainedPersistenceExceptionTranslatorTests {
mpet1.addTranslation(in1, out1);
ChainedPersistenceExceptionTranslator chainedPet1 = new ChainedPersistenceExceptionTranslator();
assertSame("Should not translate yet", in1, DataAccessUtils.translateIfNecessary(in1, chainedPet1));
assertThat(DataAccessUtils.translateIfNecessary(in1, chainedPet1)).as("Should not translate yet").isSameAs(in1);
chainedPet1.addDelegate(mpet1);
assertSame("Should now translate", out1, DataAccessUtils.translateIfNecessary(in1, chainedPet1));
assertThat(DataAccessUtils.translateIfNecessary(in1, chainedPet1)).as("Should now translate").isSameAs(out1);
// Now add a new translator and verify it wins
MapPersistenceExceptionTranslator mpet2 = new MapPersistenceExceptionTranslator();
mpet2.addTranslation(in1, out2);
chainedPet1.addDelegate(mpet2);
assertSame("Should still translate the same due to ordering",
out1, DataAccessUtils.translateIfNecessary(in1, chainedPet1));
assertThat(DataAccessUtils.translateIfNecessary(in1, chainedPet1)).as("Should still translate the same due to ordering").isSameAs(out1);
ChainedPersistenceExceptionTranslator chainedPet2 = new ChainedPersistenceExceptionTranslator();
chainedPet2.addDelegate(mpet2);
chainedPet2.addDelegate(mpet1);
assertSame("Should translate differently due to ordering",
out2, DataAccessUtils.translateIfNecessary(in1, chainedPet2));
assertThat(DataAccessUtils.translateIfNecessary(in1, chainedPet2)).as("Should translate differently due to ordering").isSameAs(out2);
RuntimeException in2 = new RuntimeException("in2");
OptimisticLockingFailureException out3 = new OptimisticLockingFailureException("out2");
assertNull(chainedPet2.translateExceptionIfPossible(in2));
assertThat(chainedPet2.translateExceptionIfPossible(in2)).isNull();
MapPersistenceExceptionTranslator mpet3 = new MapPersistenceExceptionTranslator();
mpet3.addTranslation(in2, out3);
chainedPet2.addDelegate(mpet3);
assertSame(out3, chainedPet2.translateExceptionIfPossible(in2));
assertThat(chainedPet2.translateExceptionIfPossible(in2)).isSameAs(out3);
}
}

59
spring-tx/src/test/java/org/springframework/dao/support/DataAccessUtilsTests.java
View File

@@ -33,9 +33,6 @@ import org.springframework.dao.TypeMismatchDataAccessException;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
/**
* @author Juergen Hoeller
@@ -47,7 +44,7 @@ public class DataAccessUtilsTests {
public void withEmptyCollection() {
Collection<String> col = new HashSet<>();
assertNull(DataAccessUtils.uniqueResult(col));
assertThat(DataAccessUtils.uniqueResult(col)).isNull();
assertThatExceptionOfType(IncorrectResultSizeDataAccessException.class).isThrownBy(() ->
DataAccessUtils.requiredUniqueResult(col))
@@ -98,12 +95,12 @@ public class DataAccessUtilsTests {
Collection<Integer> col = new HashSet<>(1);
col.add(5);
assertEquals(Integer.valueOf(5), DataAccessUtils.uniqueResult(col));
assertEquals(Integer.valueOf(5), DataAccessUtils.requiredUniqueResult(col));
assertEquals(Integer.valueOf(5), DataAccessUtils.objectResult(col, Integer.class));
assertEquals("5", DataAccessUtils.objectResult(col, String.class));
assertEquals(5, DataAccessUtils.intResult(col));
assertEquals(5, DataAccessUtils.longResult(col));
assertThat(DataAccessUtils.uniqueResult(col)).isEqualTo(Integer.valueOf(5));
assertThat(DataAccessUtils.requiredUniqueResult(col)).isEqualTo(Integer.valueOf(5));
assertThat(DataAccessUtils.objectResult(col, Integer.class)).isEqualTo(Integer.valueOf(5));
assertThat(DataAccessUtils.objectResult(col, String.class)).isEqualTo("5");
assertThat(DataAccessUtils.intResult(col)).isEqualTo(5);
assertThat(DataAccessUtils.longResult(col)).isEqualTo(5);
}
@Test
@@ -113,12 +110,12 @@ public class DataAccessUtilsTests {
col.add(i);
col.add(i);
assertEquals(Integer.valueOf(5), DataAccessUtils.uniqueResult(col));
assertEquals(Integer.valueOf(5), DataAccessUtils.requiredUniqueResult(col));
assertEquals(Integer.valueOf(5), DataAccessUtils.objectResult(col, Integer.class));
assertEquals("5", DataAccessUtils.objectResult(col, String.class));
assertEquals(5, DataAccessUtils.intResult(col));
assertEquals(5, DataAccessUtils.longResult(col));
assertThat(DataAccessUtils.uniqueResult(col)).isEqualTo(Integer.valueOf(5));
assertThat(DataAccessUtils.requiredUniqueResult(col)).isEqualTo(Integer.valueOf(5));
assertThat(DataAccessUtils.objectResult(col, Integer.class)).isEqualTo(Integer.valueOf(5));
assertThat(DataAccessUtils.objectResult(col, String.class)).isEqualTo("5");
assertThat(DataAccessUtils.intResult(col)).isEqualTo(5);
assertThat(DataAccessUtils.longResult(col)).isEqualTo(5);
}
@Test
@@ -138,12 +135,12 @@ public class DataAccessUtilsTests {
Collection<Long> col = new HashSet<>(1);
col.add(5L);
assertEquals(Long.valueOf(5L), DataAccessUtils.uniqueResult(col));
assertEquals(Long.valueOf(5L), DataAccessUtils.requiredUniqueResult(col));
assertEquals(Long.valueOf(5L), DataAccessUtils.objectResult(col, Long.class));
assertEquals("5", DataAccessUtils.objectResult(col, String.class));
assertEquals(5, DataAccessUtils.intResult(col));
assertEquals(5, DataAccessUtils.longResult(col));
assertThat(DataAccessUtils.uniqueResult(col)).isEqualTo(Long.valueOf(5L));
assertThat(DataAccessUtils.requiredUniqueResult(col)).isEqualTo(Long.valueOf(5L));
assertThat(DataAccessUtils.objectResult(col, Long.class)).isEqualTo(Long.valueOf(5L));
assertThat(DataAccessUtils.objectResult(col, String.class)).isEqualTo("5");
assertThat(DataAccessUtils.intResult(col)).isEqualTo(5);
assertThat(DataAccessUtils.longResult(col)).isEqualTo(5);
}
@Test
@@ -151,9 +148,9 @@ public class DataAccessUtilsTests {
Collection<String> col = new HashSet<>(1);
col.add("test1");
assertEquals("test1", DataAccessUtils.uniqueResult(col));
assertEquals("test1", DataAccessUtils.requiredUniqueResult(col));
assertEquals("test1", DataAccessUtils.objectResult(col, String.class));
assertThat(DataAccessUtils.uniqueResult(col)).isEqualTo("test1");
assertThat(DataAccessUtils.requiredUniqueResult(col)).isEqualTo("test1");
assertThat(DataAccessUtils.objectResult(col, String.class)).isEqualTo("test1");
assertThatExceptionOfType(TypeMismatchDataAccessException.class).isThrownBy(() ->
DataAccessUtils.intResult(col));
@@ -168,10 +165,10 @@ public class DataAccessUtilsTests {
Collection<Date> col = new HashSet<>(1);
col.add(date);
assertEquals(date, DataAccessUtils.uniqueResult(col));
assertEquals(date, DataAccessUtils.requiredUniqueResult(col));
assertEquals(date, DataAccessUtils.objectResult(col, Date.class));
assertEquals(date.toString(), DataAccessUtils.objectResult(col, String.class));
assertThat(DataAccessUtils.uniqueResult(col)).isEqualTo(date);
assertThat(DataAccessUtils.requiredUniqueResult(col)).isEqualTo(date);
assertThat(DataAccessUtils.objectResult(col, Date.class)).isEqualTo(date);
assertThat(DataAccessUtils.objectResult(col, String.class)).isEqualTo(date.toString());
assertThatExceptionOfType(TypeMismatchDataAccessException.class).isThrownBy(() ->
DataAccessUtils.intResult(col));
@@ -184,7 +181,7 @@ public class DataAccessUtilsTests {
public void exceptionTranslationWithNoTranslation() {
MapPersistenceExceptionTranslator mpet = new MapPersistenceExceptionTranslator();
RuntimeException in = new RuntimeException();
assertSame(in, DataAccessUtils.translateIfNecessary(in, mpet));
assertThat(DataAccessUtils.translateIfNecessary(in, mpet)).isSameAs(in);
}
@Test
@@ -193,7 +190,7 @@ public class DataAccessUtilsTests {
RuntimeException in = new RuntimeException("in");
InvalidDataAccessApiUsageException out = new InvalidDataAccessApiUsageException("out");
mpet.addTranslation(in, out);
assertSame(out, DataAccessUtils.translateIfNecessary(in, mpet));
assertThat(DataAccessUtils.translateIfNecessary(in, mpet)).isSameAs(out);
}
private <E extends IncorrectResultSizeDataAccessException> Consumer<E> sizeRequirements(

6
spring-tx/src/test/java/org/springframework/jca/cci/CciLocalTransactionTests.java
View File

@@ -35,7 +35,7 @@ import org.springframework.transaction.support.TransactionCallbackWithoutResult;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import org.springframework.transaction.support.TransactionTemplate;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
@@ -73,7 +73,7 @@ public class CciLocalTransactionTests {
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertTrue("Has thread connection", TransactionSynchronizationManager.hasResource(connectionFactory));
assertThat(TransactionSynchronizationManager.hasResource(connectionFactory)).as("Has thread connection").isTrue();
CciTemplate ct = new CciTemplate(connectionFactory);
ct.execute(interactionSpec, record, record);
}
@@ -113,7 +113,7 @@ public class CciLocalTransactionTests {
tt.execute(new TransactionCallback<Void>() {
@Override
public Void doInTransaction(TransactionStatus status) {
assertTrue("Has thread connection", TransactionSynchronizationManager.hasResource(connectionFactory));
assertThat(TransactionSynchronizationManager.hasResource(connectionFactory)).as("Has thread connection").isTrue();
CciTemplate ct = new CciTemplate(connectionFactory);
ct.execute(interactionSpec, record, record);
throw new DataRetrievalFailureException("error");

11
spring-tx/src/test/java/org/springframework/jca/cci/CciTemplateTests.java
View File

@@ -40,9 +40,7 @@ import org.springframework.jca.cci.core.InteractionCallback;
import org.springframework.jca.cci.core.RecordCreator;
import org.springframework.jca.cci.core.RecordExtractor;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
@@ -128,7 +126,8 @@ public class CciTemplateTests {
ct.setOutputRecordCreator(new RecordCreator() {
@Override
public Record createRecord(RecordFactory recordFactory) {
assertTrue(recordFactory instanceof NotSupportedRecordFactory);
boolean condition = recordFactory instanceof NotSupportedRecordFactory;
assertThat(condition).isTrue();
return outputRecord;
}
});
@@ -341,7 +340,7 @@ public class CciTemplateTests {
CciTemplate ct = new CciTemplate(connectionFactory);
ct.setOutputRecordCreator(creator);
assertEquals(obj, ct.execute(interactionSpec, generator, extractor));
assertThat(ct.execute(interactionSpec, generator, extractor)).isEqualTo(obj);
verify(interaction).close();
verify(connection).close();
@@ -534,7 +533,7 @@ public class CciTemplateTests {
CciTemplate ct = new CciTemplate(connectionFactory);
Record tmpOutputRecord = ct.execute(interactionSpec, inputOutputRecord);
assertNull(tmpOutputRecord);
assertThat(tmpOutputRecord).isNull();
verify(interaction).execute(interactionSpec, inputOutputRecord);
verify(interaction).close();

6
spring-tx/src/test/java/org/springframework/jca/cci/EisOperationTests.java
View File

@@ -30,7 +30,7 @@ import org.springframework.jca.cci.core.RecordCreator;
import org.springframework.jca.cci.object.MappingRecordOperation;
import org.springframework.jca.cci.object.SimpleRecordOperation;
import static org.junit.Assert.assertSame;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
@@ -139,7 +139,7 @@ public class EisOperationTests {
given(interaction.execute(interactionSpec, inputRecord)).willReturn(outputRecord);
given(callDetector.callExtractOutputData(outputRecord)).willReturn(outObj);
assertSame(outObj, query.execute(inObj));
assertThat(query.execute(inObj)).isSameAs(outObj);
verify(interaction).close();
verify(connection).close();
}
@@ -176,7 +176,7 @@ public class EisOperationTests {
given(interaction.execute(interactionSpec, inputRecord, outputRecord)).willReturn(true);
given(callDetector.callExtractOutputData(outputRecord)).willReturn(outObj);
assertSame(outObj, query.execute(inObj));
assertThat(query.execute(inObj)).isSameAs(outObj);
verify(interaction).close();
verify(connection).close();
}

10
spring-tx/src/test/java/org/springframework/jca/support/LocalConnectionFactoryBeanTests.java
View File

@@ -21,10 +21,8 @@ import javax.resource.spi.ManagedConnectionFactory;
import org.junit.Test;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
@@ -46,13 +44,13 @@ public class LocalConnectionFactoryBeanTests {
@Test
public void testIsSingleton() throws Exception {
LocalConnectionFactoryBean factory = new LocalConnectionFactoryBean();
assertTrue(factory.isSingleton());
assertThat(factory.isSingleton()).isTrue();
}
@Test
public void testGetObjectTypeIsNullIfConnectionFactoryHasNotBeenConfigured() throws Exception {
LocalConnectionFactoryBean factory = new LocalConnectionFactoryBean();
assertNull(factory.getObjectType());
assertThat(factory.getObjectType()).isNull();
}
@Test
@@ -63,7 +61,7 @@ public class LocalConnectionFactoryBeanTests {
LocalConnectionFactoryBean factory = new LocalConnectionFactoryBean();
factory.setManagedConnectionFactory(managedConnectionFactory);
factory.afterPropertiesSet();
assertEquals(CONNECTION_FACTORY, factory.getObject());
assertThat(factory.getObject()).isEqualTo(CONNECTION_FACTORY);
}
@Test

80
spring-tx/src/test/java/org/springframework/transaction/JndiJtaTransactionManagerTests.java
View File

@@ -30,10 +30,7 @@ import org.springframework.transaction.support.TransactionCallbackWithoutResult;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import org.springframework.transaction.support.TransactionTemplate;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
@@ -86,34 +83,37 @@ public class JndiJtaTransactionManagerTests {
ptm.afterPropertiesSet();
if (tmFound) {
assertEquals(tm, ptm.getTransactionManager());
assertThat(ptm.getTransactionManager()).isEqualTo(tm);
}
else {
assertNull(ptm.getTransactionManager());
assertThat(ptm.getTransactionManager()).isNull();
}
if (defaultUt) {
assertEquals(ut, ptm.getUserTransaction());
assertThat(ptm.getUserTransaction()).isEqualTo(ut);
}
else {
assertTrue(ptm.getUserTransaction() instanceof UserTransactionAdapter);
boolean condition = ptm.getUserTransaction() instanceof UserTransactionAdapter;
assertThat(condition).isTrue();
UserTransactionAdapter uta = (UserTransactionAdapter) ptm.getUserTransaction();
assertEquals(tm, uta.getTransactionManager());
assertThat(uta.getTransactionManager()).isEqualTo(tm);
}
TransactionTemplate tt = new TransactionTemplate(ptm);
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition1).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
// something transactional
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
}
});
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
if (defaultUt) {
@@ -143,22 +143,24 @@ public class JndiJtaTransactionManagerTests {
ptm.setJndiTemplate(jndiTemplate);
ptm.afterPropertiesSet();
assertEquals(ut, ptm.getUserTransaction());
assertEquals(tm, ptm.getTransactionManager());
assertThat(ptm.getUserTransaction()).isEqualTo(ut);
assertThat(ptm.getTransactionManager()).isEqualTo(tm);
TransactionTemplate tt = new TransactionTemplate(ptm);
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition1).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
// something transactional
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
}
});
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
verify(ut).begin();
verify(ut).commit();
@@ -177,18 +179,19 @@ public class JndiJtaTransactionManagerTests {
ptm.setCacheUserTransaction(false);
ptm.afterPropertiesSet();
assertEquals(ut, ptm.getUserTransaction());
assertThat(ptm.getUserTransaction()).isEqualTo(ut);
TransactionTemplate tt = new TransactionTemplate(ptm);
assertEquals(JtaTransactionManager.SYNCHRONIZATION_ALWAYS, ptm.getTransactionSynchronization());
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(ptm.getTransactionSynchronization()).isEqualTo(JtaTransactionManager.SYNCHRONIZATION_ALWAYS);
boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition1).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
// something transactional
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
}
});
@@ -197,12 +200,13 @@ public class JndiJtaTransactionManagerTests {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
// something transactional
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
}
});
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
verify(ut).begin();
verify(ut).commit();
@@ -216,11 +220,11 @@ public class JndiJtaTransactionManagerTests {
*/
@After
public void tearDown() {
assertTrue(TransactionSynchronizationManager.getResourceMap().isEmpty());
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertNull(TransactionSynchronizationManager.getCurrentTransactionName());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
assertThat(TransactionSynchronizationManager.getResourceMap().isEmpty()).isTrue();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isNull();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
}
}

267
spring-tx/src/test/java/org/springframework/transaction/JtaTransactionManagerTests.java
View File

@@ -42,12 +42,7 @@ import org.springframework.transaction.support.TransactionTemplate;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.assertj.core.api.Assertions.fail;
import static org.mockito.BDDMockito.given;
import static org.mockito.BDDMockito.willThrow;
import static org.mockito.Mockito.atLeastOnce;
@@ -72,23 +67,23 @@ public class JtaTransactionManagerTests {
TransactionTemplate tt = new TransactionTemplate(ptm);
tt.setName("txName");
assertEquals(JtaTransactionManager.SYNCHRONIZATION_ALWAYS, ptm.getTransactionSynchronization());
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertNull(TransactionSynchronizationManager.getCurrentTransactionName());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(ptm.getTransactionSynchronization()).isEqualTo(JtaTransactionManager.SYNCHRONIZATION_ALWAYS);
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isNull();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
// something transactional
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.registerSynchronization(synch);
assertEquals("txName", TransactionSynchronizationManager.getCurrentTransactionName());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isEqualTo("txName");
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
}
});
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertNull(TransactionSynchronizationManager.getCurrentTransactionName());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isNull();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
verify(ut).begin();
verify(ut).commit();
@@ -108,16 +103,16 @@ public class JtaTransactionManagerTests {
JtaTransactionManager ptm = newJtaTransactionManager(ut);
TransactionTemplate tt = new TransactionTemplate(ptm);
ptm.setTransactionSynchronization(JtaTransactionManager.SYNCHRONIZATION_ON_ACTUAL_TRANSACTION);
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
// something transactional
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.registerSynchronization(synch);
}
});
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
verify(ut).begin();
verify(ut).commit();
@@ -138,14 +133,14 @@ public class JtaTransactionManagerTests {
ptm.setTransactionSynchronization(JtaTransactionManager.SYNCHRONIZATION_NEVER);
ptm.afterPropertiesSet();
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
}
});
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
verify(ut).begin();
verify(ut).commit();
@@ -162,22 +157,22 @@ public class JtaTransactionManagerTests {
tt.setTimeout(10);
tt.setName("txName");
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertNull(TransactionSynchronizationManager.getCurrentTransactionName());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isNull();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.registerSynchronization(synch);
assertEquals("txName", TransactionSynchronizationManager.getCurrentTransactionName());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isEqualTo("txName");
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
status.setRollbackOnly();
}
});
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertNull(TransactionSynchronizationManager.getCurrentTransactionName());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isNull();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
verify(ut).setTransactionTimeout(10);
verify(ut).begin();
@@ -196,16 +191,16 @@ public class JtaTransactionManagerTests {
TransactionTemplate tt = new TransactionTemplate(ptm);
ptm.setTransactionSynchronization(JtaTransactionManager.SYNCHRONIZATION_ON_ACTUAL_TRANSACTION);
tt.setTimeout(10);
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.registerSynchronization(synch);
status.setRollbackOnly();
}
});
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
verify(ut).setTransactionTimeout(10);
verify(ut).begin();
@@ -225,15 +220,15 @@ public class JtaTransactionManagerTests {
tt.setTimeout(10);
ptm.afterPropertiesSet();
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
status.setRollbackOnly();
}
});
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
verify(ut).setTransactionTimeout(10);
verify(ut).begin();
@@ -250,16 +245,16 @@ public class JtaTransactionManagerTests {
JtaTransactionManager ptm = newJtaTransactionManager(ut);
TransactionTemplate tt = new TransactionTemplate(ptm);
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.registerSynchronization(synch);
status.setRollbackOnly();
}
});
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
verify(ut).setRollbackOnly();
verify(synch).beforeCompletion();
@@ -275,17 +270,17 @@ public class JtaTransactionManagerTests {
JtaTransactionManager ptm = newJtaTransactionManager(ut);
TransactionTemplate tt = new TransactionTemplate(ptm);
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThatIllegalStateException().isThrownBy(() ->
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.registerSynchronization(synch);
throw new IllegalStateException("I want a rollback");
}
}));
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
verify(ut).setRollbackOnly();
verify(synch).beforeCompletion();
@@ -302,16 +297,16 @@ public class JtaTransactionManagerTests {
JtaTransactionManager ptm = newJtaTransactionManager(ut);
TransactionTemplate tt = new TransactionTemplate(ptm);
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThatExceptionOfType(OptimisticLockingFailureException.class).isThrownBy(() ->
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.registerSynchronization(synch);
}
}));
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
verify(ut).setRollbackOnly();
verify(synch).beforeCompletion();
@@ -328,16 +323,16 @@ public class JtaTransactionManagerTests {
JtaTransactionManager ptm = newJtaTransactionManager(ut);
ptm.setGlobalRollbackOnParticipationFailure(false);
TransactionTemplate tt = new TransactionTemplate(ptm);
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.registerSynchronization(synch);
status.setRollbackOnly();
}
});
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
verify(ut).setRollbackOnly();
verify(synch).beforeCompletion();
@@ -353,17 +348,17 @@ public class JtaTransactionManagerTests {
JtaTransactionManager ptm = newJtaTransactionManager(ut);
ptm.setGlobalRollbackOnParticipationFailure(false);
TransactionTemplate tt = new TransactionTemplate(ptm);
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThatIllegalStateException().isThrownBy(() ->
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.registerSynchronization(synch);
throw new IllegalStateException("I want a rollback");
}
}));
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
verify(synch).beforeCompletion();
verify(synch).afterCompletion(TransactionSynchronization.STATUS_UNKNOWN);
@@ -382,17 +377,17 @@ public class JtaTransactionManagerTests {
JtaTransactionManager ptm = newJtaTransactionManager(ut, tm);
TransactionTemplate tt = new TransactionTemplate(ptm);
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.registerSynchronization(synch);
status.setRollbackOnly();
}
});
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertNotNull(tx.getSynchronization());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(tx.getSynchronization()).isNotNull();
tx.getSynchronization().beforeCompletion();
tx.getSynchronization().afterCompletion(Status.STATUS_ROLLEDBACK);
@@ -411,16 +406,16 @@ public class JtaTransactionManagerTests {
JtaTransactionManager ptm = newJtaTransactionManager(ut);
TransactionTemplate tt = new TransactionTemplate(ptm);
ptm.setTransactionSynchronization(JtaTransactionManager.SYNCHRONIZATION_ON_ACTUAL_TRANSACTION);
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.registerSynchronization(synch);
status.setRollbackOnly();
}
});
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
verify(ut).setRollbackOnly();
verify(synch).beforeCompletion();
@@ -437,15 +432,15 @@ public class JtaTransactionManagerTests {
ptm.setTransactionSynchronization(JtaTransactionManager.SYNCHRONIZATION_NEVER);
ptm.afterPropertiesSet();
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
status.setRollbackOnly();
}
});
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
verify(ut).setRollbackOnly();
}
@@ -460,16 +455,16 @@ public class JtaTransactionManagerTests {
JtaTransactionManager ptm = newJtaTransactionManager(ut);
TransactionTemplate tt = new TransactionTemplate(ptm);
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.registerSynchronization(synch);
status.setRollbackOnly();
}
});
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
verify(ut).setRollbackOnly();
verify(synch).beforeCompletion();
@@ -486,16 +481,16 @@ public class JtaTransactionManagerTests {
JtaTransactionManager ptm = newJtaTransactionManager(ut);
TransactionTemplate tt = new TransactionTemplate(ptm);
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.registerSynchronization(synch);
status.setRollbackOnly();
}
});
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
verify(synch).beforeCompletion();
verify(synch).afterCompletion(TransactionSynchronization.STATUS_ROLLED_BACK);
@@ -512,15 +507,15 @@ public class JtaTransactionManagerTests {
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);
ptm.afterPropertiesSet();
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
status.setRollbackOnly();
}
});
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
}
@Test
@@ -534,15 +529,15 @@ public class JtaTransactionManagerTests {
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);
ptm.afterPropertiesSet();
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
status.setRollbackOnly();
}
});
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
}
@Test
@@ -556,15 +551,15 @@ public class JtaTransactionManagerTests {
JtaTransactionManager ptm = newJtaTransactionManager(ut, tm);
TransactionTemplate tt = new TransactionTemplate(ptm);
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_NOT_SUPPORTED);
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
status.setRollbackOnly();
}
});
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
verify(tm).resume(tx);
}
@@ -584,13 +579,13 @@ public class JtaTransactionManagerTests {
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
tt.setName("txName");
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertEquals("txName", TransactionSynchronizationManager.getCurrentTransactionName());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isEqualTo("txName");
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
TransactionTemplate tt2 = new TransactionTemplate(ptm);
tt2.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
@@ -599,18 +594,18 @@ public class JtaTransactionManagerTests {
tt2.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertEquals("txName2", TransactionSynchronizationManager.getCurrentTransactionName());
assertTrue(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isEqualTo("txName2");
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isTrue();
}
});
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertEquals("txName", TransactionSynchronizationManager.getCurrentTransactionName());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isEqualTo("txName");
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
}
});
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
verify(ut, times(2)).begin();
verify(ut, times(2)).commit();
@@ -627,31 +622,31 @@ public class JtaTransactionManagerTests {
TransactionTemplate tt = new TransactionTemplate(ptm);
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
TransactionTemplate tt2 = new TransactionTemplate(ptm);
tt2.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
tt2.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
}
});
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
}
});
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
verify(ut).begin();
verify(ut).commit();
@@ -668,14 +663,14 @@ public class JtaTransactionManagerTests {
JtaTransactionManager ptm = newJtaTransactionManager(ut, tm);
TransactionTemplate tt = new TransactionTemplate(ptm);
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
}
});
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
verify(ut).begin();
verify(ut).commit();
@@ -692,15 +687,15 @@ public class JtaTransactionManagerTests {
JtaTransactionManager ptm = newJtaTransactionManager(ut, tm);
TransactionTemplate tt = new TransactionTemplate(ptm);
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThatExceptionOfType(TransactionSystemException.class).isThrownBy(() ->
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
}
}));
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
}
@Test
@@ -715,15 +710,15 @@ public class JtaTransactionManagerTests {
JtaTransactionManager ptm = newJtaTransactionManager(ut, tm);
TransactionTemplate tt = new TransactionTemplate(ptm);
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThatExceptionOfType(CannotCreateTransactionException.class).isThrownBy(() ->
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
}
}));
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
verify(tm).resume(tx);
}
@@ -737,14 +732,14 @@ public class JtaTransactionManagerTests {
JtaTransactionManager ptm = newJtaTransactionManager(tm);
TransactionTemplate tt = new TransactionTemplate(ptm);
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
}
});
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
verify(tm).begin();
verify(tm).commit();
@@ -759,14 +754,14 @@ public class JtaTransactionManagerTests {
JtaTransactionManager ptm = newJtaTransactionManager(ut);
TransactionTemplate tt = new TransactionTemplate(ptm);
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThatExceptionOfType(TransactionSuspensionNotSupportedException.class).isThrownBy(() ->
tt.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus status) {
}
}));
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
}
@Test
@@ -896,7 +891,7 @@ public class JtaTransactionManagerTests {
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
@Override
public void afterCompletion(int status) {
assertTrue("Correct completion status", status == TransactionSynchronization.STATUS_ROLLED_BACK);
assertThat(status == TransactionSynchronization.STATUS_ROLLED_BACK).as("Correct completion status").isTrue();
}
});
}
@@ -930,7 +925,7 @@ public class JtaTransactionManagerTests {
TransactionStatus ts = tm.getTransaction(new DefaultTransactionDefinition());
boolean outerTransactionBoundaryReached = false;
try {
assertTrue("Is new transaction", ts.isNewTransaction());
assertThat(ts.isNewTransaction()).as("Is new transaction").isTrue();
TransactionTemplate tt = new TransactionTemplate(tm);
tt.execute(new TransactionCallbackWithoutResult() {
@@ -940,7 +935,7 @@ public class JtaTransactionManagerTests {
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
@Override
public void afterCompletion(int status) {
assertTrue("Correct completion status", status == TransactionSynchronization.STATUS_ROLLED_BACK);
assertThat(status == TransactionSynchronization.STATUS_ROLLED_BACK).as("Correct completion status").isTrue();
}
});
}
@@ -985,7 +980,7 @@ public class JtaTransactionManagerTests {
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
@Override
public void afterCompletion(int status) {
assertTrue("Correct completion status", status == TransactionSynchronization.STATUS_UNKNOWN);
assertThat(status == TransactionSynchronization.STATUS_UNKNOWN).as("Correct completion status").isTrue();
}
});
}
@@ -1012,7 +1007,7 @@ public class JtaTransactionManagerTests {
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
@Override
public void afterCompletion(int status) {
assertTrue("Correct completion status", status == TransactionSynchronization.STATUS_UNKNOWN);
assertThat(status == TransactionSynchronization.STATUS_UNKNOWN).as("Correct completion status").isTrue();
}
});
}
@@ -1039,7 +1034,7 @@ public class JtaTransactionManagerTests {
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
@Override
public void afterCompletion(int status) {
assertTrue("Correct completion status", status == TransactionSynchronization.STATUS_UNKNOWN);
assertThat(status == TransactionSynchronization.STATUS_UNKNOWN).as("Correct completion status").isTrue();
}
});
}
@@ -1064,7 +1059,7 @@ public class JtaTransactionManagerTests {
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
@Override
public void afterCompletion(int status) {
assertTrue("Correct completion status", status == TransactionSynchronization.STATUS_UNKNOWN);
assertThat(status == TransactionSynchronization.STATUS_UNKNOWN).as("Correct completion status").isTrue();
}
});
status.setRollbackOnly();
@@ -1109,7 +1104,7 @@ public class JtaTransactionManagerTests {
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
@Override
public void afterCompletion(int status) {
assertTrue("Correct completion status", status == TransactionSynchronization.STATUS_UNKNOWN);
assertThat(status == TransactionSynchronization.STATUS_UNKNOWN).as("Correct completion status").isTrue();
}
});
}
@@ -1124,12 +1119,12 @@ public class JtaTransactionManagerTests {
Status.STATUS_ACTIVE, Status.STATUS_ACTIVE);
JtaTransactionManager ptm = newJtaTransactionManager(ut);
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
TransactionStatus status = ptm.getTransaction(new DefaultTransactionDefinition());
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
// first commit
ptm.commit(status);
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
// second commit attempt
assertThatExceptionOfType(IllegalTransactionStateException.class).isThrownBy(() ->
ptm.commit(status));
@@ -1143,12 +1138,12 @@ public class JtaTransactionManagerTests {
given(ut.getStatus()).willReturn(Status.STATUS_NO_TRANSACTION, Status.STATUS_ACTIVE);
JtaTransactionManager ptm = newJtaTransactionManager(ut);
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
TransactionStatus status = ptm.getTransaction(new DefaultTransactionDefinition());
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
// first rollback
ptm.rollback(status);
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
// second rollback attempt
assertThatExceptionOfType(IllegalTransactionStateException.class).isThrownBy(() ->
ptm.rollback(status));
@@ -1163,12 +1158,12 @@ public class JtaTransactionManagerTests {
given(ut.getStatus()).willReturn(Status.STATUS_NO_TRANSACTION, Status.STATUS_ACTIVE);
JtaTransactionManager ptm = newJtaTransactionManager(ut);
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
TransactionStatus status = ptm.getTransaction(new DefaultTransactionDefinition());
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
// first: rollback
ptm.rollback(status);
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
// second: commit attempt
assertThatExceptionOfType(IllegalTransactionStateException.class).isThrownBy(() ->
ptm.commit(status));
@@ -1197,12 +1192,12 @@ public class JtaTransactionManagerTests {
*/
@After
public void tearDown() {
assertTrue(TransactionSynchronizationManager.getResourceMap().isEmpty());
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertNull(TransactionSynchronizationManager.getCurrentTransactionName());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertNull(TransactionSynchronizationManager.getCurrentTransactionIsolationLevel());
assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
assertThat(TransactionSynchronizationManager.getResourceMap().isEmpty()).isTrue();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.getCurrentTransactionName()).isNull();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertThat(TransactionSynchronizationManager.getCurrentTransactionIsolationLevel()).isNull();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
}
}

131
spring-tx/src/test/java/org/springframework/transaction/TransactionSupportTests.java
View File

@@ -25,13 +25,9 @@ import org.springframework.transaction.support.TransactionCallbackWithoutResult;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import org.springframework.transaction.support.TransactionTemplate;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
/**
* @author Juergen Hoeller
@@ -44,12 +40,12 @@ public class TransactionSupportTests {
PlatformTransactionManager tm = new TestTransactionManager(false, true);
DefaultTransactionStatus status1 = (DefaultTransactionStatus)
tm.getTransaction(new DefaultTransactionDefinition(TransactionDefinition.PROPAGATION_SUPPORTS));
assertFalse("Must not have transaction", status1.hasTransaction());
assertThat(status1.hasTransaction()).as("Must not have transaction").isFalse();
DefaultTransactionStatus status2 = (DefaultTransactionStatus)
tm.getTransaction(new DefaultTransactionDefinition(TransactionDefinition.PROPAGATION_REQUIRED));
assertTrue("Must have transaction", status2.hasTransaction());
assertTrue("Must be new transaction", status2.isNewTransaction());
assertThat(status2.hasTransaction()).as("Must have transaction").isTrue();
assertThat(status2.isNewTransaction()).as("Must be new transaction").isTrue();
assertThatExceptionOfType(IllegalTransactionStateException.class).isThrownBy(() ->
tm.getTransaction(new DefaultTransactionDefinition(TransactionDefinition.PROPAGATION_MANDATORY)));
@@ -60,18 +56,21 @@ public class TransactionSupportTests {
PlatformTransactionManager tm = new TestTransactionManager(true, true);
DefaultTransactionStatus status1 = (DefaultTransactionStatus)
tm.getTransaction(new DefaultTransactionDefinition(TransactionDefinition.PROPAGATION_SUPPORTS));
assertTrue("Must have transaction", status1.getTransaction() != null);
assertTrue("Must not be new transaction", !status1.isNewTransaction());
assertThat(status1.getTransaction() != null).as("Must have transaction").isTrue();
boolean condition2 = !status1.isNewTransaction();
assertThat(condition2).as("Must not be new transaction").isTrue();
DefaultTransactionStatus status2 = (DefaultTransactionStatus)
tm.getTransaction(new DefaultTransactionDefinition(TransactionDefinition.PROPAGATION_REQUIRED));
assertTrue("Must have transaction", status2.getTransaction() != null);
assertTrue("Must not be new transaction", !status2.isNewTransaction());
assertThat(status2.getTransaction() != null).as("Must have transaction").isTrue();
boolean condition1 = !status2.isNewTransaction();
assertThat(condition1).as("Must not be new transaction").isTrue();
DefaultTransactionStatus status3 = (DefaultTransactionStatus)
tm.getTransaction(new DefaultTransactionDefinition(TransactionDefinition.PROPAGATION_MANDATORY));
assertTrue("Must have transaction", status3.getTransaction() != null);
assertTrue("Must not be new transaction", !status3.isNewTransaction());
assertThat(status3.getTransaction() != null).as("Must have transaction").isTrue();
boolean condition = !status3.isNewTransaction();
assertThat(condition).as("Must not be new transaction").isTrue();
}
@Test
@@ -80,10 +79,10 @@ public class TransactionSupportTests {
TransactionStatus status = tm.getTransaction(null);
tm.commit(status);
assertTrue("triggered begin", tm.begin);
assertTrue("triggered commit", tm.commit);
assertFalse("no rollback", tm.rollback);
assertFalse("no rollbackOnly", tm.rollbackOnly);
assertThat(tm.begin).as("triggered begin").isTrue();
assertThat(tm.commit).as("triggered commit").isTrue();
assertThat(tm.rollback).as("no rollback").isFalse();
assertThat(tm.rollbackOnly).as("no rollbackOnly").isFalse();
}
@Test
@@ -92,10 +91,10 @@ public class TransactionSupportTests {
TransactionStatus status = tm.getTransaction(null);
tm.rollback(status);
assertTrue("triggered begin", tm.begin);
assertFalse("no commit", tm.commit);
assertTrue("triggered rollback", tm.rollback);
assertFalse("no rollbackOnly", tm.rollbackOnly);
assertThat(tm.begin).as("triggered begin").isTrue();
assertThat(tm.commit).as("no commit").isFalse();
assertThat(tm.rollback).as("triggered rollback").isTrue();
assertThat(tm.rollbackOnly).as("no rollbackOnly").isFalse();
}
@Test
@@ -105,10 +104,10 @@ public class TransactionSupportTests {
status.setRollbackOnly();
tm.commit(status);
assertTrue("triggered begin", tm.begin);
assertFalse("no commit", tm.commit);
assertTrue("triggered rollback", tm.rollback);
assertFalse("no rollbackOnly", tm.rollbackOnly);
assertThat(tm.begin).as("triggered begin").isTrue();
assertThat(tm.commit).as("no commit").isFalse();
assertThat(tm.rollback).as("triggered rollback").isTrue();
assertThat(tm.rollbackOnly).as("no rollbackOnly").isFalse();
}
@Test
@@ -117,10 +116,10 @@ public class TransactionSupportTests {
TransactionStatus status = tm.getTransaction(null);
tm.commit(status);
assertFalse("no begin", tm.begin);
assertFalse("no commit", tm.commit);
assertFalse("no rollback", tm.rollback);
assertFalse("no rollbackOnly", tm.rollbackOnly);
assertThat(tm.begin).as("no begin").isFalse();
assertThat(tm.commit).as("no commit").isFalse();
assertThat(tm.rollback).as("no rollback").isFalse();
assertThat(tm.rollbackOnly).as("no rollbackOnly").isFalse();
}
@Test
@@ -129,10 +128,10 @@ public class TransactionSupportTests {
TransactionStatus status = tm.getTransaction(null);
tm.rollback(status);
assertFalse("no begin", tm.begin);
assertFalse("no commit", tm.commit);
assertFalse("no rollback", tm.rollback);
assertTrue("triggered rollbackOnly", tm.rollbackOnly);
assertThat(tm.begin).as("no begin").isFalse();
assertThat(tm.commit).as("no commit").isFalse();
assertThat(tm.rollback).as("no rollback").isFalse();
assertThat(tm.rollbackOnly).as("triggered rollbackOnly").isTrue();
}
@Test
@@ -142,10 +141,10 @@ public class TransactionSupportTests {
status.setRollbackOnly();
tm.commit(status);
assertFalse("no begin", tm.begin);
assertFalse("no commit", tm.commit);
assertFalse("no rollback", tm.rollback);
assertTrue("triggered rollbackOnly", tm.rollbackOnly);
assertThat(tm.begin).as("no begin").isFalse();
assertThat(tm.commit).as("no commit").isFalse();
assertThat(tm.rollback).as("no rollback").isFalse();
assertThat(tm.rollbackOnly).as("triggered rollbackOnly").isTrue();
}
@Test
@@ -158,10 +157,10 @@ public class TransactionSupportTests {
}
});
assertTrue("triggered begin", tm.begin);
assertTrue("triggered commit", tm.commit);
assertFalse("no rollback", tm.rollback);
assertFalse("no rollbackOnly", tm.rollbackOnly);
assertThat(tm.begin).as("triggered begin").isTrue();
assertThat(tm.commit).as("triggered commit").isTrue();
assertThat(tm.rollback).as("no rollback").isFalse();
assertThat(tm.rollbackOnly).as("no rollbackOnly").isFalse();
}
@Test
@@ -174,8 +173,8 @@ public class TransactionSupportTests {
}
});
assertSame(template, ptm.getDefinition());
assertFalse(ptm.getStatus().isRollbackOnly());
assertThat(ptm.getDefinition()).isSameAs(template);
assertThat(ptm.getStatus().isRollbackOnly()).isFalse();
}
@Test
@@ -191,10 +190,10 @@ public class TransactionSupportTests {
}
}))
.isSameAs(ex);
assertTrue("triggered begin", tm.begin);
assertFalse("no commit", tm.commit);
assertTrue("triggered rollback", tm.rollback);
assertFalse("no rollbackOnly", tm.rollbackOnly);
assertThat(tm.begin).as("triggered begin").isTrue();
assertThat(tm.commit).as("no commit").isFalse();
assertThat(tm.rollback).as("triggered rollback").isTrue();
assertThat(tm.rollbackOnly).as("no rollbackOnly").isFalse();
}
@SuppressWarnings("serial")
@@ -218,10 +217,10 @@ public class TransactionSupportTests {
}
}))
.isSameAs(tex);
assertTrue("triggered begin", tm.begin);
assertFalse("no commit", tm.commit);
assertTrue("triggered rollback", tm.rollback);
assertFalse("no rollbackOnly", tm.rollbackOnly);
assertThat(tm.begin).as("triggered begin").isTrue();
assertThat(tm.commit).as("no commit").isFalse();
assertThat(tm.rollback).as("triggered rollback").isTrue();
assertThat(tm.rollbackOnly).as("no rollbackOnly").isFalse();
}
@Test
@@ -235,10 +234,10 @@ public class TransactionSupportTests {
throw new Error("Some application error");
}
}));
assertTrue("triggered begin", tm.begin);
assertFalse("no commit", tm.commit);
assertTrue("triggered rollback", tm.rollback);
assertFalse("no rollbackOnly", tm.rollbackOnly);
assertThat(tm.begin).as("triggered begin").isTrue();
assertThat(tm.commit).as("no commit").isFalse();
assertThat(tm.rollback).as("triggered rollback").isTrue();
assertThat(tm.rollbackOnly).as("no rollbackOnly").isFalse();
}
@Test
@@ -246,28 +245,28 @@ public class TransactionSupportTests {
TestTransactionManager tm = new TestTransactionManager(false, true);
TransactionTemplate template = new TransactionTemplate();
template.setTransactionManager(tm);
assertTrue("correct transaction manager set", template.getTransactionManager() == tm);
assertThat(template.getTransactionManager() == tm).as("correct transaction manager set").isTrue();
assertThatIllegalArgumentException().isThrownBy(() ->
template.setPropagationBehaviorName("TIMEOUT_DEFAULT"));
template.setPropagationBehaviorName("PROPAGATION_SUPPORTS");
assertTrue("Correct propagation behavior set", template.getPropagationBehavior() == TransactionDefinition.PROPAGATION_SUPPORTS);
assertThat(template.getPropagationBehavior() == TransactionDefinition.PROPAGATION_SUPPORTS).as("Correct propagation behavior set").isTrue();
assertThatIllegalArgumentException().isThrownBy(() ->
template.setPropagationBehavior(999));
template.setPropagationBehavior(TransactionDefinition.PROPAGATION_MANDATORY);
assertTrue("Correct propagation behavior set", template.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY);
assertThat(template.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY).as("Correct propagation behavior set").isTrue();
assertThatIllegalArgumentException().isThrownBy(() ->
template.setIsolationLevelName("TIMEOUT_DEFAULT"));
template.setIsolationLevelName("ISOLATION_SERIALIZABLE");
assertTrue("Correct isolation level set", template.getIsolationLevel() == TransactionDefinition.ISOLATION_SERIALIZABLE);
assertThat(template.getIsolationLevel() == TransactionDefinition.ISOLATION_SERIALIZABLE).as("Correct isolation level set").isTrue();
assertThatIllegalArgumentException().isThrownBy(() ->
template.setIsolationLevel(999));
template.setIsolationLevel(TransactionDefinition.ISOLATION_REPEATABLE_READ);
assertTrue("Correct isolation level set", template.getIsolationLevel() == TransactionDefinition.ISOLATION_REPEATABLE_READ);
assertThat(template.getIsolationLevel() == TransactionDefinition.ISOLATION_REPEATABLE_READ).as("Correct isolation level set").isTrue();
}
@Test
@@ -278,16 +277,16 @@ public class TransactionSupportTests {
TransactionTemplate template2 = new TransactionTemplate(tm2);
TransactionTemplate template3 = new TransactionTemplate(tm2);
assertNotEquals(template1, template2);
assertNotEquals(template1, template3);
assertEquals(template2, template3);
assertThat(template2).isNotEqualTo(template1);
assertThat(template3).isNotEqualTo(template1);
assertThat(template3).isEqualTo(template2);
}
@After
public void clear() {
assertTrue(TransactionSynchronizationManager.getResourceMap().isEmpty());
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.getResourceMap().isEmpty()).isTrue();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
}
}

24
spring-tx/src/test/java/org/springframework/transaction/TxNamespaceHandlerTests.java
View File

@@ -30,10 +30,8 @@ import org.springframework.transaction.interceptor.TransactionAttribute;
import org.springframework.transaction.interceptor.TransactionAttributeSource;
import org.springframework.transaction.interceptor.TransactionInterceptor;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
/**
* @author Rob Harrop
@@ -59,7 +57,7 @@ public class TxNamespaceHandlerTests {
@Test
public void isProxy() {
ITestBean bean = getTestBean();
assertTrue("testBean is not a proxy", AopUtils.isAopProxy(bean));
assertThat(AopUtils.isAopProxy(bean)).as("testBean is not a proxy").isTrue();
}
@Test
@@ -68,21 +66,21 @@ public class TxNamespaceHandlerTests {
CallCountingTransactionManager ptm = (CallCountingTransactionManager) context.getBean("transactionManager");
// try with transactional
assertEquals("Should not have any started transactions", 0, ptm.begun);
assertThat(ptm.begun).as("Should not have any started transactions").isEqualTo(0);
testBean.getName();
assertTrue(ptm.lastDefinition.isReadOnly());
assertEquals("Should have 1 started transaction", 1, ptm.begun);
assertEquals("Should have 1 committed transaction", 1, ptm.commits);
assertThat(ptm.lastDefinition.isReadOnly()).isTrue();
assertThat(ptm.begun).as("Should have 1 started transaction").isEqualTo(1);
assertThat(ptm.commits).as("Should have 1 committed transaction").isEqualTo(1);
// try with non-transaction
testBean.haveBirthday();
assertEquals("Should not have started another transaction", 1, ptm.begun);
assertThat(ptm.begun).as("Should not have started another transaction").isEqualTo(1);
// try with exceptional
assertThatExceptionOfType(Throwable.class).isThrownBy(() ->
testBean.exceptional(new IllegalArgumentException("foo")));
assertEquals("Should have another started transaction", 2, ptm.begun);
assertEquals("Should have 1 rolled back transaction", 1, ptm.rollbacks);
assertThat(ptm.begun).as("Should have another started transaction").isEqualTo(2);
assertThat(ptm.rollbacks).as("Should have 1 rolled back transaction").isEqualTo(1);
}
@Test
@@ -90,10 +88,10 @@ public class TxNamespaceHandlerTests {
TransactionInterceptor txInterceptor = (TransactionInterceptor) context.getBean("txRollbackAdvice");
TransactionAttributeSource txAttrSource = txInterceptor.getTransactionAttributeSource();
TransactionAttribute txAttr = txAttrSource.getTransactionAttribute(getAgeMethod,ITestBean.class);
assertTrue("should be configured to rollback on Exception",txAttr.rollbackOn(new Exception()));
assertThat(txAttr.rollbackOn(new Exception())).as("should be configured to rollback on Exception").isTrue();
txAttr = txAttrSource.getTransactionAttribute(setAgeMethod, ITestBean.class);
assertFalse("should not rollback on RuntimeException",txAttr.rollbackOn(new RuntimeException()));
assertThat(txAttr.rollbackOn(new RuntimeException())).as("should not rollback on RuntimeException").isFalse();
}
private ITestBean getTestBean() {

109
spring-tx/src/test/java/org/springframework/transaction/annotation/AnnotationTransactionAttributeSourceTests.java
View File

@@ -38,11 +38,7 @@ import org.springframework.transaction.interceptor.TransactionAttribute;
import org.springframework.transaction.interceptor.TransactionInterceptor;
import org.springframework.util.SerializationTestUtils;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
/**
* @author Colin Sampaleanu
@@ -64,7 +60,7 @@ public class AnnotationTransactionAttributeSourceTests {
proxyFactory.setTarget(tb);
ITestBean1 proxy = (ITestBean1) proxyFactory.getProxy();
proxy.getAge();
assertEquals(1, ptm.commits);
assertThat(ptm.commits).isEqualTo(1);
ITestBean1 serializedProxy = (ITestBean1) SerializationTestUtils.serializeAndDeserialize(proxy);
serializedProxy.getAge();
@@ -72,7 +68,7 @@ public class AnnotationTransactionAttributeSourceTests {
TransactionInterceptor serializedTi = (TransactionInterceptor) advised.getAdvisors()[0].getAdvice();
CallCountingTransactionManager serializedPtm =
(CallCountingTransactionManager) serializedTi.getTransactionManager();
assertEquals(2, serializedPtm.commits);
assertThat(serializedPtm.commits).isEqualTo(2);
}
@Test
@@ -80,10 +76,10 @@ public class AnnotationTransactionAttributeSourceTests {
Method method = Empty.class.getMethod("getAge");
AnnotationTransactionAttributeSource atas = new AnnotationTransactionAttributeSource();
assertNull(atas.getTransactionAttribute(method, null));
assertThat(atas.getTransactionAttribute(method, null)).isNull();
// Try again in case of caching
assertNull(atas.getTransactionAttribute(method, null));
assertThat(atas.getTransactionAttribute(method, null)).isNull();
}
/**
@@ -99,7 +95,7 @@ public class AnnotationTransactionAttributeSourceTests {
RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();
rbta.getRollbackRules().add(new RollbackRuleAttribute(Exception.class));
assertEquals(rbta.getRollbackRules(), ((RuleBasedTransactionAttribute) actual).getRollbackRules());
assertThat(((RuleBasedTransactionAttribute) actual).getRollbackRules()).isEqualTo(rbta.getRollbackRules());
}
/**
@@ -119,7 +115,7 @@ public class AnnotationTransactionAttributeSourceTests {
RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();
rbta.getRollbackRules().add(new RollbackRuleAttribute(Exception.class));
assertEquals(rbta.getRollbackRules(), ((RuleBasedTransactionAttribute) actual).getRollbackRules());
assertThat(((RuleBasedTransactionAttribute) actual).getRollbackRules()).isEqualTo(rbta.getRollbackRules());
}
/**
@@ -133,7 +129,7 @@ public class AnnotationTransactionAttributeSourceTests {
TransactionAttribute actual = atas.getTransactionAttribute(interfaceMethod, TestBean2.class);
RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();
assertEquals(rbta.getRollbackRules(), ((RuleBasedTransactionAttribute) actual).getRollbackRules());
assertThat(((RuleBasedTransactionAttribute) actual).getRollbackRules()).isEqualTo(rbta.getRollbackRules());
}
/**
@@ -146,18 +142,18 @@ public class AnnotationTransactionAttributeSourceTests {
AnnotationTransactionAttributeSource atas = new AnnotationTransactionAttributeSource();
TransactionAttribute actual = atas.getTransactionAttribute(interfaceMethod, TestBean3.class);
assertEquals(TransactionAttribute.PROPAGATION_REQUIRES_NEW, actual.getPropagationBehavior());
assertEquals(TransactionAttribute.ISOLATION_REPEATABLE_READ, actual.getIsolationLevel());
assertEquals(5, actual.getTimeout());
assertTrue(actual.isReadOnly());
assertThat(actual.getPropagationBehavior()).isEqualTo(TransactionAttribute.PROPAGATION_REQUIRES_NEW);
assertThat(actual.getIsolationLevel()).isEqualTo(TransactionAttribute.ISOLATION_REPEATABLE_READ);
assertThat(actual.getTimeout()).isEqualTo(5);
assertThat(actual.isReadOnly()).isTrue();
RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();
rbta.getRollbackRules().add(new RollbackRuleAttribute(Exception.class));
rbta.getRollbackRules().add(new NoRollbackRuleAttribute(IOException.class));
assertEquals(rbta.getRollbackRules(), ((RuleBasedTransactionAttribute) actual).getRollbackRules());
assertThat(((RuleBasedTransactionAttribute) actual).getRollbackRules()).isEqualTo(rbta.getRollbackRules());
TransactionAttribute actual2 = atas.getTransactionAttribute(interfaceMethod2, TestBean3.class);
assertEquals(TransactionAttribute.PROPAGATION_REQUIRED, actual2.getPropagationBehavior());
assertThat(actual2.getPropagationBehavior()).isEqualTo(TransactionAttribute.PROPAGATION_REQUIRED);
}
@Test
@@ -171,9 +167,9 @@ public class AnnotationTransactionAttributeSourceTests {
rbta.getRollbackRules().add(new RollbackRuleAttribute("java.lang.Exception"));
rbta.getRollbackRules().add(new NoRollbackRuleAttribute(IOException.class));
assertEquals(rbta.getRollbackRules(), ((RuleBasedTransactionAttribute) actual).getRollbackRules());
assertTrue(actual.rollbackOn(new Exception()));
assertFalse(actual.rollbackOn(new IOException()));
assertThat(((RuleBasedTransactionAttribute) actual).getRollbackRules()).isEqualTo(rbta.getRollbackRules());
assertThat(actual.rollbackOn(new Exception())).isTrue();
assertThat(actual.rollbackOn(new IOException())).isFalse();
actual = atas.getTransactionAttribute(method, method.getDeclaringClass());
@@ -181,9 +177,9 @@ public class AnnotationTransactionAttributeSourceTests {
rbta.getRollbackRules().add(new RollbackRuleAttribute("java.lang.Exception"));
rbta.getRollbackRules().add(new NoRollbackRuleAttribute(IOException.class));
assertEquals(rbta.getRollbackRules(), ((RuleBasedTransactionAttribute) actual).getRollbackRules());
assertTrue(actual.rollbackOn(new Exception()));
assertFalse(actual.rollbackOn(new IOException()));
assertThat(((RuleBasedTransactionAttribute) actual).getRollbackRules()).isEqualTo(rbta.getRollbackRules());
assertThat(actual.rollbackOn(new Exception())).isTrue();
assertThat(actual.rollbackOn(new IOException())).isFalse();
}
/**
@@ -200,7 +196,7 @@ public class AnnotationTransactionAttributeSourceTests {
RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();
rbta.getRollbackRules().add(new RollbackRuleAttribute(Exception.class));
rbta.getRollbackRules().add(new NoRollbackRuleAttribute(IOException.class));
assertEquals(rbta.getRollbackRules(), ((RuleBasedTransactionAttribute) actual).getRollbackRules());
assertThat(((RuleBasedTransactionAttribute) actual).getRollbackRules()).isEqualTo(rbta.getRollbackRules());
}
@Test
@@ -213,7 +209,7 @@ public class AnnotationTransactionAttributeSourceTests {
RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();
rbta.getRollbackRules().add(new RollbackRuleAttribute(Exception.class));
rbta.getRollbackRules().add(new NoRollbackRuleAttribute(IOException.class));
assertEquals(rbta.getRollbackRules(), ((RuleBasedTransactionAttribute) actual).getRollbackRules());
assertThat(((RuleBasedTransactionAttribute) actual).getRollbackRules()).isEqualTo(rbta.getRollbackRules());
}
@Test
@@ -226,7 +222,7 @@ public class AnnotationTransactionAttributeSourceTests {
RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();
rbta.getRollbackRules().add(new RollbackRuleAttribute(Exception.class));
rbta.getRollbackRules().add(new NoRollbackRuleAttribute(IOException.class));
assertEquals(rbta.getRollbackRules(), ((RuleBasedTransactionAttribute) actual).getRollbackRules());
assertThat(((RuleBasedTransactionAttribute) actual).getRollbackRules()).isEqualTo(rbta.getRollbackRules());
}
@Test
@@ -239,9 +235,9 @@ public class AnnotationTransactionAttributeSourceTests {
RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();
rbta.getRollbackRules().add(new RollbackRuleAttribute(Exception.class));
rbta.getRollbackRules().add(new NoRollbackRuleAttribute(IOException.class));
assertEquals(rbta.getRollbackRules(), ((RuleBasedTransactionAttribute) actual).getRollbackRules());
assertThat(((RuleBasedTransactionAttribute) actual).getRollbackRules()).isEqualTo(rbta.getRollbackRules());
assertTrue(actual.isReadOnly());
assertThat(actual.isReadOnly()).isTrue();
}
@Test
@@ -254,9 +250,9 @@ public class AnnotationTransactionAttributeSourceTests {
RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();
rbta.getRollbackRules().add(new RollbackRuleAttribute(Exception.class));
rbta.getRollbackRules().add(new NoRollbackRuleAttribute(IOException.class));
assertEquals(rbta.getRollbackRules(), ((RuleBasedTransactionAttribute) actual).getRollbackRules());
assertThat(((RuleBasedTransactionAttribute) actual).getRollbackRules()).isEqualTo(rbta.getRollbackRules());
assertTrue(actual.isReadOnly());
assertThat(actual.isReadOnly()).isTrue();
}
@Test
@@ -264,20 +260,20 @@ public class AnnotationTransactionAttributeSourceTests {
Method method = TestInterface9.class.getMethod("getAge");
Transactional annotation = AnnotationUtils.findAnnotation(method, Transactional.class);
assertNull("AnnotationUtils.findAnnotation should not find @Transactional for TestBean9.getAge()", annotation);
assertThat(annotation).as("AnnotationUtils.findAnnotation should not find @Transactional for TestBean9.getAge()").isNull();
annotation = AnnotationUtils.findAnnotation(TestBean9.class, Transactional.class);
assertNotNull("AnnotationUtils.findAnnotation failed to find @Transactional for TestBean9", annotation);
assertThat(annotation).as("AnnotationUtils.findAnnotation failed to find @Transactional for TestBean9").isNotNull();
AnnotationTransactionAttributeSource atas = new AnnotationTransactionAttributeSource();
TransactionAttribute actual = atas.getTransactionAttribute(method, TestBean9.class);
assertNotNull("Failed to retrieve TransactionAttribute for TestBean9.getAge()", actual);
assertThat(actual).as("Failed to retrieve TransactionAttribute for TestBean9.getAge()").isNotNull();
RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();
rbta.getRollbackRules().add(new RollbackRuleAttribute(Exception.class));
rbta.getRollbackRules().add(new NoRollbackRuleAttribute(IOException.class));
assertEquals(rbta.getRollbackRules(), ((RuleBasedTransactionAttribute) actual).getRollbackRules());
assertThat(((RuleBasedTransactionAttribute) actual).getRollbackRules()).isEqualTo(rbta.getRollbackRules());
assertTrue(actual.isReadOnly());
assertThat(actual.isReadOnly()).isTrue();
}
@Test
@@ -285,21 +281,20 @@ public class AnnotationTransactionAttributeSourceTests {
Method method = TestInterface10.class.getMethod("getAge");
Transactional annotation = AnnotationUtils.findAnnotation(method, Transactional.class);
assertNotNull("AnnotationUtils.findAnnotation failed to find @Transactional for TestBean10.getAge()",
annotation);
assertThat(annotation).as("AnnotationUtils.findAnnotation failed to find @Transactional for TestBean10.getAge()").isNotNull();
annotation = AnnotationUtils.findAnnotation(TestBean10.class, Transactional.class);
assertNull("AnnotationUtils.findAnnotation should not find @Transactional for TestBean10", annotation);
assertThat(annotation).as("AnnotationUtils.findAnnotation should not find @Transactional for TestBean10").isNull();
AnnotationTransactionAttributeSource atas = new AnnotationTransactionAttributeSource();
TransactionAttribute actual = atas.getTransactionAttribute(method, TestBean10.class);
assertNotNull("Failed to retrieve TransactionAttribute for TestBean10.getAge()", actual);
assertThat(actual).as("Failed to retrieve TransactionAttribute for TestBean10.getAge()").isNotNull();
RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();
rbta.getRollbackRules().add(new RollbackRuleAttribute(Exception.class));
rbta.getRollbackRules().add(new NoRollbackRuleAttribute(IOException.class));
assertEquals(rbta.getRollbackRules(), ((RuleBasedTransactionAttribute) actual).getRollbackRules());
assertThat(((RuleBasedTransactionAttribute) actual).getRollbackRules()).isEqualTo(rbta.getRollbackRules());
assertTrue(actual.isReadOnly());
assertThat(actual.isReadOnly()).isTrue();
}
@Test
@@ -309,9 +304,9 @@ public class AnnotationTransactionAttributeSourceTests {
AnnotationTransactionAttributeSource atas = new AnnotationTransactionAttributeSource();
TransactionAttribute getAgeAttr = atas.getTransactionAttribute(getAgeMethod, Ejb3AnnotatedBean1.class);
assertEquals(TransactionAttribute.PROPAGATION_REQUIRED, getAgeAttr.getPropagationBehavior());
assertThat(getAgeAttr.getPropagationBehavior()).isEqualTo(TransactionAttribute.PROPAGATION_REQUIRED);
TransactionAttribute getNameAttr = atas.getTransactionAttribute(getNameMethod, Ejb3AnnotatedBean1.class);
assertEquals(TransactionAttribute.PROPAGATION_SUPPORTS, getNameAttr.getPropagationBehavior());
assertThat(getNameAttr.getPropagationBehavior()).isEqualTo(TransactionAttribute.PROPAGATION_SUPPORTS);
}
@Test
@@ -321,9 +316,9 @@ public class AnnotationTransactionAttributeSourceTests {
AnnotationTransactionAttributeSource atas = new AnnotationTransactionAttributeSource();
TransactionAttribute getAgeAttr = atas.getTransactionAttribute(getAgeMethod, Ejb3AnnotatedBean2.class);
assertEquals(TransactionAttribute.PROPAGATION_REQUIRED, getAgeAttr.getPropagationBehavior());
assertThat(getAgeAttr.getPropagationBehavior()).isEqualTo(TransactionAttribute.PROPAGATION_REQUIRED);
TransactionAttribute getNameAttr = atas.getTransactionAttribute(getNameMethod, Ejb3AnnotatedBean2.class);
assertEquals(TransactionAttribute.PROPAGATION_SUPPORTS, getNameAttr.getPropagationBehavior());
assertThat(getNameAttr.getPropagationBehavior()).isEqualTo(TransactionAttribute.PROPAGATION_SUPPORTS);
}
@Test
@@ -333,9 +328,9 @@ public class AnnotationTransactionAttributeSourceTests {
AnnotationTransactionAttributeSource atas = new AnnotationTransactionAttributeSource();
TransactionAttribute getAgeAttr = atas.getTransactionAttribute(getAgeMethod, Ejb3AnnotatedBean3.class);
assertEquals(TransactionAttribute.PROPAGATION_REQUIRED, getAgeAttr.getPropagationBehavior());
assertThat(getAgeAttr.getPropagationBehavior()).isEqualTo(TransactionAttribute.PROPAGATION_REQUIRED);
TransactionAttribute getNameAttr = atas.getTransactionAttribute(getNameMethod, Ejb3AnnotatedBean3.class);
assertEquals(TransactionAttribute.PROPAGATION_SUPPORTS, getNameAttr.getPropagationBehavior());
assertThat(getNameAttr.getPropagationBehavior()).isEqualTo(TransactionAttribute.PROPAGATION_SUPPORTS);
}
@Test
@@ -345,9 +340,9 @@ public class AnnotationTransactionAttributeSourceTests {
AnnotationTransactionAttributeSource atas = new AnnotationTransactionAttributeSource();
TransactionAttribute getAgeAttr = atas.getTransactionAttribute(getAgeMethod, JtaAnnotatedBean1.class);
assertEquals(TransactionAttribute.PROPAGATION_REQUIRED, getAgeAttr.getPropagationBehavior());
assertThat(getAgeAttr.getPropagationBehavior()).isEqualTo(TransactionAttribute.PROPAGATION_REQUIRED);
TransactionAttribute getNameAttr = atas.getTransactionAttribute(getNameMethod, JtaAnnotatedBean1.class);
assertEquals(TransactionAttribute.PROPAGATION_SUPPORTS, getNameAttr.getPropagationBehavior());
assertThat(getNameAttr.getPropagationBehavior()).isEqualTo(TransactionAttribute.PROPAGATION_SUPPORTS);
}
@Test
@@ -357,9 +352,9 @@ public class AnnotationTransactionAttributeSourceTests {
AnnotationTransactionAttributeSource atas = new AnnotationTransactionAttributeSource();
TransactionAttribute getAgeAttr = atas.getTransactionAttribute(getAgeMethod, JtaAnnotatedBean2.class);
assertEquals(TransactionAttribute.PROPAGATION_REQUIRED, getAgeAttr.getPropagationBehavior());
assertThat(getAgeAttr.getPropagationBehavior()).isEqualTo(TransactionAttribute.PROPAGATION_REQUIRED);
TransactionAttribute getNameAttr = atas.getTransactionAttribute(getNameMethod, JtaAnnotatedBean2.class);
assertEquals(TransactionAttribute.PROPAGATION_SUPPORTS, getNameAttr.getPropagationBehavior());
assertThat(getNameAttr.getPropagationBehavior()).isEqualTo(TransactionAttribute.PROPAGATION_SUPPORTS);
}
@Test
@@ -369,9 +364,9 @@ public class AnnotationTransactionAttributeSourceTests {
AnnotationTransactionAttributeSource atas = new AnnotationTransactionAttributeSource();
TransactionAttribute getAgeAttr = atas.getTransactionAttribute(getAgeMethod, JtaAnnotatedBean3.class);
assertEquals(TransactionAttribute.PROPAGATION_REQUIRED, getAgeAttr.getPropagationBehavior());
assertThat(getAgeAttr.getPropagationBehavior()).isEqualTo(TransactionAttribute.PROPAGATION_REQUIRED);
TransactionAttribute getNameAttr = atas.getTransactionAttribute(getNameMethod, JtaAnnotatedBean3.class);
assertEquals(TransactionAttribute.PROPAGATION_SUPPORTS, getNameAttr.getPropagationBehavior());
assertThat(getNameAttr.getPropagationBehavior()).isEqualTo(TransactionAttribute.PROPAGATION_SUPPORTS);
}
@Test
@@ -382,10 +377,10 @@ public class AnnotationTransactionAttributeSourceTests {
AnnotationTransactionAttributeSource atas = new AnnotationTransactionAttributeSource();
TransactionAttribute getAgeAttr = atas.getTransactionAttribute(getAgeMethod, GroovyTestBean.class);
assertEquals(TransactionAttribute.PROPAGATION_REQUIRED, getAgeAttr.getPropagationBehavior());
assertThat(getAgeAttr.getPropagationBehavior()).isEqualTo(TransactionAttribute.PROPAGATION_REQUIRED);
TransactionAttribute getNameAttr = atas.getTransactionAttribute(getNameMethod, GroovyTestBean.class);
assertEquals(TransactionAttribute.PROPAGATION_REQUIRED, getNameAttr.getPropagationBehavior());
assertNull(atas.getTransactionAttribute(getMetaClassMethod, GroovyTestBean.class));
assertThat(getNameAttr.getPropagationBehavior()).isEqualTo(TransactionAttribute.PROPAGATION_REQUIRED);
assertThat(atas.getTransactionAttribute(getMetaClassMethod, GroovyTestBean.class)).isNull();
}

100
spring-tx/src/test/java/org/springframework/transaction/annotation/AnnotationTransactionInterceptorTests.java
View File

@@ -24,12 +24,10 @@ import org.springframework.tests.transaction.CallCountingTransactionManager;
import org.springframework.transaction.interceptor.TransactionInterceptor;
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.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
/**
* @author Rob Harrop
@@ -335,13 +333,13 @@ public class AnnotationTransactionInterceptorTests {
}
private void assertGetTransactionAndCommitCount(int expectedCount) {
assertEquals(expectedCount, this.ptm.begun);
assertEquals(expectedCount, this.ptm.commits);
assertThat(this.ptm.begun).isEqualTo(expectedCount);
assertThat(this.ptm.commits).isEqualTo(expectedCount);
}
private void assertGetTransactionAndRollbackCount(int expectedCount) {
assertEquals(expectedCount, this.ptm.begun);
assertEquals(expectedCount, this.ptm.rollbacks);
assertThat(this.ptm.begun).isEqualTo(expectedCount);
assertThat(this.ptm.rollbacks).isEqualTo(expectedCount);
}
@@ -349,13 +347,13 @@ public class AnnotationTransactionInterceptorTests {
public static class TestClassLevelOnly {
public void doSomething() {
assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
}
public void doSomethingElse() {
assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
}
}
@@ -364,19 +362,19 @@ public class AnnotationTransactionInterceptorTests {
public static class TestWithSingleMethodOverride {
public void doSomething() {
assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
}
@Transactional(readOnly = true)
public void doSomethingElse() {
assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
assertTrue(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isTrue();
}
public void doSomethingCompletelyElse() {
assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
}
}
@@ -386,18 +384,18 @@ public class AnnotationTransactionInterceptorTests {
@Transactional
public void doSomething() {
assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
}
public void doSomethingElse() {
assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
assertTrue(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isTrue();
}
public void doSomethingCompletelyElse() {
assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
assertTrue(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isTrue();
}
}
@@ -407,19 +405,19 @@ public class AnnotationTransactionInterceptorTests {
@Transactional(readOnly = true)
public void doSomething() {
assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
assertTrue(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isTrue();
}
@Transactional(readOnly = true)
public void doSomethingElse() {
assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
assertTrue(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isTrue();
}
public void doSomethingCompletelyElse() {
assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
}
}
@@ -428,28 +426,28 @@ public class AnnotationTransactionInterceptorTests {
public static class TestWithExceptions {
public void doSomethingErroneous() {
assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
throw new IllegalStateException();
}
public void doSomethingElseErroneous() {
assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
throw new IllegalArgumentException();
}
@Transactional
public void doSomethingElseWithCheckedException() throws Exception {
assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
throw new Exception();
}
@Transactional(rollbackFor = Exception.class)
public void doSomethingElseWithCheckedExceptionAndRollbackRule() throws Exception {
assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
throw new Exception();
}
}
@@ -459,27 +457,27 @@ public class AnnotationTransactionInterceptorTests {
public static class TestWithVavrTry {
public Try<String> doSomething() {
assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
return Try.success("ok");
}
public Try<String> doSomethingErroneous() {
assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
return Try.failure(new IllegalStateException());
}
public Try<String> doSomethingErroneousWithCheckedException() {
assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
return Try.failure(new Exception());
}
@Transactional(rollbackFor = Exception.class)
public Try<String> doSomethingErroneousWithCheckedExceptionAndRollbackRule() {
assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
return Try.failure(new Exception());
}
}
@@ -498,8 +496,8 @@ public class AnnotationTransactionInterceptorTests {
void doSomethingElse();
default void doSomethingDefault() {
assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
}
}
@@ -508,14 +506,14 @@ public class AnnotationTransactionInterceptorTests {
@Override
public void doSomething() {
assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
}
@Override
public void doSomethingElse() {
assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
assertTrue(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isTrue();
}
}

33
spring-tx/src/test/java/org/springframework/transaction/annotation/AnnotationTransactionNamespaceHandlerTests.java
View File

@@ -35,9 +35,8 @@ import org.springframework.tests.transaction.CallCountingTransactionManager;
import org.springframework.transaction.config.TransactionManagementConfigUtils;
import org.springframework.transaction.event.TransactionalEventListenerFactory;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
/**
* @author Rob Harrop
@@ -57,9 +56,9 @@ public class AnnotationTransactionNamespaceHandlerTests {
@Test
public void isProxy() throws Exception {
TransactionalTestBean bean = getTestBean();
assertTrue("testBean is not a proxy", AopUtils.isAopProxy(bean));
assertThat(AopUtils.isAopProxy(bean)).as("testBean is not a proxy").isTrue();
Map<String, Object> services = this.context.getBeansWithAnnotation(Service.class);
assertTrue("Stereotype annotation not visible", services.containsKey("testBean"));
assertThat(services.containsKey("testBean")).as("Stereotype annotation not visible").isTrue();
}
@Test
@@ -68,21 +67,21 @@ public class AnnotationTransactionNamespaceHandlerTests {
CallCountingTransactionManager ptm = (CallCountingTransactionManager) context.getBean("transactionManager");
// try with transactional
assertEquals("Should not have any started transactions", 0, ptm.begun);
assertThat(ptm.begun).as("Should not have any started transactions").isEqualTo(0);
testBean.findAllFoos();
assertEquals("Should have 1 started transaction", 1, ptm.begun);
assertEquals("Should have 1 committed transaction", 1, ptm.commits);
assertThat(ptm.begun).as("Should have 1 started transaction").isEqualTo(1);
assertThat(ptm.commits).as("Should have 1 committed transaction").isEqualTo(1);
// try with non-transaction
testBean.doSomething();
assertEquals("Should not have started another transaction", 1, ptm.begun);
assertThat(ptm.begun).as("Should not have started another transaction").isEqualTo(1);
// try with exceptional
assertThatExceptionOfType(Throwable.class).isThrownBy(() ->
testBean.exceptional(new IllegalArgumentException("foo")))
.satisfies(ex -> {
assertEquals("Should have another started transaction", 2, ptm.begun);
assertEquals("Should have 1 rolled back transaction", 1, ptm.rollbacks);
assertThat(ptm.begun).as("Should have another started transaction").isEqualTo(2);
assertThat(ptm.rollbacks).as("Should have 1 rolled back transaction").isEqualTo(1);
});
}
@@ -91,23 +90,23 @@ public class AnnotationTransactionNamespaceHandlerTests {
TransactionalTestBean testBean = getTestBean();
CallCountingTransactionManager ptm = (CallCountingTransactionManager) context.getBean("transactionManager");
assertEquals("Should not have any started transactions", 0, ptm.begun);
assertThat(ptm.begun).as("Should not have any started transactions").isEqualTo(0);
testBean.annotationsOnProtectedAreIgnored();
assertEquals("Should not have any started transactions", 0, ptm.begun);
assertThat(ptm.begun).as("Should not have any started transactions").isEqualTo(0);
}
@Test
public void mBeanExportAlsoWorks() throws Exception {
MBeanServer server = ManagementFactory.getPlatformMBeanServer();
assertEquals("done",
server.invoke(ObjectName.getInstance("test:type=TestBean"), "doSomething", new Object[0], new String[0]));
Object actual = server.invoke(ObjectName.getInstance("test:type=TestBean"), "doSomething", new Object[0], new String[0]);
assertThat(actual).isEqualTo("done");
}
@Test
public void transactionalEventListenerRegisteredProperly() {
assertTrue(this.context.containsBean(TransactionManagementConfigUtils
.TRANSACTIONAL_EVENT_LISTENER_FACTORY_BEAN_NAME));
assertEquals(1, this.context.getBeansOfType(TransactionalEventListenerFactory.class).size());
assertThat(this.context.containsBean(TransactionManagementConfigUtils
.TRANSACTIONAL_EVENT_LISTENER_FACTORY_BEAN_NAME)).isTrue();
assertThat(this.context.getBeansOfType(TransactionalEventListenerFactory.class).size()).isEqualTo(1);
}
private TransactionalTestBean getTestBean() {

18
spring-tx/src/test/java/org/springframework/transaction/annotation/EnableTransactionManagementTests.java
View File

@@ -40,8 +40,6 @@ import org.springframework.transaction.event.TransactionalEventListenerFactory;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
/**
* Tests demonstrating use of @EnableTransactionManagement @Configuration classes.
@@ -59,9 +57,9 @@ public class EnableTransactionManagementTests {
AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(
EnableTxConfig.class, TxManagerConfig.class);
TransactionalTestBean bean = ctx.getBean(TransactionalTestBean.class);
assertTrue("testBean is not a proxy", AopUtils.isAopProxy(bean));
assertThat(AopUtils.isAopProxy(bean)).as("testBean is not a proxy").isTrue();
Map<?,?> services = ctx.getBeansWithAnnotation(Service.class);
assertTrue("Stereotype annotation not visible", services.containsKey("testBean"));
assertThat(services.containsKey("testBean")).as("Stereotype annotation not visible").isTrue();
ctx.close();
}
@@ -70,9 +68,9 @@ public class EnableTransactionManagementTests {
AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(
InheritedEnableTxConfig.class, TxManagerConfig.class);
TransactionalTestBean bean = ctx.getBean(TransactionalTestBean.class);
assertTrue("testBean is not a proxy", AopUtils.isAopProxy(bean));
assertThat(AopUtils.isAopProxy(bean)).as("testBean is not a proxy").isTrue();
Map<?,?> services = ctx.getBeansWithAnnotation(Service.class);
assertTrue("Stereotype annotation not visible", services.containsKey("testBean"));
assertThat(services.containsKey("testBean")).as("Stereotype annotation not visible").isTrue();
ctx.close();
}
@@ -81,9 +79,9 @@ public class EnableTransactionManagementTests {
AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(
ParentEnableTxConfig.class, ChildEnableTxConfig.class, TxManagerConfig.class);
TransactionalTestBean bean = ctx.getBean(TransactionalTestBean.class);
assertTrue("testBean is not a proxy", AopUtils.isAopProxy(bean));
assertThat(AopUtils.isAopProxy(bean)).as("testBean is not a proxy").isTrue();
Map<?,?> services = ctx.getBeansWithAnnotation(Service.class);
assertTrue("Stereotype annotation not visible", services.containsKey("testBean"));
assertThat(services.containsKey("testBean")).as("Stereotype annotation not visible").isTrue();
ctx.close();
}
@@ -126,8 +124,8 @@ public class EnableTransactionManagementTests {
@Test
public void transactionalEventListenerRegisteredProperly() {
AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(EnableTxConfig.class);
assertTrue(ctx.containsBean(TransactionManagementConfigUtils.TRANSACTIONAL_EVENT_LISTENER_FACTORY_BEAN_NAME));
assertEquals(1, ctx.getBeansOfType(TransactionalEventListenerFactory.class).size());
assertThat(ctx.containsBean(TransactionManagementConfigUtils.TRANSACTIONAL_EVENT_LISTENER_FACTORY_BEAN_NAME)).isTrue();
assertThat(ctx.getBeansOfType(TransactionalEventListenerFactory.class).size()).isEqualTo(1);
ctx.close();
}

30
spring-tx/src/test/java/org/springframework/transaction/config/AnnotationDrivenTests.java
View File

@@ -31,9 +31,7 @@ import org.springframework.tests.transaction.CallCountingTransactionManager;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import org.springframework.util.SerializationTestUtils;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
/**
* @author Rob Harrop
@@ -68,19 +66,19 @@ public class AnnotationDrivenTests {
CallCountingTransactionManager tm1 = context.getBean("transactionManager1", CallCountingTransactionManager.class);
CallCountingTransactionManager tm2 = context.getBean("transactionManager2", CallCountingTransactionManager.class);
TransactionalService service = context.getBean("service", TransactionalService.class);
assertTrue(AopUtils.isCglibProxy(service));
assertThat(AopUtils.isCglibProxy(service)).isTrue();
service.setSomething("someName");
assertEquals(1, tm1.commits);
assertEquals(0, tm2.commits);
assertThat(tm1.commits).isEqualTo(1);
assertThat(tm2.commits).isEqualTo(0);
service.doSomething();
assertEquals(1, tm1.commits);
assertEquals(1, tm2.commits);
assertThat(tm1.commits).isEqualTo(1);
assertThat(tm2.commits).isEqualTo(1);
service.setSomething("someName");
assertEquals(2, tm1.commits);
assertEquals(1, tm2.commits);
assertThat(tm1.commits).isEqualTo(2);
assertThat(tm2.commits).isEqualTo(1);
service.doSomething();
assertEquals(2, tm1.commits);
assertEquals(2, tm2.commits);
assertThat(tm1.commits).isEqualTo(2);
assertThat(tm2.commits).isEqualTo(2);
}
@Test
@@ -109,12 +107,12 @@ public class AnnotationDrivenTests {
@Override
public Object invoke(MethodInvocation methodInvocation) throws Throwable {
if (methodInvocation.getMethod().getName().equals("setSomething")) {
assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
}
else {
assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
}
return methodInvocation.proceed();
}

10
spring-tx/src/test/java/org/springframework/transaction/event/ApplicationListenerMethodTransactionalAdapterTests.java
View File

@@ -26,8 +26,7 @@ import org.springframework.core.ResolvableType;
import org.springframework.core.annotation.AnnotatedElementUtils;
import org.springframework.util.ReflectionUtils;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.assertj.core.api.Assertions.assertThat;
/**
* @author Stephane Nicoll
@@ -64,16 +63,15 @@ public class ApplicationListenerMethodTransactionalAdapterTests {
}
private void assertPhase(Method method, TransactionPhase expected) {
assertNotNull("Method must not be null", method);
assertThat(method).as("Method must not be null").isNotNull();
TransactionalEventListener annotation =
AnnotatedElementUtils.findMergedAnnotation(method, TransactionalEventListener.class);
assertEquals("Wrong phase for '" + method + "'", expected, annotation.phase());
assertThat(annotation.phase()).as("Wrong phase for '" + method + "'").isEqualTo(expected);
}
private void supportsEventType(boolean match, Method method, ResolvableType eventType) {
ApplicationListenerMethodAdapter adapter = createTestInstance(method);
assertEquals("Wrong match for event '" + eventType + "' on " + method,
match, adapter.supportsEventType(eventType));
assertThat(adapter.supportsEventType(eventType)).as("Wrong match for event '" + eventType + "' on " + method).isEqualTo(match);
}
private ApplicationListenerMethodTransactionalAdapter createTestInstance(Method m) {

14
spring-tx/src/test/java/org/springframework/transaction/event/TransactionalEventListenerTests.java
View File

@@ -46,8 +46,8 @@ import org.springframework.transaction.support.TransactionTemplate;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.junit.Assert.assertEquals;
import static org.springframework.transaction.event.TransactionPhase.AFTER_COMMIT;
import static org.springframework.transaction.event.TransactionPhase.AFTER_COMPLETION;
import static org.springframework.transaction.event.TransactionPhase.AFTER_ROLLBACK;
@@ -375,16 +375,16 @@ public class TransactionalEventListenerTests {
}
for (String phase : phases) {
List<Object> eventsForPhase = getEvents(phase);
assertEquals("Expected no events for phase '" + phase + "' " +
"but got " + eventsForPhase + ":", 0, eventsForPhase.size());
assertThat(eventsForPhase.size()).as("Expected no events for phase '" + phase + "' " +
"but got " + eventsForPhase + ":").isEqualTo(0);
}
}
public void assertEvents(String phase, Object... expected) {
List<Object> actual = getEvents(phase);
assertEquals("wrong number of events for phase '" + phase + "'", expected.length, actual.size());
assertThat(actual.size()).as("wrong number of events for phase '" + phase + "'").isEqualTo(expected.length);
for (int i = 0; i < expected.length; i++) {
assertEquals("Wrong event for phase '" + phase + "' at index " + i, expected[i], actual.get(i));
assertThat(actual.get(i)).as("Wrong event for phase '" + phase + "' at index " + i).isEqualTo(expected[i]);
}
}
@@ -393,8 +393,8 @@ public class TransactionalEventListenerTests {
for (Map.Entry<String, List<Object>> entry : this.events.entrySet()) {
size += entry.getValue().size();
}
assertEquals("Wrong number of total events (" + this.events.size() + ") " +
"registered phase(s)", number, size);
assertThat(size).as("Wrong number of total events (" + this.events.size() + ") " +
"registered phase(s)").isEqualTo(number);
}
}

5
spring-tx/src/test/java/org/springframework/transaction/interceptor/AbstractReactiveTransactionAspectTests.java
View File

@@ -33,7 +33,6 @@ import org.springframework.transaction.reactive.TransactionContext;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Fail.fail;
import static org.junit.Assert.assertEquals;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
@@ -337,8 +336,8 @@ public abstract class AbstractReactiveTransactionAspectTests {
Mono.from(itb.setName(name))
.as(StepVerifier::create)
.consumeErrorWith(throwable -> {
assertEquals(RuntimeException.class, throwable.getClass());
assertEquals(ex, throwable.getCause());
assertThat(throwable.getClass()).isEqualTo(RuntimeException.class);
assertThat(throwable.getCause()).isEqualTo(ex);
})
.verify();

45
spring-tx/src/test/java/org/springframework/transaction/interceptor/AbstractTransactionAspectTests.java
View File

@@ -34,12 +34,9 @@ import org.springframework.transaction.TransactionSystemException;
import org.springframework.transaction.UnexpectedRollbackException;
import org.springframework.transaction.interceptor.TransactionAspectSupport.TransactionInfo;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.assertj.core.api.Assertions.fail;
import static org.mockito.BDDMockito.given;
import static org.mockito.BDDMockito.willThrow;
import static org.mockito.Mockito.mock;
@@ -141,8 +138,8 @@ public abstract class AbstractTransactionAspectTests {
itb.getName();
checkTransactionStatus(false);
assertSame(txatt, ptm.getDefinition());
assertFalse(ptm.getStatus().isRollbackOnly());
assertThat(ptm.getDefinition()).isSameAs(txatt);
assertThat(ptm.getStatus().isRollbackOnly()).isFalse();
}
@Test
@@ -162,8 +159,8 @@ public abstract class AbstractTransactionAspectTests {
itb.exceptional(new OptimisticLockingFailureException("")));
checkTransactionStatus(false);
assertSame(txatt, ptm.getDefinition());
assertFalse(ptm.getStatus().isRollbackOnly());
assertThat(ptm.getDefinition()).isSameAs(txatt);
assertThat(ptm.getStatus().isRollbackOnly()).isFalse();
}
/**
@@ -239,8 +236,8 @@ public abstract class AbstractTransactionAspectTests {
@Override
public void exceptional(Throwable t) throws Throwable {
TransactionInfo ti = TransactionAspectSupport.currentTransactionInfo();
assertTrue(ti.hasTransaction());
assertEquals(spouseName, getSpouse().getName());
assertThat(ti.hasTransaction()).isTrue();
assertThat(getSpouse().getName()).isEqualTo(spouseName);
}
};
TestBean inner = new TestBean() {
@@ -248,7 +245,7 @@ public abstract class AbstractTransactionAspectTests {
public String getName() {
// Assert that we're in the inner proxy
TransactionInfo ti = TransactionAspectSupport.currentTransactionInfo();
assertFalse(ti.hasTransaction());
assertThat(ti.hasTransaction()).isFalse();
return spouseName;
}
};
@@ -292,9 +289,9 @@ public abstract class AbstractTransactionAspectTests {
@Override
public void exceptional(Throwable t) throws Throwable {
TransactionInfo ti = TransactionAspectSupport.currentTransactionInfo();
assertTrue(ti.hasTransaction());
assertEquals(outerTxatt, ti.getTransactionAttribute());
assertEquals(spouseName, getSpouse().getName());
assertThat(ti.hasTransaction()).isTrue();
assertThat(ti.getTransactionAttribute()).isEqualTo(outerTxatt);
assertThat(getSpouse().getName()).isEqualTo(spouseName);
}
};
TestBean inner = new TestBean() {
@@ -303,8 +300,8 @@ public abstract class AbstractTransactionAspectTests {
// Assert that we're in the inner proxy
TransactionInfo ti = TransactionAspectSupport.currentTransactionInfo();
// Has nested transaction
assertTrue(ti.hasTransaction());
assertEquals(innerTxatt, ti.getTransactionAttribute());
assertThat(ti.hasTransaction()).isTrue();
assertThat(ti.getTransactionAttribute()).isEqualTo(innerTxatt);
return spouseName;
}
};
@@ -377,7 +374,7 @@ public abstract class AbstractTransactionAspectTests {
TransactionAttribute txatt = new DefaultTransactionAttribute() {
@Override
public boolean rollbackOn(Throwable t) {
assertTrue(t == ex);
assertThat(t == ex).isTrue();
return shouldRollback;
}
};
@@ -411,10 +408,10 @@ public abstract class AbstractTransactionAspectTests {
}
catch (Throwable t) {
if (rollbackException) {
assertEquals("Caught wrong exception", tex, t);
assertThat(t).as("Caught wrong exception").isEqualTo(tex);
}
else {
assertEquals("Caught wrong exception", ex, t);
assertThat(t).as("Caught wrong exception").isEqualTo(ex);
}
}
@@ -457,7 +454,7 @@ public abstract class AbstractTransactionAspectTests {
ITestBean itb = (ITestBean) advised(tb, ptm, tas);
// verification!?
assertTrue(name.equals(itb.getName()));
assertThat(name.equals(itb.getName())).isTrue();
verify(ptm).commit(status);
}
@@ -493,7 +490,7 @@ public abstract class AbstractTransactionAspectTests {
fail("Shouldn't have invoked method");
}
catch (CannotCreateTransactionException thrown) {
assertTrue(thrown == ex);
assertThat(thrown == ex).isTrue();
}
}
@@ -528,11 +525,11 @@ public abstract class AbstractTransactionAspectTests {
fail("Shouldn't have succeeded");
}
catch (UnexpectedRollbackException thrown) {
assertTrue(thrown == ex);
assertThat(thrown == ex).isTrue();
}
// Should have invoked target and changed name
assertTrue(itb.getName() == name);
assertThat(itb.getName() == name).isTrue();
}
protected void checkTransactionStatus(boolean expected) {

69
spring-tx/src/test/java/org/springframework/transaction/interceptor/BeanFactoryTransactionTests.java
View File

@@ -42,11 +42,8 @@ import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionException;
import org.springframework.transaction.TransactionStatus;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verifyZeroInteractions;
@@ -73,8 +70,9 @@ public class BeanFactoryTransactionTests {
@Test
public void testGetsAreNotTransactionalWithProxyFactory1() {
ITestBean testBean = (ITestBean) factory.getBean("proxyFactory1");
assertTrue("testBean is a dynamic proxy", Proxy.isProxyClass(testBean.getClass()));
assertFalse(testBean instanceof TransactionalProxy);
assertThat(Proxy.isProxyClass(testBean.getClass())).as("testBean is a dynamic proxy").isTrue();
boolean condition = testBean instanceof TransactionalProxy;
assertThat(condition).isFalse();
doTestGetsAreNotTransactional(testBean);
}
@@ -82,32 +80,35 @@ public class BeanFactoryTransactionTests {
public void testGetsAreNotTransactionalWithProxyFactory2DynamicProxy() {
this.factory.preInstantiateSingletons();
ITestBean testBean = (ITestBean) factory.getBean("proxyFactory2DynamicProxy");
assertTrue("testBean is a dynamic proxy", Proxy.isProxyClass(testBean.getClass()));
assertTrue(testBean instanceof TransactionalProxy);
assertThat(Proxy.isProxyClass(testBean.getClass())).as("testBean is a dynamic proxy").isTrue();
boolean condition = testBean instanceof TransactionalProxy;
assertThat(condition).isTrue();
doTestGetsAreNotTransactional(testBean);
}
@Test
public void testGetsAreNotTransactionalWithProxyFactory2Cglib() {
ITestBean testBean = (ITestBean) factory.getBean("proxyFactory2Cglib");
assertTrue("testBean is CGLIB advised", AopUtils.isCglibProxy(testBean));
assertTrue(testBean instanceof TransactionalProxy);
assertThat(AopUtils.isCglibProxy(testBean)).as("testBean is CGLIB advised").isTrue();
boolean condition = testBean instanceof TransactionalProxy;
assertThat(condition).isTrue();
doTestGetsAreNotTransactional(testBean);
}
@Test
public void testProxyFactory2Lazy() {
ITestBean testBean = (ITestBean) factory.getBean("proxyFactory2Lazy");
assertFalse(factory.containsSingleton("target"));
assertEquals(666, testBean.getAge());
assertTrue(factory.containsSingleton("target"));
assertThat(factory.containsSingleton("target")).isFalse();
assertThat(testBean.getAge()).isEqualTo(666);
assertThat(factory.containsSingleton("target")).isTrue();
}
@Test
public void testCglibTransactionProxyImplementsNoInterfaces() {
ImplementsNoInterfaces ini = (ImplementsNoInterfaces) factory.getBean("cglibNoInterfaces");
assertTrue("testBean is CGLIB advised", AopUtils.isCglibProxy(ini));
assertTrue(ini instanceof TransactionalProxy);
assertThat(AopUtils.isCglibProxy(ini)).as("testBean is CGLIB advised").isTrue();
boolean condition = ini instanceof TransactionalProxy;
assertThat(condition).isTrue();
String newName = "Gordon";
// Install facade
@@ -115,15 +116,17 @@ public class BeanFactoryTransactionTests {
PlatformTransactionManagerFacade.delegate = ptm;
ini.setName(newName);
assertEquals(newName, ini.getName());
assertEquals(2, ptm.commits);
assertThat(ini.getName()).isEqualTo(newName);
assertThat(ptm.commits).isEqualTo(2);
}
@Test
public void testGetsAreNotTransactionalWithProxyFactory3() {
ITestBean testBean = (ITestBean) factory.getBean("proxyFactory3");
assertTrue("testBean is a full proxy", testBean instanceof DerivedTestBean);
assertTrue(testBean instanceof TransactionalProxy);
boolean condition = testBean instanceof DerivedTestBean;
assertThat(condition).as("testBean is a full proxy").isTrue();
boolean condition1 = testBean instanceof TransactionalProxy;
assertThat(condition1).isTrue();
InvocationCounterPointcut txnCounter = (InvocationCounterPointcut) factory.getBean("txnInvocationCounterPointcut");
InvocationCounterInterceptor preCounter = (InvocationCounterInterceptor) factory.getBean("preInvocationCounterInterceptor");
InvocationCounterInterceptor postCounter = (InvocationCounterInterceptor) factory.getBean("postInvocationCounterInterceptor");
@@ -132,9 +135,9 @@ public class BeanFactoryTransactionTests {
postCounter.counter = 0;
doTestGetsAreNotTransactional(testBean);
// Can't assert it's equal to 4 as the pointcut may be optimized and only invoked once
assertTrue(0 < txnCounter.counter && txnCounter.counter <= 4);
assertEquals(4, preCounter.counter);
assertEquals(4, postCounter.counter);
assertThat(0 < txnCounter.counter && txnCounter.counter <= 4).isTrue();
assertThat(preCounter.counter).isEqualTo(4);
assertThat(postCounter.counter).isEqualTo(4);
}
private void doTestGetsAreNotTransactional(final ITestBean testBean) {
@@ -142,7 +145,7 @@ public class BeanFactoryTransactionTests {
PlatformTransactionManager ptm = mock(PlatformTransactionManager.class);
PlatformTransactionManagerFacade.delegate = ptm;
assertTrue("Age should not be " + testBean.getAge(), testBean.getAge() == 666);
assertThat(testBean.getAge() == 666).as("Age should not be " + testBean.getAge()).isTrue();
// Expect no methods
verifyZeroInteractions(ptm);
@@ -165,7 +168,7 @@ public class BeanFactoryTransactionTests {
}
@Override
public void commit(TransactionStatus status) throws TransactionException {
assertTrue(status == ts);
assertThat(status == ts).isTrue();
}
@Override
public void rollback(TransactionStatus status) throws TransactionException {
@@ -177,13 +180,13 @@ public class BeanFactoryTransactionTests {
// TODO same as old age to avoid ordering effect for now
int age = 666;
testBean.setAge(age);
assertTrue(testBean.getAge() == age);
assertThat(testBean.getAge() == age).isTrue();
}
@Test
public void testGetBeansOfTypeWithAbstract() {
Map<String, ITestBean> beansOfType = factory.getBeansOfType(ITestBean.class, true, true);
assertNotNull(beansOfType);
assertThat(beansOfType).isNotNull();
}
/**
@@ -208,22 +211,22 @@ public class BeanFactoryTransactionTests {
PlatformTransactionManagerFacade.delegate = txMan;
TestBean tb = (TestBean) factory.getBean("hotSwapped");
assertEquals(666, tb.getAge());
assertThat(tb.getAge()).isEqualTo(666);
int newAge = 557;
tb.setAge(newAge);
assertEquals(newAge, tb.getAge());
assertThat(tb.getAge()).isEqualTo(newAge);
TestBean target2 = new TestBean();
target2.setAge(65);
HotSwappableTargetSource ts = (HotSwappableTargetSource) factory.getBean("swapper");
ts.swap(target2);
assertEquals(target2.getAge(), tb.getAge());
assertThat(tb.getAge()).isEqualTo(target2.getAge());
tb.setAge(newAge);
assertEquals(newAge, target2.getAge());
assertThat(target2.getAge()).isEqualTo(newAge);
assertEquals(0, txMan.inflight);
assertEquals(2, txMan.commits);
assertEquals(0, txMan.rollbacks);
assertThat(txMan.inflight).isEqualTo(0);
assertThat(txMan.commits).isEqualTo(2);
assertThat(txMan.rollbacks).isEqualTo(0);
}

16
spring-tx/src/test/java/org/springframework/transaction/interceptor/RollbackRuleTests.java
View File

@@ -24,8 +24,6 @@ import org.springframework.beans.FatalBeanException;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
/**
* Unit tests for the {@link RollbackRuleAttribute} class.
@@ -41,19 +39,19 @@ public class RollbackRuleTests {
@Test
public void foundImmediatelyWithString() {
RollbackRuleAttribute rr = new RollbackRuleAttribute(java.lang.Exception.class.getName());
assertEquals(0, rr.getDepth(new Exception()));
assertThat(rr.getDepth(new Exception())).isEqualTo(0);
}
@Test
public void foundImmediatelyWithClass() {
RollbackRuleAttribute rr = new RollbackRuleAttribute(Exception.class);
assertEquals(0, rr.getDepth(new Exception()));
assertThat(rr.getDepth(new Exception())).isEqualTo(0);
}
@Test
public void notFound() {
RollbackRuleAttribute rr = new RollbackRuleAttribute(java.io.IOException.class.getName());
assertEquals(-1, rr.getDepth(new MyRuntimeException("")));
assertThat(rr.getDepth(new MyRuntimeException(""))).isEqualTo(-1);
}
@Test
@@ -66,10 +64,10 @@ public class RollbackRuleTests {
@Test
public void alwaysTrueForThrowable() {
RollbackRuleAttribute rr = new RollbackRuleAttribute(java.lang.Throwable.class.getName());
assertTrue(rr.getDepth(new MyRuntimeException("")) > 0);
assertTrue(rr.getDepth(new IOException()) > 0);
assertTrue(rr.getDepth(new FatalBeanException(null,null)) > 0);
assertTrue(rr.getDepth(new RuntimeException()) > 0);
assertThat(rr.getDepth(new MyRuntimeException("")) > 0).isTrue();
assertThat(rr.getDepth(new IOException()) > 0).isTrue();
assertThat(rr.getDepth(new FatalBeanException(null,null)) > 0).isTrue();
assertThat(rr.getDepth(new RuntimeException()) > 0).isTrue();
}
@Test

63
spring-tx/src/test/java/org/springframework/transaction/interceptor/RuleBasedTransactionAttributeTests.java
View File

@@ -26,8 +26,7 @@ import org.junit.Test;
import org.springframework.transaction.TransactionDefinition;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
/**
* @author Rod Johnson
@@ -41,10 +40,10 @@ public class RuleBasedTransactionAttributeTests {
@Test
public void testDefaultRule() {
RuleBasedTransactionAttribute rta = new RuleBasedTransactionAttribute();
assertTrue(rta.rollbackOn(new RuntimeException()));
assertTrue(rta.rollbackOn(new MyRuntimeException("")));
assertFalse(rta.rollbackOn(new Exception()));
assertFalse(rta.rollbackOn(new IOException()));
assertThat(rta.rollbackOn(new RuntimeException())).isTrue();
assertThat(rta.rollbackOn(new MyRuntimeException(""))).isTrue();
assertThat(rta.rollbackOn(new Exception())).isFalse();
assertThat(rta.rollbackOn(new IOException())).isFalse();
}
/**
@@ -56,11 +55,11 @@ public class RuleBasedTransactionAttributeTests {
list.add(new RollbackRuleAttribute(IOException.class.getName()));
RuleBasedTransactionAttribute rta = new RuleBasedTransactionAttribute(TransactionDefinition.PROPAGATION_REQUIRED, list);
assertTrue(rta.rollbackOn(new RuntimeException()));
assertTrue(rta.rollbackOn(new MyRuntimeException("")));
assertFalse(rta.rollbackOn(new Exception()));
assertThat(rta.rollbackOn(new RuntimeException())).isTrue();
assertThat(rta.rollbackOn(new MyRuntimeException(""))).isTrue();
assertThat(rta.rollbackOn(new Exception())).isFalse();
// Check that default behaviour is overridden
assertTrue(rta.rollbackOn(new IOException()));
assertThat(rta.rollbackOn(new IOException())).isTrue();
}
@Test
@@ -70,12 +69,12 @@ public class RuleBasedTransactionAttributeTests {
list.add(new RollbackRuleAttribute(IOException.class.getName()));
RuleBasedTransactionAttribute rta = new RuleBasedTransactionAttribute(TransactionDefinition.PROPAGATION_REQUIRED, list);
assertTrue(rta.rollbackOn(new RuntimeException()));
assertThat(rta.rollbackOn(new RuntimeException())).isTrue();
// Check default behaviour is overridden
assertFalse(rta.rollbackOn(new MyRuntimeException("")));
assertFalse(rta.rollbackOn(new Exception()));
assertThat(rta.rollbackOn(new MyRuntimeException(""))).isFalse();
assertThat(rta.rollbackOn(new Exception())).isFalse();
// Check that default behaviour is overridden
assertTrue(rta.rollbackOn(new IOException()));
assertThat(rta.rollbackOn(new IOException())).isTrue();
}
@Test
@@ -94,11 +93,11 @@ public class RuleBasedTransactionAttributeTests {
}
private void doTestRuleForSelectiveRollbackOnChecked(RuleBasedTransactionAttribute rta) {
assertTrue(rta.rollbackOn(new RuntimeException()));
assertThat(rta.rollbackOn(new RuntimeException())).isTrue();
// Check default behaviour is overridden
assertFalse(rta.rollbackOn(new Exception()));
assertThat(rta.rollbackOn(new Exception())).isFalse();
// Check that default behaviour is overridden
assertTrue(rta.rollbackOn(new RemoteException()));
assertThat(rta.rollbackOn(new RemoteException())).isTrue();
}
/**
@@ -114,10 +113,10 @@ public class RuleBasedTransactionAttributeTests {
list.add(new NoRollbackRuleAttribute("IOException"));
RuleBasedTransactionAttribute rta = new RuleBasedTransactionAttribute(TransactionDefinition.PROPAGATION_REQUIRED, list);
assertTrue(rta.rollbackOn(new RuntimeException()));
assertTrue(rta.rollbackOn(new Exception()));
assertThat(rta.rollbackOn(new RuntimeException())).isTrue();
assertThat(rta.rollbackOn(new Exception())).isTrue();
// Check that default behaviour is overridden
assertFalse(rta.rollbackOn(new IOException()));
assertThat(rta.rollbackOn(new IOException())).isFalse();
}
@Test
@@ -126,11 +125,11 @@ public class RuleBasedTransactionAttributeTests {
list.add(new NoRollbackRuleAttribute("Throwable"));
RuleBasedTransactionAttribute rta = new RuleBasedTransactionAttribute(TransactionDefinition.PROPAGATION_REQUIRED, list);
assertFalse(rta.rollbackOn(new Throwable()));
assertFalse(rta.rollbackOn(new RuntimeException()));
assertFalse(rta.rollbackOn(new MyRuntimeException("")));
assertFalse(rta.rollbackOn(new Exception()));
assertFalse(rta.rollbackOn(new IOException()));
assertThat(rta.rollbackOn(new Throwable())).isFalse();
assertThat(rta.rollbackOn(new RuntimeException())).isFalse();
assertThat(rta.rollbackOn(new MyRuntimeException(""))).isFalse();
assertThat(rta.rollbackOn(new Exception())).isFalse();
assertThat(rta.rollbackOn(new IOException())).isFalse();
}
@Test
@@ -143,11 +142,11 @@ public class RuleBasedTransactionAttributeTests {
tae.setAsText(rta.toString());
rta = (RuleBasedTransactionAttribute) tae.getValue();
assertFalse(rta.rollbackOn(new Throwable()));
assertFalse(rta.rollbackOn(new RuntimeException()));
assertFalse(rta.rollbackOn(new MyRuntimeException("")));
assertFalse(rta.rollbackOn(new Exception()));
assertFalse(rta.rollbackOn(new IOException()));
assertThat(rta.rollbackOn(new Throwable())).isFalse();
assertThat(rta.rollbackOn(new RuntimeException())).isFalse();
assertThat(rta.rollbackOn(new MyRuntimeException(""))).isFalse();
assertThat(rta.rollbackOn(new Exception())).isFalse();
assertThat(rta.rollbackOn(new IOException())).isFalse();
}
/**
@@ -160,8 +159,8 @@ public class RuleBasedTransactionAttributeTests {
list.add(new RollbackRuleAttribute(MyBusinessException.class));
RuleBasedTransactionAttribute rta = new RuleBasedTransactionAttribute(TransactionDefinition.PROPAGATION_REQUIRED, list);
assertTrue(rta.rollbackOn(new MyBusinessException()));
assertFalse(rta.rollbackOn(new MyBusinessWarningException()));
assertThat(rta.rollbackOn(new MyBusinessException())).isTrue();
assertThat(rta.rollbackOn(new MyBusinessWarningException())).isFalse();
}

98
spring-tx/src/test/java/org/springframework/transaction/interceptor/TransactionAttributeEditorTests.java
View File

@@ -23,12 +23,8 @@ import org.junit.Test;
import org.springframework.transaction.TransactionDefinition;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertTrue;
/**
* Tests to check conversion from String to TransactionAttribute.
@@ -45,7 +41,7 @@ public class TransactionAttributeEditorTests {
TransactionAttributeEditor pe = new TransactionAttributeEditor();
pe.setAsText(null);
TransactionAttribute ta = (TransactionAttribute) pe.getValue();
assertTrue(ta == null);
assertThat(ta == null).isTrue();
}
@Test
@@ -53,7 +49,7 @@ public class TransactionAttributeEditorTests {
TransactionAttributeEditor pe = new TransactionAttributeEditor();
pe.setAsText("");
TransactionAttribute ta = (TransactionAttribute) pe.getValue();
assertTrue(ta == null);
assertThat(ta == null).isTrue();
}
@Test
@@ -61,10 +57,11 @@ public class TransactionAttributeEditorTests {
TransactionAttributeEditor pe = new TransactionAttributeEditor();
pe.setAsText("PROPAGATION_REQUIRED");
TransactionAttribute ta = (TransactionAttribute) pe.getValue();
assertTrue(ta != null);
assertTrue(ta.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED);
assertTrue(ta.getIsolationLevel() == TransactionDefinition.ISOLATION_DEFAULT);
assertTrue(!ta.isReadOnly());
assertThat(ta != null).isTrue();
assertThat(ta.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED).isTrue();
assertThat(ta.getIsolationLevel() == TransactionDefinition.ISOLATION_DEFAULT).isTrue();
boolean condition = !ta.isReadOnly();
assertThat(condition).isTrue();
}
@Test
@@ -80,9 +77,9 @@ public class TransactionAttributeEditorTests {
TransactionAttributeEditor pe = new TransactionAttributeEditor();
pe.setAsText("PROPAGATION_REQUIRED, ISOLATION_READ_UNCOMMITTED");
TransactionAttribute ta = (TransactionAttribute) pe.getValue();
assertTrue(ta != null);
assertTrue(ta.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED);
assertTrue(ta.getIsolationLevel() == TransactionDefinition.ISOLATION_READ_UNCOMMITTED);
assertThat(ta != null).isTrue();
assertThat(ta.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED).isTrue();
assertThat(ta.getIsolationLevel() == TransactionDefinition.ISOLATION_READ_UNCOMMITTED).isTrue();
}
@Test
@@ -98,16 +95,17 @@ public class TransactionAttributeEditorTests {
TransactionAttributeEditor pe = new TransactionAttributeEditor();
pe.setAsText("PROPAGATION_MANDATORY,ISOLATION_REPEATABLE_READ,timeout_10,-IOException,+MyRuntimeException");
TransactionAttribute ta = (TransactionAttribute) pe.getValue();
assertNotNull(ta);
assertEquals(TransactionDefinition.PROPAGATION_MANDATORY, ta.getPropagationBehavior());
assertEquals(TransactionDefinition.ISOLATION_REPEATABLE_READ, ta.getIsolationLevel());
assertEquals(10, ta.getTimeout());
assertFalse(ta.isReadOnly());
assertTrue(ta.rollbackOn(new RuntimeException()));
assertFalse(ta.rollbackOn(new Exception()));
assertThat(ta).isNotNull();
assertThat(ta.getPropagationBehavior()).isEqualTo(TransactionDefinition.PROPAGATION_MANDATORY);
assertThat(ta.getIsolationLevel()).isEqualTo(TransactionDefinition.ISOLATION_REPEATABLE_READ);
assertThat(ta.getTimeout()).isEqualTo(10);
assertThat(ta.isReadOnly()).isFalse();
assertThat(ta.rollbackOn(new RuntimeException())).isTrue();
assertThat(ta.rollbackOn(new Exception())).isFalse();
// Check for our bizarre customized rollback rules
assertTrue(ta.rollbackOn(new IOException()));
assertTrue(!ta.rollbackOn(new MyRuntimeException("")));
assertThat(ta.rollbackOn(new IOException())).isTrue();
boolean condition = !ta.rollbackOn(new MyRuntimeException(""));
assertThat(condition).isTrue();
}
@Test
@@ -115,16 +113,16 @@ public class TransactionAttributeEditorTests {
TransactionAttributeEditor pe = new TransactionAttributeEditor();
pe.setAsText("+IOException,readOnly,ISOLATION_READ_COMMITTED,-MyRuntimeException,PROPAGATION_SUPPORTS");
TransactionAttribute ta = (TransactionAttribute) pe.getValue();
assertNotNull(ta);
assertEquals(TransactionDefinition.PROPAGATION_SUPPORTS, ta.getPropagationBehavior());
assertEquals(TransactionDefinition.ISOLATION_READ_COMMITTED, ta.getIsolationLevel());
assertEquals(TransactionDefinition.TIMEOUT_DEFAULT, ta.getTimeout());
assertTrue(ta.isReadOnly());
assertTrue(ta.rollbackOn(new RuntimeException()));
assertFalse(ta.rollbackOn(new Exception()));
assertThat(ta).isNotNull();
assertThat(ta.getPropagationBehavior()).isEqualTo(TransactionDefinition.PROPAGATION_SUPPORTS);
assertThat(ta.getIsolationLevel()).isEqualTo(TransactionDefinition.ISOLATION_READ_COMMITTED);
assertThat(ta.getTimeout()).isEqualTo(TransactionDefinition.TIMEOUT_DEFAULT);
assertThat(ta.isReadOnly()).isTrue();
assertThat(ta.rollbackOn(new RuntimeException())).isTrue();
assertThat(ta.rollbackOn(new Exception())).isFalse();
// Check for our bizarre customized rollback rules
assertFalse(ta.rollbackOn(new IOException()));
assertTrue(ta.rollbackOn(new MyRuntimeException("")));
assertThat(ta.rollbackOn(new IOException())).isFalse();
assertThat(ta.rollbackOn(new MyRuntimeException(""))).isTrue();
}
@Test
@@ -138,18 +136,18 @@ public class TransactionAttributeEditorTests {
TransactionAttributeEditor pe = new TransactionAttributeEditor();
pe.setAsText(source.toString());
TransactionAttribute ta = (TransactionAttribute) pe.getValue();
assertEquals(ta, source);
assertEquals(TransactionDefinition.PROPAGATION_SUPPORTS, ta.getPropagationBehavior());
assertEquals(TransactionDefinition.ISOLATION_REPEATABLE_READ, ta.getIsolationLevel());
assertEquals(10, ta.getTimeout());
assertTrue(ta.isReadOnly());
assertTrue(ta.rollbackOn(new RuntimeException()));
assertFalse(ta.rollbackOn(new Exception()));
assertThat(source).isEqualTo(ta);
assertThat(ta.getPropagationBehavior()).isEqualTo(TransactionDefinition.PROPAGATION_SUPPORTS);
assertThat(ta.getIsolationLevel()).isEqualTo(TransactionDefinition.ISOLATION_REPEATABLE_READ);
assertThat(ta.getTimeout()).isEqualTo(10);
assertThat(ta.isReadOnly()).isTrue();
assertThat(ta.rollbackOn(new RuntimeException())).isTrue();
assertThat(ta.rollbackOn(new Exception())).isFalse();
source.setTimeout(9);
assertNotSame(ta, source);
assertThat(source).isNotSameAs(ta);
source.setTimeout(10);
assertEquals(ta, source);
assertThat(source).isEqualTo(ta);
}
@Test
@@ -165,19 +163,19 @@ public class TransactionAttributeEditorTests {
TransactionAttributeEditor pe = new TransactionAttributeEditor();
pe.setAsText(source.toString());
TransactionAttribute ta = (TransactionAttribute) pe.getValue();
assertEquals(ta, source);
assertEquals(TransactionDefinition.PROPAGATION_SUPPORTS, ta.getPropagationBehavior());
assertEquals(TransactionDefinition.ISOLATION_REPEATABLE_READ, ta.getIsolationLevel());
assertEquals(10, ta.getTimeout());
assertTrue(ta.isReadOnly());
assertTrue(ta.rollbackOn(new IllegalArgumentException()));
assertFalse(ta.rollbackOn(new IllegalStateException()));
assertThat(source).isEqualTo(ta);
assertThat(ta.getPropagationBehavior()).isEqualTo(TransactionDefinition.PROPAGATION_SUPPORTS);
assertThat(ta.getIsolationLevel()).isEqualTo(TransactionDefinition.ISOLATION_REPEATABLE_READ);
assertThat(ta.getTimeout()).isEqualTo(10);
assertThat(ta.isReadOnly()).isTrue();
assertThat(ta.rollbackOn(new IllegalArgumentException())).isTrue();
assertThat(ta.rollbackOn(new IllegalStateException())).isFalse();
source.getRollbackRules().clear();
assertNotSame(ta, source);
assertThat(source).isNotSameAs(ta);
source.getRollbackRules().add(new RollbackRuleAttribute("IllegalArgumentException"));
source.getRollbackRules().add(new NoRollbackRuleAttribute("IllegalStateException"));
assertEquals(ta, source);
assertThat(source).isEqualTo(ta);
}
}

14
spring-tx/src/test/java/org/springframework/transaction/interceptor/TransactionAttributeSourceEditorTests.java
View File

@@ -22,10 +22,8 @@ import org.junit.Test;
import org.springframework.transaction.TransactionDefinition;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
/**
* Unit tests for {@link TransactionAttributeSourceEditor}.
@@ -47,7 +45,7 @@ public class TransactionAttributeSourceEditorTests {
TransactionAttributeSource tas = (TransactionAttributeSource) editor.getValue();
Method m = Object.class.getMethod("hashCode");
assertNull(tas.getTransactionAttribute(m, null));
assertThat(tas.getTransactionAttribute(m, null)).isNull();
}
@Test
@@ -109,12 +107,12 @@ public class TransactionAttributeSourceEditorTests {
private void checkTransactionProperties(TransactionAttributeSource tas, Method method, int propagationBehavior) {
TransactionAttribute ta = tas.getTransactionAttribute(method, null);
if (propagationBehavior >= 0) {
assertNotNull(ta);
assertEquals(TransactionDefinition.ISOLATION_DEFAULT, ta.getIsolationLevel());
assertEquals(propagationBehavior, ta.getPropagationBehavior());
assertThat(ta).isNotNull();
assertThat(ta.getIsolationLevel()).isEqualTo(TransactionDefinition.ISOLATION_DEFAULT);
assertThat(ta.getPropagationBehavior()).isEqualTo(propagationBehavior);
}
else {
assertNull(ta);
assertThat(ta).isNull();
}
}

27
spring-tx/src/test/java/org/springframework/transaction/interceptor/TransactionAttributeSourceTests.java
View File

@@ -23,10 +23,7 @@ import org.junit.Test;
import org.springframework.transaction.TransactionDefinition;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Unit tests for the various {@link TransactionAttributeSource} implementations.
@@ -44,13 +41,13 @@ public class TransactionAttributeSourceTests {
public void matchAlwaysTransactionAttributeSource() throws Exception {
MatchAlwaysTransactionAttributeSource tas = new MatchAlwaysTransactionAttributeSource();
TransactionAttribute ta = tas.getTransactionAttribute(Object.class.getMethod("hashCode"), null);
assertNotNull(ta);
assertTrue(TransactionDefinition.PROPAGATION_REQUIRED == ta.getPropagationBehavior());
assertThat(ta).isNotNull();
assertThat(TransactionDefinition.PROPAGATION_REQUIRED == ta.getPropagationBehavior()).isTrue();
tas.setTransactionAttribute(new DefaultTransactionAttribute(TransactionDefinition.PROPAGATION_SUPPORTS));
ta = tas.getTransactionAttribute(IOException.class.getMethod("getMessage"), IOException.class);
assertNotNull(ta);
assertTrue(TransactionDefinition.PROPAGATION_SUPPORTS == ta.getPropagationBehavior());
assertThat(ta).isNotNull();
assertThat(TransactionDefinition.PROPAGATION_SUPPORTS == ta.getPropagationBehavior()).isTrue();
}
@Test
@@ -60,8 +57,8 @@ public class TransactionAttributeSourceTests {
attributes.put("*ashCode", "PROPAGATION_REQUIRED");
tas.setProperties(attributes);
TransactionAttribute ta = tas.getTransactionAttribute(Object.class.getMethod("hashCode"), null);
assertNotNull(ta);
assertEquals(TransactionDefinition.PROPAGATION_REQUIRED, ta.getPropagationBehavior());
assertThat(ta).isNotNull();
assertThat(ta.getPropagationBehavior()).isEqualTo(TransactionDefinition.PROPAGATION_REQUIRED);
}
@Test
@@ -71,8 +68,8 @@ public class TransactionAttributeSourceTests {
attributes.put("hashCod*", "PROPAGATION_REQUIRED");
tas.setProperties(attributes);
TransactionAttribute ta = tas.getTransactionAttribute(Object.class.getMethod("hashCode"), null);
assertNotNull(ta);
assertEquals(TransactionDefinition.PROPAGATION_REQUIRED, ta.getPropagationBehavior());
assertThat(ta).isNotNull();
assertThat(ta.getPropagationBehavior()).isEqualTo(TransactionDefinition.PROPAGATION_REQUIRED);
}
@Test
@@ -83,8 +80,8 @@ public class TransactionAttributeSourceTests {
attributes.put("hashCode", "PROPAGATION_MANDATORY");
tas.setProperties(attributes);
TransactionAttribute ta = tas.getTransactionAttribute(Object.class.getMethod("hashCode"), null);
assertNotNull(ta);
assertEquals(TransactionDefinition.PROPAGATION_MANDATORY, ta.getPropagationBehavior());
assertThat(ta).isNotNull();
assertThat(ta.getPropagationBehavior()).isEqualTo(TransactionDefinition.PROPAGATION_MANDATORY);
}
@Test
@@ -94,7 +91,7 @@ public class TransactionAttributeSourceTests {
attributes.put("", "PROPAGATION_MANDATORY");
tas.setProperties(attributes);
TransactionAttribute ta = tas.getTransactionAttribute(Object.class.getMethod("hashCode"), null);
assertNull(ta);
assertThat(ta).isNull();
}
}

53
spring-tx/src/test/java/org/springframework/transaction/interceptor/TransactionInterceptorTests.java
View File

@@ -31,12 +31,8 @@ import org.springframework.transaction.TransactionException;
import org.springframework.transaction.TransactionStatus;
import org.springframework.util.SerializationTestUtils;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
@@ -70,9 +66,9 @@ public class TransactionInterceptorTests extends AbstractTransactionAspectTests
protected Object advised(Object target, PlatformTransactionManager ptm, TransactionAttributeSource tas) {
TransactionInterceptor ti = new TransactionInterceptor();
ti.setTransactionManager(ptm);
assertEquals(ptm, ti.getTransactionManager());
assertThat(ti.getTransactionManager()).isEqualTo(ptm);
ti.setTransactionAttributeSource(tas);
assertEquals(tas, ti.getTransactionAttributeSource());
assertThat(ti.getTransactionAttributeSource()).isEqualTo(tas);
ProxyFactory pf = new ProxyFactory(target);
pf.addAdvice(0, ti);
@@ -95,9 +91,10 @@ public class TransactionInterceptorTests extends AbstractTransactionAspectTests
ti = (TransactionInterceptor) SerializationTestUtils.serializeAndDeserialize(ti);
// Check that logger survived deserialization
assertNotNull(ti.logger);
assertTrue(ti.getTransactionManager() instanceof SerializableTransactionManager);
assertNotNull(ti.getTransactionAttributeSource());
assertThat(ti.logger).isNotNull();
boolean condition = ti.getTransactionManager() instanceof SerializableTransactionManager;
assertThat(condition).isTrue();
assertThat(ti.getTransactionAttributeSource()).isNotNull();
}
@Test
@@ -118,11 +115,15 @@ public class TransactionInterceptorTests extends AbstractTransactionAspectTests
ti.setTransactionManager(ptm);
ti = (TransactionInterceptor) SerializationTestUtils.serializeAndDeserialize(ti);
assertTrue(ti.getTransactionManager() instanceof SerializableTransactionManager);
assertTrue(ti.getTransactionAttributeSource() instanceof CompositeTransactionAttributeSource);
boolean condition3 = ti.getTransactionManager() instanceof SerializableTransactionManager;
assertThat(condition3).isTrue();
boolean condition2 = ti.getTransactionAttributeSource() instanceof CompositeTransactionAttributeSource;
assertThat(condition2).isTrue();
CompositeTransactionAttributeSource ctas = (CompositeTransactionAttributeSource) ti.getTransactionAttributeSource();
assertTrue(ctas.getTransactionAttributeSources()[0] instanceof NameMatchTransactionAttributeSource);
assertTrue(ctas.getTransactionAttributeSources()[1] instanceof NameMatchTransactionAttributeSource);
boolean condition1 = ctas.getTransactionAttributeSources()[0] instanceof NameMatchTransactionAttributeSource;
assertThat(condition1).isTrue();
boolean condition = ctas.getTransactionAttributeSources()[1] instanceof NameMatchTransactionAttributeSource;
assertThat(condition).isTrue();
}
@Test
@@ -130,7 +131,7 @@ public class TransactionInterceptorTests extends AbstractTransactionAspectTests
PlatformTransactionManager transactionManager = mock(PlatformTransactionManager.class);
TransactionInterceptor ti = transactionInterceptorWithTransactionManager(transactionManager, null);
assertSame(transactionManager, ti.determineTransactionManager(new DefaultTransactionAttribute()));
assertThat(ti.determineTransactionManager(new DefaultTransactionAttribute())).isSameAs(transactionManager);
}
@Test
@@ -138,7 +139,7 @@ public class TransactionInterceptorTests extends AbstractTransactionAspectTests
PlatformTransactionManager transactionManager = mock(PlatformTransactionManager.class);
TransactionInterceptor ti = transactionInterceptorWithTransactionManager(transactionManager, null);
assertSame(transactionManager, ti.determineTransactionManager(null));
assertThat(ti.determineTransactionManager(null)).isSameAs(transactionManager);
}
@Test
@@ -146,7 +147,7 @@ public class TransactionInterceptorTests extends AbstractTransactionAspectTests
BeanFactory beanFactory = mock(BeanFactory.class);
TransactionInterceptor ti = simpleTransactionInterceptor(beanFactory);
assertNull(ti.determineTransactionManager(null));
assertThat(ti.determineTransactionManager(null)).isNull();
}
@Test
@@ -172,7 +173,7 @@ public class TransactionInterceptorTests extends AbstractTransactionAspectTests
DefaultTransactionAttribute attribute = new DefaultTransactionAttribute();
attribute.setQualifier("fooTransactionManager");
assertSame(fooTransactionManager, ti.determineTransactionManager(attribute));
assertThat(ti.determineTransactionManager(attribute)).isSameAs(fooTransactionManager);
}
@Test
@@ -187,7 +188,7 @@ public class TransactionInterceptorTests extends AbstractTransactionAspectTests
DefaultTransactionAttribute attribute = new DefaultTransactionAttribute();
attribute.setQualifier("fooTransactionManager");
assertSame(fooTransactionManager, ti.determineTransactionManager(attribute));
assertThat(ti.determineTransactionManager(attribute)).isSameAs(fooTransactionManager);
}
@Test
@@ -201,7 +202,7 @@ public class TransactionInterceptorTests extends AbstractTransactionAspectTests
DefaultTransactionAttribute attribute = new DefaultTransactionAttribute();
attribute.setQualifier("");
assertSame(defaultTransactionManager, ti.determineTransactionManager(attribute));
assertThat(ti.determineTransactionManager(attribute)).isSameAs(defaultTransactionManager);
}
@Test
@@ -214,11 +215,11 @@ public class TransactionInterceptorTests extends AbstractTransactionAspectTests
DefaultTransactionAttribute attribute = new DefaultTransactionAttribute();
attribute.setQualifier("fooTransactionManager");
PlatformTransactionManager actual = ti.determineTransactionManager(attribute);
assertSame(txManager, actual);
assertThat(actual).isSameAs(txManager);
// Call again, should be cached
PlatformTransactionManager actual2 = ti.determineTransactionManager(attribute);
assertSame(txManager, actual2);
assertThat(actual2).isSameAs(txManager);
verify(beanFactory, times(1)).containsBean("fooTransactionManager");
verify(beanFactory, times(1)).getBean("fooTransactionManager", PlatformTransactionManager.class);
}
@@ -233,11 +234,11 @@ public class TransactionInterceptorTests extends AbstractTransactionAspectTests
DefaultTransactionAttribute attribute = new DefaultTransactionAttribute();
PlatformTransactionManager actual = ti.determineTransactionManager(attribute);
assertSame(txManager, actual);
assertThat(actual).isSameAs(txManager);
// Call again, should be cached
PlatformTransactionManager actual2 = ti.determineTransactionManager(attribute);
assertSame(txManager, actual2);
assertThat(actual2).isSameAs(txManager);
verify(beanFactory, times(1)).getBean("fooTransactionManager", PlatformTransactionManager.class);
}
@@ -251,11 +252,11 @@ public class TransactionInterceptorTests extends AbstractTransactionAspectTests
DefaultTransactionAttribute attribute = new DefaultTransactionAttribute();
PlatformTransactionManager actual = ti.determineTransactionManager(attribute);
assertSame(txManager, actual);
assertThat(actual).isSameAs(txManager);
// Call again, should be cached
PlatformTransactionManager actual2 = ti.determineTransactionManager(attribute);
assertSame(txManager, actual2);
assertThat(actual2).isSameAs(txManager);
verify(beanFactory, times(1)).getBean(PlatformTransactionManager.class);
}

360
spring-tx/src/test/java/org/springframework/transaction/jta/WebSphereUowTransactionManagerTests.java
View File

@@ -38,9 +38,6 @@ 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.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
@@ -60,16 +57,16 @@ public class WebSphereUowTransactionManagerTests {
ptm.afterPropertiesSet();
DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
assertEquals("result", ptm.execute(definition, new TransactionCallback<String>() {
assertThat(ptm.execute(definition, new TransactionCallback<String>() {
@Override
public String doInTransaction(TransactionStatus status) {
return "result";
}
}));
})).isEqualTo("result");
assertEquals(UOWManager.UOW_TYPE_GLOBAL_TRANSACTION, manager.getUOWType());
assertFalse(manager.getJoined());
assertFalse(manager.getRollbackOnly());
assertThat(manager.getUOWType()).isEqualTo(UOWManager.UOW_TYPE_GLOBAL_TRANSACTION);
assertThat(manager.getJoined()).isFalse();
assertThat(manager.getRollbackOnly()).isFalse();
}
@Test
@@ -88,16 +85,16 @@ public class WebSphereUowTransactionManagerTests {
DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
TransactionStatus ts = ptm.getTransaction(definition);
ptm.commit(ts);
assertEquals("result", ptm.execute(definition, new TransactionCallback<String>() {
assertThat(ptm.execute(definition, new TransactionCallback<String>() {
@Override
public String doInTransaction(TransactionStatus status) {
return "result";
}
}));
})).isEqualTo("result");
assertEquals(UOWManager.UOW_TYPE_GLOBAL_TRANSACTION, manager.getUOWType());
assertFalse(manager.getJoined());
assertFalse(manager.getRollbackOnly());
assertThat(manager.getUOWType()).isEqualTo(UOWManager.UOW_TYPE_GLOBAL_TRANSACTION);
assertThat(manager.getJoined()).isFalse();
assertThat(manager.getRollbackOnly()).isFalse();
verify(ut).begin();
verify(ut).commit();
}
@@ -180,35 +177,35 @@ public class WebSphereUowTransactionManagerTests {
definition.setPropagationBehavior(propagationBehavior);
definition.setReadOnly(true);
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertEquals("result", ptm.execute(definition, new TransactionCallback<String>() {
assertThat(ptm.execute(definition, new TransactionCallback<String>() {
@Override
public String doInTransaction(TransactionStatus status) {
if (synchMode == WebSphereUowTransactionManager.SYNCHRONIZATION_ALWAYS) {
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
assertTrue(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isTrue();
}
else {
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
}
return "result";
}
}));
})).isEqualTo("result");
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertEquals(0, manager.getUOWTimeout());
assertEquals(UOWManager.UOW_TYPE_LOCAL_TRANSACTION, manager.getUOWType());
assertFalse(manager.getJoined());
assertFalse(manager.getRollbackOnly());
assertThat(manager.getUOWTimeout()).isEqualTo(0);
assertThat(manager.getUOWType()).isEqualTo(UOWManager.UOW_TYPE_LOCAL_TRANSACTION);
assertThat(manager.getJoined()).isFalse();
assertThat(manager.getRollbackOnly()).isFalse();
}
@Test
@@ -273,35 +270,35 @@ public class WebSphereUowTransactionManagerTests {
definition.setPropagationBehavior(propagationBehavior);
definition.setReadOnly(true);
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertEquals("result", ptm.execute(definition, new TransactionCallback<String>() {
assertThat(ptm.execute(definition, new TransactionCallback<String>() {
@Override
public String doInTransaction(TransactionStatus status) {
if (synchMode != WebSphereUowTransactionManager.SYNCHRONIZATION_NEVER) {
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
assertTrue(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isTrue();
}
else {
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
}
return "result";
}
}));
})).isEqualTo("result");
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertEquals(0, manager.getUOWTimeout());
assertEquals(UOWManager.UOW_TYPE_GLOBAL_TRANSACTION, manager.getUOWType());
assertFalse(manager.getJoined());
assertFalse(manager.getRollbackOnly());
assertThat(manager.getUOWTimeout()).isEqualTo(0);
assertThat(manager.getUOWType()).isEqualTo(UOWManager.UOW_TYPE_GLOBAL_TRANSACTION);
assertThat(manager.getJoined()).isFalse();
assertThat(manager.getRollbackOnly()).isFalse();
}
@Test
@@ -312,28 +309,28 @@ public class WebSphereUowTransactionManagerTests {
definition.setTimeout(10);
definition.setReadOnly(true);
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertEquals("result", ptm.execute(definition, new TransactionCallback<String>() {
assertThat(ptm.execute(definition, new TransactionCallback<String>() {
@Override
public String doInTransaction(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
assertTrue(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isTrue();
return "result";
}
}));
})).isEqualTo("result");
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertEquals(10, manager.getUOWTimeout());
assertEquals(UOWManager.UOW_TYPE_GLOBAL_TRANSACTION, manager.getUOWType());
assertFalse(manager.getJoined());
assertFalse(manager.getRollbackOnly());
assertThat(manager.getUOWTimeout()).isEqualTo(10);
assertThat(manager.getUOWType()).isEqualTo(UOWManager.UOW_TYPE_GLOBAL_TRANSACTION);
assertThat(manager.getJoined()).isFalse();
assertThat(manager.getRollbackOnly()).isFalse();
}
@Test
@@ -348,17 +345,17 @@ public class WebSphereUowTransactionManagerTests {
WebSphereUowTransactionManager ptm = new WebSphereUowTransactionManager(manager);
DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertThatExceptionOfType(TransactionSystemException.class).isThrownBy(() ->
ptm.execute(definition, new TransactionCallback<String>() {
@Override
public String doInTransaction(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
return "result";
}
}))
@@ -368,11 +365,11 @@ public class WebSphereUowTransactionManagerTests {
assertThat(ex.getMostSpecificCause()).isSameAs(rex);
});
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertEquals(0, manager.getUOWTimeout());
assertThat(manager.getUOWTimeout()).isEqualTo(0);
}
@Test
@@ -381,29 +378,29 @@ public class WebSphereUowTransactionManagerTests {
WebSphereUowTransactionManager ptm = new WebSphereUowTransactionManager(manager);
DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertThatExceptionOfType(OptimisticLockingFailureException.class).isThrownBy(() ->
ptm.execute(definition, new TransactionCallback<String>() {
@Override
public String doInTransaction(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
throw new OptimisticLockingFailureException("");
}
}));
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertEquals(0, manager.getUOWTimeout());
assertEquals(UOWManager.UOW_TYPE_GLOBAL_TRANSACTION, manager.getUOWType());
assertFalse(manager.getJoined());
assertTrue(manager.getRollbackOnly());
assertThat(manager.getUOWTimeout()).isEqualTo(0);
assertThat(manager.getUOWType()).isEqualTo(UOWManager.UOW_TYPE_GLOBAL_TRANSACTION);
assertThat(manager.getJoined()).isFalse();
assertThat(manager.getRollbackOnly()).isTrue();
}
@Test
@@ -412,29 +409,29 @@ public class WebSphereUowTransactionManagerTests {
WebSphereUowTransactionManager ptm = new WebSphereUowTransactionManager(manager);
DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertEquals("result", ptm.execute(definition, new TransactionCallback<String>() {
assertThat(ptm.execute(definition, new TransactionCallback<String>() {
@Override
public String doInTransaction(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
status.setRollbackOnly();
return "result";
}
}));
})).isEqualTo("result");
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertEquals(0, manager.getUOWTimeout());
assertEquals(UOWManager.UOW_TYPE_GLOBAL_TRANSACTION, manager.getUOWType());
assertFalse(manager.getJoined());
assertTrue(manager.getRollbackOnly());
assertThat(manager.getUOWTimeout()).isEqualTo(0);
assertThat(manager.getUOWType()).isEqualTo(UOWManager.UOW_TYPE_GLOBAL_TRANSACTION);
assertThat(manager.getJoined()).isFalse();
assertThat(manager.getRollbackOnly()).isTrue();
}
@Test
@@ -444,28 +441,28 @@ public class WebSphereUowTransactionManagerTests {
WebSphereUowTransactionManager ptm = new WebSphereUowTransactionManager(manager);
DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertEquals("result", ptm.execute(definition, new TransactionCallback<String>() {
assertThat(ptm.execute(definition, new TransactionCallback<String>() {
@Override
public String doInTransaction(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
return "result";
}
}));
})).isEqualTo("result");
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertEquals(0, manager.getUOWTimeout());
assertEquals(UOWManager.UOW_TYPE_GLOBAL_TRANSACTION, manager.getUOWType());
assertTrue(manager.getJoined());
assertFalse(manager.getRollbackOnly());
assertThat(manager.getUOWTimeout()).isEqualTo(0);
assertThat(manager.getUOWType()).isEqualTo(UOWManager.UOW_TYPE_GLOBAL_TRANSACTION);
assertThat(manager.getJoined()).isTrue();
assertThat(manager.getRollbackOnly()).isFalse();
}
@Test
@@ -525,37 +522,37 @@ public class WebSphereUowTransactionManagerTests {
definition2.setPropagationBehavior(propagationBehavior);
definition2.setReadOnly(true);
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertEquals("result", ptm.execute(definition, new TransactionCallback<String>() {
assertThat(ptm.execute(definition, new TransactionCallback<String>() {
@Override
public String doInTransaction(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertEquals("result2", ptm.execute(definition2, new TransactionCallback<String>() {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertThat(ptm.execute(definition2, new TransactionCallback<String>() {
@Override
public String doInTransaction(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
public String doInTransaction(TransactionStatus status1) {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
return "result2";
}
}));
})).isEqualTo("result2");
return "result";
}
}));
})).isEqualTo("result");
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertEquals(0, manager.getUOWTimeout());
assertEquals(UOWManager.UOW_TYPE_GLOBAL_TRANSACTION, manager.getUOWType());
assertTrue(manager.getJoined());
assertFalse(manager.getRollbackOnly());
assertThat(manager.getUOWTimeout()).isEqualTo(0);
assertThat(manager.getUOWType()).isEqualTo(UOWManager.UOW_TYPE_GLOBAL_TRANSACTION);
assertThat(manager.getJoined()).isTrue();
assertThat(manager.getRollbackOnly()).isFalse();
}
@Test
@@ -576,43 +573,42 @@ public class WebSphereUowTransactionManagerTests {
definition2.setPropagationBehavior(propagationBehavior);
definition2.setReadOnly(true);
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertEquals("result", ptm.execute(definition, new TransactionCallback<String>() {
assertThat(ptm.execute(definition, new TransactionCallback<String>() {
@Override
public String doInTransaction(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertEquals("result2", ptm.execute(definition2, new TransactionCallback<String>() {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertThat(ptm.execute(definition2, new TransactionCallback<String>() {
@Override
public String doInTransaction(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertEquals(propagationBehavior == TransactionDefinition.PROPAGATION_REQUIRES_NEW,
TransactionSynchronizationManager.isActualTransactionActive());
assertTrue(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
public String doInTransaction(TransactionStatus status1) {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isEqualTo((propagationBehavior == TransactionDefinition.PROPAGATION_REQUIRES_NEW));
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isTrue();
return "result2";
}
}));
})).isEqualTo("result2");
return "result";
}
}));
})).isEqualTo("result");
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertEquals(0, manager.getUOWTimeout());
assertThat(manager.getUOWTimeout()).isEqualTo(0);
if (propagationBehavior == TransactionDefinition.PROPAGATION_REQUIRES_NEW) {
assertEquals(UOWManager.UOW_TYPE_GLOBAL_TRANSACTION, manager.getUOWType());
assertThat(manager.getUOWType()).isEqualTo(UOWManager.UOW_TYPE_GLOBAL_TRANSACTION);
}
else {
assertEquals(UOWManager.UOW_TYPE_LOCAL_TRANSACTION, manager.getUOWType());
assertThat(manager.getUOWType()).isEqualTo(UOWManager.UOW_TYPE_LOCAL_TRANSACTION);
}
assertFalse(manager.getJoined());
assertFalse(manager.getRollbackOnly());
assertThat(manager.getJoined()).isFalse();
assertThat(manager.getRollbackOnly()).isFalse();
}
@Test
@@ -624,37 +620,37 @@ public class WebSphereUowTransactionManagerTests {
definition2.setPropagationBehavior(TransactionDefinition.PROPAGATION_NOT_SUPPORTED);
definition2.setReadOnly(true);
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertEquals("result", ptm.execute(definition, new TransactionCallback<String>() {
assertThat(ptm.execute(definition, new TransactionCallback<String>() {
@Override
public String doInTransaction(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertTrue(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertEquals("result2", ptm.execute(definition2, new TransactionCallback<String>() {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isTrue();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertThat(ptm.execute(definition2, new TransactionCallback<String>() {
@Override
public String doInTransaction(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
assertTrue(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
public String doInTransaction(TransactionStatus status1) {
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isTrue();
return "result2";
}
}));
})).isEqualTo("result2");
return "result";
}
}));
})).isEqualTo("result");
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertEquals(0, manager.getUOWTimeout());
assertEquals(UOWManager.UOW_TYPE_LOCAL_TRANSACTION, manager.getUOWType());
assertFalse(manager.getJoined());
assertFalse(manager.getRollbackOnly());
assertThat(manager.getUOWTimeout()).isEqualTo(0);
assertThat(manager.getUOWType()).isEqualTo(UOWManager.UOW_TYPE_LOCAL_TRANSACTION);
assertThat(manager.getJoined()).isFalse();
assertThat(manager.getRollbackOnly()).isFalse();
}
}

53
spring-tx/src/test/java/org/springframework/transaction/reactive/ReactiveTransactionSupportTests.java
View File

@@ -27,9 +27,7 @@ import org.springframework.transaction.ReactiveTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.support.DefaultTransactionDefinition;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Unit tests for transactional support through {@link ReactiveTestTransactionManager}.
@@ -44,16 +42,15 @@ public class ReactiveTransactionSupportTests {
tm.getReactiveTransaction(new DefaultTransactionDefinition(TransactionDefinition.PROPAGATION_SUPPORTS))
.subscriberContext(TransactionContextManager.createTransactionContext()).cast(GenericReactiveTransaction.class)
.as(StepVerifier::create).consumeNextWith(actual ->
assertFalse(actual.hasTransaction())
).verifyComplete();
.as(StepVerifier::create).consumeNextWith(actual -> assertThat(actual.hasTransaction()).isFalse()
).verifyComplete();
tm.getReactiveTransaction(new DefaultTransactionDefinition(TransactionDefinition.PROPAGATION_REQUIRED))
.cast(GenericReactiveTransaction.class).subscriberContext(TransactionContextManager.createTransactionContext())
.as(StepVerifier::create).consumeNextWith(actual -> {
assertTrue(actual.hasTransaction());
assertTrue(actual.isNewTransaction());
}).verifyComplete();
assertThat(actual.hasTransaction()).isTrue();
assertThat(actual.isNewTransaction()).isTrue();
}).verifyComplete();
tm.getReactiveTransaction(new DefaultTransactionDefinition(TransactionDefinition.PROPAGATION_MANDATORY))
.subscriberContext(TransactionContextManager.createTransactionContext()).cast(GenericReactiveTransaction.class)
@@ -67,23 +64,23 @@ public class ReactiveTransactionSupportTests {
tm.getReactiveTransaction(new DefaultTransactionDefinition(TransactionDefinition.PROPAGATION_SUPPORTS))
.subscriberContext(TransactionContextManager.createTransactionContext()).cast(GenericReactiveTransaction.class)
.as(StepVerifier::create).consumeNextWith(actual -> {
assertNotNull(actual.getTransaction());
assertFalse(actual.isNewTransaction());
}).verifyComplete();
assertThat(actual.getTransaction()).isNotNull();
assertThat(actual.isNewTransaction()).isFalse();
}).verifyComplete();
tm.getReactiveTransaction(new DefaultTransactionDefinition(TransactionDefinition.PROPAGATION_REQUIRED))
.subscriberContext(TransactionContextManager.createTransactionContext()).cast(GenericReactiveTransaction.class)
.as(StepVerifier::create).consumeNextWith(actual -> {
assertNotNull(actual.getTransaction());
assertFalse(actual.isNewTransaction());
}).verifyComplete();
assertThat(actual.getTransaction()).isNotNull();
assertThat(actual.isNewTransaction()).isFalse();
}).verifyComplete();
tm.getReactiveTransaction(new DefaultTransactionDefinition(TransactionDefinition.PROPAGATION_MANDATORY))
.subscriberContext(TransactionContextManager.createTransactionContext()).cast(GenericReactiveTransaction.class)
.as(StepVerifier::create).consumeNextWith(actual -> {
assertNotNull(actual.getTransaction());
assertFalse(actual.isNewTransaction());
}).verifyComplete();
assertThat(actual.getTransaction()).isNotNull();
assertThat(actual.isNewTransaction()).isFalse();
}).verifyComplete();
}
@Test
@@ -207,43 +204,43 @@ public class ReactiveTransactionSupportTests {
}
private void assertHasBegan(ReactiveTestTransactionManager actual) {
assertTrue("Expected <ReactiveTransactionManager.begin()> but was <begin()> was not invoked", actual.begin);
assertThat(actual.begin).as("Expected <ReactiveTransactionManager.begin()> but was <begin()> was not invoked").isTrue();
}
private void assertHasNotBegan(ReactiveTestTransactionManager actual) {
assertFalse("Expected to not call <ReactiveTransactionManager.begin()> but was <begin()> was called", actual.begin);
assertThat(actual.begin).as("Expected to not call <ReactiveTransactionManager.begin()> but was <begin()> was called").isFalse();
}
private void assertHasCommitted(ReactiveTestTransactionManager actual) {
assertTrue("Expected <ReactiveTransactionManager.commit()> but was <commit()> was not invoked", actual.commit);
assertThat(actual.commit).as("Expected <ReactiveTransactionManager.commit()> but was <commit()> was not invoked").isTrue();
}
private void assertHasNotCommitted(ReactiveTestTransactionManager actual) {
assertFalse("Expected to not call <ReactiveTransactionManager.commit()> but was <commit()> was called", actual.commit);
assertThat(actual.commit).as("Expected to not call <ReactiveTransactionManager.commit()> but was <commit()> was called").isFalse();
}
private void assertHasRolledBack(ReactiveTestTransactionManager actual) {
assertTrue("Expected <ReactiveTransactionManager.rollback()> but was <rollback()> was not invoked", actual.rollback);
assertThat(actual.rollback).as("Expected <ReactiveTransactionManager.rollback()> but was <rollback()> was not invoked").isTrue();
}
private void assertHasNoRollback(ReactiveTestTransactionManager actual) {
assertFalse("Expected to not call <ReactiveTransactionManager.rollback()> but was <rollback()> was called", actual.rollback);
assertThat(actual.rollback).as("Expected to not call <ReactiveTransactionManager.rollback()> but was <rollback()> was called").isFalse();
}
private void assertHasSetRollbackOnly(ReactiveTestTransactionManager actual) {
assertTrue("Expected <ReactiveTransactionManager.setRollbackOnly()> but was <setRollbackOnly()> was not invoked", actual.rollbackOnly);
assertThat(actual.rollbackOnly).as("Expected <ReactiveTransactionManager.setRollbackOnly()> but was <setRollbackOnly()> was not invoked").isTrue();
}
private void assertHasNotSetRollbackOnly(ReactiveTestTransactionManager actual) {
assertFalse("Expected to not call <ReactiveTransactionManager.setRollbackOnly()> but was <setRollbackOnly()> was called", actual.rollbackOnly);
assertThat(actual.rollbackOnly).as("Expected to not call <ReactiveTransactionManager.setRollbackOnly()> but was <setRollbackOnly()> was called").isFalse();
}
private void assertHasCleanedUp(ReactiveTestTransactionManager actual) {
assertTrue("Expected <ReactiveTransactionManager.doCleanupAfterCompletion()> but was <doCleanupAfterCompletion()> was not invoked", actual.cleanup);
assertThat(actual.cleanup).as("Expected <ReactiveTransactionManager.doCleanupAfterCompletion()> but was <doCleanupAfterCompletion()> was not invoked").isTrue();
}
private void assertHasNotCleanedUp(ReactiveTestTransactionManager actual) {
assertFalse("Expected to not call <ReactiveTransactionManager.doCleanupAfterCompletion()> but was <doCleanupAfterCompletion()> was called", actual.cleanup);
assertThat(actual.cleanup).as("Expected to not call <ReactiveTransactionManager.doCleanupAfterCompletion()> but was <doCleanupAfterCompletion()> was called").isFalse();
}
}

19
spring-tx/src/test/java/org/springframework/transaction/reactive/TransactionalOperatorTests.java
View File

@@ -23,8 +23,7 @@ import reactor.test.StepVerifier;
import org.springframework.transaction.support.DefaultTransactionDefinition;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link TransactionalOperator}.
@@ -43,8 +42,8 @@ public class TransactionalOperatorTests {
.as(StepVerifier::create)
.expectNext(true)
.verifyComplete();
assertTrue(tm.commit);
assertFalse(tm.rollback);
assertThat(tm.commit).isTrue();
assertThat(tm.rollback).isFalse();
}
@Test
@@ -53,8 +52,8 @@ public class TransactionalOperatorTests {
Mono.error(new IllegalStateException()).as(operator::transactional)
.as(StepVerifier::create)
.verifyError(IllegalStateException.class);
assertFalse(tm.commit);
assertTrue(tm.rollback);
assertThat(tm.commit).isFalse();
assertThat(tm.rollback).isTrue();
}
@Test
@@ -64,8 +63,8 @@ public class TransactionalOperatorTests {
.as(StepVerifier::create)
.expectNextCount(4)
.verifyComplete();
assertTrue(tm.commit);
assertFalse(tm.rollback);
assertThat(tm.commit).isTrue();
assertThat(tm.rollback).isFalse();
}
@Test
@@ -74,8 +73,8 @@ public class TransactionalOperatorTests {
Flux.error(new IllegalStateException()).as(operator::transactional)
.as(StepVerifier::create)
.verifyError(IllegalStateException.class);
assertFalse(tm.commit);
assertTrue(tm.rollback);
assertThat(tm.commit).isFalse();
assertThat(tm.rollback).isTrue();
}
}

18
spring-tx/src/test/java/org/springframework/transaction/support/JtaTransactionManagerSerializationTests.java
View File

@@ -25,10 +25,7 @@ import org.springframework.tests.mock.jndi.SimpleNamingContextBuilder;
import org.springframework.transaction.jta.JtaTransactionManager;
import org.springframework.util.SerializationTestUtils;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
/**
@@ -55,13 +52,12 @@ public class JtaTransactionManagerSerializationTests {
.serializeAndDeserialize(jtam);
// should do client-side lookup
assertNotNull("Logger must survive serialization",
serializedJtatm.logger);
assertTrue("UserTransaction looked up on client", serializedJtatm
.getUserTransaction() == ut2);
assertNull("TransactionManager didn't survive", serializedJtatm
.getTransactionManager());
assertEquals(true, serializedJtatm.isRollbackOnCommitFailure());
assertThat(serializedJtatm.logger).as("Logger must survive serialization").isNotNull();
assertThat(serializedJtatm
.getUserTransaction() == ut2).as("UserTransaction looked up on client").isTrue();
assertThat(serializedJtatm
.getTransactionManager()).as("TransactionManager didn't survive").isNull();
assertThat(serializedJtatm.isRollbackOnCommitFailure()).isEqualTo(true);
}
}

69
spring-tx/src/test/java/org/springframework/transaction/support/SimpleTransactionScopeTests.java
View File

@@ -28,11 +28,8 @@ import org.springframework.tests.sample.beans.DerivedTestBean;
import org.springframework.tests.sample.beans.TestBean;
import org.springframework.tests.transaction.CallCountingTransactionManager;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
/**
* @author Juergen Hoeller
@@ -74,34 +71,34 @@ public class SimpleTransactionScopeTests {
TransactionSynchronizationManager.initSynchronization();
try {
bean1 = context.getBean(TestBean.class);
assertSame(bean1, context.getBean(TestBean.class));
assertThat(context.getBean(TestBean.class)).isSameAs(bean1);
bean2 = context.getBean(DerivedTestBean.class);
assertSame(bean2, context.getBean(DerivedTestBean.class));
assertThat(context.getBean(DerivedTestBean.class)).isSameAs(bean2);
context.getBeanFactory().destroyScopedBean("txScopedObject2");
assertFalse(TransactionSynchronizationManager.hasResource("txScopedObject2"));
assertTrue(bean2.wasDestroyed());
assertThat(TransactionSynchronizationManager.hasResource("txScopedObject2")).isFalse();
assertThat(bean2.wasDestroyed()).isTrue();
bean2a = context.getBean(DerivedTestBean.class);
assertSame(bean2a, context.getBean(DerivedTestBean.class));
assertNotSame(bean2, bean2a);
assertThat(context.getBean(DerivedTestBean.class)).isSameAs(bean2a);
assertThat(bean2a).isNotSameAs(bean2);
context.getBeanFactory().getRegisteredScope("tx").remove("txScopedObject2");
assertFalse(TransactionSynchronizationManager.hasResource("txScopedObject2"));
assertFalse(bean2a.wasDestroyed());
assertThat(TransactionSynchronizationManager.hasResource("txScopedObject2")).isFalse();
assertThat(bean2a.wasDestroyed()).isFalse();
bean2b = context.getBean(DerivedTestBean.class);
assertSame(bean2b, context.getBean(DerivedTestBean.class));
assertNotSame(bean2, bean2b);
assertNotSame(bean2a, bean2b);
assertThat(context.getBean(DerivedTestBean.class)).isSameAs(bean2b);
assertThat(bean2b).isNotSameAs(bean2);
assertThat(bean2b).isNotSameAs(bean2a);
}
finally {
TransactionSynchronizationUtils.triggerAfterCompletion(TransactionSynchronization.STATUS_COMMITTED);
TransactionSynchronizationManager.clearSynchronization();
}
assertFalse(bean2a.wasDestroyed());
assertTrue(bean2b.wasDestroyed());
assertTrue(TransactionSynchronizationManager.getResourceMap().isEmpty());
assertThat(bean2a.wasDestroyed()).isFalse();
assertThat(bean2b.wasDestroyed()).isTrue();
assertThat(TransactionSynchronizationManager.getResourceMap().isEmpty()).isTrue();
assertThatExceptionOfType(BeanCreationException.class).isThrownBy(() ->
context.getBean(TestBean.class))
@@ -136,26 +133,26 @@ public class SimpleTransactionScopeTests {
tt.execute(status -> {
TestBean bean1 = context.getBean(TestBean.class);
assertSame(bean1, context.getBean(TestBean.class));
assertThat(context.getBean(TestBean.class)).isSameAs(bean1);
DerivedTestBean bean2 = context.getBean(DerivedTestBean.class);
assertSame(bean2, context.getBean(DerivedTestBean.class));
assertThat(context.getBean(DerivedTestBean.class)).isSameAs(bean2);
context.getBeanFactory().destroyScopedBean("txScopedObject2");
assertFalse(TransactionSynchronizationManager.hasResource("txScopedObject2"));
assertTrue(bean2.wasDestroyed());
assertThat(TransactionSynchronizationManager.hasResource("txScopedObject2")).isFalse();
assertThat(bean2.wasDestroyed()).isTrue();
DerivedTestBean bean2a = context.getBean(DerivedTestBean.class);
assertSame(bean2a, context.getBean(DerivedTestBean.class));
assertNotSame(bean2, bean2a);
assertThat(context.getBean(DerivedTestBean.class)).isSameAs(bean2a);
assertThat(bean2a).isNotSameAs(bean2);
context.getBeanFactory().getRegisteredScope("tx").remove("txScopedObject2");
assertFalse(TransactionSynchronizationManager.hasResource("txScopedObject2"));
assertFalse(bean2a.wasDestroyed());
assertThat(TransactionSynchronizationManager.hasResource("txScopedObject2")).isFalse();
assertThat(bean2a.wasDestroyed()).isFalse();
DerivedTestBean bean2b = context.getBean(DerivedTestBean.class);
finallyDestroy.add(bean2b);
assertSame(bean2b, context.getBean(DerivedTestBean.class));
assertNotSame(bean2, bean2b);
assertNotSame(bean2a, bean2b);
assertThat(context.getBean(DerivedTestBean.class)).isSameAs(bean2b);
assertThat(bean2b).isNotSameAs(bean2);
assertThat(bean2b).isNotSameAs(bean2a);
Set<DerivedTestBean> immediatelyDestroy = new HashSet<>();
TransactionTemplate tt2 = new TransactionTemplate(tm);
@@ -163,19 +160,19 @@ public class SimpleTransactionScopeTests {
tt2.execute(status2 -> {
DerivedTestBean bean2c = context.getBean(DerivedTestBean.class);
immediatelyDestroy.add(bean2c);
assertSame(bean2c, context.getBean(DerivedTestBean.class));
assertNotSame(bean2, bean2c);
assertNotSame(bean2a, bean2c);
assertNotSame(bean2b, bean2c);
assertThat(context.getBean(DerivedTestBean.class)).isSameAs(bean2c);
assertThat(bean2c).isNotSameAs(bean2);
assertThat(bean2c).isNotSameAs(bean2a);
assertThat(bean2c).isNotSameAs(bean2b);
return null;
});
assertTrue(immediatelyDestroy.iterator().next().wasDestroyed());
assertFalse(bean2b.wasDestroyed());
assertThat(immediatelyDestroy.iterator().next().wasDestroyed()).isTrue();
assertThat(bean2b.wasDestroyed()).isFalse();
return null;
});
assertTrue(finallyDestroy.iterator().next().wasDestroyed());
assertThat(finallyDestroy.iterator().next().wasDestroyed()).isTrue();
}
}