All Classes and Interfaces
类
说明
AbstractApplicationContextRunner<SELF extends AbstractApplicationContextRunner<SELF,C,A>,C extends cn.taketoday.context.ConfigurableApplicationContext,A extends ApplicationContextAssertProvider<C>>
Utility design to run an
ApplicationContext and provide AssertJ style
assertions.A Bean registration to be applied when the context loaded.
AbstractApplicationContextRunner.RunnerConfiguration<C extends cn.taketoday.context.ConfigurableApplicationContext>
Abstract application context loader that provides a basis for all concrete
implementations of the
ContextLoader SPI.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.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.Abstract base class for implementations of
ExecutionCondition that
evaluate expressions configured via annotations to determine if a container
or test is enabled.Abstract, generic extension of
AbstractContextLoader that loads a
GenericApplicationContext.Abstract, generic extension of
AbstractContextLoader that loads a
GenericWebApplicationContext.Base class for AssertJ based JSON marshal testers.
Utility class used to support field initialization.
Abstract base test class which integrates the Infra TestContext
Framework with explicit
ApplicationContext testing support
in a JUnit 4 environment.Abstract implementation of
MockMvcBuilder with common methods for
configuring filters, default request properties, global expectations and
global result actions.Base class for implementations of
MockMvcWebTestClient.MockMvcServerSpec
that simply delegates to a ConfigurableMockMvcBuilder supplied by
the concrete subclasses.Base class for implementations of
WebTestClient.MockServerSpec.Base class for
RequestExpectationManager implementations responsible
for storing expectations and actual requests, and checking for unsatisfied
expectations at the end.Helper class to manage a group of remaining expectations.
Abstract implementation of the
TestContextBootstrapper interface which
provides most of the behavior required by a bootstrapper.Abstract ordered implementation of the
TestExecutionListener API.Abstract transactional extension of
AbstractJUnit4ContextTests which adds convenience functionality
for JDBC access.ActiveProfiles is a class-level annotation that is used to declare
which active bean definition profiles should be used when loading
an ApplicationContext
for test classes.Strategy interface for programmatically resolving which active bean
definition profiles should be used when loading an
ApplicationContext
for a test class.Utility methods for working with
@ActiveProfiles and
ActiveProfilesResolvers.@EventListener annotation used to consume a
AfterTestClassEvent published by the
EventPublishingTestExecutionListener.TestContextEvent published by the EventPublishingTestExecutionListener when
TestExecutionListener.afterTestClass(TestContext)
is invoked.@EventListener annotation used to consume a
AfterTestExecutionEvent published by the
EventPublishingTestExecutionListener.TestContextEvent published by the EventPublishingTestExecutionListener when
TestExecutionListener.afterTestExecution(TestContext)
is invoked.@EventListener annotation used to consume a
AfterTestMethodEvent published by the
EventPublishingTestExecutionListener.TestContextEvent published by the EventPublishingTestExecutionListener when
TestExecutionListener.afterTestMethod(TestContext)
is invoked.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 Framework's @Transactional
annotation.Utility class to find a class annotated with a particular annotation in a hierarchy.
Cache implementation based on
LinkedHashMap.Concrete implementation of
AbstractGenericContextLoader that loads
bean definitions from component classes.Utility methods for
SmartContextLoaders that deal
with component classes (e.g., @Configuration classes).Concrete implementation of
AbstractGenericWebContextLoader that loads
bean definitions from annotated classes.AopTestUtils is a collection of AOP-related utility methods for
use in unit and integration testing scenarios.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 Infra TestContext Framework.MergedContextConfiguration implementation based on an AOT-generated
ApplicationContextInitializer that is used to load an AOT-optimized
ApplicationContext.Holder for metadata specific to ahead-of-time (AOT) support in the Infra
TestContext Framework.
Internal code generator for
AotTestAttributes.Factory for
AotTestAttributes.AotTestContextInitializers provides mappings from test classes to
AOT-optimized context initializers.Internal code generator for mappings used by
AotTestContextInitializers.Factory for
AotTestContextInitializers.AotTestExecutionListener is an extension of the TestExecutionListener
SPI that allows a listener to optionally provide ahead-of-time (AOT) support.ApplicationContextAssert<C extends cn.taketoday.context.ApplicationContext>
AssertJ
assertions that can be applied to an
ApplicationContext.ApplicationContextAssert.ContextFailedToStart<C extends cn.taketoday.context.ApplicationContext>
The scope of an assertion.
ApplicationContextAssertProvider<C extends cn.taketoday.context.ApplicationContext>
An
ApplicationContext that additionally supports AssertJ style assertions.Strategy for components that process failures related to application contexts
within the Infra TestContext Framework.
Utility methods for working with
ApplicationContextInitializers.Simple wrapper around a
DefaultMockMvcBuilder.An
ApplicationContext runner for a standard,
non-web environment ConfigurableApplicationContext.Application context related test utilities.
ApplicationEvents encapsulates all application events that were fired during the execution of a single test method.ApplicationListener that listens to all events and adds them to the
current ApplicationEvents instance if registered for the current thread.Holder class to expose the application events published during the execution
of a test in the form of a thread-bound
ApplicationEvents object.TestExecutionListener which provides support for ApplicationEvents.Factory that exposes the current
ApplicationEvents object on demand.An
ApplicationContext that additionally supports AssertJ style assertions.A
ReactiveWebApplicationContext that additionally supports AssertJ style
assertions.A
WebApplicationContext that additionally supports AssertJ style assertions.Test assertions that are independent of any third-party assertion library.
InvocationHandler used by ApplicationContextAssertProvider generated
proxies.AssertJ based JSON tester that works with basic JSON strings.
@EventListener annotation used to consume a
BeforeTestClassEvent published by the
EventPublishingTestExecutionListener.TestContextEvent published by the EventPublishingTestExecutionListener when
TestExecutionListener.beforeTestClass(TestContext)
is invoked.@EventListener annotation used to consume a
BeforeTestExecution published by the
EventPublishingTestExecutionListener.TestContextEvent published by the EventPublishingTestExecutionListener when
TestExecutionListener.beforeTestExecution(TestContext)
is invoked.@EventListener annotation used to consume a
BeforeTestMethodEvent published by the
EventPublishingTestExecutionListener.TestContextEvent published by the EventPublishingTestExecutionListener when
TestExecutionListener.beforeTestMethod(TestContext)
is invoked.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 Framework's @Transactional
annotation.BootstrapContext encapsulates the context in which the Infra
TestContext Framework is bootstrapped.BootstrapUtils is a collection of utility methods to assist with
bootstrapping the TestContext Framework.@BootstrapWith defines class-level metadata that is used to determine
how to bootstrap the TestContext Framework.A
CacheAwareContextLoaderDelegate is responsible for loading and closing application
contexts, interacting transparently with a
ContextCache
behind the scenes.Provides access to
System.out and System.err
output that has been captured by the OutputCaptureExtension or
OutputCaptureRule.@Commit is a test annotation that is used to indicate that a
test-managed transaction should be committed after
the test method has completed.ApplicationContextInitializer that can be used with the
ContextConfiguration.initializers() to trigger loading of ConfigData
such as application.properties.Defines common methods for building a
MockMvc.An extension of
SmartRequestBuilder that can be configured with RequestPostProcessors.Factory for request content
RequestMatcher's.Abstract base class for XML
RequestMatcher's.Factory for response content assertions.
ContextCache defines the SPI for caching Infra
ApplicationContexts within the
TestContext Framework.Collection of utilities for working with
ContextCaches.@ContextConfiguration defines class-level metadata that is used to determine
how to load and configure an ApplicationContext for integration tests.ContextConfigurationAttributes encapsulates the context configuration
attributes declared via @ContextConfiguration.ContextConsumer<C extends cn.taketoday.context.ApplicationContext>
Callback interface used to process an
ApplicationContext with the ability to
throw a (checked) exception.Strategy interface for customizing
application contexts that are created and managed by the Infra
TestContext Framework.@ContextCustomizerFactories defines class-level metadata for configuring
which ContextCustomizerFactory implementations should be registered with
the Infra TestContext Framework.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.Factory for creating
ContextCustomizers.@ContextHierarchy is a class-level annotation that is used to define
a hierarchy of ApplicationContexts for integration tests.Strategy interface for loading an
application context
for an integration test managed by the TestContext Framework.Utility methods for resolving
ContextConfigurationAttributes from the
@ContextConfiguration and
@ContextHierarchy annotations for use with
SmartContextLoaders.Exception thrown when an error occurs while a
SmartContextLoader
attempts to load an ApplicationContext.Assertions on cookies of the response.
Factory for response cookie assertions.
Default implementation of the
ActiveProfilesResolver strategy that
resolves active bean definition profiles based solely on profiles
configured declaratively via ActiveProfiles.profiles() or
ActiveProfiles.value().Default implementation of
AotTestAttributes backed by a Map.Default implementation of
ApplicationEvents.Default implementation of the
BootstrapContext interface.Default implementation of the
CacheAwareContextLoaderDelegate interface.Default implementation of the
ContextCache API.A concrete implementation of
AbstractMockMvcBuilder that provides
the WebApplicationContext supplied to it as a constructor argument.A simple implementation of
MvcResult with setters.Default implementation of
RequestExpectation that simply delegates
to the request matchers and the response creator it contains.Helper class that keeps track of actual vs expected request count.
A
ResponseCreator with builder-style methods for adding response details.Spec for setting up server-less testing against a RouterFunction.
Default implementation of the
TestContext interface.Default implementation of the
TestContextBootstrapper SPI.Default implementation of
WebTestClient.Default implementation of
WebTestClient.Builder.Base class for
MockDefinition and SpyDefinition.Parser to create
MockDefinition and SpyDefinition instances from
@MockBean and @SpyBean annotations declared on or in a
class.Delegating implementation of
ServletInputStream.Delegating implementation of
ServletOutputStream.DelegatingSmartContextLoader is a concrete implementation of
AbstractDelegatingSmartContextLoader that delegates to a
GenericXmlContextLoader AnnotationConfigContextLoader.Implementation of
WebConnection that allows delegating to various
WebConnection implementations.The delegate web connection.
TestExecutionListener which provides support for dependency
injection and initialization of test instances.Test annotation which indicates that the
ApplicationContext
associated with a test is dirty and should therefore be closed
and removed from the context cache.Defines modes which determine how
@DirtiesContext is
interpreted when used to annotate a test class.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.Defines modes which determine how
@DirtiesContext is
interpreted when used to annotate a test method.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.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 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 is an ExecutionCondition
that supports the @DisabledIf annotation when using the Infra
TestContext Framework in conjunction with JUnit 5's Jupiter programming model.@DisabledInAotMode signals that an annotated test class is disabled
in Infra AOT (ahead-of-time) mode, which means that the ApplicationContext
for the test class will not be processed for AOT optimizations at build time.ExecutionCondition implementation for DisabledInAotMode.Strategy interface for customizing
DispatcherServlet instances that are
managed by MockMvc.A
ContextCustomizerFactory that produces a ContextCustomizer that warns
the user when multiple occurrences of JSONObject are found on the class path.ContextCustomizer to support
@DynamicPropertySource methods.ContextCustomizerFactory to support
@DynamicPropertySource methods.Registry used with
@DynamicPropertySource
methods so that they can add properties to the Environment that have
dynamically resolved values.Method-level annotation for integration tests that need to add properties with
dynamic values to the
Environment's set of PropertySources.EnumerablePropertySource backed by a map with dynamically supplied
values.@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 is an ExecutionCondition
that supports the @EnabledIf annotation when using the Infra
TestContext Framework in conjunction with JUnit 5's Jupiter programming model.ExchangeResult sub-class that exposes the response body fully
extracted to a representation of type <T>.TestExecutionListener that publishes test execution events to the
ApplicationContext
for the currently executing test.ExceptionCollector is a test utility for executing code blocks,
collecting exceptions, and generating a single AssertionError
containing any exceptions encountered as suppressed exceptions.Executable is a functional interface that can be used to implement
any generic block of code that potentially throws a Throwable.Container for request and response details for exchanges performed through
WebTestClient.ApplicationContextInitializer to register the TestTypeExcludeFilter for
when Application.from(cn.taketoday.util.function.ThrowingConsumer<java.lang.String[]>) is being used with the test classpath.A simple type representing a range for an expected count.
FailOnTimeout is a custom JUnit Statement which adds
support for Framework's @Timed
annotation by throwing an exception if the next statement in the execution
chain takes more than the specified number of milliseconds.Test
URLClassLoader that can filter the classes and resources it can load.Filter to restrict the classes that can be loaded.
Filter to restrict the resources that can be loaded.
Filter to restrict the packages that can be loaded.
Factory for "output" flash attribute assertions.
ExchangeResult variant with the response body decoded as
Flux<T> but not yet consumed.RequestPostProcessor to update the request for a forwarded dispatch.Utilities for loading generated maps.
Concrete implementation of
AbstractGenericContextLoader that reads
bean definitions from Java Properties resources.Concrete implementation of
AbstractGenericContextLoader that reads
bean definitions from XML resources.Concrete implementation of
AbstractGenericWebContextLoader that loads
bean definitions from XML resources.AssertJ based JSON tester backed by Gson.
Factory for assertions on the selected handler or handler method.
Assertions on headers of the response.
Factory for response header assertions.
Internal helper class that serves as a value holder for request headers.
A
WebRequestMatcher that allows matching on the host and optionally
the port of WebRequest#getUrl().Internal class used to transform a
WebRequest into a
MockHttpServletRequest using Web MVC Test's RequestBuilder.Connector that handles requests by invoking an
HttpHandler rather
than making actual requests to a network socket.Indicates that an error occurred after the server response was completed,
via
ReactiveHttpOutputMessage.writeWith(org.reactivestreams.Publisher<? extends cn.taketoday.core.io.buffer.DataBuffer>) or ReactiveHttpOutputMessage.setComplete(),
and can no longer be changed.Test annotation for use with JUnit 4 to indicate whether a test is enabled or
disabled for a specific testing profile.
ContextCustomizer to allow @Import annotations to be used directly on
test classes.The key used to ensure correct application context caching.
BeanDefinitionRegistryPostProcessor to cleanup temporary configuration
added to load imports.@Configuration registered to trigger the
ImportsContextCustomizer.ImportsSelector.ImportSelector that returns the original test class so that direct
@Import annotations are processed.ContextCustomizerFactory to allow @Import annotations to be used
directly on test classes.A
ContextLoader that can be used to test Infra applications (those that
normally startup using Application).Adapts a
ContextCustomizer to a ApplicationContextInitializer so
that it can be triggered via Application.ApplicationContextInitializer used to set the parent context.Inner class to configure
WebMergedContextConfiguration.ApplicationClassRule is a custom JUnit TestRule that supports
class-level features of the TestContext Framework
in standard JUnit tests by means of the TestContextManager and
associated support classes and annotations.ApplicationExtension integrates the TestContext Framework
into JUnit 5's Jupiter programming model.ApplicationMethodRule is a custom JUnit 4 MethodRule that
supports instance-level and method-level features of the
TestContext Framework in standard JUnit tests by means
of the TestContextManager and associated support classes and
annotations.A
MockResolver for testing Infra applications with Resolves
mocks by returning the ultimate
target object of the instance.MockServletContext implementation for Infra.Runner is an alias for the JUnit4ClassRunner.Annotation that can be specified on a test class that runs Infra based tests.
An enumeration web environment modes.
Entry point for AOT processing of a Infra application's tests.
ContextCustomizer to track application arguments that are used in a
InfraTest.TestContextBootstrapper for Infra.EnvironmentPostProcessor implementation to start the management context on a
random port if the main server's port is 0 and the management context is expected on a
different port.ContextCustomizer to track the web environment that is used in a
InfraTest.AssertJ based JSON tester backed by Jackson.
AbstractJsonMarshalTester.FieldInitializer for Jackson.JdbcTestUtils is a collection of JDBC related utility functions
intended to simplify standard database testing scenarios.AssertJ based JSON tester backed by Jsonb.
AbstractJsonMarshalTester.FieldInitializer for Jsonb.JSON content usually created from a JSON tester.
AssertJ
Assert for JsonContent.A helper class for assertions on JSON content.
Internal helper used to load JSON from various sources.
JsonPath assertions.
A helper class for applying assertions via JSON path expressions.
Factory for assertions on the request content using
JsonPath expressions.
Abstract base class for
JsonPath-based RequestMatchers.Factory for assertions on the response content using
JsonPath expressions.
JUnit4ClassRunner is a custom extension of JUnit's
BlockJUnit4ClassRunner which provides functionality of the
TestContext Framework to standard JUnit tests by means of the
TestContextManager and associated support classes and annotations.@ApplicationJUnitConfig is a composed annotation that combines
@ExtendWith(ApplicationExtension.class) from JUnit Jupiter with
@ContextConfiguration from the Infra TestContext
Framework.@ApplicationJUnitWebConfig is a composed annotation that combines
@ExtendWith(ApplicationExtension.class) from JUnit Jupiter with
@ContextConfiguration and
@WebAppConfiguration from the TestContext Framework.UriTemplateHandler will automatically prefix relative URIs with
localhost:${local.server.port}.Annotation at the field or method/constructor parameter level that injects the HTTP
port that got allocated at runtime.
MergedContextConfiguration encapsulates the merged
context configuration declared on a test class and all of its superclasses
via @ContextConfiguration,
@ActiveProfiles, and
@TestPropertySource.MergedContextConfigurationRuntimeHints registers run-time hints for
standard functionality in the Infra TestContext Framework based on
MergedContextConfiguration.MergedSqlConfig encapsulates the merged @SqlConfig
attributes declared locally via Sql.config() and globally as a class-level annotation.MergedTestPropertySources encapsulates the merged
property sources declared on a test class and all of its superclasses
via @TestPropertySource.Mock implementation of the
AsyncContext interface.Annotation that can be used to add mocks to a Infra
ApplicationContext.Container annotation that aggregates several
@MockBean annotations.Mock implementation of the
BodyContent class.Mock implementation of
ClientHttpRequest.Mock implementation of
ClientHttpRequest.Mock implementation of
ClientHttpResponse.Mock implementation of
ClientHttpResponse.Extension of
Cookie with extra attributes, as defined in
RFC 6265.A complete definition that can be used to create a Mockito mock.
Simple
ConfigurableEnvironment implementation exposing
MockEnvironment.setProperty(String, String) and MockEnvironment.withProperty(String, String)
methods for testing purposes.Mock implementation of the
FilterChain interface.A filter that simply delegates to a Servlet.
Mock implementation of the
FilterConfig interface.Mock implementation of
HttpInputMessage.Mock implementation of
HttpOutputMessage.Mock implementation of
HttpServletMapping.Mock implementation of the
HttpServletRequest interface.Default builder for
MockHttpServletRequest required as input to
perform requests in MockMvc.Mock implementation of the
HttpServletResponse interface.Mock implementation of the
HttpSession interface.Beans created using
A
ContextCustomizer to add Mockito support.A
ContextCustomizerFactory to add Mockito support.BeanPostProcessor to handle SpyBean definitions.ReflectionUtils.FieldCallback to collect Mockito annotations.Mock implementation of the
JspWriter class.Mock implementation of the
MultipartFile
interface.Mock implementation of the
MultipartRequest interface.Default builder for
MockMultipartHttpServletRequest.Main entry point for server-side Web MVC test support.
Builds a
MockMvc instance.The main class to import in order to access all available
MockMvcBuilders.Base class for MockMvc builder implementations, providing the capability to
create a
MockMvc instance.A
ClientHttpRequestFactory for requests executed via MockMvc.Contract for customizing a
ConfigurableMockMvcBuilder in some
specific way, e.g. a 3rd party library that wants to provide shortcuts for
setting up a MockMvc.An empty method implementation of
MockMvcConfigurer.A Filter that invokes a delegate
Filter only if the request URL
matches the pattern it is mapped to using pattern matching as defined in the
Servlet spec.MockMvcHtmlUnitDriverBuilder simplifies the building of an
HtmlUnitDriver that delegates to MockMvc and optionally
delegates to an actual connection for specific requests.Connector that handles requests by invoking a
MockMvc rather than
making actual requests over HTTP.Static factory methods for
RequestBuilders.Static factory methods for
ResultHandler-based result actions.A
PrintingResultHandler that writes to a PrintWriter.Static factory methods for
ResultMatcher-based result actions.MockMvcWebClientBuilder simplifies the creation of an HtmlUnit
WebClient that delegates to a MockMvc instance.Support class that simplifies the creation of a
WebConnection that
uses MockMvc and optionally delegates to a real WebConnection
for specific requests.The main class for testing Web MVC applications via
WebTestClient
with MockMvc for server request handling.Specification for configuring
MockMvc to test one or more
controllers directly, and a simple facade around
StandaloneMockMvcBuilder.Base specification for configuring
MockMvc, and a simple facade
around ConfigurableMockMvcBuilder.Mock implementation of the
PageContext interface.Mock implementation of
jakarta.servlet.http.Part.Simple
PropertySource implementation for use in testing.Mock implementation of the
RequestDispatcher interface.Reset strategy used on a mock bean.
Dummy
InvocationListener used to hold the MockReset value.Static factory methods for
RequestMatcher classes.Static factory methods for obtaining a
ResponseCreator instance.Main entry point for client-side REST testing.
Builder to create a
MockRestServiceServer.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.Contract that frameworks or applications can use to pre-package a set of
customizations to a
WebTestClient.MockServerSpec and expose that
as a shortcut.Mock implementation of the
ServerContainer interface.ContextCustomizer that instantiates a new MockServerContainer
and stores it in the ServletContext under the attribute named
"jakarta.websocket.server.ServerContainer".ContextCustomizerFactory which creates a MockServerContainerContextCustomizer
if WebSocket support is present in the classpath and the test class is annotated
with @WebAppConfiguration.Mock extension of
AbstractServerHttpRequest for use in tests without
an actual server.Request builder exposing properties not related to the body.
A builder that adds a body to the request.
Mock extension of
AbstractServerHttpResponse for use in tests without
an actual server.RestTemplateCustomizer that can be applied to a RestTemplateBuilder
instances to add MockRestServiceServer support.Mock implementation of the
ServletConfig interface.Mock implementation of the
ServletContext interface.Mock implementation of the
SessionCookieConfig interface.Builder used internally to create
WebResponses.A collection of assertions intended to simplify testing scenarios dealing
with Infra Web MVC
ModelAndView objects.Factory for assertions on the model.
Provides access to the result of an executed request.
@NestedTestConfiguration is a type-level annotation that is used to
configure how Infra test configuration annotations are processed within
enclosing class hierarchies (i.e., for inner test classes).Enumeration of modes that dictate how test configuration from
enclosing classes is processed for inner test classes.
Object content usually created from
AbstractJsonMarshalTester.AssertJ
Assert for ObjectContent.Provides support for capturing
System.out and System.err.Save, disable and restore AnsiOutput without it needing to be on the classpath.
A captured string that forms part of the full output.
An
OutputStream implementation that captures written strings.A
PrintStream implementation that captures written strings.A capture session that captures
System.out and System.err.Types of content that can be captured.
JUnit
@Rule to capture output from System.out and System.err.Implementation of the
FilterConfig 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).@EventListener annotation used to consume a
PrepareTestInstanceEvent published by the
EventPublishingTestExecutionListener.TestContextEvent published by the EventPublishingTestExecutionListener when
TestExecutionListener.prepareTestInstance(TestContext)
is invoked.Result handler that prints
MvcResult details to a given output
stream — for example: System.out, System.err, a
custom java.io.PrintWriter, etc.A contract for how to actually write result information.
ProfileValueChecker is a custom JUnit Statement that checks
whether a test class or test method is enabled in the current environment
via Framework's @IfProfileValue annotation.
Strategy interface for retrieving profile values for a given
testing environment.
ProfileValueSourceConfiguration is a class-level annotation for use
with JUnit 4 which is used to specify what type of ProfileValueSource
to use when retrieving profile values configured via
@IfProfileValue.General utility methods for working with profile values.
Strategy for providing named properties — for example, for looking up
key-value pairs in a generic fashion.
Definition of a Infra
@Qualifier.An
ApplicationContext runner for a
ConfigurableReactiveWebApplicationContext.Encapsulates the merged context configuration declared on a test class and all
of its superclasses for a reactive web application.
@RecordApplicationEvents is a class-level annotation that is used to
instruct the Infra 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 is a collection of reflection-based utility
methods for use in unit and integration testing scenarios.Test annotation for use with JUnit 4 to indicate that a test method should be
invoked repeatedly.
RepeatTest is a custom JUnit Statement which adds support
for Framework's @Repeat
annotation by repeating the test the specified number of times.Builds a
MockHttpServletRequest.An extension of
ResponseActions that also implements
RequestMatcher and ResponseCreatorEncapsulates the behavior required to implement
MockRestServiceServer
including its public API (create expectations + verify/reset) along with an
extra method for verifying actual requests.A contract for matching requests to expectations.
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.Factory for assertions on the request.
TestExecutionListener to reset any mock beans that have been marked with a
MockReset.A contract for setting up request expectations and defining a response.
A contract for creating a
ClientHttpResponse.Allows applying actions, such as expectations, on the result of an executed
request.
A
ResultHandler performs a generic action on the result of an
executed request — for example, printing debug information.A
ResultMatcher matches the result of an executed request against
some expectation.@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.RequestExpectationManager that strips the specified root URI from the request
before verification.ClientHttpRequest wrapper to replace the request URI.RunAfterTestClassCallbacks is a custom JUnit Statement which allows
the TestContext Framework to be plugged into the JUnit execution chain
by calling afterTestClass() on the supplied
TestContextManager.RunAfterTestExecutionCallbacks is a custom JUnit Statement
which allows the TestContext Framework to be plugged into the
JUnit 4 execution chain by calling afterTestExecution() on the supplied TestContextManager.RunAfterTestMethodCallbacks is a custom JUnit Statement which allows
the TestContext Framework to be plugged into the JUnit execution chain
by calling afterTestMethod() on the supplied
TestContextManager.RunBeforeTestClassCallbacks is a custom JUnit Statement which allows
the TestContext Framework to be plugged into the JUnit execution chain
by calling beforeTestClass() on the
supplied TestContextManager.RunBeforeTestExecutionCallbacks is a custom JUnit Statement
which allows the TestContext Framework to be plugged into the
JUnit 4 execution chain by calling beforeTestExecution() on the supplied TestContextManager.RunBeforeTestMethodCallbacks is a custom JUnit Statement which allows
the TestContext Framework to be plugged into the JUnit execution chain
by calling beforeTestMethod() on the supplied TestContextManager.RunPrepareTestInstanceCallbacks is a custom JUnit Statement which
allows the TestContext Framework to be plugged into the JUnit
execution chain by calling prepareTestInstance() on the supplied TestContextManager.TestExecutionListener which provides mock Servlet API support to
WebServletApplicationContext loaded by the Infra
TestContext Framework.MockMvcConfigurer that stores and re-uses the HTTP session across
multiple requests performed through the same MockMvc instance.Simple
RequestExpectationManager that matches requests to expectations
sequentially, i.e. in the order of declaration of expectations.Strategy interface for loading an
application context
for an integration test managed by the TestContext Framework.Extended variant of a
RequestBuilder that applies its
cn.taketoday.test.web.servlet.request.RequestPostProcessors
as a separate step from the RequestBuilder.buildRequest(jakarta.servlet.ServletContext) method.Annotation that can be used to apply Mockito spies to a Infra
ApplicationContext.Container annotation that aggregates several
@SpyBean annotations.A complete definition that can be used to create a Mockito spy.
A
VerificationStartedListener that bypasses any proxy created by Infra AOP
when the verification of a spy starts.@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.Enumeration of phases that dictate when SQL scripts are executed.
@SqlConfig defines metadata that is used to determine how to parse
and execute SQL scripts configured via the @Sql annotation.Enumeration of modes that dictate how errors are handled while
executing SQL statements.
Enumeration of modes that dictate whether SQL scripts should be
executed within a transaction and what the transaction propagation behavior
should be.
Container annotation that aggregates several
@Sql annotations.@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.Enumeration of modes that dictate whether method-level
@Sql
declarations are merged with class-level @Sql declarations.TestExecutionListener that provides support for executing SQL
scripts and inlined statements
configured via the @Sql annotation.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.A
ViewResolver that always returns same View.Simple wrapper around a
StandaloneMockMvcBuilder that implements
MockMvcWebTestClient.ControllerSpec.TestRuntimeHintsRegistrar implementation that registers run-time hints
for standard functionality in the Infra TestContext Framework.Assertions on the response status.
Factory for assertions on the response status.
A stub WebApplicationContext that accepts registrations of object instances.
Implementation of
ProfileValueSource which uses system properties as
the underlying source.Collection of utility methods for working with Framework's core testing annotations.
Filesystem-based ahead-of-time (AOT) processing base implementation that scans
the provided classpath roots for Infra integration test classes and then
generates AOT artifacts for those test classes in the configured output directories.
TestClassScanner scans provided classpath roots for Infra integration
test classes using the JUnit Platform Launcher API which allows all
registered TestEngines to discover
tests according to their own rules.@Component that can be used when a bean is intended only for tests,
and should be excluded from Infra's component scanning.@Configuration that can be used to define additional beans or
customizations for a test.@TestConstructor is a type-level annotation that is used to configure
how the parameters of a test class constructor are autowired from components
in the test's ApplicationContext.Defines autowiring modes for parameters in a test constructor.
Utility methods for working with
@TestConstructor.TestContext encapsulates the context in which a test is executed,
agnostic of the actual testing framework in use.TestContextAnnotationUtils is a collection of utility methods that
complements the standard support already available in AnnotationUtils
and AnnotatedElementUtils, while transparently honoring
@NestedTestConfiguration semantics.Descriptor for an
Annotation, including the class on which the annotation is declared
as well as the merged annotation instance.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.Thrown if an error occurs during AOT build-time processing or AOT run-time
execution in the Infra TestContext Framework.
TestContextAotGenerator generates AOT artifacts for integration tests
that depend on support from the Infra TestContext Framework.TestContextBootstrapper defines the SPI for bootstrapping the
TestContext Framework.Base class for events published by the
EventPublishingTestExecutionListener.Collection of utilities for working with
TodayStrategies within
the Infra TestContext Framework.Infra factories
TodayStrategies.FailureHandler used
within the Infra TestContext Framework.Extension of
DefaultGenerationContext with a custom implementation of
TestContextGenerationContext.withName(String) that is specific to the Infra TestContext Framework.TestContextManager is the main entry point into the Infra
TestContext Framework.Utility methods for working with resources within the Infra TestContext
Framework.
RuntimeHintsRegistrar implementation that makes types and annotations
from the Infra TestContext Framework available at runtime.Utility methods for working with transactions and data access related beans
within the TestContext Framework.
A subclass of
DispatcherServlet that saves the result in an
MvcResult.TestExecutionListener defines a listener API for reacting to
test execution events published by the TestContextManager with which
the listener is registered.TestExecutionListeners defines class-level metadata for configuring
which TestExecutionListeners should be
registered with a TestContextManager.Enumeration of modes that dictate whether or not explicitly
declared listeners are merged with the default listeners when
@TestExecutionListeners is declared on a class that does
not inherit listeners from a superclass.Callback interface trigger from
InfraTestContextBootstrapper that can be
used to post-process the list of default TestExecutionListener classes to be
used by a test.@TestPropertySource is a class-level annotation that is used 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.TestPropertySourceAttributes encapsulates attributes declared
via @TestPropertySource annotations.@TestPropertySources is a container for one or more
@TestPropertySource declarations.Utility methods for working with
@TestPropertySource
and adding test PropertySources to the Environment.Extension of
Properties that mimics a SequencedMap by tracking
all added properties with a String key in a LinkedHashMap.Test utilities for adding properties.
A single name value pair.
The type of property source.
Convenient alternative of
RestTemplate that is suitable for integration tests.HttpComponentsClientHttpRequestFactory to apply customizations.Options used to customize the Apache HTTP Client.
FactoryBean used to create and configure a TestRestTemplate.BeanDefinitionRegistryPostProcessor that runs after the
ConfigurationClassPostProcessor and add a TestRestTemplateContextCustomizer.TestRestTemplateFactory
bean definition when a TestRestTemplate hasn't already been registered.Contract for registering
RuntimeHints for integration tests run with
the Infra TestContext Framework based on the ClassLoader
of the deployment unit.TestTransaction provides a collection of static utility methods for
programmatic interaction with test-managed transactions within
test methods, before methods, and after methods.TypeExcludeFilter to exclude classes annotated with
@TestComponent as well as inner-classes of tests.Test annotation for use with JUnit 4 to indicate that a test method has to finish
execution in a specified time period.
TestExecutionListener that provides support for executing tests
within test-managed transactions by honoring Framework's
@Transactional annotation.Transaction context for a specific
TestContext.InheritableThreadLocal-based holder for the current TransactionContext.RequestExpectationManager that matches requests to expectations
regardless of the order of declaration of expected requests.A
WebRequestMatcher that allows matching on
WebRequest#getUrl().toExternalForm() using a regular expression.Factory for assertions on the selected view.
@WebAppConfiguration is a class-level annotation that is used to
declare that the ApplicationContext loaded for an integration test
should be a WebApplicationContext.An
ApplicationContext runner for a Servlet
based ConfigurableWebApplicationContext.WebConnectionHtmlUnitDriver enables configuration of the
WebConnection for an HtmlUnitDriver instance.WebDelegatingSmartContextLoader is a concrete implementation of
AbstractDelegatingSmartContextLoader that delegates to a
GenericXmlWebContextLoader and an AnnotationConfigWebContextLoader.WebMergedContextConfiguration encapsulates the merged
context configuration declared on a test class and all of its superclasses
via @ContextConfiguration,
@WebAppConfiguration, and
@ActiveProfiles.Strategy for matching on a
WebRequest.Client for testing web servers that uses
WebClient internally to
perform requests while also providing a fluent API to verify responses.Spec for expectations on the response body content.
Spec for expectations on the response body decoded to a single Object.
Steps for customizing the
WebClient used to test with,
internally delegating to a
WebClient.Builder.Spec for expectations on the response body decoded to a List.
Base specification for setting up tests without a server.
Specification for providing body of a request.
Specification for providing the body and the URI of a request.
Specification for adding request headers and performing an exchange.
Specification for providing request headers and the URI of a request.
Chained API for applying assertions to a response.
Specification for customizing router function configuration.
Specification for providing the URI of a request.
A customizer for a
WebTestClient.Builder.Contract to encapsulate customizations to a
WebTestClient.Builder.FactoryBean used to create and configure a WebTestClient.BeanDefinitionRegistryPostProcessor that runs after the
ConfigurationClassPostProcessor and add a WebTestClientContextCustomizer.WebTestClientFactory bean
definition when a WebTestClient hasn't already been registered.ContextCustomizerFactory for WebTestClient.Web-specific implementation of the
TestContextBootstrapper SPI.Decorate another
ClientHttpConnector with the purpose of
intercepting, capturing, and exposing actual request and response data
transmitted to and received from the server.ClientHttpRequestDecorator that intercepts and saves the request body.
ClientHttpResponseDecorator that intercepts and saves the response body.
Tap into a Publisher of data buffers to save the content.
A helper class for assertions on XML content.
Inner class to prevent hard dependency on XML Unit.
XPath assertions for the
WebTestClient.Lets us be able to use lambda expressions that could throw checked exceptions, since
XpathExpectationsHelper throws Exception on its methods.A helper class for applying assertions via XPath expressions.
Factory methods for request content
RequestMatcher implementations
that use an XPath expression.Functional interface for XPath
RequestMatcher implementations.Factory for assertions on the response content using XPath expressions.