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

51
spring-orm/src/test/java/org/springframework/orm/jpa/AbstractContainerEntityManagerFactoryIntegrationTests.java
View File

@@ -29,12 +29,9 @@ import org.springframework.orm.jpa.domain.DriversLicense;
import org.springframework.orm.jpa.domain.Person;
import org.springframework.util.SerializationTestUtils;
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.assertNotNull;
import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertTrue;
/**
* Integration tests for LocalContainerEntityManagerFactoryBean.
@@ -48,16 +45,17 @@ public abstract class AbstractContainerEntityManagerFactoryIntegrationTests
@Test
public void testEntityManagerFactoryImplementsEntityManagerFactoryInfo() {
assertTrue("Must have introduced config interface", entityManagerFactory instanceof EntityManagerFactoryInfo);
boolean condition = entityManagerFactory instanceof EntityManagerFactoryInfo;
assertThat(condition).as("Must have introduced config interface").isTrue();
EntityManagerFactoryInfo emfi = (EntityManagerFactoryInfo) entityManagerFactory;
assertEquals("Person", emfi.getPersistenceUnitName());
assertNotNull("PersistenceUnitInfo must be available", emfi.getPersistenceUnitInfo());
assertNotNull("Raw EntityManagerFactory must be available", emfi.getNativeEntityManagerFactory());
assertThat(emfi.getPersistenceUnitName()).isEqualTo("Person");
assertThat(emfi.getPersistenceUnitInfo()).as("PersistenceUnitInfo must be available").isNotNull();
assertThat(emfi.getNativeEntityManagerFactory()).as("Raw EntityManagerFactory must be available").isNotNull();
}
@Test
public void testStateClean() {
assertEquals("Should be no people from previous transactions", 0, countRowsInTable("person"));
assertThat(countRowsInTable("person")).as("Should be no people from previous transactions").isEqualTo(0);
}
@Test
@@ -77,20 +75,19 @@ public abstract class AbstractContainerEntityManagerFactoryIntegrationTests
@Test
public void testJdbcTx2() {
assertEquals("Any previous tx must have been rolled back", 0, countRowsInTable("person"));
assertThat(countRowsInTable("person")).as("Any previous tx must have been rolled back").isEqualTo(0);
executeSqlScript("/org/springframework/orm/jpa/insertPerson.sql");
}
@Test
@SuppressWarnings("unchecked")
public void testEntityManagerProxyIsProxy() {
assertTrue(Proxy.isProxyClass(sharedEntityManager.getClass()));
assertThat(Proxy.isProxyClass(sharedEntityManager.getClass())).isTrue();
Query q = sharedEntityManager.createQuery("select p from Person as p");
q.getResultList();
assertTrue("Should be open to start with", sharedEntityManager.isOpen());
assertThat(sharedEntityManager.isOpen()).as("Should be open to start with").isTrue();
sharedEntityManager.close();
assertTrue("Close should have been silently ignored", sharedEntityManager.isOpen());
assertThat(sharedEntityManager.isOpen()).as("Close should have been silently ignored").isTrue();
}
@Test
@@ -127,10 +124,10 @@ public abstract class AbstractContainerEntityManagerFactoryIntegrationTests
startNewTransaction();
sharedEntityManager.clear();
Person newTony = entityManagerFactory.createEntityManager().getReference(Person.class, tony.getId());
assertNotSame(newTony, tony);
assertThat(tony).isNotSameAs(newTony);
endTransaction();
assertNotNull(newTony.getDriversLicense());
assertThat(newTony.getDriversLicense()).isNotNull();
newTony.getDriversLicense().getSerialNumber();
}
@@ -146,12 +143,12 @@ public abstract class AbstractContainerEntityManagerFactoryIntegrationTests
String firstName = "Tony";
insertPerson(firstName);
assertTrue(Proxy.isProxyClass(sharedEntityManager.getClass()));
assertThat(Proxy.isProxyClass(sharedEntityManager.getClass())).isTrue();
Query q = sharedEntityManager.createQuery("select p from Person as p");
List<Person> people = q.getResultList();
assertEquals(1, people.size());
assertEquals(firstName, people.get(0).getFirstName());
assertThat(people.size()).isEqualTo(1);
assertThat(people.get(0).getFirstName()).isEqualTo(firstName);
}
protected void insertPerson(String firstName) {
@@ -171,14 +168,14 @@ public abstract class AbstractContainerEntityManagerFactoryIntegrationTests
}
protected void testInstantiateAndSave(EntityManager em) {
assertEquals("Should be no people from previous transactions", 0, countRowsInTable("person"));
assertThat(countRowsInTable("person")).as("Should be no people from previous transactions").isEqualTo(0);
Person p = new Person();
p.setFirstName("Tony");
p.setLastName("Blair");
em.persist(p);
em.flush();
assertEquals("1 row must have been inserted", 1, countRowsInTable("person"));
assertThat(countRowsInTable("person")).as("1 row must have been inserted").isEqualTo(1);
}
@Test
@@ -187,7 +184,7 @@ public abstract class AbstractContainerEntityManagerFactoryIntegrationTests
EntityManager em = entityManagerFactory.createEntityManager();
Query q = em.createQuery("select p from Person as p");
List<Person> people = q.getResultList();
assertEquals(0, people.size());
assertThat(people.size()).isEqualTo(0);
assertThatExceptionOfType(NoResultException.class).isThrownBy(
q::getSingleResult);
}
@@ -200,7 +197,7 @@ public abstract class AbstractContainerEntityManagerFactoryIntegrationTests
EntityManager em = entityManagerFactory.createEntityManager();
Query q = em.createQuery("select p from Person as p");
List<Person> people = q.getResultList();
assertEquals(0, people.size());
assertThat(people.size()).isEqualTo(0);
assertThatExceptionOfType(NoResultException.class).isThrownBy(
q::getSingleResult);
}
@@ -211,7 +208,7 @@ public abstract class AbstractContainerEntityManagerFactoryIntegrationTests
Query q = this.sharedEntityManager.createQuery("select p from Person as p");
q.setFlushMode(FlushModeType.AUTO);
List<Person> people = q.getResultList();
assertEquals(0, people.size());
assertThat(people.size()).isEqualTo(0);
assertThatExceptionOfType(NoResultException.class).isThrownBy(
q::getSingleResult);
}
@@ -225,7 +222,7 @@ public abstract class AbstractContainerEntityManagerFactoryIntegrationTests
Query q = em.createQuery("select p from Person as p");
q.setFlushMode(FlushModeType.AUTO);
List<Person> people = q.getResultList();
assertEquals(0, people.size());
assertThat(people.size()).isEqualTo(0);
assertThatExceptionOfType(Exception.class).isThrownBy(() ->
q.getSingleResult())
.withMessageContaining("closed");
@@ -240,8 +237,8 @@ public abstract class AbstractContainerEntityManagerFactoryIntegrationTests
@Test
public void testCanSerializeProxies() throws Exception {
assertNotNull(SerializationTestUtils.serializeAndDeserialize(entityManagerFactory));
assertNotNull(SerializationTestUtils.serializeAndDeserialize(sharedEntityManager));
assertThat(SerializationTestUtils.serializeAndDeserialize(entityManagerFactory)).isNotNull();
assertThat(SerializationTestUtils.serializeAndDeserialize(sharedEntityManager)).isNotNull();
}
}

24
spring-orm/src/test/java/org/springframework/orm/jpa/AbstractEntityManagerFactoryBeanTests.java
View File

@@ -25,9 +25,7 @@ import org.junit.Before;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
/**
@@ -49,21 +47,21 @@ public abstract class AbstractEntityManagerFactoryBeanTests {
@After
public void tearDown() throws Exception {
assertTrue(TransactionSynchronizationManager.getResourceMap().isEmpty());
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
assertThat(TransactionSynchronizationManager.getResourceMap().isEmpty()).isTrue();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
}
protected void checkInvariants(AbstractEntityManagerFactoryBean demf) {
assertTrue(EntityManagerFactory.class.isAssignableFrom(demf.getObjectType()));
assertThat(EntityManagerFactory.class.isAssignableFrom(demf.getObjectType())).isTrue();
Object gotObject = demf.getObject();
assertTrue("Object created by factory implements EntityManagerFactoryInfo",
gotObject instanceof EntityManagerFactoryInfo);
boolean condition = gotObject instanceof EntityManagerFactoryInfo;
assertThat(condition).as("Object created by factory implements EntityManagerFactoryInfo").isTrue();
EntityManagerFactoryInfo emfi = (EntityManagerFactoryInfo) demf.getObject();
assertSame("Successive invocations of getObject() return same object", emfi, demf.getObject());
assertSame(emfi, demf.getObject());
assertSame(emfi.getNativeEntityManagerFactory(), mockEmf);
assertThat(demf.getObject()).as("Successive invocations of getObject() return same object").isSameAs(emfi);
assertThat(demf.getObject()).isSameAs(emfi);
assertThat(mockEmf).isSameAs(emfi.getNativeEntityManagerFactory());
}

11
spring-orm/src/test/java/org/springframework/orm/jpa/AbstractEntityManagerFactoryIntegrationTests.java
View File

@@ -38,8 +38,7 @@ import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
/**
* @author Rod Johnson
@@ -110,10 +109,10 @@ public abstract class AbstractEntityManagerFactoryIntegrationTests {
endTransaction();
}
assertTrue(TransactionSynchronizationManager.getResourceMap().isEmpty());
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
assertThat(TransactionSynchronizationManager.getResourceMap().isEmpty()).isTrue();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
}
@AfterClass

33
spring-orm/src/test/java/org/springframework/orm/jpa/ApplicationManagedEntityManagerIntegrationTests.java
View File

@@ -26,11 +26,8 @@ import org.junit.Test;
import org.springframework.orm.jpa.domain.Person;
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;
/**
* An application-managed entity manager can join an existing transaction,
@@ -46,14 +43,14 @@ public class ApplicationManagedEntityManagerIntegrationTests extends AbstractEnt
@SuppressWarnings("unchecked")
public void testEntityManagerProxyIsProxy() {
EntityManager em = entityManagerFactory.createEntityManager();
assertTrue(Proxy.isProxyClass(em.getClass()));
assertThat(Proxy.isProxyClass(em.getClass())).isTrue();
Query q = em.createQuery("select p from Person as p");
List<Person> people = q.getResultList();
assertNotNull(people);
assertThat(people).isNotNull();
assertTrue("Should be open to start with", em.isOpen());
assertThat(em.isOpen()).as("Should be open to start with").isTrue();
em.close();
assertFalse("Close should work on application managed EM", em.isOpen());
assertThat(em.isOpen()).as("Close should work on application managed EM").isFalse();
}
@Test
@@ -92,12 +89,12 @@ public class ApplicationManagedEntityManagerIntegrationTests extends AbstractEnt
em.persist(p);
em.flush();
assertEquals("1 row must have been inserted", 1, countRowsInTable(em, "person"));
assertThat(countRowsInTable(em, "person")).as("1 row must have been inserted").isEqualTo(1);
}
@Test
public void testStateClean() {
assertEquals("Should be no people from previous transactions", 0, countRowsInTable("person"));
assertThat(countRowsInTable("person")).as("Should be no people from previous transactions").isEqualTo(0);
}
@Test
@@ -108,27 +105,27 @@ public class ApplicationManagedEntityManagerIntegrationTests extends AbstractEnt
doInstantiateAndSave(em);
endTransaction();
assertFalse(em.getTransaction().isActive());
assertThat(em.getTransaction().isActive()).isFalse();
startNewTransaction();
// Call any method: should cause automatic tx invocation
assertFalse(em.contains(new Person()));
assertThat(em.contains(new Person())).isFalse();
assertFalse(em.getTransaction().isActive());
assertThat(em.getTransaction().isActive()).isFalse();
em.joinTransaction();
assertTrue(em.getTransaction().isActive());
assertThat(em.getTransaction().isActive()).isTrue();
doInstantiateAndSave(em);
setComplete();
endTransaction(); // Should rollback
assertEquals("Tx must have committed back", 1, countRowsInTable(em, "person"));
assertThat(countRowsInTable(em, "person")).as("Tx must have committed back").isEqualTo(1);
// Now clean up the database
startNewTransaction();
em.joinTransaction();
deleteAllPeopleUsingEntityManager(em);
assertEquals("People have been killed", 0, countRowsInTable(em, "person"));
assertThat(countRowsInTable(em, "person")).as("People have been killed").isEqualTo(0);
setComplete();
}
@@ -142,7 +139,7 @@ public class ApplicationManagedEntityManagerIntegrationTests extends AbstractEnt
em.joinTransaction();
doInstantiateAndSave(em);
endTransaction(); // Should rollback
assertEquals("Tx must have been rolled back", 0, countRowsInTable(em, "person"));
assertThat(countRowsInTable(em, "person")).as("Tx must have been rolled back").isEqualTo(0);
}
@Test
@@ -153,7 +150,7 @@ public class ApplicationManagedEntityManagerIntegrationTests extends AbstractEnt
setComplete();
endTransaction(); // Should rollback
assertEquals("Tx must have committed back", 1, countRowsInTable(em, "person"));
assertThat(countRowsInTable(em, "person")).as("Tx must have committed back").isEqualTo(1);
// Now clean up the database
deleteFromTables("person");

35
spring-orm/src/test/java/org/springframework/orm/jpa/ContainerManagedEntityManagerIntegrationTests.java
View File

@@ -30,14 +30,9 @@ import org.springframework.dao.DataAccessException;
import org.springframework.dao.support.PersistenceExceptionTranslator;
import org.springframework.orm.jpa.domain.Person;
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.assertSame;
import static org.junit.Assert.assertTrue;
/**
* Integration tests using in-memory database for container-managed JPA
@@ -59,32 +54,32 @@ public class ContainerManagedEntityManagerIntegrationTests extends AbstractEntit
@Test
public void testExceptionTranslationWithDialectFoundOnEntityManagerFactoryBean() throws Exception {
assertNotNull("Dialect must have been set", entityManagerFactoryBean.getJpaDialect());
assertThat(entityManagerFactoryBean.getJpaDialect()).as("Dialect must have been set").isNotNull();
doTestExceptionTranslationWithDialectFound(entityManagerFactoryBean);
}
protected void doTestExceptionTranslationWithDialectFound(PersistenceExceptionTranslator pet) throws Exception {
RuntimeException in1 = new RuntimeException("in1");
PersistenceException in2 = new PersistenceException();
assertNull("No translation here", pet.translateExceptionIfPossible(in1));
assertThat(pet.translateExceptionIfPossible(in1)).as("No translation here").isNull();
DataAccessException dex = pet.translateExceptionIfPossible(in2);
assertNotNull(dex);
assertSame(in2, dex.getCause());
assertThat(dex).isNotNull();
assertThat(dex.getCause()).isSameAs(in2);
}
@Test
@SuppressWarnings("unchecked")
public void testEntityManagerProxyIsProxy() {
EntityManager em = createContainerManagedEntityManager();
assertTrue(Proxy.isProxyClass(em.getClass()));
assertThat(Proxy.isProxyClass(em.getClass())).isTrue();
Query q = em.createQuery("select p from Person as p");
List<Person> people = q.getResultList();
assertTrue(people.isEmpty());
assertThat(people.isEmpty()).isTrue();
assertTrue("Should be open to start with", em.isOpen());
assertThat(em.isOpen()).as("Should be open to start with").isTrue();
assertThatIllegalStateException().as("Close should not work on container managed EM").isThrownBy(
em::close);
assertTrue(em.isOpen());
assertThat(em.isOpen()).isTrue();
}
// This would be legal, at least if not actually _starting_ a tx
@@ -117,7 +112,7 @@ public class ContainerManagedEntityManagerIntegrationTests extends AbstractEntit
}
protected void doInstantiateAndSave(EntityManager em) {
assertEquals("Should be no people from previous transactions", 0, countRowsInTable(em, "person"));
assertThat(countRowsInTable(em, "person")).as("Should be no people from previous transactions").isEqualTo(0);
Person p = new Person();
p.setFirstName("Tony");
@@ -125,7 +120,7 @@ public class ContainerManagedEntityManagerIntegrationTests extends AbstractEntit
em.persist(p);
em.flush();
assertEquals("1 row must have been inserted", 1, countRowsInTable(em, "person"));
assertThat(countRowsInTable(em, "person")).as("1 row must have been inserted").isEqualTo(1);
}
@Test
@@ -138,13 +133,13 @@ public class ContainerManagedEntityManagerIntegrationTests extends AbstractEntit
startNewTransaction();
// Call any method: should cause automatic tx invocation
assertFalse(em.contains(new Person()));
assertThat(em.contains(new Person())).isFalse();
//assertTrue(em.getTransaction().isActive());
doInstantiateAndSave(em);
setComplete();
endTransaction(); // Should rollback
assertEquals("Tx must have committed back", 1, countRowsInTable(em, "person"));
assertThat(countRowsInTable(em, "person")).as("Tx must have committed back").isEqualTo(1);
// Now clean up the database
deleteFromTables("person");
@@ -155,7 +150,7 @@ public class ContainerManagedEntityManagerIntegrationTests extends AbstractEntit
EntityManager em = createContainerManagedEntityManager();
doInstantiateAndSave(em);
endTransaction(); // Should rollback
assertEquals("Tx must have been rolled back", 0, countRowsInTable(em, "person"));
assertThat(countRowsInTable(em, "person")).as("Tx must have been rolled back").isEqualTo(0);
}
@Test
@@ -164,7 +159,7 @@ public class ContainerManagedEntityManagerIntegrationTests extends AbstractEntit
doInstantiateAndSave(em);
setComplete();
endTransaction(); // Should rollback
assertEquals("Tx must have committed back", 1, countRowsInTable(em, "person"));
assertThat(countRowsInTable(em, "person")).as("Tx must have committed back").isEqualTo(1);
// Now clean up the database
deleteFromTables("person");

6
spring-orm/src/test/java/org/springframework/orm/jpa/DefaultJpaDialectTests.java
View File

@@ -26,8 +26,8 @@ import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionException;
import org.springframework.transaction.support.DefaultTransactionDefinition;
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.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
@@ -61,8 +61,6 @@ public class DefaultJpaDialectTests {
@Test
public void testTranslateException() {
OptimisticLockException ex = new OptimisticLockException();
assertEquals(
EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(ex).getCause(),
dialect.translateExceptionIfPossible(ex).getCause());
assertThat(dialect.translateExceptionIfPossible(ex).getCause()).isEqualTo(EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(ex).getCause());
}
}

49
spring-orm/src/test/java/org/springframework/orm/jpa/EntityManagerFactoryUtilsTests.java
View File

@@ -35,10 +35,8 @@ import org.springframework.dao.IncorrectResultSizeDataAccessException;
import org.springframework.dao.InvalidDataAccessApiUsageException;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
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;
@@ -62,8 +60,8 @@ public class EntityManagerFactoryUtilsTests {
EntityManagerFactory factory = mock(EntityManagerFactory.class);
// no tx active
assertNull(EntityManagerFactoryUtils.doGetTransactionalEntityManager(factory, null));
assertTrue(TransactionSynchronizationManager.getResourceMap().isEmpty());
assertThat(EntityManagerFactoryUtils.doGetTransactionalEntityManager(factory, null)).isNull();
assertThat(TransactionSynchronizationManager.getResourceMap().isEmpty()).isTrue();
}
@Test
@@ -76,30 +74,32 @@ public class EntityManagerFactoryUtilsTests {
given(factory.createEntityManager()).willReturn(manager);
// no tx active
assertSame(manager, EntityManagerFactoryUtils.doGetTransactionalEntityManager(factory, null));
assertSame(manager, ((EntityManagerHolder)TransactionSynchronizationManager.unbindResource(factory)).getEntityManager());
assertThat(EntityManagerFactoryUtils.doGetTransactionalEntityManager(factory, null)).isSameAs(manager);
assertThat(((EntityManagerHolder) TransactionSynchronizationManager.unbindResource(factory)).getEntityManager()).isSameAs(manager);
}
finally {
TransactionSynchronizationManager.clearSynchronization();
}
assertTrue(TransactionSynchronizationManager.getResourceMap().isEmpty());
assertThat(TransactionSynchronizationManager.getResourceMap().isEmpty()).isTrue();
}
@Test
public void testTranslatesIllegalStateException() {
IllegalStateException ise = new IllegalStateException();
DataAccessException dex = EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(ise);
assertSame(ise, dex.getCause());
assertTrue(dex instanceof InvalidDataAccessApiUsageException);
assertThat(dex.getCause()).isSameAs(ise);
boolean condition = dex instanceof InvalidDataAccessApiUsageException;
assertThat(condition).isTrue();
}
@Test
public void testTranslatesIllegalArgumentException() {
IllegalArgumentException iae = new IllegalArgumentException();
DataAccessException dex = EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(iae);
assertSame(iae, dex.getCause());
assertTrue(dex instanceof InvalidDataAccessApiUsageException);
assertThat(dex.getCause()).isSameAs(iae);
boolean condition = dex instanceof InvalidDataAccessApiUsageException;
assertThat(condition).isTrue();
}
/**
@@ -108,9 +108,7 @@ public class EntityManagerFactoryUtilsTests {
@Test
public void testDoesNotTranslateUnfamiliarException() {
UnsupportedOperationException userRuntimeException = new UnsupportedOperationException();
assertNull(
"Exception should not be wrapped",
EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(userRuntimeException));
assertThat(EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(userRuntimeException)).as("Exception should not be wrapped").isNull();
}
/*
@@ -121,33 +119,26 @@ public class EntityManagerFactoryUtilsTests {
@SuppressWarnings("serial")
public void testConvertJpaPersistenceException() {
EntityNotFoundException entityNotFound = new EntityNotFoundException();
assertSame(JpaObjectRetrievalFailureException.class,
EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(entityNotFound).getClass());
assertThat(EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(entityNotFound).getClass()).isSameAs(JpaObjectRetrievalFailureException.class);
NoResultException noResult = new NoResultException();
assertSame(EmptyResultDataAccessException.class,
EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(noResult).getClass());
assertThat(EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(noResult).getClass()).isSameAs(EmptyResultDataAccessException.class);
NonUniqueResultException nonUniqueResult = new NonUniqueResultException();
assertSame(IncorrectResultSizeDataAccessException.class,
EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(nonUniqueResult).getClass());
assertThat(EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(nonUniqueResult).getClass()).isSameAs(IncorrectResultSizeDataAccessException.class);
OptimisticLockException optimisticLock = new OptimisticLockException();
assertSame(JpaOptimisticLockingFailureException.class,
EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(optimisticLock).getClass());
assertThat(EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(optimisticLock).getClass()).isSameAs(JpaOptimisticLockingFailureException.class);
EntityExistsException entityExists = new EntityExistsException("foo");
assertSame(DataIntegrityViolationException.class,
EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(entityExists).getClass());
assertThat(EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(entityExists).getClass()).isSameAs(DataIntegrityViolationException.class);
TransactionRequiredException transactionRequired = new TransactionRequiredException("foo");
assertSame(InvalidDataAccessApiUsageException.class,
EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(transactionRequired).getClass());
assertThat(EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(transactionRequired).getClass()).isSameAs(InvalidDataAccessApiUsageException.class);
PersistenceException unknown = new PersistenceException() {
};
assertSame(JpaSystemException.class,
EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(unknown).getClass());
assertThat(EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(unknown).getClass()).isSameAs(JpaSystemException.class);
}
}

333
spring-orm/src/test/java/org/springframework/orm/jpa/JpaTransactionManagerTests.java
View File

@@ -37,10 +37,8 @@ import org.springframework.transaction.support.TransactionSynchronizationAdapter
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.junit.Assert.assertFalse;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.mockito.BDDMockito.given;
import static org.mockito.BDDMockito.willThrow;
import static org.mockito.Mockito.mock;
@@ -82,10 +80,10 @@ public class JpaTransactionManagerTests {
@After
public void verifyTransactionSynchronizationManagerState() {
assertTrue(TransactionSynchronizationManager.getResourceMap().isEmpty());
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
assertThat(TransactionSynchronizationManager.getResourceMap().isEmpty()).isTrue();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
}
@@ -96,21 +94,25 @@ public class JpaTransactionManagerTests {
final List<String> l = new ArrayList<>();
l.add("test");
assertTrue(!TransactionSynchronizationManager.hasResource(factory));
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
boolean condition3 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition3).isTrue();
boolean condition2 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition2).isTrue();
Object result = tt.execute(new TransactionCallback() {
@Override
public Object doInTransaction(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.hasResource(factory));
assertThat(TransactionSynchronizationManager.hasResource(factory)).isTrue();
EntityManagerFactoryUtils.getTransactionalEntityManager(factory).flush();
return l;
}
});
assertSame(l, result);
assertThat(result).isSameAs(l);
assertTrue(!TransactionSynchronizationManager.hasResource(factory));
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
boolean condition1 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition1).isTrue();
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
verify(tx).commit();
verify(manager).flush();
@@ -126,27 +128,32 @@ public class JpaTransactionManagerTests {
final List<String> l = new ArrayList<>();
l.add("test");
assertTrue(!TransactionSynchronizationManager.hasResource(factory));
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
boolean condition3 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition3).isTrue();
boolean condition2 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition2).isTrue();
try {
Object result = tt.execute(new TransactionCallback() {
@Override
public Object doInTransaction(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.hasResource(factory));
assertThat(TransactionSynchronizationManager.hasResource(factory)).isTrue();
EntityManagerFactoryUtils.getTransactionalEntityManager(factory).flush();
return l;
}
});
assertSame(l, result);
assertThat(result).isSameAs(l);
}
catch (TransactionSystemException tse) {
// expected
assertTrue(tse.getCause() instanceof RollbackException);
boolean condition = tse.getCause() instanceof RollbackException;
assertThat(condition).isTrue();
}
assertTrue(!TransactionSynchronizationManager.hasResource(factory));
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
boolean condition1 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition1).isTrue();
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
verify(manager).flush();
verify(manager).close();
@@ -160,21 +167,25 @@ public class JpaTransactionManagerTests {
final List<String> l = new ArrayList<>();
l.add("test");
assertTrue(!TransactionSynchronizationManager.hasResource(factory));
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
boolean condition3 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition3).isTrue();
boolean condition2 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition2).isTrue();
assertThatExceptionOfType(RuntimeException.class).isThrownBy(() ->
tt.execute(new TransactionCallback() {
@Override
public Object doInTransaction(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.hasResource(factory));
assertThat(TransactionSynchronizationManager.hasResource(factory)).isTrue();
EntityManagerFactoryUtils.getTransactionalEntityManager(factory);
throw new RuntimeException("some exception");
}
})).withMessage("some exception");
assertTrue(!TransactionSynchronizationManager.hasResource(factory));
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
boolean condition1 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition1).isTrue();
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
verify(tx).rollback();
verify(manager).close();
@@ -187,21 +198,25 @@ public class JpaTransactionManagerTests {
final List<String> l = new ArrayList<>();
l.add("test");
assertTrue(!TransactionSynchronizationManager.hasResource(factory));
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
boolean condition3 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition3).isTrue();
boolean condition2 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition2).isTrue();
assertThatExceptionOfType(RuntimeException.class).isThrownBy(() ->
tt.execute(new TransactionCallback() {
@Override
public Object doInTransaction(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.hasResource(factory));
assertThat(TransactionSynchronizationManager.hasResource(factory)).isTrue();
EntityManagerFactoryUtils.getTransactionalEntityManager(factory);
throw new RuntimeException("some exception");
}
}));
assertTrue(!TransactionSynchronizationManager.hasResource(factory));
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
boolean condition1 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition1).isTrue();
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
verify(manager).close();
}
@@ -214,13 +229,15 @@ public class JpaTransactionManagerTests {
final List<String> l = new ArrayList<>();
l.add("test");
assertTrue(!TransactionSynchronizationManager.hasResource(factory));
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
boolean condition3 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition3).isTrue();
boolean condition2 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition2).isTrue();
tt.execute(new TransactionCallback() {
@Override
public Object doInTransaction(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.hasResource(factory));
assertThat(TransactionSynchronizationManager.hasResource(factory)).isTrue();
EntityManagerFactoryUtils.getTransactionalEntityManager(factory).flush();
status.setRollbackOnly();
@@ -229,8 +246,10 @@ public class JpaTransactionManagerTests {
}
});
assertTrue(!TransactionSynchronizationManager.hasResource(factory));
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
boolean condition1 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition1).isTrue();
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
verify(manager).flush();
verify(tx).rollback();
@@ -244,13 +263,15 @@ public class JpaTransactionManagerTests {
final List<String> l = new ArrayList<>();
l.add("test");
assertTrue(!TransactionSynchronizationManager.hasResource(factory));
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
boolean condition3 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition3).isTrue();
boolean condition2 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition2).isTrue();
tt.execute(new TransactionCallback() {
@Override
public Object doInTransaction(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.hasResource(factory));
assertThat(TransactionSynchronizationManager.hasResource(factory)).isTrue();
return tt.execute(new TransactionCallback() {
@Override
@@ -262,8 +283,10 @@ public class JpaTransactionManagerTests {
}
});
assertTrue(!TransactionSynchronizationManager.hasResource(factory));
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
boolean condition1 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition1).isTrue();
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
verify(manager).flush();
verify(tx).commit();
@@ -278,14 +301,16 @@ public class JpaTransactionManagerTests {
final List<String> l = new ArrayList<>();
l.add("test");
assertTrue(!TransactionSynchronizationManager.hasResource(factory));
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
boolean condition3 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition3).isTrue();
boolean condition2 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition2).isTrue();
assertThatExceptionOfType(RuntimeException.class).isThrownBy(() ->
tt.execute(new TransactionCallback() {
@Override
public Object doInTransaction(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.hasResource(factory));
assertThat(TransactionSynchronizationManager.hasResource(factory)).isTrue();
return tt.execute(new TransactionCallback() {
@Override
public Object doInTransaction(TransactionStatus status) {
@@ -296,8 +321,10 @@ public class JpaTransactionManagerTests {
}
}));
assertTrue(!TransactionSynchronizationManager.hasResource(factory));
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
boolean condition1 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition1).isTrue();
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
verify(tx).setRollbackOnly();
verify(tx).rollback();
@@ -314,14 +341,16 @@ public class JpaTransactionManagerTests {
final List<String> l = new ArrayList<>();
l.add("test");
assertTrue(!TransactionSynchronizationManager.hasResource(factory));
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
boolean condition3 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition3).isTrue();
boolean condition2 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition2).isTrue();
assertThatExceptionOfType(TransactionSystemException.class).isThrownBy(() ->
tt.execute(new TransactionCallback() {
@Override
public Object doInTransaction(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.hasResource(factory));
assertThat(TransactionSynchronizationManager.hasResource(factory)).isTrue();
return tt.execute(new TransactionCallback() {
@Override
@@ -335,8 +364,10 @@ public class JpaTransactionManagerTests {
}))
.withCauseInstanceOf(RollbackException.class);
assertTrue(!TransactionSynchronizationManager.hasResource(factory));
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
boolean condition1 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition1).isTrue();
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
verify(manager).flush();
verify(tx).setRollbackOnly();
@@ -354,13 +385,15 @@ public class JpaTransactionManagerTests {
final List<String> l = new ArrayList<>();
l.add("test");
assertTrue(!TransactionSynchronizationManager.hasResource(factory));
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
boolean condition3 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition3).isTrue();
boolean condition2 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition2).isTrue();
Object result = tt.execute(new TransactionCallback() {
@Override
public Object doInTransaction(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.hasResource(factory));
assertThat(TransactionSynchronizationManager.hasResource(factory)).isTrue();
return tt.execute(new TransactionCallback() {
@Override
public Object doInTransaction(TransactionStatus status) {
@@ -370,10 +403,12 @@ public class JpaTransactionManagerTests {
});
}
});
assertSame(l, result);
assertThat(result).isSameAs(l);
assertTrue(!TransactionSynchronizationManager.hasResource(factory));
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
boolean condition1 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition1).isTrue();
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
verify(manager).flush();
verify(manager, times(2)).close();
@@ -389,8 +424,10 @@ public class JpaTransactionManagerTests {
final List<String> l = new ArrayList<>();
l.add("test");
assertTrue(!TransactionSynchronizationManager.hasResource(factory));
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
boolean condition3 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition3).isTrue();
boolean condition2 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition2).isTrue();
TransactionSynchronizationManager.bindResource(factory, new EntityManagerHolder(manager));
@@ -400,7 +437,7 @@ public class JpaTransactionManagerTests {
public Object doInTransaction(TransactionStatus status) {
EntityManagerFactoryUtils.getTransactionalEntityManager(factory);
assertTrue(TransactionSynchronizationManager.hasResource(factory));
assertThat(TransactionSynchronizationManager.hasResource(factory)).isTrue();
return tt.execute(new TransactionCallback() {
@Override
public Object doInTransaction(TransactionStatus status) {
@@ -410,14 +447,16 @@ public class JpaTransactionManagerTests {
});
}
});
assertSame(l, result);
assertThat(result).isSameAs(l);
}
finally {
TransactionSynchronizationManager.unbindResource(factory);
}
assertTrue(!TransactionSynchronizationManager.hasResource(factory));
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
boolean condition1 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition1).isTrue();
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
verify(tx, times(2)).begin();
verify(tx, times(2)).commit();
@@ -434,13 +473,15 @@ public class JpaTransactionManagerTests {
final List<String> l = new ArrayList<>();
l.add("test");
assertTrue(!TransactionSynchronizationManager.hasResource(factory));
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
boolean condition3 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition3).isTrue();
boolean condition2 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition2).isTrue();
Object result = tt.execute(new TransactionCallback() {
@Override
public Object doInTransaction(TransactionStatus status) {
assertFalse(TransactionSynchronizationManager.hasResource(factory));
assertThat(TransactionSynchronizationManager.hasResource(factory)).isFalse();
TransactionTemplate tt2 = new TransactionTemplate(tm);
tt2.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
return tt2.execute(new TransactionCallback() {
@@ -452,10 +493,12 @@ public class JpaTransactionManagerTests {
});
}
});
assertSame(l, result);
assertThat(result).isSameAs(l);
assertTrue(!TransactionSynchronizationManager.hasResource(factory));
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
boolean condition1 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition1).isTrue();
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
verify(tx).commit();
verify(manager).flush();
@@ -473,15 +516,17 @@ public class JpaTransactionManagerTests {
final List<String> l = new ArrayList<>();
l.add("test");
assertTrue(!TransactionSynchronizationManager.hasResource(factory));
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
boolean condition3 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition3).isTrue();
boolean condition2 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition2).isTrue();
Object result = tt.execute(new TransactionCallback() {
@Override
public Object doInTransaction(TransactionStatus status) {
EntityManagerFactoryUtils.getTransactionalEntityManager(factory);
assertTrue(TransactionSynchronizationManager.hasResource(factory));
assertThat(TransactionSynchronizationManager.hasResource(factory)).isTrue();
TransactionTemplate tt2 = new TransactionTemplate(tm);
tt2.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
return tt2.execute(new TransactionCallback() {
@@ -493,10 +538,12 @@ public class JpaTransactionManagerTests {
});
}
});
assertSame(l, result);
assertThat(result).isSameAs(l);
assertTrue(!TransactionSynchronizationManager.hasResource(factory));
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
boolean condition1 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition1).isTrue();
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
verify(tx).commit();
verify(manager).flush();
@@ -515,8 +562,10 @@ public class JpaTransactionManagerTests {
given(manager2.getTransaction()).willReturn(tx2);
given(manager2.isOpen()).willReturn(true);
assertTrue(!TransactionSynchronizationManager.hasResource(factory));
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
boolean condition3 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition3).isTrue();
boolean condition2 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition2).isTrue();
tt.execute(new TransactionCallback() {
@Override
@@ -538,8 +587,10 @@ public class JpaTransactionManagerTests {
}
});
assertTrue(!TransactionSynchronizationManager.hasResource(factory));
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
boolean condition1 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition1).isTrue();
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
verify(tx).commit();
verify(tx2).begin();
@@ -559,23 +610,29 @@ public class JpaTransactionManagerTests {
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);
assertTrue(!TransactionSynchronizationManager.hasResource(factory));
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
boolean condition3 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition3).isTrue();
boolean condition2 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition2).isTrue();
Object result = tt.execute(new TransactionCallback() {
@Override
public Object doInTransaction(TransactionStatus status) {
assertTrue(!TransactionSynchronizationManager.hasResource(factory));
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertTrue(!status.isNewTransaction());
boolean condition1 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition1).isTrue();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
boolean condition = !status.isNewTransaction();
assertThat(condition).isTrue();
EntityManagerFactoryUtils.getTransactionalEntityManager(factory).flush();
return l;
}
});
assertSame(l, result);
assertThat(result).isSameAs(l);
assertTrue(!TransactionSynchronizationManager.hasResource(factory));
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
boolean condition1 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition1).isTrue();
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
verify(manager).flush();
verify(manager).close();
@@ -587,23 +644,29 @@ public class JpaTransactionManagerTests {
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);
assertTrue(!TransactionSynchronizationManager.hasResource(factory));
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
boolean condition3 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition3).isTrue();
boolean condition2 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition2).isTrue();
tt.execute(new TransactionCallback() {
@Override
public Object doInTransaction(TransactionStatus status) {
assertTrue(!TransactionSynchronizationManager.hasResource(factory));
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertTrue(!status.isNewTransaction());
boolean condition1 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition1).isTrue();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
boolean condition = !status.isNewTransaction();
assertThat(condition).isTrue();
EntityManagerFactoryUtils.getTransactionalEntityManager(factory).flush();
status.setRollbackOnly();
return null;
}
});
assertTrue(!TransactionSynchronizationManager.hasResource(factory));
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
boolean condition1 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition1).isTrue();
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
verify(manager).flush();
verify(manager).close();
@@ -616,24 +679,27 @@ public class JpaTransactionManagerTests {
final List<String> l = new ArrayList<>();
l.add("test");
assertTrue(!TransactionSynchronizationManager.hasResource(factory));
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
boolean condition2 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition2).isTrue();
boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition1).isTrue();
TransactionSynchronizationManager.bindResource(factory, new EntityManagerHolder(manager));
try {
Object result = tt.execute(new TransactionCallback() {
@Override
public Object doInTransaction(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.hasResource(factory));
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
EntityManagerFactoryUtils.getTransactionalEntityManager(factory);
return l;
}
});
assertSame(l, result);
assertThat(result).isSameAs(l);
assertTrue(TransactionSynchronizationManager.hasResource(factory));
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.hasResource(factory)).isTrue();
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
}
finally {
TransactionSynchronizationManager.unbindResource(factory);
@@ -648,24 +714,27 @@ public class JpaTransactionManagerTests {
given(manager.getTransaction()).willReturn(tx);
given(tx.isActive()).willReturn(true);
assertTrue(!TransactionSynchronizationManager.hasResource(factory));
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
boolean condition2 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition2).isTrue();
boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition1).isTrue();
TransactionSynchronizationManager.bindResource(factory, new EntityManagerHolder(manager));
try {
tt.execute(new TransactionCallback() {
@Override
public Object doInTransaction(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.hasResource(factory));
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
EntityManagerFactoryUtils.getTransactionalEntityManager(factory);
status.setRollbackOnly();
return null;
}
});
assertTrue(TransactionSynchronizationManager.hasResource(factory));
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.hasResource(factory)).isTrue();
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
}
finally {
TransactionSynchronizationManager.unbindResource(factory);
@@ -683,25 +752,29 @@ public class JpaTransactionManagerTests {
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);
assertTrue(!TransactionSynchronizationManager.hasResource(factory));
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
boolean condition2 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition2).isTrue();
boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition1).isTrue();
TransactionSynchronizationManager.bindResource(factory, new EntityManagerHolder(manager));
try {
Object result = tt.execute(new TransactionCallback() {
@Override
public Object doInTransaction(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.hasResource(factory));
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertTrue(!status.isNewTransaction());
assertThat(TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
boolean condition = !status.isNewTransaction();
assertThat(condition).isTrue();
EntityManagerFactoryUtils.getTransactionalEntityManager(factory).flush();
return l;
}
});
assertSame(l, result);
assertThat(result).isSameAs(l);
assertTrue(TransactionSynchronizationManager.hasResource(factory));
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.hasResource(factory)).isTrue();
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
}
finally {
TransactionSynchronizationManager.unbindResource(factory);
@@ -714,25 +787,29 @@ public class JpaTransactionManagerTests {
public void testTransactionRollbackWithPreboundAndPropagationSupports() {
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);
assertTrue(!TransactionSynchronizationManager.hasResource(factory));
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
boolean condition2 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition2).isTrue();
boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition1).isTrue();
TransactionSynchronizationManager.bindResource(factory, new EntityManagerHolder(manager));
try {
tt.execute(new TransactionCallback() {
@Override
public Object doInTransaction(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.hasResource(factory));
assertTrue(TransactionSynchronizationManager.isSynchronizationActive());
assertTrue(!status.isNewTransaction());
assertThat(TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
boolean condition = !status.isNewTransaction();
assertThat(condition).isTrue();
EntityManagerFactoryUtils.getTransactionalEntityManager(factory).flush();
status.setRollbackOnly();
return null;
}
});
assertTrue(TransactionSynchronizationManager.hasResource(factory));
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.hasResource(factory)).isTrue();
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
}
finally {
TransactionSynchronizationManager.unbindResource(factory);
@@ -762,19 +839,23 @@ public class JpaTransactionManagerTests {
public void testTransactionFlush() {
given(manager.getTransaction()).willReturn(tx);
assertTrue(!TransactionSynchronizationManager.hasResource(factory));
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
boolean condition3 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition3).isTrue();
boolean condition2 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition2).isTrue();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
public void doInTransactionWithoutResult(TransactionStatus status) {
assertTrue(TransactionSynchronizationManager.hasResource(factory));
assertThat(TransactionSynchronizationManager.hasResource(factory)).isTrue();
status.flush();
}
});
assertTrue(!TransactionSynchronizationManager.hasResource(factory));
assertTrue(!TransactionSynchronizationManager.isSynchronizationActive());
boolean condition1 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition1).isTrue();
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
verify(tx).commit();
verify(manager).flush();

52
spring-orm/src/test/java/org/springframework/orm/jpa/LocalContainerEntityManagerFactoryBeanTests.java
View File

@@ -39,15 +39,9 @@ import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.interceptor.DefaultTransactionAttribute;
import org.springframework.util.SerializationTestUtils;
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.assertNotNull;
import static org.junit.Assert.assertNotSame;
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.BDDMockito.willThrow;
import static org.mockito.Mockito.mock;
@@ -77,31 +71,31 @@ public class LocalContainerEntityManagerFactoryBeanTests extends AbstractEntityM
public void testExceptionTranslationWithNoDialect() throws Exception {
LocalContainerEntityManagerFactoryBean cefb = parseValidPersistenceUnit();
cefb.getObject();
assertNull("No dialect set", cefb.getJpaDialect());
assertThat(cefb.getJpaDialect()).as("No dialect set").isNull();
RuntimeException in1 = new RuntimeException("in1");
PersistenceException in2 = new PersistenceException();
assertNull("No translation here", cefb.translateExceptionIfPossible(in1));
assertThat(cefb.translateExceptionIfPossible(in1)).as("No translation here").isNull();
DataAccessException dex = cefb.translateExceptionIfPossible(in2);
assertNotNull(dex);
assertSame(in2, dex.getCause());
assertThat(dex).isNotNull();
assertThat(dex.getCause()).isSameAs(in2);
}
@Test
public void testEntityManagerFactoryIsProxied() throws Exception {
LocalContainerEntityManagerFactoryBean cefb = parseValidPersistenceUnit();
EntityManagerFactory emf = cefb.getObject();
assertSame("EntityManagerFactory reference must be cached after init", emf, cefb.getObject());
assertThat(cefb.getObject()).as("EntityManagerFactory reference must be cached after init").isSameAs(emf);
assertNotSame("EMF must be proxied", mockEmf, emf);
assertTrue(emf.equals(emf));
assertThat(emf).as("EMF must be proxied").isNotSameAs(mockEmf);
assertThat(emf.equals(emf)).isTrue();
DefaultListableBeanFactory bf = new DefaultListableBeanFactory();
bf.setSerializationId("emf-bf");
bf.registerSingleton("emf", cefb);
cefb.setBeanFactory(bf);
cefb.setBeanName("emf");
assertNotNull(SerializationTestUtils.serializeAndDeserialize(emf));
assertThat(SerializationTestUtils.serializeAndDeserialize(emf)).isNotNull();
}
@Test
@@ -113,11 +107,11 @@ public class LocalContainerEntityManagerFactoryBeanTests extends AbstractEntityM
LocalContainerEntityManagerFactoryBean cefb = parseValidPersistenceUnit();
EntityManagerFactory emf = cefb.getObject();
assertSame("EntityManagerFactory reference must be cached after init", emf, cefb.getObject());
assertThat(cefb.getObject()).as("EntityManagerFactory reference must be cached after init").isSameAs(emf);
assertNotSame("EMF must be proxied", mockEmf, emf);
assertThat(emf).as("EMF must be proxied").isNotSameAs(mockEmf);
EntityManager em = emf.createEntityManager();
assertFalse(em.contains(testEntity));
assertThat(em.contains(testEntity)).isFalse();
cefb.destroy();
@@ -148,12 +142,12 @@ public class LocalContainerEntityManagerFactoryBeanTests extends AbstractEntityM
TransactionStatus txStatus = jpatm.getTransaction(new DefaultTransactionAttribute());
EntityManagerFactory emf = cefb.getObject();
assertSame("EntityManagerFactory reference must be cached after init", emf, cefb.getObject());
assertThat(cefb.getObject()).as("EntityManagerFactory reference must be cached after init").isSameAs(emf);
assertNotSame("EMF must be proxied", mockEmf, emf);
assertThat(emf).as("EMF must be proxied").isNotSameAs(mockEmf);
EntityManager em = emf.createEntityManager();
em.joinTransaction();
assertFalse(em.contains(testEntity));
assertThat(em.contains(testEntity)).isFalse();
jpatm.commit(txStatus);
@@ -190,12 +184,12 @@ public class LocalContainerEntityManagerFactoryBeanTests extends AbstractEntityM
TransactionStatus txStatus = jpatm.getTransaction(new DefaultTransactionAttribute());
EntityManagerFactory emf = cefb.getObject();
assertSame("EntityManagerFactory reference must be cached after init", emf, cefb.getObject());
assertThat(cefb.getObject()).as("EntityManagerFactory reference must be cached after init").isSameAs(emf);
assertNotSame("EMF must be proxied", mockEmf, emf);
assertThat(emf).as("EMF must be proxied").isNotSameAs(mockEmf);
EntityManager em = emf.createEntityManager();
em.joinTransaction();
assertFalse(em.contains(testEntity));
assertThat(em.contains(testEntity)).isFalse();
assertThatExceptionOfType(OptimisticLockingFailureException.class).isThrownBy(() ->
jpatm.commit(txStatus));
@@ -230,12 +224,12 @@ public class LocalContainerEntityManagerFactoryBeanTests extends AbstractEntityM
TransactionStatus txStatus = jpatm.getTransaction(new DefaultTransactionAttribute());
EntityManagerFactory emf = cefb.getObject();
assertSame("EntityManagerFactory reference must be cached after init", emf, cefb.getObject());
assertThat(cefb.getObject()).as("EntityManagerFactory reference must be cached after init").isSameAs(emf);
assertNotSame("EMF must be proxied", mockEmf, emf);
assertThat(emf).as("EMF must be proxied").isNotSameAs(mockEmf);
EntityManager em = emf.createEntityManager();
em.joinTransaction();
assertFalse(em.contains(testEntity));
assertThat(em.contains(testEntity)).isFalse();
jpatm.commit(txStatus);
@@ -277,9 +271,9 @@ public class LocalContainerEntityManagerFactoryBeanTests extends AbstractEntityM
containerEmfb.setPersistenceXmlLocation(persistenceXml);
containerEmfb.afterPropertiesSet();
assertEquals(entityManagerName, actualPui.getPersistenceUnitName());
assertThat(actualPui.getPersistenceUnitName()).isEqualTo(entityManagerName);
if (props != null) {
assertEquals(props, actualProps);
assertThat((Object) actualProps).isEqualTo(props);
}
//checkInvariants(containerEmfb);

7
spring-orm/src/test/java/org/springframework/orm/jpa/LocalEntityManagerFactoryBeanTests.java
View File

@@ -26,8 +26,7 @@ import javax.persistence.spi.ProviderUtil;
import org.junit.After;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertSame;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.verify;
/**
@@ -73,9 +72,9 @@ public class LocalEntityManagerFactoryBeanTests extends AbstractEntityManagerFac
}
lemfb.afterPropertiesSet();
assertSame(entityManagerName, actualName);
assertThat(actualName).isSameAs(entityManagerName);
if (props != null) {
assertEquals(props, actualProps);
assertThat((Object) actualProps).isEqualTo(props);
}
checkInvariants(lemfb);

9
spring-orm/src/test/java/org/springframework/orm/jpa/SharedEntityManagerCreatorTests.java
View File

@@ -30,7 +30,6 @@ import org.mockito.junit.MockitoJUnitRunner;
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.mockito.BDDMockito.given;
import static org.mockito.BDDMockito.willReturn;
import static org.mockito.Mockito.mock;
@@ -184,10 +183,10 @@ public class SharedEntityManagerCreatorTests {
spq.registerStoredProcedureParameter(1, Number.class, ParameterMode.IN);
spq.registerStoredProcedureParameter(2, Object.class, ParameterMode.INOUT);
spq.execute();
assertEquals("y", spq.getOutputParameterValue(0));
assertThat(spq.getOutputParameterValue(0)).isEqualTo("y");
assertThatIllegalArgumentException().isThrownBy(() ->
spq.getOutputParameterValue(1));
assertEquals("z", spq.getOutputParameterValue(2));
assertThat(spq.getOutputParameterValue(2)).isEqualTo("z");
verify(query).registerStoredProcedureParameter(0, String.class, ParameterMode.OUT);
verify(query).registerStoredProcedureParameter(1, Number.class, ParameterMode.IN);
@@ -215,10 +214,10 @@ public class SharedEntityManagerCreatorTests {
spq.registerStoredProcedureParameter("b", Number.class, ParameterMode.IN);
spq.registerStoredProcedureParameter("c", Object.class, ParameterMode.INOUT);
spq.execute();
assertEquals("y", spq.getOutputParameterValue("a"));
assertThat(spq.getOutputParameterValue("a")).isEqualTo("y");
assertThatIllegalArgumentException().isThrownBy(() ->
spq.getOutputParameterValue("b"));
assertEquals("z", spq.getOutputParameterValue("c"));
assertThat(spq.getOutputParameterValue("c")).isEqualTo("z");
verify(query).registerStoredProcedureParameter("a", String.class, ParameterMode.OUT);
verify(query).registerStoredProcedureParameter("b", Number.class, ParameterMode.IN);

10
spring-orm/src/test/java/org/springframework/orm/jpa/eclipselink/EclipseLinkEntityManagerFactoryIntegrationTests.java
View File

@@ -22,8 +22,7 @@ import org.junit.Test;
import org.springframework.orm.jpa.AbstractContainerEntityManagerFactoryIntegrationTests;
import org.springframework.orm.jpa.EntityManagerFactoryInfo;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
/**
* EclipseLink-specific JPA tests.
@@ -35,14 +34,15 @@ public class EclipseLinkEntityManagerFactoryIntegrationTests extends AbstractCon
@Test
public void testCanCastNativeEntityManagerFactoryToEclipseLinkEntityManagerFactoryImpl() {
EntityManagerFactoryInfo emfi = (EntityManagerFactoryInfo) entityManagerFactory;
assertTrue(emfi.getNativeEntityManagerFactory().getClass().getName().endsWith("EntityManagerFactoryImpl"));
assertThat(emfi.getNativeEntityManagerFactory().getClass().getName().endsWith("EntityManagerFactoryImpl")).isTrue();
}
@Test
public void testCanCastSharedEntityManagerProxyToEclipseLinkEntityManager() {
assertTrue(sharedEntityManager instanceof JpaEntityManager);
boolean condition = sharedEntityManager instanceof JpaEntityManager;
assertThat(condition).isTrue();
JpaEntityManager eclipselinkEntityManager = (JpaEntityManager) sharedEntityManager;
assertNotNull(eclipselinkEntityManager.getActiveSession());
assertThat(eclipselinkEntityManager.getActiveSession()).isNotNull();
}
}

38
spring-orm/src/test/java/org/springframework/orm/jpa/hibernate/HibernateEntityManagerFactoryIntegrationTests.java
View File

@@ -29,9 +29,7 @@ import org.springframework.orm.jpa.AbstractContainerEntityManagerFactoryIntegrat
import org.springframework.orm.jpa.EntityManagerFactoryInfo;
import org.springframework.orm.jpa.EntityManagerProxy;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Hibernate-specific JPA tests.
@@ -52,37 +50,45 @@ public class HibernateEntityManagerFactoryIntegrationTests extends AbstractConta
@Test
public void testCanCastNativeEntityManagerFactoryToHibernateEntityManagerFactoryImpl() {
EntityManagerFactoryInfo emfi = (EntityManagerFactoryInfo) entityManagerFactory;
assertTrue(emfi.getNativeEntityManagerFactory() instanceof org.hibernate.jpa.HibernateEntityManagerFactory);
assertTrue(emfi.getNativeEntityManagerFactory() instanceof SessionFactory); // as of Hibernate 5.2
boolean condition1 = emfi.getNativeEntityManagerFactory() instanceof org.hibernate.jpa.HibernateEntityManagerFactory;
assertThat(condition1).isTrue();
// as of Hibernate 5.2
boolean condition = emfi.getNativeEntityManagerFactory() instanceof SessionFactory;
assertThat(condition).isTrue();
}
@Test
public void testCanCastSharedEntityManagerProxyToHibernateEntityManager() {
assertTrue(sharedEntityManager instanceof org.hibernate.jpa.HibernateEntityManager);
assertTrue(((EntityManagerProxy) sharedEntityManager).getTargetEntityManager() instanceof Session); // as of Hibernate 5.2
boolean condition1 = sharedEntityManager instanceof org.hibernate.jpa.HibernateEntityManager;
assertThat(condition1).isTrue();
// as of Hibernate 5.2
boolean condition = ((EntityManagerProxy) sharedEntityManager).getTargetEntityManager() instanceof Session;
assertThat(condition).isTrue();
}
@Test
public void testCanUnwrapAopProxy() {
EntityManager em = entityManagerFactory.createEntityManager();
EntityManager proxy = ProxyFactory.getProxy(EntityManager.class, new SingletonTargetSource(em));
assertTrue(em instanceof org.hibernate.jpa.HibernateEntityManager);
assertFalse(proxy instanceof org.hibernate.jpa.HibernateEntityManager);
assertTrue(proxy.unwrap(org.hibernate.jpa.HibernateEntityManager.class) != null);
assertSame(em, proxy.unwrap(org.hibernate.jpa.HibernateEntityManager.class));
assertSame(em.getDelegate(), proxy.getDelegate());
boolean condition = em instanceof org.hibernate.jpa.HibernateEntityManager;
assertThat(condition).isTrue();
boolean condition1 = proxy instanceof org.hibernate.jpa.HibernateEntityManager;
assertThat(condition1).isFalse();
assertThat(proxy.unwrap(org.hibernate.jpa.HibernateEntityManager.class) != null).isTrue();
assertThat(proxy.unwrap(org.hibernate.jpa.HibernateEntityManager.class)).isSameAs(em);
assertThat(proxy.getDelegate()).isSameAs(em.getDelegate());
}
@Test // SPR-16956
public void testReadOnly() {
assertSame(FlushMode.AUTO, sharedEntityManager.unwrap(Session.class).getHibernateFlushMode());
assertFalse(sharedEntityManager.unwrap(Session.class).isDefaultReadOnly());
assertThat(sharedEntityManager.unwrap(Session.class).getHibernateFlushMode()).isSameAs(FlushMode.AUTO);
assertThat(sharedEntityManager.unwrap(Session.class).isDefaultReadOnly()).isFalse();
endTransaction();
this.transactionDefinition.setReadOnly(true);
startNewTransaction();
assertSame(FlushMode.MANUAL, sharedEntityManager.unwrap(Session.class).getHibernateFlushMode());
assertTrue(sharedEntityManager.unwrap(Session.class).isDefaultReadOnly());
assertThat(sharedEntityManager.unwrap(Session.class).getHibernateFlushMode()).isSameAs(FlushMode.MANUAL);
assertThat(sharedEntityManager.unwrap(Session.class).isDefaultReadOnly()).isTrue();
}
}

13
spring-orm/src/test/java/org/springframework/orm/jpa/hibernate/HibernateMultiEntityManagerFactoryIntegrationTests.java
View File

@@ -25,10 +25,8 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.jpa.AbstractContainerEntityManagerFactoryIntegrationTests;
import org.springframework.orm.jpa.EntityManagerFactoryInfo;
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.assertTrue;
/**
* Hibernate-specific JPA tests with multiple EntityManagerFactory instances.
@@ -50,11 +48,12 @@ public class HibernateMultiEntityManagerFactoryIntegrationTests extends Abstract
@Test
public void testEntityManagerFactoryImplementsEntityManagerFactoryInfo() {
assertTrue("Must have introduced config interface", this.entityManagerFactory instanceof EntityManagerFactoryInfo);
boolean condition = this.entityManagerFactory instanceof EntityManagerFactoryInfo;
assertThat(condition).as("Must have introduced config interface").isTrue();
EntityManagerFactoryInfo emfi = (EntityManagerFactoryInfo) this.entityManagerFactory;
assertEquals("Drivers", emfi.getPersistenceUnitName());
assertNotNull("PersistenceUnitInfo must be available", emfi.getPersistenceUnitInfo());
assertNotNull("Raw EntityManagerFactory must be available", emfi.getNativeEntityManagerFactory());
assertThat(emfi.getPersistenceUnitName()).isEqualTo("Drivers");
assertThat(emfi.getPersistenceUnitInfo()).as("PersistenceUnitInfo must be available").isNotNull();
assertThat(emfi.getNativeEntityManagerFactory()).as("Raw EntityManagerFactory must be available").isNotNull();
}
@Test

28
spring-orm/src/test/java/org/springframework/orm/jpa/hibernate/HibernateNativeEntityManagerFactoryIntegrationTests.java
View File

@@ -29,10 +29,7 @@ import org.springframework.orm.jpa.AbstractContainerEntityManagerFactoryIntegrat
import org.springframework.orm.jpa.EntityManagerFactoryInfo;
import org.springframework.orm.jpa.domain.Person;
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.assertj.core.api.Assertions.assertThat;
/**
* Hibernate-specific JPA tests with native SessionFactory setup and getCurrentSession interaction.
@@ -58,7 +55,8 @@ public class HibernateNativeEntityManagerFactoryIntegrationTests extends Abstrac
@Test
public void testEntityManagerFactoryImplementsEntityManagerFactoryInfo() {
assertFalse("Must not have introduced config interface", entityManagerFactory instanceof EntityManagerFactoryInfo);
boolean condition = entityManagerFactory instanceof EntityManagerFactoryInfo;
assertThat(condition).as("Must not have introduced config interface").isFalse();
}
@Test
@@ -68,9 +66,9 @@ public class HibernateNativeEntityManagerFactoryIntegrationTests extends Abstrac
insertPerson(firstName);
List<Person> people = sharedEntityManager.createQuery("select p from Person as p").getResultList();
assertEquals(1, people.size());
assertEquals(firstName, people.get(0).getFirstName());
assertSame(applicationContext, people.get(0).postLoaded);
assertThat(people.size()).isEqualTo(1);
assertThat(people.get(0).getFirstName()).isEqualTo(firstName);
assertThat(people.get(0).postLoaded).isSameAs(applicationContext);
}
@Test
@@ -81,21 +79,21 @@ public class HibernateNativeEntityManagerFactoryIntegrationTests extends Abstrac
Query q = sessionFactory.getCurrentSession().createQuery("select p from Person as p");
List<Person> people = q.getResultList();
assertEquals(1, people.size());
assertEquals(firstName, people.get(0).getFirstName());
assertSame(applicationContext, people.get(0).postLoaded);
assertThat(people.size()).isEqualTo(1);
assertThat(people.get(0).getFirstName()).isEqualTo(firstName);
assertThat(people.get(0).postLoaded).isSameAs(applicationContext);
}
@Test // SPR-16956
public void testReadOnly() {
assertSame(FlushMode.AUTO, sessionFactory.getCurrentSession().getHibernateFlushMode());
assertFalse(sessionFactory.getCurrentSession().isDefaultReadOnly());
assertThat(sessionFactory.getCurrentSession().getHibernateFlushMode()).isSameAs(FlushMode.AUTO);
assertThat(sessionFactory.getCurrentSession().isDefaultReadOnly()).isFalse();
endTransaction();
this.transactionDefinition.setReadOnly(true);
startNewTransaction();
assertSame(FlushMode.MANUAL, sessionFactory.getCurrentSession().getHibernateFlushMode());
assertTrue(sessionFactory.getCurrentSession().isDefaultReadOnly());
assertThat(sessionFactory.getCurrentSession().getHibernateFlushMode()).isSameAs(FlushMode.MANUAL);
assertThat(sessionFactory.getCurrentSession().isDefaultReadOnly()).isTrue();
}
}

116
spring-orm/src/test/java/org/springframework/orm/jpa/hibernate/HibernateNativeEntityManagerFactorySpringBeanContainerIntegrationTests.java
View File

@@ -35,12 +35,8 @@ import org.springframework.orm.jpa.hibernate.beans.MultiplePrototypesInSpringCon
import org.springframework.orm.jpa.hibernate.beans.NoDefinitionInSpringContextTestBean;
import org.springframework.orm.jpa.hibernate.beans.SinglePrototypeInSpringContextTestBean;
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.assertNotSame;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
/**
* Hibernate-specific SpringBeanContainer integration tests.
@@ -75,96 +71,96 @@ public class HibernateNativeEntityManagerFactorySpringBeanContainerIntegrationTe
@Test
public void testCanRetrieveBeanByTypeWithJpaCompliantOptions() {
BeanContainer beanContainer = getBeanContainer();
assertNotNull(beanContainer);
assertThat(beanContainer).isNotNull();
ContainedBean<SinglePrototypeInSpringContextTestBean> bean = beanContainer.getBean(
SinglePrototypeInSpringContextTestBean.class,
JpaLifecycleOptions.INSTANCE, IneffectiveBeanInstanceProducer.INSTANCE
);
assertNotNull(bean);
assertThat(bean).isNotNull();
SinglePrototypeInSpringContextTestBean instance = bean.getBeanInstance();
assertNotNull(instance);
assertSame(applicationContext, instance.getApplicationContext());
assertThat(instance).isNotNull();
assertThat(instance.getApplicationContext()).isSameAs(applicationContext);
}
@Test
public void testCanRetrieveBeanByNameWithJpaCompliantOptions() {
BeanContainer beanContainer = getBeanContainer();
assertNotNull(beanContainer);
assertThat(beanContainer).isNotNull();
ContainedBean<MultiplePrototypesInSpringContextTestBean> bean = beanContainer.getBean(
"multiple-1", MultiplePrototypesInSpringContextTestBean.class,
JpaLifecycleOptions.INSTANCE, IneffectiveBeanInstanceProducer.INSTANCE
);
assertNotNull(bean);
assertThat(bean).isNotNull();
MultiplePrototypesInSpringContextTestBean instance = bean.getBeanInstance();
assertNotNull(instance);
assertEquals("multiple-1", instance.getName());
assertSame(applicationContext, instance.getApplicationContext());
assertThat(instance).isNotNull();
assertThat(instance.getName()).isEqualTo("multiple-1");
assertThat(instance.getApplicationContext()).isSameAs(applicationContext);
}
@Test
public void testCanRetrieveBeanByTypeWithNativeOptions() {
BeanContainer beanContainer = getBeanContainer();
assertNotNull(beanContainer);
assertThat(beanContainer).isNotNull();
ContainedBean<SinglePrototypeInSpringContextTestBean> bean = beanContainer.getBean(
SinglePrototypeInSpringContextTestBean.class,
NativeLifecycleOptions.INSTANCE, IneffectiveBeanInstanceProducer.INSTANCE
);
assertNotNull(bean);
assertThat(bean).isNotNull();
SinglePrototypeInSpringContextTestBean instance = bean.getBeanInstance();
assertNotNull(instance);
assertEquals("single", instance.getName());
assertSame(applicationContext, instance.getApplicationContext());
assertThat(instance).isNotNull();
assertThat(instance.getName()).isEqualTo("single");
assertThat(instance.getApplicationContext()).isSameAs(applicationContext);
ContainedBean<SinglePrototypeInSpringContextTestBean> bean2 = beanContainer.getBean(
SinglePrototypeInSpringContextTestBean.class,
NativeLifecycleOptions.INSTANCE, IneffectiveBeanInstanceProducer.INSTANCE
);
assertNotNull(bean2);
assertThat(bean2).isNotNull();
SinglePrototypeInSpringContextTestBean instance2 = bean2.getBeanInstance();
assertNotNull(instance2);
assertThat(instance2).isNotNull();
// Due to the lifecycle options, and because the bean has the "prototype" scope, we should not return the same instance
assertNotSame(instance, instance2);
assertThat(instance2).isNotSameAs(instance);
}
@Test
public void testCanRetrieveBeanByNameWithNativeOptions() {
BeanContainer beanContainer = getBeanContainer();
assertNotNull(beanContainer);
assertThat(beanContainer).isNotNull();
ContainedBean<MultiplePrototypesInSpringContextTestBean> bean = beanContainer.getBean(
"multiple-1", MultiplePrototypesInSpringContextTestBean.class,
NativeLifecycleOptions.INSTANCE, IneffectiveBeanInstanceProducer.INSTANCE
);
assertNotNull(bean);
assertThat(bean).isNotNull();
MultiplePrototypesInSpringContextTestBean instance = bean.getBeanInstance();
assertNotNull(instance);
assertEquals("multiple-1", instance.getName());
assertSame(applicationContext, instance.getApplicationContext());
assertThat(instance).isNotNull();
assertThat(instance.getName()).isEqualTo("multiple-1");
assertThat(instance.getApplicationContext()).isSameAs(applicationContext);
ContainedBean<MultiplePrototypesInSpringContextTestBean> bean2 = beanContainer.getBean(
"multiple-1", MultiplePrototypesInSpringContextTestBean.class,
NativeLifecycleOptions.INSTANCE, IneffectiveBeanInstanceProducer.INSTANCE
);
assertNotNull(bean2);
assertThat(bean2).isNotNull();
MultiplePrototypesInSpringContextTestBean instance2 = bean2.getBeanInstance();
assertNotNull(instance2);
assertThat(instance2).isNotNull();
// Due to the lifecycle options, and because the bean has the "prototype" scope, we should not return the same instance
assertNotSame(instance, instance2);
assertThat(instance2).isNotSameAs(instance);
}
@Test
public void testCanRetrieveFallbackBeanByTypeWithJpaCompliantOptions() {
BeanContainer beanContainer = getBeanContainer();
assertNotNull(beanContainer);
assertThat(beanContainer).isNotNull();
NoDefinitionInSpringContextTestBeanInstanceProducer fallbackProducer = new NoDefinitionInSpringContextTestBeanInstanceProducer();
ContainedBean<NoDefinitionInSpringContextTestBean> bean = beanContainer.getBean(
@@ -172,20 +168,20 @@ public class HibernateNativeEntityManagerFactorySpringBeanContainerIntegrationTe
JpaLifecycleOptions.INSTANCE, fallbackProducer
);
assertEquals(1, fallbackProducer.currentUnnamedInstantiationCount());
assertEquals(0, fallbackProducer.currentNamedInstantiationCount());
assertThat(fallbackProducer.currentUnnamedInstantiationCount()).isEqualTo(1);
assertThat(fallbackProducer.currentNamedInstantiationCount()).isEqualTo(0);
assertNotNull(bean);
assertThat(bean).isNotNull();
NoDefinitionInSpringContextTestBean instance = bean.getBeanInstance();
assertNotNull(instance);
assertEquals(BeanSource.FALLBACK, instance.getSource());
assertNull(instance.getApplicationContext());
assertThat(instance).isNotNull();
assertThat(instance.getSource()).isEqualTo(BeanSource.FALLBACK);
assertThat(instance.getApplicationContext()).isNull();
}
@Test
public void testCanRetrieveFallbackBeanByNameWithJpaCompliantOptions() {
BeanContainer beanContainer = getBeanContainer();
assertNotNull(beanContainer);
assertThat(beanContainer).isNotNull();
NoDefinitionInSpringContextTestBeanInstanceProducer fallbackProducer = new NoDefinitionInSpringContextTestBeanInstanceProducer();
ContainedBean<NoDefinitionInSpringContextTestBean> bean = beanContainer.getBean(
@@ -193,21 +189,21 @@ public class HibernateNativeEntityManagerFactorySpringBeanContainerIntegrationTe
JpaLifecycleOptions.INSTANCE, fallbackProducer
);
assertEquals(0, fallbackProducer.currentUnnamedInstantiationCount());
assertEquals(1, fallbackProducer.currentNamedInstantiationCount());
assertThat(fallbackProducer.currentUnnamedInstantiationCount()).isEqualTo(0);
assertThat(fallbackProducer.currentNamedInstantiationCount()).isEqualTo(1);
assertNotNull(bean);
assertThat(bean).isNotNull();
NoDefinitionInSpringContextTestBean instance = bean.getBeanInstance();
assertNotNull(instance);
assertEquals(BeanSource.FALLBACK, instance.getSource());
assertEquals("some name", instance.getName());
assertNull(instance.getApplicationContext());
assertThat(instance).isNotNull();
assertThat(instance.getSource()).isEqualTo(BeanSource.FALLBACK);
assertThat(instance.getName()).isEqualTo("some name");
assertThat(instance.getApplicationContext()).isNull();
}
@Test
public void testCanRetrieveFallbackBeanByTypeWithNativeOptions() {
BeanContainer beanContainer = getBeanContainer();
assertNotNull(beanContainer);
assertThat(beanContainer).isNotNull();
NoDefinitionInSpringContextTestBeanInstanceProducer fallbackProducer = new NoDefinitionInSpringContextTestBeanInstanceProducer();
ContainedBean<NoDefinitionInSpringContextTestBean> bean = beanContainer.getBean(
@@ -215,20 +211,20 @@ public class HibernateNativeEntityManagerFactorySpringBeanContainerIntegrationTe
NativeLifecycleOptions.INSTANCE, fallbackProducer
);
assertEquals(1, fallbackProducer.currentUnnamedInstantiationCount());
assertEquals(0, fallbackProducer.currentNamedInstantiationCount());
assertThat(fallbackProducer.currentUnnamedInstantiationCount()).isEqualTo(1);
assertThat(fallbackProducer.currentNamedInstantiationCount()).isEqualTo(0);
assertNotNull(bean);
assertThat(bean).isNotNull();
NoDefinitionInSpringContextTestBean instance = bean.getBeanInstance();
assertNotNull(instance);
assertEquals(BeanSource.FALLBACK, instance.getSource());
assertNull(instance.getApplicationContext());
assertThat(instance).isNotNull();
assertThat(instance.getSource()).isEqualTo(BeanSource.FALLBACK);
assertThat(instance.getApplicationContext()).isNull();
}
@Test
public void testCanRetrieveFallbackBeanByNameWithNativeOptions() {
BeanContainer beanContainer = getBeanContainer();
assertNotNull(beanContainer);
assertThat(beanContainer).isNotNull();
NoDefinitionInSpringContextTestBeanInstanceProducer fallbackProducer = new NoDefinitionInSpringContextTestBeanInstanceProducer();
ContainedBean<NoDefinitionInSpringContextTestBean> bean = beanContainer.getBean(
@@ -236,15 +232,15 @@ public class HibernateNativeEntityManagerFactorySpringBeanContainerIntegrationTe
NativeLifecycleOptions.INSTANCE, fallbackProducer
);
assertEquals(0, fallbackProducer.currentUnnamedInstantiationCount());
assertEquals(1, fallbackProducer.currentNamedInstantiationCount());
assertThat(fallbackProducer.currentUnnamedInstantiationCount()).isEqualTo(0);
assertThat(fallbackProducer.currentNamedInstantiationCount()).isEqualTo(1);
assertNotNull(bean);
assertThat(bean).isNotNull();
NoDefinitionInSpringContextTestBean instance = bean.getBeanInstance();
assertNotNull(instance);
assertEquals(BeanSource.FALLBACK, instance.getSource());
assertEquals("some name", instance.getName());
assertNull(instance.getApplicationContext());
assertThat(instance).isNotNull();
assertThat(instance.getSource()).isEqualTo(BeanSource.FALLBACK);
assertThat(instance.getName()).isEqualTo("some name");
assertThat(instance.getApplicationContext()).isNull();
}
@Test

229
spring-orm/src/test/java/org/springframework/orm/jpa/persistenceunit/PersistenceXmlParsingTests.java
View File

@@ -36,13 +36,8 @@ import org.springframework.jdbc.datasource.lookup.JndiDataSourceLookup;
import org.springframework.jdbc.datasource.lookup.MapDataSourceLookup;
import org.springframework.tests.mock.jndi.SimpleNamingContextBuilder;
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.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
/**
* Unit and integration tests for the JPA XML resource parsing support.
@@ -60,15 +55,15 @@ public class PersistenceXmlParsingTests {
String resource = "/org/springframework/orm/jpa/META-INF/persistence.xml";
PersistenceUnitInfo[] info = reader.readPersistenceUnitInfos(resource);
assertNotNull(info);
assertEquals(1, info.length);
assertEquals("OrderManagement", info[0].getPersistenceUnitName());
assertThat(info).isNotNull();
assertThat(info.length).isEqualTo(1);
assertThat(info[0].getPersistenceUnitName()).isEqualTo("OrderManagement");
assertEquals(2, info[0].getJarFileUrls().size());
assertEquals(new ClassPathResource("order.jar").getURL(), info[0].getJarFileUrls().get(0));
assertEquals(new ClassPathResource("order-supplemental.jar").getURL(), info[0].getJarFileUrls().get(1));
assertThat(info[0].getJarFileUrls().size()).isEqualTo(2);
assertThat(info[0].getJarFileUrls().get(0)).isEqualTo(new ClassPathResource("order.jar").getURL());
assertThat(info[0].getJarFileUrls().get(1)).isEqualTo(new ClassPathResource("order-supplemental.jar").getURL());
assertFalse("Exclude unlisted should default false in 1.0.", info[0].excludeUnlistedClasses());
assertThat(info[0].excludeUnlistedClasses()).as("Exclude unlisted should default false in 1.0.").isFalse();
}
@Test
@@ -78,11 +73,11 @@ public class PersistenceXmlParsingTests {
String resource = "/org/springframework/orm/jpa/persistence-example1.xml";
PersistenceUnitInfo[] info = reader.readPersistenceUnitInfos(resource);
assertNotNull(info);
assertEquals(1, info.length);
assertEquals("OrderManagement", info[0].getPersistenceUnitName());
assertThat(info).isNotNull();
assertThat(info.length).isEqualTo(1);
assertThat(info[0].getPersistenceUnitName()).isEqualTo("OrderManagement");
assertFalse("Exclude unlisted should default false in 1.0.", info[0].excludeUnlistedClasses());
assertThat(info[0].excludeUnlistedClasses()).as("Exclude unlisted should default false in 1.0.").isFalse();
}
@Test
@@ -92,16 +87,16 @@ public class PersistenceXmlParsingTests {
String resource = "/org/springframework/orm/jpa/persistence-example2.xml";
PersistenceUnitInfo[] info = reader.readPersistenceUnitInfos(resource);
assertNotNull(info);
assertEquals(1, info.length);
assertThat(info).isNotNull();
assertThat(info.length).isEqualTo(1);
assertEquals("OrderManagement2", info[0].getPersistenceUnitName());
assertThat(info[0].getPersistenceUnitName()).isEqualTo("OrderManagement2");
assertEquals(1, info[0].getMappingFileNames().size());
assertEquals("mappings.xml", info[0].getMappingFileNames().get(0));
assertEquals(0, info[0].getProperties().keySet().size());
assertThat(info[0].getMappingFileNames().size()).isEqualTo(1);
assertThat(info[0].getMappingFileNames().get(0)).isEqualTo("mappings.xml");
assertThat(info[0].getProperties().keySet().size()).isEqualTo(0);
assertFalse("Exclude unlisted should default false in 1.0.", info[0].excludeUnlistedClasses());
assertThat(info[0].excludeUnlistedClasses()).as("Exclude unlisted should default false in 1.0.").isFalse();
}
@Test
@@ -111,19 +106,19 @@ public class PersistenceXmlParsingTests {
String resource = "/org/springframework/orm/jpa/persistence-example3.xml";
PersistenceUnitInfo[] info = reader.readPersistenceUnitInfos(resource);
assertNotNull(info);
assertEquals(1, info.length);
assertEquals("OrderManagement3", info[0].getPersistenceUnitName());
assertThat(info).isNotNull();
assertThat(info.length).isEqualTo(1);
assertThat(info[0].getPersistenceUnitName()).isEqualTo("OrderManagement3");
assertEquals(2, info[0].getJarFileUrls().size());
assertEquals(new ClassPathResource("order.jar").getURL(), info[0].getJarFileUrls().get(0));
assertEquals(new ClassPathResource("order-supplemental.jar").getURL(), info[0].getJarFileUrls().get(1));
assertThat(info[0].getJarFileUrls().size()).isEqualTo(2);
assertThat(info[0].getJarFileUrls().get(0)).isEqualTo(new ClassPathResource("order.jar").getURL());
assertThat(info[0].getJarFileUrls().get(1)).isEqualTo(new ClassPathResource("order-supplemental.jar").getURL());
assertEquals(0, info[0].getProperties().keySet().size());
assertNull(info[0].getJtaDataSource());
assertNull(info[0].getNonJtaDataSource());
assertThat(info[0].getProperties().keySet().size()).isEqualTo(0);
assertThat(info[0].getJtaDataSource()).isNull();
assertThat(info[0].getNonJtaDataSource()).isNull();
assertFalse("Exclude unlisted should default false in 1.0.", info[0].excludeUnlistedClasses());
assertThat(info[0].excludeUnlistedClasses()).as("Exclude unlisted should default false in 1.0.").isFalse();
}
@Test
@@ -137,22 +132,22 @@ public class PersistenceXmlParsingTests {
String resource = "/org/springframework/orm/jpa/persistence-example4.xml";
PersistenceUnitInfo[] info = reader.readPersistenceUnitInfos(resource);
assertNotNull(info);
assertEquals(1, info.length);
assertEquals("OrderManagement4", info[0].getPersistenceUnitName());
assertThat(info).isNotNull();
assertThat(info.length).isEqualTo(1);
assertThat(info[0].getPersistenceUnitName()).isEqualTo("OrderManagement4");
assertEquals(1, info[0].getMappingFileNames().size());
assertEquals("order-mappings.xml", info[0].getMappingFileNames().get(0));
assertThat(info[0].getMappingFileNames().size()).isEqualTo(1);
assertThat(info[0].getMappingFileNames().get(0)).isEqualTo("order-mappings.xml");
assertEquals(3, info[0].getManagedClassNames().size());
assertEquals("com.acme.Order", info[0].getManagedClassNames().get(0));
assertEquals("com.acme.Customer", info[0].getManagedClassNames().get(1));
assertEquals("com.acme.Item", info[0].getManagedClassNames().get(2));
assertThat(info[0].getManagedClassNames().size()).isEqualTo(3);
assertThat(info[0].getManagedClassNames().get(0)).isEqualTo("com.acme.Order");
assertThat(info[0].getManagedClassNames().get(1)).isEqualTo("com.acme.Customer");
assertThat(info[0].getManagedClassNames().get(2)).isEqualTo("com.acme.Item");
assertTrue("Exclude unlisted should be true when no value.", info[0].excludeUnlistedClasses());
assertThat(info[0].excludeUnlistedClasses()).as("Exclude unlisted should be true when no value.").isTrue();
assertSame(PersistenceUnitTransactionType.RESOURCE_LOCAL, info[0].getTransactionType());
assertEquals(0, info[0].getProperties().keySet().size());
assertThat(info[0].getTransactionType()).isSameAs(PersistenceUnitTransactionType.RESOURCE_LOCAL);
assertThat(info[0].getProperties().keySet().size()).isEqualTo(0);
builder.clear();
}
@@ -164,22 +159,22 @@ public class PersistenceXmlParsingTests {
String resource = "/org/springframework/orm/jpa/persistence-example5.xml";
PersistenceUnitInfo[] info = reader.readPersistenceUnitInfos(resource);
assertNotNull(info);
assertEquals(1, info.length);
assertEquals("OrderManagement5", info[0].getPersistenceUnitName());
assertThat(info).isNotNull();
assertThat(info.length).isEqualTo(1);
assertThat(info[0].getPersistenceUnitName()).isEqualTo("OrderManagement5");
assertEquals(2, info[0].getMappingFileNames().size());
assertEquals("order1.xml", info[0].getMappingFileNames().get(0));
assertEquals("order2.xml", info[0].getMappingFileNames().get(1));
assertThat(info[0].getMappingFileNames().size()).isEqualTo(2);
assertThat(info[0].getMappingFileNames().get(0)).isEqualTo("order1.xml");
assertThat(info[0].getMappingFileNames().get(1)).isEqualTo("order2.xml");
assertEquals(2, info[0].getJarFileUrls().size());
assertEquals(new ClassPathResource("order.jar").getURL(), info[0].getJarFileUrls().get(0));
assertEquals(new ClassPathResource("order-supplemental.jar").getURL(), info[0].getJarFileUrls().get(1));
assertThat(info[0].getJarFileUrls().size()).isEqualTo(2);
assertThat(info[0].getJarFileUrls().get(0)).isEqualTo(new ClassPathResource("order.jar").getURL());
assertThat(info[0].getJarFileUrls().get(1)).isEqualTo(new ClassPathResource("order-supplemental.jar").getURL());
assertEquals("com.acme.AcmePersistence", info[0].getPersistenceProviderClassName());
assertEquals(0, info[0].getProperties().keySet().size());
assertThat(info[0].getPersistenceProviderClassName()).isEqualTo("com.acme.AcmePersistence");
assertThat(info[0].getProperties().keySet().size()).isEqualTo(0);
assertFalse("Exclude unlisted should default false in 1.0.", info[0].excludeUnlistedClasses());
assertThat(info[0].excludeUnlistedClasses()).as("Exclude unlisted should default false in 1.0.").isFalse();
}
@Test
@@ -196,53 +191,53 @@ public class PersistenceXmlParsingTests {
new PathMatchingResourcePatternResolver(), dataSourceLookup);
PersistenceUnitInfo[] info = reader.readPersistenceUnitInfos(resource);
assertEquals(2, info.length);
assertThat(info.length).isEqualTo(2);
PersistenceUnitInfo pu1 = info[0];
assertEquals("pu1", pu1.getPersistenceUnitName());
assertThat(pu1.getPersistenceUnitName()).isEqualTo("pu1");
assertEquals("com.acme.AcmePersistence", pu1.getPersistenceProviderClassName());
assertThat(pu1.getPersistenceProviderClassName()).isEqualTo("com.acme.AcmePersistence");
assertEquals(1, pu1.getMappingFileNames().size());
assertEquals("ormap2.xml", pu1.getMappingFileNames().get(0));
assertThat(pu1.getMappingFileNames().size()).isEqualTo(1);
assertThat(pu1.getMappingFileNames().get(0)).isEqualTo("ormap2.xml");
assertEquals(1, pu1.getJarFileUrls().size());
assertEquals(new ClassPathResource("order.jar").getURL(), pu1.getJarFileUrls().get(0));
assertThat(pu1.getJarFileUrls().size()).isEqualTo(1);
assertThat(pu1.getJarFileUrls().get(0)).isEqualTo(new ClassPathResource("order.jar").getURL());
assertFalse(pu1.excludeUnlistedClasses());
assertThat(pu1.excludeUnlistedClasses()).isFalse();
assertSame(PersistenceUnitTransactionType.RESOURCE_LOCAL, pu1.getTransactionType());
assertThat(pu1.getTransactionType()).isSameAs(PersistenceUnitTransactionType.RESOURCE_LOCAL);
Properties props = pu1.getProperties();
assertEquals(2, props.keySet().size());
assertEquals("on", props.getProperty("com.acme.persistence.sql-logging"));
assertEquals("bar", props.getProperty("foo"));
assertThat(props.keySet().size()).isEqualTo(2);
assertThat(props.getProperty("com.acme.persistence.sql-logging")).isEqualTo("on");
assertThat(props.getProperty("foo")).isEqualTo("bar");
assertNull(pu1.getNonJtaDataSource());
assertThat(pu1.getNonJtaDataSource()).isNull();
assertSame(ds, pu1.getJtaDataSource());
assertThat(pu1.getJtaDataSource()).isSameAs(ds);
assertFalse("Exclude unlisted should default false in 1.0.", pu1.excludeUnlistedClasses());
assertThat(pu1.excludeUnlistedClasses()).as("Exclude unlisted should default false in 1.0.").isFalse();
PersistenceUnitInfo pu2 = info[1];
assertSame(PersistenceUnitTransactionType.JTA, pu2.getTransactionType());
assertEquals("com.acme.AcmePersistence", pu2.getPersistenceProviderClassName());
assertThat(pu2.getTransactionType()).isSameAs(PersistenceUnitTransactionType.JTA);
assertThat(pu2.getPersistenceProviderClassName()).isEqualTo("com.acme.AcmePersistence");
assertEquals(1, pu2.getMappingFileNames().size());
assertEquals("order2.xml", pu2.getMappingFileNames().get(0));
assertThat(pu2.getMappingFileNames().size()).isEqualTo(1);
assertThat(pu2.getMappingFileNames().get(0)).isEqualTo("order2.xml");
// the following assertions fail only during coverage runs
// assertEquals(1, pu2.getJarFileUrls().size());
// assertEquals(new ClassPathResource("order-supplemental.jar").getURL(), pu2.getJarFileUrls().get(0));
assertTrue(pu2.excludeUnlistedClasses());
assertThat(pu2.excludeUnlistedClasses()).isTrue();
assertNull(pu2.getJtaDataSource());
assertEquals(ds, pu2.getNonJtaDataSource());
assertThat(pu2.getJtaDataSource()).isNull();
assertThat(pu2.getNonJtaDataSource()).isEqualTo(ds);
assertTrue("Exclude unlisted should be true when no value.", pu2.excludeUnlistedClasses());
assertThat(pu2.excludeUnlistedClasses()).as("Exclude unlisted should be true when no value.").isTrue();
}
@Test
@@ -251,11 +246,11 @@ public class PersistenceXmlParsingTests {
new PathMatchingResourcePatternResolver(), new JndiDataSourceLookup());
String resource = "/org/springframework/orm/jpa/persistence-example6.xml";
PersistenceUnitInfo[] info = reader.readPersistenceUnitInfos(resource);
assertEquals(1, info.length);
assertEquals("pu", info[0].getPersistenceUnitName());
assertEquals(0, info[0].getProperties().keySet().size());
assertThat(info.length).isEqualTo(1);
assertThat(info[0].getPersistenceUnitName()).isEqualTo("pu");
assertThat(info[0].getProperties().keySet().size()).isEqualTo(0);
assertFalse("Exclude unlisted should default false in 1.0.", info[0].excludeUnlistedClasses());
assertThat(info[0].excludeUnlistedClasses()).as("Exclude unlisted should default false in 1.0.").isFalse();
}
@Ignore // not doing schema parsing anymore for JPA 2.0 compatibility
@@ -281,10 +276,10 @@ public class PersistenceXmlParsingTests {
@Test
public void testPersistenceUnitRootUrl() throws Exception {
URL url = PersistenceUnitReader.determinePersistenceUnitRootUrl(new ClassPathResource("/org/springframework/orm/jpa/persistence-no-schema.xml"));
assertNull(url);
assertThat(url).isNull();
url = PersistenceUnitReader.determinePersistenceUnitRootUrl(new ClassPathResource("/org/springframework/orm/jpa/META-INF/persistence.xml"));
assertTrue("the containing folder should have been returned", url.toString().endsWith("/org/springframework/orm/jpa"));
assertThat(url.toString().endsWith("/org/springframework/orm/jpa")).as("the containing folder should have been returned").isTrue();
}
@Test
@@ -293,9 +288,9 @@ public class PersistenceXmlParsingTests {
String newRoot = "jar:" + archive.getURL().toExternalForm() + "!/META-INF/persist.xml";
Resource insideArchive = new UrlResource(newRoot);
// make sure the location actually exists
assertTrue(insideArchive.exists());
assertThat(insideArchive.exists()).isTrue();
URL url = PersistenceUnitReader.determinePersistenceUnitRootUrl(insideArchive);
assertTrue("the archive location should have been returned", archive.getURL().sameFile(url));
assertThat(archive.getURL().sameFile(url)).as("the archive location should have been returned").isTrue();
}
@Test
@@ -305,28 +300,28 @@ public class PersistenceXmlParsingTests {
String resource = "/org/springframework/orm/jpa/persistence-exclude-1.0.xml";
PersistenceUnitInfo[] info = reader.readPersistenceUnitInfos(resource);
assertNotNull(info);
assertEquals("The number of persistence units is incorrect.", 4, info.length);
assertThat(info).isNotNull();
assertThat(info.length).as("The number of persistence units is incorrect.").isEqualTo(4);
PersistenceUnitInfo noExclude = info[0];
assertNotNull("noExclude should not be null.", noExclude);
assertEquals("noExclude name is not correct.", "NoExcludeElement", noExclude.getPersistenceUnitName());
assertFalse("Exclude unlisted should default false in 1.0.", noExclude.excludeUnlistedClasses());
assertThat(noExclude).as("noExclude should not be null.").isNotNull();
assertThat(noExclude.getPersistenceUnitName()).as("noExclude name is not correct.").isEqualTo("NoExcludeElement");
assertThat(noExclude.excludeUnlistedClasses()).as("Exclude unlisted should default false in 1.0.").isFalse();
PersistenceUnitInfo emptyExclude = info[1];
assertNotNull("emptyExclude should not be null.", emptyExclude);
assertEquals("emptyExclude name is not correct.", "EmptyExcludeElement", emptyExclude.getPersistenceUnitName());
assertTrue("emptyExclude should be true.", emptyExclude.excludeUnlistedClasses());
assertThat(emptyExclude).as("emptyExclude should not be null.").isNotNull();
assertThat(emptyExclude.getPersistenceUnitName()).as("emptyExclude name is not correct.").isEqualTo("EmptyExcludeElement");
assertThat(emptyExclude.excludeUnlistedClasses()).as("emptyExclude should be true.").isTrue();
PersistenceUnitInfo trueExclude = info[2];
assertNotNull("trueExclude should not be null.", trueExclude);
assertEquals("trueExclude name is not correct.", "TrueExcludeElement", trueExclude.getPersistenceUnitName());
assertTrue("trueExclude should be true.", trueExclude.excludeUnlistedClasses());
assertThat(trueExclude).as("trueExclude should not be null.").isNotNull();
assertThat(trueExclude.getPersistenceUnitName()).as("trueExclude name is not correct.").isEqualTo("TrueExcludeElement");
assertThat(trueExclude.excludeUnlistedClasses()).as("trueExclude should be true.").isTrue();
PersistenceUnitInfo falseExclude = info[3];
assertNotNull("falseExclude should not be null.", falseExclude);
assertEquals("falseExclude name is not correct.", "FalseExcludeElement", falseExclude.getPersistenceUnitName());
assertFalse("falseExclude should be false.", falseExclude.excludeUnlistedClasses());
assertThat(falseExclude).as("falseExclude should not be null.").isNotNull();
assertThat(falseExclude.getPersistenceUnitName()).as("falseExclude name is not correct.").isEqualTo("FalseExcludeElement");
assertThat(falseExclude.excludeUnlistedClasses()).as("falseExclude should be false.").isFalse();
}
@Test
@@ -336,28 +331,28 @@ public class PersistenceXmlParsingTests {
String resource = "/org/springframework/orm/jpa/persistence-exclude-2.0.xml";
PersistenceUnitInfo[] info = reader.readPersistenceUnitInfos(resource);
assertNotNull(info);
assertEquals("The number of persistence units is incorrect.", 4, info.length);
assertThat(info).isNotNull();
assertThat(info.length).as("The number of persistence units is incorrect.").isEqualTo(4);
PersistenceUnitInfo noExclude = info[0];
assertNotNull("noExclude should not be null.", noExclude);
assertEquals("noExclude name is not correct.", "NoExcludeElement", noExclude.getPersistenceUnitName());
assertFalse("Exclude unlisted still defaults to false in 2.0.", noExclude.excludeUnlistedClasses());
assertThat(noExclude).as("noExclude should not be null.").isNotNull();
assertThat(noExclude.getPersistenceUnitName()).as("noExclude name is not correct.").isEqualTo("NoExcludeElement");
assertThat(noExclude.excludeUnlistedClasses()).as("Exclude unlisted still defaults to false in 2.0.").isFalse();
PersistenceUnitInfo emptyExclude = info[1];
assertNotNull("emptyExclude should not be null.", emptyExclude);
assertEquals("emptyExclude name is not correct.", "EmptyExcludeElement", emptyExclude.getPersistenceUnitName());
assertTrue("emptyExclude should be true.", emptyExclude.excludeUnlistedClasses());
assertThat(emptyExclude).as("emptyExclude should not be null.").isNotNull();
assertThat(emptyExclude.getPersistenceUnitName()).as("emptyExclude name is not correct.").isEqualTo("EmptyExcludeElement");
assertThat(emptyExclude.excludeUnlistedClasses()).as("emptyExclude should be true.").isTrue();
PersistenceUnitInfo trueExclude = info[2];
assertNotNull("trueExclude should not be null.", trueExclude);
assertEquals("trueExclude name is not correct.", "TrueExcludeElement", trueExclude.getPersistenceUnitName());
assertTrue("trueExclude should be true.", trueExclude.excludeUnlistedClasses());
assertThat(trueExclude).as("trueExclude should not be null.").isNotNull();
assertThat(trueExclude.getPersistenceUnitName()).as("trueExclude name is not correct.").isEqualTo("TrueExcludeElement");
assertThat(trueExclude.excludeUnlistedClasses()).as("trueExclude should be true.").isTrue();
PersistenceUnitInfo falseExclude = info[3];
assertNotNull("falseExclude should not be null.", falseExclude);
assertEquals("falseExclude name is not correct.", "FalseExcludeElement", falseExclude.getPersistenceUnitName());
assertFalse("falseExclude should be false.", falseExclude.excludeUnlistedClasses());
assertThat(falseExclude).as("falseExclude should not be null.").isNotNull();
assertThat(falseExclude.getPersistenceUnitName()).as("falseExclude name is not correct.").isEqualTo("FalseExcludeElement");
assertThat(falseExclude.excludeUnlistedClasses()).as("falseExclude should be false.").isFalse();
}
}

81
spring-orm/src/test/java/org/springframework/orm/jpa/support/OpenEntityManagerInViewTests.java
View File

@@ -48,10 +48,7 @@ import org.springframework.web.context.request.async.WebAsyncManager;
import org.springframework.web.context.request.async.WebAsyncUtils;
import org.springframework.web.context.support.StaticWebApplicationContext;
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.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
@@ -93,10 +90,10 @@ public class OpenEntityManagerInViewTests {
@After
public void tearDown() throws Exception {
assertTrue(TransactionSynchronizationManager.getResourceMap().isEmpty());
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
assertThat(TransactionSynchronizationManager.getResourceMap().isEmpty()).isTrue();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
}
@Test
@@ -108,7 +105,7 @@ public class OpenEntityManagerInViewTests {
MockHttpServletRequest request = new MockHttpServletRequest(sc);
interceptor.preHandle(new ServletWebRequest(request));
assertTrue(TransactionSynchronizationManager.hasResource(this.factory));
assertThat(TransactionSynchronizationManager.hasResource(this.factory)).isTrue();
// check that further invocations simply participate
interceptor.preHandle(new ServletWebRequest(request));
@@ -125,12 +122,12 @@ public class OpenEntityManagerInViewTests {
interceptor.afterCompletion(new ServletWebRequest(request), null);
interceptor.postHandle(new ServletWebRequest(request), null);
assertTrue(TransactionSynchronizationManager.hasResource(factory));
assertThat(TransactionSynchronizationManager.hasResource(factory)).isTrue();
given(manager.isOpen()).willReturn(true);
interceptor.afterCompletion(new ServletWebRequest(request), null);
assertFalse(TransactionSynchronizationManager.hasResource(factory));
assertThat(TransactionSynchronizationManager.hasResource(factory)).isFalse();
verify(manager).close();
}
@@ -146,7 +143,7 @@ public class OpenEntityManagerInViewTests {
given(factory.createEntityManager()).willReturn(this.manager);
interceptor.preHandle(this.webRequest);
assertTrue(TransactionSynchronizationManager.hasResource(factory));
assertThat(TransactionSynchronizationManager.hasResource(factory)).isTrue();
AsyncWebRequest asyncWebRequest = new StandardServletAsyncWebRequest(this.request, this.response);
WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(this.webRequest);
@@ -160,12 +157,12 @@ public class OpenEntityManagerInViewTests {
});
interceptor.afterConcurrentHandlingStarted(this.webRequest);
assertFalse(TransactionSynchronizationManager.hasResource(factory));
assertThat(TransactionSynchronizationManager.hasResource(factory)).isFalse();
// Async dispatch thread
interceptor.preHandle(this.webRequest);
assertTrue(TransactionSynchronizationManager.hasResource(factory));
assertThat(TransactionSynchronizationManager.hasResource(factory)).isTrue();
asyncManager.clearConcurrentResult();
@@ -184,12 +181,12 @@ public class OpenEntityManagerInViewTests {
interceptor.afterCompletion(new ServletWebRequest(request), null);
interceptor.postHandle(this.webRequest, null);
assertTrue(TransactionSynchronizationManager.hasResource(factory));
assertThat(TransactionSynchronizationManager.hasResource(factory)).isTrue();
given(this.manager.isOpen()).willReturn(true);
interceptor.afterCompletion(this.webRequest, null);
assertFalse(TransactionSynchronizationManager.hasResource(factory));
assertThat(TransactionSynchronizationManager.hasResource(factory)).isFalse();
verify(this.manager).close();
}
@@ -205,7 +202,7 @@ public class OpenEntityManagerInViewTests {
given(this.factory.createEntityManager()).willReturn(this.manager);
interceptor.preHandle(this.webRequest);
assertTrue(TransactionSynchronizationManager.hasResource(this.factory));
assertThat(TransactionSynchronizationManager.hasResource(this.factory)).isTrue();
AsyncWebRequest asyncWebRequest = new StandardServletAsyncWebRequest(this.request, this.response);
WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(this.request);
@@ -219,7 +216,7 @@ public class OpenEntityManagerInViewTests {
});
interceptor.afterConcurrentHandlingStarted(this.webRequest);
assertFalse(TransactionSynchronizationManager.hasResource(this.factory));
assertThat(TransactionSynchronizationManager.hasResource(this.factory)).isFalse();
// Async request timeout
@@ -247,7 +244,7 @@ public class OpenEntityManagerInViewTests {
given(this.factory.createEntityManager()).willReturn(this.manager);
interceptor.preHandle(this.webRequest);
assertTrue(TransactionSynchronizationManager.hasResource(this.factory));
assertThat(TransactionSynchronizationManager.hasResource(this.factory)).isTrue();
AsyncWebRequest asyncWebRequest = new StandardServletAsyncWebRequest(this.request, this.response);
WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(this.request);
@@ -261,7 +258,7 @@ public class OpenEntityManagerInViewTests {
});
interceptor.afterConcurrentHandlingStarted(this.webRequest);
assertFalse(TransactionSynchronizationManager.hasResource(this.factory));
assertThat(TransactionSynchronizationManager.hasResource(this.factory)).isFalse();
// Async request timeout
@@ -310,7 +307,7 @@ public class OpenEntityManagerInViewTests {
final FilterChain filterChain = new FilterChain() {
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse) {
assertTrue(TransactionSynchronizationManager.hasResource(factory));
assertThat(TransactionSynchronizationManager.hasResource(factory)).isTrue();
servletRequest.setAttribute("invoked", Boolean.TRUE);
}
};
@@ -319,19 +316,19 @@ public class OpenEntityManagerInViewTests {
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse)
throws IOException, ServletException {
assertTrue(TransactionSynchronizationManager.hasResource(factory2));
assertThat(TransactionSynchronizationManager.hasResource(factory2)).isTrue();
filter.doFilter(servletRequest, servletResponse, filterChain);
}
};
FilterChain filterChain3 = new PassThroughFilterChain(filter2, filterChain2);
assertFalse(TransactionSynchronizationManager.hasResource(factory));
assertFalse(TransactionSynchronizationManager.hasResource(factory2));
assertThat(TransactionSynchronizationManager.hasResource(factory)).isFalse();
assertThat(TransactionSynchronizationManager.hasResource(factory2)).isFalse();
filter2.doFilter(request, response, filterChain3);
assertFalse(TransactionSynchronizationManager.hasResource(factory));
assertFalse(TransactionSynchronizationManager.hasResource(factory2));
assertNotNull(request.getAttribute("invoked"));
assertThat(TransactionSynchronizationManager.hasResource(factory)).isFalse();
assertThat(TransactionSynchronizationManager.hasResource(factory2)).isFalse();
assertThat(request.getAttribute("invoked")).isNotNull();
verify(manager).close();
verify(manager2).close();
@@ -371,7 +368,7 @@ public class OpenEntityManagerInViewTests {
final FilterChain filterChain = new FilterChain() {
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse) {
assertTrue(TransactionSynchronizationManager.hasResource(factory));
assertThat(TransactionSynchronizationManager.hasResource(factory)).isTrue();
servletRequest.setAttribute("invoked", Boolean.TRUE);
count.incrementAndGet();
}
@@ -383,7 +380,7 @@ public class OpenEntityManagerInViewTests {
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse)
throws IOException, ServletException {
assertTrue(TransactionSynchronizationManager.hasResource(factory2));
assertThat(TransactionSynchronizationManager.hasResource(factory2)).isTrue();
filter.doFilter(servletRequest, servletResponse, filterChain);
count2.incrementAndGet();
}
@@ -404,14 +401,14 @@ public class OpenEntityManagerInViewTests {
}
});
assertFalse(TransactionSynchronizationManager.hasResource(factory));
assertFalse(TransactionSynchronizationManager.hasResource(factory2));
assertThat(TransactionSynchronizationManager.hasResource(factory)).isFalse();
assertThat(TransactionSynchronizationManager.hasResource(factory2)).isFalse();
filter2.doFilter(this.request, this.response, filterChain3);
assertFalse(TransactionSynchronizationManager.hasResource(factory));
assertFalse(TransactionSynchronizationManager.hasResource(factory2));
assertEquals(1, count.get());
assertEquals(1, count2.get());
assertNotNull(request.getAttribute("invoked"));
assertThat(TransactionSynchronizationManager.hasResource(factory)).isFalse();
assertThat(TransactionSynchronizationManager.hasResource(factory2)).isFalse();
assertThat(count.get()).isEqualTo(1);
assertThat(count2.get()).isEqualTo(1);
assertThat(request.getAttribute("invoked")).isNotNull();
verify(asyncWebRequest, times(2)).addCompletionHandler(any(Runnable.class));
verify(asyncWebRequest).addTimeoutHandler(any(Runnable.class));
verify(asyncWebRequest, times(2)).addCompletionHandler(any(Runnable.class));
@@ -422,13 +419,13 @@ public class OpenEntityManagerInViewTests {
reset(asyncWebRequest);
given(asyncWebRequest.isAsyncStarted()).willReturn(false);
assertFalse(TransactionSynchronizationManager.hasResource(factory));
assertFalse(TransactionSynchronizationManager.hasResource(factory2));
assertThat(TransactionSynchronizationManager.hasResource(factory)).isFalse();
assertThat(TransactionSynchronizationManager.hasResource(factory2)).isFalse();
filter.doFilter(this.request, this.response, filterChain3);
assertFalse(TransactionSynchronizationManager.hasResource(factory));
assertFalse(TransactionSynchronizationManager.hasResource(factory2));
assertEquals(2, count.get());
assertEquals(2, count2.get());
assertThat(TransactionSynchronizationManager.hasResource(factory)).isFalse();
assertThat(TransactionSynchronizationManager.hasResource(factory2)).isFalse();
assertThat(count.get()).isEqualTo(2);
assertThat(count2.get()).isEqualTo(2);
verify(this.manager).close();
verify(manager2).close();

15
spring-orm/src/test/java/org/springframework/orm/jpa/support/PersistenceContextTransactionTests.java
View File

@@ -33,8 +33,7 @@ import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import org.springframework.transaction.support.TransactionTemplate;
import static org.junit.Assert.assertFalse;
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.times;
@@ -80,16 +79,16 @@ public class PersistenceContextTransactionTests {
};
pabpp.postProcessProperties(null, bean, "bean");
assertTrue(TransactionSynchronizationManager.getResourceMap().isEmpty());
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertThat(TransactionSynchronizationManager.getResourceMap().isEmpty()).isTrue();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
}
@After
public void clear() {
assertTrue(TransactionSynchronizationManager.getResourceMap().isEmpty());
assertFalse(TransactionSynchronizationManager.isSynchronizationActive());
assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly());
assertFalse(TransactionSynchronizationManager.isActualTransactionActive());
assertThat(TransactionSynchronizationManager.getResourceMap().isEmpty()).isTrue();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isFalse();
assertThat(TransactionSynchronizationManager.isCurrentTransactionReadOnly()).isFalse();
assertThat(TransactionSynchronizationManager.isActualTransactionActive()).isFalse();
}

6
spring-orm/src/test/java/org/springframework/orm/jpa/support/PersistenceInjectionIntegrationTests.java
View File

@@ -23,7 +23,7 @@ import org.springframework.orm.jpa.AbstractEntityManagerFactoryIntegrationTests;
import org.springframework.orm.jpa.support.PersistenceInjectionTests.DefaultPublicPersistenceContextSetter;
import org.springframework.orm.jpa.support.PersistenceInjectionTests.DefaultPublicPersistenceUnitSetterNamedPerson;
import static org.junit.Assert.assertNotNull;
import static org.assertj.core.api.Assertions.assertThat;
/**
* @author Rod Johnson
@@ -41,12 +41,12 @@ public class PersistenceInjectionIntegrationTests extends AbstractEntityManagerF
@Test
public void testDefaultPersistenceContextSetterInjection() {
assertNotNull(defaultSetterInjected.getEntityManager());
assertThat(defaultSetterInjected.getEntityManager()).isNotNull();
}
@Test
public void testSetterInjectionOfNamedPersistenceContext() {
assertNotNull(namedSetterInjected.getEntityManagerFactory());
assertThat(namedSetterInjected.getEntityManagerFactory()).isNotNull();
}
}

104
spring-orm/src/test/java/org/springframework/orm/jpa/support/PersistenceInjectionTests.java
View File

@@ -48,10 +48,8 @@ import org.springframework.tests.mock.jndi.ExpectedLookupTemplate;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import org.springframework.util.SerializationTestUtils;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.junit.Assert.assertNotNull;
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.verify;
@@ -84,11 +82,11 @@ public class PersistenceInjectionTests extends AbstractEntityManagerFactoryBeanT
DefaultPrivatePersistenceContextField.class.getName());
FactoryBeanWithPersistenceContextField bean2 = (FactoryBeanWithPersistenceContextField) gac.getBean(
"&" + FactoryBeanWithPersistenceContextField.class.getName());
assertNotNull(bean.em);
assertNotNull(bean2.em);
assertThat(bean.em).isNotNull();
assertThat(bean2.em).isNotNull();
assertNotNull(SerializationTestUtils.serializeAndDeserialize(bean.em));
assertNotNull(SerializationTestUtils.serializeAndDeserialize(bean2.em));
assertThat(SerializationTestUtils.serializeAndDeserialize(bean.em)).isNotNull();
assertThat(SerializationTestUtils.serializeAndDeserialize(bean2.em)).isNotNull();
}
@Test
@@ -103,7 +101,7 @@ public class PersistenceInjectionTests extends AbstractEntityManagerFactoryBeanT
DefaultVendorSpecificPrivatePersistenceContextField bean = (DefaultVendorSpecificPrivatePersistenceContextField)
gac.getBean(DefaultVendorSpecificPrivatePersistenceContextField.class.getName());
assertNotNull(bean.em);
assertThat(bean.em).isNotNull();
}
@Test
@@ -121,7 +119,7 @@ public class PersistenceInjectionTests extends AbstractEntityManagerFactoryBeanT
DefaultPublicPersistenceContextSetter bean = (DefaultPublicPersistenceContextSetter) gac.getBean(
DefaultPublicPersistenceContextSetter.class.getName());
assertNotNull(bean.em);
assertThat(bean.em).isNotNull();
}
@Test
@@ -141,7 +139,7 @@ public class PersistenceInjectionTests extends AbstractEntityManagerFactoryBeanT
SpecificPublicPersistenceContextSetter bean = (SpecificPublicPersistenceContextSetter) gac.getBean(
SpecificPublicPersistenceContextSetter.class.getName());
assertNotNull(bean.getEntityManager());
assertThat(bean.getEntityManager()).isNotNull();
bean.getEntityManager().flush();
verify(mockEm2).getTransaction();
verify(mockEm2).flush();
@@ -160,11 +158,11 @@ public class PersistenceInjectionTests extends AbstractEntityManagerFactoryBeanT
DefaultPrivatePersistenceContextField existingBean1 = new DefaultPrivatePersistenceContextField();
gac.getAutowireCapableBeanFactory().autowireBean(existingBean1);
assertNotNull(existingBean1.em);
assertThat(existingBean1.em).isNotNull();
DefaultPublicPersistenceContextSetter existingBean2 = new DefaultPublicPersistenceContextSetter();
gac.getAutowireCapableBeanFactory().autowireBean(existingBean2);
assertNotNull(existingBean2.em);
assertThat(existingBean2.em).isNotNull();
}
@Test
@@ -186,12 +184,12 @@ public class PersistenceInjectionTests extends AbstractEntityManagerFactoryBeanT
DefaultPublicPersistenceContextSetter bean = (DefaultPublicPersistenceContextSetter) gac.getBean(
DefaultPublicPersistenceContextSetter.class.getName());
assertNotNull(bean.em);
assertNotNull(SerializationTestUtils.serializeAndDeserialize(bean.em));
assertThat(bean.em).isNotNull();
assertThat(SerializationTestUtils.serializeAndDeserialize(bean.em)).isNotNull();
SimpleMapScope serialized = (SimpleMapScope) SerializationTestUtils.serializeAndDeserialize(myScope);
serialized.close();
assertTrue(DummyInvocationHandler.closed);
assertThat(DummyInvocationHandler.closed).isTrue();
DummyInvocationHandler.closed = false;
}
@@ -217,8 +215,8 @@ public class PersistenceInjectionTests extends AbstractEntityManagerFactoryBeanT
DefaultPublicPersistenceContextSetter bean = (DefaultPublicPersistenceContextSetter) gac.getBean(
DefaultPublicPersistenceContextSetter.class.getName());
assertNotNull(bean.em);
assertNotNull(SerializationTestUtils.serializeAndDeserialize(bean.em));
assertThat(bean.em).isNotNull();
assertThat(SerializationTestUtils.serializeAndDeserialize(bean.em)).isNotNull();
}
@Test
@@ -236,7 +234,7 @@ public class PersistenceInjectionTests extends AbstractEntityManagerFactoryBeanT
DefaultPublicPersistenceContextSetter bean = (DefaultPublicPersistenceContextSetter) gac.getBean(
DefaultPublicPersistenceContextSetter.class.getName());
assertSame(mockEm2, bean.em);
assertThat(bean.em).isSameAs(mockEm2);
}
@Test
@@ -251,7 +249,7 @@ public class PersistenceInjectionTests extends AbstractEntityManagerFactoryBeanT
DefaultPrivatePersistenceUnitField bean = (DefaultPrivatePersistenceUnitField) gac.getBean(
DefaultPrivatePersistenceUnitField.class.getName());
assertSame(mockEmf, bean.emf);
assertThat(bean.emf).isSameAs(mockEmf);
}
@Test
@@ -266,7 +264,7 @@ public class PersistenceInjectionTests extends AbstractEntityManagerFactoryBeanT
DefaultPublicPersistenceUnitSetter bean = (DefaultPublicPersistenceUnitSetter) gac.getBean(
DefaultPublicPersistenceUnitSetter.class.getName());
assertSame(mockEmf, bean.emf);
assertThat(bean.emf).isSameAs(mockEmf);
}
@Test
@@ -284,7 +282,7 @@ public class PersistenceInjectionTests extends AbstractEntityManagerFactoryBeanT
DefaultPublicPersistenceUnitSetter bean = (DefaultPublicPersistenceUnitSetter) gac.getBean(
DefaultPublicPersistenceUnitSetter.class.getName());
assertSame(mockEmf2, bean.emf);
assertThat(bean.emf).isSameAs(mockEmf2);
}
@Test
@@ -308,8 +306,8 @@ public class PersistenceInjectionTests extends AbstractEntityManagerFactoryBeanT
gac.getBean(DefaultPublicPersistenceUnitSetter.class.getName());
DefaultPublicPersistenceUnitSetterNamedPerson bean2 = (DefaultPublicPersistenceUnitSetterNamedPerson)
gac.getBean(DefaultPublicPersistenceUnitSetterNamedPerson.class.getName());
assertSame(mockEmf, bean.emf);
assertSame(mockEmf2, bean2.emf);
assertThat(bean.emf).isSameAs(mockEmf);
assertThat(bean2.emf).isSameAs(mockEmf2);
}
@Test
@@ -333,8 +331,8 @@ public class PersistenceInjectionTests extends AbstractEntityManagerFactoryBeanT
gac.getBean(DefaultPublicPersistenceUnitSetter.class.getName());
DefaultPublicPersistenceUnitSetterNamedPerson bean2 = (DefaultPublicPersistenceUnitSetterNamedPerson)
gac.getBean(DefaultPublicPersistenceUnitSetterNamedPerson.class.getName());
assertSame(mockEmf, bean.emf);
assertSame(mockEmf2, bean2.emf);
assertThat(bean.emf).isSameAs(mockEmf);
assertThat(bean2.emf).isSameAs(mockEmf2);
}
@Test
@@ -374,10 +372,10 @@ public class PersistenceInjectionTests extends AbstractEntityManagerFactoryBeanT
bf.getBean(DefaultPrivatePersistenceContextField.class.getName());
DefaultPublicPersistenceContextSetter bean4 = (DefaultPublicPersistenceContextSetter)
bf.getBean(DefaultPublicPersistenceContextSetter.class.getName());
assertSame(mockEmf, bean.emf);
assertSame(mockEmf2, bean2.emf);
assertNotNull(bean3.em);
assertNotNull(bean4.em);
assertThat(bean.emf).isSameAs(mockEmf);
assertThat(bean2.emf).isSameAs(mockEmf2);
assertThat(bean3.em).isNotNull();
assertThat(bean4.em).isNotNull();
}
@Test
@@ -406,8 +404,8 @@ public class PersistenceInjectionTests extends AbstractEntityManagerFactoryBeanT
bf.getBean(DefaultPublicPersistenceUnitSetter.class.getName());
DefaultPublicPersistenceUnitSetterNamedPerson bean2 = (DefaultPublicPersistenceUnitSetterNamedPerson)
bf.getBean(DefaultPublicPersistenceUnitSetterNamedPerson.class.getName());
assertSame(mockEmf, bean.emf);
assertSame(mockEmf2, bean2.emf);
assertThat(bean.emf).isSameAs(mockEmf);
assertThat(bean2.emf).isSameAs(mockEmf2);
}
@Test
@@ -431,8 +429,8 @@ public class PersistenceInjectionTests extends AbstractEntityManagerFactoryBeanT
bf.getBean(DefaultPublicPersistenceUnitSetter.class.getName());
DefaultPublicPersistenceUnitSetterNamedPerson bean2 = (DefaultPublicPersistenceUnitSetterNamedPerson)
bf.getBean(DefaultPublicPersistenceUnitSetterNamedPerson.class.getName());
assertSame(mockEmf, bean.emf);
assertSame(mockEmf, bean2.emf);
assertThat(bean.emf).isSameAs(mockEmf);
assertThat(bean2.emf).isSameAs(mockEmf);
}
@Test
@@ -470,9 +468,9 @@ public class PersistenceInjectionTests extends AbstractEntityManagerFactoryBeanT
bf.getBean(DefaultPrivatePersistenceContextFieldNamedPerson.class.getName());
DefaultPublicPersistenceContextSetter bean3 = (DefaultPublicPersistenceContextSetter)
bf.getBean(DefaultPublicPersistenceContextSetter.class.getName());
assertSame(mockEm, bean1.em);
assertSame(mockEm2, bean2.em);
assertSame(mockEm3, bean3.em);
assertThat(bean1.em).isSameAs(mockEm);
assertThat(bean2.em).isSameAs(mockEm2);
assertThat(bean3.em).isSameAs(mockEm3);
}
@Test
@@ -511,9 +509,9 @@ public class PersistenceInjectionTests extends AbstractEntityManagerFactoryBeanT
bf.getBean(DefaultPrivatePersistenceContextFieldNamedPerson.class.getName());
DefaultPublicPersistenceContextSetter bean3 = (DefaultPublicPersistenceContextSetter)
bf.getBean(DefaultPublicPersistenceContextSetter.class.getName());
assertSame(mockEm, bean1.em);
assertSame(mockEm2, bean2.em);
assertSame(mockEm3, bean3.em);
assertThat(bean1.em).isSameAs(mockEm);
assertThat(bean2.em).isSameAs(mockEm2);
assertThat(bean3.em).isSameAs(mockEm3);
}
@Test
@@ -544,8 +542,8 @@ public class PersistenceInjectionTests extends AbstractEntityManagerFactoryBeanT
bf.getBean(DefaultPrivatePersistenceContextField.class.getName());
DefaultPublicPersistenceContextSetter bean2 = (DefaultPublicPersistenceContextSetter)
bf.getBean(DefaultPublicPersistenceContextSetter.class.getName());
assertSame(mockEm, bean1.em);
assertSame(mockEm2, bean2.em);
assertThat(bean1.em).isSameAs(mockEm);
assertThat(bean2.em).isSameAs(mockEm2);
}
@Test
@@ -577,7 +575,7 @@ public class PersistenceInjectionTests extends AbstractEntityManagerFactoryBeanT
PersistenceAnnotationBeanPostProcessor pabpp = new MockPersistenceAnnotationBeanPostProcessor();
DefaultPrivatePersistenceContextFieldExtended dppcf = new DefaultPrivatePersistenceContextFieldExtended();
pabpp.postProcessProperties(null, dppcf, "bean");
assertNotNull(dppcf.em);
assertThat(dppcf.em).isNotNull();
}
@Test
@@ -591,7 +589,7 @@ public class PersistenceInjectionTests extends AbstractEntityManagerFactoryBeanT
DefaultPrivatePersistenceContextFieldExtendedWithProps dppcf =
new DefaultPrivatePersistenceContextFieldExtendedWithProps();
pabpp.postProcessProperties(null, dppcf, "bean");
assertNotNull(dppcf.em);
assertThat(dppcf.em).isNotNull();
}
@Test
@@ -608,8 +606,8 @@ public class PersistenceInjectionTests extends AbstractEntityManagerFactoryBeanT
new DefaultPrivatePersistenceContextFieldWithProperties();
pabpp.postProcessProperties(null, transactionalField, "bean");
assertNotNull(transactionalField.em);
assertNotNull(transactionalField.em.getDelegate());
assertThat(transactionalField.em).isNotNull();
assertThat(transactionalField.em.getDelegate()).isNotNull();
verify(em).close();
}
@@ -636,14 +634,14 @@ public class PersistenceInjectionTests extends AbstractEntityManagerFactoryBeanT
pabpp.postProcessProperties(null, transactionalFieldWithProperties, "bean1");
pabpp.postProcessProperties(null, transactionalField, "bean2");
assertNotNull(transactionalFieldWithProperties.em);
assertNotNull(transactionalField.em);
assertThat(transactionalFieldWithProperties.em).isNotNull();
assertThat(transactionalField.em).isNotNull();
// the EM w/ properties will be created
assertNotNull(transactionalFieldWithProperties.em.getDelegate());
assertThat(transactionalFieldWithProperties.em.getDelegate()).isNotNull();
// bind em to the thread now since it's created
try {
TransactionSynchronizationManager.bindResource(mockEmf, new EntityManagerHolder(em));
assertNotNull(transactionalField.em.getDelegate());
assertThat(transactionalField.em.getDelegate()).isNotNull();
verify(em).close();
}
finally {
@@ -669,14 +667,14 @@ public class PersistenceInjectionTests extends AbstractEntityManagerFactoryBeanT
pabpp.postProcessProperties(null, transactionalFieldWithProperties, "bean1");
pabpp.postProcessProperties(null, transactionalField, "bean2");
assertNotNull(transactionalFieldWithProperties.em);
assertNotNull(transactionalField.em);
assertThat(transactionalFieldWithProperties.em).isNotNull();
assertThat(transactionalField.em).isNotNull();
// the EM w/o properties will be created
assertNotNull(transactionalField.em.getDelegate());
assertThat(transactionalField.em.getDelegate()).isNotNull();
// bind em to the thread now since it's created
try {
TransactionSynchronizationManager.bindResource(mockEmf, new EntityManagerHolder(em));
assertNotNull(transactionalFieldWithProperties.em.getDelegate());
assertThat(transactionalFieldWithProperties.em.getDelegate()).isNotNull();
verify(em).close();
}
finally {

19
spring-orm/src/test/java/org/springframework/orm/jpa/support/SharedEntityManagerFactoryTests.java
View File

@@ -25,10 +25,8 @@ import org.springframework.orm.jpa.EntityManagerHolder;
import org.springframework.orm.jpa.EntityManagerProxy;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.junit.Assert.assertFalse;
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.verify;
@@ -54,27 +52,28 @@ public class SharedEntityManagerFactoryTests {
proxyFactoryBean.setEntityManagerFactory(mockEmf);
proxyFactoryBean.afterPropertiesSet();
assertTrue(EntityManager.class.isAssignableFrom(proxyFactoryBean.getObjectType()));
assertTrue(proxyFactoryBean.isSingleton());
assertThat(EntityManager.class.isAssignableFrom(proxyFactoryBean.getObjectType())).isTrue();
assertThat(proxyFactoryBean.isSingleton()).isTrue();
EntityManager proxy = proxyFactoryBean.getObject();
assertSame(proxy, proxyFactoryBean.getObject());
assertFalse(proxy.contains(o));
assertThat(proxyFactoryBean.getObject()).isSameAs(proxy);
assertThat(proxy.contains(o)).isFalse();
assertTrue(proxy instanceof EntityManagerProxy);
boolean condition = proxy instanceof EntityManagerProxy;
assertThat(condition).isTrue();
EntityManagerProxy emProxy = (EntityManagerProxy) proxy;
assertThatIllegalStateException().as("outside of transaction").isThrownBy(
emProxy::getTargetEntityManager);
TransactionSynchronizationManager.bindResource(mockEmf, new EntityManagerHolder(mockEm));
try {
assertSame(mockEm, emProxy.getTargetEntityManager());
assertThat(emProxy.getTargetEntityManager()).isSameAs(mockEm);
}
finally {
TransactionSynchronizationManager.unbindResource(mockEmf);
}
assertTrue(TransactionSynchronizationManager.getResourceMap().isEmpty());
assertThat(TransactionSynchronizationManager.getResourceMap().isEmpty()).isTrue();
verify(mockEm).contains(o);
verify(mockEm).close();
}