@Test public void defaultViewName() { testDefaultViewName(null, on(Handler.class).annotPresent(ModelAttribute.class).resolveReturnType(String.class)); testDefaultViewName(Mono.empty(), on(Handler.class).resolveReturnType(Mono.class, String.class)); testDefaultViewName(Mono.empty(), on(Handler.class).resolveReturnType(Mono.class, Void.class)); testDefaultViewName(Completable.complete(), on(Handler.class).resolveReturnType(Completable.class)); }
private ResponseBodyEmitter handleValue(Object returnValue, Class<?> asyncType, ResolvableType genericType) throws Exception { ModelAndViewContainer mavContainer = new ModelAndViewContainer(); MethodParameter returnType = on(TestController.class).resolveReturnType(asyncType, genericType); return this.handler.handleValue(returnValue, returnType, mavContainer, this.webRequest); }
@Test // SPR-13631 public void useDefaultCharset() throws Exception { this.exchange.getAttributes().put(PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE, Collections.singleton(APPLICATION_JSON)); String body = "foo"; MethodParameter type = on(TestController.class).resolveReturnType(String.class); this.resultHandler.writeBody(body, type, this.exchange).block(Duration.ofSeconds(5)); assertEquals(APPLICATION_JSON_UTF8, this.exchange.getResponse().getHeaders().getContentType()); }
@Test public void supportsReturnType() throws Exception { assertTrue(this.handler.supportsReturnType( on(TestController.class).resolveReturnType(DeferredResult.class, String.class))); assertTrue(this.handler.supportsReturnType( on(TestController.class).resolveReturnType(ListenableFuture.class, String.class))); assertTrue(this.handler.supportsReturnType( on(TestController.class).resolveReturnType(CompletableFuture.class, String.class))); }
@Test public void invocationTargetException() { Method method = ResolvableMethod.on(TestController.class).mockCall(TestController::exceptionMethod).method(); Mono<HandlerResult> mono = invoke(new TestController(), method); try { mono.block(); fail("Expected IllegalStateException"); } catch (IllegalStateException ex) { assertThat(ex.getMessage(), is("boo")); } }
@Test public void handleReturnValueLastModified() throws Exception { Instant currentTime = Instant.now().truncatedTo(ChronoUnit.SECONDS); Instant oneMinAgo = currentTime.minusSeconds(60); long timestamp = currentTime.toEpochMilli(); MockServerWebExchange exchange = MockServerWebExchange.from(get("/path").ifModifiedSince(timestamp)); ResponseEntity<String> entity = ok().lastModified(oneMinAgo.toEpochMilli()).body("body"); MethodParameter returnType = on(TestController.class).resolveReturnType(entity(String.class)); HandlerResult result = handlerResult(entity, returnType); this.resultHandler.handleResult(exchange, result).block(Duration.ofSeconds(5)); assertConditionalResponse(exchange, HttpStatus.NOT_MODIFIED, null, null, oneMinAgo); }
@Test public void handleReturnValueEtag() throws Exception { String etagValue = "\"deadb33f8badf00d\""; MockServerWebExchange exchange = MockServerWebExchange.from(get("/path").ifNoneMatch(etagValue)); ResponseEntity<String> entity = ok().eTag(etagValue).body("body"); MethodParameter returnType = on(TestController.class).resolveReturnType(entity(String.class)); HandlerResult result = handlerResult(entity, returnType); this.resultHandler.handleResult(exchange, result).block(Duration.ofSeconds(5)); assertConditionalResponse(exchange, HttpStatus.NOT_MODIFIED, null, etagValue, Instant.MIN); }
@Test public void doesNotSupport() throws Exception { Object value = null; MethodParameter returnType = on(TestController.class).resolveReturnType(String.class); assertFalse(this.resultHandler.supports(handlerResult(value, returnType))); returnType = on(TestController.class).resolveReturnType(Completable.class); assertFalse(this.resultHandler.supports(handlerResult(value, returnType))); // SPR-15464 returnType = on(TestController.class).resolveReturnType(Flux.class); assertFalse(this.resultHandler.supports(handlerResult(value, returnType))); }
@Test public void resolveNoArgValue() { this.resolvers.add(stubResolver(Mono.empty())); Method method = ResolvableMethod.on(TestController.class).mockCall(o -> o.singleArg(null)).method(); Mono<HandlerResult> mono = invoke(new TestController(), method); assertHandlerResultValue(mono, "success:null"); }
@Test // SPR-14877 public void handleMonoWithWildcardBodyTypeAndNullBody() throws Exception { MockServerWebExchange exchange = MockServerWebExchange.from(get("/path")); exchange.getAttributes().put(PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE, Collections.singleton(APPLICATION_JSON)); 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)); assertEquals(HttpStatus.NOT_FOUND, exchange.getResponse().getStatusCode()); assertResponseBodyIsEmpty(exchange); }
@Test public void supports() throws NoSuchMethodException { Object controller = new TestController(); Method method; method = on(TestController.class).annotPresent(ResponseBody.class).resolveMethod(); testSupports(controller, method); method = on(TestController.class).annotNotPresent(ResponseBody.class).resolveMethod("doWork"); HandlerResult handlerResult = getHandlerResult(controller, method); assertFalse(this.resultHandler.supports(handlerResult)); }
@Test public void resolveArg() { this.resolvers.add(stubResolver("value1")); Method method = ResolvableMethod.on(TestController.class).mockCall(o -> o.singleArg(null)).method(); Mono<HandlerResult> mono = invoke(new TestController(), method); assertHandlerResultValue(mono, "success:value1"); }
@Test public void resolveProvidedArgFirst() { this.resolvers.add(stubResolver("value1")); Method method = ResolvableMethod.on(TestController.class).mockCall(o -> o.singleArg(null)).method(); Mono<HandlerResult> mono = invoke(new TestController(), method, "value2"); assertHandlerResultValue(mono, "success:value2"); }
@Test public void handleResponseEntityWithNullBody() throws Exception { Object returnValue = Mono.just(notFound().build()); MethodParameter type = on(TestController.class).resolveReturnType(Mono.class, entity(String.class)); HandlerResult result = handlerResult(returnValue, type); MockServerWebExchange exchange = MockServerWebExchange.from(get("/path")); this.resultHandler.handleResult(exchange, result).block(Duration.ofSeconds(5)); assertEquals(HttpStatus.NOT_FOUND, exchange.getResponse().getStatusCode()); assertResponseBodyIsEmpty(exchange); }
@Test public void resolveNoArgs() { Method method = ResolvableMethod.on(TestController.class).mockCall(TestController::noArgs).method(); Mono<HandlerResult> mono = invoke(new TestController(), method); assertHandlerResultValue(mono, "success"); }
@Test public void responseStatusAnnotation() { Method method = ResolvableMethod.on(TestController.class).mockCall(TestController::created).method(); Mono<HandlerResult> mono = invoke(new TestController(), method); assertHandlerResultValue(mono, "created"); assertThat(this.exchange.getResponse().getStatusCode(), is(HttpStatus.CREATED)); }
@Test public void resolveProvidedArg() { Method method = ResolvableMethod.on(TestController.class).mockCall(o -> o.singleArg(null)).method(); Mono<HandlerResult> mono = invoke(new TestController(), method, "value1"); assertHandlerResultValue(mono, "success:value1"); }
@Test public void getHandlerGlobMatch() { Method expected = on(TestController.class).annot(requestMapping("/ba*").method(GET, HEAD)).resolveMethod(); ServerWebExchange exchange = MockServerWebExchange.from(get("/bar")); HandlerMethod hm = (HandlerMethod) this.handlerMapping.getHandler(exchange).block(); assertEquals(expected, hm.getMethod()); }
@Test // SPR-17076 public void responseEntityFluxWithCustomHeader() throws Exception { EmitterProcessor<SimpleBean> processor = EmitterProcessor.create(); ResponseEntity<Flux<SimpleBean>> entity = ResponseEntity.ok().header("x-foo", "bar").body(processor); ResolvableType bodyType = forClassWithGenerics(Flux.class, SimpleBean.class); MethodParameter type = on(TestController.class).resolveReturnType(ResponseEntity.class, bodyType); this.handler.handleReturnValue(entity, type, this.mavContainer, this.webRequest); assertTrue(this.request.isAsyncStarted()); assertEquals(200, this.response.getStatus()); assertEquals("bar", this.response.getHeader("x-foo")); assertFalse(this.response.isCommitted()); }
@Test public void voidMethodWithExchangeArg() { this.resolvers.add(stubResolver(this.exchange)); Method method = ResolvableMethod.on(TestController.class).mockCall(c -> c.exchange(exchange)).method(); HandlerResult result = invokeForResult(new TestController(), method); assertNull("Expected no result (i.e. fully handled)", result); assertEquals("bar", this.exchange.getResponse().getHeaders().getFirst("foo")); }