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

Improved generics support in ResolvableMethod

Browse Source
This commit is contained in:
Rossen Stoyanchev
2017-03-05 18:10:45 -05:00
parent c5351fdbef
commit 0296d003af
8 changed files with 234 additions and 217 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -59,11 +59,10 @@ import org.springframework.web.server.adapter.DefaultServerWebExchange;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.springframework.core.ResolvableType.forClassWithGenerics;
import static org.springframework.http.MediaType.APPLICATION_JSON;
import static org.springframework.http.MediaType.APPLICATION_JSON_UTF8;
import static org.springframework.web.reactive.HandlerMapping.PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE;
import static org.springframework.web.method.ResolvableMethod.on;
import static org.springframework.web.reactive.HandlerMapping.PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE;
/**
* Unit tests for {@link AbstractMessageWriterResultHandler}.
@@ -110,27 +109,19 @@ public class MessageWriterResultHandlerTests {
@Test
public void voidReturnType() throws Exception {
testVoid(null, on(TestController.class).resolveReturnType(void.class));
testVoid(Mono.empty(), on(TestController.class).resolveReturnType(Mono.class, Void.class));
testVoid(Flux.empty(), on(TestController.class).resolveReturnType(Flux.class, Void.class));
testVoid(Completable.complete(), on(TestController.class).resolveReturnType(Completable.class));
testVoid(Observable.empty(), on(TestController.class).resolveReturnType(Observable.class, Void.class));
testVoid(Mono.empty(), on(TestController.class)
.resolveReturnType(forClassWithGenerics(Mono.class, Void.class)));
MethodParameter type = on(TestController.class).resolveReturnType(io.reactivex.Completable.class);
testVoid(io.reactivex.Completable.complete(), type);
testVoid(Flux.empty(), on(TestController.class)
.resolveReturnType(forClassWithGenerics(Flux.class, Void.class)));
type = on(TestController.class).resolveReturnType(io.reactivex.Observable.class, Void.class);
testVoid(io.reactivex.Observable.empty(), type);
testVoid(Completable.complete(), on(TestController.class)
.resolveReturnType(Completable.class));
testVoid(Observable.empty(), on(TestController.class)
.resolveReturnType(forClassWithGenerics(Observable.class, Void.class)));
testVoid(io.reactivex.Completable.complete(), on(TestController.class)
.resolveReturnType(io.reactivex.Completable.class));
testVoid(io.reactivex.Observable.empty(), on(TestController.class)
.resolveReturnType(forClassWithGenerics(io.reactivex.Observable.class, Void.class)));
testVoid(Flowable.empty(), on(TestController.class)
.resolveReturnType(forClassWithGenerics(Flowable.class, Void.class)));
type = on(TestController.class).resolveReturnType(Flowable.class, Void.class);
testVoid(Flowable.empty(), type);
}
private void testVoid(Object body, MethodParameter returnType) {
@@ -155,9 +146,7 @@ public class MessageWriterResultHandlerTests {
@Test // SPR-12811
public void jacksonTypeOfListElement() throws Exception {
MethodParameter returnType = on(TestController.class)
.resolveReturnType(forClassWithGenerics(List.class, ParentClass.class));
MethodParameter returnType = on(TestController.class).resolveReturnType(List.class, ParentClass.class);
List<ParentClass> body = Arrays.asList(new Foo("foo"), new Bar("bar"));
this.resultHandler.writeBody(body, returnType, this.exchange).block(Duration.ofSeconds(5));
@@ -179,8 +168,7 @@ public class MessageWriterResultHandlerTests {
@Test // SPR-13318
public void jacksonTypeWithSubTypeOfListElement() throws Exception {
MethodParameter returnType = on(TestController.class)
.resolveReturnType(forClassWithGenerics(List.class, Identifiable.class));
MethodParameter returnType = on(TestController.class).resolveReturnType(List.class, Identifiable.class);
List<SimpleBean> body = Arrays.asList(new SimpleBean(123L, "foo"), new SimpleBean(456L, "bar"));
this.resultHandler.writeBody(body, returnType, this.exchange).block(Duration.ofSeconds(5));

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

@@ -38,13 +38,16 @@ import org.springframework.validation.beanvalidation.LocalValidatorFactoryBean;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.support.ConfigurableWebBindingInitializer;
import org.springframework.web.bind.support.WebExchangeBindException;
import org.springframework.web.reactive.BindingContext;
import org.springframework.web.method.ResolvableMethod;
import org.springframework.web.reactive.BindingContext;
import org.springframework.web.server.ServerWebExchange;
import org.springframework.web.server.adapter.DefaultServerWebExchange;
import static org.junit.Assert.*;
import static org.springframework.core.ResolvableType.*;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
/**
* Unit tests for {@link ModelAttributeMethodArgumentResolver}.
@@ -76,13 +79,13 @@ public class ModelAttributeMethodArgumentResolverTests {
MethodParameter param = this.testMethod.annotated(ModelAttribute.class).arg(Foo.class);
assertTrue(resolver.supportsParameter(param));
param = this.testMethod.annotated(ModelAttribute.class).arg(forClassWithGenerics(Mono.class, Foo.class));
param = this.testMethod.annotated(ModelAttribute.class).arg(Mono.class, Foo.class);
assertTrue(resolver.supportsParameter(param));
param = this.testMethod.notAnnotated(ModelAttribute.class).arg(Foo.class);
assertFalse(resolver.supportsParameter(param));
param = this.testMethod.notAnnotated(ModelAttribute.class).arg(forClassWithGenerics(Mono.class, Foo.class));
param = this.testMethod.notAnnotated(ModelAttribute.class).arg(Mono.class, Foo.class);
assertFalse(resolver.supportsParameter(param));
}
@@ -94,13 +97,13 @@ public class ModelAttributeMethodArgumentResolverTests {
MethodParameter param = this.testMethod.notAnnotated(ModelAttribute.class).arg(Foo.class);
assertTrue(resolver.supportsParameter(param));
param = this.testMethod.notAnnotated(ModelAttribute.class).arg(forClassWithGenerics(Mono.class, Foo.class));
param = this.testMethod.notAnnotated(ModelAttribute.class).arg(Mono.class, Foo.class);
assertTrue(resolver.supportsParameter(param));
param = this.testMethod.notAnnotated(ModelAttribute.class).arg(String.class);
assertFalse(resolver.supportsParameter(param));
param = this.testMethod.notAnnotated(ModelAttribute.class).arg(forClassWithGenerics(Mono.class, String.class));
param = this.testMethod.notAnnotated(ModelAttribute.class).arg(Mono.class, String.class);
assertFalse(resolver.supportsParameter(param));
}
@@ -115,8 +118,8 @@ public class ModelAttributeMethodArgumentResolverTests {
@Test
public void createAndBindToMono() throws Exception {
MethodParameter parameter = this.testMethod.notAnnotated(ModelAttribute.class)
.arg(forClassWithGenerics(Mono.class, Foo.class));
MethodParameter parameter = this.testMethod
.notAnnotated(ModelAttribute.class).arg(Mono.class, Foo.class);
testBindFoo(parameter, mono -> {
assertTrue(mono.getClass().getName(), mono instanceof Mono);
@@ -129,8 +132,8 @@ public class ModelAttributeMethodArgumentResolverTests {
@Test
public void createAndBindToSingle() throws Exception {
MethodParameter parameter = this.testMethod.annotated(ModelAttribute.class)
.arg(forClassWithGenerics(Single.class, Foo.class));
MethodParameter parameter = this.testMethod
.annotated(ModelAttribute.class).arg(Single.class, Foo.class);
testBindFoo(parameter, single -> {
assertTrue(single.getClass().getName(), single instanceof Single);
@@ -191,8 +194,8 @@ public class ModelAttributeMethodArgumentResolverTests {
foo.setName("Jim");
this.bindContext.getModel().addAttribute("foo", Mono.just(foo));
MethodParameter parameter = this.testMethod.notAnnotated(ModelAttribute.class)
.arg(forClassWithGenerics(Mono.class, Foo.class));
MethodParameter parameter = this.testMethod
.notAnnotated(ModelAttribute.class).arg(Mono.class, Foo.class);
testBindFoo(parameter, mono -> {
assertTrue(mono.getClass().getName(), mono instanceof Mono);
@@ -230,8 +233,8 @@ public class ModelAttributeMethodArgumentResolverTests {
@SuppressWarnings("unchecked")
public void validationErrorToMono() throws Exception {
MethodParameter parameter = this.testMethod.notAnnotated(ModelAttribute.class)
.arg(forClassWithGenerics(Mono.class, Foo.class));
MethodParameter parameter = this.testMethod
.notAnnotated(ModelAttribute.class).arg(Mono.class, Foo.class);
testValidationError(parameter,
resolvedArgumentMono -> {
@@ -246,8 +249,8 @@ public class ModelAttributeMethodArgumentResolverTests {
@SuppressWarnings("unchecked")
public void validationErrorToSingle() throws Exception {
MethodParameter parameter = this.testMethod.annotated(ModelAttribute.class)
.arg(forClassWithGenerics(Single.class, Foo.class));
MethodParameter parameter = this.testMethod
.annotated(ModelAttribute.class).arg(Single.class, Foo.class);
testValidationError(parameter,
resolvedArgumentMono -> {

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

@@ -33,15 +33,14 @@ import rx.RxReactiveStreams;
import rx.Single;
import org.springframework.core.MethodParameter;
import org.springframework.core.ResolvableType;
import org.springframework.core.codec.StringDecoder;
import org.springframework.http.codec.DecoderHttpMessageReader;
import org.springframework.http.codec.HttpMessageReader;
import org.springframework.mock.http.server.reactive.test.MockServerHttpRequest;
import org.springframework.mock.http.server.reactive.test.MockServerHttpResponse;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.reactive.BindingContext;
import org.springframework.web.method.ResolvableMethod;
import org.springframework.web.reactive.BindingContext;
import org.springframework.web.server.ServerWebExchange;
import org.springframework.web.server.ServerWebInputException;
import org.springframework.web.server.adapter.DefaultServerWebExchange;
@@ -51,7 +50,6 @@ import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.springframework.core.ResolvableType.forClassWithGenerics;
/**
* Unit tests for {@link RequestBodyArgumentResolver}. When adding a test also
@@ -77,13 +75,13 @@ public class RequestBodyArgumentResolverTests {
@Test
public void supports() throws Exception {
MethodParameter param;
ResolvableType type = forClassWithGenerics(Mono.class, String.class);
assertTrue(this.resolver.supportsParameter(
this.testMethod.annotated(RequestBody.class, required()).arg(type)));
param = this.testMethod.annotated(RequestBody.class, required()).arg(Mono.class, String.class);
assertTrue(this.resolver.supportsParameter(param));
MethodParameter parameter = this.testMethod.notAnnotated(RequestBody.class).arg(String.class);
assertFalse(this.resolver.supportsParameter(parameter));
param = this.testMethod.notAnnotated(RequestBody.class).arg(String.class);
assertFalse(this.resolver.supportsParameter(param));
}
@Test
@@ -112,15 +110,15 @@ public class RequestBodyArgumentResolverTests {
@Test
@SuppressWarnings("unchecked")
public void emptyBodyWithMono() throws Exception {
ResolvableType type = forClassWithGenerics(Mono.class, String.class);
MethodParameter param;
MethodParameter param = this.testMethod.annotated(RequestBody.class, required()).arg(type);
param = this.testMethod.annotated(RequestBody.class, required()).arg(Mono.class, String.class);
StepVerifier.create((Mono<Void>) resolveValueWithEmptyBody(param))
.expectNextCount(0)
.expectError(ServerWebInputException.class)
.verify();
param = this.testMethod.annotated(RequestBody.class, notRequired()).arg(type);
param = this.testMethod.annotated(RequestBody.class, notRequired()).arg(Mono.class, String.class);
StepVerifier.create((Mono<Void>) resolveValueWithEmptyBody(param))
.expectNextCount(0)
.expectComplete()
@@ -130,15 +128,15 @@ public class RequestBodyArgumentResolverTests {
@Test
@SuppressWarnings("unchecked")
public void emptyBodyWithFlux() throws Exception {
ResolvableType type = forClassWithGenerics(Flux.class, String.class);
MethodParameter param;
MethodParameter param = this.testMethod.annotated(RequestBody.class, required()).arg(type);
param = this.testMethod.annotated(RequestBody.class, required()).arg(Flux.class, String.class);
StepVerifier.create((Flux<Void>) resolveValueWithEmptyBody(param))
.expectNextCount(0)
.expectError(ServerWebInputException.class)
.verify();
param = this.testMethod.annotated(RequestBody.class, notRequired()).arg(type);
param = this.testMethod.annotated(RequestBody.class, notRequired()).arg(Flux.class, String.class);
StepVerifier.create((Flux<Void>) resolveValueWithEmptyBody(param))
.expectNextCount(0)
.expectComplete()
@@ -147,16 +145,16 @@ public class RequestBodyArgumentResolverTests {
@Test
public void emptyBodyWithSingle() throws Exception {
ResolvableType type = forClassWithGenerics(Single.class, String.class);
MethodParameter param;
MethodParameter param = this.testMethod.annotated(RequestBody.class, required()).arg(type);
param = this.testMethod.annotated(RequestBody.class, required()).arg(Single.class, String.class);
Single<String> single = resolveValueWithEmptyBody(param);
StepVerifier.create(RxReactiveStreams.toPublisher(single))
.expectNextCount(0)
.expectError(ServerWebInputException.class)
.verify();
param = this.testMethod.annotated(RequestBody.class, notRequired()).arg(type);
param = this.testMethod.annotated(RequestBody.class, notRequired()).arg(Single.class, String.class);
single = resolveValueWithEmptyBody(param);
StepVerifier.create(RxReactiveStreams.toPublisher(single))
.expectNextCount(0)
@@ -166,16 +164,16 @@ public class RequestBodyArgumentResolverTests {
@Test
public void emptyBodyWithMaybe() throws Exception {
ResolvableType type = forClassWithGenerics(Maybe.class, String.class);
MethodParameter param;
MethodParameter param = this.testMethod.annotated(RequestBody.class, required()).arg(type);
param = this.testMethod.annotated(RequestBody.class, required()).arg(Maybe.class, String.class);
Maybe<String> maybe = resolveValueWithEmptyBody(param);
StepVerifier.create(maybe.toFlowable())
.expectNextCount(0)
.expectError(ServerWebInputException.class)
.verify();
param = this.testMethod.annotated(RequestBody.class, notRequired()).arg(type);
param = this.testMethod.annotated(RequestBody.class, notRequired()).arg(Maybe.class, String.class);
maybe = resolveValueWithEmptyBody(param);
StepVerifier.create(maybe.toFlowable())
.expectNextCount(0)
@@ -185,16 +183,19 @@ public class RequestBodyArgumentResolverTests {
@Test
public void emptyBodyWithObservable() throws Exception {
ResolvableType type = forClassWithGenerics(Observable.class, String.class);
MethodParameter param = this.testMethod.annotated(RequestBody.class, required()).arg(type);
MethodParameter param = this.testMethod
.annotated(RequestBody.class, required()).arg(Observable.class, String.class);
Observable<String> observable = resolveValueWithEmptyBody(param);
StepVerifier.create(RxReactiveStreams.toPublisher(observable))
.expectNextCount(0)
.expectError(ServerWebInputException.class)
.verify();
param = this.testMethod.annotated(RequestBody.class, notRequired()).arg(type);
param = this.testMethod
.annotated(RequestBody.class, notRequired()).arg(Observable.class, String.class);
observable = resolveValueWithEmptyBody(param);
StepVerifier.create(RxReactiveStreams.toPublisher(observable))
.expectNextCount(0)
@@ -204,16 +205,19 @@ public class RequestBodyArgumentResolverTests {
@Test
public void emptyBodyWithCompletableFuture() throws Exception {
ResolvableType type = forClassWithGenerics(CompletableFuture.class, String.class);
MethodParameter param = this.testMethod.annotated(RequestBody.class, required()).arg(type);
MethodParameter param = this.testMethod
.annotated(RequestBody.class, required()).arg(CompletableFuture.class, String.class);
CompletableFuture<String> future = resolveValueWithEmptyBody(param);
future.whenComplete((text, ex) -> {
assertNull(text);
assertNotNull(ex);
});
param = this.testMethod.annotated(RequestBody.class, notRequired()).arg(type);
param = this.testMethod
.annotated(RequestBody.class, notRequired()).arg(CompletableFuture.class, String.class);
future = resolveValueWithEmptyBody(param);
future.whenComplete((text, ex) -> {
assertNotNull(text);

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

@@ -26,7 +26,6 @@ import org.junit.Test;
import reactor.core.publisher.Mono;
import reactor.test.StepVerifier;
import org.springframework.core.LocalVariableTableParameterNameDiscoverer;
import org.springframework.core.MethodParameter;
import org.springframework.format.support.DefaultFormattingConversionService;
import org.springframework.http.MediaType;
@@ -145,7 +144,6 @@ public class RequestParamMethodArgumentResolverTests {
public void resolveSimpleTypeParam() throws Exception {
ServerWebExchange exchange = exchangeWithQuery("stringNotAnnot=plainValue");
MethodParameter param = this.testMethod.notAnnotated(RequestParam.class).arg(String.class);
param.initParameterNameDiscovery(new LocalVariableTableParameterNameDiscoverer());
Object result = resolve(param, exchange);
assertEquals("plainValue", result);
}
@@ -153,7 +151,6 @@ public class RequestParamMethodArgumentResolverTests {
@Test // SPR-8561
public void resolveSimpleTypeParamToNull() throws Exception {
MethodParameter param = this.testMethod.notAnnotated(RequestParam.class).arg(String.class);
param.initParameterNameDiscovery(new LocalVariableTableParameterNameDiscoverer());
assertNull(resolve(param, exchange()));
}
@@ -168,7 +165,6 @@ public class RequestParamMethodArgumentResolverTests {
@Test
public void resolveEmptyValueWithoutDefault() throws Exception {
MethodParameter param = this.testMethod.notAnnotated(RequestParam.class).arg(String.class);
param.initParameterNameDiscovery(new LocalVariableTableParameterNameDiscoverer());
assertEquals("", resolve(param, exchangeWithQuery("stringNotAnnot=")));
}

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

@@ -61,7 +61,6 @@ import org.springframework.web.server.adapter.DefaultServerWebExchange;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.springframework.core.ResolvableType.forClass;
import static org.springframework.core.ResolvableType.forClassWithGenerics;
import static org.springframework.http.ResponseEntity.notFound;
import static org.springframework.http.ResponseEntity.ok;
@@ -124,13 +123,13 @@ public class ResponseEntityResultHandlerTests {
MethodParameter returnType = on(TestController.class).resolveReturnType(entity(String.class));
assertTrue(this.resultHandler.supports(handlerResult(value, returnType)));
returnType = on(TestController.class).resolveReturnType(asyncEntity(Mono.class, String.class));
returnType = on(TestController.class).resolveReturnType(Mono.class, entity(String.class));
assertTrue(this.resultHandler.supports(handlerResult(value, returnType)));
returnType = on(TestController.class).resolveReturnType(asyncEntity(Single.class, String.class));
returnType = on(TestController.class).resolveReturnType(Single.class, entity(String.class));
assertTrue(this.resultHandler.supports(handlerResult(value, returnType)));
returnType = on(TestController.class).resolveReturnType(asyncEntity(CompletableFuture.class, String.class));
returnType = on(TestController.class).resolveReturnType(CompletableFuture.class, entity(String.class));
assertTrue(this.resultHandler.supports(handlerResult(value, returnType)));
}
@@ -140,10 +139,10 @@ public class ResponseEntityResultHandlerTests {
Object value = null;
MethodParameter returnType = on(TestController.class).resolveReturnType(forClass(String.class));
MethodParameter returnType = on(TestController.class).resolveReturnType(String.class);
assertFalse(this.resultHandler.supports(handlerResult(value, returnType)));
returnType = on(TestController.class).resolveReturnType(forClass(Completable.class));
returnType = on(TestController.class).resolveReturnType(Completable.class);
assertFalse(this.resultHandler.supports(handlerResult(value, returnType)));
}
@@ -181,7 +180,7 @@ public class ResponseEntityResultHandlerTests {
@Test
public void handleResponseEntityWithNullBody() throws Exception {
Object returnValue = Mono.just(notFound().build());
MethodParameter type = on(TestController.class).resolveReturnType(asyncEntity(Mono.class, String.class));
MethodParameter type = on(TestController.class).resolveReturnType(Mono.class, entity(String.class));
HandlerResult result = handlerResult(returnValue, type);
this.resultHandler.handleResult(createExchange(), result).block(Duration.ofSeconds(5));
@@ -196,15 +195,15 @@ public class ResponseEntityResultHandlerTests {
testHandle(returnValue, returnType);
returnValue = Mono.just(ok("abc"));
returnType = on(TestController.class).resolveReturnType(asyncEntity(Mono.class, String.class));
returnType = on(TestController.class).resolveReturnType(Mono.class, entity(String.class));
testHandle(returnValue, returnType);
returnValue = Mono.just(ok("abc"));
returnType = on(TestController.class).resolveReturnType(asyncEntity(Single.class, String.class));
returnType = on(TestController.class).resolveReturnType(Single.class, entity(String.class));
testHandle(returnValue, returnType);
returnValue = Mono.just(ok("abc"));
returnType = on(TestController.class).resolveReturnType(asyncEntity(CompletableFuture.class, String.class));
returnType = on(TestController.class).resolveReturnType(CompletableFuture.class, entity(String.class));
testHandle(returnValue, returnType);
}
@@ -296,8 +295,8 @@ public class ResponseEntityResultHandlerTests {
exchange.getAttributes().put(HandlerMapping.PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE,
Collections.singleton(MediaType.APPLICATION_JSON));
HandlerResult result = new HandlerResult(new TestController(), Mono.just(ok().body("body")),
on(TestController.class).resolveReturnType(forClassWithGenerics(Mono.class, ResponseEntity.class)));
MethodParameter type = on(TestController.class).resolveReturnType(Mono.class, ResponseEntity.class);
HandlerResult result = new HandlerResult(new TestController(), Mono.just(ok().body("body")), type);
this.resultHandler.handleResult(exchange, result).block(Duration.ofSeconds(5));
@@ -312,8 +311,7 @@ public class ResponseEntityResultHandlerTests {
exchange.getAttributes().put(HandlerMapping.PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE,
Collections.singleton(MediaType.APPLICATION_JSON));
MethodParameter returnType = on(TestController.class).resolveReturnType(forClassWithGenerics(Mono.class, ResponseEntity.class));
MethodParameter returnType = on(TestController.class).resolveReturnType(Mono.class, ResponseEntity.class);
HandlerResult result = new HandlerResult(new TestController(), Mono.just(notFound().build()), returnType);
this.resultHandler.handleResult(exchange, result).block(Duration.ofSeconds(5));
@@ -339,11 +337,7 @@ public class ResponseEntityResultHandlerTests {
}
private ResolvableType entity(Class<?> bodyType) {
return forClassWithGenerics(ResponseEntity.class, forClass(bodyType));
}
private ResolvableType asyncEntity(Class<?> asyncType, Class<?> bodyType) {
return forClassWithGenerics(asyncType, entity(bodyType));
return forClassWithGenerics(ResponseEntity.class, bodyType);
}
private HandlerResult handlerResult(Object returnValue, MethodParameter returnType) {

36
spring-webflux/src/test/java/org/springframework/web/reactive/result/view/ViewResolutionResultHandlerTests.java
View File

@@ -62,7 +62,6 @@ import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
import static org.springframework.core.ResolvableType.forClass;
import static org.springframework.core.ResolvableType.forClassWithGenerics;
import static org.springframework.http.MediaType.APPLICATION_JSON;
import static org.springframework.web.method.ResolvableMethod.on;
@@ -90,11 +89,11 @@ public class ViewResolutionResultHandlerTests {
testSupports(on(TestController.class).resolveReturnType(String.class));
testSupports(on(TestController.class).resolveReturnType(View.class));
testSupports(on(TestController.class).resolveReturnType(forClassWithGenerics(Mono.class, String.class)));
testSupports(on(TestController.class).resolveReturnType(forClassWithGenerics(Mono.class, View.class)));
testSupports(on(TestController.class).resolveReturnType(forClassWithGenerics(Single.class, String.class)));
testSupports(on(TestController.class).resolveReturnType(forClassWithGenerics(Single.class, View.class)));
testSupports(on(TestController.class).resolveReturnType(forClassWithGenerics(Mono.class, Void.class)));
testSupports(on(TestController.class).resolveReturnType(Mono.class, String.class));
testSupports(on(TestController.class).resolveReturnType(Mono.class, View.class));
testSupports(on(TestController.class).resolveReturnType(Single.class, String.class));
testSupports(on(TestController.class).resolveReturnType(Single.class, View.class));
testSupports(on(TestController.class).resolveReturnType(Mono.class, Void.class));
testSupports(on(TestController.class).resolveReturnType(Completable.class));
testSupports(on(TestController.class).resolveReturnType(Model.class));
testSupports(on(TestController.class).resolveReturnType(Map.class));
@@ -139,27 +138,27 @@ public class ViewResolutionResultHandlerTests {
returnValue = new TestView("account");
testHandle("/path", returnType, returnValue, "account: {id=123}");
returnType = on(TestController.class).resolveReturnType(forClassWithGenerics(Mono.class, View.class));
returnType = on(TestController.class).resolveReturnType(Mono.class, View.class);
returnValue = Mono.just(new TestView("account"));
testHandle("/path", returnType, returnValue, "account: {id=123}");
returnType = on(TestController.class).resolveReturnType(forClass(String.class));
returnType = on(TestController.class).resolveReturnType(String.class);
returnValue = "account";
testHandle("/path", returnType, returnValue, "account: {id=123}", resolver);
returnType = on(TestController.class).resolveReturnType(forClassWithGenerics(Mono.class, String.class));
returnType = on(TestController.class).resolveReturnType(Mono.class, String.class);
returnValue = Mono.just("account");
testHandle("/path", returnType, returnValue, "account: {id=123}", resolver);
returnType = on(TestController.class).resolveReturnType(forClass(Model.class));
returnType = on(TestController.class).resolveReturnType(Model.class);
returnValue = new ConcurrentModel().addAttribute("name", "Joe");
testHandle("/account", returnType, returnValue, "account: {id=123, name=Joe}", resolver);
returnType = on(TestController.class).resolveReturnType(forClass(Map.class));
returnType = on(TestController.class).resolveReturnType(Map.class);
returnValue = Collections.singletonMap("name", "Joe");
testHandle("/account", returnType, returnValue, "account: {id=123, name=Joe}", resolver);
returnType = on(TestController.class).resolveReturnType(forClass(TestBean.class));
returnType = on(TestController.class).resolveReturnType(TestBean.class);
returnValue = new TestBean("Joe");
String responseBody = "account: {" +
"id=123, " +
@@ -184,17 +183,10 @@ public class ViewResolutionResultHandlerTests {
@Test
public void defaultViewName() throws Exception {
testDefaultViewName(null, on(TestController.class).resolveReturnType(String.class));
testDefaultViewName(Mono.empty(), on(TestController.class)
.resolveReturnType(forClassWithGenerics(Mono.class, String.class)));
testDefaultViewName(Mono.empty(), on(TestController.class)
.resolveReturnType(forClassWithGenerics(Mono.class, Void.class)));
testDefaultViewName(Completable.complete(), on(TestController.class)
.resolveReturnType(forClass(Completable.class)));
testDefaultViewName(Mono.empty(), on(TestController.class).resolveReturnType(Mono.class, String.class));
testDefaultViewName(Mono.empty(), on(TestController.class).resolveReturnType(Mono.class, Void.class));
testDefaultViewName(Completable.complete(), on(TestController.class).resolveReturnType(Completable.class));
}
private void testDefaultViewName(Object returnValue, MethodParameter returnType) throws URISyntaxException {