# All Classes and Interfaces

Class
Description
AbstractBindingResultAssert<SELF extends AbstractBindingResultAssert<SELF>>
AssertJ `assertions` that can be applied to `BindingResult`.
AbstractContextLoader
Abstract application context loader that provides a basis for all concrete implementations of the `ContextLoader` SPI.
AbstractDelegatingSmartContextLoader
`AbstractDelegatingSmartContextLoader` serves as an abstract base class for implementations of the `SmartContextLoader` SPI that delegate to a set of candidate SmartContextLoaders (i.e., one that supports XML configuration files or Groovy scripts and one that supports annotated classes) to determine which context loader is appropriate for a given test class's configuration.
AbstractDirtiesContextTestExecutionListener
Abstract base class for `TestExecutionListener` implementations that provide support for marking the `ApplicationContext` associated with a test as dirty for both test classes and test methods annotated with the `@DirtiesContext` annotation.
AbstractGenericContextLoader
Abstract, generic extension of `AbstractContextLoader` that loads a `GenericApplicationContext`.
AbstractGenericWebContextLoader
Abstract, generic extension of `AbstractContextLoader` that loads a `GenericWebApplicationContext`.
AbstractHttpServletRequestAssert<SELF extends AbstractHttpServletRequestAssert<SELF,ACTUAL>,ACTUAL extends HttpServletRequest>
Base AssertJ assertions that can be applied to an `HttpServletRequest`.
AbstractHttpServletResponseAssert<R extends HttpServletResponse,SELF extends AbstractHttpServletResponseAssert<R,SELF,ACTUAL>,ACTUAL>
Base AssertJ assertions that can be applied to any object that provides an `HttpServletResponse`.
AbstractJsonContentAssert<SELF extends AbstractJsonContentAssert<SELF>>
Base AssertJ assertions that can be applied to a JSON document.
AbstractJsonValueAssert<SELF extends AbstractJsonValueAssert<SELF>>
Base AssertJ assertions that can be applied to a JSON value.
AbstractJUnit4SpringContextTests
Abstract base test class which integrates the Spring TestContext Framework with explicit `ApplicationContext` testing support in a JUnit 4 environment.
AbstractMockHttpServletRequestAssert<SELF extends AbstractMockHttpServletRequestAssert<SELF>>
AssertJ assertions that can be applied to `MockHttpServletRequest`.
AbstractMockHttpServletRequestBuilder<B extends AbstractMockHttpServletRequestBuilder<B>>
Base builder for `MockHttpServletRequest` required as input to perform requests in `MockMvc`.
AbstractMockHttpServletResponseAssert<SELF extends AbstractMockHttpServletResponseAssert<SELF,ACTUAL>,ACTUAL>
Extension of `AbstractHttpServletResponseAssert` for `MockHttpServletResponse`.
AbstractMockMultipartHttpServletRequestBuilder<B extends AbstractMockMultipartHttpServletRequestBuilder<B>>
Base builder for `MockMultipartHttpServletRequest`.
AbstractMockMvcBuilder<B extends AbstractMockMvcBuilder<B>>
Abstract implementation of `MockMvcBuilder` with common methods for configuring filters, default request properties, global expectations and global result actions.
AbstractRequestExpectationManager
Base class for `RequestExpectationManager` implementations responsible for storing expectations and actual requests, and checking for unsatisfied expectations at the end.
AbstractRequestExpectationManager.RequestExpectationGroup
Helper class to manage a group of remaining expectations.
AbstractTestContextBootstrapper
Abstract implementation of the `TestContextBootstrapper` interface which provides most of the behavior required by a bootstrapper.
AbstractTestExecutionListener
Abstract ordered implementation of the `TestExecutionListener` API.
AbstractTestNGSpringContextTests
Abstract base test class which integrates the Spring TestContext Framework with explicit `ApplicationContext` testing support in a TestNG environment.
AbstractTransactionalJUnit4SpringContextTests
Abstract transactional extension of `AbstractJUnit4SpringContextTests` which adds convenience functionality for JDBC access.
AbstractTransactionalTestNGSpringContextTests
Abstract transactional extension of `AbstractTestNGSpringContextTests` which adds convenience functionality for JDBC access.
ActiveProfiles
`ActiveProfiles` is an annotation that can be applied to a test class to declare which active bean definition profiles should be used when loading an `ApplicationContext` for integration tests.
ActiveProfilesResolver
Strategy interface for programmatically resolving which active bean definition profiles should be used when loading an `ApplicationContext` for a test class.
AfterTestClass
`@EventListener` annotation used to consume an `AfterTestClassEvent` published by the `EventPublishingTestExecutionListener`.
AfterTestClassEvent
`TestContextEvent` published by the `EventPublishingTestExecutionListener` when `TestExecutionListener.afterTestClass(TestContext)` is invoked.
AfterTestExecution
`@EventListener` annotation used to consume an `AfterTestExecutionEvent` published by the `EventPublishingTestExecutionListener`.
AfterTestExecutionEvent
`TestContextEvent` published by the `EventPublishingTestExecutionListener` when `TestExecutionListener.afterTestExecution(TestContext)` is invoked.
AfterTestMethod
`@EventListener` annotation used to consume an `AfterTestMethodEvent` published by the `EventPublishingTestExecutionListener`.
AfterTestMethodEvent
`TestContextEvent` published by the `EventPublishingTestExecutionListener` when `TestExecutionListener.afterTestMethod(TestContext)` is invoked.
AfterTransaction
Test annotation which indicates that the annotated `void` method should be executed after a transaction is ended for a test method configured to run within a transaction via Spring's `@Transactional` annotation.
AnnotationConfigContextLoader
Concrete implementation of `AbstractGenericContextLoader` that loads bean definitions from component classes.
AnnotationConfigContextLoaderUtils
Utility methods for `SmartContextLoaders` that deal with component classes (for example, `@Configuration` classes).
AnnotationConfigWebContextLoader
Concrete implementation of `AbstractGenericWebContextLoader` that loads bean definitions from annotated classes.
AopTestUtils
`AopTestUtils` is a collection of AOP-related utility methods for use in unit and integration testing scenarios.
AotContextLoader
Strategy interface for loading an `ApplicationContext` for build-time AOT processing as well as run-time AOT execution for an integration test managed by the Spring TestContext Framework.
AotTestAttributes
Holder for metadata specific to ahead-of-time (AOT) support in the Spring TestContext Framework.
AotTestContextInitializers
`AotTestContextInitializers` provides mappings from test classes to AOT-optimized context initializers.
AotTestExecutionListener
`AotTestExecutionListener` is an extension of the `TestExecutionListener` SPI that allows a listener to optionally provide ahead-of-time (AOT) support.
ApplicationContextFailureProcessor
Strategy for components that process failures related to application contexts within the Spring TestContext Framework.
ApplicationEvents
`ApplicationEvents` encapsulates all application events that were fired during the execution of a single test method.
ApplicationEventsHolder
Holder class to expose the application events published during the execution of a test in the form of a thread-bound `ApplicationEvents` object.
ApplicationEventsTestExecutionListener
`TestExecutionListener` which provides support for `ApplicationEvents`.
AssertionErrors
Test assertions that are independent of any third-party assertion library.
BeanOverride
Mark a composed annotation as eligible for Bean Override processing.
BeanOverrideHandler
Handler for Bean Override injection points that is responsible for creating the bean override instance for a given set of metadata and potentially for tracking the created instance.
BeanOverrideProcessor
Strategy interface for Bean Override processing, which creates `BeanOverrideHandler` instances that drive how target beans are overridden.
BeanOverrideStrategy
Strategies for bean override processing.
BeanOverrideTestExecutionListener
`TestExecutionListener` that enables `@BeanOverride` support in tests, by injecting overridden beans in appropriate fields of the test instance.
BeforeTestClass
`@EventListener` annotation used to consume a `BeforeTestClassEvent` published by the `EventPublishingTestExecutionListener`.
BeforeTestClassEvent
`TestContextEvent` published by the `EventPublishingTestExecutionListener` when `TestExecutionListener.beforeTestClass(TestContext)` is invoked.
BeforeTestExecution
`@EventListener` annotation used to consume a `BeforeTestExecution` published by the `EventPublishingTestExecutionListener`.
BeforeTestExecutionEvent
`TestContextEvent` published by the `EventPublishingTestExecutionListener` when `TestExecutionListener.beforeTestExecution(TestContext)` is invoked.
BeforeTestMethod
`@EventListener` annotation used to consume a `BeforeTestMethodEvent` published by the `EventPublishingTestExecutionListener`.
BeforeTestMethodEvent
`TestContextEvent` published by the `EventPublishingTestExecutionListener` when `TestExecutionListener.beforeTestMethod(TestContext)` is invoked.
BeforeTransaction
Test annotation which indicates that the annotated `void` method should be executed before a transaction is started for a test method configured to run within a transaction via Spring's `@Transactional` annotation.
BootstrapContext
`BootstrapContext` encapsulates the context in which the Spring TestContext Framework is bootstrapped.
BootstrapUtils
`BootstrapUtils` is a collection of utility methods to assist with bootstrapping the Spring TestContext Framework.
BootstrapWith
`@BootstrapWith` is an annotation that can be applied to a test class to define metadata that is used to determine how to bootstrap the Spring TestContext Framework.
CacheAwareContextLoaderDelegate
A `CacheAwareContextLoaderDelegate` is responsible for loading and closing application contexts, interacting transparently with a `ContextCache` behind the scenes.
Commit
`@Commit` is a test annotation that is used to indicate that a test-managed transaction should be committed after the test method has completed.
CommonCachesTestExecutionListener
`TestExecutionListener` which makes sure that common caches are cleared once they are no longer required.
ConfigurableMockMvcBuilder<B extends ConfigurableMockMvcBuilder<B>>
Defines common methods for building a `MockMvc`.
ConfigurableSmartRequestBuilder<B extends ConfigurableSmartRequestBuilder<B>>
An extension of `SmartRequestBuilder` that can be configured with `RequestPostProcessors`.
ContentRequestMatchers
Factory for request content `RequestMatcher`'s.
ContentResultMatchers
Factory for response content assertions.
ContextCache
`ContextCache` defines the SPI for caching Spring `ApplicationContexts` within the Spring TestContext Framework.
ContextCacheUtils
Collection of utilities for working with context caching.
ContextConfiguration
`@ContextConfiguration` is an annotation that can be applied to a test class to define metadata that is used to determine how to load and configure an `ApplicationContext` for integration tests.
ContextConfigurationAttributes
`ContextConfigurationAttributes` encapsulates the context configuration attributes declared via `@ContextConfiguration`.
ContextCustomizer
Strategy interface for customizing `application contexts` that are created and managed by the Spring TestContext Framework.
ContextCustomizerFactories
`@ContextCustomizerFactories` is an annotation that can be applied to a test class to configure which `ContextCustomizerFactory` implementations should be registered with the Spring TestContext Framework.
ContextCustomizerFactories.MergeMode
Enumeration of modes that dictate whether explicitly declared factories are merged with the default factories when `@ContextCustomizerFactories` is declared on a class that does not inherit factories from a superclass or enclosing class.
ContextCustomizerFactory
Factory for creating `ContextCustomizers`.
ContextHierarchy
`@ContextHierarchy` is an annotation that can be applied to a test class to define a hierarchy of `ApplicationContexts` for integration tests.
ContextLoader
Strategy interface for loading an `ApplicationContext` for an integration test managed by the Spring TestContext Framework.
ContextLoadException
Exception thrown when an error occurs while a `SmartContextLoader` attempts to load an `ApplicationContext`.
CookieAssertions
Assertions on cookies of the response.
CookieMapAssert
AssertJ assertions that can be applied to `cookies`.
CookieResultMatchers
Factory for response cookie assertions.
DefaultActiveProfilesResolver
Default implementation of the `ActiveProfilesResolver` strategy that resolves active bean definition profiles based solely on profiles configured declaratively via `ActiveProfiles.profiles()` or `ActiveProfiles.value()`.
DefaultBootstrapContext
Default implementation of the `BootstrapContext` interface.
DefaultCacheAwareContextLoaderDelegate
Default implementation of the `CacheAwareContextLoaderDelegate` strategy.
DefaultContextCache
Default implementation of the `ContextCache` API.
DefaultMockMvcBuilder
A concrete implementation of `AbstractMockMvcBuilder` that provides the `WebApplicationContext` supplied to it as a constructor argument.
DefaultRequestExpectation
Default implementation of `RequestExpectation` that simply delegates to the request matchers and the response creator it contains.
DefaultRequestExpectation.RequestCount
Helper class that keeps track of actual vs expected request count.
DefaultResponseCreator
A `ResponseCreator` with builder-style methods for adding response details.
DefaultTestContext
Default implementation of the `TestContext` interface.
DefaultTestContextBootstrapper
Default implementation of the `TestContextBootstrapper` SPI.
DelegatingServletInputStream
Delegating implementation of `ServletInputStream`.
DelegatingServletOutputStream
Delegating implementation of `ServletOutputStream`.
DelegatingSmartContextLoader
`DelegatingSmartContextLoader` is a concrete implementation of `AbstractDelegatingSmartContextLoader` that delegates to a `GenericXmlContextLoader` (or a `GenericGroovyXmlContextLoader` if Groovy is present in the classpath) and an `AnnotationConfigContextLoader`.
DelegatingWebConnection
Implementation of `WebConnection` that allows delegating to various `WebConnection` implementations.
DelegatingWebConnection.DelegateWebConnection
The delegate web connection.
DependencyInjectionTestExecutionListener
`TestExecutionListener` which provides support for dependency injection and initialization of test instances.
DirtiesContext
Test annotation which indicates that the `ApplicationContext` associated with a test is dirty and should therefore be closed and removed from the context cache.
DirtiesContext.ClassMode
Defines modes which determine how `@DirtiesContext` is interpreted when used to annotate a test class.
DirtiesContext.HierarchyMode
Defines modes which determine how the context cache is cleared when `@DirtiesContext` is used in a test whose context is configured as part of a hierarchy via `@ContextHierarchy`.
DirtiesContext.MethodMode
Defines modes which determine how `@DirtiesContext` is interpreted when used to annotate a test method.
DirtiesContextBeforeModesTestExecutionListener
`TestExecutionListener` which provides support for marking the `ApplicationContext` associated with a test as dirty for both test classes and test methods annotated with the `@DirtiesContext` annotation.
DirtiesContextTestExecutionListener
`TestExecutionListener` which provides support for marking the `ApplicationContext` associated with a test as dirty for both test classes and test methods annotated with the `@DirtiesContext` annotation.
DisabledIf
`@DisabledIf` is used to signal that the annotated test class or test method is disabled and should not be executed if the supplied `DisabledIf.expression()` evaluates to `true`.
DisabledIfCondition
`DisabledIfCondition` is an `ExecutionCondition` that supports the `@DisabledIf` annotation when using the Spring TestContext Framework in conjunction with JUnit 5's Jupiter programming model.
DisabledInAotMode
`@DisabledInAotMode` signals that the annotated test class is disabled in Spring AOT (ahead-of-time) mode, which means that the `ApplicationContext` for the test class will not be processed for AOT optimizations at build time.
DispatcherServletCustomizer
Strategy interface for customizing `DispatcherServlet` instances that are managed by `MockMvc`.
DynamicPropertyRegistrar
Registrar that is used to add properties with dynamically resolved values to the `Environment` via a `DynamicPropertyRegistry`.
DynamicPropertyRegistrarBeanInitializer
`BeanFactoryInitializer` that eagerly initializes `DynamicPropertyRegistrar` beans.
DynamicPropertyRegistry
Registry that is used to add properties with dynamically resolved values to the `Environment`.
DynamicPropertySource
`@DynamicPropertySource` is an annotation that can be applied to static methods in integration test classes in order to add properties with dynamic values to the `Environment`'s set of `PropertySources`.
EnabledIf
`@EnabledIf` is used to signal that the annotated test class or test method is enabled and should be executed if the supplied `EnabledIf.expression()` evaluates to `true`.
EnabledIfCondition
`EnabledIfCondition` is an `ExecutionCondition` that supports the `@EnabledIf` annotation when using the Spring TestContext Framework in conjunction with JUnit 5's Jupiter programming model.
EntityExchangeResult<T>
`ExchangeResult` sub-class that exposes the response body fully extracted to a representation of type `<T>`.
EventPublishingTestExecutionListener
`TestExecutionListener` that publishes test execution events to the `ApplicationContext` for the currently executing test.
ExceptionCollector
`ExceptionCollector` is a test utility for executing code blocks, collecting exceptions, and generating a single `AssertionError` containing any exceptions encountered as suppressed exceptions.
ExceptionCollector.Executable
`Executable` is a functional interface that can be used to implement any generic block of code that potentially throws a `Throwable`.
ExchangeResult
Container for request and response details for exchanges performed through `WebTestClient`.
ExecutingResponseCreator
`ResponseCreator` that obtains the response by executing the request through a `ClientHttpRequestFactory`.
ExpectedCount
A simple type representing a range for an expected count.
FlashAttributeResultMatchers
Factory for "output" flash attribute assertions.
FluxExchangeResult<T>
`ExchangeResult` variant with the response body decoded as `Flux<T>` but not yet consumed.
GenericGroovyXmlContextLoader
Concrete implementation of `AbstractGenericContextLoader` that reads bean definitions from Groovy scripts and XML configuration files.
GenericGroovyXmlWebContextLoader
Concrete implementation of `AbstractGenericWebContextLoader` that loads bean definitions from Groovy scripts and XML configuration files.
GenericXmlContextLoader
Concrete implementation of `AbstractGenericContextLoader` that reads bean definitions from XML resources.
GenericXmlWebContextLoader
Concrete implementation of `AbstractGenericWebContextLoader` that loads bean definitions from XML resources.
HandlerResultAssert
AssertJ assertions that can be applied to a handler or handler method.
HandlerResultMatchers
Factory for assertions on the selected handler or handler method.
HeaderAssertions
Assertions on headers of the response.
HeaderResultMatchers
Factory for response header assertions.
HostRequestMatcher
A `WebRequestMatcher` that allows matching on the host and optionally the port of `WebRequest#getUrl()`.
HttpHandlerConnector
Connector that handles requests by invoking an `HttpHandler` rather than making actual requests to a network socket.
HttpHandlerConnector.FailureAfterResponseCompletedException
Indicates that an error occurred after the server response was completed, via `ReactiveHttpOutputMessage.writeWith(org.reactivestreams.Publisher<? extends org.springframework.core.io.buffer.DataBuffer>)` or `ReactiveHttpOutputMessage.setComplete()`, and can no longer be changed.
HttpHeadersAssert
AssertJ `assertions` that can be applied to `HttpHeaders`.
HttpMessageContentConverter
Convert HTTP message content for testing purposes.
IfProfileValue
Test annotation for use with JUnit 4 to indicate whether the annotated test class or test method is enabled or disabled for a specific testing profile.
JdbcTestUtils
`JdbcTestUtils` is a collection of JDBC related utility functions intended to simplify standard database testing scenarios.
JsonAssert
Useful methods that can be used with `org.skyscreamer.jsonassert`.
JsonComparator
Strategy interface used to compare JSON strings.
JsonCompareMode
Modes that can be used to compare JSON.
JsonComparison
A comparison of two JSON strings as returned from a `JsonComparator`.
JsonComparison.Result
Comparison results.
JsonContent
JSON content which is generally used to `provide` `JsonContentAssert` to AssertJ `assertThat` calls.
JsonContentAssert
Default `AbstractJsonContentAssert` implementation.
JsonExpectationsHelper
Deprecated.
in favor of using `JSONAssert` directly or the `JsonComparator` abstraction
JsonPathAssertions
JsonPath assertions.
JsonPathExpectationsHelper
A helper class for applying assertions via JSON path expressions.
JsonPathRequestMatchers
Factory for assertions on the request content using JsonPath expressions.
JsonPathResultMatchers
Factory for assertions on the response content using JsonPath expressions.
JsonPathValueAssert
AssertJ assertions that can be applied to a JSON value produced by evaluating a JSON path expression.
MediaTypeAssert
AssertJ `assertions` that can be applied to a `MediaType`.
MergedContextConfiguration
`MergedContextConfiguration` encapsulates the merged context configuration declared on a test class and all of its superclasses and enclosing classes via `@ContextConfiguration`, `@ActiveProfiles`, and `@TestPropertySource`.
MethodAssert
AssertJ `assertions` that can be applied to a `Method`.
MethodInvoker
`MethodInvoker` defines a generic API for invoking a `Method` within the Spring TestContext Framework.
MockAsyncContext
Mock implementation of the `AsyncContext` interface.
MockBodyContent
Mock implementation of the `BodyContent` class.
MockClientHttpRequest
Mock implementation of `ClientHttpRequest`.
MockClientHttpRequest
Mock implementation of `ClientHttpRequest`.
MockClientHttpResponse
Mock implementation of `ClientHttpResponse`.
MockClientHttpResponse
Mock implementation of `ClientHttpResponse`.
MockCookie
Extension of `Cookie` with extra attributes, as defined in RFC 6265.
MockEnvironment
Simple `ConfigurableEnvironment` implementation exposing `MockEnvironment.setProperty(java.lang.String, java.lang.Object)` and `MockEnvironment.withProperty(java.lang.String, java.lang.Object)` methods for testing purposes.
MockFilterChain
Mock implementation of the `FilterChain` interface.
MockFilterConfig
Mock implementation of the `FilterConfig` interface.
MockFilterRegistration
Mock implementation of `FilterRegistration`.
MockHttpInputMessage
Mock implementation of `HttpInputMessage`.
MockHttpOutputMessage
Mock implementation of `HttpOutputMessage`.
MockHttpServletMapping
Mock implementation of `HttpServletMapping`.
MockHttpServletRequest
Mock implementation of the `HttpServletRequest` interface.
MockHttpServletRequestBuilder
Default builder for `MockHttpServletRequest` required as input to perform requests in `MockMvc`.
MockHttpServletResponse
Mock implementation of the `HttpServletResponse` interface.
MockHttpSession
Mock implementation of the `HttpSession` interface.
MockitoBean
`@MockitoBean` is an annotation that can be used in test classes to override a bean in the test's `ApplicationContext` with a Mockito mock.
MockitoBeans
Container for `@MockitoBean` annotations which allows `@MockitoBean` to be used as a repeatable annotation at the type level — for example, on test classes or interfaces implemented by test classes.
MockitoResetTestExecutionListener
`TestExecutionListener` that resets any mock beans that have been marked with a `MockReset`.
MockitoSpyBean
`@MockitoSpyBean` is an annotation that can be used in test classes to override a bean in the test's `ApplicationContext` with a Mockito spy that wraps the original bean instance.
MockitoSpyBeans
Container for `@MockitoSpyBean` annotations which allows `@MockitoSpyBean` to be used as a repeatable annotation at the type level — for example, on test classes or interfaces implemented by test classes.
MockJspWriter
Mock implementation of the `JspWriter` class.
MockMultipartFile
Mock implementation of the `MultipartFile` interface.
MockMultipartHttpServletRequest
Mock implementation of the `MultipartHttpServletRequest` interface.
MockMultipartHttpServletRequestBuilder
Default builder for `MockMultipartHttpServletRequest`.
MockMvc
Main entry point for server-side Spring MVC test support.
MockMvcBuilder
Builds a `MockMvc` instance.
MockMvcBuilders
The main class to import in order to access all available `MockMvcBuilders`.
MockMvcBuilderSupport
Base class for MockMvc builder implementations, providing the capability to create a `MockMvc` instance.
MockMvcClientHttpRequestFactory
A `ClientHttpRequestFactory` for requests executed via `MockMvc`.
MockMvcConfigurer
Contract for customizing a `ConfigurableMockMvcBuilder` in some specific way, for example, a 3rd party library that wants to provide shortcuts for setting up a MockMvc.
MockMvcConfigurerAdapter
An empty method implementation of `MockMvcConfigurer`.
MockMvcHtmlUnitDriverBuilder
`MockMvcHtmlUnitDriverBuilder` simplifies the building of an `HtmlUnitDriver` that delegates to `MockMvc` and optionally delegates to an actual connection for specific requests.
MockMvcHttpConnector
Connector that handles requests by invoking a `MockMvc` rather than making actual requests over HTTP.
MockMvcRequestBuilders
Static factory methods for `RequestBuilders`.
MockMvcResultHandlers
Static factory methods for `ResultHandler`-based result actions.
MockMvcResultMatchers
Static factory methods for `ResultMatcher`-based result actions.
MockMvcTester
`MockMvcTester` provides support for testing Spring MVC applications with `MockMvc` for server request handling using AssertJ.
MockMvcWebClientBuilder
`MockMvcWebClientBuilder` simplifies the creation of an HtmlUnit `WebClient` that delegates to a `MockMvc` instance.
MockMvcWebConnection
`MockMvcWebConnection` enables `MockMvc` to transform a `WebRequest` into a `WebResponse`.
MockMvcWebConnectionBuilderSupport<T extends MockMvcWebConnectionBuilderSupport<T>>
Support class that simplifies the creation of a `WebConnection` that uses `MockMvc` and optionally delegates to a real `WebConnection` for specific requests.
MockMvcWebTestClient
The main class for testing Spring MVC applications via `WebTestClient` with `MockMvc` for server request handling.
MockMvcWebTestClient.ControllerSpec
Specification for configuring `MockMvc` to test one or more controllers directly, and a simple facade around `StandaloneMockMvcBuilder`.
MockMvcWebTestClient.MockMvcServerSpec<B extends MockMvcWebTestClient.MockMvcServerSpec<B>>
Base specification for configuring `MockMvc`, and a simple facade around `ConfigurableMockMvcBuilder`.
MockMvcWebTestClient.RouterFunctionSpec
Specification for configuring `MockMvc` to test one or more router functions directly, and a simple facade around `RouterFunctionMockMvcBuilder`.
MockPageContext
Mock implementation of the `PageContext` interface.
MockPart
Mock implementation of `jakarta.servlet.http.Part`.
MockPropertySource
Simple `PropertySource` implementation for use in testing.
MockRequestDispatcher
Mock implementation of the `RequestDispatcher` interface.
MockReset
Reset strategy used on a mock bean.
MockRestRequestMatchers
Static factory methods for `RequestMatcher` classes.
MockRestResponseCreators
Static factory methods to obtain a `ResponseCreator` with a fixed response.
MockRestServiceServer
Main entry point for client-side REST testing.
MockRestServiceServer.MockRestServiceServerBuilder
Builder to create a `MockRestServiceServer`.
MockServerClientHttpResponse
Simple `ClientHttpResponse` extension that also exposes a result object from the underlying mock server exchange for further assertions on the state of the server response after the request is performed.
MockServerConfigurer
Contract that frameworks or applications can use to pre-package a set of customizations to a `WebTestClient.MockServerSpec` and expose that as a shortcut.
MockServerHttpRequest
Mock extension of `AbstractServerHttpRequest` for use in tests without an actual server.
MockServerHttpRequest.BaseBuilder<B extends MockServerHttpRequest.BaseBuilder<B>>
Request builder exposing properties not related to the body.
MockServerHttpRequest.BodyBuilder
A builder that adds a body to the request.
MockServerHttpResponse
Mock extension of `AbstractServerHttpResponse` for use in tests without an actual server.
MockServerRequest
Mock implementation of `ServerRequest`.
MockServerRequest.Builder
Builder for `MockServerRequest`.
MockServerWebExchange
Extension of `DefaultServerWebExchange` for use in tests, along with `MockServerHttpRequest` and `MockServerHttpResponse`.
MockServerWebExchange.Builder
Builder for a `MockServerWebExchange`.
MockServletConfig
Mock implementation of the `ServletConfig` interface.
MockServletContext
Mock implementation of the `ServletContext` interface.
MockSessionCookieConfig
Mock implementation of the `SessionCookieConfig` interface.
MockWebSession
Implementation of `WebSession` that delegates to a session instance obtained via `InMemoryWebSessionStore`.
ModelAndViewAssert
A collection of assertions intended to simplify testing scenarios dealing with Spring Web MVC `ModelAndView` objects.
ModelAssert
AssertJ assertions that can be applied to a model.
ModelResultMatchers
Factory for assertions on the model.
MvcResult
Provides access to the result of an executed request.
MvcTestResult
Provides the result of an executed request using `MockMvcTester` that is meant to be used with `assertThat`.
MvcTestResultAssert
AssertJ assertions that can be applied to `MvcTestResult`.
NestedTestConfiguration
`@NestedTestConfiguration` is an annotation that can be applied to a test class to configure how Spring test configuration annotations are processed within enclosing class hierarchies (i.e., for inner test classes).
NestedTestConfiguration.EnclosingConfiguration
Enumeration of modes that dictate how test configuration from enclosing classes is processed for inner test classes.
PassThroughFilterChain
Implementation of the `FilterChain` interface which simply passes the call through to a given Filter/FilterChain combination (indicating the next Filter in the chain along with the FilterChain that it is supposed to work on) or to a given Servlet (indicating the end of the chain).
PrepareTestInstance
`@EventListener` annotation used to consume a `PrepareTestInstanceEvent` published by the `EventPublishingTestExecutionListener`.
PrepareTestInstanceEvent
`TestContextEvent` published by the `EventPublishingTestExecutionListener` when `TestExecutionListener.prepareTestInstance(TestContext)` is invoked.
PrintingResultHandler
Result handler that prints `MvcResult` details to a given output stream — for example: `System.out`, `System.err`, a custom `java.io.PrintWriter`, etc.
PrintingResultHandler.ResultValuePrinter
A contract for how to actually write result information.
ProfileValueChecker
`ProfileValueChecker` is a custom JUnit `Statement` that checks whether a test class or test method is enabled in the current environment via Spring's `@IfProfileValue` annotation.
ProfileValueSource
Strategy interface for retrieving profile values for a given testing environment.
ProfileValueSourceConfiguration
`ProfileValueSourceConfiguration` is an annotation that can be applied to a JUnit 4 based test class to specify what type of `ProfileValueSource` to use when retrieving profile values configured via `@IfProfileValue`.
ProfileValueUtils
General utility methods for working with profile values.
PropertyProvider
Strategy for providing named properties — for example, for looking up key-value pairs in a generic fashion.
RecordApplicationEvents
`@RecordApplicationEvents` is an annotation that can be applied to a test class to instruct the Spring TestContext Framework to record all application events that are published in the `ApplicationContext` during the execution of a single test, either from the test thread or its descendants.
ReflectionTestUtils
`ReflectionTestUtils` is a collection of reflection-based utility methods for use in unit and integration testing scenarios.
Repeat
Test annotation for use with JUnit 4 to indicate that a test method should be invoked repeatedly.
RequestBuilder
Builds a `MockHttpServletRequest`.
RequestExpectation
An extension of `ResponseActions` that also implements `RequestMatcher` and `ResponseCreator`
RequestExpectationManager
Encapsulates the behavior required to implement `MockRestServiceServer` including its public API (create expectations + verify/reset) along with an extra method for verifying actual requests.
RequestMatcher
A contract for matching requests to expectations.
RequestPostProcessor
Extension point for applications or 3rd party libraries that wish to further initialize a `MockHttpServletRequest` instance after it has been built by `MockHttpServletRequestBuilder` or its subclass `MockMultipartHttpServletRequestBuilder`.
RequestResultMatchers
Factory for assertions on the request.
ResponseActions
A contract for setting up request expectations and defining a response.
ResponseCreator
A contract for creating a `ClientHttpResponse`.
ResultActions
Allows applying actions, such as expectations, on the result of an executed request.
ResultHandler
A `ResultHandler` performs a generic action on the result of an executed request — for example, printing debug information.
ResultMatcher
A `ResultMatcher` matches the result of an executed request against some expectation.
Rollback
`@Rollback` is a test annotation that is used to indicate whether a test-managed transaction should be rolled back after the test method has completed.
RouterFunctionMockMvcBuilder
A `MockMvcBuilder` that accepts `RouterFunction` registrations thus allowing full control over the instantiation and initialization of router functions and their dependencies similar to plain unit tests, and also making it possible to test one function at a time.
RunAfterTestClassCallbacks
`RunAfterTestClassCallbacks` is a custom JUnit `Statement` which allows the Spring TestContext Framework to be plugged into the JUnit execution chain by calling `afterTestClass()` on the supplied `TestContextManager`.
RunAfterTestExecutionCallbacks
`RunAfterTestExecutionCallbacks` is a custom JUnit `Statement` which allows the Spring TestContext Framework to be plugged into the JUnit 4 execution chain by calling `afterTestExecution()` on the supplied `TestContextManager`.
RunAfterTestMethodCallbacks
`RunAfterTestMethodCallbacks` is a custom JUnit `Statement` which allows the Spring TestContext Framework to be plugged into the JUnit execution chain by calling `afterTestMethod()` on the supplied `TestContextManager`.
RunBeforeTestClassCallbacks
`RunBeforeTestClassCallbacks` is a custom JUnit `Statement` which allows the Spring TestContext Framework to be plugged into the JUnit execution chain by calling `beforeTestClass()` on the supplied `TestContextManager`.
RunBeforeTestExecutionCallbacks
`RunBeforeTestExecutionCallbacks` is a custom JUnit `Statement` which allows the Spring TestContext Framework to be plugged into the JUnit 4 execution chain by calling `beforeTestExecution()` on the supplied `TestContextManager`.
RunBeforeTestMethodCallbacks
`RunBeforeTestMethodCallbacks` is a custom JUnit `Statement` which allows the Spring TestContext Framework to be plugged into the JUnit execution chain by calling `beforeTestMethod()` on the supplied `TestContextManager`.
RunPrepareTestInstanceCallbacks
`RunPrepareTestInstanceCallbacks` is a custom JUnit `Statement` which allows the Spring TestContext Framework to be plugged into the JUnit execution chain by calling `prepareTestInstance()` on the supplied `TestContextManager`.
ServletTestExecutionListener
`TestExecutionListener` which provides mock Servlet API support to `WebApplicationContexts` loaded by the Spring TestContext Framework.
SharedHttpSessionConfigurer
`MockMvcConfigurer` that stores and re-uses the HTTP session across multiple requests performed through the same `MockMvc` instance.
SimpleRequestExpectationManager
Simple `RequestExpectationManager` that matches requests to expectations sequentially, i.e.
SmartContextLoader
Strategy interface for loading an `ApplicationContext` for an integration test managed by the Spring TestContext Framework.
SmartRequestBuilder
Extended variant of a `RequestBuilder` that applies its `org.springframework.test.web.servlet.request.RequestPostProcessors` as a separate step from the `RequestBuilder.buildRequest(jakarta.servlet.ServletContext)` method.
SpringClassRule
`SpringClassRule` is a custom JUnit `TestRule` that supports class-level features of the Spring TestContext Framework in standard JUnit tests by means of the `TestContextManager` and associated support classes and annotations.
SpringExtension
`SpringExtension` integrates the Spring TestContext Framework into JUnit 5's Jupiter programming model.
SpringFailOnTimeout
`SpringFailOnTimeout` is a custom JUnit `Statement` which adds support for Spring's `@Timed` annotation by throwing an exception if the next statement in the execution chain takes more than the specified number of milliseconds.
SpringJUnit4ClassRunner
`SpringJUnit4ClassRunner` is a custom extension of JUnit's `BlockJUnit4ClassRunner` which provides functionality of the Spring TestContext Framework to standard JUnit tests by means of the `TestContextManager` and associated support classes and annotations.
SpringJUnitConfig
`@SpringJUnitConfig` is a composed annotation that combines `@ExtendWith(SpringExtension.class)` from JUnit Jupiter with `@ContextConfiguration` from the Spring TestContext Framework.
SpringJUnitWebConfig
`@SpringJUnitWebConfig` is a composed annotation that combines `@ExtendWith(SpringExtension.class)` from JUnit Jupiter with `@ContextConfiguration` and `@WebAppConfiguration` from the Spring TestContext Framework.
SpringMethodRule
`SpringMethodRule` is a custom JUnit 4 `MethodRule` that supports instance-level and method-level features of the Spring TestContext Framework in standard JUnit tests by means of the `TestContextManager` and associated support classes and annotations.
SpringMockResolver
A `MockResolver` for testing Spring applications with Mockito.
SpringRepeat
`SpringRepeat` is a custom JUnit `Statement` which adds support for Spring's `@Repeat` annotation by repeating the test the specified number of times.
SpringRunner
`SpringRunner` is an alias for the `SpringJUnit4ClassRunner`.
Sql
`@Sql` is used to annotate a test class or test method to configure SQL `Sql.scripts()` and `Sql.statements()` to be executed against a given database during integration tests.
Sql.ExecutionPhase
Enumeration of phases that dictate when SQL scripts are executed.
SqlConfig
`@SqlConfig` defines metadata that is used to determine how to parse and execute SQL scripts configured via the `@Sql` annotation.
SqlConfig.ErrorMode
Enumeration of modes that dictate how errors are handled while executing SQL statements.
SqlConfig.TransactionMode
Enumeration of modes that dictate whether SQL scripts should be executed within a transaction and what the transaction propagation behavior should be.
SqlGroup
Container annotation that aggregates several `@Sql` annotations.
SqlMergeMode
`@SqlMergeMode` is used to annotate a test class or test method to configure whether method-level `@Sql` declarations are merged with class-level `@Sql` declarations.
SqlMergeMode.MergeMode
Enumeration of modes that dictate whether method-level `@Sql` declarations are merged with class-level `@Sql` declarations.
SqlScriptsTestExecutionListener
`TestExecutionListener` that provides support for executing SQL `scripts` and inlined `statements` configured via the `@Sql` annotation.
StandaloneMockMvcBuilder
A `MockMvcBuilder` that accepts `@Controller` registrations thus allowing full control over the instantiation and initialization of controllers and their dependencies similar to plain unit tests, and also making it possible to test one controller at a time.
StatusAssertions
Assertions on the response status.
StatusResultMatchers
Factory for assertions on the response status.
SystemProfileValueSource
Implementation of `ProfileValueSource` which uses system properties as the underlying source.
TestAnnotationUtils
Collection of utility methods for working with Spring's core testing annotations.
TestAotProcessor
Filesystem-based ahead-of-time (AOT) processing base implementation that scans the provided classpath roots for Spring integration test classes and then generates AOT artifacts for those test classes in the configured output directories.
TestBean
`@TestBean` is an annotation that can be applied to a non-static field in a test class to override a bean in the test's `ApplicationContext` using a static factory method.
TestConstructor
`@TestConstructor` is an annotation that can be applied to a test class to configure how the parameters of a test class constructor are autowired from components in the test's `ApplicationContext`.
TestConstructor.AutowireMode
Defines autowiring modes for parameters in a test constructor.
TestConstructorUtils
Utility methods for working with `@TestConstructor`.
TestContext
`TestContext` encapsulates the context in which a test is executed, agnostic of the actual testing framework in use.
TestContextAnnotationUtils
`TestContextAnnotationUtils` is a collection of utility methods that complements the standard support already available in `MergedAnnotations`, `AnnotationUtils`, and `AnnotatedElementUtils`, while transparently honoring `@NestedTestConfiguration` semantics.
TestContextAnnotationUtils.AnnotationDescriptor<T extends Annotation>
Descriptor for an `Annotation`, including the class on which the annotation is declared as well as the merged annotation instance.
TestContextAnnotationUtils.UntypedAnnotationDescriptor
Untyped extension of `TestContextAnnotationUtils.AnnotationDescriptor` that is used to describe the declaration of one of several candidate annotation types where the actual annotation type cannot be predetermined.
TestContextAotException
Thrown if an error occurs during AOT build-time processing or AOT run-time execution in the Spring TestContext Framework.
TestContextAotGenerator
`TestContextAotGenerator` generates AOT artifacts for integration tests that depend on support from the Spring TestContext Framework.
TestContextBootstrapper
`TestContextBootstrapper` defines the SPI for bootstrapping the Spring TestContext Framework.
TestContextEvent
Base class for events published by the `EventPublishingTestExecutionListener`.
TestContextManager
`TestContextManager` is the main entry point into the Spring TestContext Framework.
TestContextResourceUtils
Utility methods for working with resources within the Spring TestContext Framework.
TestContextSpringFactoriesUtils
Collection of utilities for working with `SpringFactoriesLoader` within the Spring TestContext Framework.
TestContextTransactionUtils
Utility methods for working with transactions and data access related beans within the Spring TestContext Framework.
TestExecutionListener
`TestExecutionListener` defines a listener API for reacting to test execution events published by the `TestContextManager` with which the listener is registered.
TestExecutionListeners
`@TestExecutionListeners` is an annotation that can be applied to a test class to configure which `TestExecutionListeners` should be registered with a `TestContextManager`.
TestExecutionListeners.MergeMode
Enumeration of modes that dictate whether explicitly declared listeners are merged with the default listeners when `@TestExecutionListeners` is declared on a class that does not inherit listeners from a superclass or enclosing class.
TestPropertySource
`@TestPropertySource` is an annotation that can be applied to a test class to configure the `TestPropertySource.locations()` of properties files and inlined `TestPropertySource.properties()` to be added to the `Environment`'s set of `PropertySources` for an `ApplicationContext` for integration tests.
TestPropertySources
`@TestPropertySources` is a container for one or more `@TestPropertySource` declarations.
TestPropertySourceUtils
Utility methods for working with `@TestPropertySource` and adding test `PropertySources` to the `Environment`.
TestRuntimeHintsRegistrar
Contract for registering `RuntimeHints` for integration tests run with the Spring TestContext Framework based on the `ClassLoader` of the deployment unit.
TestSocketUtils
Simple utility for finding available TCP ports on `localhost` for use in integration testing scenarios.
TestTransaction
`TestTransaction` provides a collection of static utility methods for programmatic interaction with test-managed transactions within test methods, before methods, and after methods.
Timed
Test annotation for use with JUnit 4 to indicate that a test method has to finish execution in a specified time period.
TransactionalTestExecutionListener
`TestExecutionListener` that provides support for executing tests within test-managed transactions by honoring Spring's `@Transactional` annotation.
UnorderedRequestExpectationManager
`RequestExpectationManager` that matches requests to expectations regardless of the order of declaration of expected requests.
UriAssert
AssertJ `assertions` that can be applied to a `String` representing a URI.
UrlRegexRequestMatcher
A `WebRequestMatcher` that allows matching on `WebRequest#getUrl().toExternalForm()` using a regular expression.
ViewResultMatchers
Factory for assertions on the selected view.
WebAppConfiguration
`@WebAppConfiguration` is an annotation that can be applied to a test class to declare that the `ApplicationContext` loaded for an integration test should be a `WebApplicationContext`.
WebConnectionHtmlUnitDriver
`WebConnectionHtmlUnitDriver` enables configuration of the `WebConnection` for an `HtmlUnitDriver` instance.
WebDelegatingSmartContextLoader
`WebDelegatingSmartContextLoader` is a concrete implementation of `AbstractDelegatingSmartContextLoader` that delegates to a `GenericXmlWebContextLoader` (or a `GenericGroovyXmlWebContextLoader` if Groovy is present on the classpath) and an `AnnotationConfigWebContextLoader`.
WebMergedContextConfiguration
`WebMergedContextConfiguration` encapsulates the merged context configuration declared on a test class and all of its superclasses and enclosing classes via `@ContextConfiguration`, `@WebAppConfiguration`, `@ActiveProfiles`, and `@TestPropertySource`.
WebRequestMatcher
Strategy for matching on a `WebRequest`.
WebTestClient
Client for testing web servers that uses `WebClient` internally to perform requests while also providing a fluent API to verify responses.
WebTestClient.BodyContentSpec
Spec for expectations on the response body content.
WebTestClient.BodySpec<B,S extends WebTestClient.BodySpec<B,S>>
Spec for expectations on the response body decoded to a single Object.
WebTestClient.Builder
Steps for customizing the `WebClient` used to test with, internally delegating to a `WebClient.Builder`.
WebTestClient.ControllerSpec
Specification for customizing controller configuration equivalent to, and internally delegating to, a `WebFluxConfigurer`.
WebTestClient.ListBodySpec<E>
Spec for expectations on the response body decoded to a List.
WebTestClient.MockServerSpec<B extends WebTestClient.MockServerSpec<B>>
Base specification for setting up tests without a server.
WebTestClient.RequestBodySpec
Specification for providing body of a request.
WebTestClient.RequestBodyUriSpec
Specification for providing the body and the URI of a request.
WebTestClient.RequestHeadersSpec<S extends WebTestClient.RequestHeadersSpec<S>>
Specification for adding request headers and performing an exchange.
WebTestClient.RequestHeadersUriSpec<S extends WebTestClient.RequestHeadersSpec<S>>
Specification for providing request headers and the URI of a request.
WebTestClient.ResponseSpec
Chained API for applying assertions to a response.
WebTestClient.ResponseSpec.ResponseSpecConsumer
`Consumer` of a `WebTestClient.ResponseSpec`.
WebTestClient.RouterFunctionSpec
Specification for customizing router function configuration.
WebTestClient.UriSpec<S extends WebTestClient.RequestHeadersSpec<?>>
Specification for providing the URI of a request.
WebTestClientConfigurer
Contract to encapsulate customizations to a `WebTestClient.Builder`.
WebTestContextBootstrapper
Web-specific implementation of the `TestContextBootstrapper` SPI.
XmlExpectationsHelper
A helper class for assertions on XML content.
XpathAssertions
XPath assertions for the `WebTestClient`.
XpathExpectationsHelper
A helper class for applying assertions via XPath expressions.
XpathRequestMatchers
Factory methods for request content `RequestMatcher` implementations that use an XPath expression.
XpathResultMatchers
Factory for assertions on the response content using XPath expressions.