AssertJ support for WebTestClient

Closes gh-35737

Author: rstoyanchev

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

@@ -111,9 +111,10 @@ class DefaultWebTestClient implements WebTestClient {
 			Consumer<EntityExchangeResult<?>> entityResultConsumer,
 			@Nullable Duration responseTimeout, DefaultWebTestClientBuilder clientBuilder) {
 
-		this.wiretapConnector = new WiretapConnector(connector);
 		this.jsonEncoderDecoder = JsonEncoderDecoder.from(
 				exchangeStrategies.messageWriters(), exchangeStrategies.messageReaders());
+
+		this.wiretapConnector = new WiretapConnector(connector, this.jsonEncoderDecoder);
 		this.exchangeFunction = exchangeFactory.apply(this.wiretapConnector);
 		this.uriBuilderFactory = uriBuilderFactory;
 		this.defaultHeaders = headers;

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

@@ -36,6 +36,7 @@
 import org.springframework.http.ResponseCookie;
 import org.springframework.http.client.reactive.ClientHttpRequest;
 import org.springframework.http.client.reactive.ClientHttpResponse;
+import org.springframework.test.json.JsonConverterDelegate;
 import org.springframework.util.Assert;
 import org.springframework.util.MultiValueMap;
 
@@ -78,6 +79,8 @@ public class ExchangeResult {
 
 	private final @Nullable Object mockServerResult;
 
+	private final @Nullable JsonConverterDelegate converterDelegate;
+
 	/** Ensure single logging, for example, for expectAll. */
 	private boolean diagnosticsLogged;
 
@@ -93,10 +96,11 @@ public class ExchangeResult {
 	 * @param timeout how long to wait for content to materialize
 	 * @param uriTemplate the URI template used to set up the request, if any
 	 * @param serverResult the result of a mock server exchange if applicable.
+	 * @param converterDelegate for JSON decoding in AssertJ support
 	 */
 	ExchangeResult(ClientHttpRequest request, ClientHttpResponse response,
 			Mono<byte[]> requestBody, Mono<byte[]> responseBody, Duration timeout, @Nullable String uriTemplate,
-			@Nullable Object serverResult) {
+			@Nullable Object serverResult, @Nullable JsonConverterDelegate converterDelegate) {
 
 		Assert.notNull(request, "ClientHttpRequest is required");
 		Assert.notNull(response, "ClientHttpResponse is required");
@@ -110,6 +114,7 @@ public class ExchangeResult {
 		this.timeout = timeout;
 		this.uriTemplate = uriTemplate;
 		this.mockServerResult = serverResult;
+		this.converterDelegate = converterDelegate;
 	}
 
 	/**
@@ -123,6 +128,7 @@ public class ExchangeResult {
 		this.timeout = other.timeout;
 		this.uriTemplate = other.uriTemplate;
 		this.mockServerResult = other.mockServerResult;
+		this.converterDelegate = other.converterDelegate;
 		this.diagnosticsLogged = other.diagnosticsLogged;
 	}
 
@@ -206,6 +212,15 @@ public MultiValueMap<String, ResponseCookie> getResponseCookies() {
 		return this.mockServerResult;
 	}
 
+	/**
+	 * Return a {@link JsonConverterDelegate} based on the configured codecs.
+	 * Mainly for internal use from AssertJ support classes.
+	 * @since 7.0
+	 */
+	public @Nullable JsonConverterDelegate getJsonConverterDelegate() {
+		return this.converterDelegate;
+	}
+
 	/**
 	 * Execute the given Runnable, catch any {@link AssertionError}, log details
 	 * about the request and response at ERROR level under the class log

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

@@ -16,6 +16,7 @@
 
 package org.springframework.test.web.reactive.server;
 
+import java.nio.charset.StandardCharsets;
 import java.util.Collection;
 import java.util.Map;
 import java.util.stream.Stream;
@@ -25,11 +26,17 @@
 import org.springframework.core.ResolvableType;
 import org.springframework.core.codec.Decoder;
 import org.springframework.core.codec.Encoder;
+import org.springframework.core.io.buffer.DataBuffer;
+import org.springframework.core.io.buffer.DataBufferUtils;
+import org.springframework.core.io.buffer.DefaultDataBufferFactory;
 import org.springframework.http.MediaType;
 import org.springframework.http.codec.DecoderHttpMessageReader;
 import org.springframework.http.codec.EncoderHttpMessageWriter;
 import org.springframework.http.codec.HttpMessageReader;
 import org.springframework.http.codec.HttpMessageWriter;
+import org.springframework.test.json.JsonConverterDelegate;
+import org.springframework.util.Assert;
+import org.springframework.util.MimeTypeUtils;
 
 /**
  * {@link Encoder} and {@link Decoder} that is able to encode and decode
@@ -49,6 +56,14 @@ record JsonEncoderDecoder(Encoder<?> encoder, Decoder<?> decoder) {
 	private static final ResolvableType MAP_TYPE = ResolvableType.forClass(Map.class);
 
 
+	/**
+	 * Return a {@link JsonConverterDelegate} that uses the encoder and decoder.
+	 */
+	public JsonConverterDelegate createJsonConverterDelegate() {
+		return new CodecsJsonConverterDelegate();
+	}
+
+
 	/**
 	 * Create a {@link JsonEncoderDecoder} instance based on the specified
 	 * infrastructure.
@@ -107,4 +122,34 @@ record JsonEncoderDecoder(Encoder<?> encoder, Decoder<?> decoder) {
 				.orElse(null);
 	}
 
+
+	/**
+	 * Implementation that delegates to the contained Encoder and Decoder.
+	 */
+	private class CodecsJsonConverterDelegate implements JsonConverterDelegate {
+
+		@SuppressWarnings("unchecked")
+		@Override
+		public <T> T read(String content, ResolvableType targetType) {
+			byte[] bytes = content.getBytes(StandardCharsets.UTF_8);
+			DataBuffer buffer = DefaultDataBufferFactory.sharedInstance.wrap(bytes);
+			Object value = decoder().decode(buffer, targetType, MediaType.APPLICATION_JSON, null);
+			Assert.state(value != null, () -> "Could not decode JSON content: " + content);
+			return (T) value;
+		}
+
+		@SuppressWarnings("unchecked")
+		@Override
+		public <T> T map(Object value, ResolvableType targetType) {
+			DataBuffer buffer = ((Encoder<T>) encoder()).encodeValue((T) value,
+					DefaultDataBufferFactory.sharedInstance, targetType, MimeTypeUtils.APPLICATION_JSON, null);
+			try {
+				return read(buffer.toString(StandardCharsets.UTF_8), targetType);
+			}
+			finally {
+				DataBufferUtils.release(buffer);
+			}
+		}
+	}
+
 }

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

@@ -38,6 +38,7 @@
 import org.springframework.http.client.reactive.ClientHttpRequestDecorator;
 import org.springframework.http.client.reactive.ClientHttpResponse;
 import org.springframework.http.client.reactive.ClientHttpResponseDecorator;
+import org.springframework.test.json.JsonConverterDelegate;
 import org.springframework.util.Assert;
 
 /**
@@ -53,11 +54,14 @@ class WiretapConnector implements ClientHttpConnector {
 
 	private final ClientHttpConnector delegate;
 
+	private final @Nullable JsonConverterDelegate converterDelegate;
+
 	private final Map<String, ClientExchangeInfo> exchanges = new ConcurrentHashMap<>();
 
 
-	WiretapConnector(ClientHttpConnector delegate) {
+	WiretapConnector(ClientHttpConnector delegate, @Nullable JsonEncoderDecoder encoderDecoder) {
 		this.delegate = delegate;
+		this.converterDelegate = (encoderDecoder != null ? encoderDecoder.createJsonConverterDelegate() : null);
 	}
 
 
@@ -96,7 +100,8 @@ ExchangeResult getExchangeResult(String requestId, @Nullable String uriTemplate,
 				clientInfo.getRequest().getRecorder().getContent(),
 				clientInfo.getResponse().getRecorder().getContent(),
 				timeout, uriTemplate,
-				clientInfo.getResponse().getMockServerResult());
+				clientInfo.getResponse().getMockServerResult(),
+				this.converterDelegate);
 	}
 
 

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

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2002-present the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.test.web.reactive.server.assertj;
+
+
+import org.springframework.test.web.reactive.server.ExchangeResult;
+
+/**
+ * Default implementation of {@link WebTestClientResponse}.
+ *
+ * @author Rossen Stoyanchev
+ * @since 7.0
+ */
+final class DefaultWebTestClientResponse implements WebTestClientResponse {
+
+	private final ExchangeResult exchangeResult;
+
+
+	DefaultWebTestClientResponse(ExchangeResult exchangeResult) {
+		this.exchangeResult = exchangeResult;
+	}
+
+
+	@Override
+	public ExchangeResult getExchangeResult() {
+		return this.exchangeResult;
+	}
+
+	/**
+	 * Use AssertJ's {@link org.assertj.core.api.Assertions#assertThat assertThat} instead.
+	 */
+	@Override
+	public WebTestClientResponseAssert assertThat() {
+		return new WebTestClientResponseAssert(this);
+	}
+
+}

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

@@ -0,0 +1,163 @@
+/*
+ * Copyright 2002-present the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.test.web.reactive.server.assertj;
+
+import java.time.Duration;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.function.Consumer;
+
+import org.assertj.core.api.AbstractMapAssert;
+import org.assertj.core.api.Assertions;
+
+import org.springframework.http.ResponseCookie;
+
+/**
+ * AssertJ {@linkplain org.assertj.core.api.Assert assertions} that can be applied
+ * to {@link ResponseCookie cookies}.
+ *
+ * @author Rossen Stoyanchev
+ * @since 7.0
+ */
+public class ResponseCookieMapAssert
+		extends AbstractMapAssert<ResponseCookieMapAssert, Map<String, ResponseCookie>, String, ResponseCookie> {
+
+
+	public ResponseCookieMapAssert(ResponseCookie[] actual) {
+		super(toMap(actual), ResponseCookieMapAssert.class);
+		as("Cookies");
+	}
+
+	private static Map<String, ResponseCookie> toMap(ResponseCookie[] cookies) {
+		Map<String, ResponseCookie> map = new LinkedHashMap<>();
+		for (ResponseCookie cookie : cookies) {
+			map.putIfAbsent(cookie.getName(), cookie);
+		}
+		return map;
+	}
+
+
+	/**
+	 * Verify that the actual cookies contain a cookie with the given {@code name}.
+	 * @param name the name of an expected cookie
+	 * @see #containsKey
+	 */
+	public ResponseCookieMapAssert containsCookie(String name) {
+		return containsKey(name);
+	}
+
+	/**
+	 * Verify that the actual cookies contain cookies with the given {@code names}.
+	 * @param names the names of expected cookies
+	 * @see #containsKeys
+	 */
+	public ResponseCookieMapAssert containsCookies(String... names) {
+		return containsKeys(names);
+	}
+
+	/**
+	 * Verify that the actual cookies do not contain a cookie with the given
+	 * {@code name}.
+	 * @param name the name of a cookie that should not be present
+	 * @see #doesNotContainKey
+	 */
+	public ResponseCookieMapAssert doesNotContainCookie(String name) {
+		return doesNotContainKey(name);
+	}
+
+	/**
+	 * Verify that the actual cookies do not contain any cookies with the given
+	 * {@code names}.
+	 * @param names the names of cookies that should not be present
+	 * @see #doesNotContainKeys
+	 */
+	public ResponseCookieMapAssert doesNotContainCookies(String... names) {
+		return doesNotContainKeys(names);
+	}
+
+	/**
+	 * Verify that the actual cookies contain a cookie with the given {@code name}
+	 * that satisfies the given {@code cookieRequirements}.
+	 * @param name the name of an expected cookie
+	 * @param cookieRequirements the requirements for the cookie
+	 */
+	public ResponseCookieMapAssert hasCookieSatisfying(String name, Consumer<ResponseCookie> cookieRequirements) {
+		return hasEntrySatisfying(name, cookieRequirements);
+	}
+
+	/**
+	 * Verify that the actual cookies contain a cookie with the given {@code name}
+	 * whose {@linkplain ResponseCookie#getValue() value} is equal to the given one.
+	 * @param name the name of the cookie
+	 * @param expected the expected value of the cookie
+	 */
+	public ResponseCookieMapAssert hasValue(String name, String expected) {
+		return hasCookieSatisfying(name, cookie -> Assertions.assertThat(cookie.getValue()).isEqualTo(expected));
+	}
+
+	/**
+	 * Verify that the actual cookies contain a cookie with the given {@code name}
+	 * whose {@linkplain ResponseCookie#getMaxAge() max age} is equal to the given one.
+	 * @param name the name of the cookie
+	 * @param expected the expected max age of the cookie
+	 */
+	public ResponseCookieMapAssert hasMaxAge(String name, Duration expected) {
+		return hasCookieSatisfying(name, cookie -> Assertions.assertThat(cookie.getMaxAge()).isEqualTo(expected));
+	}
+
+	/**
+	 * Verify that the actual cookies contain a cookie with the given {@code name}
+	 * whose {@linkplain ResponseCookie#getPath() path} is equal to the given one.
+	 * @param name the name of the cookie
+	 * @param expected the expected path of the cookie
+	 */
+	public ResponseCookieMapAssert hasPath(String name, String expected) {
+		return hasCookieSatisfying(name, cookie -> Assertions.assertThat(cookie.getPath()).isEqualTo(expected));
+	}
+
+	/**
+	 * Verify that the actual cookies contain a cookie with the given {@code name}
+	 * whose {@linkplain ResponseCookie#getDomain() domain} is equal to the given one.
+	 * @param name the name of the cookie
+	 * @param expected the expected domain of the cookie
+	 */
+	public ResponseCookieMapAssert hasDomain(String name, String expected) {
+		return hasCookieSatisfying(name, cookie -> Assertions.assertThat(cookie.getDomain()).isEqualTo(expected));
+	}
+
+	/**
+	 * Verify that the actual cookies contain a cookie with the given {@code name}
+	 * whose {@linkplain ResponseCookie#isSecure() secure flag} is equal to the give one.
+	 * @param name the name of the cookie
+	 * @param expected whether the cookie is secure
+	 */
+	public ResponseCookieMapAssert isSecure(String name, boolean expected) {
+		return hasCookieSatisfying(name, cookie -> Assertions.assertThat(cookie.isSecure()).isEqualTo(expected));
+	}
+
+	/**
+	 * Verify that the actual cookies contain a cookie with the given {@code name}
+	 * whose {@linkplain ResponseCookie#isHttpOnly() http only flag} is equal to the given
+	 * one.
+	 * @param name the name of the cookie
+	 * @param expected whether the cookie is http only
+	 */
+	public ResponseCookieMapAssert isHttpOnly(String name, boolean expected) {
+		return hasCookieSatisfying(name, cookie -> Assertions.assertThat(cookie.isHttpOnly()).isEqualTo(expected));
+	}
+
+}