@Override public ClientResponse build() { ClientHttpResponse httpResponse = new BuiltClientHttpResponse(this.statusCode, this.headers, this.cookies, this.body); // When building ClientResponse manually, the ClientRequest.logPrefix() has to be passed, // e.g. via ClientResponse.Builder, but this (builder) is not used currently. return new DefaultClientResponse(httpResponse, this.strategies, ""); }
@Override public <T> Mono<T> bodyToMono(ParameterizedTypeReference<T> typeReference) { return body(BodyExtractors.toMono(typeReference)); }
@Override public <T> Mono<ResponseEntity<List<T>>> toEntityList(Class<T> responseType) { return toEntityListInternal(bodyToFlux(responseType)); }
@Override public <T> Mono<ResponseEntity<T>> toEntity(Class<T> bodyType) { return toEntityInternal(bodyToMono(bodyType)); }
private <T> Mono<ResponseEntity<List<T>>> toEntityListInternal(Flux<T> bodyFlux) { HttpHeaders headers = headers().asHttpHeaders(); int status = rawStatusCode(); return bodyFlux .collectList() .map(body -> createEntity(body, headers, status)); }
private <T extends Publisher<?>> T bodyToPublisher( BodyExtractor<T, ? super ClientHttpResponse> extractor, Function<WebClientException, T> errorFunction) { HttpStatus status = statusCode(); if (status.is4xxClientError() || status.is5xxServerError()) { WebClientException ex = new WebClientException( "ClientResponse has erroneous status code: " + status.value() + " " + status.getReasonPhrase()); return errorFunction.apply(ex); } else { return body(extractor); } }
@Test public void bodyToMono() { DefaultDataBufferFactory factory = new DefaultDataBufferFactory(); DefaultDataBuffer dataBuffer = factory.wrap(ByteBuffer.wrap("foo".getBytes(StandardCharsets.UTF_8))); Flux<DataBuffer> body = Flux.just(dataBuffer); mockTextPlainResponse(body); List<HttpMessageReader<?>> messageReaders = Collections .singletonList(new DecoderHttpMessageReader<>(StringDecoder.allMimeTypes())); when(mockExchangeStrategies.messageReaders()).thenReturn(messageReaders); Mono<String> resultMono = defaultClientResponse.bodyToMono(String.class); assertEquals("foo", resultMono.block()); }
@Test public void bodyToFlux() { DefaultDataBufferFactory factory = new DefaultDataBufferFactory(); DefaultDataBuffer dataBuffer = factory.wrap(ByteBuffer.wrap("foo".getBytes(StandardCharsets.UTF_8))); Flux<DataBuffer> body = Flux.just(dataBuffer); mockTextPlainResponse(body); List<HttpMessageReader<?>> messageReaders = Collections .singletonList(new DecoderHttpMessageReader<>(StringDecoder.allMimeTypes())); when(mockExchangeStrategies.messageReaders()).thenReturn(messageReaders); Flux<String> resultFlux = defaultClientResponse.bodyToFlux(String.class); Mono<List<String>> result = resultFlux.collectList(); assertEquals(Collections.singletonList("foo"), result.block()); }
@Test public void rawStatusCode() { int status = 999; when(mockResponse.getRawStatusCode()).thenReturn(status); assertEquals(status, defaultClientResponse.rawStatusCode()); }
@Test public void statusCode() { HttpStatus status = HttpStatus.CONTINUE; when(mockResponse.getStatusCode()).thenReturn(status); assertEquals(status, defaultClientResponse.statusCode()); }
@Test public void header() { HttpHeaders httpHeaders = new HttpHeaders(); long contentLength = 42L; httpHeaders.setContentLength(contentLength); MediaType contentType = MediaType.TEXT_PLAIN; httpHeaders.setContentType(contentType); InetSocketAddress host = InetSocketAddress.createUnresolved("localhost", 80); httpHeaders.setHost(host); List<HttpRange> range = Collections.singletonList(HttpRange.createByteRange(0, 42)); httpHeaders.setRange(range); when(mockResponse.getHeaders()).thenReturn(httpHeaders); ClientResponse.Headers headers = defaultClientResponse.headers(); assertEquals(OptionalLong.of(contentLength), headers.contentLength()); assertEquals(Optional.of(contentType), headers.contentType()); assertEquals(httpHeaders, headers.asHttpHeaders()); }
@Override public <T> Flux<T> bodyToFlux(Class<? extends T> elementClass) { return bodyToPublisher(BodyExtractors.toFlux(elementClass), Flux::error); }
@Test public void cookies() { ResponseCookie cookie = ResponseCookie.from("foo", "bar").build(); MultiValueMap<String, ResponseCookie> cookies = new LinkedMultiValueMap<>(); cookies.add("foo", cookie); when(mockResponse.getCookies()).thenReturn(cookies); assertSame(cookies, defaultClientResponse.cookies()); }
private <T> Mono<ResponseEntity<T>> toEntityInternal(Mono<T> bodyMono) { HttpHeaders headers = headers().asHttpHeaders(); int status = rawStatusCode(); return bodyMono .map(body -> createEntity(body, headers, status)) .switchIfEmpty(Mono.defer( () -> Mono.just(createEntity(headers, status)))); }
@Override public <T> Mono<ResponseEntity<T>> toEntity(ParameterizedTypeReference<T> typeReference) { return toEntityInternal(bodyToMono(typeReference)); }
@Test public void bodyToMonoTypeReference() { DefaultDataBufferFactory factory = new DefaultDataBufferFactory(); DefaultDataBuffer dataBuffer = factory.wrap(ByteBuffer.wrap("foo".getBytes(StandardCharsets.UTF_8))); Flux<DataBuffer> body = Flux.just(dataBuffer); mockTextPlainResponse(body); List<HttpMessageReader<?>> messageReaders = Collections .singletonList(new DecoderHttpMessageReader<>(StringDecoder.allMimeTypes())); when(mockExchangeStrategies.messageReaders()).thenReturn(messageReaders); Mono<String> resultMono = defaultClientResponse.bodyToMono(new ParameterizedTypeReference<String>() { }); assertEquals("foo", resultMono.block()); }
@Test public void bodyToFluxTypeReference() { DefaultDataBufferFactory factory = new DefaultDataBufferFactory(); DefaultDataBuffer dataBuffer = factory.wrap(ByteBuffer.wrap("foo".getBytes(StandardCharsets.UTF_8))); Flux<DataBuffer> body = Flux.just(dataBuffer); mockTextPlainResponse(body); List<HttpMessageReader<?>> messageReaders = Collections .singletonList(new DecoderHttpMessageReader<>(StringDecoder.allMimeTypes())); when(mockExchangeStrategies.messageReaders()).thenReturn(messageReaders); Flux<String> resultFlux = defaultClientResponse.bodyToFlux(new ParameterizedTypeReference<String>() { }); Mono<List<String>> result = resultFlux.collectList(); assertEquals(Collections.singletonList("foo"), result.block()); }
@Override public <T> Mono<T> bodyToMono(Class<? extends T> elementClass) { return bodyToPublisher(BodyExtractors.toMono(elementClass), Mono::error); }
@Override public <T> Mono<T> bodyToMono(Class<? extends T> elementClass) { return body(BodyExtractors.toMono(elementClass)); }
@Before public void createMocks() { mockResponse = mock(ClientHttpResponse.class); mockExchangeStrategies = mock(ExchangeStrategies.class); defaultClientResponse = new DefaultClientResponse(mockResponse, mockExchangeStrategies, ""); }