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

Polish tests

Browse Source
This commit is contained in:
Rossen Stoyanchev
2016-07-05 18:14:47 -04:00
parent 7af7a55ede
commit 33b6dca2a6
3 changed files with 85 additions and 174 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -23,14 +23,12 @@ import org.junit.Before;
import org.junit.Test;
import org.reactivestreams.Publisher;
import reactor.core.publisher.Mono;
import reactor.core.publisher.Signal;
import reactor.core.util.SignalKind;
import reactor.core.test.TestSubscriber;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.codec.StringEncoder;
import org.springframework.core.convert.ConversionService;
import org.springframework.core.convert.support.DefaultConversionService;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.core.io.buffer.DefaultDataBufferFactory;
@@ -38,7 +36,6 @@ import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.converter.reactive.CodecHttpMessageConverter;
import org.springframework.http.converter.reactive.HttpMessageConverter;
import org.springframework.http.server.reactive.MockServerHttpRequest;
import org.springframework.http.server.reactive.MockServerHttpResponse;
import org.springframework.stereotype.Controller;
@@ -52,14 +49,10 @@ import org.springframework.web.server.NotAcceptableStatusException;
import org.springframework.web.server.ResponseStatusException;
import org.springframework.web.server.ServerWebExchange;
import org.springframework.web.server.WebExceptionHandler;
import org.springframework.web.server.WebFilter;
import org.springframework.web.server.WebFilterChain;
import org.springframework.web.server.WebHandler;
import org.springframework.web.server.adapter.DefaultServerWebExchange;
import org.springframework.web.server.handler.ExceptionHandlingWebHandler;
import org.springframework.web.server.handler.FilteringWebHandler;
import org.springframework.web.server.session.MockWebSessionManager;
import org.springframework.web.server.session.WebSessionManager;
import static org.hamcrest.CoreMatchers.startsWith;
import static org.junit.Assert.assertEquals;
@@ -75,15 +68,13 @@ import static org.junit.Assert.assertThat;
@SuppressWarnings({"ThrowableResultOfMethodCallIgnored", "ThrowableInstanceNeverThrown"})
public class DispatcherHandlerErrorTests {
public static final IllegalStateException EXCEPTION = new IllegalStateException("boo");
private static final IllegalStateException EXCEPTION = new IllegalStateException("boo");
private DispatcherHandler dispatcherHandler;
private MockServerHttpRequest request;
private MockServerHttpResponse response;
private ServerWebExchange exchange;
@@ -96,127 +87,101 @@ public class DispatcherHandlerErrorTests {
this.dispatcherHandler = new DispatcherHandler();
this.dispatcherHandler.setApplicationContext(appContext);
WebSessionManager sessionManager = new MockWebSessionManager();
this.request = new MockServerHttpRequest(HttpMethod.GET, new URI("/"));
this.response = new MockServerHttpResponse();
this.exchange = new DefaultServerWebExchange(this.request, this.response, sessionManager);
MockServerHttpResponse response = new MockServerHttpResponse();
MockWebSessionManager sessionManager = new MockWebSessionManager();
this.exchange = new DefaultServerWebExchange(this.request, response, sessionManager);
}
@Test
public void noHandler() throws Exception {
this.request.setUri(new URI("/does-not-exist"));
Mono<Void> publisher = this.dispatcherHandler.handle(this.exchange);
Throwable ex = awaitErrorSignal(publisher);
assertEquals(ResponseStatusException.class, ex.getClass());
assertEquals(HttpStatus.NOT_FOUND, ((ResponseStatusException) ex).getStatus());
TestSubscriber.subscribe(publisher)
.assertError(ResponseStatusException.class)
.assertErrorMessage("Request failure [status: 404, reason: \"No matching handler\"]");
}
@Test
public void noResolverForArgument() throws Exception {
public void unknownMethodArgumentType() throws Exception {
this.request.setUri(new URI("/unknown-argument-type"));
Mono<Void> publisher = this.dispatcherHandler.handle(this.exchange);
Throwable ex = awaitErrorSignal(publisher);
assertEquals(IllegalStateException.class, ex.getClass());
assertThat(ex.getMessage(), startsWith("No resolver for argument [0]"));
TestSubscriber.subscribe(publisher)
.assertError(IllegalStateException.class)
.assertErrorWith(ex -> assertThat(ex.getMessage(), startsWith("No resolver for argument [0]")));
}
@Test
public void controllerMethodError() throws Exception {
public void controllerReturnsMonoError() throws Exception {
this.request.setUri(new URI("/error-signal"));
Mono<Void> publisher = this.dispatcherHandler.handle(this.exchange);
Throwable ex = awaitErrorSignal(publisher);
assertSame(EXCEPTION, ex);
TestSubscriber.subscribe(publisher)
.assertErrorWith(ex -> assertSame(EXCEPTION, ex));
}
@Test
public void controllerMethodWithThrownException() throws Exception {
public void controllerThrowsException() throws Exception {
this.request.setUri(new URI("/raise-exception"));
Mono<Void> publisher = this.dispatcherHandler.handle(this.exchange);
Throwable ex = awaitErrorSignal(publisher);
assertSame(EXCEPTION, ex);
TestSubscriber.subscribe(publisher)
.assertErrorWith(ex -> assertSame(EXCEPTION, ex));
}
@Test
public void noHandlerResultHandler() throws Exception {
public void unknownReturnType() throws Exception {
this.request.setUri(new URI("/unknown-return-type"));
Mono<Void> publisher = this.dispatcherHandler.handle(this.exchange);
Throwable ex = awaitErrorSignal(publisher);
assertEquals(IllegalStateException.class, ex.getClass());
assertThat(ex.getMessage(), startsWith("No HandlerResultHandler"));
TestSubscriber.subscribe(publisher)
.assertError(IllegalStateException.class)
.assertErrorWith(ex -> assertThat(ex.getMessage(), startsWith("No HandlerResultHandler")));
}
@Test
public void notAcceptable() throws Exception {
public void responseBodyMessageConversionError() throws Exception {
DataBuffer dataBuffer = new DefaultDataBufferFactory().allocateBuffer();
this.request.setUri(new URI("/request-body"));
this.request.getHeaders().setAccept(Collections.singletonList(MediaType.APPLICATION_JSON));
DataBuffer buffer = new DefaultDataBufferFactory().allocateBuffer()
.write("body".getBytes("UTF-8"));
this.request.writeWith(Mono.just(buffer));
this.request.getHeaders().add("Accept", MediaType.APPLICATION_JSON_VALUE);
this.request.writeWith(Mono.just(dataBuffer.write("body".getBytes("UTF-8"))));
Mono<Void> publisher = this.dispatcherHandler.handle(this.exchange);
Throwable ex = awaitErrorSignal(publisher);
assertEquals(NotAcceptableStatusException.class, ex.getClass());
TestSubscriber.subscribe(publisher)
.assertError(NotAcceptableStatusException.class);
}
@Test
public void requestBodyError() throws Exception {
this.request.setUri(new URI("/request-body"));
this.request.writeWith(Mono.error(EXCEPTION));
Mono<Void> publisher = this.dispatcherHandler.handle(this.exchange);
Throwable ex = awaitErrorSignal(publisher);
ex.printStackTrace();
assertSame(EXCEPTION, ex);
TestSubscriber.subscribe(publisher)
.assertErrorWith(ex -> assertSame(EXCEPTION, ex));
}
@Test
public void dispatcherHandlerWithHttpExceptionHandler() throws Exception {
public void webExceptionHandler() throws Exception {
this.request.setUri(new URI("/unknown-argument-type"));
WebExceptionHandler exceptionHandler = new ServerError500ExceptionHandler();
WebHandler webHandler = new ExceptionHandlingWebHandler(this.dispatcherHandler, exceptionHandler);
Mono<Void> publisher = webHandler.handle(this.exchange);
publisher.block();
assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, this.response.getStatusCode());
}
TestSubscriber.subscribe(publisher)
.assertErrorWith(ex -> assertEquals(
HttpStatus.INTERNAL_SERVER_ERROR, this.exchange.getResponse().getStatusCode()));
@Test
public void filterChainWithHttpExceptionHandler() throws Exception {
this.request.setUri(new URI("/unknown-argument-type"));
WebHandler webHandler = new FilteringWebHandler(this.dispatcherHandler, new TestWebFilter());
webHandler = new ExceptionHandlingWebHandler(webHandler, new ServerError500ExceptionHandler());
Mono<Void> publisher = webHandler.handle(this.exchange);
publisher.block();
assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, this.response.getStatusCode());
}
private Throwable awaitErrorSignal(Mono<?> mono) throws Exception {
Signal<?> signal = mono.materialize().block();
assertEquals("Unexpected signal: " + signal, SignalKind.onError, signal.getType());
return signal.getThrowable();
}
@Configuration
@SuppressWarnings("unused")
@SuppressWarnings({"unused", "WeakerAccess"})
static class TestConfig {
@Bean
@@ -231,9 +196,9 @@ public class DispatcherHandlerErrorTests {
@Bean
public ResponseBodyResultHandler resultHandler() {
HttpMessageConverter<String> converter = new CodecHttpMessageConverter<>(new StringEncoder());
ConversionService conversionService = new DefaultConversionService();
return new ResponseBodyResultHandler(Collections.singletonList(converter), conversionService);
return new ResponseBodyResultHandler(
Collections.singletonList(new CodecHttpMessageConverter<>(new StringEncoder())),
new DefaultConversionService());
}
@Bean
@@ -285,12 +250,4 @@ public class DispatcherHandlerErrorTests {
}
}
private static class TestWebFilter implements WebFilter {
@Override
public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain) {
return chain.filter(exchange);
}
}
}

26
spring-web-reactive/src/test/java/org/springframework/web/reactive/ResponseStatusExceptionHandlerTests.java
View File

@@ -16,11 +16,12 @@
package org.springframework.web.reactive;
import java.net.URI;
import java.time.Duration;
import org.junit.Before;
import org.junit.Test;
import reactor.core.publisher.Mono;
import reactor.core.publisher.Signal;
import reactor.core.test.TestSubscriber;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
@@ -30,12 +31,9 @@ import org.springframework.web.server.ResponseStatusException;
import org.springframework.web.server.ServerWebExchange;
import org.springframework.web.server.adapter.DefaultServerWebExchange;
import org.springframework.web.server.session.MockWebSessionManager;
import org.springframework.web.server.session.WebSessionManager;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
/**
* Unit tests for {@link ResponseStatusExceptionHandler}.
@@ -54,31 +52,29 @@ public class ResponseStatusExceptionHandlerTests {
@Before
public void setUp() throws Exception {
this.handler = new ResponseStatusExceptionHandler();
MockServerHttpRequest request = new MockServerHttpRequest(HttpMethod.GET, new URI("/path"));
WebSessionManager sessionManager = new MockWebSessionManager();
this.response = new MockServerHttpResponse();
this.exchange = new DefaultServerWebExchange(request, this.response, sessionManager);
this.exchange = new DefaultServerWebExchange(
new MockServerHttpRequest(HttpMethod.GET, new URI("/path")),
this.response,
new MockWebSessionManager());
}
@Test
public void handleException() throws Exception {
Throwable ex = new ResponseStatusException(HttpStatus.BAD_REQUEST, "");
Mono<Void> publisher = this.handler.handle(this.exchange, ex);
this.handler.handle(this.exchange, ex).block(Duration.ofSeconds(5));
publisher.block();
assertEquals(HttpStatus.BAD_REQUEST, this.response.getStatusCode());
}
@Test
public void unresolvedException() throws Exception {
Throwable ex = new IllegalStateException();
Mono<Void> publisher = this.handler.handle(this.exchange, ex);
Throwable expected = new IllegalStateException();
Mono<Void> mono = this.handler.handle(this.exchange, expected);
Signal<Void> signal = publisher.materialize().block();
assertNotNull(signal);
assertTrue(signal.hasError());
assertSame(ex, signal.getThrowable());
TestSubscriber.subscribe(mono)
.assertErrorWith(actual -> assertSame(expected, actual));
}
}

114
spring-web-reactive/src/test/java/org/springframework/web/reactive/result/WebHandlerIntegrationTests.java → spring-web-reactive/src/test/java/org/springframework/web/reactive/result/SimpleUrlHandlerMappingIntegrationTests.java
View File

@@ -17,7 +17,6 @@
package org.springframework.web.reactive.result;
import java.net.URI;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;
@@ -31,6 +30,7 @@ import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.convert.support.DefaultConversionService;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.core.io.buffer.DefaultDataBuffer;
import org.springframework.core.io.buffer.DefaultDataBufferFactory;
import org.springframework.http.HttpStatus;
import org.springframework.http.RequestEntity;
@@ -42,27 +42,22 @@ import org.springframework.web.client.RestTemplate;
import org.springframework.web.reactive.DispatcherHandler;
import org.springframework.web.reactive.ResponseStatusExceptionHandler;
import org.springframework.web.reactive.handler.SimpleUrlHandlerMapping;
import org.springframework.web.server.ServerWebExchange;
import org.springframework.web.server.WebHandler;
import org.springframework.web.server.adapter.WebHttpHandlerBuilder;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
/**
* Integration tests with requests mapped to plain {@link WebHandler}s.
* Integration tests with requests mapped via
* {@link SimpleUrlHandlerMapping} to plain {@link WebHandler}s.
*
* @author Rossen Stoyanchev
*/
public class WebHandlerIntegrationTests extends AbstractHttpHandlerIntegrationTests {
private static final Charset UTF_8 = Charset.forName("UTF-8");
public class SimpleUrlHandlerMappingIntegrationTests extends AbstractHttpHandlerIntegrationTests {
@Override
protected HttpHandler createHttpHandler() {
AnnotationConfigApplicationContext wac = new AnnotationConfigApplicationContext();
wac.register(WebConfig.class);
wac.refresh();
@@ -76,109 +71,73 @@ public class WebHandlerIntegrationTests extends AbstractHttpHandlerIntegrationTe
}
@Test
public void testFooHandler() throws Exception {
RestTemplate restTemplate = new RestTemplate();
URI url = new URI("http://localhost:" + port + "/foo");
public void testRequestToFooHandler() throws Exception {
URI url = new URI("http://localhost:" + this.port + "/foo");
RequestEntity<Void> request = RequestEntity.get(url).build();
ResponseEntity<byte[]> response = restTemplate.exchange(request, byte[].class);
ResponseEntity<byte[]> response = new RestTemplate().exchange(request, byte[].class);
assertEquals(HttpStatus.OK, response.getStatusCode());
assertArrayEquals("foo".getBytes(UTF_8), response.getBody());
assertArrayEquals("foo".getBytes("UTF-8"), response.getBody());
}
@Test
public void testBarHandler() throws Exception {
RestTemplate restTemplate = new RestTemplate();
URI url = new URI("http://localhost:" + port + "/bar");
public void testRequestToBarHandler() throws Exception {
URI url = new URI("http://localhost:" + this.port + "/bar");
RequestEntity<Void> request = RequestEntity.get(url).build();
ResponseEntity<byte[]> response = restTemplate.exchange(request, byte[].class);
ResponseEntity<byte[]> response = new RestTemplate().exchange(request, byte[].class);
assertEquals(HttpStatus.OK, response.getStatusCode());
assertArrayEquals("bar".getBytes(UTF_8), response.getBody());
assertArrayEquals("bar".getBytes("UTF-8"), response.getBody());
}
@Test
public void testHeaderSettingHandler() throws Exception {
RestTemplate restTemplate = new RestTemplate();
URI url = new URI("http://localhost:" + port + "/header");
public void testRequestToHeaderSettingHandler() throws Exception {
URI url = new URI("http://localhost:" + this.port + "/header");
RequestEntity<Void> request = RequestEntity.get(url).build();
ResponseEntity<byte[]> response = restTemplate.exchange(request, byte[].class);
ResponseEntity<byte[]> response = new RestTemplate().exchange(request, byte[].class);
assertEquals(HttpStatus.OK, response.getStatusCode());
assertEquals("bar", response.getHeaders().getFirst("foo"));
}
@Test
public void testNotFound() throws Exception {
RestTemplate restTemplate = new RestTemplate();
URI url = new URI("http://localhost:" + port + "/oops");
public void testHandlerNotFound() throws Exception {
URI url = new URI("http://localhost:" + this.port + "/oops");
RequestEntity<Void> request = RequestEntity.get(url).build();
try {
restTemplate.exchange(request, byte[].class);
new RestTemplate().exchange(request, byte[].class);
}
catch (HttpClientErrorException ex) {
assertEquals(HttpStatus.NOT_FOUND, ex.getStatusCode());
}
}
private static class TestSimpleUrlHandlerMapping extends SimpleUrlHandlerMapping {
public TestSimpleUrlHandlerMapping() {
Map<String, Object> map = new HashMap<>();
map.put("/foo", new FooHandler());
map.put("/bar", new BarHandler());
map.put("/header", new HeaderSettingHandler());
setUrlMap(map);
}
}
private static DataBuffer asDataBuffer(String text) {
return new DefaultDataBufferFactory().allocateBuffer()
.write(text.getBytes(StandardCharsets.UTF_8));
DefaultDataBuffer buffer = new DefaultDataBufferFactory().allocateBuffer();
return buffer.write(text.getBytes(StandardCharsets.UTF_8));
}
private static class FooHandler implements WebHandler {
@Override
public Mono<Void> handle(ServerWebExchange exchange) {
DataBuffer buffer = asDataBuffer("foo");
return exchange.getResponse().writeWith(Flux.just(buffer));
}
}
private static class BarHandler implements WebHandler {
@Override
public Mono<Void> handle(ServerWebExchange exchange) {
DataBuffer buffer = asDataBuffer("bar");
return exchange.getResponse().writeWith(Flux.just(buffer));
}
}
private static class HeaderSettingHandler implements WebHandler {
@Override
public Mono<Void> handle(ServerWebExchange exchange) {
exchange.getResponse().getHeaders().add("foo", "bar");
return Mono.empty();
}
}
@Configuration
@SuppressWarnings({"unused", "WeakerAccess"})
static class WebConfig {
@Bean
public TestSimpleUrlHandlerMapping handlerMapping() {
return new TestSimpleUrlHandlerMapping();
public SimpleUrlHandlerMapping handlerMapping() {
return new SimpleUrlHandlerMapping() {
{
Map<String, Object> map = new HashMap<>();
map.put("/foo", (WebHandler) exchange ->
exchange.getResponse().writeWith(Flux.just(asDataBuffer("foo"))));
map.put("/bar", (WebHandler) exchange ->
exchange.getResponse().writeWith(Flux.just(asDataBuffer("bar"))));
map.put("/header", (WebHandler) exchange -> {
exchange.getResponse().getHeaders().add("foo", "bar");
return Mono.empty();
});
setUrlMap(map);
}
};
}
@Bean
@@ -190,7 +149,6 @@ public class WebHandlerIntegrationTests extends AbstractHttpHandlerIntegrationTe
public SimpleResultHandler resultHandler() {
return new SimpleResultHandler(new DefaultConversionService());
}
}
}