@SuppressWarnings("unchecked") private <T> void assertError(Mono<Object> mono, final Class<T> exceptionClass, final Consumer<T> consumer) { StepVerifier.create(mono) .consumeErrorWith(error -> { assertEquals(exceptionClass, error.getClass()); consumer.accept((T) error); }) .verify(); }
@Test public void filterWithInvalidMethodValue() { StepVerifier.create(postForm("_method=INVALID")) .consumeErrorWith(error -> { assertThat(error, Matchers.instanceOf(IllegalArgumentException.class)); assertEquals("HttpMethod 'INVALID' not supported", error.getMessage()); }) .verify(); }
@Test public void noHandler() { MockServerWebExchange exchange = MockServerWebExchange.from(MockServerHttpRequest.get("/does-not-exist")); Mono<Void> mono = this.dispatcherHandler.handle(exchange); StepVerifier.create(mono) .consumeErrorWith(ex -> { assertThat(ex, instanceOf(ResponseStatusException.class)); assertThat(ex.getMessage(), is("404 NOT_FOUND \"No matching handler\"")); }) .verify(); // SPR-17475 AtomicReference<Throwable> exceptionRef = new AtomicReference<>(); StepVerifier.create(mono).consumeErrorWith(exceptionRef::set).verify(); StepVerifier.create(mono).consumeErrorWith(ex -> assertNotSame(exceptionRef.get(), ex)).verify(); }
@Test public void bothErrorDelayed() { IOException firstError = new IOException("first"); IOException secondError = new IOException("second"); new FluxMergeOrdered<Integer>(2, Queues.small(), Comparator.naturalOrder(), Flux.error(firstError), Flux.error(secondError) ) .as(StepVerifier::create) .consumeErrorWith(e -> assertThat(Exceptions.unwrapMultiple(e)).containsExactly(firstError, secondError)) .verifyThenAssertThat() .hasNotDroppedErrors(); }
private void resourceNotFound(HttpMethod httpMethod) { MockServerHttpRequest request = MockServerHttpRequest.method(httpMethod, "").build(); MockServerWebExchange exchange = MockServerWebExchange.from(request); setPathWithinHandlerMapping(exchange, "not-there.css"); Mono<Void> mono = this.handler.handle(exchange); StepVerifier.create(mono) .expectErrorSatisfies(err -> { assertThat(err, instanceOf(ResponseStatusException.class)); assertEquals(HttpStatus.NOT_FOUND, ((ResponseStatusException) err).getStatus()); }).verify(TIMEOUT); // SPR-17475 AtomicReference<Throwable> exceptionRef = new AtomicReference<>(); StepVerifier.create(mono).consumeErrorWith(exceptionRef::set).verify(); StepVerifier.create(mono).consumeErrorWith(ex -> assertNotSame(exceptionRef.get(), ex)).verify(); }
private void testValidationError(MethodParameter param, Function<Mono<?>, Mono<?>> valueMonoExtractor) throws URISyntaxException { ServerWebExchange exchange = postForm("age=invalid"); Mono<?> mono = createResolver().resolveArgument(param, this.bindContext, exchange); mono = valueMonoExtractor.apply(mono); StepVerifier.create(mono) .consumeErrorWith(ex -> { assertTrue(ex instanceof WebExchangeBindException); WebExchangeBindException bindException = (WebExchangeBindException) ex; assertEquals(1, bindException.getErrorCount()); assertTrue(bindException.hasFieldErrors("age")); }) .verify(); }
@Test // SPR-16231 public void responseCommitted() { Throwable ex = new ResponseStatusException(HttpStatus.INTERNAL_SERVER_ERROR, "Oops"); this.exchange.getResponse().setStatusCode(HttpStatus.CREATED); Mono<Void> mono = this.exchange.getResponse().setComplete() .then(Mono.defer(() -> this.handler.handle(this.exchange, ex))); StepVerifier.create(mono).consumeErrorWith(actual -> assertSame(ex, actual)).verify(); }
@Test public void responseBodyMessageConversionError() { ServerWebExchange exchange = MockServerWebExchange.from( MockServerHttpRequest.post("/request-body").accept(APPLICATION_JSON).body("body")); Mono<Void> publisher = this.dispatcherHandler.handle(exchange); StepVerifier.create(publisher) .consumeErrorWith(error -> assertThat(error, instanceOf(NotAcceptableStatusException.class))) .verify(); }
@Test public void controllerReturnsMonoError() { MockServerWebExchange exchange = MockServerWebExchange.from(MockServerHttpRequest.get("/error-signal")); Mono<Void> publisher = this.dispatcherHandler.handle(exchange); StepVerifier.create(publisher) .consumeErrorWith(error -> assertSame(EXCEPTION, error)) .verify(); }
@Test public void unresolvedException() { Throwable expected = new IllegalStateException(); Mono<Void> mono = this.handler.handle(this.exchange, expected); StepVerifier.create(mono).consumeErrorWith(actual -> assertSame(expected, actual)).verify(); }
@Test public void requestBodyError() { ServerWebExchange exchange = MockServerWebExchange.from( MockServerHttpRequest.post("/request-body").body(Mono.error(EXCEPTION))); Mono<Void> publisher = this.dispatcherHandler.handle(exchange); StepVerifier.create(publisher) .consumeErrorWith(error -> assertSame(EXCEPTION, error)) .verify(); }
@Test public void controllerThrowsException() { MockServerWebExchange exchange = MockServerWebExchange.from(MockServerHttpRequest.get("/raise-exception")); Mono<Void> publisher = this.dispatcherHandler.handle(exchange); StepVerifier.create(publisher) .consumeErrorWith(error -> assertSame(EXCEPTION, error)) .verify(); }
@Test public void unknownReturnType() { MockServerWebExchange exchange = MockServerWebExchange.from(MockServerHttpRequest.get("/unknown-return-type")); Mono<Void> publisher = this.dispatcherHandler.handle(exchange); StepVerifier.create(publisher) .consumeErrorWith(error -> { assertThat(error, instanceOf(IllegalStateException.class)); assertThat(error.getMessage(), startsWith("No HandlerResultHandler")); }) .verify(); }