@Test public void bodyClass() { String body = "foo"; Publisher<String> publisher = Mono.just(body); ClientRequest result = ClientRequest.create(POST, URI.create("http://example.com")) .body(publisher, String.class).build(); List<HttpMessageWriter<?>> messageWriters = new ArrayList<>(); messageWriters.add(new EncoderHttpMessageWriter<>(CharSequenceEncoder.allMimeTypes())); ExchangeStrategies strategies = mock(ExchangeStrategies.class); when(strategies.messageWriters()).thenReturn(messageWriters); MockClientHttpRequest request = new MockClientHttpRequest(GET, "/"); result.writeTo(request, strategies).block(); assertNotNull(request.getBody()); StepVerifier.create(request.getBody()) .expectNextCount(1) .verifyComplete(); }
@Test public void bodyParameterizedTypeReference() { String body = "foo"; Publisher<String> publisher = Mono.just(body); ParameterizedTypeReference<String> typeReference = new ParameterizedTypeReference<String>() {}; ClientRequest result = ClientRequest.create(POST, URI.create("http://example.com")) .body(publisher, typeReference).build(); List<HttpMessageWriter<?>> messageWriters = new ArrayList<>(); messageWriters.add(new EncoderHttpMessageWriter<>(CharSequenceEncoder.allMimeTypes())); ExchangeStrategies strategies = mock(ExchangeStrategies.class); when(strategies.messageWriters()).thenReturn(messageWriters); MockClientHttpRequest request = new MockClientHttpRequest(GET, "/"); result.writeTo(request, strategies).block(); assertNotNull(request.getBody()); StepVerifier.create(request.getBody()) .expectNextCount(1) .verifyComplete(); }
@Test(expected = IllegalArgumentException.class) public void basicAuthenticationInvalidCharacters() { ClientRequest request = ClientRequest.create(HttpMethod.GET, DEFAULT_URL).build(); ExchangeFunction exchange = r -> Mono.just(mock(ClientResponse.class)); ExchangeFilterFunctions.basicAuthentication("foo", "\ud83d\udca9").filter(request, exchange); }
@Test public void bodyInserter() { String body = "foo"; BodyInserter<String, ClientHttpRequest> inserter = (response, strategies) -> { byte[] bodyBytes = body.getBytes(UTF_8); DataBuffer buffer = new DefaultDataBufferFactory().wrap(bodyBytes); return response.writeWith(Mono.just(buffer)); }; ClientRequest result = ClientRequest.create(POST, URI.create("http://example.com")) .body(inserter).build(); List<HttpMessageWriter<?>> messageWriters = new ArrayList<>(); messageWriters.add(new EncoderHttpMessageWriter<>(CharSequenceEncoder.allMimeTypes())); ExchangeStrategies strategies = mock(ExchangeStrategies.class); when(strategies.messageWriters()).thenReturn(messageWriters); MockClientHttpRequest request = new MockClientHttpRequest(GET, "/"); result.writeTo(request, strategies).block(); assertNotNull(request.getBody()); StepVerifier.create(request.getBody()) .expectNextCount(1) .verifyComplete(); }
@Test public void shouldApplyExchangeFilter() { prepareResponse(response -> response.setHeader("Content-Type", "text/plain") .setBody("Hello Spring!")); WebClient filteredClient = this.webClient.mutate() .filter((request, next) -> { ClientRequest filteredRequest = ClientRequest.from(request).header("foo", "bar").build(); return next.exchange(filteredRequest); }) .build(); Mono<String> result = filteredClient.get() .uri("/greeting?name=Spring") .retrieve() .bodyToMono(String.class); StepVerifier.create(result) .expectNext("Hello Spring!") .expectComplete() .verify(Duration.ofSeconds(3)); expectRequestCount(1); expectRequest(request -> assertEquals("bar", request.getHeader("foo"))); }
@Test @SuppressWarnings("deprecation") public void basicAuthenticationAttributes() { ClientRequest request = ClientRequest.create(HttpMethod.GET, DEFAULT_URL) .attributes(org.springframework.web.reactive.function.client.ExchangeFilterFunctions .Credentials.basicAuthenticationCredentials("foo", "bar")) .build(); ClientResponse response = mock(ClientResponse.class); ExchangeFunction exchange = r -> { assertTrue(r.headers().containsKey(HttpHeaders.AUTHORIZATION)); assertTrue(r.headers().getFirst(HttpHeaders.AUTHORIZATION).startsWith("Basic ")); return Mono.just(response); }; ExchangeFilterFunction auth = ExchangeFilterFunctions.basicAuthentication(); assertFalse(request.headers().containsKey(HttpHeaders.AUTHORIZATION)); ClientResponse result = auth.filter(request, exchange).block(); assertEquals(response, result); }
@Test public void apply() { ClientRequest request = ClientRequest.create(HttpMethod.GET, DEFAULT_URL).build(); ClientResponse response = mock(ClientResponse.class); ExchangeFunction exchange = r -> Mono.just(response); boolean[] filterInvoked = new boolean[1]; ExchangeFilterFunction filter = (r, n) -> { assertFalse(filterInvoked[0]); filterInvoked[0] = true; return n.exchange(r); }; ExchangeFunction filteredExchange = filter.apply(exchange); ClientResponse result = filteredExchange.exchange(request).block(); assertEquals(response, result); assertTrue(filterInvoked[0]); }
@Test public void from() throws URISyntaxException { ClientRequest other = ClientRequest.create(GET, URI.create("http://example.com")) .header("foo", "bar") .cookie("baz", "qux").build(); ClientRequest result = ClientRequest.from(other) .headers(httpHeaders -> httpHeaders.set("foo", "baar")) .cookies(cookies -> cookies.set("baz", "quux")) .build(); assertEquals(new URI("http://example.com"), result.url()); assertEquals(GET, result.method()); assertEquals(1, result.headers().size()); assertEquals("baar", result.headers().getFirst("foo")); assertEquals(1, result.cookies().size()); assertEquals("quux", result.cookies().getFirst("baz")); }
@Test public void limitResponseSize() { DefaultDataBufferFactory bufferFactory = new DefaultDataBufferFactory(); DataBuffer b1 = dataBuffer("foo", bufferFactory); DataBuffer b2 = dataBuffer("bar", bufferFactory); DataBuffer b3 = dataBuffer("baz", bufferFactory); ClientRequest request = ClientRequest.create(HttpMethod.GET, DEFAULT_URL).build(); ClientResponse response = ClientResponse.create(HttpStatus.OK).body(Flux.just(b1, b2, b3)).build(); Mono<ClientResponse> result = ExchangeFilterFunctions.limitResponseSize(5) .filter(request, req -> Mono.just(response)); StepVerifier.create(result.flatMapMany(res -> res.body(BodyExtractors.toDataBuffers()))) .consumeNextWith(buffer -> assertEquals("foo", string(buffer))) .consumeNextWith(buffer -> assertEquals("ba", string(buffer))) .expectComplete() .verify(); }
@Test public void captureAndClaim() { ClientHttpRequest request = new MockClientHttpRequest(HttpMethod.GET, "/test"); ClientHttpResponse response = new MockClientHttpResponse(HttpStatus.OK); ClientHttpConnector connector = (method, uri, fn) -> fn.apply(request).then(Mono.just(response)); ClientRequest clientRequest = ClientRequest.create(HttpMethod.GET, URI.create("/test")) .header(WebTestClient.WEBTESTCLIENT_REQUEST_ID, "1").build(); WiretapConnector wiretapConnector = new WiretapConnector(connector); ExchangeFunction function = ExchangeFunctions.create(wiretapConnector); function.exchange(clientRequest).block(ofMillis(0)); WiretapConnector.Info actual = wiretapConnector.claimRequest("1"); ExchangeResult result = actual.createExchangeResult(Duration.ZERO, null); assertEquals(HttpMethod.GET, result.getMethod()); assertEquals("/test", result.getUrl().toString()); }
/** * Return a filter that applies HTTP Basic Authentication to the request * headers via {@link HttpHeaders#setBasicAuth(String, String)}. * @param user the user * @param password the password * @return the filter to add authentication headers with * @see HttpHeaders#setBasicAuth(String, String) * @see HttpHeaders#setBasicAuth(String, String, Charset) */ public static ExchangeFilterFunction basicAuthentication(String user, String password) { return (request, next) -> next.exchange(ClientRequest.from(request) .headers(headers -> headers.setBasicAuth(user, password)) .build()); }
@Test @SuppressWarnings("deprecation") public void basicAuthenticationAbsentAttributes() { ClientRequest request = ClientRequest.create(HttpMethod.GET, DEFAULT_URL).build(); ClientResponse response = mock(ClientResponse.class); ExchangeFunction exchange = r -> { assertFalse(r.headers().containsKey(HttpHeaders.AUTHORIZATION)); return Mono.just(response); }; ExchangeFilterFunction auth = ExchangeFilterFunctions.basicAuthentication(); assertFalse(request.headers().containsKey(HttpHeaders.AUTHORIZATION)); ClientResponse result = auth.filter(request, exchange).block(); assertEquals(response, result); }
@Test public void basicAuthenticationUsernamePassword() { ClientRequest request = ClientRequest.create(HttpMethod.GET, DEFAULT_URL).build(); ClientResponse response = mock(ClientResponse.class); ExchangeFunction exchange = r -> { assertTrue(r.headers().containsKey(HttpHeaders.AUTHORIZATION)); assertTrue(r.headers().getFirst(HttpHeaders.AUTHORIZATION).startsWith("Basic ")); return Mono.just(response); }; ExchangeFilterFunction auth = ExchangeFilterFunctions.basicAuthentication("foo", "bar"); assertFalse(request.headers().containsKey(HttpHeaders.AUTHORIZATION)); ClientResponse result = auth.filter(request, exchange).block(); assertEquals(response, result); }
@Test public void build() { ClientRequest result = ClientRequest.create(GET, URI.create("http://example.com")) .header("MyKey", "MyValue") .cookie("foo", "bar") .build(); MockClientHttpRequest request = new MockClientHttpRequest(GET, "/"); ExchangeStrategies strategies = mock(ExchangeStrategies.class); result.writeTo(request, strategies).block(); assertEquals("MyValue", request.getHeaders().getFirst("MyKey")); assertEquals("bar", request.getCookies().getFirst("foo").getValue()); StepVerifier.create(request.getBody()).expectComplete().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(); }
@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 cookie() { ClientRequest result = ClientRequest.create(GET, URI.create("http://example.com")) .cookie("foo", "bar").build(); assertEquals("bar", result.cookies().getFirst("foo")); }
@Test public void url() throws URISyntaxException { URI url1 = new URI("http://example.com/foo"); URI url2 = new URI("http://example.com/bar"); ClientRequest.Builder builder = ClientRequest.create(DELETE, url1); assertEquals(url1, builder.build().url()); builder.url(url2); assertEquals(url2, builder.build().url()); }