@Test public void modelAttributesConventions() { Set<String> model = Collections.singleton("bar"); Mono<RenderingResponse> result = RenderingResponse.create("foo") .modelAttributes(model).build(); StepVerifier.create(result) .expectNextMatches(response -> "bar".equals(response.model().get("string"))) .expectComplete() .verify(); }
@Test public void readAsynchronousFileChannelPosition() throws Exception { URI uri = this.resource.getURI(); Flux<DataBuffer> flux = DataBufferUtils.readAsynchronousFileChannel( () -> AsynchronousFileChannel.open(Paths.get(uri), StandardOpenOption.READ), 9, this.bufferFactory, 3); StepVerifier.create(flux) .consumeNextWith(stringConsumer("qux")) .expectComplete() .verify(Duration.ofSeconds(5)); }
private void verifyWrittenData(Flux<DataBuffer> writeResult) throws IOException { StepVerifier.create(writeResult) .consumeNextWith(stringConsumer("foo")) .consumeNextWith(stringConsumer("bar")) .consumeNextWith(stringConsumer("baz")) .consumeNextWith(stringConsumer("qux")) .expectComplete() .verify(Duration.ofSeconds(3)); String result = String.join("", Files.readAllLines(tempFile)); assertEquals("foobarbazqux", result); }
@Test public void decodeEmptyDataBuffer() { Flux<DataBuffer> input = Flux.just(stringBuffer("")); Flux<String> output = this.decoder.decode(input, TYPE, null, Collections.emptyMap()); StepVerifier.create(output) .expectNext("") .expectComplete().verify(); }
@Test public void contentLength() { String body = "foo"; Mono<EntityResponse<String>> result = EntityResponse.fromObject(body).contentLength(42).build(); StepVerifier.create(result) .expectNextMatches(response -> Long.valueOf(42).equals(response.headers().getContentLength())) .expectComplete() .verify(); }
@Test public void readAsynchronousFileChannelCancel() throws Exception { URI uri = this.resource.getURI(); Flux<DataBuffer> flux = DataBufferUtils.readAsynchronousFileChannel( () -> AsynchronousFileChannel.open(Paths.get(uri), StandardOpenOption.READ), this.bufferFactory, 3); StepVerifier.create(flux) .consumeNextWith(stringConsumer("foo")) .thenCancel() .verify(); }
@Test // SPR-15782 public void shouldFailWithRelativeUrls() { String uri = "/api/v4/groups/1"; Mono<ClientResponse> responseMono = WebClient.builder().build().get().uri(uri).exchange(); StepVerifier.create(responseMono) .expectErrorMessage("URI is not absolute: " + uri) .verify(Duration.ofSeconds(5)); }
@Test // SPR-16521 public void jsonEOFExceptionIsWrappedAsDecodingError() { Flux<DataBuffer> source = Flux.just(stringBuffer("{\"status\": \"noClosingQuote}")); Flux<TokenBuffer> tokens = Jackson2Tokenizer.tokenize(source, this.jsonFactory, false); StepVerifier.create(tokens) .expectError(DecodingException.class) .verify(); }
@Test public void normal() { HandlerFunction<ServerResponse> handlerFunction = request -> ServerResponse.ok().build(); RouterFunction<ServerResponse> routerFunction = request -> Mono.just(handlerFunction); RouterFunctionMapping mapping = new RouterFunctionMapping(routerFunction); mapping.setMessageReaders(this.codecConfigurer.getReaders()); Mono<Object> result = mapping.getHandler(this.exchange); StepVerifier.create(result) .expectNext(handlerFunction) .expectComplete() .verify(); }
@Test public void directory() { MockServerWebExchange exchange = MockServerWebExchange.from(MockServerHttpRequest.get("")); setPathWithinHandlerMapping(exchange, "js/"); StepVerifier.create(this.handler.handle(exchange)) .expectErrorSatisfies(err -> { assertThat(err, instanceOf(ResponseStatusException.class)); assertEquals(HttpStatus.NOT_FOUND, ((ResponseStatusException) err).getStatus()); }).verify(TIMEOUT); }
@Test public void decodeMultipleXmlRootElement() throws Exception { Mono<DataBuffer> source = stringBuffer(POJO_CHILD); Flux<Object> output = this.decoder.decode(source, ResolvableType.forClass(Pojo.class), null, Collections.emptyMap()); StepVerifier.create(output) .expectNext(new Pojo("foo", "bar")) .expectNext(new Pojo("foofoo", "barbar")) .expectComplete() .verify(); }
@Test public void cacheControlTag() { String body = "foo"; Mono<EntityResponse<String>> result = EntityResponse.fromObject(body).cacheControl(CacheControl.noCache()).build(); StepVerifier.create(result) .expectNextMatches(response -> "no-cache".equals(response.headers().getCacheControl())) .expectComplete() .verify(); }
@Test // SPR-15758 public void toMonoWithEmptyBodyAndNoContentType() { BodyExtractor<Mono<Map<String, String>>, ReactiveHttpInputMessage> extractor = BodyExtractors.toMono(new ParameterizedTypeReference<Map<String, String>>() {}); MockServerHttpRequest request = MockServerHttpRequest.post("/").body(Flux.empty()); Mono<Map<String, String>> result = extractor.extract(request, this.context); StepVerifier.create(result).expectComplete().verify(); }
@Test public void emptyBodyWithRxJava2Single() throws Exception { ResolvableType type = httpEntityType(io.reactivex.Single.class, String.class); HttpEntity<io.reactivex.Single<String>> entity = resolveValueWithEmptyBody(type); StepVerifier.create(entity.getBody().toFlowable()) .expectNextCount(0) .expectError(ServerWebInputException.class) .verify(); }
@Test public void ok() { Mono<ServerResponse> result = ServerResponse.ok().build(); StepVerifier.create(result) .expectNextMatches(response -> HttpStatus.OK.equals(response.statusCode())) .expectComplete() .verify(); }
@Test public void noContent() { Mono<ServerResponse> result = ServerResponse.noContent().build(); StepVerifier.create(result) .expectNextMatches(response -> HttpStatus.NO_CONTENT.equals(response.statusCode())) .expectComplete() .verify(); }
@Test public void notFound() { Mono<ServerResponse> result = ServerResponse.notFound().build(); StepVerifier.create(result) .expectNextMatches(response -> HttpStatus.NOT_FOUND.equals(response.statusCode())) .expectComplete() .verify(); }
@Test public void unprocessableEntity() { Mono<ServerResponse> result = ServerResponse.unprocessableEntity().build(); StepVerifier.create(result) .expectNextMatches(response -> HttpStatus.UNPROCESSABLE_ENTITY.equals(response.statusCode())) .expectComplete() .verify(); }
@Test public void transformNoLinks() { MockServerWebExchange exchange = MockServerWebExchange.from(get("/static/foo.css")); Resource expected = getResource("foo.css"); StepVerifier.create(this.transformerChain.transform(exchange, expected)) .consumeNextWith(resource -> assertSame(expected, resource)) .expectComplete().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(); }