root
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Actions 8 Packages Projects Releases Wiki Activity

Polish

This commit is contained in:
Brian Clozel 2017-09-12 17:52:43 +02:00
parent f4ef5cd451
commit aa19912e00
1 changed files with 183 additions and 216 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

399
spring-webflux/src/test/java/org/springframework/web/reactive/function/client/WebClientIntegrationTests.java
View File

@ -19,13 +19,13 @@ package org.springframework.web.reactive.function.client;
import java.time.Duration;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import okhttp3.mockwebserver.MockResponse;
import okhttp3.mockwebserver.MockWebServer;
import okhttp3.mockwebserver.RecordedRequest;
import org.hamcrest.Matchers;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import reactor.core.publisher.Flux;
@ -39,7 +39,9 @@ import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.http.codec.Pojo;
import static org.junit.Assert.*;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
/**
* Integration tests using a {@link ExchangeFunction} through {@link WebClient}.
@ -56,8 +58,7 @@ public class WebClientIntegrationTests {
@Before
public void setup() {
this.server = new MockWebServer();
String baseUrl = this.server.url("/").toString();
this.webClient = WebClient.create(baseUrl);
this.webClient = WebClient.create(this.server.url("/").toString());
}
@After
@ -65,17 +66,12 @@ public class WebClientIntegrationTests {
this.server.shutdown();
}
@Test
public void headers() throws Exception {
this.server.enqueue(new MockResponse().setHeader("Content-Type", "text/plain").setBody("Hello Spring!"));
public void shouldReceiveResponseHeaders() throws Exception {
prepareResponse(response -> response
.setHeader("Content-Type", "text/plain")
.setBody("Hello Spring!"));
this.webClient.get().uri("/test")
.exchange()
.map(response -> {
response.close();
return response.statusCode();
});
Mono<HttpHeaders> result = this.webClient.get()
.uri("/greeting?name=Spring")
.exchange()
@ -87,18 +83,18 @@ public class WebClientIntegrationTests {
assertEquals(MediaType.TEXT_PLAIN, httpHeaders.getContentType());
assertEquals(13L, httpHeaders.getContentLength());
})
.expectComplete()
.verify(Duration.ofSeconds(3));
.expectComplete().verify(Duration.ofSeconds(3));
RecordedRequest recordedRequest = server.takeRequest();
Assert.assertEquals(1, server.getRequestCount());
Assert.assertEquals("*/*", recordedRequest.getHeader(HttpHeaders.ACCEPT));
Assert.assertEquals("/greeting?name=Spring", recordedRequest.getPath());
expectRequestCount(1);
expectRequest(request -> {
assertEquals("*/*", request.getHeader(HttpHeaders.ACCEPT));
assertEquals("/greeting?name=Spring", request.getPath());
});
}
@Test
public void plainText() throws Exception {
this.server.enqueue(new MockResponse().setBody("Hello Spring!"));
public void shouldReceivePlainText() throws Exception {
prepareResponse(response -> response.setBody("Hello Spring!"));
Mono<String> result = this.webClient.get()
.uri("/greeting?name=Spring")
@ -108,94 +104,69 @@ public class WebClientIntegrationTests {
StepVerifier.create(result)
.expectNext("Hello Spring!")
.expectComplete()
.verify(Duration.ofSeconds(3));
.expectComplete().verify(Duration.ofSeconds(3));
RecordedRequest recordedRequest = server.takeRequest();
Assert.assertEquals(1, server.getRequestCount());
Assert.assertEquals("testvalue", recordedRequest.getHeader("X-Test-Header"));
Assert.assertEquals("*/*", recordedRequest.getHeader(HttpHeaders.ACCEPT));
Assert.assertEquals("/greeting?name=Spring", recordedRequest.getPath());
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 jsonString() throws Exception {
public void shouldReceiveJsonAsString() throws Exception {
String content = "{\"bar\":\"barbar\",\"foo\":\"foofoo\"}";
this.server.enqueue(new MockResponse().setHeader("Content-Type", "application/json")
.setBody(content));
prepareResponse(response -> response
.setHeader("Content-Type", "application/json").setBody(content));
Mono<String> result = this.webClient.get()
.uri("/json")
.accept(MediaType.APPLICATION_JSON)
.exchange()
.flatMap(response -> response.bodyToMono(String.class));
StepVerifier.create(result)
.expectNext(content)
.expectComplete()
.verify(Duration.ofSeconds(3));
RecordedRequest recordedRequest = server.takeRequest();
Assert.assertEquals(1, server.getRequestCount());
Assert.assertEquals("/json", recordedRequest.getPath());
Assert.assertEquals("application/json", recordedRequest.getHeader(HttpHeaders.ACCEPT));
}
@Test
public void jsonStringRetrieveMono() throws Exception {
String content = "{\"bar\":\"barbar\",\"foo\":\"foofoo\"}";
this.server.enqueue(new MockResponse().setHeader("Content-Type", "application/json")
.setBody(content));
Mono<String> result = this.webClient.get()
.uri("/json")
.accept(MediaType.APPLICATION_JSON)
.uri("/json").accept(MediaType.APPLICATION_JSON)
.retrieve()
.bodyToMono(String.class);
StepVerifier.create(result)
.expectNext(content)
.expectComplete()
.verify(Duration.ofSeconds(3));
.expectComplete().verify(Duration.ofSeconds(3));
RecordedRequest recordedRequest = server.takeRequest();
Assert.assertEquals(1, server.getRequestCount());
Assert.assertEquals("/json", recordedRequest.getPath());
Assert.assertEquals("application/json", recordedRequest.getHeader(HttpHeaders.ACCEPT));
expectRequestCount(1);
expectRequest(request -> {
assertEquals("/json", request.getPath());
assertEquals("application/json", request.getHeader(HttpHeaders.ACCEPT));
});
}
@Test
public void jsonStringRetrieveMonoTypeReference() throws Exception {
public void shouldReceiveJsonAsTypeReferenceString() throws Exception {
String content = "{\"bar\":\"barbar\",\"foo\":\"foofoo\"}";
this.server.enqueue(new MockResponse().setHeader("Content-Type", "application/json")
.setBody(content));
prepareResponse(response -> response
.setHeader("Content-Type", "application/json").setBody(content));
Mono<String> result = this.webClient.get()
.uri("/json")
.accept(MediaType.APPLICATION_JSON)
.uri("/json").accept(MediaType.APPLICATION_JSON)
.retrieve()
.bodyToMono(new ParameterizedTypeReference<String>() {});
.bodyToMono(new ParameterizedTypeReference<String>() {
});
StepVerifier.create(result)
.expectNext(content)
.expectComplete()
.verify(Duration.ofSeconds(3));
.expectComplete().verify(Duration.ofSeconds(3));
RecordedRequest recordedRequest = server.takeRequest();
Assert.assertEquals(1, server.getRequestCount());
Assert.assertEquals("/json", recordedRequest.getPath());
Assert.assertEquals("application/json", recordedRequest.getHeader(HttpHeaders.ACCEPT));
expectRequestCount(1);
expectRequest(request -> {
assertEquals("/json", request.getPath());
assertEquals("application/json", request.getHeader(HttpHeaders.ACCEPT));
});
}
@Test
public void jsonStringExchangeEntity() throws Exception {
public void shouldReceiveJsonAsResponseEntityString() throws Exception {
String content = "{\"bar\":\"barbar\",\"foo\":\"foofoo\"}";
this.server.enqueue(new MockResponse().setHeader("Content-Type", "application/json")
.setBody(content));
prepareResponse(response -> response
.setHeader("Content-Type", "application/json").setBody(content));
Mono<ResponseEntity<String>> result = this.webClient.get()
.uri("/json")
.accept(MediaType.APPLICATION_JSON)
.uri("/json").accept(MediaType.APPLICATION_JSON)
.exchange()
.flatMap(response -> response.toEntity(String.class));
@ -206,23 +177,23 @@ public class WebClientIntegrationTests {
assertEquals(31, entity.getHeaders().getContentLength());
assertEquals(content, entity.getBody());
})
.expectComplete()
.verify(Duration.ofSeconds(3));
.expectComplete().verify(Duration.ofSeconds(3));
RecordedRequest recordedRequest = server.takeRequest();
Assert.assertEquals(1, server.getRequestCount());
Assert.assertEquals("/json", recordedRequest.getPath());
Assert.assertEquals("application/json", recordedRequest.getHeader(HttpHeaders.ACCEPT));
expectRequestCount(1);
expectRequest(request -> {
assertEquals("/json", request.getPath());
assertEquals("application/json", request.getHeader(HttpHeaders.ACCEPT));
});
}
@Test
public void jsonStringExchangeEntityList() throws Exception {
public void shouldReceiveJsonAsResponseEntityList() throws Exception {
String content = "[{\"bar\":\"bar1\",\"foo\":\"foo1\"}, {\"bar\":\"bar2\",\"foo\":\"foo2\"}]";
this.server.enqueue(new MockResponse().setHeader("Content-Type", "application/json").setBody(content));
prepareResponse(response -> response
.setHeader("Content-Type", "application/json").setBody(content));
Mono<ResponseEntity<List<Pojo>>> result = this.webClient.get()
.uri("/json")
.accept(MediaType.APPLICATION_JSON)
.uri("/json").accept(MediaType.APPLICATION_JSON)
.exchange()
.flatMap(response -> response.toEntityList(Pojo.class));
@ -235,64 +206,41 @@ public class WebClientIntegrationTests {
Pojo pojo2 = new Pojo("foo2", "bar2");
assertEquals(Arrays.asList(pojo1, pojo2), entity.getBody());
})
.expectComplete()
.verify(Duration.ofSeconds(3));
.expectComplete().verify(Duration.ofSeconds(3));
RecordedRequest recordedRequest = server.takeRequest();
Assert.assertEquals(1, server.getRequestCount());
Assert.assertEquals("/json", recordedRequest.getPath());
Assert.assertEquals("application/json", recordedRequest.getHeader(HttpHeaders.ACCEPT));
expectRequestCount(1);
expectRequest(request -> {
assertEquals("/json", request.getPath());
assertEquals("application/json", request.getHeader(HttpHeaders.ACCEPT));
});
}
@Test
public void jsonStringRetrieveFlux() throws Exception {
public void shouldReceiveJsonAsFluxString() throws Exception {
String content = "{\"bar\":\"barbar\",\"foo\":\"foofoo\"}";
this.server.enqueue(new MockResponse().setHeader("Content-Type", "application/json")
.setBody(content));
prepareResponse(response -> response
.setHeader("Content-Type", "application/json").setBody(content));
Flux<String> result = this.webClient.get()
.uri("/json")
.accept(MediaType.APPLICATION_JSON)
.uri("/json").accept(MediaType.APPLICATION_JSON)
.retrieve()
.bodyToFlux(String.class);
StepVerifier.create(result)
.expectNext(content)
.expectComplete()
.verify(Duration.ofSeconds(3));
.expectComplete().verify(Duration.ofSeconds(3));
RecordedRequest recordedRequest = server.takeRequest();
Assert.assertEquals(1, server.getRequestCount());
Assert.assertEquals("/json", recordedRequest.getPath());
Assert.assertEquals("application/json", recordedRequest.getHeader(HttpHeaders.ACCEPT));
expectRequestCount(1);
expectRequest(request -> {
assertEquals("/json", request.getPath());
assertEquals("application/json", request.getHeader(HttpHeaders.ACCEPT));
});
}
@Test
public void jsonStringRetrieveFluxTypeReference() throws Exception {
String content = "{\"bar\":\"barbar\",\"foo\":\"foofoo\"}";
this.server.enqueue(new MockResponse().setHeader("Content-Type", "application/json")
.setBody(content));
Flux<String> result = this.webClient.get()
.uri("/json")
.accept(MediaType.APPLICATION_JSON)
.retrieve()
.bodyToFlux(new ParameterizedTypeReference<String>() {});
StepVerifier.create(result)
.expectNext(content)
.expectComplete()
.verify(Duration.ofSeconds(3));
RecordedRequest recordedRequest = server.takeRequest();
Assert.assertEquals(1, server.getRequestCount());
Assert.assertEquals("/json", recordedRequest.getPath());
Assert.assertEquals("application/json", recordedRequest.getHeader(HttpHeaders.ACCEPT));
}
@Test
public void jsonPojoMono() throws Exception {
this.server.enqueue(new MockResponse().setHeader("Content-Type", "application/json")
public void shouldReceiveJsonAsPojo() throws Exception {
prepareResponse(response -> response
.setHeader("Content-Type", "application/json")
.setBody("{\"bar\":\"barbar\",\"foo\":\"foofoo\"}"));
Mono<Pojo> result = this.webClient.get()
@ -306,15 +254,17 @@ public class WebClientIntegrationTests {
.expectComplete()
.verify(Duration.ofSeconds(3));
RecordedRequest recordedRequest = server.takeRequest();
Assert.assertEquals(1, server.getRequestCount());
Assert.assertEquals("/pojo", recordedRequest.getPath());
Assert.assertEquals("application/json", recordedRequest.getHeader(HttpHeaders.ACCEPT));
expectRequestCount(1);
expectRequest(request -> {
assertEquals("/pojo", request.getPath());
assertEquals("application/json", request.getHeader(HttpHeaders.ACCEPT));
});
}
@Test
public void jsonPojoFlux() throws Exception {
this.server.enqueue(new MockResponse().setHeader("Content-Type", "application/json")
public void shouldReceiveJsonAsFluxPojo() throws Exception {
prepareResponse(response -> response
.setHeader("Content-Type", "application/json")
.setBody("[{\"bar\":\"bar1\",\"foo\":\"foo1\"},{\"bar\":\"bar2\",\"foo\":\"foo2\"}]"));
Flux<Pojo> result = this.webClient.get()
@ -329,16 +279,16 @@ public class WebClientIntegrationTests {
.expectComplete()
.verify(Duration.ofSeconds(3));
RecordedRequest recordedRequest = server.takeRequest();
Assert.assertEquals(1, server.getRequestCount());
Assert.assertEquals("/pojos", recordedRequest.getPath());
Assert.assertEquals("application/json", recordedRequest.getHeader(HttpHeaders.ACCEPT));
expectRequestCount(1);
expectRequest(request -> {
assertEquals("/pojos", request.getPath());
assertEquals("application/json", request.getHeader(HttpHeaders.ACCEPT));
});
}
@Test
public void postJsonPojo() throws Exception {
this.server.enqueue(new MockResponse()
.setHeader("Content-Type", "application/json")
public void shouldSendPojoAsJson() throws Exception {
prepareResponse(response -> response.setHeader("Content-Type", "application/json")
.setBody("{\"bar\":\"BARBAR\",\"foo\":\"FOOFOO\"}"));
Mono<Pojo> result = this.webClient.post()
@ -354,18 +304,19 @@ public class WebClientIntegrationTests {
.expectComplete()
.verify(Duration.ofSeconds(3));
RecordedRequest recordedRequest = server.takeRequest();
Assert.assertEquals(1, server.getRequestCount());
Assert.assertEquals("/pojo/capitalize", recordedRequest.getPath());
Assert.assertEquals("{\"foo\":\"foofoo\",\"bar\":\"barbar\"}", recordedRequest.getBody().readUtf8());
Assert.assertEquals("chunked", recordedRequest.getHeader(HttpHeaders.TRANSFER_ENCODING));
Assert.assertEquals("application/json", recordedRequest.getHeader(HttpHeaders.ACCEPT));
Assert.assertEquals("application/json", recordedRequest.getHeader(HttpHeaders.CONTENT_TYPE));
expectRequestCount(1);
expectRequest(request -> {
assertEquals("/pojo/capitalize", request.getPath());
assertEquals("{\"foo\":\"foofoo\",\"bar\":\"barbar\"}", request.getBody().readUtf8());
assertEquals("chunked", request.getHeader(HttpHeaders.TRANSFER_ENCODING));
assertEquals("application/json", request.getHeader(HttpHeaders.ACCEPT));
assertEquals("application/json", request.getHeader(HttpHeaders.CONTENT_TYPE));
});
}
@Test
public void cookies() throws Exception {
this.server.enqueue(new MockResponse()
public void shouldSendCookies() throws Exception {
prepareResponse(response -> response
.setHeader("Content-Type", "text/plain").setBody("test"));
Mono<String> result = this.webClient.get()
@ -379,15 +330,16 @@ public class WebClientIntegrationTests {
.expectComplete()
.verify(Duration.ofSeconds(3));
RecordedRequest recordedRequest = server.takeRequest();
Assert.assertEquals(1, server.getRequestCount());
Assert.assertEquals("/test", recordedRequest.getPath());
Assert.assertEquals("testkey=testvalue", recordedRequest.getHeader(HttpHeaders.COOKIE));
expectRequestCount(1);
expectRequest(request -> {
assertEquals("/test", request.getPath());
assertEquals("testkey=testvalue", request.getHeader(HttpHeaders.COOKIE));
});
}
@Test
public void exchangeNotFound() throws Exception {
this.server.enqueue(new MockResponse().setResponseCode(404)
public void shouldReceive404Response() throws Exception {
prepareResponse(response -> response.setResponseCode(404)
.setHeader("Content-Type", "text/plain").setBody("Not Found"));
Mono<ClientResponse> result = this.webClient.get().uri("/greeting?name=Spring").exchange();
@ -397,15 +349,16 @@ public class WebClientIntegrationTests {
.expectComplete()
.verify(Duration.ofSeconds(3));
RecordedRequest recordedRequest = server.takeRequest();
Assert.assertEquals(1, server.getRequestCount());
Assert.assertEquals("*/*", recordedRequest.getHeader(HttpHeaders.ACCEPT));
Assert.assertEquals("/greeting?name=Spring", recordedRequest.getPath());
expectRequestCount(1);
expectRequest(request -> {
assertEquals("*/*", request.getHeader(HttpHeaders.ACCEPT));
assertEquals("/greeting?name=Spring", request.getPath());
});
}
@Test
public void retrieveBodyToMonoNotFound() throws Exception {
this.server.enqueue(new MockResponse().setResponseCode(404)
public void shouldGetErrorSignalOn404() throws Exception {
prepareResponse(response -> response.setResponseCode(404)
.setHeader("Content-Type", "text/plain").setBody("Not Found"));
Mono<String> result = this.webClient.get()
@ -417,16 +370,17 @@ public class WebClientIntegrationTests {
.expectError(WebClientException.class)
.verify(Duration.ofSeconds(3));
RecordedRequest recordedRequest = server.takeRequest();
Assert.assertEquals(1, server.getRequestCount());
Assert.assertEquals("*/*", recordedRequest.getHeader(HttpHeaders.ACCEPT));
Assert.assertEquals("/greeting?name=Spring", recordedRequest.getPath());
expectRequestCount(1);
expectRequest(request -> {
assertEquals("*/*", request.getHeader(HttpHeaders.ACCEPT));
assertEquals("/greeting?name=Spring", request.getPath());
});
}
@Test
public void retrieveBodyToMonoInternalServerError() throws Exception {
public void shouldGetInternalServerErrorSignal() throws Exception {
String errorMessage = "Internal Server error";
this.server.enqueue(new MockResponse().setResponseCode(500)
prepareResponse(response -> response.setResponseCode(500)
.setHeader("Content-Type", "text/plain").setBody(errorMessage));
Mono<String> result = this.webClient.get()
@ -438,22 +392,22 @@ public class WebClientIntegrationTests {
.expectErrorSatisfies(throwable -> {
assertTrue(throwable instanceof WebClientResponseException);
WebClientResponseException ex = (WebClientResponseException) throwable;
assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, ex.getStatusCode());
assertEquals(MediaType.TEXT_PLAIN, ex.getHeaders().getContentType());
assertEquals(errorMessage, ex.getResponseBodyAsString());
})
.verify(Duration.ofSeconds(3));
RecordedRequest recordedRequest = server.takeRequest();
Assert.assertEquals(1, server.getRequestCount());
Assert.assertEquals("*/*", recordedRequest.getHeader(HttpHeaders.ACCEPT));
Assert.assertEquals("/greeting?name=Spring", recordedRequest.getPath());
expectRequestCount(1);
expectRequest(request -> {
assertEquals("*/*", request.getHeader(HttpHeaders.ACCEPT));
assertEquals("/greeting?name=Spring", request.getPath());
});
}
@Test
public void retrieveBodyToCustomStatusHandler() throws Exception {
this.server.enqueue(new MockResponse().setResponseCode(500)
public void shouldApplyCustomStatusHandler() throws Exception {
prepareResponse(response -> response.setResponseCode(500)
.setHeader("Content-Type", "text/plain").setBody("Internal Server error"));
Mono<String> result = this.webClient.get()
@ -466,15 +420,16 @@ public class WebClientIntegrationTests {
.expectError(MyException.class)
.verify(Duration.ofSeconds(3));
RecordedRequest recordedRequest = server.takeRequest();
Assert.assertEquals(1, server.getRequestCount());
Assert.assertEquals("*/*", recordedRequest.getHeader(HttpHeaders.ACCEPT));
Assert.assertEquals("/greeting?name=Spring", recordedRequest.getPath());
expectRequestCount(1);
expectRequest(request -> {
assertEquals("*/*", request.getHeader(HttpHeaders.ACCEPT));
assertEquals("/greeting?name=Spring", request.getPath());
});
}
@Test
public void exchangeToEntityNotFound() throws Exception {
this.server.enqueue(new MockResponse().setResponseCode(404)
public void shouldReceiveNotFoundEntity() throws Exception {
prepareResponse(response -> response.setResponseCode(404)
.setHeader("Content-Type", "text/plain").setBody("Not Found"));
Mono<ResponseEntity<String>> result = this.webClient.get()
@ -487,15 +442,16 @@ public class WebClientIntegrationTests {
.expectComplete()
.verify(Duration.ofSeconds(3));
RecordedRequest recordedRequest = server.takeRequest();
Assert.assertEquals(1, server.getRequestCount());
Assert.assertEquals("*/*", recordedRequest.getHeader(HttpHeaders.ACCEPT));
Assert.assertEquals("/greeting?name=Spring", recordedRequest.getPath());
expectRequestCount(1);
expectRequest(request -> {
assertEquals("*/*", request.getHeader(HttpHeaders.ACCEPT));
assertEquals("/greeting?name=Spring", request.getPath());
});
}
@Test
public void filter() throws Exception {
this.server.enqueue(new MockResponse().setHeader("Content-Type", "text/plain")
public void shouldApplyExchangeFilter() throws Exception {
prepareResponse(response -> response.setHeader("Content-Type", "text/plain")
.setBody("Hello Spring!"));
WebClient filteredClient = this.webClient.mutate()
@ -516,29 +472,29 @@ public class WebClientIntegrationTests {
.expectComplete()
.verify(Duration.ofSeconds(3));
RecordedRequest recordedRequest = server.takeRequest();
Assert.assertEquals(1, server.getRequestCount());
Assert.assertEquals("bar", recordedRequest.getHeader("foo"));
expectRequestCount(1);
expectRequest(request -> {
assertEquals("bar", request.getHeader("foo"));
});
}
@Test
public void errorHandlingFilter() throws Exception {
public void shouldApplyErrorHandlingFilter() throws Exception {
ExchangeFilterFunction filter = ExchangeFilterFunction.ofResponseProcessor(
clientResponse -> {
List<String> headerValues = clientResponse.headers().header("Foo");
return headerValues.isEmpty() ? Mono.error(
new MyException("Response does not contain Foo header")) :
Mono.just(clientResponse);
}
);
clientResponse -> {
List<String> headerValues = clientResponse.headers().header("Foo");
return headerValues.isEmpty() ? Mono.error(
new MyException("Response does not contain Foo header")) :
Mono.just(clientResponse);
}
);
WebClient filteredClient = this.webClient.mutate()
.filter(filter)
.build();
WebClient filteredClient = this.webClient.mutate().filter(filter).build();
// header not present
this.server.enqueue(new MockResponse().setHeader("Content-Type", "text/plain").setBody("Hello Spring!"));
prepareResponse(response -> response
.setHeader("Content-Type", "text/plain").setBody("Hello Spring!"));
Mono<String> result = filteredClient.get()
.uri("/greeting?name=Spring")
@ -546,31 +502,28 @@ public class WebClientIntegrationTests {
.bodyToMono(String.class);
StepVerifier.create(result)
.expectError(MyException.class)
.verify(Duration.ofSeconds(3));
.expectError(MyException.class).verify(Duration.ofSeconds(3));
// header present
this.server.enqueue(new MockResponse().setHeader("Content-Type", "text/plain")
prepareResponse(response -> response.setHeader("Content-Type", "text/plain")
.setHeader("Foo", "Bar")
.setBody("Hello Spring!"));
result = filteredClient.get()
.uri("/greeting?name=Spring")
.retrieve()
.bodyToMono(String.class);
.retrieve().bodyToMono(String.class);
StepVerifier.create(result)
.expectNext("Hello Spring!")
.expectComplete()
.verify(Duration.ofSeconds(3));
.expectComplete().verify(Duration.ofSeconds(3));
Assert.assertEquals(2, server.getRequestCount());
expectRequestCount(2);
}
@Test
public void exchangeNoContent() throws Exception {
this.server.enqueue(new MockResponse().setHeader("Content-Length", "0"));
public void shouldReceiveEmptyResponse() throws Exception {
prepareResponse(response -> response.setHeader("Content-Length", "0"));
Mono<ClientResponse> result = this.webClient.get()
.uri("/noContent")
@ -583,7 +536,7 @@ public class WebClientIntegrationTests {
}
@Test // SPR-15782
public void absoluteUri() throws Exception {
public void shouldFailWithRelativeUrls() throws Exception {
String uri = "/api/v4/groups/1";
Mono<ClientResponse> responseMono = WebClient.builder().build().get().uri(uri).exchange();
@ -592,6 +545,20 @@ public class WebClientIntegrationTests {
.verify(Duration.ofSeconds(5));
}
private void prepareResponse(Consumer<MockResponse> consumer) {
MockResponse response = new MockResponse();
consumer.accept(response);
this.server.enqueue(response);
}
private void expectRequest(Consumer<RecordedRequest> consumer) throws InterruptedException {
consumer.accept(this.server.takeRequest());
}
private void expectRequestCount(int count) {
assertEquals(count, this.server.getRequestCount());
}
@SuppressWarnings("serial")
private static class MyException extends RuntimeException {