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

Migrate Hamcrest assertions to AssertJ

Browse Source 
Migrate all existing `assertThat(..., Matcher)` assertions to AssertJ
and add checkstyle rules to ensure they don't return.

See gh-23022
This commit is contained in:
Phillip Webb
2019-05-23 15:48:03 -07:00
parent 2294625cf0
commit 95a9d46a87
322 changed files with 4358 additions and 4814 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
spring-webflux/src/test/java/org/springframework/web/reactive/DispatcherHandlerErrorTests.java
View File

@@ -50,10 +50,7 @@ import org.springframework.web.server.WebExceptionHandler;
import org.springframework.web.server.WebHandler;
import org.springframework.web.server.handler.ExceptionHandlingWebHandler;
import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.startsWith;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertSame;
@@ -89,8 +86,8 @@ public class DispatcherHandlerErrorTests {
StepVerifier.create(mono)
.consumeErrorWith(ex -> {
assertThat(ex, instanceOf(ResponseStatusException.class));
assertThat(ex.getMessage(), is("404 NOT_FOUND \"No matching handler\""));
assertThat(ex).isInstanceOf(ResponseStatusException.class);
assertThat(ex.getMessage()).isEqualTo("404 NOT_FOUND \"No matching handler\"");
})
.verify();
@@ -126,10 +123,10 @@ public class DispatcherHandlerErrorTests {
Mono<Void> publisher = this.dispatcherHandler.handle(exchange);
StepVerifier.create(publisher)
.consumeErrorWith(error -> {
assertThat(error, instanceOf(IllegalStateException.class));
assertThat(error.getMessage(), startsWith("No HandlerResultHandler"));
})
.consumeErrorWith(error ->
assertThat(error)
.isInstanceOf(IllegalStateException.class)
.hasMessageStartingWith("No HandlerResultHandler"))
.verify();
}
@@ -141,7 +138,7 @@ public class DispatcherHandlerErrorTests {
Mono<Void> publisher = this.dispatcherHandler.handle(exchange);
StepVerifier.create(publisher)
.consumeErrorWith(error -> assertThat(error, instanceOf(NotAcceptableStatusException.class)))
.consumeErrorWith(error -> assertThat(error).isInstanceOf(NotAcceptableStatusException.class))
.verify();
}

71
spring-webflux/src/test/java/org/springframework/web/reactive/config/ResourceHandlerRegistryTests.java
View File

@@ -21,7 +21,6 @@ import java.time.Duration;
import java.util.List;
import java.util.concurrent.TimeUnit;
import org.hamcrest.Matchers;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mockito;
@@ -49,7 +48,7 @@ import org.springframework.web.reactive.resource.ResourceWebHandler;
import org.springframework.web.reactive.resource.VersionResourceResolver;
import org.springframework.web.reactive.resource.WebJarsResourceResolver;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
@@ -99,11 +98,11 @@ public class ResourceHandlerRegistryTests {
@Test
public void cacheControl() {
assertThat(getHandler("/resources/**").getCacheControl(), Matchers.nullValue());
assertThat(getHandler("/resources/**").getCacheControl()).isNull();
this.registration.setCacheControl(CacheControl.noCache().cachePrivate());
assertThat(getHandler("/resources/**").getCacheControl().getHeaderValue(),
Matchers.equalTo(CacheControl.noCache().cachePrivate().getHeaderValue()));
assertThat(getHandler("/resources/**").getCacheControl().getHeaderValue())
.isEqualTo(CacheControl.noCache().cachePrivate().getHeaderValue());
}
@Test
@@ -131,18 +130,18 @@ public class ResourceHandlerRegistryTests {
ResourceWebHandler handler = getHandler("/resources/**");
List<ResourceResolver> resolvers = handler.getResourceResolvers();
assertThat(resolvers.toString(), resolvers, Matchers.hasSize(4));
assertThat(resolvers.get(0), Matchers.instanceOf(CachingResourceResolver.class));
assertThat(resolvers).hasSize(4);
assertThat(resolvers.get(0)).isInstanceOf(CachingResourceResolver.class);
CachingResourceResolver cachingResolver = (CachingResourceResolver) resolvers.get(0);
assertThat(cachingResolver.getCache(), Matchers.instanceOf(ConcurrentMapCache.class));
assertThat(resolvers.get(1), Matchers.equalTo(mockResolver));
assertThat(resolvers.get(2), Matchers.instanceOf(WebJarsResourceResolver.class));
assertThat(resolvers.get(3), Matchers.instanceOf(PathResourceResolver.class));
assertThat(cachingResolver.getCache()).isInstanceOf(ConcurrentMapCache.class);
assertThat(resolvers.get(1)).isEqualTo(mockResolver);
assertThat(resolvers.get(2)).isInstanceOf(WebJarsResourceResolver.class);
assertThat(resolvers.get(3)).isInstanceOf(PathResourceResolver.class);
List<ResourceTransformer> transformers = handler.getResourceTransformers();
assertThat(transformers, Matchers.hasSize(2));
assertThat(transformers.get(0), Matchers.instanceOf(CachingResourceTransformer.class));
assertThat(transformers.get(1), Matchers.equalTo(mockTransformer));
assertThat(transformers).hasSize(2);
assertThat(transformers.get(0)).isInstanceOf(CachingResourceTransformer.class);
assertThat(transformers.get(1)).isEqualTo(mockTransformer);
Mockito.verify(mockTransformer).setResourceUrlProvider(resourceUrlProvider);
}
@@ -152,12 +151,12 @@ public class ResourceHandlerRegistryTests {
ResourceWebHandler handler = getHandler("/resources/**");
List<ResourceResolver> resolvers = handler.getResourceResolvers();
assertThat(resolvers, Matchers.hasSize(2));
assertThat(resolvers.get(0), Matchers.instanceOf(WebJarsResourceResolver.class));
assertThat(resolvers.get(1), Matchers.instanceOf(PathResourceResolver.class));
assertThat(resolvers).hasSize(2);
assertThat(resolvers.get(0)).isInstanceOf(WebJarsResourceResolver.class);
assertThat(resolvers.get(1)).isInstanceOf(PathResourceResolver.class);
List<ResourceTransformer> transformers = handler.getResourceTransformers();
assertThat(transformers, Matchers.hasSize(0));
assertThat(transformers).hasSize(0);
}
@Test
@@ -171,17 +170,17 @@ public class ResourceHandlerRegistryTests {
ResourceWebHandler handler = getHandler("/resources/**");
List<ResourceResolver> resolvers = handler.getResourceResolvers();
assertThat(resolvers.toString(), resolvers, Matchers.hasSize(4));
assertThat(resolvers.get(0), Matchers.instanceOf(CachingResourceResolver.class));
assertThat(resolvers.get(1), Matchers.sameInstance(versionResolver));
assertThat(resolvers.get(2), Matchers.instanceOf(WebJarsResourceResolver.class));
assertThat(resolvers.get(3), Matchers.instanceOf(PathResourceResolver.class));
assertThat(resolvers).hasSize(4);
assertThat(resolvers.get(0)).isInstanceOf(CachingResourceResolver.class);
assertThat(resolvers.get(1)).isSameAs(versionResolver);
assertThat(resolvers.get(2)).isInstanceOf(WebJarsResourceResolver.class);
assertThat(resolvers.get(3)).isInstanceOf(PathResourceResolver.class);
List<ResourceTransformer> transformers = handler.getResourceTransformers();
assertThat(transformers, Matchers.hasSize(3));
assertThat(transformers.get(0), Matchers.instanceOf(CachingResourceTransformer.class));
assertThat(transformers.get(1), Matchers.instanceOf(CssLinkResourceTransformer.class));
assertThat(transformers.get(2), Matchers.instanceOf(AppCacheManifestTransformer.class));
assertThat(transformers).hasSize(3);
assertThat(transformers.get(0)).isInstanceOf(CachingResourceTransformer.class);
assertThat(transformers.get(1)).isInstanceOf(CssLinkResourceTransformer.class);
assertThat(transformers.get(2)).isInstanceOf(AppCacheManifestTransformer.class);
}
@Test
@@ -206,17 +205,17 @@ public class ResourceHandlerRegistryTests {
ResourceWebHandler handler = getHandler("/resources/**");
List<ResourceResolver> resolvers = handler.getResourceResolvers();
assertThat(resolvers.toString(), resolvers, Matchers.hasSize(4));
assertThat(resolvers.get(0), Matchers.sameInstance(cachingResolver));
assertThat(resolvers.get(1), Matchers.sameInstance(versionResolver));
assertThat(resolvers.get(2), Matchers.sameInstance(webjarsResolver));
assertThat(resolvers.get(3), Matchers.sameInstance(pathResourceResolver));
assertThat(resolvers).hasSize(4);
assertThat(resolvers.get(0)).isSameAs(cachingResolver);
assertThat(resolvers.get(1)).isSameAs(versionResolver);
assertThat(resolvers.get(2)).isSameAs(webjarsResolver);
assertThat(resolvers.get(3)).isSameAs(pathResourceResolver);
List<ResourceTransformer> transformers = handler.getResourceTransformers();
assertThat(transformers, Matchers.hasSize(3));
assertThat(transformers.get(0), Matchers.sameInstance(cachingTransformer));
assertThat(transformers.get(1), Matchers.sameInstance(appCacheTransformer));
assertThat(transformers.get(2), Matchers.sameInstance(cssLinkTransformer));
assertThat(transformers).hasSize(3);
assertThat(transformers.get(0)).isSameAs(cachingTransformer);
assertThat(transformers.get(1)).isSameAs(appCacheTransformer);
assertThat(transformers.get(2)).isSameAs(cssLinkTransformer);
}

11
spring-webflux/src/test/java/org/springframework/web/reactive/function/BodyInsertersTests.java
View File

@@ -67,8 +67,7 @@ import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.containsString;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.springframework.http.codec.json.Jackson2CodecSupport.JSON_VIEW_HINT;
@@ -341,16 +340,16 @@ public class BodyInsertersTests {
dataBuffer.read(resultBytes);
DataBufferUtils.release(dataBuffer);
String content = new String(resultBytes, StandardCharsets.UTF_8);
assertThat(content, containsString("Content-Disposition: form-data; name=\"name\"\r\n" +
assertThat(content).contains("Content-Disposition: form-data; name=\"name\"\r\n" +
"Content-Type: text/plain;charset=UTF-8\r\n" +
"Content-Length: 6\r\n" +
"\r\n" +
"value1"));
assertThat(content, containsString("Content-Disposition: form-data; name=\"name\"\r\n" +
"value1");
assertThat(content).contains("Content-Disposition: form-data; name=\"name\"\r\n" +
"Content-Type: text/plain;charset=UTF-8\r\n" +
"Content-Length: 6\r\n" +
"\r\n" +
"value2"));
"value2");
})
.expectComplete()
.verify();

7
spring-webflux/src/test/java/org/springframework/web/reactive/function/client/WebClientIntegrationTests.java
View File

@@ -29,7 +29,6 @@ import java.util.zip.CRC32;
import okhttp3.mockwebserver.MockResponse;
import okhttp3.mockwebserver.MockWebServer;
import okhttp3.mockwebserver.RecordedRequest;
import org.hamcrest.Matchers;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
@@ -56,7 +55,7 @@ import org.springframework.http.client.reactive.JettyClientHttpConnector;
import org.springframework.http.client.reactive.ReactorClientHttpConnector;
import org.springframework.http.codec.Pojo;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
@@ -338,8 +337,8 @@ public class WebClientIntegrationTests {
.bodyToFlux(Pojo.class);
StepVerifier.create(result)
.consumeNextWith(p -> assertThat(p.getBar(), Matchers.is("bar1")))
.consumeNextWith(p -> assertThat(p.getBar(), Matchers.is("bar2")))
.consumeNextWith(p -> assertThat(p.getBar()).isEqualTo("bar1"))
.consumeNextWith(p -> assertThat(p.getBar()).isEqualTo("bar2"))
.expectComplete()
.verify(Duration.ofSeconds(3));

22
spring-webflux/src/test/java/org/springframework/web/reactive/resource/AppCacheManifestTransformerTests.java
View File

@@ -29,8 +29,7 @@ import org.springframework.core.io.Resource;
import org.springframework.mock.web.test.server.MockServerWebExchange;
import org.springframework.util.FileCopyUtils;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.containsString;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertSame;
@@ -104,21 +103,20 @@ public class AppCacheManifestTransformerTests {
byte[] bytes = FileCopyUtils.copyToByteArray(actual.getInputStream());
String content = new String(bytes, "UTF-8");
assertThat("should rewrite resource links", content,
containsString("/static/foo-e36d2e05253c6c7085a91522ce43a0b4.css"));
assertThat("should rewrite resource links", content,
containsString("/static/bar-11e16cf79faee7ac698c805cf28248d2.css"));
assertThat("should rewrite resource links", content,
containsString("/static/js/bar-bd508c62235b832d960298ca6c0b7645.js"));
assertThat(content).as("rewrite resource links")
.contains("/static/foo-e36d2e05253c6c7085a91522ce43a0b4.css")
.contains("/static/bar-11e16cf79faee7ac698c805cf28248d2.css")
.contains("/static/js/bar-bd508c62235b832d960298ca6c0b7645.js");
assertThat("should not rewrite external resources", content, containsString("//example.org/style.css"));
assertThat("should not rewrite external resources", content, containsString("http://example.org/image.png"));
assertThat(content).as("not rewrite external resources")
.contains("//example.org/style.css")
.contains("http://example.org/image.png");
// Not the same hash as Spring MVC
// Hash is computed from links, and not from the linked content
assertThat("should generate fingerprint", content,
containsString("# Hash: 8eefc904df3bd46537fa7bdbbc5ab9fb"));
assertThat(content).as("generate fingerprint")
.contains("# Hash: 8eefc904df3bd46537fa7bdbbc5ab9fb");
}
private Resource getResource(String filePath) {

42
spring-webflux/src/test/java/org/springframework/web/reactive/resource/ResourceUrlProviderTests.java
View File

@@ -23,9 +23,7 @@ import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.hamcrest.BaseMatcher;
import org.hamcrest.Description;
import org.hamcrest.Matchers;
import org.assertj.core.api.Condition;
import org.junit.Before;
import org.junit.Test;
@@ -39,7 +37,7 @@ import org.springframework.web.context.support.AnnotationConfigWebApplicationCon
import org.springframework.web.reactive.handler.SimpleUrlHandlerMapping;
import org.springframework.web.util.pattern.PathPattern;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.springframework.mock.http.server.reactive.test.MockServerHttpRequest.get;
@@ -138,11 +136,17 @@ public class ResourceUrlProviderTests {
context.register(HandlerMappingConfiguration.class);
context.refresh();
assertThat(context.getBean(ResourceUrlProvider.class).getHandlerMap(),
Matchers.hasKey(pattern("/resources/**")));
assertThat(context.getBean(ResourceUrlProvider.class).getHandlerMap())
.hasKeySatisfying(pathPatternStringOf("/resources/**"));
}
private Condition<PathPattern> pathPatternStringOf(String expected) {
return new Condition<PathPattern>(
actual -> actual != null && actual.getPatternString().equals(expected),
"Pattern %s", expected);
}
@Configuration
@SuppressWarnings({"unused", "WeakerAccess"})
static class HandlerMappingConfiguration {
@@ -163,30 +167,4 @@ public class ResourceUrlProviderTests {
}
}
private static PathPatternMatcher pattern(String pattern) {
return new PathPatternMatcher(pattern);
}
private static class PathPatternMatcher extends BaseMatcher<PathPattern> {
private final String pattern;
public PathPatternMatcher(String pattern) {
this.pattern = pattern;
}
@Override
public boolean matches(Object item) {
if (item != null && item instanceof PathPattern) {
return ((PathPattern) item).getPatternString().equals(pattern);
}
return false;
}
@Override
public void describeTo(Description description) {
}
}
}

15
spring-webflux/src/test/java/org/springframework/web/reactive/resource/ResourceWebHandlerTests.java
View File

@@ -55,10 +55,9 @@ import org.springframework.web.server.MethodNotAllowedException;
import org.springframework.web.server.ResponseStatusException;
import org.springframework.web.server.ServerWebExchange;
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.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.instanceOf;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertNull;
@@ -287,7 +286,7 @@ public class ResourceWebHandlerTests {
StepVerifier.create(handler.handle(exchange))
.expectErrorSatisfies(err -> {
assertThat(err, instanceOf(ResponseStatusException.class));
assertThat(err).isInstanceOf(ResponseStatusException.class);
assertEquals(HttpStatus.NOT_FOUND, ((ResponseStatusException) err).getStatus());
}).verify(TIMEOUT);
}
@@ -333,7 +332,7 @@ public class ResourceWebHandlerTests {
setPathWithinHandlerMapping(exchange, requestPath);
StepVerifier.create(this.handler.handle(exchange))
.expectErrorSatisfies(err -> {
assertThat(err, instanceOf(ResponseStatusException.class));
assertThat(err).isInstanceOf(ResponseStatusException.class);
assertEquals(HttpStatus.NOT_FOUND, ((ResponseStatusException) err).getStatus());
})
.verify(TIMEOUT);
@@ -428,7 +427,7 @@ public class ResourceWebHandlerTests {
setPathWithinHandlerMapping(exchange, "js/");
StepVerifier.create(this.handler.handle(exchange))
.expectErrorSatisfies(err -> {
assertThat(err, instanceOf(ResponseStatusException.class));
assertThat(err).isInstanceOf(ResponseStatusException.class);
assertEquals(HttpStatus.NOT_FOUND, ((ResponseStatusException) err).getStatus());
}).verify(TIMEOUT);
}
@@ -439,7 +438,7 @@ public class ResourceWebHandlerTests {
setPathWithinHandlerMapping(exchange, "underscorejs/");
StepVerifier.create(this.handler.handle(exchange))
.expectErrorSatisfies(err -> {
assertThat(err, instanceOf(ResponseStatusException.class));
assertThat(err).isInstanceOf(ResponseStatusException.class);
assertEquals(HttpStatus.NOT_FOUND, ((ResponseStatusException) err).getStatus());
}).verify(TIMEOUT);
}
@@ -450,7 +449,7 @@ public class ResourceWebHandlerTests {
setPathWithinHandlerMapping(exchange, "");
StepVerifier.create(this.handler.handle(exchange))
.expectErrorSatisfies(err -> {
assertThat(err, instanceOf(ResponseStatusException.class));
assertThat(err).isInstanceOf(ResponseStatusException.class);
assertEquals(HttpStatus.NOT_FOUND, ((ResponseStatusException) err).getStatus());
}).verify(TIMEOUT);
}
@@ -485,7 +484,7 @@ public class ResourceWebHandlerTests {
StepVerifier.create(mono)
.expectErrorSatisfies(err -> {
assertThat(err, instanceOf(ResponseStatusException.class));
assertThat(err).isInstanceOf(ResponseStatusException.class);
assertEquals(HttpStatus.NOT_FOUND, ((ResponseStatusException) err).getStatus());
}).verify(TIMEOUT);

27
spring-webflux/src/test/java/org/springframework/web/reactive/resource/VersionResourceResolverTests.java
View File

@@ -23,7 +23,6 @@ import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.hamcrest.Matchers;
import org.junit.Before;
import org.junit.Test;
import reactor.core.publisher.Mono;
@@ -34,9 +33,7 @@ import org.springframework.mock.http.server.reactive.test.MockServerHttpRequest;
import org.springframework.mock.web.test.server.MockServerWebExchange;
import org.springframework.web.server.ServerWebExchange;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.instanceOf;
import static org.hamcrest.Matchers.is;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.mockito.BDDMockito.given;
@@ -179,7 +176,7 @@ public class VersionResourceResolverTests {
assertEquals(expected.getFilename(), actual.getFilename());
verify(this.versionStrategy, times(1)).getResourceVersion(expected);
assertThat(actual, instanceOf(HttpResource.class));
assertThat(actual).isInstanceOf(HttpResource.class);
assertEquals("\"" + version + "\"", ((HttpResource)actual).getResponseHeaders().getETag());
}
@@ -203,19 +200,19 @@ public class VersionResourceResolverTests {
this.resolver.addFixedVersionStrategy("fixedversion", "/js/**", "/css/**", "/fixedversion/css/**");
assertThat(this.resolver.getStrategyMap().size(), is(4));
assertThat(this.resolver.getStrategyMap()).hasSize(4);
assertThat(this.resolver.getStrategyForPath("js/something.js"),
Matchers.instanceOf(FixedVersionStrategy.class));
assertThat(this.resolver.getStrategyForPath("js/something.js"))
.isInstanceOf(FixedVersionStrategy.class);
assertThat(this.resolver.getStrategyForPath("fixedversion/js/something.js"),
Matchers.instanceOf(FixedVersionStrategy.class));
assertThat(this.resolver.getStrategyForPath("fixedversion/js/something.js"))
.isInstanceOf(FixedVersionStrategy.class);
assertThat(this.resolver.getStrategyForPath("css/something.css"),
Matchers.instanceOf(FixedVersionStrategy.class));
assertThat(this.resolver.getStrategyForPath("css/something.css"))
.isInstanceOf(FixedVersionStrategy.class);
assertThat(this.resolver.getStrategyForPath("fixedversion/css/something.css"),
Matchers.instanceOf(FixedVersionStrategy.class));
assertThat(this.resolver.getStrategyForPath("fixedversion/css/something.css"))
.isInstanceOf(FixedVersionStrategy.class);
}
@Test // SPR-15372
@@ -223,7 +220,7 @@ public class VersionResourceResolverTests {
given(this.chain.resolveUrlPath("/foo.css", this.locations)).willReturn(Mono.just("/foo.css"));
String resolved = this.resolver.resolveUrlPathInternal("/foo.css", this.locations, this.chain)
.block(Duration.ofMillis(1000));
assertThat(resolved, is("/foo.css"));
assertThat(resolved).isEqualTo("/foo.css");
}

11
spring-webflux/src/test/java/org/springframework/web/reactive/result/method/HandlerMethodMappingTests.java
View File

@@ -35,8 +35,8 @@ import org.springframework.web.server.ServerWebExchange;
import org.springframework.web.util.pattern.PathPattern;
import org.springframework.web.util.pattern.PathPatternParser;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
@@ -111,8 +111,8 @@ public class HandlerMethodMappingTests {
this.mapping.registerMapping(key1, this.handler, this.method1);
this.mapping.registerMapping(key2, this.handler, this.method2);
assertThat(this.mapping.getMappingRegistry().getMappings().keySet(),
Matchers.contains(key1, key2));
assertThat(this.mapping.getMappingRegistry().getMappings())
.containsKeys(key1, key2);
}
@Test
@@ -124,7 +124,8 @@ public class HandlerMethodMappingTests {
this.mapping.registerMapping(key1, handler1, this.method1);
this.mapping.registerMapping(key2, handler2, this.method1);
assertThat(this.mapping.getMappingRegistry().getMappings().keySet(), Matchers.contains(key1, key2));
assertThat(this.mapping.getMappingRegistry().getMappings())
.containsKeys(key1, key2);
}
@Test
@@ -139,7 +140,7 @@ public class HandlerMethodMappingTests {
result = this.mapping.getHandler(MockServerWebExchange.from(MockServerHttpRequest.get(key)));
assertNull(result.block());
assertThat(this.mapping.getMappingRegistry().getMappings().keySet(), Matchers.not(Matchers.contains(key)));
assertThat(this.mapping.getMappingRegistry().getMappings().keySet()).isNotEqualTo(Matchers.contains(key));
}

5
spring-webflux/src/test/java/org/springframework/web/reactive/result/method/InvocableHandlerMethodTests.java
View File

@@ -42,10 +42,9 @@ import org.springframework.web.reactive.HandlerResult;
import org.springframework.web.server.ServerWebExchange;
import org.springframework.web.server.UnsupportedMediaTypeStatusException;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.mockito.ArgumentMatchers.any;
@@ -158,7 +157,7 @@ public class InvocableHandlerMethodTests {
Mono<HandlerResult> mono = invoke(new TestController(), method);
assertHandlerResultValue(mono, "created");
assertThat(this.exchange.getResponse().getStatusCode(), is(HttpStatus.CREATED));
assertThat(this.exchange.getResponse().getStatusCode()).isEqualTo(HttpStatus.CREATED);
}
@Test

7
spring-webflux/src/test/java/org/springframework/web/reactive/result/method/RequestMappingInfoHandlerMappingTests.java
View File

@@ -58,8 +58,7 @@ import org.springframework.web.server.ServerWebInputException;
import org.springframework.web.server.UnsupportedMediaTypeStatusException;
import org.springframework.web.util.pattern.PathPattern;
import static org.hamcrest.CoreMatchers.containsString;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
@@ -187,8 +186,8 @@ public class RequestMappingInfoHandlerMappingTests {
ServerWebExchange exchange = MockServerWebExchange.from(get("/params"));
Mono<Object> mono = this.handlerMapping.getHandler(exchange);
assertError(mono, ServerWebInputException.class, ex -> {
assertThat(ex.getReason(), containsString("[foo=bar]"));
assertThat(ex.getReason(), containsString("[bar=baz]"));
assertThat(ex.getReason()).contains("[foo=bar]");
assertThat(ex.getReason()).contains("[bar=baz]");
});
}

17
spring-webflux/src/test/java/org/springframework/web/reactive/result/method/annotation/GlobalCorsConfigIntegrationTests.java
View File

@@ -38,8 +38,6 @@ import org.springframework.web.reactive.config.WebFluxConfigurationSupport;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.contains;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
@@ -116,8 +114,8 @@ public class GlobalCorsConfigIntegrationTests extends AbstractRequestMappingInte
ResponseEntity<String> entity = performOptions("/cors", this.headers, String.class);
assertEquals(HttpStatus.OK, entity.getStatusCode());
assertEquals("*", entity.getHeaders().getAccessControlAllowOrigin());
assertThat(entity.getHeaders().getAccessControlAllowMethods(),
contains(HttpMethod.GET, HttpMethod.HEAD, HttpMethod.POST));
assertThat(entity.getHeaders().getAccessControlAllowMethods())
.containsExactly(HttpMethod.GET, HttpMethod.HEAD, HttpMethod.POST);
}
@Test
@@ -143,7 +141,8 @@ public class GlobalCorsConfigIntegrationTests extends AbstractRequestMappingInte
ResponseEntity<String> entity = performOptions("/cors-restricted", this.headers, String.class);
assertEquals(HttpStatus.OK, entity.getStatusCode());
assertEquals("https://foo", entity.getHeaders().getAccessControlAllowOrigin());
assertThat(entity.getHeaders().getAccessControlAllowMethods(), contains(HttpMethod.GET, HttpMethod.POST));
assertThat(entity.getHeaders().getAccessControlAllowMethods())
.containsExactly(HttpMethod.GET, HttpMethod.POST);
}
@Test
@@ -152,10 +151,12 @@ public class GlobalCorsConfigIntegrationTests extends AbstractRequestMappingInte
ResponseEntity<String> entity = performOptions("/ambiguous", this.headers, String.class);
assertEquals(HttpStatus.OK, entity.getStatusCode());
assertEquals("http://localhost:9000", entity.getHeaders().getAccessControlAllowOrigin());
assertThat(entity.getHeaders().getAccessControlAllowMethods(), contains(HttpMethod.GET));
assertThat(entity.getHeaders().getAccessControlAllowMethods())
.containsExactly(HttpMethod.GET);
assertEquals(true, entity.getHeaders().getAccessControlAllowCredentials());
assertThat(entity.getHeaders().get(HttpHeaders.VARY), contains(HttpHeaders.ORIGIN,
HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD, HttpHeaders.ACCESS_CONTROL_REQUEST_HEADERS));
assertThat(entity.getHeaders().get(HttpHeaders.VARY))
.containsExactly(HttpHeaders.ORIGIN, HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD,
HttpHeaders.ACCESS_CONTROL_REQUEST_HEADERS);
}

5
spring-webflux/src/test/java/org/springframework/web/reactive/socket/WebSocketIntegrationTests.java
View File

@@ -25,7 +25,6 @@ import java.util.concurrent.atomic.AtomicReference;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hamcrest.Matchers;
import org.junit.Test;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
@@ -38,7 +37,7 @@ import org.springframework.http.HttpHeaders;
import org.springframework.web.reactive.HandlerMapping;
import org.springframework.web.reactive.handler.SimpleUrlHandlerMapping;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
/**
@@ -99,7 +98,7 @@ public class WebSocketIntegrationTests extends AbstractWebSocketIntegrationTests
.block(TIMEOUT);
HandshakeInfo info = infoRef.get();
assertThat(info.getHeaders().getFirst("Upgrade"), Matchers.equalToIgnoringCase("websocket"));
assertThat(info.getHeaders().getFirst("Upgrade")).isEqualToIgnoringCase("websocket");
assertEquals(protocol, info.getHeaders().getFirst("Sec-WebSocket-Protocol"));
assertEquals("Wrong protocol accepted", protocol, info.getSubProtocol());
assertEquals("Wrong protocol detected on the server side", protocol, output.block(TIMEOUT));

13
spring-webflux/src/test/java/org/springframework/web/reactive/socket/server/support/HandshakeWebSocketServiceTests.java
View File

@@ -20,7 +20,6 @@ import java.util.Arrays;
import java.util.Map;
import java.util.function.Supplier;
import org.hamcrest.Matchers;
import org.junit.Test;
import reactor.core.publisher.Mono;
@@ -33,8 +32,7 @@ import org.springframework.web.reactive.socket.WebSocketHandler;
import org.springframework.web.reactive.socket.server.RequestUpgradeStrategy;
import org.springframework.web.server.ServerWebExchange;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertNotNull;
import static org.mockito.Mockito.mock;
@@ -67,10 +65,11 @@ public class HandshakeWebSocketServiceTests {
assertNotNull(info);
Map<String, Object> attributes = info.getAttributes();
assertEquals(3, attributes.size());
assertThat(attributes, Matchers.hasEntry("a1", "v1"));
assertThat(attributes, Matchers.hasEntry("a3", "v3"));
assertThat(attributes, Matchers.hasEntry("a5", "v5"));
assertThat(attributes)
.hasSize(3)
.containsEntry("a1", "v1")
.containsEntry("a3", "v3")
.containsEntry("a5", "v5");
}
private MockServerHttpRequest initHandshakeRequest() {