@Override public HttpStatus statusCode() { return this.delegate.statusCode(); }
/** * Return a filter that generates an error signal when the given * {@link HttpStatus} predicate matches. * @param statusPredicate the predicate to check the HTTP status with * @param exceptionFunction the function that to create the exception * @return the filter to generate an error signal */ public static ExchangeFilterFunction statusError(Predicate<HttpStatus> statusPredicate, Function<ClientResponse, ? extends Throwable> exceptionFunction) { Assert.notNull(statusPredicate, "Predicate must not be null"); Assert.notNull(exceptionFunction, "Function must not be null"); return ExchangeFilterFunction.ofResponseProcessor( response -> (statusPredicate.test(response.statusCode()) ? Mono.error(exceptionFunction.apply(response)) : Mono.just(response))); }
private Function<ClientResponse, Mono<DetectedEndpoint>> convert(EndpointDefinition endpointDefinition, URI uri) { return response -> { Mono<DetectedEndpoint> endpoint = Mono.empty(); if (response.statusCode().is2xxSuccessful()) { endpoint = Mono.just(DetectedEndpoint.of(endpointDefinition, uri.toString())); } return response.bodyToMono(Void.class).then(endpoint); }; }
private <T extends Publisher<?>> T handleBody(ClientResponse response, T bodyPublisher, Function<Mono<? extends Throwable>, T> errorFunction) { if (HttpStatus.resolve(response.rawStatusCode()) != null) { for (StatusHandler handler : this.statusHandlers) { if (handler.test(response.statusCode())) { HttpRequest request = this.requestSupplier.get(); Mono<? extends Throwable> exMono = handler.apply(response, request); exMono = exMono.flatMap(ex -> drainBody(response, ex)); exMono = exMono.onErrorResume(ex -> drainBody(response, ex)); return errorFunction.apply(exMono); } } return bodyPublisher; } else { return errorFunction.apply(createResponseException(response, this.requestSupplier.get())); } }
protected Mono<Info> convertInfo(Instance instance, ClientResponse response) { if (response.statusCode().is2xxSuccessful() && response.headers() .contentType() .map(mt -> mt.isCompatibleWith(MediaType.APPLICATION_JSON) || mt.isCompatibleWith(ACTUATOR_V2_MEDIATYPE)) .orElse(false)) { return response.bodyToMono(RESPONSE_TYPE).map(Info::from).defaultIfEmpty(Info.empty()); } log.info("Couldn't retrieve info for {}: {}", instance, response.statusCode()); return response.bodyToMono(Void.class).then(Mono.just(Info.empty())); }
protected Mono<StatusInfo> convertStatusInfo(ClientResponse response) { Boolean hasCompatibleContentType = response.headers() .contentType() .map(mt -> mt.isCompatibleWith(MediaType.APPLICATION_JSON) || mt.isCompatibleWith(ACTUATOR_V2_MEDIATYPE)) .orElse(false); StatusInfo statusInfoFromStatus = this.getStatusInfoFromStatus(response.statusCode(), emptyMap()); if (hasCompatibleContentType) { return response.bodyToMono(RESPONSE_TYPE).map(body -> { if (body.get("status") instanceof String) { return StatusInfo.from(body); } return getStatusInfoFromStatus(response.statusCode(), body); }).defaultIfEmpty(statusInfoFromStatus); } return response.bodyToMono(Void.class).then(Mono.just(statusInfoFromStatus)); }
@Test public void statusCode() { HttpStatus status = HttpStatus.BAD_REQUEST; when(mockResponse.statusCode()).thenReturn(status); assertSame(status, wrapper.statusCode()); }
public DefaultClientResponseBuilder(ClientResponse other) { Assert.notNull(other, "ClientResponse must not be null"); this.strategies = other.strategies(); statusCode(other.statusCode()); headers(headers -> headers.addAll(other.headers().asHttpHeaders())); cookies(cookies -> cookies.addAll(other.cookies())); }
if (HttpStatus.resolve(response.rawStatusCode()) != null) { return WebClientResponseException.create( response.statusCode().value(), response.statusCode().getReasonPhrase(), response.headers().asHttpHeaders(), bodyBytes,
@Test public void statusHandlerMatch() { ClientRequest request = ClientRequest.create(HttpMethod.GET, DEFAULT_URL).build(); ClientResponse response = mock(ClientResponse.class); when(response.statusCode()).thenReturn(HttpStatus.NOT_FOUND); ExchangeFunction exchange = r -> Mono.just(response); ExchangeFilterFunction errorHandler = ExchangeFilterFunctions.statusError( HttpStatus::is4xxClientError, r -> new MyException()); Mono<ClientResponse> result = errorHandler.filter(request, exchange); StepVerifier.create(result) .expectError(MyException.class) .verify(); }
@Test public void statusHandlerNoMatch() { ClientRequest request = ClientRequest.create(HttpMethod.GET, DEFAULT_URL).build(); ClientResponse response = mock(ClientResponse.class); when(response.statusCode()).thenReturn(HttpStatus.NOT_FOUND); Mono<ClientResponse> result = ExchangeFilterFunctions .statusError(HttpStatus::is5xxServerError, req -> new MyException()) .filter(request, req -> Mono.just(response)); StepVerifier.create(result) .expectNext(response) .expectComplete() .verify(); }
@RequestMapping(path = REQUEST_MAPPING_PATH, method = {RequestMethod.GET, RequestMethod.HEAD, RequestMethod.POST, RequestMethod.PUT, RequestMethod.PATCH, RequestMethod.DELETE, RequestMethod.OPTIONS}) public Mono<Void> endpointProxy(@PathVariable("instanceId") String instanceId, ServerHttpRequest request, ServerHttpResponse response) { String endpointLocalPath = getEndpointLocalPath(request.getPath().pathWithinApplication().value()); URI uri = UriComponentsBuilder.fromPath(endpointLocalPath) .query(request.getURI().getRawQuery()) .build(true) .toUri(); return super.forward(instanceId, uri, request.getMethod(), request.getHeaders(), () -> BodyInserters.fromDataBuffers(request.getBody())).flatMap(clientResponse -> { response.setStatusCode(clientResponse.statusCode()); response.getHeaders().addAll(filterHeaders(clientResponse.headers().asHttpHeaders())); return response.writeAndFlushWith(clientResponse.body(BodyExtractors.toDataBuffers()).window(1)); }); } }
@Test public void requestPart() { Mono<ClientResponse> result = webClient .post() .uri("/requestPart") .syncBody(generateBody()) .exchange(); StepVerifier .create(result) .consumeNextWith(response -> assertEquals(HttpStatus.OK, response.statusCode())) .verifyComplete(); }
@Test public void multipartData() { Mono<ClientResponse> result = webClient .post() .uri("http://localhost:" + this.port + "/multipartData") .syncBody(generateBody()) .exchange(); StepVerifier .create(result) .consumeNextWith(response -> assertEquals(HttpStatus.OK, response.statusCode())) .verifyComplete(); }
@Test public void parts() { Mono<ClientResponse> result = webClient .post() .uri("http://localhost:" + this.port + "/parts") .syncBody(generateBody()) .exchange(); StepVerifier .create(result) .consumeNextWith(response -> assertEquals(HttpStatus.OK, response.statusCode())) .verifyComplete(); }
@Test public void fixedLocale() { Mono<ClientResponse> result = webClient .get() .uri("http://localhost:" + this.port + "/") .exchange(); StepVerifier .create(result) .consumeNextWith(response -> { assertEquals(HttpStatus.OK, response.statusCode()); assertEquals(Locale.GERMANY, response.headers().asHttpHeaders().getContentLanguage()); }) .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 fixedLocale() { Mono<ClientResponse> result = webClient .get() .uri("http://localhost:" + this.port + "/") .exchange(); StepVerifier.create(result) .consumeNextWith(response -> { assertEquals(HttpStatus.OK, response.statusCode()); assertEquals(Locale.GERMANY, response.headers().asHttpHeaders().getContentLanguage()); }) .verifyComplete(); }
@Test public void shouldReceive404Response() { prepareResponse(response -> response.setResponseCode(404) .setHeader("Content-Type", "text/plain").setBody("Not Found")); Mono<ClientResponse> result = this.webClient.get().uri("/greeting?name=Spring").exchange(); StepVerifier.create(result) .consumeNextWith(response -> assertEquals(HttpStatus.NOT_FOUND, response.statusCode())) .expectComplete() .verify(Duration.ofSeconds(3)); expectRequestCount(1); expectRequest(request -> { assertEquals("*/*", request.getHeader(HttpHeaders.ACCEPT)); assertEquals("/greeting?name=Spring", request.getPath()); }); }