@Override public <T> Flux<T> bodyToFlux(ParameterizedTypeReference<T> typeReference) { return this.delegate.bodyToFlux(typeReference); }
@Override public <T> Flux<T> bodyToFlux(Class<? extends T> elementClass) { return this.delegate.bodyToFlux(elementClass); }
@Override public <T> Flux<T> bodyToFlux(ParameterizedTypeReference<T> typeReference) { return delegate.bodyToFlux(typeReference); }
@Override public <T> Flux<T> bodyToFlux(Class<? extends T> elementClass) { return delegate.bodyToFlux(elementClass); }
@Override public <T> FluxExchangeResult<T> returnResult(ParameterizedTypeReference<T> elementType) { Flux<T> body = this.response.bodyToFlux(elementType); return new FluxExchangeResult<>(this.exchangeResult, body); } }
@Override public <T> FluxExchangeResult<T> returnResult(Class<T> elementType) { Flux<T> body = this.response.bodyToFlux(elementType); return new FluxExchangeResult<>(this.exchangeResult, body); }
@Override public <E> ListBodySpec<E> expectBodyList(ParameterizedTypeReference<E> elementType) { Flux<E> flux = this.response.bodyToFlux(elementType); return getListBodySpec(flux); }
@Override public <E> ListBodySpec<E> expectBodyList(Class<E> elementType) { return getListBodySpec(this.response.bodyToFlux(elementType)); }
@Override public <T> Flux<T> bodyToFlux(Class<T> elementType) { return this.responseMono.flatMapMany(response -> handleBody(response, response.bodyToFlux(elementType), mono -> mono.flatMapMany(Flux::error))); }
@Override public <T> Flux<T> bodyToFlux(ParameterizedTypeReference<T> elementType) { return this.responseMono.flatMapMany(response -> handleBody(response, response.bodyToFlux(elementType), mono -> mono.flatMapMany(Flux::error))); }
@Test public void bodyToFluxParameterizedTypeReference() { Flux<String> result = Flux.just("foo"); ParameterizedTypeReference<String> reference = new ParameterizedTypeReference<String>() {}; when(mockResponse.bodyToFlux(reference)).thenReturn(result); assertSame(result, wrapper.bodyToFlux(reference)); }
@Test public void bodyToFluxClass() { Flux<String> result = Flux.just("foo"); when(mockResponse.bodyToFlux(String.class)).thenReturn(result); assertSame(result, wrapper.bodyToFlux(String.class)); }
private static Function<ClientResponse, Mono<ClientResponse>> convertClientResponse(Function<Flux<DataBuffer>, Flux<DataBuffer>> bodConverter, MediaType contentType) { return response -> { ClientResponse convertedResponse = ClientResponse.from(response).headers(headers -> { headers.replace(HttpHeaders.CONTENT_TYPE, singletonList(contentType.toString())); headers.remove(HttpHeaders.CONTENT_LENGTH); }).body(response.bodyToFlux(DataBuffer.class).transform(bodConverter)).build(); return Mono.just(convertedResponse); }; }
@Test public void values() { Flux<Msg> result = this.webClient.get() .uri("/messages") .exchange() .doOnNext(response -> { Assert.assertEquals("true", response.headers().contentType().get().getParameters().get("delimited")); Assert.assertEquals("sample.proto", response.headers().header("X-Protobuf-Schema").get(0)); Assert.assertEquals("Msg", response.headers().header("X-Protobuf-Message").get(0)); }) .flatMapMany(response -> response.bodyToFlux(Msg.class)); StepVerifier.create(result) .expectNext(TEST_MSG) .expectNext(TEST_MSG) .expectNext(TEST_MSG) .verifyComplete(); }
@Test public void normal() { Flux<DataBuffer> body = Flux.just("baz") .map(s -> s.getBytes(StandardCharsets.UTF_8)) .map(dataBufferFactory::wrap); ClientResponse response = ClientResponse.create(HttpStatus.BAD_GATEWAY, ExchangeStrategies.withDefaults()) .header("foo", "bar") .cookie("baz", "qux") .body(body) .build(); assertEquals(HttpStatus.BAD_GATEWAY, response.statusCode()); HttpHeaders responseHeaders = response.headers().asHttpHeaders(); assertEquals("bar", responseHeaders.getFirst("foo")); assertNotNull("qux", response.cookies().getFirst("baz")); assertEquals("qux", response.cookies().getFirst("baz").getValue()); StepVerifier.create(response.bodyToFlux(String.class)) .expectNext("baz") .verifyComplete(); }
@Test public void from() { Flux<DataBuffer> otherBody = Flux.just("foo", "bar") .map(s -> s.getBytes(StandardCharsets.UTF_8)) .map(dataBufferFactory::wrap); ClientResponse other = ClientResponse.create(HttpStatus.BAD_REQUEST, ExchangeStrategies.withDefaults()) .header("foo", "bar") .cookie("baz", "qux") .body(otherBody) .build(); Flux<DataBuffer> body = Flux.just("baz") .map(s -> s.getBytes(StandardCharsets.UTF_8)) .map(dataBufferFactory::wrap); ClientResponse result = ClientResponse.from(other) .headers(httpHeaders -> httpHeaders.set("foo", "baar")) .cookies(cookies -> cookies.set("baz", ResponseCookie.from("baz", "quux").build())) .body(body) .build(); assertEquals(HttpStatus.BAD_REQUEST, result.statusCode()); assertEquals(1, result.headers().asHttpHeaders().size()); assertEquals("baar", result.headers().asHttpHeaders().getFirst("foo")); assertEquals(1, result.cookies().size()); assertEquals("quux", result.cookies().getFirst("baz").getValue()); StepVerifier.create(result.bodyToFlux(String.class)) .expectNext("baz") .verifyComplete(); }
@Test public void streaming() { Flux<Msg> result = this.webClient.get() .uri("/message-stream") .exchange() .doOnNext(response -> { Assert.assertEquals("true", response.headers().contentType().get().getParameters().get("delimited")); Assert.assertEquals("sample.proto", response.headers().header("X-Protobuf-Schema").get(0)); Assert.assertEquals("Msg", response.headers().header("X-Protobuf-Message").get(0)); }) .flatMapMany(response -> response.bodyToFlux(Msg.class)); StepVerifier.create(result) .expectNext(Msg.newBuilder().setFoo("Foo").setBlah(SecondMsg.newBuilder().setBlah(0).build()).build()) .expectNext(Msg.newBuilder().setFoo("Foo").setBlah(SecondMsg.newBuilder().setBlah(1).build()).build()) .thenCancel() .verify(); }
@Test public void sseAsString() { Flux<String> result = this.webClient.get() .uri("/string") .accept(TEXT_EVENT_STREAM) .exchange() .flatMapMany(response -> response.bodyToFlux(String.class)); StepVerifier.create(result) .expectNext("foo 0") .expectNext("foo 1") .thenCancel() .verify(Duration.ofSeconds(5L)); }
@Test public void shouldReceivePlainTextFlux() throws Exception { prepareResponse(response -> response.setBody("Hello Spring!")); Flux<String> result = this.webClient.get() .uri("/greeting?name=Spring") .header("X-Test-Header", "testvalue") .exchange() .flatMapMany(response -> response.bodyToFlux(String.class)); StepVerifier.create(result) .expectNext("Hello Spring!") .expectComplete().verify(Duration.ofSeconds(3)); expectRequestCount(1); expectRequest(request -> { assertEquals("testvalue", request.getHeader("X-Test-Header")); assertEquals("*/*", request.getHeader(HttpHeaders.ACCEPT)); assertEquals("/greeting?name=Spring", request.getPath()); }); }
@Test public void sseAsPerson() { Flux<Person> result = this.webClient.get() .uri("/person") .accept(TEXT_EVENT_STREAM) .exchange() .flatMapMany(response -> response.bodyToFlux(Person.class)); StepVerifier.create(result) .expectNext(new Person("foo 0")) .expectNext(new Person("foo 1")) .thenCancel() .verify(Duration.ofSeconds(5L)); }