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

Simplify AssertJ assertions and also make them more readable

Browse Source 
See gh-33653
This commit is contained in:
Krzysztof Krason
2022-12-29 17:52:45 +01:00
committed by Moritz Halbritter
parent c9a2b2ab66
commit cf6493f65c
345 changed files with 1258 additions and 1292 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/AbstractDependsOnBeanFactoryPostProcessorTests.java
View File

@@ -75,7 +75,7 @@ class AbstractDependsOnBeanFactoryPostProcessorTests {
@Test
void postProcessorHasADefaultOrderOfZero() {
assertThat(new FooDependsOnBarTypePostProcessor().getOrder()).isEqualTo(0);
assertThat(new FooDependsOnBarTypePostProcessor().getOrder()).isZero();
}
private void assertThatFooDependsOnBar(AssertableApplicationContext context) {

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

@@ -125,7 +125,7 @@ class ImportAutoConfigurationImportSelectorTests {
Set<Object> set2 = this.importSelector
.determineImports(getAnnotationMetadata(ImportMetaAutoConfigurationWithUnrelatedTwo.class));
assertThat(set1).isEqualTo(set2);
assertThat(set1.hashCode()).isEqualTo(set2.hashCode());
assertThat(set1).hasSameHashCodeAs(set2);
}
@Test
@@ -153,7 +153,7 @@ class ImportAutoConfigurationImportSelectorTests {
Set<Object> set2 = this.importSelector
.determineImports(getAnnotationMetadata(ImportMetaAutoConfigurationExcludeWithUnrelatedTwo.class));
assertThat(set1).isEqualTo(set2);
assertThat(set1.hashCode()).isEqualTo(set2.hashCode());
assertThat(set1).hasSameHashCodeAs(set2);
}
@Test

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

@@ -39,28 +39,28 @@ class SpringBootApplicationTests {
void proxyBeanMethodsIsEnabledByDefault() {
AnnotationAttributes attributes = AnnotatedElementUtils
.getMergedAnnotationAttributes(DefaultSpringBootApplication.class, Configuration.class);
assertThat(attributes.get("proxyBeanMethods")).isEqualTo(true);
assertThat(attributes).containsEntry("proxyBeanMethods", true);
}
@Test
void proxyBeanMethodsCanBeDisabled() {
AnnotationAttributes attributes = AnnotatedElementUtils
.getMergedAnnotationAttributes(NoBeanMethodProxyingSpringBootApplication.class, Configuration.class);
assertThat(attributes.get("proxyBeanMethods")).isEqualTo(false);
assertThat(attributes).containsEntry("proxyBeanMethods", false);
}
@Test
void nameGeneratorDefaultToBeanNameGenerator() {
AnnotationAttributes attributes = AnnotatedElementUtils
.getMergedAnnotationAttributes(DefaultSpringBootApplication.class, ComponentScan.class);
assertThat(attributes.get("nameGenerator")).isEqualTo(BeanNameGenerator.class);
assertThat(attributes).containsEntry("nameGenerator", BeanNameGenerator.class);
}
@Test
void nameGeneratorCanBeSpecified() {
AnnotationAttributes attributes = AnnotatedElementUtils
.getMergedAnnotationAttributes(CustomNameGeneratorConfiguration.class, ComponentScan.class);
assertThat(attributes.get("nameGenerator")).isEqualTo(TestBeanNameGenerator.class);
assertThat(attributes).containsEntry("nameGenerator", TestBeanNameGenerator.class);
}
@SpringBootApplication

2
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/batch/BatchAutoConfigurationTests.java
View File

@@ -255,7 +255,7 @@ class BatchAutoConfigurationTests {
PlatformTransactionManager transactionManager = context.getBean(PlatformTransactionManager.class);
// It's a lazy proxy, but it does render its target if you ask for
// toString():
assertThat(transactionManager.toString().contains("JpaTransactionManager")).isTrue();
assertThat(transactionManager.toString()).contains("JpaTransactionManager");
assertThat(context).hasSingleBean(EntityManagerFactory.class);
// Ensure the JobRepository can be used (no problem with isolation
// level)

4
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/batch/JobExecutionExitCodeGeneratorTests.java
View File

@@ -35,7 +35,7 @@ class JobExecutionExitCodeGeneratorTests {
@Test
void testExitCodeForRunning() {
this.generator.onApplicationEvent(new JobExecutionEvent(new JobExecution(0L)));
assertThat(this.generator.getExitCode()).isEqualTo(1);
assertThat(this.generator.getExitCode()).isOne();
}
@Test
@@ -43,7 +43,7 @@ class JobExecutionExitCodeGeneratorTests {
JobExecution execution = new JobExecution(0L);
execution.setStatus(BatchStatus.COMPLETED);
this.generator.onApplicationEvent(new JobExecutionEvent(execution));
assertThat(this.generator.getExitCode()).isEqualTo(0);
assertThat(this.generator.getExitCode()).isZero();
}
@Test

2
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/cache/AbstractCacheAutoConfigurationTests.java vendored
View File

@@ -72,7 +72,7 @@ abstract class AbstractCacheAutoConfigurationTests {
assertThat(value.cacheManager).isNull();
}
});
assertThat(expected).hasSize(0);
assertThat(expected).isEmpty();
};
}

4
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/cache/CacheAutoConfigurationTests.java vendored
View File

@@ -696,7 +696,7 @@ class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationTests {
Cache foo = manager.getCache("foo");
foo.get("1");
// See next tests: no spec given so stats should be disabled
assertThat(((CaffeineCache) foo).getNativeCache().stats().missCount()).isEqualTo(0L);
assertThat(((CaffeineCache) foo).getNativeCache().stats().missCount()).isZero();
});
}
@@ -750,7 +750,7 @@ class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationTests {
assertThat(manager.getCacheNames()).containsOnly("foo", "bar");
Cache foo = manager.getCache("foo");
foo.get("1");
assertThat(((CaffeineCache) foo).getNativeCache().stats().missCount()).isEqualTo(1L);
assertThat(((CaffeineCache) foo).getNativeCache().stats().missCount()).isOne();
}
private CouchbaseCacheConfiguration getDefaultCouchbaseCacheConfiguration(CouchbaseCacheManager cacheManager) {

8
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/cache/CacheManagerCustomizersTests.java vendored
View File

@@ -56,14 +56,14 @@ class CacheManagerCustomizersTests {
list.add(new TestConcurrentMapCacheManagerCustomizer());
CacheManagerCustomizers customizers = new CacheManagerCustomizers(list);
customizers.customize(mock(CacheManager.class));
assertThat(list.get(0).getCount()).isEqualTo(1);
assertThat(list.get(1).getCount()).isEqualTo(0);
assertThat(list.get(0).getCount()).isOne();
assertThat(list.get(1).getCount()).isZero();
customizers.customize(mock(ConcurrentMapCacheManager.class));
assertThat(list.get(0).getCount()).isEqualTo(2);
assertThat(list.get(1).getCount()).isEqualTo(1);
assertThat(list.get(1).getCount()).isOne();
customizers.customize(mock(CaffeineCacheManager.class));
assertThat(list.get(0).getCount()).isEqualTo(3);
assertThat(list.get(1).getCount()).isEqualTo(1);
assertThat(list.get(1).getCount()).isOne();
}
static class CacheNamesCacheManagerCustomizer implements CacheManagerCustomizer<ConcurrentMapCacheManager> {

5
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/condition/ConditionEvaluationReportTests.java
View File

@@ -122,7 +122,7 @@ class ConditionEvaluationReportTests {
this.report.recordConditionEvaluation("a", this.condition2, this.outcome2);
this.report.recordConditionEvaluation("b", this.condition3, this.outcome3);
Map<String, ConditionAndOutcomes> map = this.report.getConditionAndOutcomesBySource();
assertThat(map.size()).isEqualTo(2);
assertThat(map).hasSize(2);
Iterator<ConditionAndOutcome> iterator = map.get("a").iterator();
ConditionAndOutcome conditionAndOutcome = iterator.next();
assertThat(conditionAndOutcome.getCondition()).isEqualTo(this.condition1);
@@ -164,7 +164,7 @@ class ConditionEvaluationReportTests {
void springBootConditionPopulatesReport() {
ConditionEvaluationReport report = ConditionEvaluationReport
.get(new AnnotationConfigApplicationContext(Config.class).getBeanFactory());
assertThat(report.getConditionAndOutcomesBySource().size()).isNotEqualTo(0);
assertThat(report.getConditionAndOutcomesBySource().size()).isNotZero();
}
@Test
@@ -175,7 +175,6 @@ class ConditionEvaluationReportTests {
new ConditionOutcome(true, "Message 2"));
ConditionAndOutcome outcome3 = new ConditionAndOutcome(this.condition3,
new ConditionOutcome(true, "Message 2"));
assertThat(outcome1).isEqualTo(outcome1);
assertThat(outcome1).isNotEqualTo(outcome2);
assertThat(outcome2).isEqualTo(outcome3);
ConditionAndOutcomes outcomes = new ConditionAndOutcomes();

48
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/condition/ConditionMessageTests.java
View File

@@ -48,49 +48,49 @@ class ConditionMessageTests {
@Test
void toStringWhenEmptyShouldReturnEmptyString() {
ConditionMessage message = ConditionMessage.empty();
assertThat(message.toString()).isEqualTo("");
assertThat(message).hasToString("");
}
@Test
void toStringWhenHasMessageShouldReturnMessage() {
ConditionMessage message = ConditionMessage.of("Test");
assertThat(message.toString()).isEqualTo("Test");
assertThat(message).hasToString("Test");
}
@Test
void appendWhenHasExistingMessageShouldAddSpace() {
ConditionMessage message = ConditionMessage.of("a").append("b");
assertThat(message.toString()).isEqualTo("a b");
assertThat(message).hasToString("a b");
}
@Test
void appendWhenAppendingNullShouldDoNothing() {
ConditionMessage message = ConditionMessage.of("a").append(null);
assertThat(message.toString()).isEqualTo("a");
assertThat(message).hasToString("a");
}
@Test
void appendWhenNoMessageShouldNotAddSpace() {
ConditionMessage message = ConditionMessage.empty().append("b");
assertThat(message.toString()).isEqualTo("b");
assertThat(message).hasToString("b");
}
@Test
void andConditionWhenUsingClassShouldIncludeCondition() {
ConditionMessage message = ConditionMessage.empty().andCondition(Test.class).because("OK");
assertThat(message.toString()).isEqualTo("@Test OK");
assertThat(message).hasToString("@Test OK");
}
@Test
void andConditionWhenUsingStringShouldIncludeCondition() {
ConditionMessage message = ConditionMessage.empty().andCondition("@Test").because("OK");
assertThat(message.toString()).isEqualTo("@Test OK");
assertThat(message).hasToString("@Test OK");
}
@Test
void andConditionWhenIncludingDetailsShouldIncludeCondition() {
ConditionMessage message = ConditionMessage.empty().andCondition(Test.class, "(a=b)").because("OK");
assertThat(message.toString()).isEqualTo("@Test (a=b) OK");
assertThat(message).hasToString("@Test (a=b) OK");
}
@Test
@@ -99,7 +99,7 @@ class ConditionMessageTests {
messages.add(ConditionMessage.of("a"));
messages.add(ConditionMessage.of("b"));
ConditionMessage message = ConditionMessage.of(messages);
assertThat(message.toString()).isEqualTo("a; b");
assertThat(message).hasToString("a; b");
}
@Test
@@ -111,89 +111,89 @@ class ConditionMessageTests {
@Test
void forConditionShouldIncludeCondition() {
ConditionMessage message = ConditionMessage.forCondition("@Test").because("OK");
assertThat(message.toString()).isEqualTo("@Test OK");
assertThat(message).hasToString("@Test OK");
}
@Test
void forConditionShouldNotAddExtraSpaceWithEmptyCondition() {
ConditionMessage message = ConditionMessage.forCondition("").because("OK");
assertThat(message.toString()).isEqualTo("OK");
assertThat(message).hasToString("OK");
}
@Test
void forConditionWhenClassShouldIncludeCondition() {
ConditionMessage message = ConditionMessage.forCondition(Test.class, "(a=b)").because("OK");
assertThat(message.toString()).isEqualTo("@Test (a=b) OK");
assertThat(message).hasToString("@Test (a=b) OK");
}
@Test
void foundExactlyShouldConstructMessage() {
ConditionMessage message = ConditionMessage.forCondition(Test.class).foundExactly("abc");
assertThat(message.toString()).isEqualTo("@Test found abc");
assertThat(message).hasToString("@Test found abc");
}
@Test
void foundWhenSingleElementShouldUseSingular() {
ConditionMessage message = ConditionMessage.forCondition(Test.class).found("bean", "beans").items("a");
assertThat(message.toString()).isEqualTo("@Test found bean a");
assertThat(message).hasToString("@Test found bean a");
}
@Test
void foundNoneAtAllShouldConstructMessage() {
ConditionMessage message = ConditionMessage.forCondition(Test.class).found("no beans").atAll();
assertThat(message.toString()).isEqualTo("@Test found no beans");
assertThat(message).hasToString("@Test found no beans");
}
@Test
void foundWhenMultipleElementsShouldUsePlural() {
ConditionMessage message = ConditionMessage.forCondition(Test.class).found("bean", "beans").items("a", "b",
"c");
assertThat(message.toString()).isEqualTo("@Test found beans a, b, c");
assertThat(message).hasToString("@Test found beans a, b, c");
}
@Test
void foundWhenQuoteStyleShouldQuote() {
ConditionMessage message = ConditionMessage.forCondition(Test.class).found("bean", "beans").items(Style.QUOTE,
"a", "b", "c");
assertThat(message.toString()).isEqualTo("@Test found beans 'a', 'b', 'c'");
assertThat(message).hasToString("@Test found beans 'a', 'b', 'c'");
}
@Test
void didNotFindWhenSingleElementShouldUseSingular() {
ConditionMessage message = ConditionMessage.forCondition(Test.class).didNotFind("class", "classes").items("a");
assertThat(message.toString()).isEqualTo("@Test did not find class a");
assertThat(message).hasToString("@Test did not find class a");
}
@Test
void didNotFindWhenMultipleElementsShouldUsePlural() {
ConditionMessage message = ConditionMessage.forCondition(Test.class).didNotFind("class", "classes").items("a",
"b", "c");
assertThat(message.toString()).isEqualTo("@Test did not find classes a, b, c");
assertThat(message).hasToString("@Test did not find classes a, b, c");
}
@Test
void resultedInShouldConstructMessage() {
ConditionMessage message = ConditionMessage.forCondition(Test.class).resultedIn("Green");
assertThat(message.toString()).isEqualTo("@Test resulted in Green");
assertThat(message).hasToString("@Test resulted in Green");
}
@Test
void notAvailableShouldConstructMessage() {
ConditionMessage message = ConditionMessage.forCondition(Test.class).notAvailable("JMX");
assertThat(message.toString()).isEqualTo("@Test JMX is not available");
assertThat(message).hasToString("@Test JMX is not available");
}
@Test
void availableShouldConstructMessage() {
ConditionMessage message = ConditionMessage.forCondition(Test.class).available("JMX");
assertThat(message.toString()).isEqualTo("@Test JMX is available");
assertThat(message).hasToString("@Test JMX is available");
}
@Test
void itemsTolerateNullInput() {
Collection<?> items = null;
ConditionMessage message = ConditionMessage.forCondition(Test.class).didNotFind("item").items(items);
assertThat(message.toString()).isEqualTo("@Test did not find item");
assertThat(message).hasToString("@Test did not find item");
}
@Test
@@ -201,7 +201,7 @@ class ConditionMessageTests {
Collection<?> items = null;
ConditionMessage message = ConditionMessage.forCondition(Test.class).didNotFind("item").items(Style.QUOTE,
items);
assertThat(message.toString()).isEqualTo("@Test did not find item");
assertThat(message).hasToString("@Test did not find item");
}
}

2
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/condition/ConditionalOnSingleCandidateTests.java
View File

@@ -58,7 +58,7 @@ class ConditionalOnSingleCandidateTests {
.withUserConfiguration(AlphaScopedProxyConfiguration.class, OnBeanSingleCandidateConfiguration.class)
.run((context) -> {
assertThat(context).hasBean("consumer");
assertThat(context.getBean("consumer").toString()).isEqualTo("alpha");
assertThat(context.getBean("consumer")).hasToString("alpha");
});
}

2
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/couchbase/CouchbasePropertiesTests.java
View File

@@ -35,7 +35,7 @@ class CouchbasePropertiesTests {
@Test
void ioHaveConsistentDefaults() {
Io io = new CouchbaseProperties().getEnv().getIo();
assertThat(io.getMinEndpoints()).isEqualTo(IoConfig.DEFAULT_NUM_KV_CONNECTIONS);
assertThat(io.getMinEndpoints()).isOne();
assertThat(io.getMaxEndpoints()).isEqualTo(IoConfig.DEFAULT_MAX_HTTP_CONNECTIONS);
assertThat(io.getIdleHttpConnectionTimeout()).isEqualTo(IoConfig.DEFAULT_IDLE_HTTP_CONNECTION_TIMEOUT);
}

2
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/data/neo4j/Neo4jRepositoriesAutoConfigurationIntegrationTests.java
View File

@@ -61,7 +61,7 @@ class Neo4jRepositoriesAutoConfigurationIntegrationTests {
@Test
void ensureRepositoryIsReady() {
assertThat(this.countryRepository.count()).isEqualTo(0);
assertThat(this.countryRepository.count()).isZero();
}
@Configuration

8
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/data/redis/RedisAutoConfigurationJedisTests.java
View File

@@ -64,7 +64,7 @@ class RedisAutoConfigurationJedisTests {
.run((context) -> {
JedisConnectionFactory cf = context.getBean(JedisConnectionFactory.class);
assertThat(cf.getHostName()).isEqualTo("foo");
assertThat(cf.getDatabase()).isEqualTo(1);
assertThat(cf.getDatabase()).isOne();
assertThat(getUserName(cf)).isNull();
assertThat(cf.getPassword()).isNull();
assertThat(cf.isUseSsl()).isFalse();
@@ -112,7 +112,7 @@ class RedisAutoConfigurationJedisTests {
JedisConnectionFactory cf = context.getBean(JedisConnectionFactory.class);
assertThat(cf.getHostName()).isEqualTo("example");
assertThat(cf.getPort()).isEqualTo(33);
assertThat(getUserName(cf)).isEqualTo("");
assertThat(getUserName(cf)).isEmpty();
assertThat(cf.getPassword()).isEqualTo("pass:word");
});
}
@@ -137,7 +137,7 @@ class RedisAutoConfigurationJedisTests {
"spring.data.redis.jedis.pool.time-between-eviction-runs:30000").run((context) -> {
JedisConnectionFactory cf = context.getBean(JedisConnectionFactory.class);
assertThat(cf.getHostName()).isEqualTo("foo");
assertThat(cf.getPoolConfig().getMinIdle()).isEqualTo(1);
assertThat(cf.getPoolConfig().getMinIdle()).isOne();
assertThat(cf.getPoolConfig().getMaxIdle()).isEqualTo(4);
assertThat(cf.getPoolConfig().getMaxTotal()).isEqualTo(16);
assertThat(cf.getPoolConfig().getMaxWaitDuration()).isEqualTo(Duration.ofSeconds(2));
@@ -152,7 +152,7 @@ class RedisAutoConfigurationJedisTests {
.run((context) -> {
JedisConnectionFactory cf = context.getBean(JedisConnectionFactory.class);
assertThat(cf.getHostName()).isEqualTo("foo");
assertThat(cf.getClientConfiguration().isUsePooling()).isEqualTo(false);
assertThat(cf.getClientConfiguration().isUsePooling()).isFalse();
});
}

11
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/data/redis/RedisAutoConfigurationTests.java
View File

@@ -26,7 +26,6 @@ import java.util.stream.Collectors;
import io.lettuce.core.ClientOptions;
import io.lettuce.core.cluster.ClusterClientOptions;
import io.lettuce.core.cluster.ClusterTopologyRefreshOptions;
import io.lettuce.core.cluster.ClusterTopologyRefreshOptions.RefreshTrigger;
import io.lettuce.core.resource.DefaultClientResources;
import io.lettuce.core.tracing.Tracing;
@@ -94,7 +93,7 @@ class RedisAutoConfigurationTests {
"spring.data.redis.lettuce.shutdown-timeout:500").run((context) -> {
LettuceConnectionFactory cf = context.getBean(LettuceConnectionFactory.class);
assertThat(cf.getHostName()).isEqualTo("foo");
assertThat(cf.getDatabase()).isEqualTo(1);
assertThat(cf.getDatabase()).isOne();
assertThat(getUserName(cf)).isNull();
assertThat(cf.getPassword()).isNull();
assertThat(cf.isUseSsl()).isFalse();
@@ -153,7 +152,7 @@ class RedisAutoConfigurationTests {
LettuceConnectionFactory cf = context.getBean(LettuceConnectionFactory.class);
assertThat(cf.getHostName()).isEqualTo("example");
assertThat(cf.getPort()).isEqualTo(33);
assertThat(getUserName(cf)).isEqualTo("");
assertThat(getUserName(cf)).isEmpty();
assertThat(cf.getPassword()).isEqualTo("pass:word");
});
}
@@ -194,7 +193,7 @@ class RedisAutoConfigurationTests {
LettuceConnectionFactory cf = context.getBean(LettuceConnectionFactory.class);
assertThat(cf.getHostName()).isEqualTo("foo");
GenericObjectPoolConfig<?> poolConfig = getPoolingClientConfiguration(cf).getPoolConfig();
assertThat(poolConfig.getMinIdle()).isEqualTo(1);
assertThat(poolConfig.getMinIdle()).isOne();
assertThat(poolConfig.getMaxIdle()).isEqualTo(4);
assertThat(poolConfig.getMaxTotal()).isEqualTo(16);
assertThat(poolConfig.getMaxWaitDuration()).isEqualTo(Duration.ofSeconds(2));
@@ -298,7 +297,7 @@ class RedisAutoConfigurationTests {
"spring.data.redis.sentinel.nodes:127.0.0.1:26379, 127.0.0.1:26380")
.run((context) -> {
LettuceConnectionFactory connectionFactory = context.getBean(LettuceConnectionFactory.class);
assertThat(connectionFactory.getDatabase()).isEqualTo(1);
assertThat(connectionFactory.getDatabase()).isOne();
assertThat(connectionFactory.isRedisSentinelAware()).isTrue();
});
}
@@ -467,7 +466,7 @@ class RedisAutoConfigurationTests {
"spring.data.redis.lettuce.cluster.refresh.dynamic-sources=")
.run(assertClientOptions(ClusterClientOptions.class,
(options) -> assertThat(options.getTopologyRefreshOptions().useDynamicRefreshSources())
.isEqualTo(ClusterTopologyRefreshOptions.DEFAULT_DYNAMIC_REFRESH_SOURCES)));
.isTrue()));
}
private <T extends ClientOptions> ContextConsumer<AssertableApplicationContext> assertClientOptions(

2
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/flyway/FlywayAutoConfigurationTests.java
View File

@@ -272,7 +272,7 @@ class FlywayAutoConfigurationTests {
.withPropertyValues("spring.flyway.schemas:public").run((context) -> {
assertThat(context).hasSingleBean(Flyway.class);
Flyway flyway = context.getBean(Flyway.class);
assertThat(Arrays.asList(flyway.getConfiguration().getSchemas()).toString()).isEqualTo("[public]");
assertThat(Arrays.asList(flyway.getConfiguration().getSchemas())).hasToString("[public]");
});
}

2
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/freemarker/FreeMarkerAutoConfigurationServletIntegrationTests.java
View File

@@ -119,7 +119,7 @@ class FreeMarkerAutoConfigurationServletIntegrationTests {
@Test
void disableCache() {
load("spring.freemarker.cache:false");
assertThat(this.context.getBean(FreeMarkerViewResolver.class).getCacheLimit()).isEqualTo(0);
assertThat(this.context.getBean(FreeMarkerViewResolver.class).getCacheLimit()).isZero();
}
@Test

2
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/groovy/template/GroovyTemplateAutoConfigurationTests.java
View File

@@ -152,7 +152,7 @@ class GroovyTemplateAutoConfigurationTests {
@Test
void disableCache() {
registerAndRefreshContext("spring.groovy.template.cache:false");
assertThat(this.context.getBean(GroovyMarkupViewResolver.class).getCacheLimit()).isEqualTo(0);
assertThat(this.context.getBean(GroovyMarkupViewResolver.class).getCacheLimit()).isZero();
}
@Test

8
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/hateoas/HypermediaAutoConfigurationTests.java
View File

@@ -93,7 +93,7 @@ class HypermediaAutoConfigurationTests {
RequestMappingHandlerAdapter handlerAdapter = context.getBean(RequestMappingHandlerAdapter.class);
Optional<HttpMessageConverter<?>> mappingJacksonConverter = handlerAdapter.getMessageConverters().stream()
.filter(MappingJackson2HttpMessageConverter.class::isInstance).findFirst();
assertThat(mappingJacksonConverter).isPresent().hasValueSatisfying(
assertThat(mappingJacksonConverter).hasValueSatisfying(
(converter) -> assertThat(converter.canWrite(RepresentationModel.class, MediaType.APPLICATION_JSON))
.isTrue());
});
@@ -106,10 +106,8 @@ class HypermediaAutoConfigurationTests {
RequestMappingHandlerAdapter handlerAdapter = context.getBean(RequestMappingHandlerAdapter.class);
Optional<HttpMessageConverter<?>> mappingJacksonConverter = handlerAdapter.getMessageConverters()
.stream().filter(MappingJackson2HttpMessageConverter.class::isInstance).findFirst();
assertThat(mappingJacksonConverter).isPresent()
.hasValueSatisfying((converter) -> assertThat(
converter.canWrite(RepresentationModel.class, MediaType.APPLICATION_JSON))
.isFalse());
assertThat(mappingJacksonConverter).hasValueSatisfying((converter) -> assertThat(
converter.canWrite(RepresentationModel.class, MediaType.APPLICATION_JSON)).isFalse());
});
}

10
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/http/HttpMessageConvertersTests.java
View File

@@ -64,8 +64,8 @@ class HttpMessageConvertersTests {
MappingJackson2HttpMessageConverter converter1 = new MappingJackson2HttpMessageConverter();
MappingJackson2HttpMessageConverter converter2 = new MappingJackson2HttpMessageConverter();
HttpMessageConverters converters = new HttpMessageConverters(converter1, converter2);
assertThat(converters.getConverters().contains(converter1)).isTrue();
assertThat(converters.getConverters().contains(converter2)).isTrue();
assertThat(converters.getConverters()).contains(converter1);
assertThat(converters.getConverters()).contains(converter2);
List<MappingJackson2HttpMessageConverter> httpConverters = new ArrayList<>();
for (HttpMessageConverter<?> candidate : converters) {
if (candidate instanceof MappingJackson2HttpMessageConverter) {
@@ -74,9 +74,9 @@ class HttpMessageConvertersTests {
}
// The existing converter is still there, but with a lower priority
assertThat(httpConverters).hasSize(3);
assertThat(httpConverters.indexOf(converter1)).isEqualTo(0);
assertThat(httpConverters.indexOf(converter2)).isEqualTo(1);
assertThat(converters.getConverters().indexOf(converter1)).isNotEqualTo(0);
assertThat(httpConverters.indexOf(converter1)).isZero();
assertThat(httpConverters.indexOf(converter2)).isOne();
assertThat(converters.getConverters().indexOf(converter1)).isNotZero();
}
@Test

2
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/http/codec/CodecsAutoConfigurationTests.java
View File

@@ -74,7 +74,7 @@ class CodecsAutoConfigurationTests {
CodecsAutoConfiguration.DefaultCodecsConfiguration.class, "defaultCodecCustomizer",
CodecProperties.class);
Integer order = new TestAnnotationAwareOrderComparator().findOrder(customizerMethod);
assertThat(order).isEqualTo(0);
assertThat(order).isZero();
});
}

2
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/integration/IntegrationAutoConfigurationTests.java
View File

@@ -423,7 +423,7 @@ class IntegrationAutoConfigurationTests {
.run((context) -> {
assertThat(context).hasSingleBean(PollerMetadata.class);
PollerMetadata metadata = context.getBean(PollerMetadata.DEFAULT_POLLER, PollerMetadata.class);
assertThat(metadata.getMaxMessagesPerPoll()).isEqualTo(1L);
assertThat(metadata.getMaxMessagesPerPoll()).isOne();
assertThat(metadata.getReceiveTimeout()).isEqualTo(10000L);
assertThat(metadata.getTrigger()).asInstanceOf(InstanceOfAssertFactories.type(CronTrigger.class))
.satisfies((trigger) -> assertThat(trigger.getExpression()).isEqualTo("* * * ? * *"));

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

@@ -102,7 +102,7 @@ class IntegrationPropertiesEnvironmentPostProcessorTests {
new IntegrationPropertiesEnvironmentPostProcessor().registerIntegrationPropertiesPropertySource(environment,
resource);
PropertySource<?> ps = environment.getPropertySources().get("META-INF/spring.integration.properties");
assertThat(ps).isNotNull().isInstanceOf(OriginLookup.class);
assertThat(ps).isInstanceOf(OriginLookup.class);
OriginLookup<String> originLookup = (OriginLookup<String>) ps;
assertThat(originLookup.getOrigin("spring.integration.channel.auto-create"))
.satisfies(textOrigin(resource, 0, 39));

4
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/DataSourceJmxConfigurationTests.java
View File

@@ -88,8 +88,8 @@ class DataSourceJmxConfigurationTests {
hikariDataSource.getConnection().close();
// We can't rely on the number of MBeans so we're checking that the
// pool and pool config MBeans were registered
assertThat(mBeanServer.queryMBeans(new ObjectName("com.zaxxer.hikari:type=*"), null).size())
.isEqualTo(existingInstances.size() + 2);
assertThat(mBeanServer.queryMBeans(new ObjectName("com.zaxxer.hikari:type=*"), null))
.hasSize(existingInstances.size() + 2);
});
}

6
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/DataSourceJsonSerializationTests.java
View File

@@ -60,7 +60,7 @@ class DataSourceJsonSerializationTests {
ObjectMapper mapper = new ObjectMapper();
mapper.setSerializerFactory(factory);
String value = mapper.writeValueAsString(dataSource);
assertThat(value.contains("\"url\":")).isTrue();
assertThat(value).contains("\"url\":");
}
@Test
@@ -69,8 +69,8 @@ class DataSourceJsonSerializationTests {
ObjectMapper mapper = new ObjectMapper();
mapper.addMixIn(DataSource.class, DataSourceJson.class);
String value = mapper.writeValueAsString(dataSource);
assertThat(value.contains("\"url\":")).isTrue();
assertThat(StringUtils.countOccurrencesOf(value, "\"url\"")).isEqualTo(1);
assertThat(value).contains("\"url\":");
assertThat(StringUtils.countOccurrencesOf(value, "\"url\"")).isOne();
}
@JsonSerialize(using = TomcatDataSourceSerializer.class)

4
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/DataSourcePropertiesTests.java
View File

@@ -121,7 +121,7 @@ class DataSourcePropertiesTests {
DataSourceProperties properties = new DataSourceProperties();
properties.setUsername("");
properties.afterPropertiesSet();
assertThat(properties.getUsername()).isEqualTo("");
assertThat(properties.getUsername()).isEmpty();
assertThat(properties.determineUsername()).isEqualTo("sa");
}
@@ -157,7 +157,7 @@ class DataSourcePropertiesTests {
DataSourceProperties properties = new DataSourceProperties();
properties.afterPropertiesSet();
assertThat(properties.getPassword()).isNull();
assertThat(properties.determinePassword()).isEqualTo("");
assertThat(properties.determinePassword()).isEmpty();
}
@Test

10
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/JdbcTemplateAutoConfigurationTests.java
View File

@@ -150,7 +150,7 @@ class JdbcTemplateAutoConfigurationTests {
this.contextRunner.withConfiguration(AutoConfigurations.of(SqlInitializationAutoConfiguration.class))
.withUserConfiguration(DataSourceInitializationValidator.class).run((context) -> {
assertThat(context).hasNotFailed();
assertThat(context.getBean(DataSourceInitializationValidator.class).count).isEqualTo(1);
assertThat(context.getBean(DataSourceInitializationValidator.class).count).isOne();
});
}
@@ -160,7 +160,7 @@ class JdbcTemplateAutoConfigurationTests {
.withPropertyValues("spring.flyway.locations:classpath:db/city")
.withConfiguration(AutoConfigurations.of(FlywayAutoConfiguration.class)).run((context) -> {
assertThat(context).hasNotFailed();
assertThat(context.getBean(DataSourceMigrationValidator.class).count).isEqualTo(0);
assertThat(context.getBean(DataSourceMigrationValidator.class).count).isZero();
});
}
@@ -171,7 +171,7 @@ class JdbcTemplateAutoConfigurationTests {
.withConfiguration(AutoConfigurations.of(FlywayAutoConfiguration.class)).run((context) -> {
assertThat(context).hasNotFailed();
assertThat(context.getBean(JdbcTemplate.class)).isNotNull();
assertThat(context.getBean(NamedParameterDataSourceMigrationValidator.class).count).isEqualTo(0);
assertThat(context.getBean(NamedParameterDataSourceMigrationValidator.class).count).isZero();
});
}
@@ -181,7 +181,7 @@ class JdbcTemplateAutoConfigurationTests {
.withPropertyValues("spring.liquibase.changeLog:classpath:db/changelog/db.changelog-city.yaml")
.withConfiguration(AutoConfigurations.of(LiquibaseAutoConfiguration.class)).run((context) -> {
assertThat(context).hasNotFailed();
assertThat(context.getBean(DataSourceMigrationValidator.class).count).isEqualTo(0);
assertThat(context.getBean(DataSourceMigrationValidator.class).count).isZero();
});
}
@@ -192,7 +192,7 @@ class JdbcTemplateAutoConfigurationTests {
.withConfiguration(AutoConfigurations.of(LiquibaseAutoConfiguration.class)).run((context) -> {
assertThat(context).hasNotFailed();
assertThat(context.getBean(JdbcTemplate.class)).isNotNull();
assertThat(context.getBean(NamedParameterDataSourceMigrationValidator.class).count).isEqualTo(0);
assertThat(context.getBean(NamedParameterDataSourceMigrationValidator.class).count).isZero();
});
}

10
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/OracleUcpDataSourceConfigurationTests.java
View File

@@ -75,13 +75,13 @@ class OracleUcpDataSourceConfigurationTests {
void testDataSourceDefaultsPreserved() {
this.contextRunner.run((context) -> {
PoolDataSourceImpl ds = context.getBean(PoolDataSourceImpl.class);
assertThat(ds.getInitialPoolSize()).isEqualTo(0);
assertThat(ds.getMinPoolSize()).isEqualTo(0);
assertThat(ds.getInitialPoolSize()).isZero();
assertThat(ds.getMinPoolSize()).isZero();
assertThat(ds.getMaxPoolSize()).isEqualTo(Integer.MAX_VALUE);
assertThat(ds.getInactiveConnectionTimeout()).isEqualTo(0);
assertThat(ds.getInactiveConnectionTimeout()).isZero();
assertThat(ds.getConnectionWaitTimeout()).isEqualTo(3);
assertThat(ds.getTimeToLiveConnectionTimeout()).isEqualTo(0);
assertThat(ds.getAbandonedConnectionTimeout()).isEqualTo(0);
assertThat(ds.getTimeToLiveConnectionTimeout()).isZero();
assertThat(ds.getAbandonedConnectionTimeout()).isZero();
assertThat(ds.getTimeoutCheckInterval()).isEqualTo(30);
assertThat(ds.getFastConnectionFailoverEnabled()).isFalse();
});

2
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jersey/JerseyAutoConfigurationCustomObjectMapperProviderTests.java
View File

@@ -61,7 +61,7 @@ class JerseyAutoConfigurationCustomObjectMapperProviderTests {
void contextLoads() {
ResponseEntity<String> response = this.restTemplate.getForEntity("/rest/message", String.class);
assertThat(HttpStatus.OK).isEqualTo(response.getStatusCode());
assertThat("{\"subject\":\"Jersey\"}").isEqualTo(response.getBody());
assertThat(response.getBody()).isEqualTo("{\"subject\":\"Jersey\"}");
}
@MinimalWebConfiguration

2
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jms/JmsAutoConfigurationTests.java
View File

@@ -261,7 +261,7 @@ class JmsAutoConfigurationTests {
assertThat(jmsTemplate.isPubSubDomain()).isFalse();
assertThat(jmsTemplate.getDefaultDestinationName()).isEqualTo("testQueue");
assertThat(jmsTemplate.getDeliveryDelay()).isEqualTo(500);
assertThat(jmsTemplate.getDeliveryMode()).isEqualTo(1);
assertThat(jmsTemplate.getDeliveryMode()).isOne();
assertThat(jmsTemplate.getPriority()).isEqualTo(6);
assertThat(jmsTemplate.getTimeToLive()).isEqualTo(6000);
assertThat(jmsTemplate.isExplicitQosEnabled()).isTrue();

4
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jms/artemis/ArtemisAutoConfigurationTests.java
View File

@@ -77,7 +77,7 @@ class ArtemisAutoConfigurationTests {
assertThat(connectionFactory.getTargetConnectionFactory()).isInstanceOf(ActiveMQConnectionFactory.class);
assertThat(connectionFactory.isCacheConsumers()).isFalse();
assertThat(connectionFactory.isCacheProducers()).isTrue();
assertThat(connectionFactory.getSessionCacheSize()).isEqualTo(1);
assertThat(connectionFactory.getSessionCacheSize()).isOne();
});
}
@@ -374,7 +374,7 @@ class ArtemisAutoConfigurationTests {
String host, int port) {
TransportConfiguration transportConfig = getSingleTransportConfiguration(connectionFactory);
assertThat(transportConfig.getFactoryClassName()).isEqualTo(NettyConnectorFactory.class.getName());
assertThat(transportConfig.getParams().get("host")).isEqualTo(host);
assertThat(transportConfig.getParams()).containsEntry("host", host);
Object transportConfigPort = transportConfig.getParams().get("port");
if (transportConfigPort instanceof String portString) {
transportConfigPort = Integer.parseInt(portString);

2
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jooq/JooqAutoConfigurationTests.java
View File

@@ -171,7 +171,7 @@ class JooqAutoConfigurationTests {
@Override
public void run(org.jooq.Configuration configuration) {
assertThat(this.dsl.fetch(this.sql).getValue(0, 0).toString()).isEqualTo(this.expected);
assertThat(this.dsl.fetch(this.sql).getValue(0, 0)).hasToString(this.expected);
}
}

2
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/kafka/KafkaAutoConfigurationIntegrationTests.java
View File

@@ -91,7 +91,7 @@ class KafkaAutoConfigurationIntegrationTests {
DefaultKafkaProducerFactory producerFactory = this.context.getBean(DefaultKafkaProducerFactory.class);
Producer producer = producerFactory.createProducer();
assertThat(producer.partitionsFor(ADMIN_CREATED_TOPIC).size()).isEqualTo(10);
assertThat(producer.partitionsFor(ADMIN_CREATED_TOPIC)).hasSize(10);
producer.close();
}

154
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/kafka/KafkaAutoConfigurationTests.java
View File

@@ -121,38 +121,38 @@ class KafkaAutoConfigurationTests {
.getBean(DefaultKafkaConsumerFactory.class);
Map<String, Object> configs = consumerFactory.getConfigurationProperties();
// common
assertThat(configs.get(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG))
.isEqualTo(Collections.singletonList("foo:1234"));
assertThat(configs.get(SslConfigs.SSL_KEY_PASSWORD_CONFIG)).isEqualTo("p1");
assertThat(configs).containsEntry(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,
Collections.singletonList("foo:1234"));
assertThat(configs).containsEntry(SslConfigs.SSL_KEY_PASSWORD_CONFIG, "p1");
assertThat((String) configs.get(SslConfigs.SSL_KEYSTORE_LOCATION_CONFIG))
.endsWith(File.separator + "ksLoc");
assertThat(configs.get(SslConfigs.SSL_KEYSTORE_PASSWORD_CONFIG)).isEqualTo("p2");
assertThat(configs.get(SslConfigs.SSL_KEYSTORE_TYPE_CONFIG)).isEqualTo("PKCS12");
assertThat(configs).containsEntry(SslConfigs.SSL_KEYSTORE_PASSWORD_CONFIG, "p2");
assertThat(configs).containsEntry(SslConfigs.SSL_KEYSTORE_TYPE_CONFIG, "PKCS12");
assertThat((String) configs.get(SslConfigs.SSL_TRUSTSTORE_LOCATION_CONFIG))
.endsWith(File.separator + "tsLoc");
assertThat(configs.get(SslConfigs.SSL_TRUSTSTORE_PASSWORD_CONFIG)).isEqualTo("p3");
assertThat(configs.get(SslConfigs.SSL_TRUSTSTORE_TYPE_CONFIG)).isEqualTo("PKCS12");
assertThat(configs.get(SslConfigs.SSL_PROTOCOL_CONFIG)).isEqualTo("TLSv1.2");
assertThat(configs).containsEntry(SslConfigs.SSL_TRUSTSTORE_PASSWORD_CONFIG, "p3");
assertThat(configs).containsEntry(SslConfigs.SSL_TRUSTSTORE_TYPE_CONFIG, "PKCS12");
assertThat(configs).containsEntry(SslConfigs.SSL_PROTOCOL_CONFIG, "TLSv1.2");
// consumer
assertThat(configs.get(ConsumerConfig.CLIENT_ID_CONFIG)).isEqualTo("ccid"); // override
assertThat(configs.get(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG)).isEqualTo(Boolean.FALSE);
assertThat(configs.get(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG)).isEqualTo(123);
assertThat(configs.get(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG)).isEqualTo("earliest");
assertThat(configs.get(ConsumerConfig.FETCH_MAX_WAIT_MS_CONFIG)).isEqualTo(456);
assertThat(configs.get(ConsumerConfig.FETCH_MIN_BYTES_CONFIG)).isEqualTo(1024);
assertThat(configs.get(ConsumerConfig.GROUP_ID_CONFIG)).isEqualTo("bar");
assertThat(configs.get(ConsumerConfig.HEARTBEAT_INTERVAL_MS_CONFIG)).isEqualTo(234);
assertThat(configs.get(ConsumerConfig.ISOLATION_LEVEL_CONFIG)).isEqualTo("read_committed");
assertThat(configs.get(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG))
.isEqualTo(LongDeserializer.class);
assertThat(configs.get(CommonClientConfigs.SECURITY_PROTOCOL_CONFIG)).isEqualTo("SSL");
assertThat(configs.get(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG))
.isEqualTo(IntegerDeserializer.class);
assertThat(configs.get(ConsumerConfig.MAX_POLL_RECORDS_CONFIG)).isEqualTo(42);
assertThat(configs.get("foo")).isEqualTo("bar");
assertThat(configs.get("baz")).isEqualTo("qux");
assertThat(configs.get("foo.bar.baz")).isEqualTo("qux.fiz.buz");
assertThat(configs.get("fiz.buz")).isEqualTo("fix.fox");
assertThat(configs).containsEntry(ConsumerConfig.CLIENT_ID_CONFIG, "ccid"); // override
assertThat(configs).containsEntry(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, Boolean.FALSE);
assertThat(configs).containsEntry(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, 123);
assertThat(configs).containsEntry(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");
assertThat(configs).containsEntry(ConsumerConfig.FETCH_MAX_WAIT_MS_CONFIG, 456);
assertThat(configs).containsEntry(ConsumerConfig.FETCH_MIN_BYTES_CONFIG, 1024);
assertThat(configs).containsEntry(ConsumerConfig.GROUP_ID_CONFIG, "bar");
assertThat(configs).containsEntry(ConsumerConfig.HEARTBEAT_INTERVAL_MS_CONFIG, 234);
assertThat(configs).containsEntry(ConsumerConfig.ISOLATION_LEVEL_CONFIG, "read_committed");
assertThat(configs).containsEntry(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG,
LongDeserializer.class);
assertThat(configs).containsEntry(CommonClientConfigs.SECURITY_PROTOCOL_CONFIG, "SSL");
assertThat(configs).containsEntry(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,
IntegerDeserializer.class);
assertThat(configs).containsEntry(ConsumerConfig.MAX_POLL_RECORDS_CONFIG, 42);
assertThat(configs).containsEntry("foo", "bar");
assertThat(configs).containsEntry("baz", "qux");
assertThat(configs).containsEntry("foo.bar.baz", "qux.fiz.buz");
assertThat(configs).containsEntry("fiz.buz", "fix.fox");
});
}
@@ -177,33 +177,33 @@ class KafkaAutoConfigurationTests {
.getBean(DefaultKafkaProducerFactory.class);
Map<String, Object> configs = producerFactory.getConfigurationProperties();
// common
assertThat(configs.get(ProducerConfig.CLIENT_ID_CONFIG)).isEqualTo("cid");
assertThat(configs).containsEntry(ProducerConfig.CLIENT_ID_CONFIG, "cid");
// producer
assertThat(configs.get(ProducerConfig.ACKS_CONFIG)).isEqualTo("all");
assertThat(configs.get(ProducerConfig.BATCH_SIZE_CONFIG)).isEqualTo(2048);
assertThat(configs.get(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG))
.isEqualTo(Collections.singletonList("bar:1234")); // override
assertThat(configs.get(ProducerConfig.BUFFER_MEMORY_CONFIG)).isEqualTo(4096L);
assertThat(configs.get(ProducerConfig.COMPRESSION_TYPE_CONFIG)).isEqualTo("gzip");
assertThat(configs.get(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG)).isEqualTo(LongSerializer.class);
assertThat(configs.get(CommonClientConfigs.SECURITY_PROTOCOL_CONFIG)).isEqualTo("SSL");
assertThat(configs.get(SslConfigs.SSL_KEY_PASSWORD_CONFIG)).isEqualTo("p4");
assertThat(configs).containsEntry(ProducerConfig.ACKS_CONFIG, "all");
assertThat(configs).containsEntry(ProducerConfig.BATCH_SIZE_CONFIG, 2048);
assertThat(configs).containsEntry(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,
Collections.singletonList("bar:1234")); // override
assertThat(configs).containsEntry(ProducerConfig.BUFFER_MEMORY_CONFIG, 4096L);
assertThat(configs).containsEntry(ProducerConfig.COMPRESSION_TYPE_CONFIG, "gzip");
assertThat(configs).containsEntry(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, LongSerializer.class);
assertThat(configs).containsEntry(CommonClientConfigs.SECURITY_PROTOCOL_CONFIG, "SSL");
assertThat(configs).containsEntry(SslConfigs.SSL_KEY_PASSWORD_CONFIG, "p4");
assertThat((String) configs.get(SslConfigs.SSL_KEYSTORE_LOCATION_CONFIG))
.endsWith(File.separator + "ksLocP");
assertThat(configs.get(SslConfigs.SSL_KEYSTORE_PASSWORD_CONFIG)).isEqualTo("p5");
assertThat(configs.get(SslConfigs.SSL_KEYSTORE_TYPE_CONFIG)).isEqualTo("PKCS12");
assertThat(configs).containsEntry(SslConfigs.SSL_KEYSTORE_PASSWORD_CONFIG, "p5");
assertThat(configs).containsEntry(SslConfigs.SSL_KEYSTORE_TYPE_CONFIG, "PKCS12");
assertThat((String) configs.get(SslConfigs.SSL_TRUSTSTORE_LOCATION_CONFIG))
.endsWith(File.separator + "tsLocP");
assertThat(configs.get(SslConfigs.SSL_TRUSTSTORE_PASSWORD_CONFIG)).isEqualTo("p6");
assertThat(configs.get(SslConfigs.SSL_TRUSTSTORE_TYPE_CONFIG)).isEqualTo("PKCS12");
assertThat(configs.get(SslConfigs.SSL_PROTOCOL_CONFIG)).isEqualTo("TLSv1.2");
assertThat(configs.get(ProducerConfig.RETRIES_CONFIG)).isEqualTo(2);
assertThat(configs.get(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG))
.isEqualTo(IntegerSerializer.class);
assertThat(configs).containsEntry(SslConfigs.SSL_TRUSTSTORE_PASSWORD_CONFIG, "p6");
assertThat(configs).containsEntry(SslConfigs.SSL_TRUSTSTORE_TYPE_CONFIG, "PKCS12");
assertThat(configs).containsEntry(SslConfigs.SSL_PROTOCOL_CONFIG, "TLSv1.2");
assertThat(configs).containsEntry(ProducerConfig.RETRIES_CONFIG, 2);
assertThat(configs).containsEntry(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,
IntegerSerializer.class);
assertThat(context.getBeansOfType(KafkaJaasLoginModuleInitializer.class)).isEmpty();
assertThat(context.getBeansOfType(KafkaTransactionManager.class)).isEmpty();
assertThat(configs.get("foo.bar.baz")).isEqualTo("qux.fiz.buz");
assertThat(configs.get("fiz.buz")).isEqualTo("fix.fox");
assertThat(configs).containsEntry("foo.bar.baz", "qux.fiz.buz");
assertThat(configs).containsEntry("fiz.buz", "fix.fox");
});
}
@@ -221,22 +221,22 @@ class KafkaAutoConfigurationTests {
KafkaAdmin admin = context.getBean(KafkaAdmin.class);
Map<String, Object> configs = admin.getConfigurationProperties();
// common
assertThat(configs.get(AdminClientConfig.CLIENT_ID_CONFIG)).isEqualTo("cid");
assertThat(configs).containsEntry(AdminClientConfig.CLIENT_ID_CONFIG, "cid");
// admin
assertThat(configs.get(CommonClientConfigs.SECURITY_PROTOCOL_CONFIG)).isEqualTo("SSL");
assertThat(configs.get(SslConfigs.SSL_KEY_PASSWORD_CONFIG)).isEqualTo("p4");
assertThat(configs).containsEntry(CommonClientConfigs.SECURITY_PROTOCOL_CONFIG, "SSL");
assertThat(configs).containsEntry(SslConfigs.SSL_KEY_PASSWORD_CONFIG, "p4");
assertThat((String) configs.get(SslConfigs.SSL_KEYSTORE_LOCATION_CONFIG))
.endsWith(File.separator + "ksLocP");
assertThat(configs.get(SslConfigs.SSL_KEYSTORE_PASSWORD_CONFIG)).isEqualTo("p5");
assertThat(configs.get(SslConfigs.SSL_KEYSTORE_TYPE_CONFIG)).isEqualTo("PKCS12");
assertThat(configs).containsEntry(SslConfigs.SSL_KEYSTORE_PASSWORD_CONFIG, "p5");
assertThat(configs).containsEntry(SslConfigs.SSL_KEYSTORE_TYPE_CONFIG, "PKCS12");
assertThat((String) configs.get(SslConfigs.SSL_TRUSTSTORE_LOCATION_CONFIG))
.endsWith(File.separator + "tsLocP");
assertThat(configs.get(SslConfigs.SSL_TRUSTSTORE_PASSWORD_CONFIG)).isEqualTo("p6");
assertThat(configs.get(SslConfigs.SSL_TRUSTSTORE_TYPE_CONFIG)).isEqualTo("PKCS12");
assertThat(configs.get(SslConfigs.SSL_PROTOCOL_CONFIG)).isEqualTo("TLSv1.2");
assertThat(configs).containsEntry(SslConfigs.SSL_TRUSTSTORE_PASSWORD_CONFIG, "p6");
assertThat(configs).containsEntry(SslConfigs.SSL_TRUSTSTORE_TYPE_CONFIG, "PKCS12");
assertThat(configs).containsEntry(SslConfigs.SSL_PROTOCOL_CONFIG, "TLSv1.2");
assertThat(context.getBeansOfType(KafkaJaasLoginModuleInitializer.class)).isEmpty();
assertThat(configs.get("foo.bar.baz")).isEqualTo("qux.fiz.buz");
assertThat(configs.get("fiz.buz")).isEqualTo("fix.fox");
assertThat(configs).containsEntry("foo.bar.baz", "qux.fiz.buz");
assertThat(configs).containsEntry("fiz.buz", "fix.fox");
assertThat(admin).hasFieldOrPropertyWithValue("fatalIfBrokerNotAvailable", true);
assertThat(admin).hasFieldOrPropertyWithValue("modifyTopicConfigs", true);
});
@@ -263,24 +263,24 @@ class KafkaAutoConfigurationTests {
.asProperties();
assertThat((List<String>) configs.get(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG))
.containsExactly("localhost:9092", "localhost:9093");
assertThat(configs.get(StreamsConfig.CACHE_MAX_BYTES_BUFFERING_CONFIG)).isEqualTo(1024);
assertThat(configs.get(StreamsConfig.CLIENT_ID_CONFIG)).isEqualTo("override");
assertThat(configs.get(StreamsConfig.REPLICATION_FACTOR_CONFIG)).isEqualTo(2);
assertThat(configs.get(CommonClientConfigs.SECURITY_PROTOCOL_CONFIG)).isEqualTo("SSL");
assertThat(configs.get(StreamsConfig.STATE_DIR_CONFIG)).isEqualTo("/tmp/state");
assertThat(configs.get(SslConfigs.SSL_KEY_PASSWORD_CONFIG)).isEqualTo("p7");
assertThat(configs).containsEntry(StreamsConfig.CACHE_MAX_BYTES_BUFFERING_CONFIG, 1024);
assertThat(configs).containsEntry(StreamsConfig.CLIENT_ID_CONFIG, "override");
assertThat(configs).containsEntry(StreamsConfig.REPLICATION_FACTOR_CONFIG, 2);
assertThat(configs).containsEntry(CommonClientConfigs.SECURITY_PROTOCOL_CONFIG, "SSL");
assertThat(configs).containsEntry(StreamsConfig.STATE_DIR_CONFIG, "/tmp/state");
assertThat(configs).containsEntry(SslConfigs.SSL_KEY_PASSWORD_CONFIG, "p7");
assertThat((String) configs.get(SslConfigs.SSL_KEYSTORE_LOCATION_CONFIG))
.endsWith(File.separator + "ksLocP");
assertThat(configs.get(SslConfigs.SSL_KEYSTORE_PASSWORD_CONFIG)).isEqualTo("p8");
assertThat(configs.get(SslConfigs.SSL_KEYSTORE_TYPE_CONFIG)).isEqualTo("PKCS12");
assertThat(configs).containsEntry(SslConfigs.SSL_KEYSTORE_PASSWORD_CONFIG, "p8");
assertThat(configs).containsEntry(SslConfigs.SSL_KEYSTORE_TYPE_CONFIG, "PKCS12");
assertThat((String) configs.get(SslConfigs.SSL_TRUSTSTORE_LOCATION_CONFIG))
.endsWith(File.separator + "tsLocP");
assertThat(configs.get(SslConfigs.SSL_TRUSTSTORE_PASSWORD_CONFIG)).isEqualTo("p9");
assertThat(configs.get(SslConfigs.SSL_TRUSTSTORE_TYPE_CONFIG)).isEqualTo("PKCS12");
assertThat(configs.get(SslConfigs.SSL_PROTOCOL_CONFIG)).isEqualTo("TLSv1.2");
assertThat(configs).containsEntry(SslConfigs.SSL_TRUSTSTORE_PASSWORD_CONFIG, "p9");
assertThat(configs).containsEntry(SslConfigs.SSL_TRUSTSTORE_TYPE_CONFIG, "PKCS12");
assertThat(configs).containsEntry(SslConfigs.SSL_PROTOCOL_CONFIG, "TLSv1.2");
assertThat(context.getBeansOfType(KafkaJaasLoginModuleInitializer.class)).isEmpty();
assertThat(configs.get("foo.bar.baz")).isEqualTo("qux.fiz.buz");
assertThat(configs.get("fiz.buz")).isEqualTo("fix.fox");
assertThat(configs).containsEntry("foo.bar.baz", "qux.fiz.buz");
assertThat(configs).containsEntry("fiz.buz", "fix.fox");
assertThat(context.getBean(KafkaStreamsDefaultConfiguration.DEFAULT_STREAMS_BUILDER_BEAN_NAME))
.isNotNull();
});
@@ -300,7 +300,7 @@ class KafkaAutoConfigurationTests {
.asProperties();
assertThat((List<String>) configs.get(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG))
.containsExactly("localhost:9092", "localhost:9093");
assertThat(configs.get(StreamsConfig.APPLICATION_ID_CONFIG)).isEqualTo("my-test-app");
assertThat(configs).containsEntry(StreamsConfig.APPLICATION_ID_CONFIG, "my-test-app");
});
}
@@ -316,9 +316,9 @@ class KafkaAutoConfigurationTests {
.getBean(KafkaStreamsDefaultConfiguration.DEFAULT_STREAMS_CONFIG_BEAN_NAME,
KafkaStreamsConfiguration.class)
.asProperties();
assertThat(configs.get(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG))
.isEqualTo("localhost:9094, localhost:9095");
assertThat(configs.get(StreamsConfig.APPLICATION_ID_CONFIG)).isEqualTo("test-id");
assertThat(configs).containsEntry(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG,
"localhost:9094, localhost:9095");
assertThat(configs).containsEntry(StreamsConfig.APPLICATION_ID_CONFIG, "test-id");
});
}
@@ -479,7 +479,7 @@ class KafkaAutoConfigurationTests {
assertThat(kafkaListenerContainerFactory.getConsumerFactory()).isEqualTo(consumerFactory);
ContainerProperties containerProperties = kafkaListenerContainerFactory.getContainerProperties();
assertThat(containerProperties.getAckMode()).isEqualTo(AckMode.MANUAL);
assertThat(containerProperties.isAsyncAcks()).isEqualTo(true);
assertThat(containerProperties.isAsyncAcks()).isTrue();
assertThat(containerProperties.getClientId()).isEqualTo("client");
assertThat(containerProperties.getAckCount()).isEqualTo(123);
assertThat(containerProperties.getAckTime()).isEqualTo(456L);
@@ -672,10 +672,10 @@ class KafkaAutoConfigurationTests {
DefaultKafkaProducerFactory<?, ?> producerFactory = context
.getBean(DefaultKafkaProducerFactory.class);
Map<String, Object> producerConfigs = producerFactory.getConfigurationProperties();
assertThat(producerConfigs.get(CommonClientConfigs.SECURITY_PROTOCOL_CONFIG)).isEqualTo("SSL");
assertThat(producerConfigs).containsEntry(CommonClientConfigs.SECURITY_PROTOCOL_CONFIG, "SSL");
KafkaAdmin admin = context.getBean(KafkaAdmin.class);
Map<String, Object> configs = admin.getConfigurationProperties();
assertThat(configs.get(CommonClientConfigs.SECURITY_PROTOCOL_CONFIG)).isEqualTo("PLAINTEXT");
assertThat(configs).containsEntry(CommonClientConfigs.SECURITY_PROTOCOL_CONFIG, "PLAINTEXT");
});
}

10
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/kafka/KafkaPropertiesTests.java
View File

@@ -51,7 +51,7 @@ class KafkaPropertiesTests {
IsolationLevel.READ_COMMITTED.name());
assertThat(original).extracting("id").containsExactly(IsolationLevel.READ_UNCOMMITTED.id(),
IsolationLevel.READ_COMMITTED.id());
assertThat(original).hasSize(IsolationLevel.values().length);
assertThat(original).hasSameSizeAs(IsolationLevel.values());
}
@Test
@@ -76,10 +76,10 @@ class KafkaPropertiesTests {
properties.getSsl().setTrustStoreCertificates("-----BEGINtrust");
properties.getSsl().setKeyStoreCertificateChain("-----BEGINchain");
Map<String, Object> consumerProperties = properties.buildConsumerProperties();
assertThat(consumerProperties.get(SslConfigs.SSL_KEYSTORE_KEY_CONFIG)).isEqualTo("-----BEGINkey");
assertThat(consumerProperties.get(SslConfigs.SSL_TRUSTSTORE_CERTIFICATES_CONFIG)).isEqualTo("-----BEGINtrust");
assertThat(consumerProperties.get(SslConfigs.SSL_KEYSTORE_CERTIFICATE_CHAIN_CONFIG))
.isEqualTo("-----BEGINchain");
assertThat(consumerProperties).containsEntry(SslConfigs.SSL_KEYSTORE_KEY_CONFIG, "-----BEGINkey");
assertThat(consumerProperties).containsEntry(SslConfigs.SSL_TRUSTSTORE_CERTIFICATES_CONFIG, "-----BEGINtrust");
assertThat(consumerProperties).containsEntry(SslConfigs.SSL_KEYSTORE_CERTIFICATE_CHAIN_CONFIG,
"-----BEGINchain");
}
@Test

6
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/ldap/LdapAutoConfigurationTests.java
View File

@@ -103,10 +103,10 @@ class LdapAutoConfigurationTests {
void contextSourceWithNoCustomization() {
this.contextRunner.run((context) -> {
LdapContextSource contextSource = context.getBean(LdapContextSource.class);
assertThat(contextSource.getUserDn()).isEqualTo("");
assertThat(contextSource.getPassword()).isEqualTo("");
assertThat(contextSource.getUserDn()).isEmpty();
assertThat(contextSource.getPassword()).isEmpty();
assertThat(contextSource.isAnonymousReadOnly()).isTrue();
assertThat(contextSource.getBaseLdapPathAsString()).isEqualTo("");
assertThat(contextSource.getBaseLdapPathAsString()).isEmpty();
});
}

6
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/liquibase/LiquibaseAutoConfigurationTests.java
View File

@@ -183,9 +183,9 @@ class LiquibaseAutoConfigurationTests {
assertThat(liquibase.getDatabaseChangeLogLockTable()).isEqualTo("LIQUI_LOCK");
JdbcTemplate jdbcTemplate = new JdbcTemplate(context.getBean(DataSource.class));
assertThat(jdbcTemplate.queryForObject("SELECT COUNT(*) FROM public.LIQUI_LOG", Integer.class))
.isEqualTo(1);
.isOne();
assertThat(jdbcTemplate.queryForObject("SELECT COUNT(*) FROM public.LIQUI_LOCK", Integer.class))
.isEqualTo(1);
.isOne();
});
}
@@ -321,7 +321,7 @@ class LiquibaseAutoConfigurationTests {
Map<String, String> parameters = (Map<String, String>) ReflectionTestUtils.getField(liquibase,
"parameters");
assertThat(parameters).containsKey("foo");
assertThat(parameters.get("foo")).isEqualTo("bar");
assertThat(parameters).containsEntry("foo", "bar");
}));
}

2
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/mail/MailSenderAutoConfigurationTests.java
View File

@@ -112,7 +112,7 @@ class MailSenderAutoConfigurationTests {
.run((context) -> {
assertThat(context).hasSingleBean(JavaMailSenderImpl.class);
JavaMailSenderImpl mailSender = context.getBean(JavaMailSenderImpl.class);
assertThat(mailSender.getJavaMailProperties().get("mail.smtp.auth")).isEqualTo("true");
assertThat(mailSender.getJavaMailProperties()).containsEntry("mail.smtp.auth", "true");
});
}

4
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/mustache/MustacheAutoConfigurationServletIntegrationTests.java
View File

@@ -82,13 +82,13 @@ class MustacheAutoConfigurationServletIntegrationTests {
@Test
void testHomePage() {
String body = new TestRestTemplate().getForObject("http://localhost:" + this.port, String.class);
assertThat(body.contains("Hello World")).isTrue();
assertThat(body).contains("Hello World");
}
@Test
void testPartialPage() {
String body = new TestRestTemplate().getForObject("http://localhost:" + this.port + "/partial", String.class);
assertThat(body.contains("Hello World")).isTrue();
assertThat(body).contains("Hello World");
}
@Configuration(proxyBeanMethods = false)

3
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/neo4j/Neo4jAutoConfigurationTests.java
View File

@@ -275,8 +275,7 @@ class Neo4jAutoConfigurationTests {
@Test
void driverConfigShouldBeConfiguredToUseUseSpringJclLogging() {
assertThat(mapDriverConfig(new Neo4jProperties()).logging()).isNotNull()
.isInstanceOf(Neo4jSpringJclLogging.class);
assertThat(mapDriverConfig(new Neo4jProperties()).logging()).isInstanceOf(Neo4jSpringJclLogging.class);
}
private URI determineServerUri(Neo4jProperties properties, Environment environment) {

10
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/orm/jpa/AbstractJpaAutoConfigurationTests.java
View File

@@ -196,9 +196,9 @@ abstract class AbstractJpaAutoConfigurationTests {
LocalContainerEntityManagerFactoryBean bean = context
.getBean(LocalContainerEntityManagerFactoryBean.class);
Map<String, Object> map = bean.getJpaPropertyMap();
assertThat(map.get("a")).isEqualTo("b");
assertThat(map.get("c")).isEqualTo("d");
assertThat(map.get("a.b")).isEqualTo("c");
assertThat(map).containsEntry("a", "b");
assertThat(map).containsEntry("c", "d");
assertThat(map).containsEntry("a.b", "c");
});
}
@@ -209,7 +209,7 @@ abstract class AbstractJpaAutoConfigurationTests {
LocalContainerEntityManagerFactoryBean factoryBean = context
.getBean(LocalContainerEntityManagerFactoryBean.class);
Map<String, Object> map = factoryBean.getJpaPropertyMap();
assertThat(map.get("configured")).isEqualTo("manually");
assertThat(map).containsEntry("configured", "manually");
});
}
@@ -219,7 +219,7 @@ abstract class AbstractJpaAutoConfigurationTests {
.run((context) -> {
EntityManagerFactory factoryBean = context.getBean(EntityManagerFactory.class);
Map<String, Object> map = factoryBean.getProperties();
assertThat(map.get("configured")).isEqualTo("manually");
assertThat(map).containsEntry("configured", "manually");
});
}

12
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/orm/jpa/CustomHibernateJpaAutoConfigurationTests.java
View File

@@ -68,7 +68,7 @@ class CustomHibernateJpaAutoConfigurationTests {
HibernateProperties hibernateProperties = context.getBean(HibernateProperties.class);
Map<String, Object> properties = hibernateProperties
.determineHibernateProperties(jpaProperties.getProperties(), new HibernateSettings());
assertThat(properties.get("hibernate.ejb.naming_strategy")).isNull();
assertThat(properties).doesNotContainKey("hibernate.ejb.naming_strategy");
});
}
@@ -78,10 +78,10 @@ class CustomHibernateJpaAutoConfigurationTests {
.withPropertyValues("spring.datasource.url:jdbc:h2:mem:naming-strategy-beans").run((context) -> {
HibernateJpaConfiguration jpaConfiguration = context.getBean(HibernateJpaConfiguration.class);
Map<String, Object> hibernateProperties = jpaConfiguration.getVendorProperties();
assertThat(hibernateProperties.get("hibernate.implicit_naming_strategy"))
.isEqualTo(NamingStrategyConfiguration.implicitNamingStrategy);
assertThat(hibernateProperties.get("hibernate.physical_naming_strategy"))
.isEqualTo(NamingStrategyConfiguration.physicalNamingStrategy);
assertThat(hibernateProperties).containsEntry("hibernate.implicit_naming_strategy",
NamingStrategyConfiguration.implicitNamingStrategy);
assertThat(hibernateProperties).containsEntry("hibernate.physical_naming_strategy",
NamingStrategyConfiguration.physicalNamingStrategy);
});
}
@@ -90,7 +90,7 @@ class CustomHibernateJpaAutoConfigurationTests {
this.contextRunner.withUserConfiguration(HibernatePropertiesCustomizerConfiguration.class).run((context) -> {
HibernateJpaConfiguration jpaConfiguration = context.getBean(HibernateJpaConfiguration.class);
Map<String, Object> hibernateProperties = jpaConfiguration.getVendorProperties();
assertThat(hibernateProperties.get("test.counter")).isEqualTo(2);
assertThat(hibernateProperties).containsEntry("test.counter", 2);
});
}

18
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/orm/jpa/HibernateJpaAutoConfigurationTests.java
View File

@@ -374,7 +374,7 @@ class HibernateJpaAutoConfigurationTests extends AbstractJpaAutoConfigurationTes
void vendorPropertiesWithEmbeddedDatabaseAndNoDdlProperty() {
contextRunner().run(vendorProperties((vendorProperties) -> {
assertThat(vendorProperties).doesNotContainKeys(AvailableSettings.JAKARTA_HBM2DDL_DATABASE_ACTION);
assertThat(vendorProperties.get(AvailableSettings.HBM2DDL_AUTO)).isEqualTo("create-drop");
assertThat(vendorProperties).containsEntry(AvailableSettings.HBM2DDL_AUTO, "create-drop");
}));
}
@@ -383,7 +383,7 @@ class HibernateJpaAutoConfigurationTests extends AbstractJpaAutoConfigurationTes
contextRunner().withPropertyValues("spring.jpa.hibernate.ddl-auto=update")
.run(vendorProperties((vendorProperties) -> {
assertThat(vendorProperties).doesNotContainKeys(AvailableSettings.JAKARTA_HBM2DDL_DATABASE_ACTION);
assertThat(vendorProperties.get(AvailableSettings.HBM2DDL_AUTO)).isEqualTo("update");
assertThat(vendorProperties).containsEntry(AvailableSettings.HBM2DDL_AUTO, "update");
}));
}
@@ -394,7 +394,7 @@ class HibernateJpaAutoConfigurationTests extends AbstractJpaAutoConfigurationTes
"spring.jpa.properties.hibernate.hbm2ddl.auto=create-drop")
.run(vendorProperties((vendorProperties) -> {
assertThat(vendorProperties).doesNotContainKeys(AvailableSettings.JAKARTA_HBM2DDL_DATABASE_ACTION);
assertThat(vendorProperties.get(AvailableSettings.HBM2DDL_AUTO)).isEqualTo("create-drop");
assertThat(vendorProperties).containsEntry(AvailableSettings.HBM2DDL_AUTO, "create-drop");
}));
}
@@ -411,8 +411,8 @@ class HibernateJpaAutoConfigurationTests extends AbstractJpaAutoConfigurationTes
.withPropertyValues(
"spring.jpa.properties.jakarta.persistence.schema-generation.database.action=create")
.run(vendorProperties((vendorProperties) -> {
assertThat(vendorProperties.get(AvailableSettings.JAKARTA_HBM2DDL_DATABASE_ACTION))
.isEqualTo("create");
assertThat(vendorProperties).containsEntry(AvailableSettings.JAKARTA_HBM2DDL_DATABASE_ACTION,
"create");
assertThat(vendorProperties).doesNotContainKeys(AvailableSettings.HBM2DDL_AUTO);
}));
}
@@ -422,9 +422,9 @@ class HibernateJpaAutoConfigurationTests extends AbstractJpaAutoConfigurationTes
contextRunner().withPropertyValues(
"spring.jpa.properties.jakarta.persistence.schema-generation.database.action=create",
"spring.jpa.hibernate.ddl-auto=create-only").run(vendorProperties((vendorProperties) -> {
assertThat(vendorProperties.get(AvailableSettings.JAKARTA_HBM2DDL_DATABASE_ACTION))
.isEqualTo("create");
assertThat(vendorProperties.get(AvailableSettings.HBM2DDL_AUTO)).isEqualTo("create-only");
assertThat(vendorProperties).containsEntry(AvailableSettings.JAKARTA_HBM2DDL_DATABASE_ACTION,
"create");
assertThat(vendorProperties).containsEntry(AvailableSettings.HBM2DDL_AUTO, "create-only");
}));
}
@@ -467,7 +467,7 @@ class HibernateJpaAutoConfigurationTests extends AbstractJpaAutoConfigurationTes
.run((context) -> {
EntityManagerFactory factoryBean = context.getBean(EntityManagerFactory.class);
Map<String, Object> map = factoryBean.getProperties();
assertThat(map.get("configured")).isEqualTo("manually");
assertThat(map).containsEntry("configured", "manually");
});
}

2
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/quartz/QuartzAutoConfigurationTests.java
View File

@@ -335,7 +335,7 @@ class QuartzAutoConfigurationTests {
assertThat(jdbcTemplate.queryForObject("SELECT COUNT(*) FROM QRTZ_JOB_DETAILS", Integer.class))
.isEqualTo(2);
assertThat(jdbcTemplate.queryForObject("SELECT COUNT(*) FROM QRTZ_SIMPLE_TRIGGERS", Integer.class))
.isEqualTo(0);
.isZero();
};
}

2
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/security/oauth2/resource/reactive/ReactiveOAuth2ResourceServerAutoConfigurationTests.java
View File

@@ -185,7 +185,7 @@ class ReactiveOAuth2ResourceServerAutoConfigurationTests {
reactiveJwtDecoderSupplier.block(TIMEOUT);
});
// The last request is to the JWK Set endpoint to look up the algorithm
assertThat(this.server.getRequestCount()).isEqualTo(1);
assertThat(this.server.getRequestCount()).isOne();
}
@Test

2
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/security/rsocket/RSocketSecurityAutoConfigurationTests.java
View File

@@ -76,7 +76,7 @@ class RSocketSecurityAutoConfigurationTests {
this.contextRunner.run((context) -> {
assertThat(context).hasSingleBean(RSocketMessageHandler.class);
RSocketMessageHandler handler = context.getBean(RSocketMessageHandler.class);
assertThat(handler.getArgumentResolverConfigurer().getCustomResolvers()).isNotEmpty()
assertThat(handler.getArgumentResolverConfigurer().getCustomResolvers())
.anyMatch((customResolver) -> customResolver instanceof AuthenticationPrincipalArgumentResolver);
});
}

4
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/security/saml2/Saml2RelyingPartyAutoConfigurationTests.java
View File

@@ -99,7 +99,7 @@ class Saml2RelyingPartyAutoConfigurationTests {
assertThat(registration.getAssertionConsumerServiceBinding()).isEqualTo(Saml2MessageBinding.REDIRECT);
assertThat(registration.getAssertingPartyDetails().getSingleSignOnServiceBinding())
.isEqualTo(Saml2MessageBinding.POST);
assertThat(registration.getAssertingPartyDetails().getWantAuthnRequestsSigned()).isEqualTo(false);
assertThat(registration.getAssertingPartyDetails().getWantAuthnRequestsSigned()).isFalse();
assertThat(registration.getSigningX509Credentials()).hasSize(1);
assertThat(registration.getDecryptionX509Credentials()).hasSize(1);
assertThat(registration.getAssertingPartyDetails().getVerificationX509Credentials()).isNotNull();
@@ -142,7 +142,7 @@ class Saml2RelyingPartyAutoConfigurationTests {
this.contextRunner.withPropertyValues(PREFIX + ".foo.assertingparty.metadata-uri=" + metadataUrl)
.run((context) -> {
assertThat(context).hasSingleBean(RelyingPartyRegistrationRepository.class);
assertThat(server.getRequestCount()).isEqualTo(1);
assertThat(server.getRequestCount()).isOne();
});
}
}

4
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/security/saml2/Saml2RelyingPartyPropertiesTests.java
View File

@@ -61,7 +61,7 @@ class Saml2RelyingPartyPropertiesTests {
bind("spring.security.saml2.relyingparty.registration.simplesamlphp.assertingparty.single-sign-on.sign-request",
"false");
assertThat(this.properties.getRegistration().get("simplesamlphp").getAssertingparty().getSinglesignon()
.isSignRequest()).isEqualTo(false);
.isSignRequest()).isFalse();
}
@Test
@@ -90,7 +90,7 @@ class Saml2RelyingPartyPropertiesTests {
void customizeSsoSignRequestsIsTrueByDefault() {
this.properties.getRegistration().put("simplesamlphp", new Saml2RelyingPartyProperties.Registration());
assertThat(this.properties.getRegistration().get("simplesamlphp").getAssertingparty().getSinglesignon()
.isSignRequest()).isEqualTo(true);
.isSignRequest()).isTrue();
}
private void bind(String name, String value) {

2
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/security/servlet/SecurityAutoConfigurationTests.java
View File

@@ -92,7 +92,7 @@ class SecurityAutoConfigurationTests {
void securityConfigurerBacksOffWhenOtherSecurityFilterChainBeanPresent() {
this.contextRunner.withConfiguration(AutoConfigurations.of(WebMvcAutoConfiguration.class))
.withUserConfiguration(TestSecurityFilterChainConfig.class).run((context) -> {
assertThat(context.getBeansOfType(SecurityFilterChain.class).size()).isEqualTo(1);
assertThat(context.getBeansOfType(SecurityFilterChain.class)).hasSize(1);
assertThat(context.containsBean("testSecurityFilterChain")).isTrue();
});
}

4
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/sendgrid/SendGridAutoConfigurationTests.java
View File

@@ -52,7 +52,7 @@ class SendGridAutoConfigurationTests {
void expectedSendGridBeanCreatedApiKey() {
loadContext("spring.sendgrid.api-key:SG.SECRET-API-KEY");
SendGrid sendGrid = this.context.getBean(SendGrid.class);
assertThat(sendGrid.getRequestHeaders().get("Authorization")).isEqualTo("Bearer SG.SECRET-API-KEY");
assertThat(sendGrid.getRequestHeaders()).containsEntry("Authorization", "Bearer SG.SECRET-API-KEY");
}
@Test
@@ -66,7 +66,7 @@ class SendGridAutoConfigurationTests {
void autoConfigurationNotFiredWhenBeanAlreadyCreated() {
loadContext(ManualSendGridConfiguration.class, "spring.sendgrid.api-key:SG.SECRET-API-KEY");
SendGrid sendGrid = this.context.getBean(SendGrid.class);
assertThat(sendGrid.getRequestHeaders().get("Authorization")).isEqualTo("Bearer SG.CUSTOM_API_KEY");
assertThat(sendGrid.getRequestHeaders()).containsEntry("Authorization", "Bearer SG.CUSTOM_API_KEY");
}
@Test

2
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/transaction/TransactionManagerCustomizersTests.java
View File

@@ -48,7 +48,7 @@ class TransactionManagerCustomizersTests {
customizers.customize(mock(PlatformTransactionManager.class));
customizers.customize(mock(JtaTransactionManager.class));
assertThat(list.get(0).getCount()).isEqualTo(2);
assertThat(list.get(1).getCount()).isEqualTo(1);
assertThat(list.get(1).getCount()).isOne();
}
static class TestCustomizer<T extends PlatformTransactionManager>

2
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/validation/ValidationAutoConfigurationTests.java
View File

@@ -231,7 +231,7 @@ class ValidationAutoConfigurationTests {
this.contextRunner.run((parent) -> new ApplicationContextRunner()
.withConfiguration(AutoConfigurations.of(ValidationAutoConfiguration.class))
.withUserConfiguration(SampleService.class).withParent(parent).run((context) -> {
assertThat(context.getBeansOfType(Validator.class)).hasSize(0);
assertThat(context.getBeansOfType(Validator.class)).isEmpty();
assertThat(parent.getBeansOfType(Validator.class)).hasSize(1);
SampleService service = context.getBean(SampleService.class);
service.doSomething("Valid");

2
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/validation/ValidatorAdapterTests.java
View File

@@ -53,7 +53,7 @@ class ValidatorAdapterTests {
assertThat(wrapper.supports(SampleData.class)).isTrue();
MapBindingResult errors = new MapBindingResult(new HashMap<String, Object>(), "test");
wrapper.validate(new SampleData(40), errors);
assertThat(errors.getErrorCount()).isEqualTo(1);
assertThat(errors.getErrorCount()).isOne();
});
}

10
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/web/ServerPropertiesTests.java
View File

@@ -44,7 +44,6 @@ import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.util.thread.QueuedThreadPool;
import org.junit.jupiter.api.Test;
import reactor.netty.http.HttpDecoderSpec;
import reactor.netty.http.server.HttpRequestDecoderSpec;
import org.springframework.boot.autoconfigure.web.ServerProperties.Tomcat.Accesslog;
import org.springframework.boot.context.properties.bind.Bindable;
@@ -148,7 +147,7 @@ class ServerPropertiesTests {
assertThat(accesslog.getSuffix()).isEqualTo("-bar.log");
assertThat(accesslog.getEncoding()).isEqualTo("UTF-8");
assertThat(accesslog.getLocale()).isEqualTo("en-AU");
assertThat(accesslog.isCheckExists()).isEqualTo(true);
assertThat(accesslog.isCheckExists()).isTrue();
assertThat(accesslog.isRotate()).isFalse();
assertThat(accesslog.isRenameOnRotate()).isTrue();
assertThat(accesslog.isIpv6Canonical()).isTrue();
@@ -173,7 +172,7 @@ class ServerPropertiesTests {
@Test
void testSlashOfContextPathIsDefaultValue() {
bind("server.servlet.context-path", "/");
assertThat(this.properties.getServlet().getContextPath()).isEqualTo("");
assertThat(this.properties.getServlet().getContextPath()).isEmpty();
}
@Test
@@ -554,13 +553,12 @@ class ServerPropertiesTests {
@Test
void nettyValidateHeadersMatchesHttpDecoderSpecDefault() {
assertThat(this.properties.getNetty().isValidateHeaders()).isEqualTo(HttpDecoderSpec.DEFAULT_VALIDATE_HEADERS);
assertThat(this.properties.getNetty().isValidateHeaders()).isTrue();
}
@Test
void nettyH2cMaxContentLengthMatchesHttpDecoderSpecDefault() {
assertThat(this.properties.getNetty().getH2cMaxContentLength().toBytes())
.isEqualTo(HttpRequestDecoderSpec.DEFAULT_H2C_MAX_CONTENT_LENGTH);
assertThat(this.properties.getNetty().getH2cMaxContentLength().toBytes()).isZero();
}
@Test

3
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/web/client/RestTemplateAutoConfigurationTests.java
View File

@@ -90,8 +90,7 @@ class RestTemplateAutoConfigurationTests {
this.contextRunner.withUserConfiguration(RestTemplateConfig.class).run((context) -> {
assertThat(context).hasSingleBean(RestTemplate.class);
RestTemplate restTemplate = context.getBean(RestTemplate.class);
assertThat(restTemplate.getMessageConverters().size())
.isEqualTo(new RestTemplate().getMessageConverters().size());
assertThat(restTemplate.getMessageConverters()).hasSameSizeAs(new RestTemplate().getMessageConverters());
});
}

4
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/web/embedded/TomcatWebServerFactoryCustomizerTests.java
View File

@@ -287,7 +287,7 @@ class TomcatWebServerFactoryCustomizerTests {
@Test
void defaultUseForwardHeaders() {
TomcatServletWebServerFactory factory = customizeAndGetFactory();
assertThat(factory.getEngineValves()).hasSize(0);
assertThat(factory.getEngineValves()).isEmpty();
}
@Test
@@ -301,7 +301,7 @@ class TomcatWebServerFactoryCustomizerTests {
this.environment.setProperty("DYNO", "-");
this.serverProperties.setForwardHeadersStrategy(ServerProperties.ForwardHeadersStrategy.NONE);
TomcatServletWebServerFactory factory = customizeAndGetFactory();
assertThat(factory.getEngineValves()).hasSize(0);
assertThat(factory.getEngineValves()).isEmpty();
}
@Test

4
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/web/format/WebConversionServiceTests.java
View File

@@ -174,8 +174,8 @@ class WebConversionServiceTests {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
assertThat(calendar.get(Calendar.YEAR)).isEqualTo(2018);
assertThat(calendar.get(Calendar.MONTH)).isEqualTo(Calendar.JANUARY);
assertThat(calendar.get(Calendar.DAY_OF_MONTH)).isEqualTo(1);
assertThat(calendar.get(Calendar.MONTH)).isZero();
assertThat(calendar.get(Calendar.DAY_OF_MONTH)).isOne();
}
private void customDateFormat(Object input) {

4
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/web/reactive/WebFluxAutoConfigurationTests.java
View File

@@ -412,7 +412,7 @@ class WebFluxAutoConfigurationTests {
this.contextRunner.withUserConfiguration(CustomRequestMappingHandlerMapping.class).run((context) -> {
assertThat(context).getBean(RequestMappingHandlerMapping.class)
.isInstanceOf(MyRequestMappingHandlerMapping.class);
assertThat(context.getBean(CustomRequestMappingHandlerMapping.class).handlerMappings).isEqualTo(1);
assertThat(context.getBean(CustomRequestMappingHandlerMapping.class).handlerMappings).isOne();
});
}
@@ -421,7 +421,7 @@ class WebFluxAutoConfigurationTests {
this.contextRunner.withUserConfiguration(CustomRequestMappingHandlerAdapter.class).run((context) -> {
assertThat(context).getBean(RequestMappingHandlerAdapter.class)
.isInstanceOf(MyRequestMappingHandlerAdapter.class);
assertThat(context.getBean(CustomRequestMappingHandlerAdapter.class).handlerAdapters).isEqualTo(1);
assertThat(context.getBean(CustomRequestMappingHandlerAdapter.class).handlerAdapters).isOne();
});
}

15
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/web/servlet/HttpEncodingAutoConfigurationTests.java
View File

@@ -132,7 +132,7 @@ class HttpEncodingAutoConfigurationTests {
void noLocaleCharsetMapping() {
load(EmptyConfiguration.class);
Map<String, WebServerFactoryCustomizer<?>> beans = getWebServerFactoryCustomizerBeans();
assertThat(beans.size()).isEqualTo(1);
assertThat(beans).hasSize(1);
assertThat(this.context.getBean(MockServletWebServerFactory.class).getLocaleCharsetMappings()).isEmpty();
}
@@ -141,15 +141,10 @@ class HttpEncodingAutoConfigurationTests {
load(EmptyConfiguration.class, "server.servlet.encoding.mapping.en:UTF-8",
"server.servlet.encoding.mapping.fr_FR:UTF-8");
Map<String, WebServerFactoryCustomizer<?>> beans = getWebServerFactoryCustomizerBeans();
assertThat(beans.size()).isEqualTo(1);
assertThat(this.context.getBean(MockServletWebServerFactory.class).getLocaleCharsetMappings().size())
.isEqualTo(2);
assertThat(
this.context.getBean(MockServletWebServerFactory.class).getLocaleCharsetMappings().get(Locale.ENGLISH))
.isEqualTo(StandardCharsets.UTF_8);
assertThat(
this.context.getBean(MockServletWebServerFactory.class).getLocaleCharsetMappings().get(Locale.FRANCE))
.isEqualTo(StandardCharsets.UTF_8);
assertThat(beans).hasSize(1);
assertThat(this.context.getBean(MockServletWebServerFactory.class).getLocaleCharsetMappings()).hasSize(2)
.containsEntry(Locale.ENGLISH, StandardCharsets.UTF_8)
.containsEntry(Locale.FRANCE, StandardCharsets.UTF_8);
}
@SuppressWarnings({ "unchecked", "rawtypes" })

19
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/web/servlet/WebMvcAutoConfigurationTests.java
View File

@@ -177,9 +177,9 @@ class WebMvcAutoConfigurationTests {
assertThat(locations.get("/webjars/**").get(0))
.isEqualTo(new ClassPathResource("/META-INF/resources/webjars/"));
assertThat(getResourceResolvers(context, "/webjars/**")).hasSize(1);
assertThat(getResourceTransformers(context, "/webjars/**")).hasSize(0);
assertThat(getResourceTransformers(context, "/webjars/**")).isEmpty();
assertThat(getResourceResolvers(context, "/**")).hasSize(1);
assertThat(getResourceTransformers(context, "/**")).hasSize(0);
assertThat(getResourceTransformers(context, "/**")).isEmpty();
});
}
@@ -318,7 +318,7 @@ class WebMvcAutoConfigurationTests {
Locale locale = localeResolver.resolveLocale(request);
// test locale resolver uses fixed locale and not user preferred
// locale
assertThat(locale.toString()).isEqualTo("en_UK");
assertThat(locale).hasToString("en_UK");
});
}
@@ -333,7 +333,7 @@ class WebMvcAutoConfigurationTests {
assertThat(localeResolver).isInstanceOf(AcceptHeaderLocaleResolver.class);
Locale locale = localeResolver.resolveLocale(request);
// test locale resolver uses user preferred locale
assertThat(locale.toString()).isEqualTo("nl_NL");
assertThat(locale).hasToString("nl_NL");
});
}
@@ -346,7 +346,7 @@ class WebMvcAutoConfigurationTests {
assertThat(localeResolver).isInstanceOf(AcceptHeaderLocaleResolver.class);
Locale locale = localeResolver.resolveLocale(request);
// test locale resolver uses default locale if no header is set
assertThat(locale.toString()).isEqualTo("en_UK");
assertThat(locale).hasToString("en_UK");
});
}
@@ -611,7 +611,7 @@ class WebMvcAutoConfigurationTests {
this.contextRunner.withUserConfiguration(CustomRequestMappingHandlerMapping.class).run((context) -> {
assertThat(context).getBean(RequestMappingHandlerMapping.class)
.isInstanceOf(MyRequestMappingHandlerMapping.class);
assertThat(context.getBean(CustomRequestMappingHandlerMapping.class).handlerMappings).isEqualTo(1);
assertThat(context.getBean(CustomRequestMappingHandlerMapping.class).handlerMappings).isOne();
});
}
@@ -620,7 +620,7 @@ class WebMvcAutoConfigurationTests {
this.contextRunner.withUserConfiguration(CustomRequestMappingHandlerAdapter.class).run((context) -> {
assertThat(context).getBean(RequestMappingHandlerAdapter.class)
.isInstanceOf(MyRequestMappingHandlerAdapter.class);
assertThat(context.getBean(CustomRequestMappingHandlerAdapter.class).handlerAdapters).isEqualTo(1);
assertThat(context.getBean(CustomRequestMappingHandlerAdapter.class).handlerAdapters).isOne();
});
}
@@ -628,8 +628,7 @@ class WebMvcAutoConfigurationTests {
void customExceptionHandlerExceptionResolver() {
this.contextRunner.withUserConfiguration(CustomExceptionHandlerExceptionResolver.class)
.run((context) -> assertThat(
context.getBean(CustomExceptionHandlerExceptionResolver.class).exceptionResolvers)
.isEqualTo(1));
context.getBean(CustomExceptionHandlerExceptionResolver.class).exceptionResolvers).isOne());
}
@Test
@@ -996,7 +995,7 @@ class WebMvcAutoConfigurationTests {
if (bean instanceof HandlerMapping handlerMapping) {
return getMappingLocations(context, handlerMapping);
}
assertThat(bean.toString()).isEqualTo("null");
assertThat(bean).hasToString("null");
return Collections.emptyMap();
}

2
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/web/servlet/error/BasicErrorControllerIntegrationTests.java
View File

@@ -333,7 +333,7 @@ class BasicErrorControllerIntegrationTests {
private void assertErrorAttributes(Map<?, ?> content, String status, String error, Class<?> exception,
String message, String path) {
assertThat(content.get("status").toString()).as("Wrong status").isEqualTo(status);
assertThat(content.get("status")).as("Wrong status").hasToString(status);
assertThat(content.get("error")).as("Wrong error").isEqualTo(error);
if (exception != null) {
assertThat(content.get("exception")).as("Wrong exception").isEqualTo(exception.getName());

2
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/websocket/servlet/WebSocketMessagingAutoConfigurationTests.java
View File

@@ -121,7 +121,7 @@ class WebSocketMessagingAutoConfigurationTests {
void customizedConverterTypesMatchDefaultConverterTypes() {
List<MessageConverter> customizedConverters = getCustomizedConverters();
List<MessageConverter> defaultConverters = getDefaultConverters();
assertThat(customizedConverters.size()).isEqualTo(defaultConverters.size());
assertThat(customizedConverters).hasSameSizeAs(defaultConverters);
Iterator<MessageConverter> customizedIterator = customizedConverters.iterator();
Iterator<MessageConverter> defaultIterator = defaultConverters.iterator();
while (customizedIterator.hasNext()) {