Decouple ExchangeResult from WiretapRequest/Response

This commit decouples ExchangeResult from knowledge about
WiretapClientHttpRequest/Response both of which are now private to
WiretapConnector.

ExchangeResult takes ClientHttpRequest/Response instead along with
promises for the serialized request and response content in the form
of MonoProcessor<byte[]>.

This sets up the possibility for an ExchangeResult to be created
outside and independent of WebTestClient, should we decide to make its
constructor public.

Issue: SPR-16101

Author: rstoyanchev

spring-test/src/main/java/org/springframework/test/web/reactive/server/DefaultWebTestClient.java

@@ -281,50 +281,50 @@ public RequestHeadersSpec<?> syncBody(Object body) {
 		public ResponseSpec exchange() {
 			ClientResponse clientResponse = this.bodySpec.exchange().block(getTimeout());
 			Assert.state(clientResponse != null, "No ClientResponse");
-			ExchangeResult exchangeResult = wiretapConnector.claimRequest(this.requestId);
-			return new DefaultResponseSpec(exchangeResult, clientResponse, this.uriTemplate, getTimeout());
+			WiretapConnector.Info info = wiretapConnector.claimRequest(this.requestId);
+			return new DefaultResponseSpec(info, clientResponse, this.uriTemplate, getTimeout());
 		}
 	}
 
 
 	private static class DefaultResponseSpec implements ResponseSpec {
 
-		private final ExchangeResult result;
+		private final ExchangeResult exchangeResult;
 
 		private final ClientResponse response;
 
 		private final Duration timeout;
 
 
-		DefaultResponseSpec(ExchangeResult result, ClientResponse response,
+		DefaultResponseSpec(WiretapConnector.Info wiretapInfo, ClientResponse response,
 				@Nullable String uriTemplate, Duration timeout) {
 
-			this.result = new ExchangeResult(result, uriTemplate);
+			this.exchangeResult = wiretapInfo.createExchangeResult(uriTemplate);
 			this.response = response;
 			this.timeout = timeout;
 		}
 
 		@Override
 		public StatusAssertions expectStatus() {
-			return new StatusAssertions(this.result, this);
+			return new StatusAssertions(this.exchangeResult, this);
 		}
 
 		@Override
 		public HeaderAssertions expectHeader() {
-			return new HeaderAssertions(this.result, this);
+			return new HeaderAssertions(this.exchangeResult, this);
 		}
 
 		@Override
 		public <B> BodySpec<B, ?> expectBody(Class<B> bodyType) {
 			B body = this.response.bodyToMono(bodyType).block(this.timeout);
-			EntityExchangeResult<B> entityResult = new EntityExchangeResult<>(this.result, body);
+			EntityExchangeResult<B> entityResult = new EntityExchangeResult<>(this.exchangeResult, body);
 			return new DefaultBodySpec<>(entityResult);
 		}
 
 		@Override
 		public <B> BodySpec<B, ?> expectBody(ParameterizedTypeReference<B> bodyType) {
 			B body = this.response.bodyToMono(bodyType).block(this.timeout);
-			EntityExchangeResult<B> entityResult = new EntityExchangeResult<>(this.result, body);
+			EntityExchangeResult<B> entityResult = new EntityExchangeResult<>(this.exchangeResult, body);
 			return new DefaultBodySpec<>(entityResult);
 		}
 
@@ -341,28 +341,28 @@ public <E> ListBodySpec<E> expectBodyList(ParameterizedTypeReference<E> elementT
 
 		private <E> ListBodySpec<E> getListBodySpec(Flux<E> flux) {
 			List<E> body = flux.collectList().block(this.timeout);
-			EntityExchangeResult<List<E>> entityResult = new EntityExchangeResult<>(this.result, body);
+			EntityExchangeResult<List<E>> entityResult = new EntityExchangeResult<>(this.exchangeResult, body);
 			return new DefaultListBodySpec<>(entityResult);
 		}
 
 		@Override
 		public BodyContentSpec expectBody() {
 			ByteArrayResource resource = this.response.bodyToMono(ByteArrayResource.class).block(this.timeout);
 			byte[] body = (resource != null ? resource.getByteArray() : null);
-			EntityExchangeResult<byte[]> entityResult = new EntityExchangeResult<>(this.result, body);
+			EntityExchangeResult<byte[]> entityResult = new EntityExchangeResult<>(this.exchangeResult, body);
 			return new DefaultBodyContentSpec(entityResult);
 		}
 
 		@Override
 		public <T> FluxExchangeResult<T> returnResult(Class<T> elementType) {
 			Flux<T> body = this.response.bodyToFlux(elementType);
-			return new FluxExchangeResult<>(this.result, body, this.timeout);
+			return new FluxExchangeResult<>(this.exchangeResult, body, this.timeout);
 		}
 
 		@Override
 		public <T> FluxExchangeResult<T> returnResult(ParameterizedTypeReference<T> elementType) {
 			Flux<T> body = this.response.bodyToFlux(elementType);
-			return new FluxExchangeResult<>(this.result, body, this.timeout);
+			return new FluxExchangeResult<>(this.exchangeResult, body, this.timeout);
 		}
 	}
 

spring-test/src/main/java/org/springframework/test/web/reactive/server/ExchangeResult.java

@@ -31,6 +31,8 @@
 import org.springframework.http.HttpStatus;
 import org.springframework.http.MediaType;
 import org.springframework.http.ResponseCookie;
+import org.springframework.http.client.reactive.ClientHttpRequest;
+import org.springframework.http.client.reactive.ClientHttpResponse;
 import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 import org.springframework.util.MultiValueMap;
@@ -58,31 +60,41 @@ public class ExchangeResult {
 			MediaType.parseMediaType("text/*"), MediaType.APPLICATION_FORM_URLENCODED);
 
 
-	private final WiretapClientHttpRequest request;
+	private final ClientHttpRequest request;
 
-	private final WiretapClientHttpResponse response;
+	private final ClientHttpResponse response;
+
+	private final MonoProcessor<byte[]> requestBody;
+
+	private final MonoProcessor<byte[]> responseBody;
 
 	@Nullable
 	private final String uriTemplate;
 
 
 	/**
-	 * Constructor to use after the server response is first received in the
-	 * {@link WiretapConnector} and the {@code ClientHttpResponse} created.
+	 * Create an instance with an HTTP request and response along with promises
+	 * for the serialized request and response body content.
+	 *
+	 * @param request the HTTP request
+	 * @param response the HTTP response
+	 * @param requestBody capture of serialized request body content
+	 * @param responseBody capture of serialized response body content
+	 * @param uriTemplate the URI template used to set up the request, if any
 	 */
-	ExchangeResult(WiretapClientHttpRequest request, WiretapClientHttpResponse response) {
+	ExchangeResult(ClientHttpRequest request, ClientHttpResponse response,
+			MonoProcessor<byte[]> requestBody, MonoProcessor<byte[]> responseBody,
+			@Nullable String uriTemplate) {
+
+		Assert.notNull(request, "ClientHttpRequest is required");
+		Assert.notNull(response, "ClientHttpResponse is required");
+		Assert.notNull(requestBody, "'requestBody' is required");
+		Assert.notNull(responseBody, "'responseBody' is required");
+
 		this.request = request;
 		this.response = response;
-		this.uriTemplate = null;
-	}
-
-	/**
-	 * Constructor to copy the from the yet undecoded ExchangeResult with extra
-	 * information to expose such as the original URI template used, if any.
-	 */
-	ExchangeResult(ExchangeResult other, @Nullable String uriTemplate) {
-		this.request = other.request;
-		this.response = other.response;
+		this.requestBody = requestBody;
+		this.responseBody = responseBody;
 		this.uriTemplate = uriTemplate;
 	}
 
@@ -92,6 +104,8 @@ public class ExchangeResult {
 	ExchangeResult(ExchangeResult other) {
 		this.request = other.request;
 		this.response = other.response;
+		this.requestBody = other.requestBody;
+		this.responseBody = other.responseBody;
 		this.uriTemplate = other.uriTemplate;
 	}
 
@@ -131,7 +145,7 @@ public HttpHeaders getRequestHeaders() {
 	 */
 	@Nullable
 	public byte[] getRequestBodyContent() {
-		MonoProcessor<byte[]> body = this.request.getRecordedContent();
+		MonoProcessor<byte[]> body = this.requestBody;
 		Assert.isTrue(body.isTerminated(), "Request body incomplete.");
 		return body.block(Duration.ZERO);
 	}
@@ -164,7 +178,7 @@ public MultiValueMap<String, ResponseCookie> getResponseCookies() {
 	 */
 	@Nullable
 	public byte[] getResponseBodyContent() {
-		MonoProcessor<byte[]> body = this.response.getRecordedContent();
+		MonoProcessor<byte[]> body = this.responseBody;
 		Assert.state(body.isTerminated(), "Response body incomplete");
 		return body.block(Duration.ZERO);
 	}
@@ -191,12 +205,12 @@ public String toString() {
 				"> " + getMethod() + " " + getUrl() + "\n" +
 				"> " + formatHeaders(getRequestHeaders(), "\n> ") + "\n" +
 				"\n" +
-				formatBody(getRequestHeaders().getContentType(), this.request.getRecordedContent()) + "\n" +
+				formatBody(getRequestHeaders().getContentType(), this.requestBody) + "\n" +
 				"\n" +
 				"< " + getStatus() + " " + getStatusReason() + "\n" +
 				"< " + formatHeaders(getResponseHeaders(), "\n< ") + "\n" +
 				"\n" +
-				formatBody(getResponseHeaders().getContentType(), this.response.getRecordedContent()) +"\n";
+				formatBody(getResponseHeaders().getContentType(), this.responseBody) +"\n";
 	}
 
 	private String getStatusReason() {