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

Merge branch '2.7.x' into 3.0.x 

Closes gh-37965
This commit is contained in:
Phillip Webb 2023-10-19 20:21:41 -07:00
parent c16f9dda96 abdad1cabe
commit a0b999c8b4
28 changed files with 125 additions and 124 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
buildSrc/src/test/java/org/springframework/boot/build/mavenplugin/PluginXmlParserTests.java
View File

@ -24,7 +24,7 @@ import org.junit.jupiter.api.Test;
import org.springframework.boot.build.mavenplugin.PluginXmlParser.Plugin;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
/**
* Tests for {@link PluginXmlParser}.
@ -49,9 +49,9 @@ class PluginXmlParserTests {
@Test
void parseNonExistingFileThrowException() {
assertThatThrownBy(() -> this.parser.parse(new File("src/test/resources/nonexistent.xml")))
.isInstanceOf(RuntimeException.class)
.hasCauseInstanceOf(FileNotFoundException.class);
assertThatExceptionOfType(RuntimeException.class)
.isThrownBy(() -> this.parser.parse(new File("src/test/resources/nonexistent.xml")))
.withCauseInstanceOf(FileNotFoundException.class);
}
}

6
spring-boot-project/spring-boot-actuator-autoconfigure/src/test/java/org/springframework/boot/actuate/autoconfigure/metrics/orm/jpa/HibernateMetricsAutoConfigurationTests.java
View File

@ -50,7 +50,7 @@ import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
@ -117,8 +117,8 @@ class HibernateMetricsAutoConfigurationTests {
.withUserConfiguration(NonHibernateEntityManagerFactoryConfiguration.class)
.run((context) -> {
// ensure EntityManagerFactory is not a Hibernate SessionFactory
assertThatThrownBy(() -> context.getBean(EntityManagerFactory.class).unwrap(SessionFactory.class))
.isInstanceOf(PersistenceException.class);
assertThatExceptionOfType(PersistenceException.class)
.isThrownBy(() -> context.getBean(EntityManagerFactory.class).unwrap(SessionFactory.class));
MeterRegistry registry = context.getBean(MeterRegistry.class);
assertThat(registry.find("hibernate.statements").meter()).isNull();
});

6
spring-boot-project/spring-boot-actuator-autoconfigure/src/test/java/org/springframework/boot/actuate/autoconfigure/observation/ObservationAutoConfigurationTests.java
View File

@ -50,7 +50,7 @@ import org.springframework.context.annotation.Import;
import org.springframework.core.annotation.Order;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.mockito.Mockito.mock;
/**
@ -174,8 +174,8 @@ class ObservationAutoConfigurationTests {
Observation.start("observation2", observationRegistry).stop();
MeterRegistry meterRegistry = context.getBean(MeterRegistry.class);
assertThat(meterRegistry.get("observation1").timer().count()).isOne();
assertThatThrownBy(() -> meterRegistry.get("observation2").timer())
.isInstanceOf(MeterNotFoundException.class);
assertThatExceptionOfType(MeterNotFoundException.class)
.isThrownBy(() -> meterRegistry.get("observation2").timer());
});
}

5
spring-boot-project/spring-boot-actuator-autoconfigure/src/test/java/org/springframework/boot/actuate/autoconfigure/tracing/zipkin/ZipkinHttpSenderTests.java
View File

@ -32,7 +32,7 @@ import zipkin2.reporter.ClosedSenderException;
import zipkin2.reporter.Sender;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
/**
* Abstract base test class which is used for testing the different implementations of the
@ -54,7 +54,8 @@ abstract class ZipkinHttpSenderTests {
@Test
void sendSpansShouldThrowIfCloseWasCalled() throws IOException {
this.sut.close();
assertThatThrownBy(() -> this.sut.sendSpans(Collections.emptyList())).isInstanceOf(ClosedSenderException.class);
assertThatExceptionOfType(ClosedSenderException.class)
.isThrownBy(() -> this.sut.sendSpans(Collections.emptyList()));
}
protected void makeRequest(List<byte[]> encodedSpans, boolean async) throws IOException {

6
spring-boot-project/spring-boot-actuator-autoconfigure/src/test/java/org/springframework/boot/actuate/autoconfigure/tracing/zipkin/ZipkinRestTemplateSenderTests.java
View File

@ -34,7 +34,7 @@ import org.springframework.test.web.client.MockRestServiceServer;
import org.springframework.web.client.RestTemplate;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.assertj.core.api.Assertions.assertThatException;
import static org.springframework.test.web.client.match.MockRestRequestMatchers.content;
import static org.springframework.test.web.client.match.MockRestRequestMatchers.header;
import static org.springframework.test.web.client.match.MockRestRequestMatchers.method;
@ -107,8 +107,8 @@ class ZipkinRestTemplateSenderTests extends ZipkinHttpSenderTests {
assertThat(callbackResult.error()).isNotNull().hasMessageContaining("500 Internal Server Error");
}
else {
assertThatThrownBy(() -> makeSyncRequest(Collections.emptyList()))
.hasMessageContaining("500 Internal Server Error");
assertThatException().isThrownBy(() -> makeSyncRequest(Collections.emptyList()))
.withMessageContaining("500 Internal Server Error");
}
}

6
spring-boot-project/spring-boot-actuator-autoconfigure/src/test/java/org/springframework/boot/actuate/autoconfigure/tracing/zipkin/ZipkinWebClientSenderTests.java
View File

@ -36,7 +36,7 @@ import zipkin2.reporter.Sender;
import org.springframework.web.reactive.function.client.WebClient;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.assertj.core.api.Assertions.assertThatException;
/**
* Tests for {@link ZipkinWebClientSender}.
@ -112,8 +112,8 @@ class ZipkinWebClientSenderTests extends ZipkinHttpSenderTests {
assertThat(callbackResult.error()).isNotNull().hasMessageContaining("500 Internal Server Error");
}
else {
assertThatThrownBy(() -> makeSyncRequest(Collections.emptyList()))
.hasMessageContaining("500 Internal Server Error");
assertThatException().isThrownBy(() -> makeSyncRequest(Collections.emptyList()))
.withMessageContaining("500 Internal Server Error");
}
requestAssertions((request) -> assertThat(request.getMethod()).isEqualTo("POST"));

6
spring-boot-project/spring-boot-actuator-autoconfigure/src/test/java/org/springframework/boot/actuate/autoconfigure/wavefront/WavefrontPropertiesTests.java
View File

@ -23,7 +23,7 @@ import org.junit.jupiter.api.Test;
import org.springframework.boot.context.properties.source.InvalidConfigurationPropertyValueException;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
/**
* Tests for {@link WavefrontProperties}.
@ -47,8 +47,8 @@ class WavefrontPropertiesTests {
sut.setUri(URI.create("http://localhost:2878"));
sut.setApiToken(null);
assertThat(sut.getEffectiveUri()).isEqualTo(URI.create("http://localhost:2878"));
assertThatThrownBy(sut::getApiTokenOrThrow).isInstanceOf(InvalidConfigurationPropertyValueException.class)
.hasMessageContaining("management.wavefront.api-token");
assertThatExceptionOfType(InvalidConfigurationPropertyValueException.class).isThrownBy(sut::getApiTokenOrThrow)
.withMessageContaining("management.wavefront.api-token");
}
}

10
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/cassandra/CassandraAutoConfigurationTests.java
View File

@ -31,13 +31,14 @@ import com.datastax.oss.driver.internal.core.session.throttling.PassThroughReque
import com.datastax.oss.driver.internal.core.session.throttling.RateLimitingRequestThrottler;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.BeanCreationException;
import org.springframework.boot.autoconfigure.AutoConfigurations;
import org.springframework.boot.test.context.runner.ApplicationContextRunner;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
/**
* Tests for {@link CassandraAutoConfiguration}
@ -215,9 +216,10 @@ class CassandraAutoConfigurationTests {
@Test
void driverConfigLoaderWithRateLimitingRequiresExtraConfiguration() {
this.contextRunner.withPropertyValues("spring.cassandra.request.throttler.type=rate-limiting")
.run((context) -> assertThatThrownBy(() -> context.getBean(CqlSession.class))
.hasMessageContaining("Error instantiating class RateLimitingRequestThrottler")
.hasMessageContaining("No configuration setting found for key"));
.run((context) -> assertThatExceptionOfType(BeanCreationException.class)
.isThrownBy(() -> context.getBean(CqlSession.class))
.withMessageContaining("Error instantiating class RateLimitingRequestThrottler")
.withMessageContaining("No configuration setting found for key"));
}
@Test

8
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/cassandra/CassandraAutoConfigurationWithPasswordAuthenticationIntegrationTests.java
View File

@ -34,13 +34,14 @@ import org.testcontainers.images.builder.Transferable;
import org.testcontainers.junit.jupiter.Container;
import org.testcontainers.junit.jupiter.Testcontainers;
import org.springframework.beans.factory.BeanCreationException;
import org.springframework.boot.autoconfigure.AutoConfigurations;
import org.springframework.boot.test.context.runner.ApplicationContextRunner;
import org.springframework.boot.testsupport.testcontainers.CassandraContainer;
import org.springframework.util.StreamUtils;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
/**
* Tests for {@link CassandraAutoConfiguration} that only uses password authentication.
@ -77,8 +78,9 @@ class CassandraAutoConfigurationWithPasswordAuthenticationIntegrationTests {
void authenticationWithInvalidCredentials() {
this.contextRunner
.withPropertyValues("spring.cassandra.username=not-a-user", "spring.cassandra.password=invalid-password")
.run((context) -> assertThatThrownBy(() -> context.getBean(CqlSession.class))
.hasMessageContaining("Authentication error"));
.run((context) -> assertThatExceptionOfType(BeanCreationException.class)
.isThrownBy(() -> context.getBean(CqlSession.class))
.withMessageContaining("Authentication error"));
}
static final class PasswordAuthenticatorCassandraContainer extends CassandraContainer {

4
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/condition/OnBeanConditionTypeDeductionFailureTests.java
View File

@ -29,7 +29,7 @@ import org.springframework.context.annotation.ImportSelector;
import org.springframework.core.type.AnnotationMetadata;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.assertThatException;
/**
* Tests for {@link OnBeanCondition} when deduction of the bean's type fails
@ -41,7 +41,7 @@ class OnBeanConditionTypeDeductionFailureTests {
@Test
void conditionalOnMissingBeanWithDeducedTypeThatIsPartiallyMissingFromClassPath() {
assertThatExceptionOfType(Exception.class)
assertThatException()
.isThrownBy(() -> new AnnotationConfigApplicationContext(ImportingConfiguration.class).close())
.satisfies((ex) -> {
Throwable beanTypeDeductionException = findNestedCause(ex, BeanTypeDeductionException.class);

12
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/integration/IntegrationPropertiesEnvironmentPostProcessorTests.java
View File

@ -34,7 +34,7 @@ import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.mockito.Mockito.mock;
/**
@ -69,11 +69,11 @@ class IntegrationPropertiesEnvironmentPostProcessorTests {
void registerIntegrationPropertiesPropertySourceWithUnknownResourceThrowsException() {
ConfigurableEnvironment environment = new StandardEnvironment();
ClassPathResource unknown = new ClassPathResource("does-not-exist.properties", getClass());
assertThatThrownBy(() -> new IntegrationPropertiesEnvironmentPostProcessor()
.registerIntegrationPropertiesPropertySource(environment, unknown))
.isInstanceOf(IllegalStateException.class)
.hasCauseInstanceOf(FileNotFoundException.class)
.hasMessageContaining(unknown.toString());
assertThatIllegalStateException()
.isThrownBy(() -> new IntegrationPropertiesEnvironmentPostProcessor()
.registerIntegrationPropertiesPropertySource(environment, unknown))
.withCauseInstanceOf(FileNotFoundException.class)
.withMessageContaining(unknown.toString());
}
@Test

10
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jackson/JacksonAutoConfigurationTests.java
View File

@ -73,7 +73,7 @@ import org.springframework.context.annotation.Primary;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.entry;
import static org.mockito.Mockito.mock;
@ -339,10 +339,10 @@ class JacksonAutoConfigurationTests {
void disableDefaultLeniency() {
this.contextRunner.withPropertyValues("spring.jackson.default-leniency:false").run((context) -> {
ObjectMapper mapper = context.getBean(ObjectMapper.class);
assertThatThrownBy(() -> mapper.readValue("{\"birthDate\": \"2010-12-30\"}", Person.class))
.isInstanceOf(InvalidFormatException.class)
.hasMessageContaining("expected format")
.hasMessageContaining("yyyyMMdd");
assertThatExceptionOfType(InvalidFormatException.class)
.isThrownBy(() -> mapper.readValue("{\"birthDate\": \"2010-12-30\"}", Person.class))
.withMessageContaining("expected format")
.withMessageContaining("yyyyMMdd");
});
}

6
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/logging/ConditionEvaluationReportLoggingListenerTests.java
View File

@ -39,7 +39,7 @@ import org.springframework.context.annotation.Import;
import org.springframework.mock.web.MockServletContext;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.assertThatException;
/**
* Tests for {@link ConditionEvaluationReportLoggingListener}.
@ -67,7 +67,7 @@ class ConditionEvaluationReportLoggingListenerTests {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
this.initializer.initialize(context);
context.register(ErrorConfig.class);
assertThatExceptionOfType(Exception.class).isThrownBy(context::refresh)
assertThatException().isThrownBy(context::refresh)
.satisfies((ex) -> withDebugLogging(() -> context
.publishEvent(new ApplicationFailedEvent(new SpringApplication(), new String[0], context, ex))));
assertThat(output).contains("CONDITIONS EVALUATION REPORT");
@ -78,7 +78,7 @@ class ConditionEvaluationReportLoggingListenerTests {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
this.initializer.initialize(context);
context.register(ErrorConfig.class);
assertThatExceptionOfType(Exception.class).isThrownBy(context::refresh)
assertThatException().isThrownBy(context::refresh)
.satisfies((ex) -> withInfoLogging(() -> context
.publishEvent(new ApplicationFailedEvent(new SpringApplication(), new String[0], context, ex))));
assertThat(output).doesNotContain("CONDITIONS EVALUATION REPORT")

6
spring-boot-project/spring-boot-test/src/test/java/org/springframework/boot/test/context/runner/ContextConsumerTests.java
View File

@ -24,8 +24,8 @@ import org.mockito.InOrder;
import org.springframework.context.ApplicationContext;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.BDDMockito.given;
import static org.mockito.BDDMockito.then;
import static org.mockito.Mockito.inOrder;
@ -59,8 +59,8 @@ class ContextConsumerTests {
given(predicate.test(24)).willReturn(false);
ContextConsumer<ApplicationContext> firstConsumer = (context) -> assertThat(predicate.test(42)).isFalse();
ContextConsumer<ApplicationContext> secondConsumer = (context) -> assertThat(predicate.test(24)).isFalse();
assertThatThrownBy(() -> firstConsumer.andThen(secondConsumer).accept(mock(ApplicationContext.class)))
.isInstanceOf(AssertionError.class);
assertThatExceptionOfType(AssertionError.class)
.isThrownBy(() -> firstConsumer.andThen(secondConsumer).accept(mock(ApplicationContext.class)));
then(predicate).should().test(42);
then(predicate).shouldHaveNoMoreInteractions();
}

6
spring-boot-project/spring-boot-tools/spring-boot-gradle-plugin/src/test/java/org/springframework/boot/gradle/tasks/buildinfo/BuildInfoTests.java
View File

@ -33,7 +33,7 @@ import org.springframework.boot.gradle.junit.GradleProjectBuilder;
import org.springframework.boot.testsupport.classpath.ClassPathExclusions;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.assertj.core.api.Assertions.assertThatException;
/**
* Tests for {@link BuildInfo}.
@ -167,8 +167,8 @@ class BuildInfoTests {
@Test
void nullAdditionalPropertyProducesInformativeFailure() {
BuildInfo task = createTask(createProject("test"));
assertThatThrownBy(() -> task.getProperties().getAdditional().put("a", null))
.hasMessage("Cannot add an entry with a null value to a property of type Map.");
assertThatException().isThrownBy(() -> task.getProperties().getAdditional().put("a", null))
.withMessage("Cannot add an entry with a null value to a property of type Map.");
}
private Project createProject(String projectName) {

7
spring-boot-project/spring-boot/src/test/java/org/springframework/boot/SpringApplicationShutdownHookTests.java
View File

@ -35,9 +35,9 @@ import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.GenericApplicationContext;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
/**
* Tests for {@link SpringApplicationShutdownHook}.
@ -163,8 +163,7 @@ class SpringApplicationShutdownHookTests {
ConfigurableApplicationContext context = new GenericApplicationContext();
shutdownHook.registerApplicationContext(context);
context.refresh();
assertThatThrownBy(() -> shutdownHook.deregisterFailedApplicationContext(context))
.isInstanceOf(IllegalStateException.class);
assertThatIllegalStateException().isThrownBy(() -> shutdownHook.deregisterFailedApplicationContext(context));
assertThat(shutdownHook.isApplicationContextRegistered(context)).isTrue();
}
@ -174,7 +173,7 @@ class SpringApplicationShutdownHookTests {
GenericApplicationContext context = new GenericApplicationContext();
shutdownHook.registerApplicationContext(context);
context.registerBean(FailingBean.class);
assertThatThrownBy(context::refresh).isInstanceOf(BeanCreationException.class);
assertThatExceptionOfType(BeanCreationException.class).isThrownBy(context::refresh);
assertThat(shutdownHook.isApplicationContextRegistered(context)).isTrue();
shutdownHook.deregisterFailedApplicationContext(context);
assertThat(shutdownHook.isApplicationContextRegistered(context)).isFalse();

14
spring-boot-project/spring-boot/src/test/java/org/springframework/boot/context/metrics/buffering/BufferingApplicationStartupTests.java
View File

@ -27,7 +27,8 @@ import org.springframework.boot.context.metrics.buffering.StartupTimeline.Timeli
import org.springframework.core.metrics.StartupStep;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
/**
* Tests for {@link BufferingApplicationStartup}.
@ -86,8 +87,8 @@ class BufferingApplicationStartupTests {
void startRecordingShouldFailIfEventsWereRecorded() {
BufferingApplicationStartup applicationStartup = new BufferingApplicationStartup(2);
applicationStartup.start("first").end();
assertThatThrownBy(applicationStartup::startRecording).isInstanceOf(IllegalStateException.class)
.hasMessage("Cannot restart recording once steps have been buffered.");
assertThatIllegalStateException().isThrownBy(applicationStartup::startRecording)
.withMessage("Cannot restart recording once steps have been buffered.");
}
@Test
@ -95,8 +96,8 @@ class BufferingApplicationStartupTests {
BufferingApplicationStartup applicationStartup = new BufferingApplicationStartup(2);
StartupStep step = applicationStartup.start("first");
step.end();
assertThatThrownBy(() -> step.tag("name", "value")).isInstanceOf(IllegalStateException.class)
.hasMessage("StartupStep has already ended.");
assertThatIllegalStateException().isThrownBy(() -> step.tag("name", "value"))
.withMessage("StartupStep has already ended.");
}
@Test
@ -104,7 +105,8 @@ class BufferingApplicationStartupTests {
BufferingApplicationStartup applicationStartup = new BufferingApplicationStartup(2);
StartupStep step = applicationStartup.start("first");
step.tag("name", "value");
assertThatThrownBy(() -> step.getTags().iterator().remove()).isInstanceOf(UnsupportedOperationException.class);
assertThatExceptionOfType(UnsupportedOperationException.class)
.isThrownBy(() -> step.getTags().iterator().remove());
}
@Test // gh-25792

28
spring-boot-project/spring-boot/src/test/java/org/springframework/boot/context/properties/ConfigurationPropertiesTests.java
View File

@ -101,6 +101,7 @@ import org.springframework.validation.Validator;
import org.springframework.validation.annotation.Validated;
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.entry;
@ -709,11 +710,10 @@ class ConfigurationPropertiesTests {
@Test
void loadWhenHasConfigurationPropertiesValidatorShouldApplyValidator() {
assertThatExceptionOfType(Exception.class).isThrownBy(() -> load(WithCustomValidatorConfiguration.class))
.satisfies((ex) -> {
assertThat(ex).hasCauseInstanceOf(BindException.class);
assertThat(ex.getCause()).hasCauseExactlyInstanceOf(BindValidationException.class);
});
assertThatException().isThrownBy(() -> load(WithCustomValidatorConfiguration.class)).satisfies((ex) -> {
assertThat(ex).hasCauseInstanceOf(BindException.class);
assertThat(ex.getCause()).hasCauseExactlyInstanceOf(BindValidationException.class);
});
}
@Test
@ -726,7 +726,7 @@ class ConfigurationPropertiesTests {
@Test
void loadWhenConfigurationPropertiesIsAlsoValidatorShouldApplyValidator() {
assertThatExceptionOfType(Exception.class).isThrownBy(() -> load(ValidatorProperties.class)).satisfies((ex) -> {
assertThatException().isThrownBy(() -> load(ValidatorProperties.class)).satisfies((ex) -> {
assertThat(ex).hasCauseInstanceOf(BindException.class);
assertThat(ex.getCause()).hasCauseExactlyInstanceOf(BindValidationException.class);
});
@ -734,8 +734,7 @@ class ConfigurationPropertiesTests {
@Test
void loadWhenConstructorBoundConfigurationPropertiesIsAlsoValidatorShouldApplyValidator() {
assertThatExceptionOfType(Exception.class)
.isThrownBy(() -> load(ValidatorConstructorBoundPropertiesConfiguration.class))
assertThatException().isThrownBy(() -> load(ValidatorConstructorBoundPropertiesConfiguration.class))
.satisfies((ex) -> {
assertThat(ex).hasCauseInstanceOf(BindException.class);
assertThat(ex.getCause()).hasCauseExactlyInstanceOf(BindValidationException.class);
@ -909,8 +908,7 @@ class ConfigurationPropertiesTests {
Map<String, Object> source = new HashMap<>();
source.put("test.duration", "P12D");
sources.addLast(new MapPropertySource("test", source));
assertThatExceptionOfType(Exception.class)
.isThrownBy(() -> load(ConstructorParameterWithFormatConfiguration.class))
assertThatException().isThrownBy(() -> load(ConstructorParameterWithFormatConfiguration.class))
.havingCause()
.isInstanceOf(BindException.class);
}
@ -921,8 +919,7 @@ class ConfigurationPropertiesTests {
Map<String, Object> source = new HashMap<>();
source.put("test.period", "P12D");
sources.addLast(new MapPropertySource("test", source));
assertThatExceptionOfType(Exception.class)
.isThrownBy(() -> load(ConstructorParameterWithFormatConfiguration.class))
assertThatException().isThrownBy(() -> load(ConstructorParameterWithFormatConfiguration.class))
.havingCause()
.isInstanceOf(BindException.class);
}
@ -938,8 +935,7 @@ class ConfigurationPropertiesTests {
@Test
void loadWhenBindingToConstructorParametersShouldValidate() {
assertThatExceptionOfType(Exception.class)
.isThrownBy(() -> load(ConstructorParameterValidationConfiguration.class))
assertThatException().isThrownBy(() -> load(ConstructorParameterValidationConfiguration.class))
.satisfies((ex) -> {
assertThat(ex).hasCauseInstanceOf(BindException.class);
assertThat(ex.getCause()).hasCauseExactlyInstanceOf(BindValidationException.class);
@ -3062,7 +3058,7 @@ class ConfigurationPropertiesTests {
@Bean
@ConfigurationPropertiesBinding
static Converter<ArrayList<?>, CustomList<?>> arrayListToCustomList() {
return new Converter<ArrayList<?>, CustomList<?>>() {
return new Converter<>() {
@Override
public CustomList<?> convert(ArrayList<?> source) {
@ -3096,7 +3092,7 @@ class ConfigurationPropertiesTests {
@Bean
@ConfigurationPropertiesBinding
static Converter<ArrayList<?>, CustomList<?>> arrayListToCustomList() {
return new Converter<ArrayList<?>, CustomList<?>>() {
return new Converter<>() {
@Override
public CustomList<?> convert(ArrayList<?> source) {

4
spring-boot-project/spring-boot/src/test/java/org/springframework/boot/diagnostics/FailureAnalyzersIntegrationTests.java
View File

@ -28,7 +28,7 @@ import org.springframework.boot.web.server.PortInUseException;
import org.springframework.context.annotation.Configuration;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.assertThatException;
/**
* Integration tests for {@link FailureAnalyzers}.
@ -40,7 +40,7 @@ class FailureAnalyzersIntegrationTests {
@Test
void analysisIsPerformed(CapturedOutput output) {
assertThatExceptionOfType(Exception.class)
assertThatException()
.isThrownBy(() -> new SpringApplicationBuilder(TestConfiguration.class).web(WebApplicationType.NONE).run());
assertThat(output).contains("APPLICATION FAILED TO START");
}

5
spring-boot-project/spring-boot/src/test/java/org/springframework/boot/diagnostics/analyzer/JakartaApiValidationExceptionFailureAnalyzerTests.java
View File

@ -25,7 +25,7 @@ import org.springframework.context.annotation.AnnotationConfigApplicationContext
import org.springframework.validation.annotation.Validated;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.assertThatException;
/**
* Tests for {@link ValidationExceptionFailureAnalyzer}
@ -37,8 +37,7 @@ class JakartaApiValidationExceptionFailureAnalyzerTests {
@Test
void validatedPropertiesTest() {
assertThatExceptionOfType(Exception.class)
.isThrownBy(() -> new AnnotationConfigApplicationContext(TestConfiguration.class).close())
assertThatException().isThrownBy(() -> new AnnotationConfigApplicationContext(TestConfiguration.class).close())
.satisfies((ex) -> assertThat(new ValidationExceptionFailureAnalyzer().analyze(ex)).isNotNull());
}

4
spring-boot-project/spring-boot/src/test/java/org/springframework/boot/jdbc/init/DataSourceScriptDatabaseInitializerTests.java
View File

@ -34,7 +34,7 @@ import org.springframework.jdbc.datasource.init.ResourceDatabasePopulator;
import org.springframework.jdbc.datasource.init.ScriptStatementFailedException;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
/**
* Tests for {@link DataSourceScriptDatabaseInitializer}.
@ -82,7 +82,7 @@ class DataSourceScriptDatabaseInitializerTests
populator.setContinueOnError(false);
}
};
assertThatThrownBy(initializer::initializeDatabase).isInstanceOf(ScriptStatementFailedException.class);
assertThatExceptionOfType(ScriptStatementFailedException.class).isThrownBy(initializer::initializeDatabase);
}
@Override

6
spring-boot-project/spring-boot/src/test/java/org/springframework/boot/validation/MessageSourceMessageInterpolatorIntegrationTests.java
View File

@ -32,7 +32,7 @@ import org.springframework.context.support.StaticMessageSource;
import org.springframework.validation.beanvalidation.LocalValidatorFactoryBean;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.assertj.core.api.Assertions.assertThatException;
/**
* Integration tests for {@link MessageSourceMessageInterpolator}.
@ -85,8 +85,8 @@ class MessageSourceMessageInterpolatorIntegrationTests {
@Test
void recursion() {
assertThatThrownBy(() -> validate("recursion"))
.hasStackTraceContaining("Circular reference '{recursion -> middle -> recursion}'");
assertThatException().isThrownBy(() -> validate("recursion"))
.withStackTraceContaining("Circular reference '{recursion -> middle -> recursion}'");
}
@Test

5
spring-boot-project/spring-boot/src/test/java/org/springframework/boot/web/embedded/jetty/SslServerCustomizerTests.java
View File

@ -38,7 +38,7 @@ import org.springframework.boot.web.server.Ssl;
import org.springframework.boot.web.server.WebServerException;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.assertThatException;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.assertj.core.api.Assertions.assertThatNoException;
@ -92,8 +92,7 @@ class SslServerCustomizerTests {
void configureSslWhenSslIsEnabledWithNoKeyStoreAndNotPkcs11ThrowsException() {
Ssl ssl = new Ssl();
SslServerCustomizer customizer = new SslServerCustomizer(null, ssl, null, null);
assertThatExceptionOfType(Exception.class)
.isThrownBy(() -> customizer.configureSsl(new SslContextFactory.Server(), ssl, null))
assertThatException().isThrownBy(() -> customizer.configureSsl(new SslContextFactory.Server(), ssl, null))
.satisfies((ex) -> {
assertThat(ex).isInstanceOf(WebServerException.class);
assertThat(ex).hasMessageContaining("Could not load key store 'null'");

9
spring-boot-project/spring-boot/src/test/java/org/springframework/boot/web/reactive/server/AbstractReactiveWebServerFactoryTests.java
View File

@ -77,7 +77,7 @@ import org.springframework.web.reactive.function.client.WebClient;
import org.springframework.web.reactive.function.client.WebClientRequestException;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.assertj.core.api.Assertions.assertThatException;
/**
* Base for testing classes that extends {@link AbstractReactiveWebServerFactory}.
@ -210,7 +210,8 @@ public abstract class AbstractReactiveWebServerFactoryTests {
}
protected void assertThatSslWithInvalidAliasCallFails(ThrowingCallable call) {
assertThatThrownBy(call).hasStackTraceContaining("Keystore does not contain specified alias 'test-alias-404'");
assertThatException().isThrownBy(call)
.withStackTraceContaining("Keystore does not contain specified alias 'test-alias-404'");
}
protected ReactorClientHttpConnector buildTrustAllSslConnector() {
@ -399,8 +400,8 @@ public abstract class AbstractReactiveWebServerFactoryTests {
@Test
void whenSslIsEnabledAndNoKeyStoreIsConfiguredThenServerFailsToStart() {
assertThatThrownBy(() -> testBasicSslWithKeyStore(null, null))
.hasMessageContaining("Could not load key store 'null'");
assertThatException().isThrownBy(() -> testBasicSslWithKeyStore(null, null))
.withMessageContaining("Could not load key store 'null'");
}
@Test

37
spring-boot-project/spring-boot/src/test/java/org/springframework/boot/web/server/PrivateKeyParserTests.java
View File

@ -26,7 +26,6 @@ import org.junit.jupiter.params.provider.ValueSource;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
/**
* Tests for {@link PrivateKeyParser}.
@ -73,12 +72,12 @@ class PrivateKeyParserTests {
})
// @formatter:on
void shouldNotParseUnsupportedTraditionalPkcs1(String file) {
assertThatThrownBy(() -> PrivateKeyParser.parse("classpath:org/springframework/boot/web/server/pkcs1/" + file))
.isInstanceOf(IllegalStateException.class)
.hasMessageContaining("Error loading private key file")
.hasCauseInstanceOf(IllegalStateException.class)
.cause()
.hasMessageContaining("Unrecognized private key format");
assertThatIllegalStateException()
.isThrownBy(() -> PrivateKeyParser.parse("classpath:org/springframework/boot/web/server/pkcs1/" + file))
.withMessageContaining("Error loading private key file")
.withCauseInstanceOf(IllegalStateException.class)
.havingCause()
.withMessageContaining("Unrecognized private key format");
}
@ParameterizedTest
@ -116,12 +115,12 @@ class PrivateKeyParserTests {
})
// @formatter:on
void shouldNotParseUnsupportedEcPkcs8(String file) {
assertThatThrownBy(() -> PrivateKeyParser.parse("classpath:org/springframework/boot/web/server/pkcs8/" + file))
.isInstanceOf(IllegalStateException.class)
.hasMessageContaining("Error loading private key file")
.hasCauseInstanceOf(IllegalStateException.class)
.cause()
.hasMessageContaining("Unrecognized private key format");
assertThatIllegalStateException()
.isThrownBy(() -> PrivateKeyParser.parse("classpath:org/springframework/boot/web/server/pkcs8/" + file))
.withMessageContaining("Error loading private key file")
.withCauseInstanceOf(IllegalStateException.class)
.havingCause()
.withMessageContaining("Unrecognized private key format");
}
@ParameterizedTest
@ -187,12 +186,12 @@ class PrivateKeyParserTests {
})
// @formatter:on
void shouldNotParseUnsupportedEcSec1(String file) {
assertThatThrownBy(() -> PrivateKeyParser.parse("classpath:org/springframework/boot/web/server/sec1/" + file))
.isInstanceOf(IllegalStateException.class)
.hasMessageContaining("Error loading private key file")
.hasCauseInstanceOf(IllegalStateException.class)
.cause()
.hasMessageContaining("Unrecognized private key format");
assertThatIllegalStateException()
.isThrownBy(() -> PrivateKeyParser.parse("classpath:org/springframework/boot/web/server/sec1/" + file))
.withMessageContaining("Error loading private key file")
.withCauseInstanceOf(IllegalStateException.class)
.havingCause()
.withMessageContaining("Unrecognized private key format");
}
@Test

14
spring-boot-project/spring-boot/src/test/java/org/springframework/boot/web/server/SslConfigurationValidatorTests.java
View File

@ -24,7 +24,7 @@ import java.security.KeyStoreException;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
/**
* Tests for {@link SslConfigurationValidator}.
@ -65,17 +65,17 @@ class SslConfigurationValidatorTests {
@Test
void validateKeyAliasWhenAliasNotFoundShouldThrowException() {
assertThatThrownBy(() -> SslConfigurationValidator.validateKeyAlias(this.keyStore, INVALID_ALIAS))
.isInstanceOf(IllegalStateException.class)
.hasMessage("Keystore does not contain specified alias '" + INVALID_ALIAS + "'");
assertThatIllegalStateException()
.isThrownBy(() -> SslConfigurationValidator.validateKeyAlias(this.keyStore, INVALID_ALIAS))
.withMessage("Keystore does not contain specified alias '" + INVALID_ALIAS + "'");
}
@Test
void validateKeyAliasWhenKeyStoreThrowsExceptionOnContains() throws KeyStoreException {
KeyStore uninitializedKeyStore = KeyStore.getInstance(KeyStore.getDefaultType());
assertThatThrownBy(() -> SslConfigurationValidator.validateKeyAlias(uninitializedKeyStore, "alias"))
.isInstanceOf(IllegalStateException.class)
.hasMessage("Could not determine if keystore contains alias 'alias'");
assertThatIllegalStateException()
.isThrownBy(() -> SslConfigurationValidator.validateKeyAlias(uninitializedKeyStore, "alias"))
.withMessage("Could not determine if keystore contains alias 'alias'");
}
}

5
spring-boot-project/spring-boot/src/test/java/org/springframework/boot/web/servlet/server/AbstractServletWebServerFactoryTests.java
View File

@ -148,11 +148,11 @@ import org.springframework.util.FileCopyUtils;
import org.springframework.util.StreamUtils;
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.assertThatIOException;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.assertj.core.api.Assertions.fail;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.BDDMockito.given;
@ -473,7 +473,8 @@ public abstract class AbstractServletWebServerFactoryTests {
}
protected void assertThatSslWithInvalidAliasCallFails(ThrowingCallable call) {
assertThatThrownBy(call).hasStackTraceContaining("Keystore does not contain specified alias 'test-alias-404'");
assertThatException().isThrownBy(call)
.withStackTraceContaining("Keystore does not contain specified alias 'test-alias-404'");
}
@Test

6
spring-boot-tests/spring-boot-smoke-tests/spring-boot-smoke-test-test/src/test/java/smoketest/test/web/UserVehicleControllerTests.java
View File

@ -16,7 +16,6 @@
package smoketest.test.web;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;
import smoketest.test.WelcomeCommandLineRunner;
import smoketest.test.domain.VehicleIdentificationNumber;
@ -31,6 +30,7 @@ import org.springframework.context.ApplicationContext;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.hamcrest.Matchers.containsString;
import static org.mockito.BDDMockito.given;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
@ -96,8 +96,8 @@ class UserVehicleControllerTests {
@Test
void welcomeCommandLineRunnerShouldNotBeAvailable() {
// Since we're a @WebMvcTest WelcomeCommandLineRunner should not be available.
Assertions.assertThatThrownBy(() -> this.applicationContext.getBean(WelcomeCommandLineRunner.class))
.isInstanceOf(NoSuchBeanDefinitionException.class);
assertThatExceptionOfType(NoSuchBeanDefinitionException.class)
.isThrownBy(() -> this.applicationContext.getBean(WelcomeCommandLineRunner.class));
}
}