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

Support async wrappers for ResponseEntity

Browse Source 
Before this commit only ResponseEntity with async body was supported,
e.g. ResponseEntity<Mono<String>>

This commit also adds suppport for an asyn wrapper around,
e.g. Mono<ResponseEntity<String>.
This commit is contained in:
Rossen Stoyanchev
2016-06-24 17:17:17 -04:00
parent 49bb83c0ec
commit 95751acb33
2 changed files with 97 additions and 23 deletions
Download Patch File Download Diff File Expand all files Collapse all files

77
spring-web-reactive/src/test/java/org/springframework/web/reactive/result/method/annotation/ResponseEntityResultHandlerTests.java
View File

@@ -16,23 +16,28 @@
package org.springframework.web.reactive.result.method.annotation;
import java.net.URI;
import java.nio.charset.Charset;
import java.time.Duration;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import org.junit.Before;
import org.junit.Test;
import reactor.core.publisher.Mono;
import reactor.core.test.TestSubscriber;
import rx.Single;
import org.springframework.core.ResolvableType;
import org.springframework.core.codec.support.ByteBufferEncoder;
import org.springframework.core.codec.support.JacksonJsonEncoder;
import org.springframework.core.codec.support.Jaxb2Encoder;
import org.springframework.core.codec.support.StringEncoder;
import org.springframework.core.convert.support.DefaultConversionService;
import org.springframework.core.convert.support.GenericConversionService;
import org.springframework.core.convert.support.ReactiveStreamsToCompletableFutureConverter;
import org.springframework.core.convert.support.ReactiveStreamsToRxJava1Converter;
import org.springframework.core.io.buffer.support.DataBufferTestUtils;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
@@ -57,6 +62,7 @@ import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
import static org.springframework.core.ResolvableType.forClassWithGenerics;
/**
* Unit tests for {@link ResponseEntityResultHandler}. When adding a test also
@@ -104,22 +110,29 @@ public class ResponseEntityResultHandlerTests {
service.addConverter(new ReactiveStreamsToRxJava1Converter());
RequestedContentTypeResolver resolver = new RequestedContentTypeResolverBuilder().build();
return new ResponseEntityResultHandler(converterList, new DefaultConversionService(), resolver);
return new ResponseEntityResultHandler(converterList, service, resolver);
}
@Test
@Test @SuppressWarnings("ConstantConditions")
public void supports() throws NoSuchMethodException {
ModelMap model = new ExtendedModelMap();
ResolvableType type = ResolvableType.forClassWithGenerics(ResponseEntity.class, String.class);
assertTrue(this.resultHandler.supports(new HandlerResult(HANDLER, null, type, model)));
Object value = null;
ResolvableType type = responseEntityType(String.class);
assertTrue(this.resultHandler.supports(new HandlerResult(HANDLER, value, type, model)));
type = ResolvableType.forClassWithGenerics(ResponseEntity.class, Void.class);
assertTrue(this.resultHandler.supports(new HandlerResult(HANDLER, null, type, model)));
type = forClassWithGenerics(Mono.class, responseEntityType(String.class));
assertTrue(this.resultHandler.supports(new HandlerResult(HANDLER, value, type, model)));
type = ResolvableType.forClass(Void.class);
assertFalse(this.resultHandler.supports(new HandlerResult(HANDLER, null, type, model)));
type = forClassWithGenerics(Single.class, responseEntityType(String.class));
assertTrue(this.resultHandler.supports(new HandlerResult(HANDLER, value, type, model)));
type = forClassWithGenerics(CompletableFuture.class, responseEntityType(String.class));
assertTrue(this.resultHandler.supports(new HandlerResult(HANDLER, value, type, model)));
type = ResolvableType.forClass(String.class);
assertFalse(this.resultHandler.supports(new HandlerResult(HANDLER, value, type, model)));
}
@Test
@@ -129,7 +142,7 @@ public class ResponseEntityResultHandlerTests {
@Test
public void statusCode() throws Exception {
ResolvableType type = ResolvableType.forClassWithGenerics(ResponseEntity.class, Void.class);
ResolvableType type = responseEntityType(Void.class);
HandlerResult result = new HandlerResult(HANDLER, ResponseEntity.noContent().build(), type);
this.resultHandler.handleResult(exchange, result).block(Duration.ofSeconds(5));
@@ -141,9 +154,9 @@ public class ResponseEntityResultHandlerTests {
@Test
public void headers() throws Exception {
URI location = new URI("/path");
ResolvableType type = ResolvableType.forClassWithGenerics(ResponseEntity.class, Void.class);
ResolvableType type = responseEntityType(Void.class);
HandlerResult result = new HandlerResult(HANDLER, ResponseEntity.created(location).build(), type);
this.resultHandler.handleResult(exchange, result).block(Duration.ofSeconds(5));
this.resultHandler.handleResult(this.exchange, result).block(Duration.ofSeconds(5));
assertEquals(HttpStatus.CREATED, this.response.getStatus());
assertEquals(1, this.response.getHeaders().size());
@@ -151,4 +164,44 @@ public class ResponseEntityResultHandlerTests {
assertNull(this.response.getBody());
}
@Test
public void handleReturnTypes() throws Exception {
Object returnValue = ResponseEntity.ok("abc");
ResolvableType returnType = responseEntityType(String.class);
testHandle(returnValue, returnType);
returnValue = Mono.just(ResponseEntity.ok("abc"));
returnType = forClassWithGenerics(Mono.class, responseEntityType(String.class));
testHandle(returnValue, returnType);
returnValue = Mono.just(ResponseEntity.ok("abc"));
returnType = forClassWithGenerics(Single.class, responseEntityType(String.class));
testHandle(returnValue, returnType);
returnValue = Mono.just(ResponseEntity.ok("abc"));
returnType = forClassWithGenerics(CompletableFuture.class, responseEntityType(String.class));
testHandle(returnValue, returnType);
}
private void testHandle(Object returnValue, ResolvableType returnType) {
HandlerResult result = new HandlerResult(HANDLER, returnValue, returnType);
this.resultHandler.handleResult(this.exchange, result).block(Duration.ofSeconds(5));
assertEquals(HttpStatus.OK, this.response.getStatus());
assertEquals("text/plain;charset=UTF-8", this.response.getHeaders().getFirst("Content-Type"));
assertResponseBody("abc");
}
private ResolvableType responseEntityType(Class<?> bodyType) {
return forClassWithGenerics(ResponseEntity.class, bodyType);
}
private void assertResponseBody(String responseBody) {
TestSubscriber.subscribe(this.response.getBody())
.assertValuesWith(buf -> assertEquals(responseBody,
DataBufferTestUtils.dumpString(buf, Charset.forName("UTF-8"))));
}
}