Polishing

sbrannen · sbrannen · commit 3ce79c3fbf9a · 2024-05-08T11:54:55.000+03:00
diff --git a/spring-test/src/main/java/org/springframework/test/json/AbstractJsonContentAssert.java b/spring-test/src/main/java/org/springframework/test/json/AbstractJsonContentAssert.java
@@ -44,17 +44,17 @@
 import org.springframework.util.function.ThrowingBiFunction;
 
 /**
- * Base AssertJ {@link org.assertj.core.api.Assert assertions} that can be
+ * Base AssertJ {@linkplain org.assertj.core.api.Assert assertions} that can be
  * applied to a JSON document.
  *
- * <p>Support evaluating {@linkplain JsonPath JSON path} expressions and
+ * <p>Supports evaluating {@linkplain JsonPath JSON path} expressions and
  * extracting a part of the document for further {@linkplain JsonPathValueAssert
  * assertions} on the value.
  *
- * <p>Also support comparing the JSON document against a target, using
+ * <p>Also supports comparing the JSON document against a target, using
  * {@linkplain JSONCompare JSON Assert}. Resources that are loaded from
  * the classpath can be relative if a {@linkplain #withResourceLoadClass(Class)
- * class} is provided. By default, {@code UTF-8} is used to load resources
+ * class} is provided. By default, {@code UTF-8} is used to load resources,
  * but this can be overridden using {@link #withCharset(Charset)}.
  *
  * @author Stephane Nicoll
@@ -85,7 +85,7 @@ public abstract class AbstractJsonContentAssert<SELF extends AbstractJsonContent
 	/**
 	 * Create an assert for the given JSON document.
 	 * <p>Path can be converted to a value object using the given
-	 * {@linkplain GenericHttpMessageConverter json message converter}.
+	 * {@linkplain GenericHttpMessageConverter JSON message converter}.
 	 * @param json the JSON document to assert
 	 * @param jsonMessageConverter the converter to use
 	 * @param selfType the implementation type of this assert
@@ -379,12 +379,13 @@ public SELF isNotStrictlyEqualTo(Resource expected) {
 	}
 
 	/**
-	 * Override the class used to load resources. Resources can be loaded from
-	 * an absolute location or relative to tpe specified class. For instance,
-	 * specifying {@code com.example.MyClass} as the resource class allows you
-	 * to use "my-file.json" to load {@code /com/example/my-file.json}.
-	 * @param resourceLoadClass the class used to load resources or {@code null}
-	 * to only use absolute paths.
+	 * Override the class used to load resources.
+	 * <p>Resources can be loaded from an absolute location or relative to the
+	 * specified class. For instance, specifying {@code com.example.MyClass} as
+	 * the resource class allows you to use "my-file.json" to load
+	 * {@code /com/example/my-file.json}.
+	 * @param resourceLoadClass the class used to load resources, or {@code null}
+	 * to only use absolute paths
 	 */
 	public SELF withResourceLoadClass(@Nullable Class<?> resourceLoadClass) {
 		this.resourceLoadClass = resourceLoadClass;
@@ -393,8 +394,8 @@ public SELF withResourceLoadClass(@Nullable Class<?> resourceLoadClass) {
 	}
 
 	/**
-	 * Override the {@link Charset} to use to load resources. By default,
-	 * resources are loaded using {@code UTF-8}.
+	 * Override the {@link Charset} to use to load resources.
+	 * <p>By default, resources are loaded using {@code UTF-8}.
 	 * @param charset the charset to use, or {@code null} to use the default
 	 */
 	public SELF withCharset(@Nullable Charset charset) {
diff --git a/spring-test/src/main/java/org/springframework/test/json/AbstractJsonValueAssert.java b/spring-test/src/main/java/org/springframework/test/json/AbstractJsonValueAssert.java
@@ -41,7 +41,7 @@
 import org.springframework.util.StringUtils;
 
 /**
- * Base AssertJ {@link org.assertj.core.api.Assert assertions} that can be
+ * Base AssertJ {@linkplain org.assertj.core.api.Assert assertions} that can be
  * applied to a JSON value.
  *
  * <p>In JSON, values must be one of the following data types:
diff --git a/spring-test/src/main/java/org/springframework/test/json/JsonContentAssert.java b/spring-test/src/main/java/org/springframework/test/json/JsonContentAssert.java
@@ -30,7 +30,7 @@ public class JsonContentAssert extends AbstractJsonContentAssert<JsonContentAsse
 	/**
 	 * Create an assert for the given JSON document.
 	 * <p>Path can be converted to a value object using the given
-	 * {@linkplain GenericHttpMessageConverter json message converter}.
+	 * {@linkplain GenericHttpMessageConverter JSON message converter}.
 	 * @param json the JSON document to assert
 	 * @param jsonMessageConverter the converter to use
 	 */
diff --git a/spring-test/src/main/java/org/springframework/test/json/JsonPathValueAssert.java b/spring-test/src/main/java/org/springframework/test/json/JsonPathValueAssert.java
@@ -22,7 +22,7 @@
 import org.springframework.lang.Nullable;
 
 /**
- * AssertJ {@link org.assertj.core.api.Assert assertions} that can be applied
+ * AssertJ {@linkplain org.assertj.core.api.Assert assertions} that can be applied
  * to a JSON value produced by evaluating a {@linkplain JsonPath JSON path}
  * expression.
  *
diff --git a/spring-test/src/main/java/org/springframework/test/web/servlet/assertj/AbstractHttpServletRequestAssert.java b/spring-test/src/main/java/org/springframework/test/web/servlet/assertj/AbstractHttpServletRequestAssert.java
@@ -34,7 +34,7 @@
 import org.springframework.web.context.request.async.DeferredResult;
 
 /**
- * Base AssertJ {@link org.assertj.core.api.Assert assertions} that can be
+ * Base AssertJ {@linkplain org.assertj.core.api.Assert assertions} that can be
  * applied to an {@link HttpServletRequest}.
  *
  * @author Stephane Nicoll
diff --git a/spring-test/src/main/java/org/springframework/test/web/servlet/assertj/AbstractHttpServletResponseAssert.java b/spring-test/src/main/java/org/springframework/test/web/servlet/assertj/AbstractHttpServletResponseAssert.java
@@ -36,7 +36,7 @@
 import org.springframework.util.function.SingletonSupplier;
 
 /**
- * Base AssertJ {@link org.assertj.core.api.Assert assertions} that can be
+ * Base AssertJ {@linkplain org.assertj.core.api.Assert assertions} that can be
  * applied to any object that provides an {@link HttpServletResponse}. This
  * provides direct access to response assertions while also providing access to
  * a different top-level object.
@@ -91,7 +91,7 @@ public MediaTypeAssert contentType() {
 	 * {@link HttpHeaders} as the object to test. The returned assertion
 	 * object provides all the regular {@linkplain AbstractMapAssert map
 	 * assertions}, with headers mapped by header name.
-	 * Examples: <pre><code class='java'>
+	 * Examples: <pre><code class="java">
 	 * // Check for the presence of the Accept header:
 	 * assertThat(response).headers().containsHeader(HttpHeaders.ACCEPT);
 	 *
diff --git a/spring-test/src/main/java/org/springframework/test/web/servlet/assertj/AbstractMockHttpServletRequestAssert.java b/spring-test/src/main/java/org/springframework/test/web/servlet/assertj/AbstractMockHttpServletRequestAssert.java
@@ -19,8 +19,8 @@
 import org.springframework.mock.web.MockHttpServletRequest;
 
 /**
- * AssertJ {@link org.assertj.core.api.Assert assertions} that can be applied to
- * {@link MockHttpServletRequest}.
+ * AssertJ {@linkplain org.assertj.core.api.Assert assertions} that can be applied
+ * to {@link MockHttpServletRequest}.
  *
  * @author Stephane Nicoll
  * @since 6.2
diff --git a/spring-test/src/main/java/org/springframework/test/web/servlet/assertj/AbstractMockHttpServletResponseAssert.java b/spring-test/src/main/java/org/springframework/test/web/servlet/assertj/AbstractMockHttpServletResponseAssert.java
@@ -56,7 +56,7 @@ protected AbstractMockHttpServletResponseAssert(
 	/**
 	 * Return a new {@linkplain AbstractStringAssert assertion} object that uses
 	 * the response body converted to text as the object to test.
-	 * <p>Examples: <pre><code class='java'>
+	 * <p>Examples: <pre><code class="java">
 	 * // Check that the response body is equal to "Hello World":
 	 * assertThat(response).bodyText().isEqualTo("Hello World");
 	 * </code></pre>
@@ -70,7 +70,7 @@ public AbstractStringAssert<?> bodyText() {
 	 * uses the response body converted to text as the object to test. Compared
 	 * to {@link #bodyText()}, the assertion object provides dedicated JSON
 	 * support.
-	 * <p>Examples: <pre><code class='java'>
+	 * <p>Examples: <pre><code class="java">
 	 * // Check that the response body is strictly equal to the content of
 	 * // "/com/acme/sample/person-created.json":
 	 * assertThat(response).bodyJson()
@@ -82,7 +82,7 @@ public AbstractStringAssert<?> bodyText() {
 	 *         .isStrictlyEqualToJson("person-created.json");
 	 * </code></pre>
 	 * The returned assert object also supports JSON path expressions.
-	 * <p>Examples: <pre><code class='java'>
+	 * <p>Examples: <pre><code class="java">
 	 * // Check that the JSON document does not have an "error" element
 	 * assertThat(response).bodyJson().doesNotHavePath("$.error");
 	 *
@@ -114,7 +114,7 @@ public AbstractByteArrayAssert<?> body() {
 	 * Return a new {@linkplain UriAssert assertion} object that uses the
 	 * forwarded URL as the object to test. If a simple equality check is
 	 * required, consider using {@link #hasForwardedUrl(String)} instead.
-	 * <p>Example: <pre><code class='java'>
+	 * <p>Example: <pre><code class="java">
 	 * // Check that the forwarded URL starts with "/orders/":
 	 * assertThat(response).forwardedUrl().matchPattern("/orders/*);
 	 * </code></pre>
@@ -127,7 +127,7 @@ public UriAssert forwardedUrl() {
 	 * Return a new {@linkplain UriAssert assertion} object that uses the
 	 * redirected URL as the object to test. If a simple equality check is
 	 * required, consider using {@link #hasRedirectedUrl(String)} instead.
-	 * <p>Example: <pre><code class='java'>
+	 * <p>Example: <pre><code class="java">
 	 * // Check that the redirected URL starts with "/orders/":
 	 * assertThat(response).redirectedUrl().matchPattern("/orders/*);
 	 * </code></pre>
diff --git a/spring-test/src/main/java/org/springframework/test/web/servlet/assertj/CookieMapAssert.java b/spring-test/src/main/java/org/springframework/test/web/servlet/assertj/CookieMapAssert.java
@@ -26,8 +26,8 @@
 import org.assertj.core.api.Assertions;
 
 /**
- * AssertJ {@link org.assertj.core.api.Assert assertions} that can be applied to
- * {@link Cookie cookies}.
+ * AssertJ {@linkplain org.assertj.core.api.Assert assertions} that can be applied
+ * to {@link Cookie cookies}.
  *
  * @author Brian Clozel
  * @author Stephane Nicoll
diff --git a/spring-test/src/main/java/org/springframework/test/web/servlet/assertj/DefaultMvcTestResult.java b/spring-test/src/main/java/org/springframework/test/web/servlet/assertj/DefaultMvcTestResult.java
@@ -39,20 +39,26 @@ final class DefaultMvcTestResult implements MvcTestResult {
 	@Nullable
 	private final GenericHttpMessageConverter<Object> jsonMessageConverter;
 
-	DefaultMvcTestResult(@Nullable MvcResult mvcResult, @Nullable Exception unresolvedException, @Nullable GenericHttpMessageConverter<Object> jsonMessageConverter) {
+
+	DefaultMvcTestResult(@Nullable MvcResult mvcResult, @Nullable Exception unresolvedException,
+			@Nullable GenericHttpMessageConverter<Object> jsonMessageConverter) {
+
 		this.mvcResult = mvcResult;
 		this.unresolvedException = unresolvedException;
 		this.jsonMessageConverter = jsonMessageConverter;
 	}
 
+
+	@Override
 	public MvcResult getMvcResult() {
 		if (this.mvcResult == null) {
 			throw new IllegalStateException(
-					"Request has failed with unresolved exception " + this.unresolvedException);
+					"Request failed with unresolved exception " + this.unresolvedException);
 		}
 		return this.mvcResult;
 	}
 
+	@Override
 	@Nullable
 	public Exception getUnresolvedException() {
 		return this.unresolvedException;
diff --git a/spring-test/src/main/java/org/springframework/test/web/servlet/assertj/HandlerResultAssert.java b/spring-test/src/main/java/org/springframework/test/web/servlet/assertj/HandlerResultAssert.java
@@ -30,8 +30,8 @@
 import org.springframework.web.servlet.mvc.method.annotation.MvcUriComponentsBuilder.MethodInvocationInfo;
 
 /**
- * AssertJ {@link org.assertj.core.api.Assert assertions} that can be applied to
- * a handler or handler method.
+ * AssertJ {@linkplain org.assertj.core.api.Assert assertions} that can be applied
+ * to a handler or handler method.
 
  * @author Stephane Nicoll
  * @since 6.2
@@ -48,9 +48,9 @@ public HandlerResultAssert(@Nullable Object actual) {
 	 * the {@link Method} that handles the request as the object to test.
 	 * <p>Verifies first that the handler is a {@linkplain #isMethodHandler()
 	 * method handler}.
-	 * <p>Example: <pre><code class='java'>
+	 * <p>Example: <pre><code class="java">
 	 * // Check that a GET to "/greet" is invoked on a "handleGreet" method name
-	 * assertThat(mvc.perform(get("/greet")).handler().method().hasName("sayGreet");
+	 * assertThat(mvc.perform(get("/greet")).handler().method().hasName("handleGreet");
 	 * </code></pre>
 	 */
 	public MethodAssert method() {
@@ -71,7 +71,7 @@ public HandlerResultAssert isMethodHandler() {
 	 * the method invocation in the {@code handlerMethod}. The arguments used by
 	 * the target method invocation can be {@code null} as the purpose of the mock
 	 * is to identify the method that was invoked.
-	 * <p>Example: <pre><code class='java'>
+	 * <p>Example: <pre><code class="java">
 	 * // If the method has a return type, you can return the result of the invocation
 	 * assertThat(mvc.perform(get("/greet")).handler().isInvokedOn(
 	 *         GreetController.class, controller -> controller.sayGreet());
@@ -96,7 +96,7 @@ public <T> HandlerResultAssert isInvokedOn(Class<T> controllerType, Function<T,
 	/**
 	 * Verify that the handler is of the given {@code type}. For a controller
 	 * method, this is the type of the controller.
-	 * <p>Example: <pre><code class='java'>
+	 * <p>Example: <pre><code class="java">
 	 * // Check that a GET to "/greet" is managed by GreetController
 	 * assertThat(mvc.perform(get("/greet")).handler().hasType(GreetController.class);
 	 * </code></pre>
diff --git a/spring-test/src/main/java/org/springframework/test/web/servlet/assertj/MockMvcTester.java b/spring-test/src/main/java/org/springframework/test/web/servlet/assertj/MockMvcTester.java
@@ -38,11 +38,12 @@
 import org.springframework.web.context.WebApplicationContext;
 
 /**
- * Test Spring MVC applications with {@link MockMvc} for server request handling
- * using {@link org.assertj.core.api.Assertions AssertJ}.
+ * {@code MockMvcTester} provides support for testing Spring MVC applications
+ * with {@link MockMvc} for server request handling using
+ * {@linkplain org.assertj.core.api.Assertions AssertJ}.
  *
  * <p>A tester instance can be created from a {@link WebApplicationContext}:
- * <pre><code class='java'>
+ * <pre><code class="java">
  * // Create an instance with default settings
  * MockMvcTester mvc = MockMvcTester.from(applicationContext);
  *
@@ -51,30 +52,31 @@
  *         builder -> builder.addFilters(filter).build());
  * </code></pre>
  *
- * <p>A tester can be created standalone by providing the controller(s) to
- * include in a standalone setup:<pre><code class='java'>
+ * <p>A tester can be created in standalone mode by providing the controller(s)
+ * to include:<pre><code class="java">
  * // Create an instance for PersonController
  * MockMvcTester mvc = MockMvcTester.of(new PersonController());
  * </code></pre>
  *
- * <p>Once a test instance is available, you can perform requests in
- * a similar fashion as with {@link MockMvc}, and wrapping the result in
- * {@code assertThat} provides access to assertions. For instance:
- * <pre><code class='java'>
+ * <p>Once a tester instance is available, you can perform requests in a similar
+ * fashion as with {@link MockMvc}, and wrapping the result in
+ * {@code assertThat()} provides access to assertions. For instance:
+ * <pre><code class="java">
  * // perform a GET on /hi and assert the response body is equal to Hello
  * assertThat(mvc.perform(get("/hi")))
  *         .hasStatusOk().hasBodyTextEqualTo("Hello");
  * </code></pre>
  *
- * <p>A main difference with {@link MockMvc} is that an unresolved exception
- * is not thrown directly. Rather an {@link MvcTestResult} is available
- * with an {@link MvcTestResult#getUnresolvedException() unresolved
- * exception}. You can assert that a request has failed unexpectedly:
- * <pre><code class='java'>
- * // perform a GET on /hi and assert the response body is equal to Hello
+ * <p>One main difference between {@link MockMvc} and {@code MockMvcTester} is
+ * that an unresolved exception is not thrown directly when using
+ * {@code MockMvcTester}. Rather an {@link MvcTestResult} is available with an
+ * {@linkplain MvcTestResult#getUnresolvedException() unresolved exception}
+ * which allows you to assert that a request failed unexpectedly:
+ * <pre><code class="java">
+ * // perform a GET on /boom and assert the message for the the unresolved exception
  * assertThat(mvc.perform(get("/boom")))
  *         .hasUnresolvedException())
- * 		   .withMessage("Test exception");
+ *         .withMessage("Test exception");
  * </code></pre>
  *
  * <p>{@link MockMvcTester} can be configured with a list of
@@ -120,7 +122,7 @@ public static MockMvcTester create(MockMvc mockMvc) {
 	 * @param applicationContext the application context to detect the Spring
 	 * MVC infrastructure and application controllers from
 	 * @param customizations a function that creates a {@link MockMvc}
-	 * instance based on a {@link DefaultMockMvcBuilder}.
+	 * instance based on a {@link DefaultMockMvcBuilder}
 	 * @see MockMvcBuilders#webAppContextSetup(WebApplicationContext)
 	 */
 	public static MockMvcTester from(WebApplicationContext applicationContext,
@@ -204,7 +206,7 @@ public MockMvcTester withHttpMessageConverters(Iterable<HttpMessageConverter<?>>
 	 * request, wrapping the invocation in {@code assertThat}. The following
 	 * asserts that a {@linkplain MockMvcRequestBuilders#get(URI) GET} request
 	 * against "/greet" has an HTTP status code 200 (OK) and a simple body:
-	 * <pre><code class='java'>assertThat(mvc.perform(get("/greet")))
+	 * <pre><code class="java">assertThat(mvc.perform(get("/greet")))
 	 *       .hasStatusOk()
 	 *       .body().asString().isEqualTo("Hello");
 	 * </code></pre>
@@ -215,7 +217,7 @@ public MockMvcTester withHttpMessageConverters(Iterable<HttpMessageConverter<?>>
 	 * {@code /boom} throws an {@code IllegalStateException}, the following
 	 * asserts that the invocation has indeed failed with the expected error
 	 * message:
-	 * <pre><code class='java'>assertThat(mvc.perform(post("/boom")))
+	 * <pre><code class="java">assertThat(mvc.perform(post("/boom")))
 	 *       .unresolvedException().isInstanceOf(IllegalStateException.class)
 	 *       .hasMessage("Expected");
 	 * </code></pre>
diff --git a/spring-test/src/main/java/org/springframework/test/web/servlet/assertj/ModelAssert.java b/spring-test/src/main/java/org/springframework/test/web/servlet/assertj/ModelAssert.java
@@ -33,8 +33,8 @@
 import org.springframework.web.servlet.ModelAndView;
 
 /**
- * AssertJ {@link org.assertj.core.api.Assert assertions} that can be applied to
- * a {@linkplain ModelAndView#getModel() model}.
+ * AssertJ {@linkplain org.assertj.core.api.Assert assertions} that can be applied
+ * to a {@linkplain ModelAndView#getModel() model}.
  *
  * @author Stephane Nicoll
  * @since 6.2
@@ -51,7 +51,7 @@ public ModelAssert(Map<String, Object> map) {
 	 * Return a new {@linkplain AbstractBindingResultAssert assertion} object
 	 * that uses the {@link BindingResult} with the given {@code name} as the
 	 * object to test.
-	 * <p>Example: <pre><code class='java'>
+	 * <p>Example: <pre><code class="java">
 	 * // Check that the "person" attribute in the model has 2 errors:
 	 * assertThat(...).model().extractingBindingResult("person").hasErrorsCount(2);
 	 * </code></pre>
diff --git a/spring-test/src/main/java/org/springframework/test/web/servlet/assertj/MvcTestResult.java b/spring-test/src/main/java/org/springframework/test/web/servlet/assertj/MvcTestResult.java
diff --git a/spring-test/src/main/java/org/springframework/test/web/servlet/assertj/MvcTestResultAssert.java b/spring-test/src/main/java/org/springframework/test/web/servlet/assertj/MvcTestResultAssert.java
diff --git a/spring-test/src/test/java/org/springframework/test/web/servlet/assertj/DefaultMvcTestResultTests.java b/spring-test/src/test/java/org/springframework/test/web/servlet/assertj/DefaultMvcTestResultTests.java
diff --git a/spring-test/src/test/java/org/springframework/test/web/servlet/assertj/MockMvcTesterIntegrationTests.java b/spring-test/src/test/java/org/springframework/test/web/servlet/assertj/MockMvcTesterIntegrationTests.java

Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@`
`41`	`41`	`import org.springframework.util.StringUtils;`
`42`	`42`
`43`	`43`	`/**`
`44`		`- * Base AssertJ {@link org.assertj.core.api.Assert assertions} that can be`
	`44`	`+ * Base AssertJ {@linkplain org.assertj.core.api.Assert assertions} that can be`
`45`	`45`	`* applied to a JSON value.`
`46`	`46`	`*`
`47`	`47`	`* <p>In JSON, values must be one of the following data types:`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@`
`22`	`22`	`import org.springframework.lang.Nullable;`
`23`	`23`
`24`	`24`	`/**`
`25`		`- * AssertJ {@link org.assertj.core.api.Assert assertions} that can be applied`
	`25`	`+ * AssertJ {@linkplain org.assertj.core.api.Assert assertions} that can be applied`
`26`	`26`	`* to a JSON value produced by evaluating a {@linkplain JsonPath JSON path}`
`27`	`27`	`* expression.`
`28`	`28`	`*`
Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@`
`34`	`34`	`import org.springframework.web.context.request.async.DeferredResult;`
`35`	`35`
`36`	`36`	`/**`
`37`		`- * Base AssertJ {@link org.assertj.core.api.Assert assertions} that can be`
	`37`	`+ * Base AssertJ {@linkplain org.assertj.core.api.Assert assertions} that can be`
`38`	`38`	`* applied to an {@link HttpServletRequest}.`
`39`	`39`	`*`
`40`	`40`	`* @author Stephane Nicoll`