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
The code is highly readable. It has a clear, logical structure with a single interface and one method. Nesting is non-existent, and the intent is well documented with a thorough JavaDoc explaining each parameter and its purpose. The code length is concise, containing only the necessary method signature and documentation. Action granularity is excellent, with each parameter on its own line for clarity. The reading flow is natural, guiding the reader through the contract's purpose before presenting the method signature. The only minor deductions are for the slightly dense JavaDoc text, though it remains clear and informative.
Run 3
The code is highly readable. Structure is logical, presenting a clean interface with clear Javadoc. Nesting is non-existent. Intent is explicit through the method name and documentation comments, which explain purpose and parameter usage. Code length is concise, containing only the essential contract. Action granularity is one action per line (method declaration with parameters). Reading flow is natural due to well-organized imports, class-level docs, and a single method with meaningful parameter names. Minor deductions: Javadoc is slightly dense and references multiple related types, which could be marginally overwhelming for quick scanning.
Run 1
Code Structure: A single, focused interface with logically grouped imports and documentation. Nesting: Minimal nesting, limited to the interface body. Clarity of intent: Descriptive names and Javadoc clearly explain the customization contract, parameters, and server-specific usage; nullable annotations clarify optional inputs. Code length: Concise, with documentation proportionate to the API's purpose. Action granularity: One method declaration, with parameters split across lines for readability and no combined actions. Reading flow: Natural progression from package and imports to interface documentation and method contract. Minor formatting improvements, such as a blank line after the package declaration, would enhance visual separation.
Run 2
Code Structure: A single, focused interface with neatly grouped imports and one method. Nesting: No nested control flow; only the interface scope. Clarity of intent: Descriptive names, comprehensive Javadoc, and explicit nullable annotations clearly communicate the configuration contract. Code length: Concise, with documentation proportionate to the API's purpose. Action granularity: One declaration, with parameters split across lines for readability; no combined actions. Reading flow: Natural progression from package and imports to interface documentation and method contract. Minor spacing improvements, such as blank lines after the package declaration and before imports from different groups, would improve visual separation.
Run 3
Code Structure: A logically organized interface with imports, interface documentation, and one method. Nesting: Minimal, with no nested control flow. Clarity of intent: Descriptive names, detailed Javadoc, and explicit nullable annotations clearly communicate the customization contract; the circumstances under which nullable parameters are absent could be clearer. Code length: Concise, with documentation proportionate to the API. Action granularity: A single method declaration, with parameters split across lines for easy scanning. Reading flow: Natural top-to-bottom progression; a blank line between the package declaration and imports would slightly improve visual separation.