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

Merge branch '5.3.x'

Browse Source 
# Conflicts:
#	spring-beans/src/test/java/org/springframework/beans/factory/support/security/CallbacksSecurityTests.java
#	spring-context/src/test/java/org/springframework/ejb/access/LocalSlsbInvokerInterceptorTests.java
#	spring-context/src/test/java/org/springframework/ejb/access/SimpleRemoteSlsbInvokerInterceptorTests.java
#	spring-web/src/test/java/org/springframework/remoting/jaxws/JaxWsSupportTests.java
#	spring-webmvc/src/test/java/org/springframework/web/servlet/config/annotation/ViewResolutionIntegrationTests.java
This commit is contained in:
Sam Brannen
2022-05-31 14:15:36 +02:00
parent b659030867 1beb7068f6
commit ee209de9cf
42 changed files with 533 additions and 780 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2021 the original author or authors.
* Copyright 2002-2022 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -30,8 +30,10 @@ import org.springframework.orm.jpa.domain.DriversLicense;
import org.springframework.orm.jpa.domain.Person;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatException;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.assertj.core.api.Assertions.assertThatRuntimeException;
/**
* Integration tests for LocalContainerEntityManagerFactoryBean.
@@ -92,7 +94,7 @@ public abstract class AbstractContainerEntityManagerFactoryIntegrationTests
@Test
public void testBogusQuery() {
assertThatExceptionOfType(RuntimeException.class).isThrownBy(() -> {
assertThatRuntimeException().isThrownBy(() -> {
Query query = sharedEntityManager.createQuery("It's raining toads");
// required in OpenJPA case
query.executeUpdate();
@@ -101,7 +103,7 @@ public abstract class AbstractContainerEntityManagerFactoryIntegrationTests
@Test
public void testGetReferenceWhenNoRow() {
assertThatExceptionOfType(Exception.class).isThrownBy(() -> {
assertThatException().isThrownBy(() -> {
Person notThere = sharedEntityManager.getReference(Person.class, 666);
// We may get here (as with Hibernate). Either behaviour is valid:
// throw exception on first access or on getReference itself.
@@ -185,8 +187,7 @@ public abstract class AbstractContainerEntityManagerFactoryIntegrationTests
Query q = em.createQuery("select p from Person as p");
List<Person> people = q.getResultList();
assertThat(people.size()).isEqualTo(0);
assertThatExceptionOfType(NoResultException.class).isThrownBy(
q::getSingleResult);
assertThatExceptionOfType(NoResultException.class).isThrownBy(q::getSingleResult);
}
@Test
@@ -198,8 +199,7 @@ public abstract class AbstractContainerEntityManagerFactoryIntegrationTests
Query q = em.createQuery("select p from Person as p");
List<Person> people = q.getResultList();
assertThat(people.size()).isEqualTo(0);
assertThatExceptionOfType(NoResultException.class).isThrownBy(
q::getSingleResult);
assertThatExceptionOfType(NoResultException.class).isThrownBy(q::getSingleResult);
}
@Test
@@ -209,8 +209,7 @@ public abstract class AbstractContainerEntityManagerFactoryIntegrationTests
q.setFlushMode(FlushModeType.AUTO);
List<Person> people = q.getResultList();
assertThat(people.size()).isEqualTo(0);
assertThatExceptionOfType(NoResultException.class).isThrownBy(
q::getSingleResult);
assertThatExceptionOfType(NoResultException.class).isThrownBy(q::getSingleResult);
}
@Test
@@ -223,15 +222,15 @@ public abstract class AbstractContainerEntityManagerFactoryIntegrationTests
q.setFlushMode(FlushModeType.AUTO);
List<Person> people = q.getResultList();
assertThat(people.size()).isEqualTo(0);
assertThatExceptionOfType(Exception.class).isThrownBy(q::getSingleResult)
assertThatException()
.isThrownBy(q::getSingleResult)
.withMessageContaining("closed");
// We would typically expect an IllegalStateException, but Hibernate throws a
// PersistenceException. So we assert the contents of the exception message instead.
Query q2 = em.createQuery("select p from Person as p");
q2.setFlushMode(FlushModeType.AUTO);
assertThatExceptionOfType(NoResultException.class).isThrownBy(
q2::getSingleResult);
assertThatExceptionOfType(NoResultException.class).isThrownBy(q2::getSingleResult);
}
@Test

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

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2020 the original author or authors.
* Copyright 2002-2022 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -38,6 +38,7 @@ import org.springframework.transaction.support.TransactionTemplate;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.assertThatRuntimeException;
import static org.mockito.BDDMockito.given;
import static org.mockito.BDDMockito.willThrow;
import static org.mockito.Mockito.mock;
@@ -93,10 +94,8 @@ public class JpaTransactionManagerTests {
final List<String> l = new ArrayList<>();
l.add("test");
boolean condition3 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition3).isTrue();
boolean condition2 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition2).isTrue();
assertThat(!TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
Object result = tt.execute(status -> {
assertThat(TransactionSynchronizationManager.hasResource(factory)).isTrue();
@@ -105,10 +104,8 @@ public class JpaTransactionManagerTests {
});
assertThat(result).isSameAs(l);
boolean condition1 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition1).isTrue();
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
assertThat(!TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
verify(tx).commit();
verify(manager).flush();
@@ -124,10 +121,8 @@ public class JpaTransactionManagerTests {
final List<String> l = new ArrayList<>();
l.add("test");
boolean condition3 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition3).isTrue();
boolean condition2 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition2).isTrue();
assertThat(!TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
try {
Object result = tt.execute(status -> {
@@ -139,14 +134,11 @@ public class JpaTransactionManagerTests {
}
catch (TransactionSystemException tse) {
// expected
boolean condition = tse.getCause() instanceof RollbackException;
assertThat(condition).isTrue();
assertThat(tse.getCause() instanceof RollbackException).isTrue();
}
boolean condition1 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition1).isTrue();
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
assertThat(!TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
verify(manager).flush();
verify(manager).close();
@@ -160,22 +152,18 @@ public class JpaTransactionManagerTests {
final List<String> l = new ArrayList<>();
l.add("test");
boolean condition3 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition3).isTrue();
boolean condition2 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition2).isTrue();
assertThat(!TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThatExceptionOfType(RuntimeException.class).isThrownBy(() ->
assertThatRuntimeException().isThrownBy(() ->
tt.execute(status -> {
assertThat(TransactionSynchronizationManager.hasResource(factory)).isTrue();
EntityManagerFactoryUtils.getTransactionalEntityManager(factory);
throw new RuntimeException("some exception");
})).withMessage("some exception");
boolean condition1 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition1).isTrue();
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
assertThat(!TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
verify(tx).rollback();
verify(manager).close();
@@ -188,22 +176,18 @@ public class JpaTransactionManagerTests {
final List<String> l = new ArrayList<>();
l.add("test");
boolean condition3 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition3).isTrue();
boolean condition2 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition2).isTrue();
assertThat(!TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThatExceptionOfType(RuntimeException.class).isThrownBy(() ->
assertThatRuntimeException().isThrownBy(() ->
tt.execute(status -> {
assertThat(TransactionSynchronizationManager.hasResource(factory)).isTrue();
EntityManagerFactoryUtils.getTransactionalEntityManager(factory);
throw new RuntimeException("some exception");
}));
boolean condition1 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition1).isTrue();
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
assertThat(!TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
verify(manager).close();
}
@@ -216,10 +200,8 @@ public class JpaTransactionManagerTests {
final List<String> l = new ArrayList<>();
l.add("test");
boolean condition3 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition3).isTrue();
boolean condition2 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition2).isTrue();
assertThat(!TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
tt.execute(status -> {
assertThat(TransactionSynchronizationManager.hasResource(factory)).isTrue();
@@ -230,10 +212,8 @@ public class JpaTransactionManagerTests {
return l;
});
boolean condition1 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition1).isTrue();
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
assertThat(!TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
verify(manager).flush();
verify(tx).rollback();
@@ -247,10 +227,8 @@ public class JpaTransactionManagerTests {
final List<String> l = new ArrayList<>();
l.add("test");
boolean condition3 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition3).isTrue();
boolean condition2 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition2).isTrue();
assertThat(!TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
tt.execute(status -> {
assertThat(TransactionSynchronizationManager.hasResource(factory)).isTrue();
@@ -261,10 +239,8 @@ public class JpaTransactionManagerTests {
});
});
boolean condition1 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition1).isTrue();
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
assertThat(!TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
verify(manager).flush();
verify(tx).commit();
@@ -279,12 +255,10 @@ public class JpaTransactionManagerTests {
final List<String> l = new ArrayList<>();
l.add("test");
boolean condition3 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition3).isTrue();
boolean condition2 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition2).isTrue();
assertThat(!TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThatExceptionOfType(RuntimeException.class).isThrownBy(() ->
assertThatRuntimeException().isThrownBy(() ->
tt.execute(status -> {
assertThat(TransactionSynchronizationManager.hasResource(factory)).isTrue();
return tt.execute(status1 -> {
@@ -293,10 +267,8 @@ public class JpaTransactionManagerTests {
});
}));
boolean condition1 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition1).isTrue();
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
assertThat(!TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
verify(tx).setRollbackOnly();
verify(tx).rollback();
@@ -313,10 +285,8 @@ public class JpaTransactionManagerTests {
final List<String> l = new ArrayList<>();
l.add("test");
boolean condition3 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition3).isTrue();
boolean condition2 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition2).isTrue();
assertThat(!TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
assertThatExceptionOfType(TransactionSystemException.class).isThrownBy(() ->
tt.execute(status -> {
@@ -330,10 +300,8 @@ public class JpaTransactionManagerTests {
}))
.withCauseInstanceOf(RollbackException.class);
boolean condition1 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition1).isTrue();
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
assertThat(!TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
verify(manager).flush();
verify(tx).setRollbackOnly();
@@ -351,10 +319,8 @@ public class JpaTransactionManagerTests {
final List<String> l = new ArrayList<>();
l.add("test");
boolean condition3 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition3).isTrue();
boolean condition2 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition2).isTrue();
assertThat(!TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
Object result = tt.execute(status -> {
assertThat(TransactionSynchronizationManager.hasResource(factory)).isTrue();
@@ -365,10 +331,8 @@ public class JpaTransactionManagerTests {
});
assertThat(result).isSameAs(l);
boolean condition1 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition1).isTrue();
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
assertThat(!TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
verify(manager).flush();
verify(manager, times(2)).close();
@@ -384,10 +348,8 @@ public class JpaTransactionManagerTests {
final List<String> l = new ArrayList<>();
l.add("test");
boolean condition3 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition3).isTrue();
boolean condition2 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition2).isTrue();
assertThat(!TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.bindResource(factory, new EntityManagerHolder(manager));
@@ -407,10 +369,8 @@ public class JpaTransactionManagerTests {
TransactionSynchronizationManager.unbindResource(factory);
}
boolean condition1 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition1).isTrue();
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
assertThat(!TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
verify(tx, times(2)).begin();
verify(tx, times(2)).commit();
@@ -427,10 +387,8 @@ public class JpaTransactionManagerTests {
final List<String> l = new ArrayList<>();
l.add("test");
boolean condition3 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition3).isTrue();
boolean condition2 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition2).isTrue();
assertThat(!TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
Object result = tt.execute(status -> {
assertThat(TransactionSynchronizationManager.hasResource(factory)).isFalse();
@@ -443,10 +401,8 @@ public class JpaTransactionManagerTests {
});
assertThat(result).isSameAs(l);
boolean condition1 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition1).isTrue();
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
assertThat(!TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
verify(tx).commit();
verify(manager).flush();
@@ -464,10 +420,8 @@ public class JpaTransactionManagerTests {
final List<String> l = new ArrayList<>();
l.add("test");
boolean condition3 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition3).isTrue();
boolean condition2 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition2).isTrue();
assertThat(!TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
Object result = tt.execute(status -> {
EntityManagerFactoryUtils.getTransactionalEntityManager(factory);
@@ -482,10 +436,8 @@ public class JpaTransactionManagerTests {
});
assertThat(result).isSameAs(l);
boolean condition1 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition1).isTrue();
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
assertThat(!TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
verify(tx).commit();
verify(manager).flush();
@@ -504,10 +456,8 @@ public class JpaTransactionManagerTests {
given(manager2.getTransaction()).willReturn(tx2);
given(manager2.isOpen()).willReturn(true);
boolean condition3 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition3).isTrue();
boolean condition2 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition2).isTrue();
assertThat(!TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
tt.execute(status -> {
EntityManagerFactoryUtils.getTransactionalEntityManager(factory).flush();
@@ -523,10 +473,8 @@ public class JpaTransactionManagerTests {
return null;
});
boolean condition1 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition1).isTrue();
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
assertThat(!TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
verify(tx).commit();
verify(tx2).begin();
@@ -546,26 +494,20 @@ public class JpaTransactionManagerTests {
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);
boolean condition3 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition3).isTrue();
boolean condition2 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition2).isTrue();
assertThat(!TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
Object result = tt.execute(status -> {
boolean condition1 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition1).isTrue();
assertThat(!TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
boolean condition = !status.isNewTransaction();
assertThat(condition).isTrue();
assertThat(!status.isNewTransaction()).isTrue();
EntityManagerFactoryUtils.getTransactionalEntityManager(factory).flush();
return l;
});
assertThat(result).isSameAs(l);
boolean condition1 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition1).isTrue();
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
assertThat(!TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
verify(manager).flush();
verify(manager).close();
@@ -577,26 +519,20 @@ public class JpaTransactionManagerTests {
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);
boolean condition3 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition3).isTrue();
boolean condition2 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition2).isTrue();
assertThat(!TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
tt.execute(status -> {
boolean condition1 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition1).isTrue();
assertThat(!TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
boolean condition = !status.isNewTransaction();
assertThat(condition).isTrue();
assertThat(!status.isNewTransaction()).isTrue();
EntityManagerFactoryUtils.getTransactionalEntityManager(factory).flush();
status.setRollbackOnly();
return null;
});
boolean condition1 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition1).isTrue();
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
assertThat(!TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
verify(manager).flush();
verify(manager).close();
@@ -609,10 +545,8 @@ public class JpaTransactionManagerTests {
final List<String> l = new ArrayList<>();
l.add("test");
boolean condition2 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition2).isTrue();
boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition1).isTrue();
assertThat(!TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.bindResource(factory, new EntityManagerHolder(manager));
try {
@@ -625,8 +559,7 @@ public class JpaTransactionManagerTests {
assertThat(result).isSameAs(l);
assertThat(TransactionSynchronizationManager.hasResource(factory)).isTrue();
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
}
finally {
TransactionSynchronizationManager.unbindResource(factory);
@@ -641,10 +574,8 @@ public class JpaTransactionManagerTests {
given(manager.getTransaction()).willReturn(tx);
given(tx.isActive()).willReturn(true);
boolean condition2 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition2).isTrue();
boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition1).isTrue();
assertThat(!TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.bindResource(factory, new EntityManagerHolder(manager));
try {
@@ -657,8 +588,7 @@ public class JpaTransactionManagerTests {
});
assertThat(TransactionSynchronizationManager.hasResource(factory)).isTrue();
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
}
finally {
TransactionSynchronizationManager.unbindResource(factory);
@@ -676,26 +606,22 @@ public class JpaTransactionManagerTests {
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);
boolean condition2 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition2).isTrue();
boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition1).isTrue();
assertThat(!TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.bindResource(factory, new EntityManagerHolder(manager));
try {
Object result = tt.execute(status -> {
assertThat(TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
boolean condition = !status.isNewTransaction();
assertThat(condition).isTrue();
assertThat(!status.isNewTransaction()).isTrue();
EntityManagerFactoryUtils.getTransactionalEntityManager(factory).flush();
return l;
});
assertThat(result).isSameAs(l);
assertThat(TransactionSynchronizationManager.hasResource(factory)).isTrue();
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
}
finally {
TransactionSynchronizationManager.unbindResource(factory);
@@ -708,26 +634,22 @@ public class JpaTransactionManagerTests {
public void testTransactionRollbackWithPreboundAndPropagationSupports() {
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS);
boolean condition2 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition2).isTrue();
boolean condition1 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition1).isTrue();
assertThat(!TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
TransactionSynchronizationManager.bindResource(factory, new EntityManagerHolder(manager));
try {
tt.execute(status -> {
assertThat(TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
boolean condition = !status.isNewTransaction();
assertThat(condition).isTrue();
assertThat(!status.isNewTransaction()).isTrue();
EntityManagerFactoryUtils.getTransactionalEntityManager(factory).flush();
status.setRollbackOnly();
return null;
});
assertThat(TransactionSynchronizationManager.hasResource(factory)).isTrue();
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
}
finally {
TransactionSynchronizationManager.unbindResource(factory);
@@ -757,10 +679,8 @@ public class JpaTransactionManagerTests {
public void testTransactionFlush() {
given(manager.getTransaction()).willReturn(tx);
boolean condition3 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition3).isTrue();
boolean condition2 = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition2).isTrue();
assertThat(!TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
tt.execute(new TransactionCallbackWithoutResult() {
@Override
@@ -770,10 +690,8 @@ public class JpaTransactionManagerTests {
}
});
boolean condition1 = !TransactionSynchronizationManager.hasResource(factory);
assertThat(condition1).isTrue();
boolean condition = !TransactionSynchronizationManager.isSynchronizationActive();
assertThat(condition).isTrue();
assertThat(!TransactionSynchronizationManager.hasResource(factory)).isTrue();
assertThat(!TransactionSynchronizationManager.isSynchronizationActive()).isTrue();
verify(tx).commit();
verify(manager).flush();

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

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2019 the original author or authors.
* Copyright 2002-2022 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -38,7 +38,7 @@ import org.springframework.jdbc.datasource.lookup.JndiDataSourceLookup;
import org.springframework.jdbc.datasource.lookup.MapDataSourceLookup;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.assertThatRuntimeException;
/**
* Unit and integration tests for the JPA XML resource parsing support.
@@ -260,8 +260,7 @@ public class PersistenceXmlParsingTests {
PersistenceUnitReader reader = new PersistenceUnitReader(
new PathMatchingResourcePatternResolver(), new JndiDataSourceLookup());
String resource = "/org/springframework/orm/jpa/persistence-invalid.xml";
assertThatExceptionOfType(RuntimeException.class).isThrownBy(() ->
reader.readPersistenceUnitInfos(resource));
assertThatRuntimeException().isThrownBy(() -> reader.readPersistenceUnitInfos(resource));
}
@Disabled("not doing schema parsing anymore for JPA 2.0 compatibility")
@@ -270,8 +269,7 @@ public class PersistenceXmlParsingTests {
PersistenceUnitReader reader = new PersistenceUnitReader(
new PathMatchingResourcePatternResolver(), new JndiDataSourceLookup());
String resource = "/org/springframework/orm/jpa/persistence-no-schema.xml";
assertThatExceptionOfType(RuntimeException.class).isThrownBy(() ->
reader.readPersistenceUnitInfos(resource));
assertThatRuntimeException().isThrownBy(() -> reader.readPersistenceUnitInfos(resource));
}
@Test