Source code
package org.springframework.test.web.reactive.server;
import org.jspecify.annotations.Nullable;
import org.springframework.http.client.reactive.ClientHttpConnector;
import org.springframework.web.server.adapter.WebHttpHandlerBuilder;
/**
* Contract to encapsulate customizations to a {@link WebTestClient.Builder}.
* Typically used by frameworks that wish to provide a shortcut for common
* initialization.
*
* @author Rossen Stoyanchev
* @since 5.0
* @see MockServerConfigurer
*/
public interface WebTestClientConfigurer {
/**
* Use methods on {@link WebTestClient.Builder} to modify test client
* settings. For a mock WebFlux server, use {@link WebHttpHandlerBuilder}
* to customize server configuration. For a MockMvc server, mutate the
* {@link org.springframework.test.web.servlet.client.MockMvcHttpConnector}
* and set it on {@link WebTestClient.Builder}.
* @param builder the WebTestClient builder for test client changes
* @param httpHandlerBuilder for mock WebFlux server settings
* @param connector the connector in use
*/
void afterConfigurerAdded(WebTestClient.Builder builder,
@Nullable WebHttpHandlerBuilder httpHandlerBuilder,
@Nullable ClientHttpConnector connector);
}
Run 1
The code is a well-structured Spring interface with clear intent. It has minimal nesting (none), appropriate length for its purpose, and each parameter is on its own line for readability. The Javadoc provides comprehensive context about how to use the interface, including references to related classes. The package structure and imports are standard and organized. The annotation @Nullable is used consistently. The method signature is clean and logically ordered. Points deducted only because the Javadoc could be slightly more concise, and there is a minor formatting inconsistency with the parameter continuation indentation. Overall, this is exemplary interface design that follows Java conventions perfectly.
Run 2
This code is highly readable. It has a clear, logical interface structure with a single well-documented method. Nesting is minimal (just standard Java interface structure). The intent is explicitly stated through comprehensive Javadoc and descriptive parameter names. Code length is concise—no unnecessary methods or fields. Action granularity is appropriate for an interface declaration (signature only). Reading flow is natural: package declaration, imports, class-level Javadoc, interface declaration, method Javadoc, then method signature. The only minor deduction is that the parameter alignment and line wrapping could be slightly more visually balanced, but overall this is exemplary code clarity.
Run 3
The code is a well-structured interface with a clear purpose: defining a customization contract for WebTestClient. It uses flat nesting with no complex logic, making it straightforward to read. The Javadoc is thorough and explains the intent and usage of the method, including its parameters and edge cases. The method signature is concise, with descriptive parameter names, and the use of @Nullable annotations enhances clarity. Action granularity is essentially a single logical action per line in the signature. The overall reading flow is natural, as the packaging, imports, type declaration, and documentation follow standard conventions. Minor deductions stem from the long Javadoc block, which, while informative, slightly increases verbosity.
Run 1
Code Structure: A single, focused interface with logically grouped imports, documentation, and one method. Nesting: No nested control flow; only the interface scope. Clarity of intent: Descriptive names, detailed Javadoc, and nullable annotations clearly explain the customization contract and parameters. Code length: Concise declaration with useful documentation rather than unnecessary implementation. Action granularity: One method declaration, with parameters split across lines for readability; no bundled actions. Reading flow: Natural progression from package and imports to interface purpose and method contract. Minor formatting improvements, such as blank lines separating the package and imports, would make it slightly easier to scan.
Run 2
Code Structure: A clean, single-purpose interface with logically ordered imports, documentation, and one method. Nesting: Minimal, with no nested control flow. Clarity of intent: Descriptive names, comprehensive Javadoc, and explicit nullable annotations clearly communicate the customization contract and parameter roles. Code length: Concise; documentation is longer than the declaration but provides useful context. Action granularity: The sole method declaration is neatly split across lines, with one parameter per continuation line. Reading flow: Natural top-to-bottom progression from interface purpose to method details. Minor formatting improvements, such as a blank line between the package declaration and imports, would make it slightly easier to scan.
Run 3
Code Structure: A clean interface with one method, logically ordered imports, and well-placed documentation. Nesting: Minimal nesting, with no conditional or control-flow complexity. Clarity of intent: Descriptive type and parameter names, detailed Javadoc, and explicit nullability annotations clearly communicate the customization contract; the callback timing is slightly less explicit. Code length: Concise declaration with proportionate documentation. Action granularity: The single method declaration is neatly split across lines, with no crowded statements. Reading flow: Natural progression from package and imports to interface documentation and method signature. A blank line between the package declaration and imports would slightly improve visual separation.