spring/spring-framework
1
0
Fork 0
mirror of https://github.com/spring-projects/spring-framework.git synced 2026-09-17 16:39:29 +00:00
Code Issues Projects Releases Wiki Activity

Upgrade tests to OkHttp 5.x

Browse Source 
See https://square.github.io/okhttp/changelogs/changelog/#version-500.

Closes gh-35183
This commit is contained in:
Sébastien Deleuze
2025-07-15 16:20:07 +02:00
parent b76e748ecf
commit 19086835a7
20 changed files with 838 additions and 818 deletions
Download Patch File Download Diff File Expand all files Collapse all files
framework-platform/framework-platform.gradle
+1 -1
View File
@@ -37,7 +37,7 @@ dependencies {
api("com.networknt:json-schema-validator:1.5.3")
api("com.oracle.database.jdbc:ojdbc11:21.9.0.0")
api("com.rometools:rome:1.19.0")
api("com.squareup.okhttp3:mockwebserver:3.14.9")
api("com.squareup.okhttp3:mockwebserver3:5.1.0")
api("com.sun.activation:jakarta.activation:2.0.1")
api("com.sun.xml.bind:jaxb-core:3.0.2")
api("com.sun.xml.bind:jaxb-impl:3.0.2")
spring-core/spring-core.gradle
+1 -1
View File
@@ -96,7 +96,7 @@ dependencies {
testImplementation("com.fasterxml.jackson.core:jackson-databind")
testImplementation("com.fasterxml.woodstox:woodstox-core")
testImplementation("com.google.code.findbugs:jsr305")
testImplementation("com.squareup.okhttp3:mockwebserver")
testImplementation("com.squareup.okhttp3:mockwebserver3")
testImplementation("io.projectreactor:reactor-test")
testImplementation("io.projectreactor.tools:blockhound")
testImplementation("jakarta.annotation:jakarta.annotation-api")
spring-core/src/test/java/org/springframework/core/io/ResourceTests.java
+20 -18
View File
@@ -37,10 +37,10 @@ import java.util.Base64;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.stream.Stream;
import okhttp3.mockwebserver.Dispatcher;
import okhttp3.mockwebserver.MockResponse;
import okhttp3.mockwebserver.MockWebServer;
import okhttp3.mockwebserver.RecordedRequest;
import mockwebserver3.Dispatcher;
import mockwebserver3.MockResponse;
import mockwebserver3.MockWebServer;
import mockwebserver3.RecordedRequest;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
@@ -419,7 +419,7 @@ class ResourceTests {
assertThat(resource.exists()).isTrue();
RecordedRequest request = this.server.takeRequest();
assertThat(request.getMethod()).isEqualTo("HEAD");
assertThat(request.getHeader("Framework-Name")).isEqualTo("Spring");
assertThat(request.getHeaders().get("Framework-Name")).isEqualTo("Spring");
}
@Test
@@ -429,7 +429,7 @@ class ResourceTests {
assertThat(resource.exists()).isTrue();
RecordedRequest request = this.server.takeRequest();
assertThat(request.getMethod()).isEqualTo("HEAD");
assertThat(request.getHeader("Framework-Name")).isEqualTo("Spring");
assertThat(request.getHeaders().get("Framework-Name")).isEqualTo("Spring");
}
@Test
@@ -439,7 +439,7 @@ class ResourceTests {
assertThat(resource.getInputStream()).hasContent("Spring");
RecordedRequest request = this.server.takeRequest();
assertThat(request.getMethod()).isEqualTo("GET");
assertThat(request.getHeader("Framework-Name")).isEqualTo("Spring");
assertThat(request.getHeaders().get("Framework-Name")).isEqualTo("Spring");
}
@Test
@@ -449,15 +449,15 @@ class ResourceTests {
"http://alice:secret@localhost:" + this.server.getPort() + "/resource");
assertThat(resource.getInputStream()).hasContent("Spring");
RecordedRequest request = this.server.takeRequest();
String authorization = request.getHeader("Authorization");
String authorization = request.getHeaders().get("Authorization");
assertThat(authorization).isNotNull().startsWith("Basic ");
assertThat(new String(Base64.getDecoder().decode(authorization.substring(6)),
StandardCharsets.ISO_8859_1)).isEqualTo("alice:secret");
}
@AfterEach
void shutdown() throws Exception {
this.server.shutdown();
void shutdown() {
this.server.close();
}
private String startServer(boolean withHeadSupport) throws Exception {
@@ -488,23 +488,25 @@ class ResourceTests {
@Override
public MockResponse dispatch(RecordedRequest request) {
if (request.getPath().equals("/resource")) {
if (request.getTarget().equals("/resource")) {
return switch (request.getMethod()) {
case "HEAD" -> (this.withHeadSupport ?
new MockResponse()
new MockResponse.Builder()
.addHeader("Content-Type", "text/plain")
.addHeader("Content-Length", "6")
.addHeader("Last-Modified", LAST_MODIFIED) :
new MockResponse().setResponseCode(405));
case "GET" -> new MockResponse()
.addHeader("Last-Modified", LAST_MODIFIED)
.build() :
new MockResponse.Builder().code(405).build());
case "GET" -> new MockResponse.Builder()
.addHeader("Content-Type", "text/plain")
.addHeader("Content-Length", "6")
.addHeader("Last-Modified", LAST_MODIFIED)
.setBody("Spring");
default -> new MockResponse().setResponseCode(404);
.body("Spring")
.build();
default -> new MockResponse.Builder().code(404).build();
};
}
return new MockResponse().setResponseCode(404);
return new MockResponse.Builder().code(404).build();
}
}
}
spring-web/spring-web.gradle
+1 -1
View File
@@ -82,7 +82,7 @@ dependencies {
testImplementation("com.fasterxml.jackson.module:jackson-module-kotlin")
testImplementation("com.fasterxml.jackson.module:jackson-module-parameter-names")
testImplementation("com.fasterxml.jackson.dataformat:jackson-dataformat-csv")
testImplementation("com.squareup.okhttp3:mockwebserver")
testImplementation("com.squareup.okhttp3:mockwebserver3")
testImplementation("io.micrometer:micrometer-observation-test")
testImplementation("io.projectreactor:reactor-test")
testImplementation("io.projectreactor.tools:blockhound")
spring-web/src/test/java/org/springframework/http/client/AbstractMockWebServerTests.java
+39 -38
View File
@@ -16,10 +16,10 @@
package org.springframework.http.client;
import okhttp3.mockwebserver.Dispatcher;
import okhttp3.mockwebserver.MockResponse;
import okhttp3.mockwebserver.MockWebServer;
import okhttp3.mockwebserver.RecordedRequest;
import mockwebserver3.Dispatcher;
import mockwebserver3.MockResponse;
import mockwebserver3.MockWebServer;
import mockwebserver3.RecordedRequest;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
@@ -49,8 +49,8 @@ public abstract class AbstractMockWebServerTests {
}
@AfterEach
void tearDown() throws Exception {
this.server.shutdown();
void tearDown() {
this.server.close();
}
@@ -59,56 +59,57 @@ public abstract class AbstractMockWebServerTests {
@Override
public MockResponse dispatch(RecordedRequest request) {
try {
if (request.getPath().equals("/echo")) {
assertThat(request.getHeader("Host")).contains("localhost:" + port);
MockResponse response = new MockResponse()
.setHeaders(request.getHeaders())
.setHeader("Content-Length", request.getBody().size())
.setResponseCode(200)
.setBody(request.getBody());
request.getBody().flush();
return response;
if (request.getTarget().equals("/echo")) {
assertThat(request.getHeaders().get("Host")).contains("localhost:" + port);
MockResponse.Builder builder = new MockResponse.Builder().headers(request.getHeaders());
if (request.getBody() != null) {
builder = builder.body(request.getBody().utf8());
}
else {
builder.setHeader("Content-Length", 0);
}
return builder.code(200).build();
}
else if(request.getPath().equals("/status/ok")) {
return new MockResponse();
else if(request.getTarget().equals("/status/ok")) {
return new MockResponse.Builder().build();
}
else if(request.getPath().equals("/status/notfound")) {
return new MockResponse().setResponseCode(404);
else if(request.getTarget().equals("/status/notfound")) {
return new MockResponse.Builder().code(404).build();
}
else if (request.getPath().equals("/status/299")) {
assertThat(request.getHeader("Expect")).contains("299");
return new MockResponse().setResponseCode(299);
else if (request.getTarget().equals("/status/299")) {
assertThat(request.getHeaders().get("Expect")).contains("299");
return new MockResponse.Builder().code(299).build();
}
else if(request.getPath().startsWith("/params")) {
assertThat(request.getPath()).contains("param1=value");
assertThat(request.getPath()).contains("param2=value1&param2=value2");
return new MockResponse();
else if(request.getTarget().startsWith("/params")) {
assertThat(request.getTarget()).contains("param1=value");
assertThat(request.getTarget()).contains("param2=value1&param2=value2");
return new MockResponse.Builder().build();
}
else if(request.getPath().equals("/methods/post")) {
else if(request.getTarget().equals("/methods/post")) {
assertThat(request.getMethod()).isEqualTo("POST");
String transferEncoding = request.getHeader("Transfer-Encoding");
String transferEncoding = request.getHeaders().get("Transfer-Encoding");
if(StringUtils.hasLength(transferEncoding)) {
assertThat(transferEncoding).isEqualTo("chunked");
}
else {
long contentLength = Long.parseLong(request.getHeader("Content-Length"));
long contentLength = Long.parseLong(request.getHeaders().get("Content-Length"));
assertThat(request.getBody().size()).isEqualTo(contentLength);
}
return new MockResponse().setResponseCode(200);
return new MockResponse.Builder().code(200).build();
}
else if(request.getPath().startsWith("/methods/")) {
String expectedMethod = request.getPath().replace("/methods/","").toUpperCase();
else if(request.getTarget().startsWith("/methods/")) {
String expectedMethod = request.getTarget().replace("/methods/","").toUpperCase();
assertThat(request.getMethod()).isEqualTo(expectedMethod);
return new MockResponse();
return new MockResponse.Builder().build();
}
else if(request.getPath().startsWith("/header/")) {
String headerName = request.getPath().replace("/header/","");
return new MockResponse().setBody(headerName + ":" + request.getHeader(headerName)).setResponseCode(200);
else if(request.getTarget().startsWith("/header/")) {
String headerName = request.getTarget().replace("/header/","");
return new MockResponse.Builder().body(headerName + ":" + request.getHeaders().get(headerName)).code(200).build();
}
return new MockResponse().setResponseCode(404);
return new MockResponse.Builder().code(404).build();
}
catch (Throwable ex) {
return new MockResponse().setResponseCode(500).setBody(ex.toString());
return new MockResponse.Builder().code(500).body(ex.toString()).build();
}
}
}
spring-web/src/test/java/org/springframework/http/client/reactive/ClientHttpConnectorTests.java
+26 -30
View File
@@ -34,10 +34,11 @@ import java.util.Random;
import java.util.Set;
import java.util.concurrent.CountDownLatch;
import java.util.function.Consumer;
import java.util.function.Function;
import okhttp3.mockwebserver.MockResponse;
import okhttp3.mockwebserver.MockWebServer;
import okhttp3.mockwebserver.RecordedRequest;
import mockwebserver3.MockResponse;
import mockwebserver3.MockWebServer;
import mockwebserver3.RecordedRequest;
import okio.Buffer;
import org.apache.hc.client5.http.impl.async.HttpAsyncClientBuilder;
import org.junit.jupiter.api.AfterEach;
@@ -84,8 +85,8 @@ class ClientHttpConnectorTests {
}
@AfterEach
void stopServer() throws IOException {
server.shutdown();
void stopServer() {
server.close();
}
// Do not auto-close arguments since HttpComponentsClientHttpConnector implements
@@ -96,11 +97,10 @@ class ClientHttpConnectorTests {
URI uri = this.server.url("/").uri();
String responseBody = "bar\r\n";
prepareResponse(response -> {
response.setResponseCode(200);
response.addHeader("Baz", "Qux");
response.setBody(responseBody);
});
prepareResponse(builder -> builder
.code(200)
.addHeader("Baz", "Qux")
.body(responseBody));
String requestBody = "foo\r\n";
boolean requestHasBody = METHODS_WITH_BODY.contains(method);
@@ -144,9 +144,9 @@ class ClientHttpConnectorTests {
expectRequest(request -> {
assertThat(request.getMethod()).isEqualTo(method.name());
assertThat(request.getHeader("Foo")).isEqualTo("Bar");
assertThat(request.getHeaders().get("Foo")).isEqualTo("Bar");
if (requestHasBody) {
assertThat(request.getBody().readUtf8()).isEqualTo(requestBody);
assertThat(request.getBody().utf8()).isEqualTo(requestBody);
}
});
}
@@ -158,7 +158,7 @@ class ClientHttpConnectorTests {
stringBuffer("foo"),
Mono.error(error)
);
prepareResponse(response -> response.setResponseCode(200));
prepareResponse(builder -> builder.code(200));
Mono<ClientHttpResponse> futureResponse =
connector.connect(HttpMethod.POST, this.server.url("/").uri(), request -> request.writeWith(body));
StepVerifier.create(futureResponse)
@@ -169,7 +169,7 @@ class ClientHttpConnectorTests {
@ParameterizedConnectorTest
void cancelResponseBody(ClientHttpConnector connector) {
Buffer responseBody = randomBody(100);
prepareResponse(response -> response.setBody(responseBody));
prepareResponse(builder -> builder.body(responseBody));
ClientHttpResponse response = connector.connect(HttpMethod.POST, this.server.url("/").uri(),
ReactiveHttpOutputMessage::setComplete).block();
@@ -187,10 +187,9 @@ class ClientHttpConnectorTests {
ZonedDateTime tomorrow = ZonedDateTime.now(ZoneId.of("UTC")).plusDays(1);
String formattedDate = tomorrow.format(DateTimeFormatter.RFC_1123_DATE_TIME);
prepareResponse(response -> {
response.setResponseCode(200);
response.addHeader("Set-Cookie", "id=test; Expires= " + formattedDate + ";");
});
prepareResponse(builder -> builder
.code(200)
.addHeader("Set-Cookie", "id=test; Expires= " + formattedDate + ";"));
Mono<ClientHttpResponse> futureResponse =
connector.connect(HttpMethod.GET, this.server.url("/").uri(), ReactiveHttpOutputMessage::setComplete);
StepVerifier.create(futureResponse)
@@ -206,10 +205,9 @@ class ClientHttpConnectorTests {
void partitionedCookieSupport(ClientHttpConnector connector) {
Assumptions.assumeFalse(connector instanceof JettyClientHttpConnector, "Jetty client does not support partitioned cookies");
Assumptions.assumeFalse(connector instanceof JdkClientHttpConnector, "JDK client does not support partitioned cookies");
prepareResponse(response -> {
response.setResponseCode(200);
response.addHeader("Set-Cookie", "id=test; Partitioned;");
});
prepareResponse(builder -> builder
.code(200)
.addHeader("Set-Cookie", "id=test; Partitioned;"));
Mono<ClientHttpResponse> futureResponse =
connector.connect(HttpMethod.GET, this.server.url("/").uri(), ReactiveHttpOutputMessage::setComplete);
StepVerifier.create(futureResponse)
@@ -227,10 +225,9 @@ class ClientHttpConnectorTests {
HttpAsyncClientBuilder.create().disableCookieManagement().build()
);
prepareResponse(response -> {
response.setResponseCode(200);
response.addHeader("Set-Cookie", "id=test;");
});
prepareResponse(builder -> builder
.code(200)
.addHeader("Set-Cookie", "id=test;"));
Mono<ClientHttpResponse> futureResponse =
connector.connect(HttpMethod.GET, this.server.url("/").uri(), ReactiveHttpOutputMessage::setComplete);
StepVerifier.create(futureResponse)
@@ -254,10 +251,9 @@ class ClientHttpConnectorTests {
return responseBody;
}
private void prepareResponse(Consumer<MockResponse> consumer) {
MockResponse response = new MockResponse();
consumer.accept(response);
this.server.enqueue(response);
private void prepareResponse(Function<MockResponse.Builder, MockResponse.Builder> f) {
MockResponse.Builder builder = new MockResponse.Builder();
this.server.enqueue(f.apply(builder).build());
}
private void expectRequest(Consumer<RecordedRequest> consumer) {
spring-web/src/test/java/org/springframework/web/client/AbstractMockWebServerTests.java
+83 -74
View File
@@ -21,11 +21,12 @@ import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.Collections;
import okhttp3.mockwebserver.Dispatcher;
import okhttp3.mockwebserver.MockResponse;
import okhttp3.mockwebserver.MockWebServer;
import okhttp3.mockwebserver.RecordedRequest;
import mockwebserver3.Dispatcher;
import mockwebserver3.MockResponse;
import mockwebserver3.MockWebServer;
import mockwebserver3.RecordedRequest;
import okio.Buffer;
import org.jspecify.annotations.Nullable;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
@@ -68,96 +69,102 @@ abstract class AbstractMockWebServerTests {
@AfterEach
void tearDown() throws Exception {
this.server.shutdown();
this.server.close();
}
private MockResponse getRequest(RecordedRequest request, byte[] body, String contentType) {
private MockResponse getRequest(RecordedRequest request, byte[] body, @Nullable String contentType) {
if (request.getMethod().equals("OPTIONS")) {
return new MockResponse().setResponseCode(200).setHeader("Allow", "GET, OPTIONS, HEAD, TRACE");
return new MockResponse.Builder().code(200).setHeader("Allow", "GET, OPTIONS, HEAD, TRACE").build();
}
Buffer buf = new Buffer();
buf.write(body);
MockResponse response = new MockResponse()
MockResponse.Builder builder = new MockResponse.Builder()
.setHeader(CONTENT_LENGTH, body.length)
.setBody(buf)
.setResponseCode(200);
.body(buf)
.code(200);
if (contentType != null) {
response = response.setHeader(CONTENT_TYPE, contentType);
return builder.setHeader(CONTENT_TYPE, contentType).build();
}
else {
return builder.build();
}
return response;
}
private MockResponse postRequest(RecordedRequest request, String expectedRequestContent,
String location, String contentType, byte[] responseBody) {
assertThat(request.getHeaders().values(CONTENT_LENGTH)).hasSize(1);
assertThat(Integer.parseInt(request.getHeader(CONTENT_LENGTH))).as("Invalid request content-length").isGreaterThan(0);
String requestContentType = request.getHeader(CONTENT_TYPE);
assertThat(Integer.parseInt(request.getHeaders().get(CONTENT_LENGTH))).as("Invalid request content-length").isGreaterThan(0);
String requestContentType = request.getHeaders().get(CONTENT_TYPE);
assertThat(requestContentType).as("No content-type").isNotNull();
Charset charset = StandardCharsets.ISO_8859_1;
if (requestContentType.contains("charset=")) {
String charsetName = requestContentType.split("charset=")[1];
charset = Charset.forName(charsetName);
}
assertThat(request.getBody().readString(charset)).as("Invalid request body").isEqualTo(expectedRequestContent);
assertThat(request.getBody().string(charset)).as("Invalid request body").isEqualTo(expectedRequestContent);
Buffer buf = new Buffer();
buf.write(responseBody);
return new MockResponse()
return new MockResponse.Builder()
.setHeader(LOCATION, baseUrl + location)
.setHeader(CONTENT_TYPE, contentType)
.setHeader(CONTENT_LENGTH, responseBody.length)
.setBody(buf)
.setResponseCode(201);
.body(buf)
.code(201)
.build();
}
private MockResponse jsonPostRequest(RecordedRequest request, String location, String contentType) {
if (request.getBodySize() > 0) {
String contentLength = request.getHeader(CONTENT_LENGTH);
String contentLength = request.getHeaders().get(CONTENT_LENGTH);
if (contentLength != null) {
assertThat(Integer.parseInt(contentLength)).as("Invalid request content-length").isGreaterThan(0);
}
assertThat(request.getHeader(CONTENT_TYPE)).as("No content-type").isNotNull();
assertThat(request.getHeaders().get(CONTENT_TYPE)).as("No content-type").isNotNull();
}
return new MockResponse()
return new MockResponse.Builder()
.setHeader(LOCATION, baseUrl + location)
.setHeader(CONTENT_TYPE, contentType)
.setHeader(CONTENT_LENGTH, request.getBody().size())
.setBody(request.getBody())
.setResponseCode(201);
.body(request.getBody().utf8())
.code(201)
.build();
}
private MockResponse multipartFormDataRequest(RecordedRequest request) {
MediaType mediaType = MediaType.parseMediaType(request.getHeader(CONTENT_TYPE));
MediaType mediaType = MediaType.parseMediaType(request.getHeaders().get(CONTENT_TYPE));
assertThat(mediaType.isCompatibleWith(MULTIPART_FORM_DATA)).as(MULTIPART_FORM_DATA.toString()).isTrue();
assertMultipart(request, mediaType);
return new MockResponse().setResponseCode(200);
return new MockResponse.Builder().code(200).build();
}
private MockResponse multipartMixedRequest(RecordedRequest request) {
MediaType mediaType = MediaType.parseMediaType(request.getHeader(CONTENT_TYPE));
MediaType mediaType = MediaType.parseMediaType(request.getHeaders().get(CONTENT_TYPE));
assertThat(mediaType.isCompatibleWith(MULTIPART_MIXED)).as(MULTIPART_MIXED.toString()).isTrue();
assertMultipart(request, mediaType);
return new MockResponse().setResponseCode(200);
return new MockResponse.Builder().code(200).build();
}
private MockResponse multipartRelatedRequest(RecordedRequest request) {
MediaType mediaType = MediaType.parseMediaType(request.getHeader(CONTENT_TYPE));
MediaType mediaType = MediaType.parseMediaType(request.getHeaders().get(CONTENT_TYPE));
assertThat(mediaType.isCompatibleWith(MULTIPART_RELATED)).as(MULTIPART_RELATED.toString()).isTrue();
assertMultipart(request, mediaType);
return new MockResponse().setResponseCode(200);
return new MockResponse.Builder().code(200).build();
}
private void assertMultipart(RecordedRequest request, MediaType mediaType) {
assertThat(mediaType.isCompatibleWith(new MediaType("multipart", "*"))).as("multipart/*").isTrue();
String boundary = mediaType.getParameter("boundary");
assertThat(boundary).as("boundary").isNotBlank();
Buffer body = request.getBody();
try {
assertPart(body, "form-data", boundary, "name 1", "text/plain", "value 1");
assertPart(body, "form-data", boundary, "name 2", "text/plain", "value 2+1");
assertPart(body, "form-data", boundary, "name 2", "text/plain", "value 2+2");
assertFilePart(body, "form-data", boundary, "logo", "logo.jpg", "image/jpeg");
try (Buffer buffer = new Buffer()) {
assertThat(request.getBody()).isNotNull();
buffer.write(request.getBody());
assertPart(buffer, "form-data", boundary, "name 1", "text/plain", "value 1");
assertPart(buffer, "form-data", boundary, "name 2", "text/plain", "value 2+1");
assertPart(buffer, "form-data", boundary, "name 2", "text/plain", "value 2+2");
assertFilePart(buffer, "form-data", boundary, "logo", "logo.jpg", "image/jpeg");
}
catch (EOFException ex) {
throw new AssertionError(ex);
@@ -192,43 +199,45 @@ abstract class AbstractMockWebServerTests {
}
private MockResponse formRequest(RecordedRequest request) {
assertThat(request.getHeader(CONTENT_TYPE)).isEqualTo("application/x-www-form-urlencoded");
assertThat(request.getBody().readUtf8()).contains("name+1=value+1", "name+2=value+2%2B1", "name+2=value+2%2B2");
return new MockResponse().setResponseCode(200);
assertThat(request.getHeaders().get(CONTENT_TYPE)).isEqualTo("application/x-www-form-urlencoded");
assertThat(request.getBody().utf8()).contains("name+1=value+1", "name+2=value+2%2B1", "name+2=value+2%2B2");
return new MockResponse.Builder().code(200).build();
}
private MockResponse patchRequest(RecordedRequest request, String expectedRequestContent,
String contentType, byte[] responseBody) {
assertThat(request.getMethod()).isEqualTo("PATCH");
assertThat(Integer.parseInt(request.getHeader(CONTENT_LENGTH))).as("Invalid request content-length").isGreaterThan(0);
String requestContentType = request.getHeader(CONTENT_TYPE);
assertThat(Integer.parseInt(request.getHeaders().get(CONTENT_LENGTH))).as("Invalid request content-length").isGreaterThan(0);
String requestContentType = request.getHeaders().get(CONTENT_TYPE);
assertThat(requestContentType).as("No content-type").isNotNull();
Charset charset = StandardCharsets.ISO_8859_1;
if (requestContentType.contains("charset=")) {
String charsetName = requestContentType.split("charset=")[1];
charset = Charset.forName(charsetName);
}
assertThat(request.getBody().readString(charset)).as("Invalid request body").isEqualTo(expectedRequestContent);
assertThat(request.getBody().string(charset)).as("Invalid request body").isEqualTo(expectedRequestContent);
Buffer buf = new Buffer();
buf.write(responseBody);
return new MockResponse().setResponseCode(201)
return new MockResponse.Builder()
.code(201)
.setHeader(CONTENT_LENGTH, responseBody.length)
.setHeader(CONTENT_TYPE, contentType)
.setBody(buf);
.body(buf)
.build();
}
private MockResponse putRequest(RecordedRequest request, String expectedRequestContent) {
assertThat(Integer.parseInt(request.getHeader(CONTENT_LENGTH))).as("Invalid request content-length").isGreaterThan(0);
String requestContentType = request.getHeader(CONTENT_TYPE);
assertThat(Integer.parseInt(request.getHeaders().get(CONTENT_LENGTH))).as("Invalid request content-length").isGreaterThan(0);
String requestContentType = request.getHeaders().get(CONTENT_TYPE);
assertThat(requestContentType).as("No content-type").isNotNull();
Charset charset = StandardCharsets.ISO_8859_1;
if (requestContentType.contains("charset=")) {
String charsetName = requestContentType.split("charset=")[1];
charset = Charset.forName(charsetName);
}
assertThat(request.getBody().readString(charset)).as("Invalid request body").isEqualTo(expectedRequestContent);
return new MockResponse().setResponseCode(202);
assertThat(request.getBody().string(charset)).as("Invalid request body").isEqualTo(expectedRequestContent);
return new MockResponse.Builder().code(202).build();
}
@@ -239,64 +248,64 @@ abstract class AbstractMockWebServerTests {
try {
byte[] helloWorldBytes = helloWorld.getBytes(StandardCharsets.UTF_8);
if (request.getPath().equals("/get")) {
if (request.getTarget().equals("/get")) {
return getRequest(request, helloWorldBytes, textContentType.toString());
}
else if (request.getPath().equals("/get/nothing")) {
else if (request.getTarget().equals("/get/nothing")) {
return getRequest(request, new byte[0], textContentType.toString());
}
else if (request.getPath().equals("/get/nocontenttype")) {
else if (request.getTarget().equals("/get/nocontenttype")) {
return getRequest(request, helloWorldBytes, null);
}
else if (request.getPath().equals("/post")) {
else if (request.getTarget().equals("/post")) {
return postRequest(request, helloWorld, "/post/1", textContentType.toString(), helloWorldBytes);
}
else if (request.getPath().equals("/jsonpost")) {
else if (request.getTarget().equals("/jsonpost")) {
return jsonPostRequest(request, "/jsonpost/1", "application/json; charset=utf-8");
}
else if (request.getPath().equals("/status/nocontent")) {
return new MockResponse().setResponseCode(204);
else if (request.getTarget().equals("/status/nocontent")) {
return new MockResponse.Builder().code(204).build();
}
else if (request.getPath().equals("/status/notmodified")) {
return new MockResponse().setResponseCode(304);
else if (request.getTarget().equals("/status/notmodified")) {
return new MockResponse.Builder().code(304).build();
}
else if (request.getPath().equals("/status/notfound")) {
return new MockResponse().setResponseCode(404);
else if (request.getTarget().equals("/status/notfound")) {
return new MockResponse.Builder().code(404).build();
}
else if (request.getPath().equals("/status/badrequest")) {
return new MockResponse().setResponseCode(400);
else if (request.getTarget().equals("/status/badrequest")) {
return new MockResponse.Builder().code(400).build();
}
else if (request.getPath().equals("/status/server")) {
return new MockResponse().setResponseCode(500);
else if (request.getTarget().equals("/status/server")) {
return new MockResponse.Builder().code(500).build();
}
else if (request.getPath().contains("/uri/")) {
return new MockResponse().setBody(request.getPath()).setHeader(CONTENT_TYPE, "text/plain");
else if (request.getTarget().contains("/uri/")) {
return new MockResponse.Builder().body(request.getTarget()).setHeader(CONTENT_TYPE, "text/plain").build();
}
else if (request.getPath().equals("/multipartFormData")) {
else if (request.getTarget().equals("/multipartFormData")) {
return multipartFormDataRequest(request);
}
else if (request.getPath().equals("/multipartMixed")) {
else if (request.getTarget().equals("/multipartMixed")) {
return multipartMixedRequest(request);
}
else if (request.getPath().equals("/multipartRelated")) {
else if (request.getTarget().equals("/multipartRelated")) {
return multipartRelatedRequest(request);
}
else if (request.getPath().equals("/form")) {
else if (request.getTarget().equals("/form")) {
return formRequest(request);
}
else if (request.getPath().equals("/delete")) {
return new MockResponse().setResponseCode(200);
else if (request.getTarget().equals("/delete")) {
return new MockResponse.Builder().code(200).build();
}
else if (request.getPath().equals("/patch")) {
else if (request.getTarget().equals("/patch")) {
return patchRequest(request, helloWorld, textContentType.toString(), helloWorldBytes);
}
else if (request.getPath().equals("/put")) {
else if (request.getTarget().equals("/put")) {
return putRequest(request, helloWorld);
}
return new MockResponse().setResponseCode(404);
return new MockResponse.Builder().code(404).build();
}
catch (Throwable ex) {
return new MockResponse().setResponseCode(500).setBody(ex.toString());
return new MockResponse.Builder().code(500).body(ex.toString()).build();
}
}
}
spring-web/src/test/java/org/springframework/web/client/RestClientIntegrationTests.java
+206 -206
View File
@@ -27,12 +27,13 @@ import java.net.URISyntaxException;
import java.util.List;
import java.util.Map;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.stream.Stream;
import com.fasterxml.jackson.annotation.JsonView;
import okhttp3.mockwebserver.MockResponse;
import okhttp3.mockwebserver.MockWebServer;
import okhttp3.mockwebserver.RecordedRequest;
import mockwebserver3.MockResponse;
import mockwebserver3.MockWebServer;
import mockwebserver3.RecordedRequest;
import org.jspecify.annotations.Nullable;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.params.ParameterizedTest;
@@ -99,8 +100,9 @@ class RestClientIntegrationTests {
private RestClient restClient;
private void startServer(ClientHttpRequestFactory requestFactory) {
private void startServer(ClientHttpRequestFactory requestFactory) throws IOException {
this.server = new MockWebServer();
this.server.start();
this.restClient = RestClient
.builder()
.requestFactory(requestFactory)
@@ -111,17 +113,17 @@ class RestClientIntegrationTests {
@AfterEach
void shutdown() throws IOException {
if (server != null) {
this.server.shutdown();
this.server.close();
}
}
@ParameterizedRestClientTest
void retrieve(ClientHttpRequestFactory requestFactory) {
void retrieve(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
prepareResponse(response ->
response.setHeader("Content-Type", "text/plain").setBody("Hello Spring!"));
prepareResponse(builder -> builder
.setHeader("Content-Type", "text/plain").body("Hello Spring!"));
String result = this.restClient.get()
.uri("/greeting")
@@ -133,18 +135,18 @@ class RestClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getHeader("X-Test-Header")).isEqualTo("testvalue");
assertThat(request.getPath()).isEqualTo("/greeting");
assertThat(request.getHeaders().get("X-Test-Header")).isEqualTo("testvalue");
assertThat(request.getTarget()).isEqualTo("/greeting");
});
}
@ParameterizedRestClientTest
void retrieveJson(ClientHttpRequestFactory requestFactory) {
void retrieveJson(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
prepareResponse(response -> response
prepareResponse(builder -> builder
.setHeader("Content-Type", "application/json")
.setBody("{\"bar\":\"barbar\",\"foo\":\"foofoo\"}"));
.body("{\"bar\":\"barbar\",\"foo\":\"foofoo\"}"));
Pojo result = this.restClient.get()
.uri("/pojo")
@@ -157,18 +159,18 @@ class RestClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getPath()).isEqualTo("/pojo");
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("application/json");
assertThat(request.getTarget()).isEqualTo("/pojo");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("application/json");
});
}
@ParameterizedRestClientTest
void retrieveJsonWithParameterizedTypeReference(ClientHttpRequestFactory requestFactory) {
void retrieveJsonWithParameterizedTypeReference(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
String content = "{\"containerValue\":{\"bar\":\"barbar\",\"foo\":\"foofoo\"}}";
prepareResponse(response -> response
.setHeader("Content-Type", "application/json").setBody(content));
prepareResponse(builder -> builder
.setHeader("Content-Type", "application/json").body(content));
ValueContainer<Pojo> result = this.restClient.get()
.uri("/json").accept(MediaType.APPLICATION_JSON)
@@ -182,18 +184,18 @@ class RestClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getPath()).isEqualTo("/json");
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("application/json");
assertThat(request.getTarget()).isEqualTo("/json");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("application/json");
});
}
@ParameterizedRestClientTest
void retrieveJsonWithListParameterizedTypeReference(ClientHttpRequestFactory requestFactory) {
void retrieveJsonWithListParameterizedTypeReference(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
String content = "{\"containerValue\":[{\"bar\":\"barbar\",\"foo\":\"foofoo\"}]}";
prepareResponse(response -> response
.setHeader("Content-Type", "application/json").setBody(content));
prepareResponse(builder -> builder
.setHeader("Content-Type", "application/json").body(content));
ValueContainer<List<Pojo>> result = this.restClient.get()
.uri("/json").accept(MediaType.APPLICATION_JSON)
@@ -205,18 +207,18 @@ class RestClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getPath()).isEqualTo("/json");
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("application/json");
assertThat(request.getTarget()).isEqualTo("/json");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("application/json");
});
}
@ParameterizedRestClientTest
void retrieveJsonAsResponseEntity(ClientHttpRequestFactory requestFactory) {
void retrieveJsonAsResponseEntity(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
String content = "{\"bar\":\"barbar\",\"foo\":\"foofoo\"}";
prepareResponse(response -> response
.setHeader("Content-Type", "application/json").setBody(content));
prepareResponse(builder -> builder
.setHeader("Content-Type", "application/json").body(content));
ResponseEntity<String> result = this.restClient.get()
.uri("/json").accept(MediaType.APPLICATION_JSON)
@@ -230,17 +232,17 @@ class RestClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getPath()).isEqualTo("/json");
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("application/json");
assertThat(request.getTarget()).isEqualTo("/json");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("application/json");
});
}
@ParameterizedRestClientTest
void retrieveJsonAsBodilessEntity(ClientHttpRequestFactory requestFactory) {
void retrieveJsonAsBodilessEntity(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
prepareResponse(response -> response
.setHeader("Content-Type", "application/json").setBody("{\"bar\":\"barbar\",\"foo\":\"foofoo\"}"));
prepareResponse(builder -> builder
.setHeader("Content-Type", "application/json").body("{\"bar\":\"barbar\",\"foo\":\"foofoo\"}"));
ResponseEntity<Void> result = this.restClient.get()
.uri("/json").accept(MediaType.APPLICATION_JSON)
@@ -254,18 +256,18 @@ class RestClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getPath()).isEqualTo("/json");
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("application/json");
assertThat(request.getTarget()).isEqualTo("/json");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("application/json");
});
}
@ParameterizedRestClientTest
void retrieveJsonArray(ClientHttpRequestFactory requestFactory) {
void retrieveJsonArray(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
prepareResponse(response -> response
prepareResponse(builder -> builder
.setHeader("Content-Type", "application/json")
.setBody("[{\"bar\":\"bar1\",\"foo\":\"foo1\"},{\"bar\":\"bar2\",\"foo\":\"foo2\"}]"));
.body("[{\"bar\":\"bar1\",\"foo\":\"foo1\"},{\"bar\":\"bar2\",\"foo\":\"foo2\"}]"));
List<Pojo> result = this.restClient.get()
.uri("/pojos")
@@ -281,18 +283,18 @@ class RestClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getPath()).isEqualTo("/pojos");
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("application/json");
assertThat(request.getTarget()).isEqualTo("/pojos");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("application/json");
});
}
@ParameterizedRestClientTest
void retrieveJsonArrayAsResponseEntityList(ClientHttpRequestFactory requestFactory) {
void retrieveJsonArrayAsResponseEntityList(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
String content = "[{\"bar\":\"bar1\",\"foo\":\"foo1\"}, {\"bar\":\"bar2\",\"foo\":\"foo2\"}]";
prepareResponse(response -> response
.setHeader("Content-Type", "application/json").setBody(content));
prepareResponse(builder -> builder
.setHeader("Content-Type", "application/json").body(content));
ResponseEntity<List<Pojo>> result = this.restClient.get()
.uri("/json").accept(MediaType.APPLICATION_JSON)
@@ -310,18 +312,18 @@ class RestClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getPath()).isEqualTo("/json");
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("application/json");
assertThat(request.getTarget()).isEqualTo("/json");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("application/json");
});
}
@ParameterizedRestClientTest
void retrieveJsonAsSerializedText(ClientHttpRequestFactory requestFactory) {
void retrieveJsonAsSerializedText(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
String content = "{\"bar\":\"barbar\",\"foo\":\"foofoo\"}";
prepareResponse(response -> response
.setHeader("Content-Type", "application/json").setBody(content));
prepareResponse(builder -> builder
.setHeader("Content-Type", "application/json").body(content));
String result = this.restClient.get()
.uri("/json").accept(MediaType.APPLICATION_JSON)
@@ -332,20 +334,20 @@ class RestClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getPath()).isEqualTo("/json");
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("application/json");
assertThat(request.getTarget()).isEqualTo("/json");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("application/json");
});
}
@ParameterizedRestClientTest
@SuppressWarnings({ "rawtypes", "unchecked" })
void retrieveJsonNull(ClientHttpRequestFactory requestFactory) {
void retrieveJsonNull(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
prepareResponse(response -> response
.setResponseCode(200)
prepareResponse(builder -> builder
.code(200)
.setHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
.setBody("null"));
.body("null"));
Map result = this.restClient.get()
.uri("/null")
@@ -356,11 +358,11 @@ class RestClientIntegrationTests {
}
@ParameterizedRestClientTest
void retrieveJsonEmpty(ClientHttpRequestFactory requestFactory) {
void retrieveJsonEmpty(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
prepareResponse(response -> response
.setResponseCode(200)
prepareResponse(builder -> builder
.code(200)
.setHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE));
Pojo result = this.restClient.get()
@@ -372,11 +374,10 @@ class RestClientIntegrationTests {
}
@ParameterizedRestClientTest
void retrieve404(ClientHttpRequestFactory requestFactory) {
void retrieve404(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
prepareResponse(response -> response.setResponseCode(404)
.setHeader("Content-Type", "text/plain"));
prepareResponse(builder -> builder.code(404).setHeader("Content-Type", "text/plain"));
assertThatExceptionOfType(HttpClientErrorException.NotFound.class).isThrownBy(() ->
this.restClient.get().uri("/greeting")
@@ -385,16 +386,16 @@ class RestClientIntegrationTests {
);
expectRequestCount(1);
expectRequest(request -> assertThat(request.getPath()).isEqualTo("/greeting"));
expectRequest(request -> assertThat(request.getTarget()).isEqualTo("/greeting"));
}
@ParameterizedRestClientTest
void retrieve404WithBody(ClientHttpRequestFactory requestFactory) {
void retrieve404WithBody(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
prepareResponse(response -> response.setResponseCode(404)
.setHeader("Content-Type", "text/plain").setBody("Not Found"));
prepareResponse(builder -> builder.code(404)
.setHeader("Content-Type", "text/plain").body("Not Found"));
assertThatExceptionOfType(HttpClientErrorException.NotFound.class).isThrownBy(() ->
this.restClient.get()
@@ -404,16 +405,16 @@ class RestClientIntegrationTests {
);
expectRequestCount(1);
expectRequest(request -> assertThat(request.getPath()).isEqualTo("/greeting"));
expectRequest(request -> assertThat(request.getTarget()).isEqualTo("/greeting"));
}
@ParameterizedRestClientTest
void retrieve500(ClientHttpRequestFactory requestFactory) {
void retrieve500(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
String errorMessage = "Internal Server error";
prepareResponse(response -> response.setResponseCode(500)
.setHeader("Content-Type", "text/plain").setBody(errorMessage));
prepareResponse(builder -> builder.code(500)
.setHeader("Content-Type", "text/plain").body(errorMessage));
String path = "/greeting";
try {
@@ -431,15 +432,15 @@ class RestClientIntegrationTests {
}
expectRequestCount(1);
expectRequest(request -> assertThat(request.getPath()).isEqualTo(path));
expectRequest(request -> assertThat(request.getTarget()).isEqualTo(path));
}
@ParameterizedRestClientTest
void retrieve500AsEntity(ClientHttpRequestFactory requestFactory) {
void retrieve500AsEntity(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
prepareResponse(response -> response.setResponseCode(500)
.setHeader("Content-Type", "text/plain").setBody("Internal Server error"));
prepareResponse(builder -> builder.code(500)
.setHeader("Content-Type", "text/plain").body("Internal Server error"));
assertThatExceptionOfType(HttpServerErrorException.InternalServerError.class).isThrownBy(() ->
this.restClient.get()
@@ -450,17 +451,17 @@ class RestClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getPath()).isEqualTo("/");
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("application/json");
assertThat(request.getTarget()).isEqualTo("/");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("application/json");
});
}
@ParameterizedRestClientTest
void retrieve500AsBodilessEntity(ClientHttpRequestFactory requestFactory) {
void retrieve500AsBodilessEntity(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
prepareResponse(response -> response.setResponseCode(500)
.setHeader("Content-Type", "text/plain").setBody("Internal Server error"));
prepareResponse(builder -> builder.code(500)
.setHeader("Content-Type", "text/plain").body("Internal Server error"));
assertThatExceptionOfType(HttpServerErrorException.InternalServerError.class).isThrownBy(() ->
this.restClient.get()
@@ -471,20 +472,20 @@ class RestClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getPath()).isEqualTo("/");
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("application/json");
assertThat(request.getTarget()).isEqualTo("/");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("application/json");
});
}
@ParameterizedRestClientTest
void retrieve555UnknownStatus(ClientHttpRequestFactory requestFactory) {
void retrieve555UnknownStatus(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
int errorStatus = 555;
assertThat(HttpStatus.resolve(errorStatus)).isNull();
String errorMessage = "Something went wrong";
prepareResponse(response -> response.setResponseCode(errorStatus)
.setHeader("Content-Type", "text/plain").setBody(errorMessage));
prepareResponse(builder -> builder.code(errorStatus)
.setHeader("Content-Type", "text/plain").body(errorMessage));
try {
this.restClient.get()
@@ -502,15 +503,15 @@ class RestClientIntegrationTests {
}
expectRequestCount(1);
expectRequest(request -> assertThat(request.getPath()).isEqualTo("/unknownPage"));
expectRequest(request -> assertThat(request.getTarget()).isEqualTo("/unknownPage"));
}
@ParameterizedRestClientTest
void postPojoAsJson(ClientHttpRequestFactory requestFactory) {
void postPojoAsJson(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
prepareResponse(response -> response.setHeader("Content-Type", "application/json")
.setBody("{\"bar\":\"BARBAR\",\"foo\":\"FOOFOO\"}"));
prepareResponse(builder -> builder.setHeader("Content-Type", "application/json")
.body("{\"bar\":\"BARBAR\",\"foo\":\"FOOFOO\"}"));
Pojo result = this.restClient.post()
.uri("/pojo/capitalize")
@@ -526,19 +527,19 @@ class RestClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getPath()).isEqualTo("/pojo/capitalize");
assertThat(request.getBody().readUtf8()).isEqualTo("{\"bar\":\"barbar\",\"foo\":\"foofoo\"}");
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("application/json");
assertThat(request.getHeader(HttpHeaders.CONTENT_TYPE)).isEqualTo("application/json");
assertThat(request.getTarget()).isEqualTo("/pojo/capitalize");
assertThat(request.getBody().utf8()).isEqualTo("{\"bar\":\"barbar\",\"foo\":\"foofoo\"}");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("application/json");
assertThat(request.getHeaders().get(HttpHeaders.CONTENT_TYPE)).isEqualTo("application/json");
});
}
@ParameterizedRestClientTest
void postUserAsJsonWithJsonView(ClientHttpRequestFactory requestFactory) {
void postUserAsJsonWithJsonView(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
prepareResponse(response -> response.setHeader("Content-Type", "application/json")
.setBody("{\"username\":\"USERNAME\"}"));
prepareResponse(builder -> builder.setHeader("Content-Type", "application/json")
.body("{\"username\":\"USERNAME\"}"));
User result = this.restClient.post()
.uri("/user/capitalize")
@@ -555,18 +556,18 @@ class RestClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getPath()).isEqualTo("/user/capitalize");
assertThat(request.getBody().readUtf8()).isEqualTo("{\"username\":\"username\"}");
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("application/json");
assertThat(request.getHeader(HttpHeaders.CONTENT_TYPE)).isEqualTo("application/json");
assertThat(request.getTarget()).isEqualTo("/user/capitalize");
assertThat(request.getBody().utf8()).isEqualTo("{\"username\":\"username\"}");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("application/json");
assertThat(request.getHeaders().get(HttpHeaders.CONTENT_TYPE)).isEqualTo("application/json");
});
}
@ParameterizedRestClientTest // gh-31361
public void postForm(ClientHttpRequestFactory requestFactory) {
public void postForm(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
prepareResponse(response -> response.setResponseCode(200));
prepareResponse(builder -> builder.code(200));
MultiValueMap<String, String> formData = new LinkedMultiValueMap<>();
formData.add("foo", "bar");
@@ -583,10 +584,10 @@ class RestClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getPath()).isEqualTo("/form");
String contentType = request.getHeader(HttpHeaders.CONTENT_TYPE);
assertThat(request.getTarget()).isEqualTo("/form");
String contentType = request.getHeaders().get(HttpHeaders.CONTENT_TYPE);
assertThat(contentType).startsWith(MediaType.MULTIPART_FORM_DATA_VALUE);
String[] lines = request.getBody().readUtf8().split("\r\n");
String[] lines = request.getBody().utf8().split("\r\n");
assertThat(lines).hasSize(13);
assertThat(lines[0]).startsWith("--"); // boundary
assertThat(lines[1]).isEqualTo("Content-Disposition: form-data; name=\"foo\"");
@@ -606,9 +607,9 @@ class RestClientIntegrationTests {
}
@ParameterizedRestClientTest // gh-35102
void postStreamingBody(ClientHttpRequestFactory requestFactory) {
void postStreamingBody(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
prepareResponse(response -> response.setResponseCode(200));
prepareResponse(builder -> builder.code(200));
StreamingHttpOutputMessage.Body testBody = out -> {
assertThat(out).as("Not a streaming response").isNotInstanceOf(FastByteArrayOutputStream.class);
@@ -625,17 +626,17 @@ class RestClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getPath()).isEqualTo("/streaming/body");
assertThat(request.getBody().readUtf8()).isEqualTo("test-data");
assertThat(request.getTarget()).isEqualTo("/streaming/body");
assertThat(request.getBody().utf8()).isEqualTo("test-data");
});
}
@ParameterizedRestClientTest
void statusHandler(ClientHttpRequestFactory requestFactory) {
void statusHandler(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
prepareResponse(response -> response.setResponseCode(500)
.setHeader("Content-Type", "text/plain").setBody("Internal Server error"));
prepareResponse(builder -> builder.code(500)
.setHeader("Content-Type", "text/plain").body("Internal Server error"));
assertThatExceptionOfType(MyException.class).isThrownBy(() ->
this.restClient.get()
@@ -648,15 +649,15 @@ class RestClientIntegrationTests {
);
expectRequestCount(1);
expectRequest(request -> assertThat(request.getPath()).isEqualTo("/greeting"));
expectRequest(request -> assertThat(request.getTarget()).isEqualTo("/greeting"));
}
@ParameterizedRestClientTest
void statusHandlerIOException(ClientHttpRequestFactory requestFactory) {
void statusHandlerIOException(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
prepareResponse(response -> response.setResponseCode(500)
.setHeader("Content-Type", "text/plain").setBody("Internal Server error"));
prepareResponse(builder -> builder.code(500)
.setHeader("Content-Type", "text/plain").body("Internal Server error"));
assertThatExceptionOfType(RestClientException.class).isThrownBy(() ->
this.restClient.get()
@@ -669,15 +670,15 @@ class RestClientIntegrationTests {
).withCauseInstanceOf(IOException.class);
expectRequestCount(1);
expectRequest(request -> assertThat(request.getPath()).isEqualTo("/greeting"));
expectRequest(request -> assertThat(request.getTarget()).isEqualTo("/greeting"));
}
@ParameterizedRestClientTest
void statusHandlerParameterizedTypeReference(ClientHttpRequestFactory requestFactory) {
void statusHandlerParameterizedTypeReference(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
prepareResponse(response -> response.setResponseCode(500)
.setHeader("Content-Type", "text/plain").setBody("Internal Server error"));
prepareResponse(builder -> builder.code(500)
.setHeader("Content-Type", "text/plain").body("Internal Server error"));
assertThatExceptionOfType(MyException.class).isThrownBy(() ->
this.restClient.get()
@@ -691,15 +692,15 @@ class RestClientIntegrationTests {
);
expectRequestCount(1);
expectRequest(request -> assertThat(request.getPath()).isEqualTo("/greeting"));
expectRequest(request -> assertThat(request.getTarget()).isEqualTo("/greeting"));
}
@ParameterizedRestClientTest
void statusHandlerSuppressedErrorSignal(ClientHttpRequestFactory requestFactory) {
void statusHandlerSuppressedErrorSignal(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
prepareResponse(response -> response.setResponseCode(500)
.setHeader("Content-Type", "text/plain").setBody("Internal Server error"));
prepareResponse(builder -> builder.code(500)
.setHeader("Content-Type", "text/plain").body("Internal Server error"));
String result = this.restClient.get()
.uri("/greeting")
@@ -710,16 +711,16 @@ class RestClientIntegrationTests {
assertThat(result).isEqualTo("Internal Server error");
expectRequestCount(1);
expectRequest(request -> assertThat(request.getPath()).isEqualTo("/greeting"));
expectRequest(request -> assertThat(request.getTarget()).isEqualTo("/greeting"));
}
@ParameterizedRestClientTest
void statusHandlerSuppressedErrorSignalWithEntity(ClientHttpRequestFactory requestFactory) {
void statusHandlerSuppressedErrorSignalWithEntity(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
String content = "Internal Server error";
prepareResponse(response ->
response.setResponseCode(500).setHeader("Content-Type", "text/plain").setBody(content));
prepareResponse(builder -> builder.code(500)
.setHeader("Content-Type", "text/plain").body(content));
ResponseEntity<String> result = this.restClient.get()
.uri("/").accept(MediaType.APPLICATION_JSON)
@@ -733,16 +734,16 @@ class RestClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getPath()).isEqualTo("/");
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("application/json");
assertThat(request.getTarget()).isEqualTo("/");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("application/json");
});
}
@ParameterizedRestClientTest
void exchangeForPlainText(ClientHttpRequestFactory requestFactory) {
void exchangeForPlainText(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
prepareResponse(response -> response.setBody("Hello Spring!"));
prepareResponse(builder -> builder.body("Hello Spring!"));
String result = this.restClient.get()
.uri("/greeting")
@@ -753,18 +754,18 @@ class RestClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getHeader("X-Test-Header")).isEqualTo("testvalue");
assertThat(request.getPath()).isEqualTo("/greeting");
assertThat(request.getHeaders().get("X-Test-Header")).isEqualTo("testvalue");
assertThat(request.getTarget()).isEqualTo("/greeting");
});
}
@ParameterizedRestClientTest
void exchangeForJson(ClientHttpRequestFactory requestFactory) {
void exchangeForJson(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
prepareResponse(response -> response
prepareResponse(builder -> builder
.setHeader("Content-Type", "application/json")
.setBody("{\"bar\":\"barbar\",\"foo\":\"foofoo\"}"));
.body("{\"bar\":\"barbar\",\"foo\":\"foofoo\"}"));
Pojo result = this.restClient.get()
.uri("/pojo")
@@ -776,18 +777,18 @@ class RestClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getPath()).isEqualTo("/pojo");
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("application/json");
assertThat(request.getTarget()).isEqualTo("/pojo");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("application/json");
});
}
@ParameterizedRestClientTest
void exchangeForJsonArray(ClientHttpRequestFactory requestFactory) {
void exchangeForJsonArray(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
prepareResponse(response -> response
prepareResponse(builder -> builder
.setHeader("Content-Type", "application/json")
.setBody("[{\"bar\":\"bar1\",\"foo\":\"foo1\"},{\"bar\":\"bar2\",\"foo\":\"foo2\"}]"));
.body("[{\"bar\":\"bar1\",\"foo\":\"foo1\"},{\"bar\":\"bar2\",\"foo\":\"foo2\"}]"));
List<Pojo> result = this.restClient.get()
.uri("/pojo")
@@ -802,17 +803,17 @@ class RestClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getPath()).isEqualTo("/pojo");
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("application/json");
assertThat(request.getTarget()).isEqualTo("/pojo");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("application/json");
});
}
@ParameterizedRestClientTest
void exchangeFor404(ClientHttpRequestFactory requestFactory) {
void exchangeFor404(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
prepareResponse(response ->
response.setResponseCode(404).setHeader("Content-Type", "text/plain").setBody("Not Found"));
prepareResponse(builder ->
builder.code(404).setHeader("Content-Type", "text/plain").body("Not Found"));
String result = this.restClient.get()
.uri("/greeting")
@@ -821,14 +822,14 @@ class RestClientIntegrationTests {
assertThat(result).isEqualTo("Not Found");
expectRequestCount(1);
expectRequest(request -> assertThat(request.getPath()).isEqualTo("/greeting"));
expectRequest(request -> assertThat(request.getTarget()).isEqualTo("/greeting"));
}
@ParameterizedRestClientTest
void exchangeForRequiredValue(ClientHttpRequestFactory requestFactory) {
void exchangeForRequiredValue(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
prepareResponse(response -> response.setBody("Hello Spring!"));
prepareResponse(builder -> builder.body("Hello Spring!"));
String result = this.restClient.get()
.uri("/greeting")
@@ -839,17 +840,17 @@ class RestClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getHeader("X-Test-Header")).isEqualTo("testvalue");
assertThat(request.getPath()).isEqualTo("/greeting");
assertThat(request.getHeaders().get("X-Test-Header")).isEqualTo("testvalue");
assertThat(request.getTarget()).isEqualTo("/greeting");
});
}
@ParameterizedRestClientTest
@SuppressWarnings("DataFlowIssue")
void exchangeForNullRequiredValue(ClientHttpRequestFactory requestFactory) {
void exchangeForNullRequiredValue(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
prepareResponse(response -> response.setBody("Hello Spring!"));
prepareResponse(builder -> builder.body("Hello Spring!"));
assertThatIllegalStateException().isThrownBy(() -> this.restClient.get()
.uri("/greeting")
@@ -858,11 +859,11 @@ class RestClientIntegrationTests {
}
@ParameterizedRestClientTest
void requestInitializer(ClientHttpRequestFactory requestFactory) {
void requestInitializer(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
prepareResponse(response ->
response.setHeader("Content-Type", "text/plain").setBody("Hello Spring!"));
prepareResponse(builder ->
builder.setHeader("Content-Type", "text/plain").body("Hello Spring!"));
RestClient initializedClient = this.restClient.mutate()
.requestInitializer(request -> request.getHeaders().add("foo", "bar"))
@@ -876,15 +877,15 @@ class RestClientIntegrationTests {
assertThat(result).isEqualTo("Hello Spring!");
expectRequestCount(1);
expectRequest(request -> assertThat(request.getHeader("foo")).isEqualTo("bar"));
expectRequest(request -> assertThat(request.getHeaders().get("foo")).isEqualTo("bar"));
}
@ParameterizedRestClientTest
void requestInterceptor(ClientHttpRequestFactory requestFactory) {
void requestInterceptor(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
prepareResponse(response ->
response.setHeader("Content-Type", "text/plain").setBody("Hello Spring!"));
prepareResponse(builder ->
builder.setHeader("Content-Type", "text/plain").body("Hello Spring!"));
RestClient interceptedClient = this.restClient.mutate()
.requestInterceptor((request, body, execution) -> {
@@ -901,15 +902,15 @@ class RestClientIntegrationTests {
assertThat(result).isEqualTo("Hello Spring!");
expectRequestCount(1);
expectRequest(request -> assertThat(request.getHeader("foo")).isEqualTo("bar"));
expectRequest(request -> assertThat(request.getHeaders().get("foo")).isEqualTo("bar"));
}
@ParameterizedRestClientTest
void requestInterceptorWithResponseBuffering(ClientHttpRequestFactory requestFactory) {
void requestInterceptorWithResponseBuffering(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
prepareResponse(response ->
response.setHeader("Content-Type", "text/plain").setBody("Hello Spring!"));
prepareResponse(builder ->
builder.setHeader("Content-Type", "text/plain").body("Hello Spring!"));
RestClient interceptedClient = this.restClient.mutate()
.requestInterceptor((request, body, execution) -> {
@@ -931,11 +932,11 @@ class RestClientIntegrationTests {
}
@ParameterizedRestClientTest
void bufferContent(ClientHttpRequestFactory requestFactory) {
void bufferContent(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
prepareResponse(response ->
response.setHeader("Content-Type", "text/plain").setBody("Hello Spring!"));
prepareResponse(builder ->
builder.setHeader("Content-Type", "text/plain").body("Hello Spring!"));
RestClient bufferingClient = this.restClient.mutate()
.bufferContent((uri, httpMethod) -> true)
@@ -956,10 +957,10 @@ class RestClientIntegrationTests {
}
@ParameterizedRestClientTest
void retrieveDefaultCookiesAsCookieHeader(ClientHttpRequestFactory requestFactory) {
void retrieveDefaultCookiesAsCookieHeader(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
prepareResponse(response ->
response.setHeader("Content-Type", "text/plain").setBody("Hello Spring!"));
prepareResponse(builder ->
builder.setHeader("Content-Type", "text/plain").body("Hello Spring!"));
RestClient restClientWithCookies = this.restClient.mutate()
.defaultCookie("testCookie", "firstValue", "secondValue")
@@ -972,13 +973,13 @@ class RestClientIntegrationTests {
.body(String.class);
expectRequest(request ->
assertThat(request.getHeader(HttpHeaders.COOKIE))
assertThat(request.getHeaders().get(HttpHeaders.COOKIE))
.isEqualTo("testCookie=firstValue; testCookie=secondValue")
);
}
@ParameterizedRestClientTest
void filterForErrorHandling(ClientHttpRequestFactory requestFactory) {
void filterForErrorHandling(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
ClientHttpRequestInterceptor interceptor = (request, body, execution) -> {
@@ -995,8 +996,8 @@ class RestClientIntegrationTests {
RestClient interceptedClient = this.restClient.mutate().requestInterceptor(interceptor).build();
// header not present
prepareResponse(response ->
response.setHeader("Content-Type", "text/plain").setBody("Hello Spring!"));
prepareResponse(builder ->
builder.setHeader("Content-Type", "text/plain").body("Hello Spring!"));
assertThatExceptionOfType(MyException.class).isThrownBy(() ->
interceptedClient.get()
@@ -1007,9 +1008,9 @@ class RestClientIntegrationTests {
// header present
prepareResponse(response -> response.setHeader("Content-Type", "text/plain")
prepareResponse(builder -> builder.setHeader("Content-Type", "text/plain")
.setHeader("Foo", "Bar")
.setBody("Hello Spring!"));
.body("Hello Spring!"));
String result = interceptedClient.get()
.uri("/greeting")
@@ -1021,11 +1022,11 @@ class RestClientIntegrationTests {
}
@ParameterizedRestClientTest
void defaultHeaders(ClientHttpRequestFactory requestFactory) {
void defaultHeaders(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
prepareResponse(response ->
response.setHeader("Content-Type", "text/plain").setBody("Hello Spring!"));
prepareResponse(builder ->
builder.setHeader("Content-Type", "text/plain").body("Hello Spring!"));
RestClient headersClient = this.restClient.mutate()
.defaultHeaders(headers -> headers.add("foo", "bar"))
@@ -1039,15 +1040,15 @@ class RestClientIntegrationTests {
assertThat(result).isEqualTo("Hello Spring!");
expectRequestCount(1);
expectRequest(request -> assertThat(request.getHeader("foo")).isEqualTo("bar"));
expectRequest(request -> assertThat(request.getHeaders().get("foo")).isEqualTo("bar"));
}
@ParameterizedRestClientTest
void defaultRequest(ClientHttpRequestFactory requestFactory) {
void defaultRequest(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
prepareResponse(response ->
response.setHeader("Content-Type", "text/plain").setBody("Hello Spring!"));
prepareResponse(builder ->
builder.setHeader("Content-Type", "text/plain").body("Hello Spring!"));
RestClient headersClient = this.restClient.mutate()
.defaultRequest(request -> request.header("foo", "bar"))
@@ -1061,15 +1062,15 @@ class RestClientIntegrationTests {
assertThat(result).isEqualTo("Hello Spring!");
expectRequestCount(1);
expectRequest(request -> assertThat(request.getHeader("foo")).isEqualTo("bar"));
expectRequest(request -> assertThat(request.getHeaders().get("foo")).isEqualTo("bar"));
}
@ParameterizedRestClientTest
void defaultRequestOverride(ClientHttpRequestFactory requestFactory) {
void defaultRequestOverride(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
prepareResponse(response ->
response.setHeader("Content-Type", "text/plain").setBody("Hello Spring!"));
prepareResponse(builder ->
builder.setHeader("Content-Type", "text/plain").body("Hello Spring!"));
RestClient headersClient = this.restClient.mutate()
.defaultRequest(request -> request.accept(MediaType.APPLICATION_JSON))
@@ -1084,15 +1085,15 @@ class RestClientIntegrationTests {
assertThat(result).isEqualTo("Hello Spring!");
expectRequestCount(1);
expectRequest(request -> assertThat(request.getHeader("Accept")).isEqualTo(MediaType.TEXT_PLAIN_VALUE));
expectRequest(request -> assertThat(request.getHeaders().get("Accept")).isEqualTo(MediaType.TEXT_PLAIN_VALUE));
}
@ParameterizedRestClientTest
void relativeUri(ClientHttpRequestFactory requestFactory) throws URISyntaxException {
void relativeUri(ClientHttpRequestFactory requestFactory) throws URISyntaxException, IOException {
startServer(requestFactory);
prepareResponse(response ->
response.setHeader("Content-Type", "text/plain").setBody("Hello Spring!"));
prepareResponse(builder ->
builder.setHeader("Content-Type", "text/plain").body("Hello Spring!"));
URI uri = new URI(null, null, "/foo bar", null);
@@ -1106,15 +1107,15 @@ class RestClientIntegrationTests {
assertThat(result).isEqualTo("Hello Spring!");
expectRequestCount(1);
expectRequest(request -> assertThat(request.getPath()).isEqualTo("/foo%20bar"));
expectRequest(request -> assertThat(request.getTarget()).isEqualTo("/foo%20bar"));
}
@ParameterizedRestClientTest
void cookieAddsCookie(ClientHttpRequestFactory requestFactory) {
void cookieAddsCookie(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
prepareResponse(response ->
response.setHeader("Content-Type", "text/plain").setBody("Hello Spring!"));
prepareResponse(builder ->
builder.setHeader("Content-Type", "text/plain").body("Hello Spring!"));
this.restClient.get()
.uri("/greeting")
@@ -1124,15 +1125,15 @@ class RestClientIntegrationTests {
.retrieve()
.body(String.class);
expectRequest(request -> assertThat(request.getHeader("Cookie")).isEqualTo("c1=v1a; c1=v1b; c2=v2a"));
expectRequest(request -> assertThat(request.getHeaders().get("Cookie")).isEqualTo("c1=v1a; c1=v1b; c2=v2a"));
}
@ParameterizedRestClientTest
void cookieOverridesDefaultCookie(ClientHttpRequestFactory requestFactory) {
void cookieOverridesDefaultCookie(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
prepareResponse(response ->
response.setHeader("Content-Type", "text/plain").setBody("Hello Spring!"));
prepareResponse(builder ->
builder.setHeader("Content-Type", "text/plain").body("Hello Spring!"));
RestClient restClientWithCookies = this.restClient.mutate()
.defaultCookie("testCookie", "firstValue", "secondValue")
@@ -1144,15 +1145,15 @@ class RestClientIntegrationTests {
.retrieve()
.body(String.class);
expectRequest(request -> assertThat(request.getHeader("Cookie")).isEqualTo("testCookie=test"));
expectRequest(request -> assertThat(request.getHeaders().get("Cookie")).isEqualTo("testCookie=test"));
}
@ParameterizedRestClientTest
void cookiesCanRemoveCookie(ClientHttpRequestFactory requestFactory) {
void cookiesCanRemoveCookie(ClientHttpRequestFactory requestFactory) throws IOException {
startServer(requestFactory);
prepareResponse(response ->
response.setHeader("Content-Type", "text/plain").setBody("Hello Spring!"));
prepareResponse(builder ->
builder.setHeader("Content-Type", "text/plain").body("Hello Spring!"));
this.restClient.get()
.uri("/greeting")
@@ -1162,13 +1163,12 @@ class RestClientIntegrationTests {
.retrieve()
.body(String.class);
expectRequest(request -> assertThat(request.getHeader("Cookie")).isEqualTo("test=Hello"));
expectRequest(request -> assertThat(request.getHeaders().get("Cookie")).isEqualTo("test=Hello"));
}
private void prepareResponse(Consumer<MockResponse> consumer) {
MockResponse response = new MockResponse();
consumer.accept(response);
this.server.enqueue(response);
private void prepareResponse(Function<MockResponse.Builder, MockResponse.Builder> f) {
MockResponse.Builder builder = new MockResponse.Builder();
this.server.enqueue(f.apply(builder).build());
}
private void expectRequest(Consumer<RecordedRequest> consumer) {
spring-web/src/test/java/org/springframework/web/client/RestClientVersionTests.java
+20 -16
View File
@@ -19,9 +19,9 @@ package org.springframework.web.client;
import java.io.IOException;
import java.util.function.Consumer;
import okhttp3.mockwebserver.MockResponse;
import okhttp3.mockwebserver.MockWebServer;
import okhttp3.mockwebserver.RecordedRequest;
import mockwebserver3.MockResponse;
import mockwebserver3.MockWebServer;
import mockwebserver3.RecordedRequest;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
@@ -39,46 +39,50 @@ public class RestClientVersionTests {
private final MockWebServer server = new MockWebServer();
private final RestClient.Builder restClientBuilder = RestClient.builder()
.requestFactory(new JdkClientHttpRequestFactory())
.baseUrl(this.server.url("/").toString());
private RestClient.Builder restClientBuilder;
@BeforeEach
void setUp() {
MockResponse response = new MockResponse();
response.setHeader("Content-Type", "text/plain").setBody("body");
void setUp() throws IOException {
this.server.start();
this.restClientBuilder = RestClient.builder()
.requestFactory(new JdkClientHttpRequestFactory())
.baseUrl(this.server.url("/").toString());
MockResponse response = new MockResponse.Builder()
.setHeader("Content-Type", "text/plain")
.body("body")
.build();
this.server.enqueue(response);
}
@AfterEach
void shutdown() throws IOException {
this.server.shutdown();
void shutdown() {
this.server.close();
}
@Test
void header() {
performRequest(ApiVersionInserter.useHeader("X-API-Version"));
expectRequest(request -> assertThat(request.getHeader("X-API-Version")).isEqualTo("1.2"));
expectRequest(request -> assertThat(request.getHeaders().get("X-API-Version")).isEqualTo("1.2"));
}
@Test
void queryParam() {
performRequest(ApiVersionInserter.useQueryParam("api-version"));
expectRequest(request -> assertThat(request.getPath()).isEqualTo("/path?api-version=1.2"));
expectRequest(request -> assertThat(request.getTarget()).isEqualTo("/path?api-version=1.2"));
}
@Test
void pathSegmentIndexLessThanSize() {
performRequest(ApiVersionInserter.builder().usePathSegment(0).withVersionFormatter(v -> "v" + v).build());
expectRequest(request -> assertThat(request.getPath()).isEqualTo("/v1.2/path"));
expectRequest(request -> assertThat(request.getTarget()).isEqualTo("/v1.2/path"));
}
@Test
void pathSegmentIndexEqualToSize() {
performRequest(ApiVersionInserter.builder().usePathSegment(1).withVersionFormatter(v -> "v" + v).build());
expectRequest(request -> assertThat(request.getPath()).isEqualTo("/path/v1.2"));
expectRequest(request -> assertThat(request.getTarget()).isEqualTo("/path/v1.2"));
}
@Test
@@ -94,7 +98,7 @@ public class RestClientVersionTests {
RestClient restClient = restClientBuilder.defaultApiVersion(1.2).apiVersionInserter(inserter).build();
restClient.get().uri("/path").retrieve().body(String.class);
expectRequest(request -> assertThat(request.getHeader("X-API-Version")).isEqualTo("1.2"));
expectRequest(request -> assertThat(request.getHeaders().get("X-API-Version")).isEqualTo("1.2"));
}
private void performRequest(ApiVersionInserter versionInserter) {
spring-web/src/test/java/org/springframework/web/client/RestTemplateTests.java
+10 -10
View File
@@ -28,9 +28,9 @@ import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import okhttp3.mockwebserver.MockResponse;
import okhttp3.mockwebserver.MockWebServer;
import okhttp3.mockwebserver.RecordedRequest;
import mockwebserver3.MockResponse;
import mockwebserver3.MockWebServer;
import mockwebserver3.RecordedRequest;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
@@ -504,18 +504,18 @@ class RestTemplateTests {
@Test // gh-23740
void headerAcceptAllOnPut() throws Exception {
try (MockWebServer server = new MockWebServer()) {
server.enqueue(new MockResponse().setResponseCode(500).setBody("internal server error"));
server.enqueue(new MockResponse.Builder().code(500).body("internal server error").build());
server.start();
template.setRequestFactory(new SimpleClientHttpRequestFactory());
template.put(server.url("/internal/server/error").uri(), null);
assertThat(server.takeRequest().getHeader("Accept")).isEqualTo("*/*");
assertThat(server.takeRequest().getHeaders().get("Accept")).isEqualTo("*/*");
}
}
@Test // gh-23740
void keepGivenAcceptHeaderOnPut() throws Exception {
try (MockWebServer server = new MockWebServer()) {
server.enqueue(new MockResponse().setResponseCode(500).setBody("internal server error"));
server.enqueue(new MockResponse.Builder().code(500).body("internal server error").build());
server.start();
HttpHeaders headers = new HttpHeaders();
headers.setAccept(Collections.singletonList(MediaType.APPLICATION_JSON));
@@ -582,11 +582,11 @@ class RestTemplateTests {
@Test // gh-23740
void headerAcceptAllOnDelete() throws Exception {
try (MockWebServer server = new MockWebServer()) {
server.enqueue(new MockResponse().setResponseCode(500).setBody("internal server error"));
server.enqueue(new MockResponse.Builder().code(500).body("internal server error").build());
server.start();
template.setRequestFactory(new SimpleClientHttpRequestFactory());
template.delete(server.url("/internal/server/error").uri());
assertThat(server.takeRequest().getHeader("Accept")).isEqualTo("*/*");
assertThat(server.takeRequest().getHeaders().get("Accept")).isEqualTo("*/*");
}
}
@@ -773,7 +773,7 @@ class RestTemplateTests {
@Test
void requestInterceptorWithBuffering() throws Exception {
try (MockWebServer server = new MockWebServer()) {
server.enqueue(new MockResponse().setResponseCode(200).setBody("Hello Spring!"));
server.enqueue(new MockResponse.Builder().code(200).body("Hello Spring!").build());
server.start();
template.setRequestFactory(new SimpleClientHttpRequestFactory());
template.setInterceptors(List.of((request, body, execution) -> {
@@ -793,7 +793,7 @@ class RestTemplateTests {
@Test
void buffering() throws Exception {
try (MockWebServer server = new MockWebServer()) {
server.enqueue(new MockResponse().setResponseCode(200).setBody("Hello Spring!"));
server.enqueue(new MockResponse.Builder().code(200).body("Hello Spring!").build());
server.start();
template.setRequestFactory(new SimpleClientHttpRequestFactory());
template.setBufferingPredicate((uri, httpMethod) -> true);
spring-web/src/test/java/org/springframework/web/client/support/RestClientAdapterTests.java
+52 -46
View File
@@ -28,15 +28,16 @@ import java.util.LinkedHashSet;
import java.util.Optional;
import java.util.Set;
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.stream.Stream;
import io.micrometer.observation.tck.TestObservationRegistry;
import okhttp3.mockwebserver.MockResponse;
import okhttp3.mockwebserver.MockWebServer;
import okhttp3.mockwebserver.RecordedRequest;
import mockwebserver3.MockResponse;
import mockwebserver3.MockWebServer;
import mockwebserver3.RecordedRequest;
import org.jspecify.annotations.Nullable;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;
@@ -82,10 +83,14 @@ class RestClientAdapterTests {
private final MockWebServer anotherServer = new MockWebServer();
@BeforeEach
void setUp() throws IOException {
this.anotherServer.start();
}
@AfterEach
void shutdown() throws IOException {
this.anotherServer.shutdown();
void shutdown() {
this.anotherServer.close();
}
@@ -96,7 +101,7 @@ class RestClientAdapterTests {
@interface ParameterizedAdapterTest {
}
public static Stream<Object[]> arguments() {
public static Stream<Object[]> arguments() throws IOException {
return Stream.of(
createArgsForAdapter((url, or) -> {
RestClient restClient = RestClient.builder().baseUrl(url).observationRegistry(or).build();
@@ -112,12 +117,15 @@ class RestClientAdapterTests {
@SuppressWarnings("resource")
private static Object[] createArgsForAdapter(
BiFunction<String, TestObservationRegistry, HttpExchangeAdapter> adapterFactory) {
BiFunction<String, TestObservationRegistry, HttpExchangeAdapter> adapterFactory) throws IOException {
MockWebServer server = new MockWebServer();
server.start();
MockResponse response = new MockResponse();
response.setHeader("Content-Type", "text/plain").setBody("Hello Spring!");
MockResponse response = new MockResponse.Builder()
.setHeader("Content-Type", "text/plain")
.body("Hello Spring!")
.build();
server.enqueue(response);
TestObservationRegistry registry = TestObservationRegistry.create();
@@ -137,7 +145,7 @@ class RestClientAdapterTests {
RecordedRequest request = server.takeRequest();
assertThat(response).isEqualTo("Hello Spring!");
assertThat(request.getMethod()).isEqualTo("GET");
assertThat(request.getPath()).isEqualTo("/greeting");
assertThat(request.getTarget()).isEqualTo("/greeting");
assertThat(registry).hasObservationWithNameEqualTo("http.client.requests").that()
.hasLowCardinalityKeyValue("uri", "/greeting");
}
@@ -151,7 +159,7 @@ class RestClientAdapterTests {
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(response.getBody()).isEqualTo("Hello Spring!");
assertThat(request.getMethod()).isEqualTo("GET");
assertThat(request.getPath()).isEqualTo("/greeting/456");
assertThat(request.getTarget()).isEqualTo("/greeting/456");
assertThat(registry).hasObservationWithNameEqualTo("http.client.requests").that()
.hasLowCardinalityKeyValue("uri", "/greeting/{id}");
}
@@ -165,15 +173,15 @@ class RestClientAdapterTests {
RecordedRequest request = server.takeRequest();
assertThat(response.orElse("empty")).isEqualTo("Hello Spring!");
assertThat(request.getMethod()).isEqualTo("GET");
assertThat(request.getRequestUrl().uri()).isEqualTo(dynamicUri);
assertThat(request.getUrl().uri()).isEqualTo(dynamicUri);
assertThat(registry).hasObservationWithNameEqualTo("http.client.requests").that()
.hasLowCardinalityKeyValue("uri", "none");
}
@Test
void greetingWithApiVersion() throws Exception {
prepareResponse(response ->
response.setHeader("Content-Type", "text/plain").setBody("Hello Spring 2!"));
prepareResponse(builder ->
builder.setHeader("Content-Type", "text/plain").body("Hello Spring 2!"));
RestClient restClient = RestClient.builder()
.baseUrl(anotherServer.url("/").toString())
@@ -186,14 +194,14 @@ class RestClientAdapterTests {
String actualResponse = service.getGreetingWithVersion();
RecordedRequest request = anotherServer.takeRequest();
assertThat(request.getHeader("X-API-Version")).isEqualTo("1.2");
assertThat(request.getHeaders().get("X-API-Version")).isEqualTo("1.2");
assertThat(actualResponse).isEqualTo("Hello Spring 2!");
}
@ParameterizedAdapterTest
void getWithUriBuilderFactory(MockWebServer server, Service service) throws InterruptedException {
prepareResponse(response ->
response.setHeader("Content-Type", "text/plain").setBody("Hello Spring 2!"));
prepareResponse(builder ->
builder.setHeader("Content-Type", "text/plain").body("Hello Spring 2!"));
String url = this.anotherServer.url("/").toString();
UriBuilderFactory factory = new DefaultUriBuilderFactory(url);
@@ -204,14 +212,14 @@ class RestClientAdapterTests {
assertThat(actualResponse.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(actualResponse.getBody()).isEqualTo("Hello Spring 2!");
assertThat(request.getMethod()).isEqualTo("GET");
assertThat(request.getPath()).isEqualTo("/greeting");
assertThat(request.getTarget()).isEqualTo("/greeting");
assertThat(server.getRequestCount()).isEqualTo(0);
}
@ParameterizedAdapterTest
void getWithFactoryPathVariableAndRequestParam(MockWebServer server, Service service) throws InterruptedException {
prepareResponse(response ->
response.setHeader("Content-Type", "text/plain").setBody("Hello Spring 2!"));
prepareResponse(builder ->
builder.setHeader("Content-Type", "text/plain").body("Hello Spring 2!"));
String url = this.anotherServer.url("/").toString();
UriBuilderFactory factory = new DefaultUriBuilderFactory(url);
@@ -222,14 +230,14 @@ class RestClientAdapterTests {
assertThat(actualResponse.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(actualResponse.getBody()).isEqualTo("Hello Spring 2!");
assertThat(request.getMethod()).isEqualTo("GET");
assertThat(request.getPath()).isEqualTo("/greeting/123?param=test");
assertThat(request.getTarget()).isEqualTo("/greeting/123?param=test");
assertThat(server.getRequestCount()).isEqualTo(0);
}
@ParameterizedAdapterTest
void getWithIgnoredUriBuilderFactory(MockWebServer server, Service service) throws InterruptedException {
prepareResponse(response ->
response.setHeader("Content-Type", "text/plain").setBody("Hello Spring 2!"));
prepareResponse(builder ->
builder.setHeader("Content-Type", "text/plain").body("Hello Spring 2!"));
URI dynamicUri = server.url("/greeting/123").uri();
UriBuilderFactory factory = new DefaultUriBuilderFactory(this.anotherServer.url("/").toString());
@@ -240,7 +248,7 @@ class RestClientAdapterTests {
assertThat(actualResponse.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(actualResponse.getBody()).isEqualTo("Hello Spring!");
assertThat(request.getMethod()).isEqualTo("GET");
assertThat(request.getPath()).isEqualTo("/greeting/123");
assertThat(request.getTarget()).isEqualTo("/greeting/123");
assertThat(this.anotherServer.getRequestCount()).isEqualTo(0);
}
@@ -250,9 +258,9 @@ class RestClientAdapterTests {
RecordedRequest request = server.takeRequest();
assertThat(request.getMethod()).isEqualTo("POST");
assertThat(request.getPath()).isEqualTo("/greeting");
assertThat(request.getTarget()).isEqualTo("/greeting");
assertThat(request.getHeaders().get("testHeaderName")).isEqualTo("testHeader");
assertThat(request.getBody().readUtf8()).isEqualTo("testBody");
assertThat(request.getBody().utf8()).isEqualTo("testBody");
}
@ParameterizedAdapterTest
@@ -265,7 +273,7 @@ class RestClientAdapterTests {
RecordedRequest request = server.takeRequest();
assertThat(request.getHeaders().get("Content-Type")).isEqualTo("application/x-www-form-urlencoded");
assertThat(request.getBody().readUtf8()).isEqualTo("param1=value+1&param2=value+2");
assertThat(request.getBody().utf8()).isEqualTo("param1=value+1&param2=value+2");
}
@ParameterizedAdapterTest // gh-30342
@@ -277,7 +285,7 @@ class RestClientAdapterTests {
RecordedRequest request = server.takeRequest();
assertThat(request.getHeaders().get("Content-Type")).startsWith("multipart/form-data;boundary=");
assertThat(request.getBody().readUtf8()).containsSubsequence(
assertThat(request.getBody().utf8()).containsSubsequence(
"Content-Disposition: form-data; name=\"file\"; filename=\"originalTestFileName\"",
"Content-Type: application/json", "Content-Length: 4", "test",
"Content-Disposition: form-data; name=\"anotherPart\"", "Content-Type: text/plain;charset=UTF-8",
@@ -293,8 +301,8 @@ class RestClientAdapterTests {
RecordedRequest request = server.takeRequest();
assertThat(request.getMethod()).isEqualTo("POST");
assertThat(request.getPath()).isEqualTo("/persons");
assertThat(request.getBody().readUtf8()).isEqualTo("[{\"name\":\"John\"},{\"name\":\"Richard\"}]");
assertThat(request.getTarget()).isEqualTo("/persons");
assertThat(request.getBody().utf8()).isEqualTo("[{\"name\":\"John\"},{\"name\":\"Richard\"}]");
}
@ParameterizedAdapterTest
@@ -303,7 +311,7 @@ class RestClientAdapterTests {
RecordedRequest request = server.takeRequest();
assertThat(request.getMethod()).isEqualTo("PUT");
assertThat(request.getHeader("Cookie")).isEqualTo("firstCookie=test1; secondCookie=test2");
assertThat(request.getHeaders().get("Cookie")).isEqualTo("firstCookie=test1; secondCookie=test2");
}
@ParameterizedAdapterTest
@@ -312,38 +320,37 @@ class RestClientAdapterTests {
RecordedRequest request = server.takeRequest();
assertThat(request.getMethod()).isEqualTo("PUT");
assertThat(request.getHeader("Cookie")).isEqualTo("testCookie=test1; testCookie=test2");
assertThat(request.getHeaders().get("Cookie")).isEqualTo("testCookie=test1; testCookie=test2");
}
@Test
void getInputStream() throws Exception {
prepareResponse(response ->
response.setHeader("Content-Type", "text/plain").setBody("Hello Spring 2!"));
prepareResponse(builder ->
builder.setHeader("Content-Type", "text/plain").body("Hello Spring 2!"));
InputStream inputStream = initService().getInputStream();
RecordedRequest request = this.anotherServer.takeRequest();
assertThat(request.getPath()).isEqualTo("/input-stream");
assertThat(request.getTarget()).isEqualTo("/input-stream");
assertThat(StreamUtils.copyToString(inputStream, StandardCharsets.UTF_8)).isEqualTo("Hello Spring 2!");
}
@Test
void postOutputStream() throws Exception {
prepareResponse(response ->
response.setHeader("Content-Type", "text/plain").setBody("Hello Spring 2!"));
prepareResponse(builder ->
builder.setHeader("Content-Type", "text/plain").body("Hello Spring 2!"));
String body = "test stream";
initService().postOutputStream(outputStream -> outputStream.write(body.getBytes()));
RecordedRequest request = this.anotherServer.takeRequest();
assertThat(request.getPath()).isEqualTo("/output-stream");
assertThat(request.getBody().readUtf8()).isEqualTo(body);
assertThat(request.getTarget()).isEqualTo("/output-stream");
assertThat(request.getBody().utf8()).isEqualTo(body);
}
@Test
void handleNotFoundException() {
MockResponse response = new MockResponse();
response.setResponseCode(404);
MockResponse response = new MockResponse.Builder().code(404).build();
this.anotherServer.enqueue(response);
RestClientAdapter clientAdapter = RestClientAdapter.create(
@@ -366,10 +373,9 @@ class RestClientAdapterTests {
return HttpServiceProxyFactory.builderFor(adapter).build().createClient(Service.class);
}
private void prepareResponse(Consumer<MockResponse> consumer) {
MockResponse response = new MockResponse();
consumer.accept(response);
this.anotherServer.enqueue(response);
private void prepareResponse(Function<MockResponse.Builder, MockResponse.Builder> f) {
MockResponse.Builder builder = new MockResponse.Builder();
this.anotherServer.enqueue(f.apply(builder).build());
}
spring-web/src/test/java/org/springframework/web/client/support/RestClientProxyRegistryIntegrationTests.java
+10 -12
View File
@@ -16,11 +16,9 @@
package org.springframework.web.client.support;
import java.io.IOException;
import okhttp3.mockwebserver.MockResponse;
import okhttp3.mockwebserver.MockWebServer;
import okhttp3.mockwebserver.RecordedRequest;
import mockwebserver3.MockResponse;
import mockwebserver3.MockWebServer;
import mockwebserver3.RecordedRequest;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
@@ -61,8 +59,8 @@ public class RestClientProxyRegistryIntegrationTests {
}
@AfterEach
void shutdown() throws IOException {
this.server.shutdown();
void shutdown() {
this.server.close();
}
@@ -89,7 +87,7 @@ public class RestClientProxyRegistryIntegrationTests {
assertThat(registry.getClient(GreetingB.class)).isSameAs(greetingB);
for (int i = 0; i < 4; i++) {
this.server.enqueue(new MockResponse().setBody("body"));
this.server.enqueue(new MockResponse.Builder().body("body").build());
}
echoA.handle("a");
@@ -97,22 +95,22 @@ public class RestClientProxyRegistryIntegrationTests {
RecordedRequest request = this.server.takeRequest();
assertThat(request.getMethod()).isEqualTo("GET");
assertThat(request.getPath()).isEqualTo("/echoA?input=a");
assertThat(request.getTarget()).isEqualTo("/echoA?input=a");
request = this.server.takeRequest();
assertThat(request.getMethod()).isEqualTo("GET");
assertThat(request.getPath()).isEqualTo("/echoB?input=b");
assertThat(request.getTarget()).isEqualTo("/echoB?input=b");
greetingA.handle("a");
greetingB.handle("b");
request = this.server.takeRequest();
assertThat(request.getMethod()).isEqualTo("GET");
assertThat(request.getPath()).isEqualTo("/greetingA?input=a");
assertThat(request.getTarget()).isEqualTo("/greetingA?input=a");
request = this.server.takeRequest();
assertThat(request.getMethod()).isEqualTo("GET");
assertThat(request.getPath()).isEqualTo("/greetingB?input=b");
assertThat(request.getTarget()).isEqualTo("/greetingB?input=b");
}
@Test
spring-web/src/test/kotlin/org/springframework/web/client/support/KotlinRestTemplateHttpServiceProxyTests.kt
+26 -22
View File
@@ -16,8 +16,8 @@
package org.springframework.web.client.support
import okhttp3.mockwebserver.MockResponse
import okhttp3.mockwebserver.MockWebServer
import mockwebserver3.MockResponse
import mockwebserver3.MockWebServer
import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.api.AfterEach
import org.junit.jupiter.api.BeforeEach
@@ -57,8 +57,10 @@ class KotlinRestTemplateHttpServiceProxyTests {
@BeforeEach
fun setUp() {
server = MockWebServer()
server.start()
prepareResponse()
anotherServer = anotherServer()
anotherServer.start()
testService = initTestService()
}
@@ -73,8 +75,8 @@ class KotlinRestTemplateHttpServiceProxyTests {
@AfterEach
fun shutDown() {
server.shutdown()
anotherServer.shutdown()
server.close()
anotherServer.close()
}
@Test
@@ -85,7 +87,7 @@ class KotlinRestTemplateHttpServiceProxyTests {
val request = server.takeRequest()
assertThat(response).isEqualTo("Hello Spring!")
assertThat(request.method).isEqualTo("GET")
assertThat(request.path).isEqualTo("/test")
assertThat(request.target).isEqualTo("/test")
}
@Test
@@ -97,20 +99,20 @@ class KotlinRestTemplateHttpServiceProxyTests {
assertThat(response.statusCode).isEqualTo(HttpStatus.OK)
assertThat(response.body).isEqualTo("Hello Spring!")
assertThat(request.method).isEqualTo("GET")
assertThat(request.path).isEqualTo("/test/456")
assertThat(request.target).isEqualTo("/test/456")
}
@Test
@Throws(InterruptedException::class)
fun getRequestWithDynamicUri() {
val dynamicUri = server.url("/greeting/123").uri()
val dynamicUri = server.url("/greeting/123").toUri()
val response = testService.getRequestWithDynamicUri(dynamicUri, "456")
val request = server.takeRequest()
assertThat(response.orElse("empty")).isEqualTo("Hello Spring!")
assertThat(request.method).isEqualTo("GET")
assertThat(request.requestUrl.uri()).isEqualTo(dynamicUri)
assertThat(request.url.toUri()).isEqualTo(dynamicUri)
}
@Test
@@ -120,9 +122,9 @@ class KotlinRestTemplateHttpServiceProxyTests {
val request = server.takeRequest()
assertThat(request.method).isEqualTo("POST")
assertThat(request.path).isEqualTo("/test")
assertThat(request.target).isEqualTo("/test")
assertThat(request.headers["testHeaderName"]).isEqualTo("testHeader")
assertThat(request.body.readUtf8()).isEqualTo("testBody")
assertThat(request.body!!.utf8()).isEqualTo("testBody")
}
@Test
@@ -136,7 +138,7 @@ class KotlinRestTemplateHttpServiceProxyTests {
val request = server.takeRequest()
assertThat(request.headers["Content-Type"]).isEqualTo("application/x-www-form-urlencoded")
assertThat(request.body.readUtf8()).isEqualTo("param1=value+1&param2=value+2")
assertThat(request.body!!.utf8()).isEqualTo("param1=value+1&param2=value+2")
}
// gh-30342
@@ -152,7 +154,7 @@ class KotlinRestTemplateHttpServiceProxyTests {
val request = server.takeRequest()
assertThat(request.headers["Content-Type"]).startsWith("multipart/form-data;boundary=")
assertThat(request.body.readUtf8()).containsSubsequence(
assertThat(request.body!!.utf8()).containsSubsequence(
"Content-Disposition: form-data; name=\"file\"; filename=\"originalTestFileName\"",
"Content-Type: application/json", "Content-Length: 4", "test",
"Content-Disposition: form-data; name=\"anotherPart\"", "Content-Type: text/plain;charset=UTF-8",
@@ -166,7 +168,7 @@ class KotlinRestTemplateHttpServiceProxyTests {
val request = server.takeRequest()
assertThat(request.method).isEqualTo("PUT")
assertThat(request.getHeader("Cookie"))
assertThat(request.headers["Cookie"])
.isEqualTo("firstCookie=test1; secondCookie=test2")
}
@@ -177,7 +179,7 @@ class KotlinRestTemplateHttpServiceProxyTests {
val request = server.takeRequest()
assertThat(request.method).isEqualTo("PUT")
assertThat(request.getHeader("Cookie"))
assertThat(request.headers["Cookie"])
.isEqualTo("testCookie=test1; testCookie=test2")
}
@@ -194,7 +196,7 @@ class KotlinRestTemplateHttpServiceProxyTests {
assertThat(actualResponse.statusCode).isEqualTo(HttpStatus.OK)
assertThat(actualResponse.body).isEqualTo("Hello Spring 2!")
assertThat(request.method).isEqualTo("GET")
assertThat(request.path).isEqualTo("/greeting")
assertThat(request.target).isEqualTo("/greeting")
assertThat(server.requestCount).isEqualTo(0)
}
@@ -212,14 +214,14 @@ class KotlinRestTemplateHttpServiceProxyTests {
assertThat(actualResponse.statusCode).isEqualTo(HttpStatus.OK)
assertThat(actualResponse.body).isEqualTo("Hello Spring 2!")
assertThat(request.method).isEqualTo("GET")
assertThat(request.path).isEqualTo("/greeting/123?param=test")
assertThat(request.target).isEqualTo("/greeting/123?param=test")
assertThat(server.requestCount).isEqualTo(0)
}
@Test
@Throws(InterruptedException::class)
fun getWithIgnoredUriBuilderFactory() {
val dynamicUri = server.url("/greeting/123").uri()
val dynamicUri = server.url("/greeting/123").toUri()
val factory: UriBuilderFactory = DefaultUriBuilderFactory(anotherServer.url("/")
.toString())
@@ -230,21 +232,23 @@ class KotlinRestTemplateHttpServiceProxyTests {
assertThat(actualResponse.statusCode).isEqualTo(HttpStatus.OK)
assertThat(actualResponse.body).isEqualTo("Hello Spring!")
assertThat(request.method).isEqualTo("GET")
assertThat(request.path).isEqualTo("/greeting/123")
assertThat(request.target).isEqualTo("/greeting/123")
assertThat(anotherServer.requestCount).isEqualTo(0)
}
private fun prepareResponse() {
val response = MockResponse()
response.setHeader("Content-Type", "text/plain").setBody("Hello Spring!")
val response = MockResponse.Builder()
.setHeader("Content-Type", "text/plain").body("Hello Spring!").build()
server.enqueue(response)
}
private fun anotherServer(): MockWebServer {
val anotherServer = MockWebServer()
val response = MockResponse()
response.setHeader("Content-Type", "text/plain").setBody("Hello Spring 2!")
val response = MockResponse.Builder()
.setHeader("Content-Type", "text/plain")
.body("Hello Spring 2!")
.build()
anotherServer.enqueue(response)
return anotherServer
}
spring-webflux/spring-webflux.gradle
+1 -1
View File
@@ -40,7 +40,7 @@ dependencies {
testImplementation(testFixtures(project(":spring-core")))
testImplementation(testFixtures(project(":spring-web")))
testImplementation("com.fasterxml:aalto-xml")
testImplementation("com.squareup.okhttp3:mockwebserver")
testImplementation("com.squareup.okhttp3:mockwebserver3")
testImplementation("io.micrometer:context-propagation")
testImplementation("io.micrometer:micrometer-observation-test")
testImplementation("io.projectreactor:reactor-test")
spring-webflux/src/test/java/org/springframework/web/reactive/function/client/WebClientDataBufferAllocatingTests.java
+34 -27
View File
@@ -16,6 +16,7 @@
package org.springframework.web.reactive.function.client;
import java.io.IOException;
import java.time.Duration;
import java.util.Collections;
import java.util.Map;
@@ -23,8 +24,8 @@ import java.util.function.Function;
import io.netty.buffer.ByteBufAllocator;
import io.netty.channel.ChannelOption;
import okhttp3.mockwebserver.MockResponse;
import okhttp3.mockwebserver.MockWebServer;
import mockwebserver3.MockResponse;
import mockwebserver3.MockWebServer;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.TestInstance;
@@ -71,9 +72,10 @@ class WebClientDataBufferAllocatingTests extends AbstractDataBufferAllocatingTes
this.factory.destroy();
}
private void setUp(DataBufferFactory bufferFactory) {
private void setUp(DataBufferFactory bufferFactory) throws IOException {
super.bufferFactory = bufferFactory;
this.server = new MockWebServer();
this.server.start();
this.webClient = WebClient
.builder()
.clientConnector(initConnector())
@@ -96,13 +98,14 @@ class WebClientDataBufferAllocatingTests extends AbstractDataBufferAllocatingTes
@ParameterizedDataBufferAllocatingTest
void bodyToMonoVoid(DataBufferFactory bufferFactory) {
void bodyToMonoVoid(DataBufferFactory bufferFactory) throws IOException {
setUp(bufferFactory);
this.server.enqueue(new MockResponse()
.setResponseCode(201)
this.server.enqueue(new MockResponse.Builder().
code(201)
.setHeader("Content-Type", "application/json")
.setChunkedBody("{\"foo\" : {\"bar\" : \"123\", \"baz\" : \"456\"}}", 5));
.chunkedBody("{\"foo\" : {\"bar\" : \"123\", \"baz\" : \"456\"}}", 5)
.build());
Mono<Void> mono = this.webClient.get()
.uri("/json").accept(MediaType.APPLICATION_JSON)
@@ -114,12 +117,13 @@ class WebClientDataBufferAllocatingTests extends AbstractDataBufferAllocatingTes
}
@ParameterizedDataBufferAllocatingTest // SPR-17482
void bodyToMonoVoidWithoutContentType(DataBufferFactory bufferFactory) {
void bodyToMonoVoidWithoutContentType(DataBufferFactory bufferFactory) throws IOException {
setUp(bufferFactory);
this.server.enqueue(new MockResponse()
.setResponseCode(HttpStatus.ACCEPTED.value())
.setChunkedBody("{\"foo\" : \"123\", \"baz\" : \"456\", \"baz\" : \"456\"}", 5));
this.server.enqueue(new MockResponse.Builder()
.code(HttpStatus.ACCEPTED.value())
.chunkedBody("{\"foo\" : \"123\", \"baz\" : \"456\", \"baz\" : \"456\"}", 5)
.build());
Mono<Map<String, String>> mono = this.webClient.get()
.uri("/sample").accept(MediaType.APPLICATION_JSON)
@@ -131,7 +135,7 @@ class WebClientDataBufferAllocatingTests extends AbstractDataBufferAllocatingTes
}
@ParameterizedDataBufferAllocatingTest
void onStatusWithBodyNotConsumed(DataBufferFactory bufferFactory) {
void onStatusWithBodyNotConsumed(DataBufferFactory bufferFactory) throws IOException {
setUp(bufferFactory);
RuntimeException ex = new RuntimeException("response error");
@@ -139,7 +143,7 @@ class WebClientDataBufferAllocatingTests extends AbstractDataBufferAllocatingTes
}
@ParameterizedDataBufferAllocatingTest
void onStatusWithBodyConsumed(DataBufferFactory bufferFactory) {
void onStatusWithBodyConsumed(DataBufferFactory bufferFactory) throws IOException {
setUp(bufferFactory);
RuntimeException ex = new RuntimeException("response error");
@@ -147,7 +151,7 @@ class WebClientDataBufferAllocatingTests extends AbstractDataBufferAllocatingTes
}
@ParameterizedDataBufferAllocatingTest // SPR-17473
void onStatusWithMonoErrorAndBodyNotConsumed(DataBufferFactory bufferFactory) {
void onStatusWithMonoErrorAndBodyNotConsumed(DataBufferFactory bufferFactory) throws IOException {
setUp(bufferFactory);
RuntimeException ex = new RuntimeException("response error");
@@ -155,7 +159,7 @@ class WebClientDataBufferAllocatingTests extends AbstractDataBufferAllocatingTes
}
@ParameterizedDataBufferAllocatingTest
void onStatusWithMonoErrorAndBodyConsumed(DataBufferFactory bufferFactory) {
void onStatusWithMonoErrorAndBodyConsumed(DataBufferFactory bufferFactory) throws IOException {
setUp(bufferFactory);
RuntimeException ex = new RuntimeException("response error");
@@ -163,7 +167,7 @@ class WebClientDataBufferAllocatingTests extends AbstractDataBufferAllocatingTes
}
@ParameterizedDataBufferAllocatingTest // gh-23230
void onStatusWithImmediateErrorAndBodyNotConsumed(DataBufferFactory bufferFactory) {
void onStatusWithImmediateErrorAndBodyNotConsumed(DataBufferFactory bufferFactory) throws IOException {
setUp(bufferFactory);
RuntimeException ex = new RuntimeException("response error");
@@ -173,13 +177,14 @@ class WebClientDataBufferAllocatingTests extends AbstractDataBufferAllocatingTes
}
@ParameterizedDataBufferAllocatingTest
void releaseBody(DataBufferFactory bufferFactory) {
void releaseBody(DataBufferFactory bufferFactory) throws IOException {
setUp(bufferFactory);
this.server.enqueue(new MockResponse()
.setResponseCode(200)
this.server.enqueue(new MockResponse.Builder()
.code(200)
.setHeader("Content-Type", "text/plain")
.setBody("foo bar"));
.body("foo bar")
.build());
Mono<Void> result = this.webClient.get()
.exchangeToMono(ClientResponse::releaseBody);
@@ -190,13 +195,14 @@ class WebClientDataBufferAllocatingTests extends AbstractDataBufferAllocatingTes
}
@ParameterizedDataBufferAllocatingTest
void exchangeToBodilessEntity(DataBufferFactory bufferFactory) {
void exchangeToBodilessEntity(DataBufferFactory bufferFactory) throws IOException {
setUp(bufferFactory);
this.server.enqueue(new MockResponse()
.setResponseCode(201)
this.server.enqueue(new MockResponse.Builder()
.code(201)
.setHeader("Foo", "bar")
.setBody("foo bar"));
.body("foo bar")
.build());
Mono<ResponseEntity<Void>> result = this.webClient.get()
.exchangeToMono(ClientResponse::toBodilessEntity);
@@ -217,10 +223,11 @@ class WebClientDataBufferAllocatingTests extends AbstractDataBufferAllocatingTes
HttpStatus errorStatus = HttpStatus.BAD_GATEWAY;
this.server.enqueue(new MockResponse()
.setResponseCode(errorStatus.value())
this.server.enqueue(new MockResponse.Builder()
.code(errorStatus.value())
.setHeader("Content-Type", "application/json")
.setChunkedBody("{\"error\" : {\"status\" : 502, \"message\" : \"Bad gateway.\"}}", 5));
.chunkedBody("{\"error\" : {\"status\" : 502, \"message\" : \"Bad gateway.\"}}", 5)
.build());
Mono<String> mono = this.webClient.get()
.uri("/json").accept(MediaType.APPLICATION_JSON)
spring-webflux/src/test/java/org/springframework/web/reactive/function/client/WebClientIntegrationTests.java
+222 -211
View File
@@ -16,7 +16,6 @@
package org.springframework.web.reactive.function.client;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
@@ -41,9 +40,9 @@ import java.util.stream.Collectors;
import java.util.stream.Stream;
import io.netty.util.Attribute;
import okhttp3.mockwebserver.MockResponse;
import okhttp3.mockwebserver.MockWebServer;
import okhttp3.mockwebserver.RecordedRequest;
import mockwebserver3.MockResponse;
import mockwebserver3.MockWebServer;
import mockwebserver3.RecordedRequest;
import org.eclipse.jetty.client.Request;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;
@@ -118,8 +117,9 @@ class WebClientIntegrationTests {
private WebClient webClient;
private void startServer(ClientHttpConnector connector) {
private void startServer(ClientHttpConnector connector) throws IOException {
this.server = new MockWebServer();
this.server.start();
this.webClient = WebClient
.builder()
.clientConnector(connector)
@@ -128,19 +128,20 @@ class WebClientIntegrationTests {
}
@AfterEach
void shutdown() throws IOException {
void shutdown() {
if (server != null) {
this.server.shutdown();
this.server.close();
}
}
@ParameterizedWebClientTest
void retrieve(ClientHttpConnector connector) {
void retrieve(ClientHttpConnector connector) throws IOException {
startServer(connector);
prepareResponse(response ->
response.setHeader("Content-Type", "text/plain").setBody("Hello Spring!"));
prepareResponse(builder -> builder
.setHeader("Content-Type", "text/plain")
.body("Hello Spring!"));
Mono<String> result = this.webClient.get()
.uri("/greeting")
@@ -156,20 +157,20 @@ class WebClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getHeader(HttpHeaders.COOKIE)).isEqualTo("testkey=testvalue");
assertThat(request.getHeader("X-Test-Header")).isEqualTo("testvalue");
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("*/*");
assertThat(request.getPath()).isEqualTo("/greeting");
assertThat(request.getHeaders().get(HttpHeaders.COOKIE)).isEqualTo("testkey=testvalue");
assertThat(request.getHeaders().get("X-Test-Header")).isEqualTo("testvalue");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("*/*");
assertThat(request.getTarget()).isEqualTo("/greeting");
});
}
@ParameterizedWebClientTest
void retrieveJson(ClientHttpConnector connector) {
void retrieveJson(ClientHttpConnector connector) throws IOException {
startServer(connector);
prepareResponse(response -> response
prepareResponse(builder -> builder
.setHeader("Content-Type", "application/json")
.setBody("{\"bar\":\"barbar\",\"foo\":\"foofoo\"}"));
.body("{\"bar\":\"barbar\",\"foo\":\"foofoo\"}"));
Mono<Pojo> result = this.webClient.get()
.uri("/pojo")
@@ -184,15 +185,15 @@ class WebClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getPath()).isEqualTo("/pojo");
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("application/json");
assertThat(request.getTarget()).isEqualTo("/pojo");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("application/json");
});
}
@ParameterizedWebClientTest
void applyAttributesToNativeRequest(ClientHttpConnector connector) {
void applyAttributesToNativeRequest(ClientHttpConnector connector) throws IOException {
startServer(connector);
prepareResponse(response -> {});
prepareResponse(Function.identity());
final AtomicReference<Object> nativeRequest = new AtomicReference<>();
Mono<Void> result = this.webClient.get()
@@ -227,12 +228,13 @@ class WebClientIntegrationTests {
@ParameterizedWebClientTest
void retrieveJsonWithParameterizedTypeReference(ClientHttpConnector connector) {
void retrieveJsonWithParameterizedTypeReference(ClientHttpConnector connector) throws IOException {
startServer(connector);
String content = "{\"containerValue\":{\"bar\":\"barbar\",\"foo\":\"foofoo\"}}";
prepareResponse(response -> response
.setHeader("Content-Type", "application/json").setBody(content));
prepareResponse(builder -> builder
.setHeader("Content-Type", "application/json")
.body(content));
Mono<ValueContainer<Pojo>> result = this.webClient.get()
.uri("/json").accept(MediaType.APPLICATION_JSON)
@@ -245,18 +247,19 @@ class WebClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getPath()).isEqualTo("/json");
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("application/json");
assertThat(request.getTarget()).isEqualTo("/json");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("application/json");
});
}
@ParameterizedWebClientTest
void retrieveJsonAsResponseEntity(ClientHttpConnector connector) {
void retrieveJsonAsResponseEntity(ClientHttpConnector connector) throws IOException {
startServer(connector);
String content = "{\"bar\":\"barbar\",\"foo\":\"foofoo\"}";
prepareResponse(response -> response
.setHeader("Content-Type", "application/json").setBody(content));
prepareResponse(builder -> builder
.setHeader("Content-Type", "application/json")
.body(content));
Mono<ResponseEntity<String>> result = this.webClient.get()
.uri("/json").accept(MediaType.APPLICATION_JSON)
@@ -274,17 +277,18 @@ class WebClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getPath()).isEqualTo("/json");
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("application/json");
assertThat(request.getTarget()).isEqualTo("/json");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("application/json");
});
}
@ParameterizedWebClientTest
void retrieveJsonAsBodilessEntity(ClientHttpConnector connector) {
void retrieveJsonAsBodilessEntity(ClientHttpConnector connector) throws IOException {
startServer(connector);
prepareResponse(response -> response
.setHeader("Content-Type", "application/json").setBody("{\"bar\":\"barbar\",\"foo\":\"foofoo\"}"));
prepareResponse(builder -> builder
.setHeader("Content-Type", "application/json")
.body("{\"bar\":\"barbar\",\"foo\":\"foofoo\"}"));
Mono<ResponseEntity<Void>> result = this.webClient.get()
.uri("/json").accept(MediaType.APPLICATION_JSON)
@@ -302,18 +306,18 @@ class WebClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getPath()).isEqualTo("/json");
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("application/json");
assertThat(request.getTarget()).isEqualTo("/json");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("application/json");
});
}
@ParameterizedWebClientTest
void retrieveJsonArray(ClientHttpConnector connector) {
void retrieveJsonArray(ClientHttpConnector connector) throws IOException {
startServer(connector);
prepareResponse(response -> response
prepareResponse(builder -> builder
.setHeader("Content-Type", "application/json")
.setBody("[{\"bar\":\"bar1\",\"foo\":\"foo1\"},{\"bar\":\"bar2\",\"foo\":\"foo2\"}]"));
.body("[{\"bar\":\"bar1\",\"foo\":\"foo1\"},{\"bar\":\"bar2\",\"foo\":\"foo2\"}]"));
Flux<Pojo> result = this.webClient.get()
.uri("/pojos")
@@ -329,18 +333,19 @@ class WebClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getPath()).isEqualTo("/pojos");
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("application/json");
assertThat(request.getTarget()).isEqualTo("/pojos");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("application/json");
});
}
@ParameterizedWebClientTest
void retrieveJsonArrayAsResponseEntityList(ClientHttpConnector connector) {
void retrieveJsonArrayAsResponseEntityList(ClientHttpConnector connector) throws IOException {
startServer(connector);
String content = "[{\"bar\":\"bar1\",\"foo\":\"foo1\"}, {\"bar\":\"bar2\",\"foo\":\"foo2\"}]";
prepareResponse(response -> response
.setHeader("Content-Type", "application/json").setBody(content));
prepareResponse(builder -> builder
.setHeader("Content-Type", "application/json")
.body(content));
Mono<ResponseEntity<List<Pojo>>> result = this.webClient.get()
.uri("/json").accept(MediaType.APPLICATION_JSON)
@@ -360,18 +365,19 @@ class WebClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getPath()).isEqualTo("/json");
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("application/json");
assertThat(request.getTarget()).isEqualTo("/json");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("application/json");
});
}
@ParameterizedWebClientTest
void retrieveJsonArrayAsResponseEntityFlux(ClientHttpConnector connector) {
void retrieveJsonArrayAsResponseEntityFlux(ClientHttpConnector connector) throws IOException {
startServer(connector);
String content = "[{\"bar\":\"bar1\",\"foo\":\"foo1\"}, {\"bar\":\"bar2\",\"foo\":\"foo2\"}]";
prepareResponse(response -> response
.setHeader("Content-Type", "application/json").setBody(content));
prepareResponse(builder -> builder
.setHeader("Content-Type", "application/json")
.body(content));
ResponseEntity<Flux<Pojo>> entity = this.webClient.get()
.uri("/json").accept(MediaType.APPLICATION_JSON)
@@ -393,18 +399,19 @@ class WebClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getPath()).isEqualTo("/json");
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("application/json");
assertThat(request.getTarget()).isEqualTo("/json");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("application/json");
});
}
@ParameterizedWebClientTest
void retrieveJsonArrayAsResponseEntityFluxWithBodyExtractor(ClientHttpConnector connector) {
void retrieveJsonArrayAsResponseEntityFluxWithBodyExtractor(ClientHttpConnector connector) throws IOException {
startServer(connector);
String content = "[{\"bar\":\"bar1\",\"foo\":\"foo1\"}, {\"bar\":\"bar2\",\"foo\":\"foo2\"}]";
prepareResponse(response -> response
.setHeader("Content-Type", "application/json").setBody(content));
prepareResponse(builder -> builder
.setHeader("Content-Type", "application/json")
.body(content));
ResponseEntity<Flux<Pojo>> entity = this.webClient.get()
.uri("/json").accept(MediaType.APPLICATION_JSON)
@@ -426,13 +433,13 @@ class WebClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getPath()).isEqualTo("/json");
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("application/json");
assertThat(request.getTarget()).isEqualTo("/json");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("application/json");
});
}
@Test // gh-24788
void retrieveJsonArrayAsBodilessEntityShouldReleasesConnection() {
void retrieveJsonArrayAsBodilessEntityShouldReleasesConnection() throws IOException {
// Constrain connection pool and make consecutive requests.
// 2nd request should hang if response was not drained.
@@ -440,6 +447,7 @@ class WebClientIntegrationTests {
ConnectionProvider connectionProvider = ConnectionProvider.create("test", 1);
this.server = new MockWebServer();
this.server.start();
WebClient webClient = WebClient
.builder()
.clientConnector(new ReactorClientHttpConnector(HttpClient.create(connectionProvider)))
@@ -455,9 +463,9 @@ class WebClientIntegrationTests {
.collect(Collectors.joining(",", "[", "]"))
.block();
prepareResponse(response -> response
prepareResponse(builder -> builder
.setHeader("Content-Type", "application/json")
.setBody(json));
.body(json));
Mono<ResponseEntity<Void>> result = webClient.get()
.uri("/json").accept(MediaType.APPLICATION_JSON)
@@ -476,19 +484,20 @@ class WebClientIntegrationTests {
expectRequestCount(i);
expectRequest(request -> {
assertThat(request.getPath()).isEqualTo("/json");
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("application/json");
assertThat(request.getTarget()).isEqualTo("/json");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("application/json");
});
}
}
@ParameterizedWebClientTest
void retrieveJsonAsSerializedText(ClientHttpConnector connector) {
void retrieveJsonAsSerializedText(ClientHttpConnector connector) throws IOException {
startServer(connector);
String content = "{\"bar\":\"barbar\",\"foo\":\"foofoo\"}";
prepareResponse(response -> response
.setHeader("Content-Type", "application/json").setBody(content));
prepareResponse(builder -> builder
.setHeader("Content-Type", "application/json")
.body(content));
Mono<String> result = this.webClient.get()
.uri("/json").accept(MediaType.APPLICATION_JSON)
@@ -501,20 +510,20 @@ class WebClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getPath()).isEqualTo("/json");
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("application/json");
assertThat(request.getTarget()).isEqualTo("/json");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("application/json");
});
}
@ParameterizedWebClientTest
@SuppressWarnings("rawtypes")
void retrieveJsonNull(ClientHttpConnector connector) {
void retrieveJsonNull(ClientHttpConnector connector) throws IOException {
startServer(connector);
prepareResponse(response -> response
.setResponseCode(200)
prepareResponse(builder -> builder
.code(200)
.setHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
.setBody("null"));
.body("null"));
Mono<Map> result = this.webClient.get()
.uri("/null")
@@ -525,10 +534,11 @@ class WebClientIntegrationTests {
}
@ParameterizedWebClientTest // SPR-15946
void retrieve404(ClientHttpConnector connector) {
void retrieve404(ClientHttpConnector connector) throws IOException {
startServer(connector);
prepareResponse(response -> response.setResponseCode(404)
prepareResponse(builder -> builder
.code(404)
.setHeader("Content-Type", "text/plain"));
Mono<String> result = this.webClient.get().uri("/greeting")
@@ -541,17 +551,19 @@ class WebClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("*/*");
assertThat(request.getPath()).isEqualTo("/greeting");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("*/*");
assertThat(request.getTarget()).isEqualTo("/greeting");
});
}
@ParameterizedWebClientTest
void retrieve404WithBody(ClientHttpConnector connector) {
void retrieve404WithBody(ClientHttpConnector connector) throws IOException {
startServer(connector);
prepareResponse(response -> response.setResponseCode(404)
.setHeader("Content-Type", "text/plain").setBody("Not Found"));
prepareResponse(builder -> builder
.code(404)
.setHeader("Content-Type", "text/plain")
.body("Not Found"));
Mono<String> result = this.webClient.get()
.uri("/greeting")
@@ -564,19 +576,19 @@ class WebClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("*/*");
assertThat(request.getPath()).isEqualTo("/greeting");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("*/*");
assertThat(request.getTarget()).isEqualTo("/greeting");
});
}
@ParameterizedWebClientTest
@SuppressWarnings("deprecation")
void retrieve500(ClientHttpConnector connector) {
void retrieve500(ClientHttpConnector connector) throws IOException {
startServer(connector);
String errorMessage = "Internal Server error";
prepareResponse(response -> response.setResponseCode(500)
.setHeader("Content-Type", "text/plain").setBody(errorMessage));
prepareResponse(builder -> builder.code(500)
.setHeader("Content-Type", "text/plain").body(errorMessage));
String path = "/greeting";
Mono<String> result = this.webClient.get()
@@ -602,17 +614,17 @@ class WebClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("*/*");
assertThat(request.getPath()).isEqualTo(path);
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("*/*");
assertThat(request.getTarget()).isEqualTo(path);
});
}
@ParameterizedWebClientTest
void retrieve500AsEntity(ClientHttpConnector connector) {
void retrieve500AsEntity(ClientHttpConnector connector) throws IOException {
startServer(connector);
prepareResponse(response -> response.setResponseCode(500)
.setHeader("Content-Type", "text/plain").setBody("Internal Server error"));
prepareResponse(builder -> builder.code(500)
.setHeader("Content-Type", "text/plain").body("Internal Server error"));
Mono<ResponseEntity<String>> result = this.webClient.get()
.uri("/").accept(MediaType.APPLICATION_JSON)
@@ -625,17 +637,17 @@ class WebClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getPath()).isEqualTo("/");
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("application/json");
assertThat(request.getTarget()).isEqualTo("/");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("application/json");
});
}
@ParameterizedWebClientTest
void retrieve500AsEntityList(ClientHttpConnector connector) {
void retrieve500AsEntityList(ClientHttpConnector connector) throws IOException {
startServer(connector);
prepareResponse(response -> response.setResponseCode(500)
.setHeader("Content-Type", "text/plain").setBody("Internal Server error"));
prepareResponse(builder -> builder.code(500)
.setHeader("Content-Type", "text/plain").body("Internal Server error"));
Mono<ResponseEntity<List<String>>> result = this.webClient.get()
.uri("/").accept(MediaType.APPLICATION_JSON)
@@ -648,17 +660,17 @@ class WebClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getPath()).isEqualTo("/");
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("application/json");
assertThat(request.getTarget()).isEqualTo("/");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("application/json");
});
}
@ParameterizedWebClientTest
void retrieve500AsBodilessEntity(ClientHttpConnector connector) {
void retrieve500AsBodilessEntity(ClientHttpConnector connector) throws IOException {
startServer(connector);
prepareResponse(response -> response.setResponseCode(500)
.setHeader("Content-Type", "text/plain").setBody("Internal Server error"));
prepareResponse(builder -> builder.code(500)
.setHeader("Content-Type", "text/plain").body("Internal Server error"));
Mono<ResponseEntity<Void>> result = this.webClient.get()
.uri("/").accept(MediaType.APPLICATION_JSON)
@@ -671,24 +683,24 @@ class WebClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getPath()).isEqualTo("/");
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("application/json");
assertThat(request.getTarget()).isEqualTo("/");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("application/json");
});
}
@ParameterizedWebClientTest
@SuppressWarnings("deprecation")
void retrieve555UnknownStatus(ClientHttpConnector connector) {
void retrieve555UnknownStatus(ClientHttpConnector connector) throws IOException {
startServer(connector);
int errorStatus = 555;
assertThat(HttpStatus.resolve(errorStatus)).isNull();
String errorMessage = "Something went wrong";
prepareResponse(response ->
response.setResponseCode(errorStatus)
.setHeader("Content-Type", "text/plain")
.setBody(errorMessage));
prepareResponse(builder -> builder
.code(errorStatus)
.setHeader("Content-Type", "text/plain")
.body(errorMessage));
Mono<String> result = this.webClient.get().uri("/unknownPage").retrieve().bodyToMono(String.class);
@@ -705,23 +717,23 @@ class WebClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("*/*");
assertThat(request.getPath()).isEqualTo("/unknownPage");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("*/*");
assertThat(request.getTarget()).isEqualTo("/unknownPage");
});
}
@ParameterizedWebClientTest // gh-31202
void retrieve929UnknownStatusCode(ClientHttpConnector connector) {
void retrieve929UnknownStatusCode(ClientHttpConnector connector) throws IOException {
startServer(connector);
int errorStatus = 929;
assertThat(HttpStatus.resolve(errorStatus)).isNull();
String errorMessage = "Something went wrong";
prepareResponse(response ->
response.setResponseCode(errorStatus)
prepareResponse(builder ->
builder.code(errorStatus)
.setHeader("Content-Type", "text/plain")
.setBody(errorMessage));
.body(errorMessage));
Mono<String> result = this.webClient.get().uri("/unknownPage").retrieve().bodyToMono(String.class);
@@ -739,17 +751,17 @@ class WebClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("*/*");
assertThat(request.getPath()).isEqualTo("/unknownPage");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("*/*");
assertThat(request.getTarget()).isEqualTo("/unknownPage");
});
}
@ParameterizedWebClientTest
void postPojoAsJson(ClientHttpConnector connector) {
void postPojoAsJson(ClientHttpConnector connector) throws IOException {
startServer(connector);
prepareResponse(response -> response.setHeader("Content-Type", "application/json")
.setBody("{\"bar\":\"BARBAR\",\"foo\":\"FOOFOO\"}"));
prepareResponse(builder -> builder.setHeader("Content-Type", "application/json")
.body("{\"bar\":\"BARBAR\",\"foo\":\"FOOFOO\"}"));
Mono<Pojo> result = this.webClient.post()
.uri("/pojo/capitalize")
@@ -766,19 +778,19 @@ class WebClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getPath()).isEqualTo("/pojo/capitalize");
assertThat(request.getBody().readUtf8()).isEqualTo("{\"bar\":\"barbar\",\"foo\":\"foofoo\"}");
assertThat(request.getHeader(HttpHeaders.CONTENT_LENGTH)).isEqualTo("31");
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("application/json");
assertThat(request.getHeader(HttpHeaders.CONTENT_TYPE)).isEqualTo("application/json");
assertThat(request.getTarget()).isEqualTo("/pojo/capitalize");
assertThat(request.getBody().utf8()).isEqualTo("{\"bar\":\"barbar\",\"foo\":\"foofoo\"}");
assertThat(request.getHeaders().get(HttpHeaders.CONTENT_LENGTH)).isEqualTo("31");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("application/json");
assertThat(request.getHeaders().get(HttpHeaders.CONTENT_TYPE)).isEqualTo("application/json");
});
}
@ParameterizedWebClientTest // SPR-16246
void postLargeTextFile(ClientHttpConnector connector) {
void postLargeTextFile(ClientHttpConnector connector) throws IOException {
startServer(connector);
prepareResponse(response -> {});
prepareResponse(Function.identity());
Resource resource = new ClassPathResource("largeTextFile.txt", getClass());
Flux<DataBuffer> body = DataBufferUtils.read(resource, DefaultDataBufferFactory.sharedInstance, 4096);
@@ -794,10 +806,8 @@ class WebClientIntegrationTests {
.verify(Duration.ofSeconds(5));
expectRequest(request -> {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
try {
request.getBody().copyTo(bos);
String actual = bos.toString(StandardCharsets.UTF_8);
String actual = request.getBody().utf8();
String expected = Files.readString(resource.getFile().toPath(), StandardCharsets.UTF_8);
assertThat(actual).isEqualTo(expected);
}
@@ -808,11 +818,11 @@ class WebClientIntegrationTests {
}
@ParameterizedWebClientTest
void statusHandler(ClientHttpConnector connector) {
void statusHandler(ClientHttpConnector connector) throws IOException {
startServer(connector);
prepareResponse(response -> response.setResponseCode(500)
.setHeader("Content-Type", "text/plain").setBody("Internal Server error"));
prepareResponse(builder -> builder.code(500)
.setHeader("Content-Type", "text/plain").body("Internal Server error"));
Mono<String> result = this.webClient.get()
.uri("/greeting")
@@ -826,17 +836,17 @@ class WebClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("*/*");
assertThat(request.getPath()).isEqualTo("/greeting");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("*/*");
assertThat(request.getTarget()).isEqualTo("/greeting");
});
}
@ParameterizedWebClientTest
void statusHandlerParameterizedTypeReference(ClientHttpConnector connector) {
void statusHandlerParameterizedTypeReference(ClientHttpConnector connector) throws IOException {
startServer(connector);
prepareResponse(response -> response.setResponseCode(500)
.setHeader("Content-Type", "text/plain").setBody("Internal Server error"));
prepareResponse(builder -> builder.code(500)
.setHeader("Content-Type", "text/plain").body("Internal Server error"));
Mono<String> result = this.webClient.get()
.uri("/greeting")
@@ -850,19 +860,19 @@ class WebClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("*/*");
assertThat(request.getPath()).isEqualTo("/greeting");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("*/*");
assertThat(request.getTarget()).isEqualTo("/greeting");
});
}
@ParameterizedWebClientTest
void statusHandlerWithErrorBodyTransformation(ClientHttpConnector connector) {
void statusHandlerWithErrorBodyTransformation(ClientHttpConnector connector) throws IOException {
startServer(connector);
prepareResponse(response -> response
.setResponseCode(500)
prepareResponse(builder -> builder
.code(500)
.setHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
.setBody("{\"bar\":\"barbar\",\"foo\":\"foofoo\"}")
.body("{\"bar\":\"barbar\",\"foo\":\"foofoo\"}")
);
Mono<String> result = this.webClient.get()
@@ -884,11 +894,12 @@ class WebClientIntegrationTests {
}
@ParameterizedWebClientTest
void statusHandlerRawStatus(ClientHttpConnector connector) {
void statusHandlerRawStatus(ClientHttpConnector connector) throws IOException {
startServer(connector);
prepareResponse(response -> response.setResponseCode(500)
.setHeader("Content-Type", "text/plain").setBody("Internal Server error"));
prepareResponse(builder -> builder.code(500)
.setHeader("Content-Type", "text/plain").body("Internal Server error")
);
Mono<String> result = this.webClient.get()
.uri("/greeting")
@@ -902,17 +913,17 @@ class WebClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("*/*");
assertThat(request.getPath()).isEqualTo("/greeting");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("*/*");
assertThat(request.getTarget()).isEqualTo("/greeting");
});
}
@ParameterizedWebClientTest
void statusHandlerSuppressedErrorSignal(ClientHttpConnector connector) {
void statusHandlerSuppressedErrorSignal(ClientHttpConnector connector) throws IOException {
startServer(connector);
prepareResponse(response -> response.setResponseCode(500)
.setHeader("Content-Type", "text/plain").setBody("Internal Server error"));
prepareResponse(builder -> builder.code(500)
.setHeader("Content-Type", "text/plain").body("Internal Server error"));
Mono<String> result = this.webClient.get()
.uri("/greeting")
@@ -926,18 +937,18 @@ class WebClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("*/*");
assertThat(request.getPath()).isEqualTo("/greeting");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("*/*");
assertThat(request.getTarget()).isEqualTo("/greeting");
});
}
@ParameterizedWebClientTest
void statusHandlerSuppressedErrorSignalWithFlux(ClientHttpConnector connector) {
void statusHandlerSuppressedErrorSignalWithFlux(ClientHttpConnector connector) throws IOException {
startServer(connector);
prepareResponse(response -> response.setResponseCode(500)
.setHeader("Content-Type", "text/plain").setBody("Internal Server error"));
prepareResponse(builder -> builder.code(500)
.setHeader("Content-Type", "text/plain").body("Internal Server error"));
Flux<String> result = this.webClient.get()
.uri("/greeting")
@@ -951,18 +962,18 @@ class WebClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("*/*");
assertThat(request.getPath()).isEqualTo("/greeting");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("*/*");
assertThat(request.getTarget()).isEqualTo("/greeting");
});
}
@ParameterizedWebClientTest
void statusHandlerSuppressedErrorSignalWithEntity(ClientHttpConnector connector) {
void statusHandlerSuppressedErrorSignalWithEntity(ClientHttpConnector connector) throws IOException {
startServer(connector);
String content = "Internal Server error";
prepareResponse(response -> response.setResponseCode(500)
.setHeader("Content-Type", "text/plain").setBody(content));
prepareResponse(builder -> builder.code(500)
.setHeader("Content-Type", "text/plain").body(content));
Mono<ResponseEntity<String>> result = this.webClient.get()
.uri("/").accept(MediaType.APPLICATION_JSON)
@@ -980,16 +991,16 @@ class WebClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getPath()).isEqualTo("/");
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("application/json");
assertThat(request.getTarget()).isEqualTo("/");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("application/json");
});
}
@ParameterizedWebClientTest
void exchangeForPlainText(ClientHttpConnector connector) {
void exchangeForPlainText(ClientHttpConnector connector) throws IOException {
startServer(connector);
prepareResponse(response -> response.setBody("Hello Spring!"));
prepareResponse(builder -> builder.body("Hello Spring!"));
Mono<String> result = this.webClient.get()
.uri("/greeting")
@@ -1002,19 +1013,19 @@ class WebClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getHeader("X-Test-Header")).isEqualTo("testvalue");
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("*/*");
assertThat(request.getPath()).isEqualTo("/greeting");
assertThat(request.getHeaders().get("X-Test-Header")).isEqualTo("testvalue");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("*/*");
assertThat(request.getTarget()).isEqualTo("/greeting");
});
}
@ParameterizedWebClientTest
void exchangeForJsonAsResponseEntity(ClientHttpConnector connector) {
void exchangeForJsonAsResponseEntity(ClientHttpConnector connector) throws IOException {
startServer(connector);
String content = "{\"bar\":\"barbar\",\"foo\":\"foofoo\"}";
prepareResponse(response -> response
.setHeader("Content-Type", "application/json").setBody(content));
prepareResponse(builder -> builder
.setHeader("Content-Type", "application/json").body(content));
Mono<ResponseEntity<Pojo>> result = this.webClient.get()
.uri("/json").accept(MediaType.APPLICATION_JSON)
@@ -1031,17 +1042,17 @@ class WebClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getPath()).isEqualTo("/json");
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("application/json");
assertThat(request.getTarget()).isEqualTo("/json");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("application/json");
});
}
@ParameterizedWebClientTest
void exchangeForJsonAsBodilessEntity(ClientHttpConnector connector) {
void exchangeForJsonAsBodilessEntity(ClientHttpConnector connector) throws IOException {
startServer(connector);
prepareResponse(response -> response
.setHeader("Content-Type", "application/json").setBody("{\"bar\":\"barbar\",\"foo\":\"foofoo\"}"));
prepareResponse(builder -> builder
.setHeader("Content-Type", "application/json").body("{\"bar\":\"barbar\",\"foo\":\"foofoo\"}"));
Mono<ResponseEntity<Void>> result = this.webClient.get()
.uri("/json").accept(MediaType.APPLICATION_JSON)
@@ -1058,18 +1069,18 @@ class WebClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getPath()).isEqualTo("/json");
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("application/json");
assertThat(request.getTarget()).isEqualTo("/json");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("application/json");
});
}
@ParameterizedWebClientTest
void exchangeForJsonArrayAsResponseEntity(ClientHttpConnector connector) {
void exchangeForJsonArrayAsResponseEntity(ClientHttpConnector connector) throws IOException {
startServer(connector);
String content = "[{\"bar\":\"bar1\",\"foo\":\"foo1\"}, {\"bar\":\"bar2\",\"foo\":\"foo2\"}]";
prepareResponse(response -> response
.setHeader("Content-Type", "application/json").setBody(content));
prepareResponse(builder -> builder
.setHeader("Content-Type", "application/json").body(content));
Mono<ResponseEntity<List<Pojo>>> result = this.webClient.get()
.uri("/json").accept(MediaType.APPLICATION_JSON)
@@ -1088,16 +1099,16 @@ class WebClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getPath()).isEqualTo("/json");
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("application/json");
assertThat(request.getTarget()).isEqualTo("/json");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("application/json");
});
}
@ParameterizedWebClientTest
void exchangeForEmptyBodyAsVoidEntity(ClientHttpConnector connector) {
void exchangeForEmptyBodyAsVoidEntity(ClientHttpConnector connector) throws IOException {
startServer(connector);
prepareResponse(response -> response.setHeader("Content-Length", "0").setBody(""));
prepareResponse(builder -> builder.addHeader("Content-Length", "0").body(""));
Mono<ResponseEntity<Void>> result = this.webClient.get()
.uri("/noContent")
@@ -1109,11 +1120,11 @@ class WebClientIntegrationTests {
}
@ParameterizedWebClientTest
void exchangeFor404(ClientHttpConnector connector) {
void exchangeFor404(ClientHttpConnector connector) throws IOException {
startServer(connector);
prepareResponse(response -> response.setResponseCode(404)
.setHeader("Content-Type", "text/plain").setBody("Not Found"));
prepareResponse(builder -> builder.code(404)
.setHeader("Content-Type", "text/plain").body("Not Found"));
Mono<ResponseEntity<Void>> result = this.webClient.get().uri("/greeting")
.exchangeToMono(ClientResponse::toBodilessEntity);
@@ -1125,20 +1136,20 @@ class WebClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("*/*");
assertThat(request.getPath()).isEqualTo("/greeting");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("*/*");
assertThat(request.getTarget()).isEqualTo("/greeting");
});
}
@ParameterizedWebClientTest
void exchangeForUnknownStatusCode(ClientHttpConnector connector) {
void exchangeForUnknownStatusCode(ClientHttpConnector connector) throws IOException {
startServer(connector);
int errorStatus = 555;
assertThat(HttpStatus.resolve(errorStatus)).isNull();
String errorMessage = "Something went wrong";
prepareResponse(response -> response.setResponseCode(errorStatus)
.setHeader("Content-Type", "text/plain").setBody(errorMessage));
prepareResponse(builder -> builder.code(errorStatus)
.setHeader("Content-Type", "text/plain").body(errorMessage));
Mono<ResponseEntity<Void>> result = this.webClient.get()
.uri("/unknownPage")
@@ -1151,17 +1162,17 @@ class WebClientIntegrationTests {
expectRequestCount(1);
expectRequest(request -> {
assertThat(request.getHeader(HttpHeaders.ACCEPT)).isEqualTo("*/*");
assertThat(request.getPath()).isEqualTo("/unknownPage");
assertThat(request.getHeaders().get(HttpHeaders.ACCEPT)).isEqualTo("*/*");
assertThat(request.getTarget()).isEqualTo("/unknownPage");
});
}
@ParameterizedWebClientTest
void filter(ClientHttpConnector connector) {
void filter(ClientHttpConnector connector) throws IOException {
startServer(connector);
prepareResponse(response -> response.setHeader("Content-Type", "text/plain")
.setBody("Hello Spring!"));
prepareResponse(builder -> builder.setHeader("Content-Type", "text/plain")
.body("Hello Spring!"));
WebClient filteredClient = this.webClient.mutate()
.filter((request, next) -> {
@@ -1182,11 +1193,11 @@ class WebClientIntegrationTests {
.verify(Duration.ofSeconds(3));
expectRequestCount(1);
expectRequest(request -> assertThat(request.getHeader("foo")).isEqualTo("bar"));
expectRequest(request -> assertThat(request.getHeaders().get("foo")).isEqualTo("bar"));
}
@ParameterizedWebClientTest
void filterForErrorHandling(ClientHttpConnector connector) {
void filterForErrorHandling(ClientHttpConnector connector) throws IOException {
startServer(connector);
ExchangeFilterFunction filter = ExchangeFilterFunction.ofResponseProcessor(
@@ -1201,8 +1212,9 @@ class WebClientIntegrationTests {
WebClient filteredClient = this.webClient.mutate().filter(filter).build();
// header not present
prepareResponse(response -> response
.setHeader("Content-Type", "text/plain").setBody("Hello Spring!"));
prepareResponse(builder -> builder
.setHeader("Content-Type", "text/plain")
.body("Hello Spring!"));
Mono<String> result = filteredClient.get()
.uri("/greeting")
@@ -1214,9 +1226,9 @@ class WebClientIntegrationTests {
// header present
prepareResponse(response -> response.setHeader("Content-Type", "text/plain")
prepareResponse(builder -> builder.setHeader("Content-Type", "text/plain")
.setHeader("Foo", "Bar")
.setBody("Hello Spring!"));
.body("Hello Spring!"));
result = filteredClient.get()
.uri("/greeting")
@@ -1230,14 +1242,14 @@ class WebClientIntegrationTests {
}
@ParameterizedWebClientTest
void exchangeResponseCookies(ClientHttpConnector connector) {
void exchangeResponseCookies(ClientHttpConnector connector) throws IOException {
startServer(connector);
prepareResponse(response -> response
prepareResponse(builder -> builder
.setHeader("Content-Type", "text/plain")
.addHeader("Set-Cookie", "testkey1=testvalue1") // TODO invalid ";" at the end
.addHeader("Set-Cookie", "testkey2=testvalue2; Max-Age=42; HttpOnly; SameSite=Lax; Secure")
.setBody("test"));
.body("test"));
this.webClient.get()
.uri("/test")
@@ -1289,12 +1301,12 @@ class WebClientIntegrationTests {
}
@ParameterizedWebClientTest
void retrieveTextDecodedToFlux(ClientHttpConnector connector) {
void retrieveTextDecodedToFlux(ClientHttpConnector connector) throws IOException {
startServer(connector);
prepareResponse(response -> response
.setHeader("Content-Type", "text/plain")
.setBody("Hey now"));
prepareResponse(builder -> builder
.addHeader("Content-Type", "text/plain")
.body("Hey now"));
Flux<String> result = this.webClient.get()
.uri("/")
@@ -1350,10 +1362,9 @@ class WebClientIntegrationTests {
});
}
private void prepareResponse(Consumer<MockResponse> consumer) {
MockResponse response = new MockResponse();
consumer.accept(response);
this.server.enqueue(response);
private void prepareResponse(Function<MockResponse.Builder, MockResponse.Builder> f) {
MockResponse.Builder builder = new MockResponse.Builder();
this.server.enqueue(f.apply(builder).build());
}
private void expectRequest(Consumer<RecordedRequest> consumer) {
spring-webflux/src/test/java/org/springframework/web/reactive/function/client/WebClientVersionTests.java
+18 -15
View File
@@ -19,9 +19,9 @@ package org.springframework.web.reactive.function.client;
import java.io.IOException;
import java.util.function.Consumer;
import okhttp3.mockwebserver.MockResponse;
import okhttp3.mockwebserver.MockWebServer;
import okhttp3.mockwebserver.RecordedRequest;
import mockwebserver3.MockResponse;
import mockwebserver3.MockWebServer;
import mockwebserver3.RecordedRequest;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
@@ -39,45 +39,48 @@ public class WebClientVersionTests {
private final MockWebServer server = new MockWebServer();
private final WebClient.Builder webClientBuilder =
WebClient.builder().baseUrl(this.server.url("/").toString());
private WebClient.Builder webClientBuilder;
@BeforeEach
void setUp() {
MockResponse response = new MockResponse();
response.setHeader("Content-Type", "text/plain").setBody("body");
void setUp() throws IOException {
this.server.start();
this.webClientBuilder = WebClient.builder().baseUrl(this.server.url("/").toString());
MockResponse response = new MockResponse.Builder()
.setHeader("Content-Type", "text/plain")
.body("body")
.build();
this.server.enqueue(response);
}
@AfterEach
void shutdown() throws IOException {
this.server.shutdown();
void shutdown() {
this.server.close();
}
@Test
void header() {
performRequest(ApiVersionInserter.useHeader("X-API-Version"));
expectRequest(request -> assertThat(request.getHeader("X-API-Version")).isEqualTo("1.2"));
expectRequest(request -> assertThat(request.getHeaders().get("X-API-Version")).isEqualTo("1.2"));
}
@Test
void queryParam() {
performRequest(ApiVersionInserter.useQueryParam("api-version"));
expectRequest(request -> assertThat(request.getPath()).isEqualTo("/path?api-version=1.2"));
expectRequest(request -> assertThat(request.getTarget()).isEqualTo("/path?api-version=1.2"));
}
@Test
void pathSegmentIndexLessThanSize() {
performRequest(ApiVersionInserter.builder().usePathSegment(0).withVersionFormatter(v -> "v" + v).build());
expectRequest(request -> assertThat(request.getPath()).isEqualTo("/v1.2/path"));
expectRequest(request -> assertThat(request.getTarget()).isEqualTo("/v1.2/path"));
}
@Test
void pathSegmentIndexEqualToSize() {
performRequest(ApiVersionInserter.builder().usePathSegment(1).withVersionFormatter(v -> "v" + v).build());
expectRequest(request -> assertThat(request.getPath()).isEqualTo("/path/v1.2"));
expectRequest(request -> assertThat(request.getTarget()).isEqualTo("/path/v1.2"));
}
@Test
@@ -93,7 +96,7 @@ public class WebClientVersionTests {
WebClient webClient = webClientBuilder.defaultApiVersion(1.2).apiVersionInserter(inserter).build();
webClient.get().uri("/path").retrieve().bodyToMono(String.class).block();
expectRequest(request -> assertThat(request.getHeader("X-API-Version")).isEqualTo("1.2"));
expectRequest(request -> assertThat(request.getHeaders().get("X-API-Version")).isEqualTo("1.2"));
}
private void performRequest(ApiVersionInserter versionInserter) {
spring-webflux/src/test/java/org/springframework/web/reactive/function/client/support/WebClientAdapterTests.java
+35 -33
View File
@@ -24,11 +24,11 @@ import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Set;
import java.util.function.Consumer;
import java.util.function.Function;
import okhttp3.mockwebserver.MockResponse;
import okhttp3.mockwebserver.MockWebServer;
import okhttp3.mockwebserver.RecordedRequest;
import mockwebserver3.MockResponse;
import mockwebserver3.MockWebServer;
import mockwebserver3.RecordedRequest;
import org.jspecify.annotations.Nullable;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
@@ -75,27 +75,29 @@ class WebClientAdapterTests {
@BeforeEach
void setUp() {
void setUp() throws IOException {
this.server = new MockWebServer();
this.server.start();
this.anotherServer = anotherServer();
this.anotherServer.start();
}
@SuppressWarnings("ConstantConditions")
@AfterEach
void shutdown() throws IOException {
void shutdown() {
if (this.server != null) {
this.server.shutdown();
this.server.close();
}
if (this.anotherServer != null) {
this.anotherServer.shutdown();
this.anotherServer.close();
}
}
@Test
void greeting() {
prepareResponse(response -> response.setHeader("Content-Type", "text/plain").setBody("Hello Spring!"));
prepareResponse(builder -> builder.setHeader("Content-Type", "text/plain").body("Hello Spring!"));
StepVerifier.create(initService().getGreeting())
.expectNext("Hello Spring!")
@@ -115,7 +117,7 @@ class WebClientAdapterTests {
})
.build();
prepareResponse(response -> response.setHeader("Content-Type", "text/plain").setBody("Hello Spring!"));
prepareResponse(response -> response.setHeader("Content-Type", "text/plain").body("Hello Spring!"));
StepVerifier.create(initService(webClient).getGreetingWithAttribute("myAttributeValue"))
.expectNext("Hello Spring!")
@@ -128,18 +130,18 @@ class WebClientAdapterTests {
@Test // gh-29624
void uri() throws Exception {
String expectedBody = "hello";
prepareResponse(response -> response.setResponseCode(200).setBody(expectedBody));
prepareResponse(response -> response.code(200).body(expectedBody));
URI dynamicUri = this.server.url("/greeting/123").uri();
String actualBody = initService().getGreetingById(dynamicUri, "456");
assertThat(actualBody).isEqualTo(expectedBody);
assertThat(this.server.takeRequest().getRequestUrl().uri()).isEqualTo(dynamicUri);
assertThat(this.server.takeRequest().getUrl().uri()).isEqualTo(dynamicUri);
}
@Test
void formData() throws Exception {
prepareResponse(response -> response.setResponseCode(201));
prepareResponse(response -> response.code(201));
MultiValueMap<String, String> map = new LinkedMultiValueMap<>();
map.add("param1", "value 1");
@@ -149,12 +151,12 @@ class WebClientAdapterTests {
RecordedRequest request = this.server.takeRequest();
assertThat(request.getHeaders().get("Content-Type")).isEqualTo("application/x-www-form-urlencoded");
assertThat(request.getBody().readUtf8()).isEqualTo("param1=value+1&param2=value+2");
assertThat(request.getBody().utf8()).isEqualTo("param1=value+1&param2=value+2");
}
@Test // gh-30342
void multipart() throws InterruptedException {
prepareResponse(response -> response.setResponseCode(201));
prepareResponse(response -> response.code(201));
String fileName = "testFileName";
String originalFileName = "originalTestFileName";
MultipartFile file = new MockMultipartFile(
@@ -164,7 +166,7 @@ class WebClientAdapterTests {
RecordedRequest request = this.server.takeRequest();
assertThat(request.getHeaders().get("Content-Type")).startsWith("multipart/form-data;boundary=");
assertThat(request.getBody().readUtf8())
assertThat(request.getBody().utf8())
.containsSubsequence("Content-Disposition: form-data; name=\"file\"; filename=\"originalTestFileName\"",
"Content-Type: application/json", "Content-Length: 4", "test",
"Content-Disposition: form-data; name=\"anotherPart\"",
@@ -173,7 +175,7 @@ class WebClientAdapterTests {
@Test // gh-34793
void postSet() throws InterruptedException {
prepareResponse(response -> response.setResponseCode(201));
prepareResponse(response -> response.code(201));
Set<Person> persons = new LinkedHashSet<>();
persons.add(new Person("John"));
@@ -183,54 +185,53 @@ class WebClientAdapterTests {
RecordedRequest request = server.takeRequest();
assertThat(request.getMethod()).isEqualTo("POST");
assertThat(request.getPath()).isEqualTo("/persons");
assertThat(request.getBody().readUtf8()).isEqualTo("[{\"name\":\"John\"},{\"name\":\"Richard\"}]");
assertThat(request.getTarget()).isEqualTo("/persons");
assertThat(request.getBody().utf8()).isEqualTo("[{\"name\":\"John\"},{\"name\":\"Richard\"}]");
}
@Test
void uriBuilderFactory() throws Exception {
String ignoredResponseBody = "hello";
prepareResponse(response -> response.setResponseCode(200).setBody(ignoredResponseBody));
prepareResponse(response -> response.code(200).body(ignoredResponseBody));
UriBuilderFactory factory = new DefaultUriBuilderFactory(this.anotherServer.url("/").toString());
String actualBody = initService().getWithUriBuilderFactory(factory);
assertThat(actualBody).isEqualTo(ANOTHER_SERVER_RESPONSE_BODY);
assertThat(this.anotherServer.takeRequest().getPath()).isEqualTo("/greeting");
assertThat(this.anotherServer.takeRequest().getTarget()).isEqualTo("/greeting");
assertThat(this.server.getRequestCount()).isEqualTo(0);
}
@Test
void uriBuilderFactoryWithPathVariableAndRequestParam() throws Exception {
String ignoredResponseBody = "hello";
prepareResponse(response -> response.setResponseCode(200).setBody(ignoredResponseBody));
prepareResponse(response -> response.code(200).body(ignoredResponseBody));
UriBuilderFactory factory = new DefaultUriBuilderFactory(this.anotherServer.url("/").toString());
String actualBody = initService().getWithUriBuilderFactory(factory, "123", "test");
assertThat(actualBody).isEqualTo(ANOTHER_SERVER_RESPONSE_BODY);
assertThat(this.anotherServer.takeRequest().getPath()).isEqualTo("/greeting/123?param=test");
assertThat(this.anotherServer.takeRequest().getTarget()).isEqualTo("/greeting/123?param=test");
assertThat(this.server.getRequestCount()).isEqualTo(0);
}
@Test
void ignoredUriBuilderFactory() throws Exception {
String expectedResponseBody = "hello";
prepareResponse(response -> response.setResponseCode(200).setBody(expectedResponseBody));
prepareResponse(response -> response.code(200).body(expectedResponseBody));
URI dynamicUri = this.server.url("/greeting/123").uri();
UriBuilderFactory factory = new DefaultUriBuilderFactory(this.anotherServer.url("/").toString());
String actualBody = initService().getWithIgnoredUriBuilderFactory(dynamicUri, factory);
assertThat(actualBody).isEqualTo(expectedResponseBody);
assertThat(this.server.takeRequest().getRequestUrl().uri()).isEqualTo(dynamicUri);
assertThat(this.server.takeRequest().getUrl().uri()).isEqualTo(dynamicUri);
assertThat(this.anotherServer.getRequestCount()).isEqualTo(0);
}
@Test
void handleNotFoundException() {
MockResponse response = new MockResponse();
response.setResponseCode(404);
MockResponse response = new MockResponse.Builder().code(404).build();
this.server.enqueue(response);
this.server.enqueue(response);
@@ -256,8 +257,10 @@ class WebClientAdapterTests {
private static MockWebServer anotherServer() {
MockWebServer anotherServer = new MockWebServer();
MockResponse response = new MockResponse();
response.setHeader("Content-Type", "text/plain").setBody(ANOTHER_SERVER_RESPONSE_BODY);
MockResponse response = new MockResponse.Builder()
.setHeader("Content-Type", "text/plain")
.body(ANOTHER_SERVER_RESPONSE_BODY)
.build();
anotherServer.enqueue(response);
return anotherServer;
}
@@ -272,10 +275,9 @@ class WebClientAdapterTests {
return HttpServiceProxyFactory.builderFor(adapter).build().createClient(Service.class);
}
private void prepareResponse(Consumer<MockResponse> consumer) {
MockResponse response = new MockResponse();
consumer.accept(response);
this.server.enqueue(response);
private void prepareResponse(Function<MockResponse.Builder, MockResponse.Builder> f) {
MockResponse.Builder builder = new MockResponse.Builder();
this.server.enqueue(f.apply(builder).build());
}
spring-webflux/src/test/java/org/springframework/web/reactive/function/client/support/WebClientProxyRegistryIntegrationTests.java
+10 -12
View File
@@ -16,11 +16,9 @@
package org.springframework.web.reactive.function.client.support;
import java.io.IOException;
import okhttp3.mockwebserver.MockResponse;
import okhttp3.mockwebserver.MockWebServer;
import okhttp3.mockwebserver.RecordedRequest;
import mockwebserver3.MockResponse;
import mockwebserver3.MockWebServer;
import mockwebserver3.RecordedRequest;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.params.ParameterizedTest;
@@ -59,8 +57,8 @@ public class WebClientProxyRegistryIntegrationTests {
}
@AfterEach
void shutdown() throws IOException {
this.server.shutdown();
void shutdown() {
this.server.close();
}
@@ -87,7 +85,7 @@ public class WebClientProxyRegistryIntegrationTests {
assertThat(registry.getClient(GreetingB.class)).isSameAs(greetingB);
for (int i = 0; i < 4; i++) {
this.server.enqueue(new MockResponse().setBody("body"));
this.server.enqueue(new MockResponse.Builder().body("body").build());
}
echoA.handle("a");
@@ -95,22 +93,22 @@ public class WebClientProxyRegistryIntegrationTests {
RecordedRequest request = this.server.takeRequest();
assertThat(request.getMethod()).isEqualTo("GET");
assertThat(request.getPath()).isEqualTo("/echoA?input=a");
assertThat(request.getTarget()).isEqualTo("/echoA?input=a");
request = this.server.takeRequest();
assertThat(request.getMethod()).isEqualTo("GET");
assertThat(request.getPath()).isEqualTo("/echoB?input=b");
assertThat(request.getTarget()).isEqualTo("/echoB?input=b");
greetingA.handle("a");
greetingB.handle("b");
request = this.server.takeRequest();
assertThat(request.getMethod()).isEqualTo("GET");
assertThat(request.getPath()).isEqualTo("/greetingA?input=a");
assertThat(request.getTarget()).isEqualTo("/greetingA?input=a");
request = this.server.takeRequest();
assertThat(request.getMethod()).isEqualTo("GET");
assertThat(request.getPath()).isEqualTo("/greetingB?input=b");
assertThat(request.getTarget()).isEqualTo("/greetingB?input=b");
}
spring-webflux/src/test/kotlin/org/springframework/web/reactive/function/client/support/WebClientHttpServiceProxyKotlinTests.kt
+23 -44
View File
@@ -16,8 +16,8 @@
package org.springframework.web.reactive.function.client.support
import kotlinx.coroutines.runBlocking
import okhttp3.mockwebserver.MockResponse
import okhttp3.mockwebserver.MockWebServer
import mockwebserver3.MockResponse
import mockwebserver3.MockWebServer
import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.api.AfterEach
import org.junit.jupiter.api.BeforeEach
@@ -39,7 +39,6 @@ import reactor.core.publisher.Mono
import reactor.test.StepVerifier
import java.net.URI
import java.time.Duration
import java.util.function.Consumer
/**
* Kotlin integration tests for [HTTP Service proxy][HttpServiceProxyFactory]
@@ -58,23 +57,20 @@ class KotlinWebClientHttpServiceGroupAdapterServiceProxyTests {
@BeforeEach
fun setUp() {
server = MockWebServer()
server.start()
anotherServer = anotherServer()
anotherServer.start()
}
@AfterEach
fun shutdown() {
server.shutdown()
anotherServer.shutdown()
server.close()
anotherServer.close()
}
@Test
fun greetingSuspending() {
prepareResponse { response: MockResponse ->
response.setHeader(
"Content-Type",
"text/plain"
).setBody("Hello Spring!")
}
prepareResponse { it.setHeader("Content-Type", "text/plain").body("Hello Spring!") }
runBlocking {
val greeting = initHttpService().getGreetingSuspending()
assertThat(greeting).isEqualTo("Hello Spring!")
@@ -83,12 +79,7 @@ class KotlinWebClientHttpServiceGroupAdapterServiceProxyTests {
@Test
fun greetingMono() {
prepareResponse { response: MockResponse ->
response.setHeader(
"Content-Type",
"text/plain"
).setBody("Hello Spring!")
}
prepareResponse { it.setHeader("Content-Type", "text/plain").body("Hello Spring!") }
StepVerifier.create(initHttpService().getGreetingMono())
.expectNext("Hello Spring!")
.expectComplete()
@@ -97,12 +88,7 @@ class KotlinWebClientHttpServiceGroupAdapterServiceProxyTests {
@Test
fun greetingBlocking() {
prepareResponse { response: MockResponse ->
response.setHeader(
"Content-Type",
"text/plain"
).setBody("Hello Spring!")
}
prepareResponse { it.setHeader("Content-Type", "text/plain").body("Hello Spring!") }
val greeting = initHttpService().getGreetingBlocking()
assertThat(greeting).isEqualTo("Hello Spring!")
}
@@ -117,12 +103,7 @@ class KotlinWebClientHttpServiceGroupAdapterServiceProxyTests {
next.exchange(request)
}
.build()
prepareResponse { response: MockResponse ->
response.setHeader(
"Content-Type",
"text/plain"
).setBody("Hello Spring!")
}
prepareResponse { it.setHeader("Content-Type", "text/plain").body("Hello Spring!") }
val service = initHttpService(webClient)
runBlocking {
val greeting = service.getGreetingSuspendingWithAttribute("myAttributeValue")
@@ -134,9 +115,7 @@ class KotlinWebClientHttpServiceGroupAdapterServiceProxyTests {
@Test
@Throws(InterruptedException::class)
fun getWithFactoryPathVariableAndRequestParam() {
prepareResponse { response: MockResponse ->
response.setHeader("Content-Type", "text/plain").setBody("Hello Spring!")
}
prepareResponse { it.setHeader("Content-Type", "text/plain").body("Hello Spring!") }
val factory: UriBuilderFactory = DefaultUriBuilderFactory(anotherServer.url("/").toString())
val actualResponse: ResponseEntity<String> =
@@ -146,17 +125,16 @@ class KotlinWebClientHttpServiceGroupAdapterServiceProxyTests {
assertThat(actualResponse.statusCode).isEqualTo(HttpStatus.OK)
assertThat(actualResponse.body).isEqualTo("Hello Spring 2!")
assertThat(request.method).isEqualTo("GET")
assertThat(request.path).isEqualTo("/greeting/123?param=test")
assertThat(request.target).isEqualTo("/greeting/123?param=test")
assertThat(server.requestCount).isEqualTo(0)
}
@Test
@Throws(InterruptedException::class)
fun getWithIgnoredUriBuilderFactory() {
prepareResponse { response: MockResponse ->
response.setHeader("Content-Type", "text/plain").setBody("Hello Spring!")
}
val dynamicUri = server.url("/greeting/123").uri()
prepareResponse {
it.setHeader("Content-Type", "text/plain").body("Hello Spring!") }
val dynamicUri = server.url("/greeting/123").toUri()
val factory: UriBuilderFactory = DefaultUriBuilderFactory(anotherServer.url("/").toString())
val actualResponse: ResponseEntity<String> =
@@ -166,7 +144,7 @@ class KotlinWebClientHttpServiceGroupAdapterServiceProxyTests {
assertThat(actualResponse.statusCode).isEqualTo(HttpStatus.OK)
assertThat(actualResponse.body).isEqualTo("Hello Spring!")
assertThat(request.method).isEqualTo("GET")
assertThat(request.path).isEqualTo("/greeting/123")
assertThat(request.target).isEqualTo("/greeting/123")
assertThat(anotherServer.requestCount).isEqualTo(0)
}
@@ -181,16 +159,17 @@ class KotlinWebClientHttpServiceGroupAdapterServiceProxyTests {
return HttpServiceProxyFactory.builderFor(adapter).build().createClient()
}
private fun prepareResponse(consumer: Consumer<MockResponse>) {
val response = MockResponse()
consumer.accept(response)
server.enqueue(response)
private fun prepareResponse(f: (MockResponse.Builder) -> MockResponse.Builder) {
val builder = MockResponse.Builder()
server.enqueue(f.invoke(builder).build())
}
private fun anotherServer(): MockWebServer {
val anotherServer = MockWebServer()
val response = MockResponse()
response.setHeader("Content-Type", "text/plain").setBody("Hello Spring 2!")
val response = MockResponse.Builder()
.setHeader("Content-Type", "text/plain")
.body("Hello Spring 2!")
.build()
anotherServer.enqueue(response)
return anotherServer
}