 |
 |
|
 |
10.1 Introduction to Spring Testing
Testing is an integral part of enterprise software development. This chapter focuses on
the value-add of the IoC principle to unit testing and on the benefits
of the Spring Framework’s support for integration testing. (A
thorough treatment of testing in the enterprise is beyond the scope of this reference
manual.)
Dependency Injection should make your code less dependent on the container than it would
be with traditional Java EE development. The POJOs that make up your application should
be testable in JUnit or TestNG tests, with objects simply instantiated using the new
operator, without Spring or any other container. You can use mock
objects (in conjunction with other valuable testing techniques) to test your code in
isolation. If you follow the architecture recommendations for Spring, the resulting
clean layering and componentization of your codebase will facilitate easier unit
testing. For example, you can test service layer objects by stubbing or mocking DAO or
Repository interfaces, without needing to access persistent data while running unit
tests.
True unit tests typically run extremely quickly, as there is no runtime infrastructure
to set up. Emphasizing true unit tests as part of your development methodology will
boost your productivity. You may not need this section of the testing chapter to help
you write effective unit tests for your IoC-based applications. For certain unit testing
scenarios, however, the Spring Framework provides the following mock objects and testing
support classes.
The org.springframework.mock.jndi package contains an implementation of the JNDI SPI,
which you can use to set up a simple JNDI environment for test suites or stand-alone
applications. If, for example, JDBC DataSource s get bound to the same JNDI names in
test code as within a Java EE container, you can reuse both application code and
configuration in testing scenarios without modification.
The org.springframework.mock.web package contains a comprehensive set of Servlet API
mock objects, targeted at usage with Spring’s Web MVC framework, which are useful for
testing web contexts and controllers. These mock objects are generally more convenient
to use than dynamic mock objects such as EasyMock or existing
Servlet API mock objects such as MockObjects.
The org.springframework.mock.web.portlet package contains a set of Portlet API mock
objects, targeted at usage with Spring’s Portlet MVC framework.
10.2.2 Unit Testing support Classes
The org.springframework.test.util package contains ReflectionTestUtils , which is a
collection of reflection-based utility methods. Developers use these methods in unit and
integration testing scenarios in which they need to set a non- public field or invoke
a non- public setter method when testing application code involving, for example:
-
ORM frameworks such as JPA and Hibernate that condone
private or protected field
access as opposed to public setter methods for properties in a domain entity.
-
Spring’s support for annotations such as
@Autowired , @Inject , and @Resource,
which provides dependency injection for private or protected fields, setter
methods, and configuration methods.
The org.springframework.test.web package contains ModelAndViewAssert , which you can
use in combination with JUnit, TestNG, or any other testing framework for unit tests
dealing with Spring MVC ModelAndView objects.
![[Tip]](images/tip.png) | Unit testing Spring MVC Controllers |
---|
To test your Spring MVC Controller s, use ModelAndViewAssert combined with
MockHttpServletRequest , MockHttpSession , and so on from the org.springframework.mock.web package.
Note: As of Spring 4.0, the set of mocks in the org.springframework.mock.web package
is now based on the Servlet 3.0 API.
|
It is important to be able to perform some integration testing without requiring
deployment to your application server or connecting to other enterprise infrastructure.
This will enable you to test things such as:
-
The correct wiring of your Spring IoC container contexts.
-
Data access using JDBC or an ORM tool. This would include such things as the
correctness of SQL statements, Hibernate queries, JPA entity mappings, etc.
The Spring Framework provides first-class support for integration testing in the
spring-test module. The name of the actual JAR file might include the release version
and might also be in the long org.springframework.test form, depending on where you
get it from (see the section on Dependency Management for an
explanation). This library includes the org.springframework.test package, which
contains valuable classes for integration testing with a Spring container. This testing
does not rely on an application server or other deployment environment. Such tests are
slower to run than unit tests but much faster than the equivalent Selenium tests or remote
tests that rely on deployment to an application server.
In Spring 2.5 and later, unit and integration testing support is provided in the form of
the annotation-driven Spring TestContext Framework. The
TestContext framework is agnostic of the actual testing framework in use, thus allowing
instrumentation of tests in various environments including JUnit, TestNG, and so on.
10.3.2 Goals of Integration Testing
Spring’s integration testing support has the following primary goals:
The next few sections describe each goal and provide links to implementation and
configuration details.
Context management and caching
The Spring TestContext Framework provides consistent loading of Spring
ApplicationContext s and WebApplicationContext s as well as caching of those
contexts. Support for the caching of loaded contexts is important, because startup time
can become an issue — not because of the overhead of Spring itself, but because the
objects instantiated by the Spring container take time to instantiate. For example, a
project with 50 to 100 Hibernate mapping files might take 10 to 20 seconds to load the
mapping files, and incurring that cost before running every test in every test fixture
leads to slower overall test runs that reduce developer productivity.
Test classes typically declare either an array of resource locations for XML
configuration metadata — often in the classpath — or an array of annotated classes
that is used to configure the application. These locations or classes are the same as or
similar to those specified in web.xml or other deployment configuration files.
By default, once loaded, the configured ApplicationContext is reused for each test.
Thus the setup cost is incurred only once per test suite, and subsequent test execution
is much faster. In this context, the term test suite means all tests run in the same
JVM — for example, all tests run from an Ant, Maven, or Gradle build for a given
project or module. In the unlikely case that a test corrupts the application context and
requires reloading — for example, by modifying a bean definition or the state of an
application object — the TestContext framework can be configured to reload the
configuration and rebuild the application context before executing the next test.
See the section called “Context management” and the section called “Context caching” with the
TestContext framework.
Dependency Injection of test fixtures
When the TestContext framework loads your application context, it can optionally
configure instances of your test classes via Dependency Injection. This provides a
convenient mechanism for setting up test fixtures using preconfigured beans from your
application context. A strong benefit here is that you can reuse application contexts
across various testing scenarios (e.g., for configuring Spring-managed object graphs,
transactional proxies, DataSource s, etc.), thus avoiding the need to duplicate
complex test fixture setup for individual test cases.
As an example, consider the scenario where we have a class, HibernateTitleRepository ,
that implements data access logic for a Title domain entity. We want to write
integration tests that test the following areas:
-
The Spring configuration: basically, is everything related to the configuration of the
HibernateTitleRepository bean correct and present?
-
The Hibernate mapping file configuration: is everything mapped correctly, and are the
correct lazy-loading settings in place?
-
The logic of the
HibernateTitleRepository : does the configured instance of this
class perform as anticipated?
See dependency injection of test fixtures with the TestContext
framework.
One common issue in tests that access a real database is their effect on the state of
the persistence store. Even when you’re using a development database, changes to the
state may affect future tests. Also, many operations — such as inserting or modifying
persistent data — cannot be performed (or verified) outside a transaction.
The TestContext framework addresses this issue. By default, the framework will create
and roll back a transaction for each test. You simply write code that can assume the
existence of a transaction. If you call transactionally proxied objects in your tests,
they will behave correctly, according to their configured transactional semantics. In
addition, if a test method deletes the contents of selected tables while running within
the transaction managed for the test, the transaction will roll back by default, and the
database will return to its state prior to execution of the test. Transactional support
is provided to a test via a PlatformTransactionManager bean defined in the test’s
application context.
If you want a transaction to commit — unusual, but occasionally useful when you want a
particular test to populate or modify the database — the TestContext framework can be
instructed to cause the transaction to commit instead of roll back via the
@TransactionConfiguration and
@Rollback annotations.
See transaction management with the TestContext framework.
Support classes for integration testing
The Spring TestContext Framework provides several abstract support classes that
simplify the writing of integration tests. These base test classes provide well-defined
hooks into the testing framework as well as convenient instance variables and methods,
which enable you to access:
-
The
ApplicationContext , for performing explicit bean lookups or testing the state of
the context as a whole.
-
A
JdbcTemplate , for executing SQL statements to query the database. Such queries can
be used to confirm database state both prior to and after execution of
database-related application code, and Spring ensures that such queries run in the
scope of the same transaction as the application code. When used in conjunction with
an ORM tool, be sure to avoid false positives.
In addition, you may want to create your own custom, application-wide superclass with
instance variables and methods specific to your project.
See support classes for the TestContext framework.
Spring Testing Annotations
The Spring Framework provides the following set of Spring-specific annotations that
you can use in your unit and integration tests in conjunction with the TestContext
framework. Refer to the corresponding javadocs for further information, including
default attribute values, attribute aliases, and so on.
-
@ContextConfiguration
Defines class-level metadata that is used to determine how to load and configure an
ApplicationContext for integration tests. Specifically, @ContextConfiguration
declares the application context resource locations or the annotated classes
that will be used to load the context.
Resource locations are typically XML configuration files located in the classpath;
whereas, annotated classes are typically @Configuration classes. However, resource
locations can also refer to files in the file system, and annotated classes can be
component classes, etc.
@ContextConfiguration("/test-config.xml")
public class XmlApplicationContextTests {
}
@ContextConfiguration(classes = TestConfig.class)
public class ConfigClassApplicationContextTests {
}
As an alternative or in addition to declaring resource locations or annotated classes,
@ContextConfiguration may be used to declare ApplicationContextInitializer classes.
@ContextConfiguration(initializers = CustomContextIntializer.class)
public class ContextInitializerTests {
}
@ContextConfiguration may optionally be used to declare the ContextLoader strategy
as well. Note, however, that you typically do not need to explicitly configure the
loader since the default loader supports either resource locations or annotated
classes as well as initializers .
@ContextConfiguration(locations = "/test-context.xml", loader = CustomContextLoader.class)
public class CustomLoaderXmlApplicationContextTests {
}
![[Note]](images/note.png) | Note |
---|
@ContextConfiguration provides support for inheriting resource locations or
configuration classes as well as context initializers declared by superclasses by
default.
|
See the section called “Context management” and the @ContextConfiguration javadocs for
further details.
-
@WebAppConfiguration
A class-level annotation that is used to declare that the ApplicationContext loaded
for an integration test should be a WebApplicationContext . The mere presence of
@WebAppConfiguration on a test class ensures that a WebApplicationContext will be
loaded for the test, using the default value of "file:src/main/webapp" for the path to
the root of the web application (i.e., the resource base path). The resource base
path is used behind the scenes to create a MockServletContext which serves as the
ServletContext for the test’s WebApplicationContext .
@ContextConfiguration
@WebAppConfiguration
public class WebAppTests {
}
To override the default, specify a different base resource path via the implicit
value attribute. Both classpath: and file: resource prefixes are supported. If no
resource prefix is supplied the path is assumed to be a file system resource.
@ContextConfiguration
@WebAppConfiguration("classpath:test-web-resources")
public class WebAppTests {
}
Note that @WebAppConfiguration must be used in conjunction with
@ContextConfiguration , either within a single test class or within a test class
hierarchy. See the @WebAppConfiguration javadocs for further details.
-
@ContextHierarchy
A class-level annotation that is used to define a hierarchy of ApplicationContext s
for integration tests. @ContextHierarchy should be declared with a list of one or more
@ContextConfiguration instances, each of which defines a level in the context
hierarchy. The following examples demonstrate the use of @ContextHierarchy within a
single test class; however, @ContextHierarchy can also be used within a test class
hierarchy.
@ContextHierarchy({
@ContextConfiguration("/parent-config.xml"),
@ContextConfiguration("/child-config.xml")
})
public class ContextHierarchyTests {
}
@WebAppConfiguration
@ContextHierarchy({
@ContextConfiguration(classes = AppConfig.class),
@ContextConfiguration(classes = WebConfig.class)
})
public class WebIntegrationTests {
}
If you need to merge or override the configuration for a given level of the context
hierarchy within a test class hierarchy, you must explicitly name that level by
supplying the same value to the name attribute in @ContextConfiguration at each
corresponding level in the class hierarchy. See
the section called “Context hierarchies” and the @ContextHierarchy javadocs
for further examples.
-
@ActiveProfiles
A class-level annotation that is used to declare which bean definition profiles
should be active when loading an ApplicationContext for test classes.
@ContextConfiguration
@ActiveProfiles("dev")
public class DeveloperTests {
}
@ContextConfiguration
@ActiveProfiles({"dev", "integration"})
public class DeveloperIntegrationTests {
}
![[Note]](images/note.png) | Note |
---|
@ActiveProfiles provides support for inheriting active bean definition profiles
declared by superclasses by default. It is also possible to resolve active bean
definition profiles programmatically by implementing a custom
ActiveProfilesResolver
and registering it via the resolver attribute of @ActiveProfiles .
|
See the section called “Context configuration with environment profiles” and the @ActiveProfiles javadocs
for examples and further details.
-
@DirtiesContext
Indicates that the underlying Spring ApplicationContext has been dirtied during
the execution of a test (i.e., modified or corrupted in some manner — for example, by
changing the state of a singleton bean) and should be closed, regardless of whether the
test passed. When an application context is marked dirty, it is removed from the
testing framework’s cache and closed. As a consequence, the underlying Spring container
will be rebuilt for any subsequent test that requires a context with the same
configuration metadata.
@DirtiesContext can be used as both a class-level and method-level annotation within
the same test class. In such scenarios, the ApplicationContext is marked as dirty
after any such annotated method as well as after the entire class. If the ClassMode is
set to AFTER_EACH_TEST_METHOD , the context is marked dirty after each test method in
the class.
The following examples explain when the context would be dirtied for various
configuration scenarios:
-
After the current test class, when declared on a class with class mode set to
AFTER_CLASS (i.e., the default class mode).
@DirtiesContext
public class ContextDirtyingTests {
}
-
After each test method in the current test class, when declared on a class with class
mode set to AFTER_EACH_TEST_METHOD.
@DirtiesContext(classMode = ClassMode.AFTER_EACH_TEST_METHOD)
public class ContextDirtyingTests {
}
-
After the current test, when declared on a method.
@DirtiesContext
@Test
public void testProcessWhichDirtiesAppCtx() {
}
If @DirtiesContext is used in a test whose context is configured as part of a context
hierarchy via @ContextHierarchy , the hierarchyMode flag can be used to control how
the context cache is cleared. By default an exhaustive algorithm will be used that
clears the context cache including not only the current level but also all other context
hierarchies that share an ancestor context common to the current test; all
ApplicationContext s that reside in a sub-hierarchy of the common ancestor context
will be removed from the context cache and closed. If the exhaustive algorithm is
overkill for a particular use case, the simpler current level algorithm can be
specified instead, as seen below.
@ContextHierarchy({
@ContextConfiguration("/parent-config.xml"),
@ContextConfiguration("/child-config.xml")
})
public class BaseTests {
}
public class ExtendedTests extends BaseTests {
@Test
@DirtiesContext(hierarchyMode = HierarchyMode.CURRENT_LEVEL)
public void test() {
}
}
For further details regarding the EXHAUSTIVE and CURRENT_LEVEL algorithms see the
DirtiesContext.HierarchyMode javadocs.
-
@TestExecutionListeners
Defines class-level metadata for configuring which TestExecutionListener s should be
registered with the TestContextManager . Typically, @TestExecutionListeners is used
in conjunction with @ContextConfiguration .
@ContextConfiguration
@TestExecutionListeners({CustomTestExecutionListener.class, AnotherTestExecutionListener.class})
public class CustomTestExecutionListenerTests {
}
@TestExecutionListeners supports inherited listeners by default. See the javadocs
for an example and further details.
-
@TransactionConfiguration
Defines class-level metadata for configuring transactional tests. Specifically, the bean
name of the PlatformTransactionManager that should be used to drive transactions can
be explicitly specified if there are multiple beans of type PlatformTransactionManager
in the test’s ApplicationContext and if the bean name of the desired
PlatformTransactionManager is not "transactionManager". In addition, you can change
the defaultRollback flag to false . Typically, @TransactionConfiguration is used in
conjunction with @ContextConfiguration .
@ContextConfiguration
@TransactionConfiguration(transactionManager = "txMgr", defaultRollback = false)
public class CustomConfiguredTransactionalTests {
}
![[Note]](images/note.png) | Note |
---|
If the default conventions are sufficient for your test configuration, you can avoid
using @TransactionConfiguration altogether. In other words, if you have only one
transaction manger — or if you have multiple transaction mangers but the transaction
manager for tests is named "transactionManager" or specified via a
TransactionManagementConfigurer — and if you want transactions to roll back
automatically, then there is no need to annotate your test class with
@TransactionConfiguration .
|
-
@Rollback
Indicates whether the transaction for the annotated test method should be rolled
back after the test method has completed. If true , the transaction is rolled back;
otherwise, the transaction is committed. Use @Rollback to override the default
rollback flag configured at the class level.
@Rollback(false)
@Test
public void testProcessWithoutRollback() {
}
-
@BeforeTransaction
Indicates that the annotated public void method should be executed before a
transaction is started for test methods configured to run within a transaction via the
@Transactional annotation.
@BeforeTransaction
public void beforeTransaction() {
}
-
@AfterTransaction
Indicates that the annotated public void method should be executed after a
transaction has ended for test methods configured to run within a transaction via the
@Transactional annotation.
@AfterTransaction
public void afterTransaction() {
}
Standard Annotation Support
The following annotations are supported with standard semantics for all configurations
of the Spring TestContext Framework. Note that these annotations are not specific to
tests and can be used anywhere in the Spring Framework.
-
@Autowired
-
@Qualifier
-
@Resource (javax.annotation) if JSR-250 is present
-
@Inject (javax.inject) if JSR-330 is present
-
@Named (javax.inject) if JSR-330 is present
-
@PersistenceContext (javax.persistence) if JPA is present
-
@PersistenceUnit (javax.persistence) if JPA is present
-
@Required
-
@Transactional
![[Note]](images/note.png) | JSR-250 Lifecycle Annotations |
---|
In the Spring TestContext Framework @PostConstruct and @PreDestroy may be used with
standard semantics on any application components configured in the ApplicationContext ;
however, these lifecycle annotations have limited usage within an actual test class.
If a method within a test class is annotated with @PostConstruct , that method will be
executed before any before methods of the underlying test framework (e.g., methods
annotated with JUnit’s @Before ), and that will apply for every test method in the test
class. On the other hand, if a method within a test class is annotated with
@PreDestroy , that method will never be executed. Within a test class it is
therefore recommended to use test lifecycle callbacks from the underlying test framework
instead of @PostConstruct and @PreDestroy .
|
Spring JUnit Testing Annotations
The following annotations are only supported when used in conjunction with the
SpringJUnit4ClassRunner or the
JUnit support classes.
-
@IfProfileValue
Indicates that the annotated test is enabled for a specific testing environment. If the
configured ProfileValueSource returns a matching value for the provided name , the
test is enabled. This annotation can be applied to an entire class or to individual
methods. Class-level usage overrides method-level usage.
@IfProfileValue(name="java.vendor", value="Oracle Corporation")
@Test
public void testProcessWhichRunsOnlyOnOracleJvm() {
}
Alternatively, you can configure @IfProfileValue with a list of values (with OR
semantics) to achieve TestNG-like support for test groups in a JUnit environment.
Consider the following example:
@IfProfileValue(name="test-groups", values={"unit-tests", "integration-tests"})
@Test
public void testProcessWhichRunsForUnitOrIntegrationTestGroups() {
}
-
@ProfileValueSourceConfiguration
Class-level annotation that specifies what type of ProfileValueSource to use when
retrieving profile values configured through the @IfProfileValue annotation. If
@ProfileValueSourceConfiguration is not declared for a test,
SystemProfileValueSource is used by default.
@ProfileValueSourceConfiguration(CustomProfileValueSource.class)
public class CustomProfileValueSourceTests {
}
-
@Timed
Indicates that the annotated test method must finish execution in a specified time
period (in milliseconds). If the text execution time exceeds the specified time period,
the test fails.
The time period includes execution of the test method itself, any repetitions of the
test (see @Repeat ), as well as any set up or tear down of the test fixture.
@Timed(millis=1000)
public void testProcessWithOneSecondTimeout() {
}
Spring’s @Timed annotation has different semantics than JUnit’s @Test(timeout=...)
support. Specifically, due to the manner in which JUnit handles test execution timeouts
(that is, by executing the test method in a separate Thread ), @Test(timeout=...)
applies to each iteration in the case of repetitions and preemptively fails the test
if the test takes too long. Spring’s @Timed , on the other hand, times the total
test execution time (including all repetitions) and does not preemptively fail the test
but rather waits for the test to complete before failing.
-
@Repeat
Indicates that the annotated test method must be executed repeatedly. The number of
times that the test method is to be executed is specified in the annotation.
The scope of execution to be repeated includes execution of the test method itself as
well as any set up or tear down of the test fixture.
@Repeat(10)
@Test
public void testProcessRepeatedly() {
}
Meta-Annotation Support for Testing
As of Spring Framework 4.0, it is now possible to use test-related annotations
as meta-annotations in order to create custom
composed annotations and reduce configuration duplication across a test suite.
Each of the following may be used as meta-annotations in conjunction with the
TestContext framework.
-
@ContextConfiguration
-
@ContextHierarchy
-
@ActiveProfiles
-
@DirtiesContext
-
@WebAppConfiguration
-
@TestExecutionListeners
-
@Transactional
-
@BeforeTransaction
-
@AfterTransaction
-
@TransactionConfiguration
-
@Rollback
-
@Repeat
-
@Timed
-
@IfProfileValue
-
@ProfileValueSourceConfiguration
For example, if we discover that we are repeating the following configuration
across our JUnit-based test suite…
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"/app-config.xml", "/test-data-access-config.xml"})
@ActiveProfiles("dev")
@Transactional
public class OrderRepositoryTests { }
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"/app-config.xml", "/test-data-access-config.xml"})
@ActiveProfiles("dev")
@Transactional
public class UserRepositoryTests { }
We can reduce the above duplication by introducing a custom composed annotation
that centralizes the common test configuration like this:
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@ContextConfiguration({"/app-config.xml", "/test-data-access-config.xml"})
@ActiveProfiles("dev")
@Transactional
public @interface TransactionalDevTest { }
Then we can use our custom @TransactionalDevTest annotation to simplify the
configuration of individual test classes as follows:
@RunWith(SpringJUnit4ClassRunner.class)
@TransactionalDevTest
public class OrderRepositoryTests { }
@RunWith(SpringJUnit4ClassRunner.class)
@TransactionalDevTest
public class UserRepositoryTests { }
10.3.5 Spring TestContext Framework
The Spring TestContext Framework (located in the
org.springframework.test.context package) provides generic, annotation-driven unit and
integration testing support that is agnostic of the testing framework in use. The
TestContext framework also places a great deal of importance on convention over
configuration with reasonable defaults that can be overridden through annotation-based
configuration.
In addition to generic testing infrastructure, the TestContext framework provides
explicit support for JUnit and TestNG in the form of abstract support classes. For
JUnit, Spring also provides a custom JUnit Runner that allows one to write so-called
POJO test classes. POJO test classes are not required to extend a particular class
hierarchy.
The following section provides an overview of the internals of the TestContext
framework. If you are only interested in using the framework and not necessarily
interested in extending it with your own custom listeners or custom loaders, feel free
to go directly to the configuration (context management,
dependency injection, transaction
management), support classes, and
annotation support sections.
The core of the framework consists of the TestContext and TestContextManager classes
and the TestExecutionListener , ContextLoader , and SmartContextLoader interfaces. A
TestContextManager is created on a per-test basis (e.g., for the execution of a single
test method in JUnit). The TestContextManager in turn manages a TestContext that
holds the context of the current test. The TestContextManager also updates the state
of the TestContext as the test progresses and delegates to TestExecutionListener s,
which instrument the actual test execution by providing dependency injection, managing
transactions, and so on. A ContextLoader (or SmartContextLoader ) is responsible for
loading an ApplicationContext for a given test class. Consult the javadocs and the
Spring test suite for further information and examples of various implementations.
-
TestContext : Encapsulates the context in which a test is executed, agnostic of the
actual testing framework in use, and provides context management and caching support
for the test instance for which it is responsible. The TestContext also delegates to
a ContextLoader (or SmartContextLoader ) to load an ApplicationContext if
requested.
-
TestContextManager : The main entry point into the Spring TestContext Framework,
which manages a single TestContext and signals events to all registered
TestExecutionListener s at well-defined test execution points:
-
prior to any before class methods of a particular testing framework
-
test instance preparation
-
prior to any before methods of a particular testing framework
-
after any after methods of a particular testing framework
-
after any after class methods of a particular testing framework
-
TestExecutionListener : Defines a listener API for reacting to test execution
events published by the TestContextManager with which the listener is registered.
Spring provides four TestExecutionListener implementations that are configured by
default: ServletTestExecutionListener , DependencyInjectionTestExecutionListener ,
DirtiesContextTestExecutionListener , and TransactionalTestExecutionListener .
Respectively, they support Servlet API mocks for a WebApplicationContext , dependency
injection of the test instance, handling of the @DirtiesContext annotation, and
transactional test execution with default rollback semantics.
-
ContextLoader : Strategy interface introduced in Spring 2.5 for loading an
ApplicationContext for an integration test managed by the Spring TestContext
Framework.
As of Spring 3.1, implement SmartContextLoader instead of this interface in order to
provide support for annotated classes and active bean definition profiles.
-
SmartContextLoader : Extension of the ContextLoader interface introduced in Spring
3.1.
The SmartContextLoader SPI supersedes the ContextLoader SPI that was introduced in
Spring 2.5. Specifically, a SmartContextLoader can choose to process resource
locations , annotated classes , or context initializers . Furthermore, a
SmartContextLoader can set active bean definition profiles in the context that it
loads.
Spring provides the following implementations:
-
DelegatingSmartContextLoader : one of two default loaders which delegates internally
to an AnnotationConfigContextLoader or a GenericXmlContextLoader depending either on
the configuration declared for the test class or on the presence of default locations or
default configuration classes.
-
WebDelegatingSmartContextLoader : one of two default loaders which delegates
internally to an AnnotationConfigWebContextLoader or a GenericXmlWebContextLoader
depending either on the configuration declared for the test class or on the presence of
default locations or default configuration classes. A web ContextLoader will only be
used if @WebAppConfiguration is present on the test class.
-
AnnotationConfigContextLoader : loads a standard ApplicationContext from
annotated classes.
-
AnnotationConfigWebContextLoader : loads a WebApplicationContext from annotated
classes.
-
GenericXmlContextLoader : loads a standard ApplicationContext from XML resource
locations.
-
GenericXmlWebContextLoader : loads a WebApplicationContext from XML resource
locations.
-
GenericPropertiesContextLoader : loads a standard ApplicationContext from Java
Properties files.
The following sections explain how to configure the TestContext framework through
annotations and provide working examples of how to write unit and integration tests with
the framework.
Each TestContext provides context management and caching support for the test instance
it is responsible for. Test instances do not automatically receive access to the
configured ApplicationContext . However, if a test class implements the
ApplicationContextAware interface, a reference to the ApplicationContext is supplied
to the test instance. Note that AbstractJUnit4SpringContextTests and
AbstractTestNGSpringContextTests implement ApplicationContextAware and therefore
provide access to the ApplicationContext automatically.
![[Tip]](images/tip.png) | @Autowired ApplicationContext |
---|
As an alternative to implementing the ApplicationContextAware interface, you can
inject the application context for your test class through the @Autowired annotation
on either a field or setter method. For example:
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
public class MyTest {
@Autowired
private ApplicationContext applicationContext;
}
Similarly, if your test is configured to load a WebApplicationContext , you can inject
the web application context into your test as follows:
@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration
public class MyWebAppTest {
@Autowired
private WebApplicationContext wac;
}
Dependency injection via @Autowired is provided by the
DependencyInjectionTestExecutionListener which is configured by default (see
the section called “Dependency injection of test fixtures”).
|
Test classes that use the TestContext framework do not need to extend any particular
class or implement a specific interface to configure their application context. Instead,
configuration is achieved simply by declaring the @ContextConfiguration annotation at
the class level. If your test class does not explicitly declare application context
resource locations or annotated classes , the configured ContextLoader determines
how to load a context from a default location or default configuration classes. In
addition to context resource locations and annotated classes , an application context
can also be configured via application context initializers .
The following sections explain how to configure an ApplicationContext via XML
configuration files, annotated classes (typically @Configuration classes), or context
initializers using Spring’s @ContextConfiguration annotation. Alternatively, you can
implement and configure your own custom SmartContextLoader for advanced use cases.
Context configuration with XML resources
To load an ApplicationContext for your tests using XML configuration files, annotate
your test class with @ContextConfiguration and configure the locations attribute
with an array that contains the resource locations of XML configuration metadata. A
plain or relative path — for example "context.xml" — will be treated as a classpath
resource that is relative to the package in which the test class is defined. A path
starting with a slash is treated as an absolute classpath location, for example
"/org/example/config.xml" . A path which represents a resource URL (i.e., a path
prefixed with classpath: , file: , http: , etc.) will be used as is.
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"/app-config.xml", "/test-config.xml"})
public class MyTest {
}
@ContextConfiguration supports an alias for the locations attribute through the
standard Java value attribute. Thus, if you do not need to declare additional
attributes in @ContextConfiguration , you can omit the declaration of the locations
attribute name and declare the resource locations by using the shorthand format
demonstrated in the following example.
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"/app-config.xml", "/test-config.xml"})
public class MyTest {
}
If you omit both the locations and value attributes from the @ContextConfiguration
annotation, the TestContext framework will attempt to detect a default XML resource
location. Specifically, GenericXmlContextLoader detects a default location based on
the name of the test class. If your class is named com.example.MyTest ,
GenericXmlContextLoader loads your application context from
"classpath:/com/example/MyTest-context.xml" .
package com.example;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
public class MyTest {
}
Context configuration with annotated classes
To load an ApplicationContext for your tests using annotated classes (see
Section 4.12, “Java-based container configuration”), annotate your test class with @ContextConfiguration and configure the
classes attribute with an array that contains references to annotated classes.
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {AppConfig.class, TestConfig.class})
public class MyTest {
}
![[Tip]](images/tip.png) | Annotated Classes |
---|
The term annotated class can refer to any of the following.
-
A class annotated with
@Configuration
-
A component (i.e., a class annotated with
@Component , @Service , @Repository , etc.)
-
A JSR-330 compliant class that is annotated with
javax.inject annotations
-
Any other class that contains
@Bean -methods
Consult the javadocs of @Configuration and @Bean for further information regarding
the configuration and semantics of annotated classes, paying special attention to
the discussion of `@Bean` Lite Mode.
|
If you omit the classes attribute from the @ContextConfiguration annotation, the
TestContext framework will attempt to detect the presence of default configuration
classes. Specifically, AnnotationConfigContextLoader will detect all static inner
classes of the test class that meet the requirements for configuration class
implementations as specified in the @Configuration javadocs. In the following
example, the OrderServiceTest class declares a static inner configuration class named
Config that will be automatically used to load the ApplicationContext for the test
class. Note that the name of the configuration class is arbitrary. In addition, a test
class can contain more than one static inner configuration class if desired.
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
public class OrderServiceTest {
@Configuration
static class Config {
@Bean
public OrderService orderService() {
OrderService orderService = new OrderServiceImpl();
return orderService;
}
}
@Autowired
private OrderService orderService;
@Test
public void testOrderService() {
}
}
Mixing XML resources and annotated classes
It may sometimes be desirable to mix XML resources and annotated classes (i.e.,
typically @Configuration classes) to configure an ApplicationContext for your tests.
For example, if you use XML configuration in production, you may decide that you want to
use @Configuration classes to configure specific Spring-managed components for your
tests, or vice versa.
Furthermore, some third-party frameworks (like Spring Boot) provide first-class
support for loading an ApplicationContext from different types of resources
simultaneously (e.g., XML configuration files and @Configuration classes). The Spring
Framework historically has not supported this for standard deployments. Consequently,
each of the SmartContextLoader implementations that the Spring Framework delivers in
the spring-test module supports only one resource type per test context;
however, this does not mean that you cannot use both. Third-party frameworks may
choose to support the declaration of both locations and classes via
@ContextConfiguration , and with the standard testing support in the TestContext
framework, you have the following options.
If you want to use XML and @Configuration classes to configure your tests, you
will have to pick one as the entry point, and that one will have to include or
import the other. For example, in XML you can include @Configuration classes via
component scanning or define them as normal Spring beans in XML; whereas, in a
@Configuration class you can use @ImportResource to import XML configuration files.
Note that this behavior is semantically equivalent to how you configure your application
in production: in production configuration you will define either a set of XML resource
locations or a set of @Configuration classes that your production ApplicationContext
will be loaded from, but you still have the freedom to include or import the other type
of configuration.
Context configuration with context initializers
To configure an ApplicationContext for your tests using context initializers, annotate
your test class with @ContextConfiguration and configure the initializers attribute
with an array that contains references to classes that implement
ApplicationContextInitializer . The declared context initializers will then be used to
initialize the ConfigurableApplicationContext that is loaded for your tests. Note that
the concrete ConfigurableApplicationContext type supported by each declared
initializer must be compatible with the type of ApplicationContext created by the
SmartContextLoader in use (i.e., typically a GenericApplicationContext ).
Furthermore, the order in which the initializers are invoked depends on whether they
implement Spring’s Ordered interface or are annotated with Spring’s @Order
annotation.
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(
classes = TestConfig.class,
initializers = TestAppCtxInitializer.class)
public class MyTest {
}
It is also possible to omit the declaration of XML configuration files or annotated
classes in @ContextConfiguration entirely and instead declare only
ApplicationContextInitializer classes which are then responsible for registering beans
in the context — for example, by programmatically loading bean definitions from XML
files or configuration classes.
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(initializers = EntireAppInitializer.class)
public class MyTest {
}
Context configuration inheritance
@ContextConfiguration supports boolean inheritLocations and inheritInitializers
attributes that denote whether resource locations or annotated classes and context
initializers declared by superclasses should be inherited. The default value for
both flags is true . This means that a test class inherits the resource locations or
annotated classes as well as the context initializers declared by any superclasses.
Specifically, the resource locations or annotated classes for a test class are appended
to the list of resource locations or annotated classes declared by superclasses.
Similarly, the initializers for a given test class will be added to the set of
initializers defined by test superclasses. Thus, subclasses have the option
of extending the resource locations, annotated classes, or context initializers.
If @ContextConfiguration 's inheritLocations or inheritInitializers attribute is
set to false , the resource locations or annotated classes and the context
initializers, respectively, for the test class shadow and effectively replace the
configuration defined by superclasses.
In the following example that uses XML resource locations, the ApplicationContext for
ExtendedTest will be loaded from "base-config.xml" and
"extended-config.xml", in that order. Beans defined in "extended-config.xml" may
therefore override (i.e., replace) those defined in "base-config.xml".
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/base-config.xml")
public class BaseTest {
}
@ContextConfiguration("/extended-config.xml")
public class ExtendedTest extends BaseTest {
}
Similarly, in the following example that uses annotated classes, the
ApplicationContext for ExtendedTest will be loaded from the BaseConfig and
ExtendedConfig classes, in that order. Beans defined in ExtendedConfig may therefore
override (i.e., replace) those defined in BaseConfig .
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = BaseConfig.class)
public class BaseTest {
}
@ContextConfiguration(classes = ExtendedConfig.class)
public class ExtendedTest extends BaseTest {
}
In the following example that uses context initializers, the ApplicationContext for
ExtendedTest will be initialized using BaseInitializer and
ExtendedInitializer . Note, however, that the order in which the initializers are
invoked depends on whether they implement Spring’s Ordered interface or are annotated
with Spring’s @Order annotation.
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(initializers = BaseInitializer.class)
public class BaseTest {
}
@ContextConfiguration(initializers = ExtendedInitializer.class)
public class ExtendedTest extends BaseTest {
}
Context configuration with environment profiles
Spring 3.1 introduced first-class support in the framework for the notion of
environments and profiles (a.k.a., bean definition profiles), and integration tests
can be configured to activate particular bean definition profiles for various testing
scenarios. This is achieved by annotating a test class with the @ActiveProfiles
annotation and supplying a list of profiles that should be activated when loading the
ApplicationContext for the test.
![[Note]](images/note.png) | Note |
---|
@ActiveProfiles may be used with any implementation of the new SmartContextLoader
SPI, but @ActiveProfiles is not supported with implementations of the older
ContextLoader SPI.
|
Let’s take a look at some examples with XML configuration and @Configuration classes.
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:jdbc="http://www.springframework.org/schema/jdbc"
xmlns:jee="http://www.springframework.org/schema/jee"
xsi:schemaLocation="...">
<bean id="transferService"
class="com.bank.service.internal.DefaultTransferService">
<constructor-arg ref="accountRepository"/>
<constructor-arg ref="feePolicy"/>
</bean>
<bean id="accountRepository"
class="com.bank.repository.internal.JdbcAccountRepository">
<constructor-arg ref="dataSource"/>
</bean>
<bean id="feePolicy"
class="com.bank.service.internal.ZeroFeePolicy"/>
<beans profile="dev">
<jdbc:embedded-database id="dataSource">
<jdbc:script
location="classpath:com/bank/config/sql/schema.sql"/>
<jdbc:script
location="classpath:com/bank/config/sql/test-data.sql"/>
</jdbc:embedded-database>
</beans>
<beans profile="production">
<jee:jndi-lookup id="dataSource" jndi-name="java:comp/env/jdbc/datasource"/>
</beans>
<beans profile="default">
<jdbc:embedded-database id="dataSource">
<jdbc:script
location="classpath:com/bank/config/sql/schema.sql"/>
</jdbc:embedded-database>
</beans>
</beans>
package com.bank.service;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/app-config.xml")
@ActiveProfiles("dev")
public class TransferServiceTest {
@Autowired
private TransferService transferService;
@Test
public void testTransferService() {
}
}
When TransferServiceTest is run, its ApplicationContext will be loaded from the
app-config.xml configuration file in the root of the classpath. If you inspect
app-config.xml you’ll notice that the accountRepository bean has a dependency on a
dataSource bean; however, dataSource is not defined as a top-level bean. Instead,
dataSource is defined three times: in the production profile, the
dev profile, and the default profile.
By annotating TransferServiceTest with @ActiveProfiles("dev") we instruct the Spring
TestContext Framework to load the ApplicationContext with the active profiles set to
{"dev"} . As a result, an embedded database will be created and populated with test data,
and the accountRepository bean will be wired with a reference to the development
DataSource . And that’s likely what we want in an integration test.
It is sometimes useful to assign beans to a default profile. Beans within the default profile
are only included when no other profile is specifically activated. This can be used to define
fallback beans to be used in the application’s default state. For example, you may
explicitly provide a data source for dev and production profiles, but define an in-memory
data source as a default when neither of these is active.
The following code listings demonstrate how to implement the same configuration and
integration test but using @Configuration classes instead of XML.
@Configuration
@Profile("dev")
public class StandaloneDataConfig {
@Bean
public DataSource dataSource() {
return new EmbeddedDatabaseBuilder()
.setType(EmbeddedDatabaseType.HSQL)
.addScript("classpath:com/bank/config/sql/schema.sql")
.addScript("classpath:com/bank/config/sql/test-data.sql")
.build();
}
}
@Configuration
@Profile("production")
public class JndiDataConfig {
@Bean
public DataSource dataSource() throws Exception {
Context ctx = new InitialContext();
return (DataSource) ctx.lookup("java:comp/env/jdbc/datasource");
}
}
@Configuration
@Profile("default")
public class DefaultDataConfig {
@Bean
public DataSource dataSource() {
return new EmbeddedDatabaseBuilder()
.setType(EmbeddedDatabaseType.HSQL)
.addScript("classpath:com/bank/config/sql/schema.sql")
.build();
}
}
@Configuration
public class TransferServiceConfig {
@Autowired DataSource dataSource;
@Bean
public TransferService transferService() {
return new DefaultTransferService(accountRepository(), feePolicy());
}
@Bean
public AccountRepository accountRepository() {
return new JdbcAccountRepository(dataSource);
}
@Bean
public FeePolicy feePolicy() {
return new ZeroFeePolicy();
}
}
package com.bank.service;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {
TransferServiceConfig.class,
StandaloneDataConfig.class,
JndiDataConfig.class,
DefaultDataConfig.class})
@ActiveProfiles("dev")
public class TransferServiceTest {
@Autowired
private TransferService transferService;
@Test
public void testTransferService() {
}
}
In this variation, we have split the XML configuration into four independent
@Configuration classes:
-
TransferServiceConfig : acquires a dataSource via dependency injection using
@Autowired
-
StandaloneDataConfig : defines a dataSource for an embedded database suitable for
developer tests
-
JndiDataConfig : defines a dataSource that is retrieved from JNDI in a production
environment
-
DefaultDataConfig : defines a dataSource for a default embedded database in case
no profile is active
As with the XML-based configuration example, we still annotate TransferServiceTest
with @ActiveProfiles("dev") , but this time we specify all four configuration classes
via the @ContextConfiguration annotation. The body of the test class itself remains
completely unchanged.
It is often the case that a single set of profiles is used across multiple test classes
within a given project. Thus, to avoid duplicate declarations of the @ActiveProfiles
annotation it is possible to declare @ActiveProfiles once on a base class, and
subclasses will automatically inherit the @ActiveProfiles configuration from the base
class. In the following example, the declaration of @ActiveProfiles (as well as other
annotations) has been moved to an abstract superclass, AbstractIntegrationTest .
package com.bank.service;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {
TransferServiceConfig.class,
StandaloneDataConfig.class,
JndiDataConfig.class,
DefaultDataConfig.class})
@ActiveProfiles("dev")
public abstract class AbstractIntegrationTest {
}
package com.bank.service;
public class TransferServiceTest extends AbstractIntegrationTest {
@Autowired
private TransferService transferService;
@Test
public void testTransferService() {
}
}
@ActiveProfiles also supports an inheritProfiles attribute that can be used to
disable the inheritance of active profiles.
package com.bank.service;
@ActiveProfiles(profiles = "production", inheritProfiles = false)
public class ProductionTransferServiceTest extends AbstractIntegrationTest {
}
Furthermore, it is sometimes necessary to resolve active profiles for tests
programmatically instead of declaratively — for example, based on:
-
the current operating system
-
whether tests are being executed on a continuous integration build server
-
the presence of certain environment variables
-
the presence of custom class-level annotations
-
etc.
To resolve active bean definition profiles programmatically, simply implement a custom
ActiveProfilesResolver and register it via the resolver attribute of
@ActiveProfiles . The following example demonstrates how to implement and register a
custom OperatingSystemActiveProfilesResolver . For further information, refer to the
corresponding javadocs.
package com.bank.service;
@ActiveProfiles(
resolver = OperatingSystemActiveProfilesResolver.class,
inheritProfiles = false)
public class TransferServiceTest extends AbstractIntegrationTest {
}
package com.bank.service.test;
public class OperatingSystemActiveProfilesResolver implements ActiveProfilesResolver {
@Override
String[] resolve(Class<?> testClass) {
String profile = ...;
return new String[] {profile};
}
}
Loading a WebApplicationContext
Spring 3.2 introduced support for loading a WebApplicationContext in integration
tests. To instruct the TestContext framework to load a WebApplicationContext instead
of a standard ApplicationContext , simply annotate the respective test class with
@WebAppConfiguration .
The presence of @WebAppConfiguration on your test class instructs the TestContext
framework (TCF) that a WebApplicationContext (WAC) should be loaded for your
integration tests. In the background the TCF makes sure that a MockServletContext is
created and supplied to your test’s WAC. By default the base resource path for your
MockServletContext will be set to "src/main/webapp". This is interpreted as a path
relative to the root of your JVM (i.e., normally the path to your project). If you’re
familiar with the directory structure of a web application in a Maven project, you’ll
know that "src/main/webapp" is the default location for the root of your WAR. If you
need to override this default, simply provide an alternate path to the
@WebAppConfiguration annotation (e.g., @WebAppConfiguration("src/test/webapp") ). If
you wish to reference a base resource path from the classpath instead of the file
system, just use Spring’s classpath: prefix.
Please note that Spring’s testing support for WebApplicationContexts is on par with
its support for standard ApplicationContexts . When testing with a
WebApplicationContext you are free to declare either XML configuration files or
@Configuration classes via @ContextConfiguration . You are of course also free to use
any other test annotations such as @TestExecutionListeners ,
@TransactionConfiguration , @ActiveProfiles , etc.
The following examples demonstrate some of the various configuration options for loading
a WebApplicationContext .
Conventions.
@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration
public class WacTests {
}
The above example demonstrates the TestContext framework’s support for convention over
configuration. If you annotate a test class with @WebAppConfiguration without
specifying a resource base path, the resource path will effectively default
to "file:src/main/webapp". Similarly, if you declare @ContextConfiguration without
specifying resource locations , annotated classes , or context initializers , Spring
will attempt to detect the presence of your configuration using conventions
(i.e., "WacTests-context.xml" in the same package as the WacTests class or static
nested @Configuration classes).
Default resource semantics.
@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration("webapp")
@ContextConfiguration("/spring/test-servlet-config.xml")
public class WacTests {
}
This example demonstrates how to explicitly declare a resource base path with
@WebAppConfiguration and an XML resource location with @ContextConfiguration . The
important thing to note here is the different semantics for paths with these two
annotations. By default, @WebAppConfiguration resource paths are file system based;
whereas, @ContextConfiguration resource locations are classpath based.
Explicit resource semantics.
@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration("classpath:test-web-resources")
@ContextConfiguration("file:src/main/webapp/WEB-INF/servlet-config.xml")
public class WacTests {
}
In this third example, we see that we can override the default resource semantics for
both annotations by specifying a Spring resource prefix. Contrast the comments in this
example with the previous example.
To provide comprehensive web testing support, Spring 3.2 introduced a
ServletTestExecutionListener that is enabled by default. When testing against a
WebApplicationContext this TestExecutionListener sets
up default thread-local state via Spring Web’s RequestContextHolder before each test
method and creates a MockHttpServletRequest , MockHttpServletResponse , and
ServletWebRequest based on the base resource path configured via
@WebAppConfiguration . ServletTestExecutionListener also ensures that the
MockHttpServletResponse and ServletWebRequest can be injected into the test
instance, and once the test is complete it cleans up thread-local state.
Once you have a WebApplicationContext loaded for your test you might find that you
need to interact with the web mocks — for example, to set up your test fixture or to
perform assertions after invoking your web component. The following example demonstrates
which mocks can be autowired into your test instance. Note that the
WebApplicationContext and MockServletContext are both cached across the test suite;
whereas, the other mocks are managed per test method by the
ServletTestExecutionListener .
Injecting mocks.
@WebAppConfiguration
@ContextConfiguration
public class WacTests {
@Autowired
WebApplicationContext wac;
@Autowired
MockServletContext servletContext;
@Autowired
MockHttpSession session;
@Autowired
MockHttpServletRequest request;
@Autowired
MockHttpServletResponse response;
@Autowired
ServletWebRequest webRequest;
}
Once the TestContext framework loads an ApplicationContext (or
WebApplicationContext ) for a test, that context will be cached and reused for all
subsequent tests that declare the same unique context configuration within the same test
suite. To understand how caching works, it is important to understand what is meant by
unique and test suite.
An ApplicationContext can be uniquely identified by the combination of
configuration parameters that are used to load it. Consequently, the unique combination
of configuration parameters are used to generate a key under which the context is
cached. The TestContext framework uses the following configuration parameters to build
the context cache key:
-
locations (from @ContextConfiguration)
-
classes (from @ContextConfiguration)
-
contextInitializerClasses (from @ContextConfiguration)
-
contextLoader (from @ContextConfiguration)
-
activeProfiles (from @ActiveProfiles)
-
resourceBasePath (from @WebAppConfiguration)
For example, if TestClassA specifies {"app-config.xml", "test-config.xml"} for the
locations (or value ) attribute of @ContextConfiguration , the TestContext framework
will load the corresponding ApplicationContext and store it in a static context
cache under a key that is based solely on those locations. So if TestClassB also
defines {"app-config.xml", "test-config.xml"} for its locations (either explicitly or
implicitly through inheritance) but does not define @WebAppConfiguration , a different
ContextLoader , different active profiles, or different context initializers, then the
same ApplicationContext will be shared by both test classes. This means that the setup
cost for loading an application context is incurred only once (per test suite), and
subsequent test execution is much faster.
![[Note]](images/note.png) | Test suites and forked processes |
---|
The Spring TestContext framework stores application contexts in a static cache. This
means that the context is literally stored in a static variable. In other words, if
tests execute in separate processes the static cache will be cleared between each test
execution, and this will effectively disable the caching mechanism.
To benefit from the caching mechanism, all tests must run within the same process or
test suite. This can be achieved by executing all tests as a group within an IDE.
Similarly, when executing tests with a build framework such as Ant, Maven, or Gradle it
is important to make sure that the build framework does not fork between tests. For
example, if the
forkMode
for the Maven Surefire plug-in is set to always or pertest , the TestContext
framework will not be able to cache application contexts between test classes and the
build process will run significantly slower as a result.
|
Since having a large number of application contexts loaded within a given test suite can
cause the suite to take an unnecessarily long time to execute, it is often beneficial to
know exactly how many contexts have been loaded and cached. To view the statistics for
the underlying context cache, simply set the log level for the
org.springframework.test.context.cache logging category to DEBUG .
In the unlikely case that a test corrupts the application context and requires reloading — for example, by modifying a bean definition or the state of an application object — you can annotate your test class or test method with @DirtiesContext (see the
discussion of @DirtiesContext in the section called “Spring Testing Annotations”). This
instructs Spring to remove the context from the cache and rebuild the application
context before executing the next test. Note that support for the @DirtiesContext
annotation is provided by the DirtiesContextTestExecutionListener which is enabled by
default.
When writing integration tests that rely on a loaded Spring ApplicationContext , it is
often sufficient to test against a single context; however, there are times when it is
beneficial or even necessary to test against a hierarchy of ApplicationContext s. For
example, if you are developing a Spring MVC web application you will typically have a
root WebApplicationContext loaded via Spring’s ContextLoaderListener and a child
WebApplicationContext loaded via Spring’s DispatcherServlet . This results in a
parent-child context hierarchy where shared components and infrastructure configuration
are declared in the root context and consumed in the child context by web-specific
components. Another use case can be found in Spring Batch applications where you often
have a parent context that provides configuration for shared batch infrastructure and a
child context for the configuration of a specific batch job.
As of Spring Framework 3.2.2, it is possible to write integration tests that use context
hierarchies by declaring context configuration via the @ContextHierarchy annotation,
either on an individual test class or within a test class hierarchy. If a context
hierarchy is declared on multiple classes within a test class hierarchy it is also
possible to merge or override the context configuration for a specific, named level in
the context hierarchy. When merging configuration for a given level in the hierarchy the
configuration resource type (i.e., XML configuration files or annotated classes) must be
consistent; otherwise, it is perfectly acceptable to have different levels in a context
hierarchy configured using different resource types.
The following JUnit-based examples demonstrate common configuration scenarios for
integration tests that require the use of context hierarchies.
ControllerIntegrationTests represents a typical integration testing scenario for a
Spring MVC web application by declaring a context hierarchy consisting of two levels,
one for the root WebApplicationContext (loaded using the TestAppConfig
@Configuration class) and one for the dispatcher servlet WebApplicationContext
(loaded using the WebConfig @Configuration class). The WebApplicationContext that
is autowired into the test instance is the one for the child context (i.e., the
lowest context in the hierarchy).
@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextHierarchy({
@ContextConfiguration(classes = TestAppConfig.class),
@ContextConfiguration(classes = WebConfig.class)
})
public class ControllerIntegrationTests {
@Autowired
private WebApplicationContext wac;
}
The following test classes define a context hierarchy within a test class hierarchy.
AbstractWebTests declares the configuration for a root WebApplicationContext in a
Spring-powered web application. Note, however, that AbstractWebTests does not declare
@ContextHierarchy ; consequently, subclasses of AbstractWebTests can optionally
participate in a context hierarchy or simply follow the standard semantics for
@ContextConfiguration . SoapWebServiceTests and RestWebServiceTests both extend
AbstractWebTests and define a context hierarchy via @ContextHierarchy . The result is
that three application contexts will be loaded (one for each declaration of
@ContextConfiguration ), and the application context loaded based on the configuration
in AbstractWebTests will be set as the parent context for each of the contexts loaded
for the concrete subclasses.
@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration("file:src/main/webapp/WEB-INF/applicationContext.xml")
public abstract class AbstractWebTests {}
@ContextHierarchy(@ContextConfiguration("/spring/soap-ws-config.xml")
public class SoapWebServiceTests extends AbstractWebTests {}
@ContextHierarchy(@ContextConfiguration("/spring/rest-ws-config.xml")
public class RestWebServiceTests extends AbstractWebTests {}
The following classes demonstrate the use of named hierarchy levels in order to
merge the configuration for specific levels in a context hierarchy. BaseTests
defines two levels in the hierarchy, parent and child . ExtendedTests extends
BaseTests and instructs the Spring TestContext Framework to merge the context
configuration for the child hierarchy level, simply by ensuring that the names
declared via ContextConfiguration 's name attribute are both "child" . The result is
that three application contexts will be loaded: one for "/app-config.xml" , one for
"/user-config.xml" , and one for {"/user-config.xml", "/order-config.xml"} . As with
the previous example, the application context loaded from "/app-config.xml" will be
set as the parent context for the contexts loaded from "/user-config.xml" and
{"/user-config.xml", "/order-config.xml"} .
@RunWith(SpringJUnit4ClassRunner.class)
@ContextHierarchy({
@ContextConfiguration(name = "parent", locations = "/app-config.xml"),
@ContextConfiguration(name = "child", locations = "/user-config.xml")
})
public class BaseTests {}
@ContextHierarchy(
@ContextConfiguration(name = "child", locations = "/order-config.xml")
)
public class ExtendedTests extends BaseTests {}
In contrast to the previous example, this example demonstrates how to override the
configuration for a given named level in a context hierarchy by setting
ContextConfiguration 's inheritLocations flag to false . Consequently, the
application context for ExtendedTests will be loaded only from
"/test-user-config.xml" and will have its parent set to the context loaded from
"/app-config.xml" .
@RunWith(SpringJUnit4ClassRunner.class)
@ContextHierarchy({
@ContextConfiguration(name = "parent", locations = "/app-config.xml"),
@ContextConfiguration(name = "child", locations = "/user-config.xml")
})
public class BaseTests {}
@ContextHierarchy(
@ContextConfiguration(
name = "child",
locations = "/test-user-config.xml",
inheritLocations = false
))
public class ExtendedTests extends BaseTests {}
![[Note]](images/note.png) | Dirtying a context within a context hierarchy |
---|
If @DirtiesContext is used in a test whose context is configured as part of a context
hierarchy, the hierarchyMode flag can be used to control how the context cache is
cleared. For further details consult the discussion of @DirtiesContext in
the section called “Spring Testing Annotations” and the @DirtiesContext javadocs.
|
Dependency injection of test fixtures
When you use the DependencyInjectionTestExecutionListener — which is configured by
default — the dependencies of your test instances are injected from beans in the
application context that you configured with @ContextConfiguration . You may use setter
injection, field injection, or both, depending on which annotations you choose and
whether you place them on setter methods or fields. For consistency with the annotation
support introduced in Spring 2.5 and 3.0, you can use Spring’s @Autowired annotation
or the @Inject annotation from JSR 300.
![[Tip]](images/tip.png) | Tip |
---|
The TestContext framework does not instrument the manner in which a test instance is
instantiated. Thus the use of @Autowired or @Inject for constructors has no effect
for test classes.
|
Because @Autowired is used to perform autowiring by type, if you have multiple bean definitions of the same type, you cannot rely on this
approach for those particular beans. In that case, you can use @Autowired in
conjunction with @Qualifier . As of Spring 3.0 you may also choose to use @Inject in
conjunction with @Named . Alternatively, if your test class has access to its
ApplicationContext , you can perform an explicit lookup by using (for example) a call
to applicationContext.getBean("titleRepository") .
If you do not want dependency injection applied to your test instances, simply do not
annotate fields or setter methods with @Autowired or @Inject . Alternatively, you can
disable dependency injection altogether by explicitly configuring your class with
@TestExecutionListeners and omitting DependencyInjectionTestExecutionListener.class
from the list of listeners.
Consider the scenario of testing a HibernateTitleRepository class, as outlined in the
Goals section. The next two code listings demonstrate the
use of @Autowired on fields and setter methods. The application context configuration
is presented after all sample code listings.
![[Note]](images/note.png) | Note |
---|
The dependency injection behavior in the following code listings is not specific to
JUnit. The same DI techniques can be used in conjunction with any testing framework.
The following examples make calls to static assertion methods such as assertNotNull()
but without prepending the call with Assert . In such cases, assume that the method was
properly imported through an import static declaration that is not shown in the
example.
|
The first code listing shows a JUnit-based implementation of the test class that uses
@Autowired for field injection.
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("repository-config.xml")
public class HibernateTitleRepositoryTests {
@Autowired
private HibernateTitleRepository titleRepository;
@Test
public void findById() {
Title title = titleRepository.findById(new Long(10));
assertNotNull(title);
}
}
Alternatively, you can configure the class to use @Autowired for setter injection as
seen below.
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("repository-config.xml")
public class HibernateTitleRepositoryTests {
private HibernateTitleRepository titleRepository;
@Autowired
public void setTitleRepository(HibernateTitleRepository titleRepository) {
this.titleRepository = titleRepository;
}
@Test
public void findById() {
Title title = titleRepository.findById(new Long(10));
assertNotNull(title);
}
}
The preceding code listings use the same XML context file referenced by the
@ContextConfiguration annotation (that is, repository-config.xml ), which looks like
this:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="titleRepository" class="com.foo.repository.hibernate.HibernateTitleRepository">
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
</bean>
</beans>
![[Note]](images/note.png) | Note |
---|
If you are extending from a Spring-provided test base class that happens to use
@Autowired on one of its setter methods, you might have multiple beans of the affected
type defined in your application context: for example, multiple DataSource beans. In
such a case, you can override the setter method and use the @Qualifier annotation to
indicate a specific target bean as follows, but make sure to delegate to the overridden
method in the superclass as well.
@Autowired
@Override
public void setDataSource(@Qualifier("myDataSource") DataSource dataSource) {
super.setDataSource(dataSource);
}
The specified qualifier value indicates the specific DataSource bean to inject,
narrowing the set of type matches to a specific bean. Its value is matched against
<qualifier> declarations within the corresponding <bean> definitions. The bean name
is used as a fallback qualifier value, so you may effectively also point to a specific
bean by name there (as shown above, assuming that "myDataSource" is the bean id).
|
Testing request and session scoped beans
Request and session scoped beans have been supported by
Spring for several years now, but it’s always been a bit non-trivial to test them. As of
Spring 3.2 it’s a breeze to test your request-scoped and session-scoped beans by
following these steps.
-
Ensure that a
WebApplicationContext is loaded for your test by annotating your test
class with @WebAppConfiguration .
-
Inject the mock request or session into your test instance and prepare your test
fixture as appropriate.
-
Invoke your web component that you retrieved from the configured
WebApplicationContext (i.e., via dependency injection).
-
Perform assertions against the mocks.
The following code snippet displays the XML configuration for a login use case. Note
that the userService bean has a dependency on a request-scoped loginAction bean.
Also, the LoginAction is instantiated using SpEL expressions that
retrieve the username and password from the current HTTP request. In our test, we will
want to configure these request parameters via the mock managed by the TestContext
framework.
Request-scoped bean configuration.
<beans>
<bean id="userService"
class="com.example.SimpleUserService"
c:loginAction-ref="loginAction" />
<bean id="loginAction" class="com.example.LoginAction"
c:username="{request.getParameter(user)}"
c:password="{request.getParameter(pswd)}"
scope="request">
<aop:scoped-proxy />
</bean>
</beans>
In RequestScopedBeanTests we inject both the UserService (i.e., the subject under
test) and the MockHttpServletRequest into our test instance. Within our
requestScope() test method we set up our test fixture by setting request parameters in
the provided MockHttpServletRequest . When the loginUser() method is invoked on our
userService we are assured that the user service has access to the request-scoped
loginAction for the current MockHttpServletRequest (i.e., the one we just set
parameters in). We can then perform assertions against the results based on the known
inputs for the username and password.
Request-scoped bean test.
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
@WebAppConfiguration
public class RequestScopedBeanTests {
@Autowired UserService userService;
@Autowired MockHttpServletRequest request;
@Test
public void requestScope() {
request.setParameter("user", "enigma");
request.setParameter("pswd", "$pr!ng");
LoginResults results = userService.loginUser();
}
}
The following code snippet is similar to the one we saw above for a request-scoped bean;
however, this time the userService bean has a dependency on a session-scoped
userPreferences bean. Note that the UserPreferences bean is instantiated using a
SpEL expression that retrieves the theme from the current HTTP session. In our test,
we will need to configure a theme in the mock session managed by the TestContext
framework.
Session-scoped bean configuration.
<beans>
<bean id="userService"
class="com.example.SimpleUserService"
c:userPreferences-ref="userPreferences" />
<bean id="userPreferences"
class="com.example.UserPreferences"
c:theme="#{session.getAttribute(theme)}"
scope="session">
<aop:scoped-proxy />
</bean>
</beans>
In SessionScopedBeanTests we inject the UserService and the MockHttpSession into
our test instance. Within our sessionScope() test method we set up our test fixture by
setting the expected "theme" attribute in the provided MockHttpSession . When the
processUserPreferences() method is invoked on our userService we are assured that
the user service has access to the session-scoped userPreferences for the current
MockHttpSession , and we can perform assertions against the results based on the
configured theme.
Session-scoped bean test.
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
@WebAppConfiguration
public class SessionScopedBeanTests {
@Autowired UserService userService;
@Autowired MockHttpSession session;
@Test
public void sessionScope() throws Exception {
session.setAttribute("theme", "blue");
Results results = userService.processUserPreferences();
}
}
In the TestContext framework, transactions are managed by the
TransactionalTestExecutionListener . Note that TransactionalTestExecutionListener is
configured by default, even if you do not explicitly declare @TestExecutionListeners
on your test class. To enable support for transactions, however, you must provide a
PlatformTransactionManager bean in the application context loaded by
@ContextConfiguration semantics. In addition, you must declare @Transactional either
at the class or method level for your tests.
For class-level transaction configuration (i.e., setting an explicit bean name for the
transaction manager and the default rollback flag), see the @TransactionConfiguration
entry in the annotation support section.
If transactions are not enabled for the entire test class, you can annotate methods
explicitly with @Transactional . To control whether a transaction should commit for a
particular test method, you can use the @Rollback annotation to override the
class-level default rollback setting.
AbstractTransactionalJUnit4SpringContextTests and
AbstractTransactionalTestNGSpringContextTests
are preconfigured for transactional support at the class level.
Occasionally you need to execute certain code before or after a transactional test
method but outside the transactional context, for example, to verify the initial
database state prior to execution of your test or to verify expected transactional
commit behavior after test execution (if the test was configured not to roll back the
transaction). TransactionalTestExecutionListener supports the @BeforeTransaction and
@AfterTransaction annotations exactly for such scenarios. Simply annotate any public
void method in your test class with one of these annotations, and the
TransactionalTestExecutionListener ensures that your before transaction method or
after transaction method is executed at the appropriate time.
![[Tip]](images/tip.png) | Tip |
---|
Any before methods (such as methods annotated with JUnit’s @Before ) and any
after methods (such as methods annotated with JUnit’s @After ) are executed
within a transaction. In addition, methods annotated with @BeforeTransaction or
@AfterTransaction are naturally not executed for test methods that are not configured
to run within a transaction.
|
The following JUnit-based example displays a fictitious integration testing scenario
highlighting several transaction-related annotations. Consult the
annotation support section for further information
and configuration examples.
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
@TransactionConfiguration(transactionManager="txMgr", defaultRollback=false)
@Transactional
public class FictitiousTransactionalTest {
@BeforeTransaction
public void verifyInitialDatabaseState() {
}
@Before
public void setUpTestDataWithinTransaction() {
}
@Test
@Rollback(true)
public void modifyDatabaseWithinTransaction() {
}
@After
public void tearDownWithinTransaction() {
}
@AfterTransaction
public void verifyFinalDatabaseState() {
}
}
![[Note]](images/note.png) | Avoid false positives when testing ORM code |
---|
When you test application code that manipulates the state of the Hibernate session, make
sure to flush the underlying session within test methods that execute that code.
Failing to flush the underlying session can produce false positives: your test may
pass, but the same code throws an exception in a live, production environment. In the
following Hibernate-based example test case, one method demonstrates a false positive,
and the other method correctly exposes the results of flushing the session. Note that
this applies to JPA and any other ORM frameworks that maintain an in-memory unit of
work.
@Autowired
private SessionFactory sessionFactory;
@Test
public void falsePositive() {
updateEntityInHibernateSession();
}
@Test(expected = GenericJDBCException.class)
public void updateWithSessionFlush() {
updateEntityInHibernateSession();
sessionFactory.getCurrentSession().flush();
}
|
TestContext Framework support classes
The org.springframework.test.context.junit4 package provides support classes for JUnit
4.5+ based test cases.
-
AbstractJUnit4SpringContextTests : Abstract base test class that integrates the
Spring TestContext Framework with explicit ApplicationContext testing support in
a JUnit 4.5+ environment.
When you extend AbstractJUnit4SpringContextTests , you can access the following
protected instance variable:
-
applicationContext : Use this variable to perform explicit bean lookups or to test
the state of the context as a whole.
-
AbstractTransactionalJUnit4SpringContextTests : Abstract transactional extension
of AbstractJUnit4SpringContextTests that also adds some convenience functionality
for JDBC access. Expects a javax.sql.DataSource bean and a
PlatformTransactionManager bean to be defined in the ApplicationContext .
When you extend AbstractTransactionalJUnit4SpringContextTests you can access the
following protected instance variables:
-
applicationContext : Inherited from the AbstractJUnit4SpringContextTests
superclass. Use this variable to perform explicit bean lookups or to test the state of
the context as a whole.
-
jdbcTemplate : Use this variable to execute SQL statements to query the database.
Such queries can be used to confirm database state both prior to and after
execution of database-related application code, and Spring ensures that such queries run
in the scope of the same transaction as the application code. When used in conjunction
with an ORM tool, be sure to avoid false positives.
![[Tip]](images/tip.png) | Tip |
---|
These classes are a convenience for extension. If you do not want your test classes to
be tied to a Spring-specific class hierarchy — for example, if you want to directly
extend the class you are testing — you can configure your own custom test classes by
using @RunWith(SpringJUnit4ClassRunner.class) , @ContextConfiguration ,
@TestExecutionListeners , and so on.
|
The Spring TestContext Framework offers full integration with JUnit 4.5+ through a
custom runner (tested on JUnit 4.5 — 4.11). By annotating test classes with
@RunWith(SpringJUnit4ClassRunner.class) , developers can implement standard JUnit-based
unit and integration tests and simultaneously reap the benefits of the TestContext
framework such as support for loading application contexts, dependency injection of test
instances, transactional test method execution, and so on. The following code listing
displays the minimal requirements for configuring a test class to run with the custom
Spring Runner. @TestExecutionListeners is configured with an empty list in order to
disable the default listeners, which otherwise would require an ApplicationContext to be
configured through @ContextConfiguration .
@RunWith(SpringJUnit4ClassRunner.class)
@TestExecutionListeners({})
public class SimpleTest {
@Test
public void testMethod() {
}
}
The org.springframework.test.context.testng package provides support classes for
TestNG based test cases.
-
AbstractTestNGSpringContextTests : Abstract base test class that integrates the
Spring TestContext Framework with explicit ApplicationContext testing support in
a TestNG environment.
When you extend AbstractTestNGSpringContextTests , you can access the following
protected instance variable:
-
applicationContext : Use this variable to perform explicit bean lookups or to test
the state of the context as a whole.
-
AbstractTransactionalTestNGSpringContextTests : Abstract transactional extension
of AbstractTestNGSpringContextTests that adds some convenience functionality for JDBC
access. Expects a javax.sql.DataSource bean and a PlatformTransactionManager bean to
be defined in the ApplicationContext .
When you extend AbstractTransactionalTestNGSpringContextTests , you can access the following
protected instance variables:
-
applicationContext : Inherited from the AbstractTestNGSpringContextTests
superclass. Use this variable to perform explicit bean lookups or to test the state of
the context as a whole.
-
jdbcTemplate : Use this variable to execute SQL statements to query the database.
Such queries can be used to confirm database state both prior to and after
execution of database-related application code, and Spring ensures that such queries run
in the scope of the same transaction as the application code. When used in conjunction
with an ORM tool, be sure to avoid false positives.
![[Tip]](images/tip.png) | Tip |
---|
These classes are a convenience for extension. If you do not want your test classes to
be tied to a Spring-specific class hierarchy — for example, if you want to directly
extend the class you are testing — you can configure your own custom test classes by
using @ContextConfiguration , @TestExecutionListeners , and so on, and by manually
instrumenting your test class with a TestContextManager . See the source code of
AbstractTestNGSpringContextTests for an example of how to instrument your test class.
|
10.3.6 Spring MVC Test Framework
The Spring MVC Test framework provides first class JUnit support for testing client
and server-side Spring MVC code through a fluent API. Typically it loads the actual
Spring configuration through the TestContext framework and always uses the
DispatcherServlet to process requests thus approximating full integration tests
without requiring a running Servlet container.
Client-side tests are RestTemplate -based and allow tests for code that relies on the
RestTemplate without requiring a running server to respond to the requests.
Before Spring Framework 3.2, the most likely way to test a Spring MVC controller was to
write a unit test that instantiates the controller, injects it with mock or stub
dependencies, and then calls its methods directly, using a MockHttpServletRequest and
MockHttpServletResponse where necessary.
Although this is pretty easy to do, controllers have many annotations, and much remains
untested. Request mappings, data binding, type conversion, and validation are just a few
examples of what isn’t tested. Furthermore, there are other types of annotated methods
such as @InitBinder , @ModelAttribute , and @ExceptionHandler that get invoked as
part of request processing.
The idea behind Spring MVC Test is to be able to re-write those controller tests by
performing actual requests and generating responses, as they would be at runtime, along
the way invoking controllers through the Spring MVC DispatcherServlet . Controllers can
still be injected with mock dependencies, so tests can remain focused on the web layer.
Spring MVC Test builds on the familiar "mock" implementations of the Servlet API
available in the spring-test module. This allows performing requests and generating
responses without the need for running in a Servlet container. For the most part
everything should work as it does at runtime with the exception of JSP rendering, which
is not available outside a Servlet container. Furthermore, if you are familiar with how
the MockHttpServletResponse works, you’ll know that forwards and redirects are not
actually executed. Instead "forwarded" and "redirected" URLs are saved and can be
asserted in tests. This means if you are using JSPs, you can verify the JSP page to
which the request was forwarded.
All other means of rendering including @ResponseBody methods and View types (besides
JSPs) such as Freemarker, Velocity, Thymeleaf, and others for rendering HTML, JSON, XML,
and so on should work as expected, and the response will contain the generated content.
Below is an example of a test requesting account information in JSON format:
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration("test-servlet-context.xml")
public class ExampleTests {
@Autowired
private WebApplicationContext wac;
private MockMvc mockMvc;
@Before
public void setup() {
this.mockMvc = MockMvcBuilders.webAppContextSetup(this.wac).build();
}
@Test
public void getAccount() throws Exception {
this.mockMvc.perform(get("/accounts/1").accept(MediaType.parseMediaType("application/json;charset=UTF-8")))
.andExpect(status().isOk())
.andExpect(content().contentType("application/json"))
.andExpect(jsonPath("$.name").value("Lee"));
}
}
The test relies on the WebApplicationContext support of the TestContext framework.
It loads Spring configuration from an XML configuration file located in the same package
as the test class (also supports JavaConfig) and injects the created
WebApplicationContext into the test so a MockMvc instance can be created with it.
The MockMvc is then used to perform a request to "/accounts/1" and verify the
resulting response status is 200, the response content type is "application/json" , and
response content has a JSON property called "name" with the value "Lee". JSON content is
inspected with the help of Jayway’s JsonPath
project. There are lots of other options for verifying the result of the performed
request and those will be discussed later.
The fluent API in the example above requires a few static imports such as
MockMvcRequestBuilders.* , MockMvcResultMatchers.* , and MockMvcBuilders.* . An easy
way to find these classes is to search for types matching "MockMvc*". If using
Eclipse, be sure to add them as "favorite static members" in the Eclipse preferences
underJava → Editor → Content Assist → Favorites. That will allow use of content
assist after typing the first character of the static method name. Other IDEs (e.g.
IntelliJ) may not require any additional configuration. Just check the support for code
completion on static members.
The goal of server-side test setup is to create an instance of MockMvc that can be
used to perform requests. There are two main options.
The first option is to point to Spring MVC configuration through the TestContext
framework, which loads the Spring configuration and injects a WebApplicationContext
into the test to use to create a MockMvc :
@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration("my-servlet-context.xml")
public class MyWebTests {
@Autowired
private WebApplicationContext wac;
private MockMvc mockMvc;
@Before
public void setup() {
this.mockMvc = MockMvcBuilders.webAppContextSetup(this.wac).build();
}
}
The second option is to simply register a controller instance without loading any Spring
configuration. Instead basic Spring MVC configuration suitable for testing annotated
controllers is automatically created. The created configuration is comparable to that of
the MVC JavaConfig (and the MVC namespace) and can be customized to a degree through
builder-style methods:
public class MyWebTests {
private MockMvc mockMvc;
@Before
public void setup() {
this.mockMvc = MockMvcBuilders.standaloneSetup(new AccountController()).build();
}
}
Which option should you use?
The "webAppContextSetup" loads the actual Spring MVC configuration resulting in a
more complete integration test. Since the TestContext framework caches the loaded
Spring configuration, it helps to keep tests running fast even as more tests get added.
Furthermore, you can inject mock services into controllers through Spring configuration,
in order to remain focused on testing the web layer. Here is an example of declaring a
mock service with Mockito:
<bean id="accountService" class="org.mockito.Mockito" factory-method="mock">
<constructor-arg value="org.example.AccountService"/>
</bean>
Then you can inject the mock service into the test in order set up and verify
expectations:
@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration("test-servlet-context.xml")
public class AccountTests {
@Autowired
private WebApplicationContext wac;
private MockMvc mockMvc;
@Autowired
private AccountService accountService;
}
The "standaloneSetup" on the other hand is a little closer to a unit test. It tests
one controller at a time, the controller can be injected with mock dependencies
manually, and it doesn’t involve loading Spring configuration. Such tests are more
focused in style and make it easier to see which controller is being tested, whether any
specific Spring MVC configuration is required to work, and so on. The "standaloneSetup"
is also a very convenient way to write ad-hoc tests to verify some behavior or to debug
an issue.
Just like with integration vs unit testing, there is no right or wrong answer. Using the
"standaloneSetup" does imply the need for some additional "webAppContextSetup" tests to
verify the Spring MVC configuration. Alternatively, you can decide write all tests with
"webAppContextSetup" and always test against actual Spring MVC configuration.
To perform requests, use the appropriate HTTP method and additional builder-style
methods corresponding to properties of MockHttpServletRequest . For example:
mockMvc.perform(post("/hotels/{id}", 42).accept(MediaType.APPLICATION_JSON));
In addition to all the HTTP methods, you can also perform file upload requests, which
internally creates an instance of MockMultipartHttpServletRequest :
mockMvc.perform(fileUpload("/doc").file("a1", "ABC".getBytes("UTF-8")));
Query string parameters can be specified in the URI template:
mockMvc.perform(get("/hotels?foo={foo}", "bar"));
Or by adding Servlet request parameters:
mockMvc.perform(get("/hotels").param("foo", "bar"));
If application code relies on Servlet request parameters, and doesn’t check the query
string, as is most often the case, then it doesn’t matter how parameters are added. Keep
in mind though that parameters provided in the URI template will be decoded while
parameters provided through the param(...) method are expected to be decoded.
In most cases it’s preferable to leave out the context path and the Servlet path from
the request URI. If you must test with the full request URI, be sure to set the
contextPath and servletPath accordingly so that request mappings will work:
mockMvc.perform(get("/app/main/hotels/{id}").contextPath("/app").servletPath("/main"))
Looking at the above example, it would be cumbersome to set the contextPath and
servletPath with every performed request. That’s why you can define default request
properties when building the MockMvc :
public class MyWebTests {
private MockMvc mockMvc;
@Before
public void setup() {
mockMvc = standaloneSetup(new AccountController())
.defaultRequest(get("/")
.contextPath("/app").servletPath("/main")
.accept(MediaType.APPLICATION_JSON).build();
}
The above properties will apply to every request performed through the MockMvc . If the
same property is also specified on a given request, it will override the default value.
That is why, the HTTP method and URI don’t matter, when setting default request
properties, since they must be specified on every request.
Expectations can be defined by appending one or more .andExpect(..) after call to
perform the request:
mockMvc.perform(get("/accounts/1")).andExpect(status().isOk());
MockMvcResultMatchers.* defines a number of static members, some of which return types
with additional methods, for asserting the result of the performed request. The
assertions fall in two general categories.
The first category of assertions verify properties of the response, i.e the response
status, headers, and content. Those are the most important things to test for.
The second category of assertions go beyond the response, and allow inspecting Spring
MVC specific constructs such as which controller method processed the request, whether
an exception was raised and handled, what the content of the model is, what view was
selected, what flash attributes were added, and so on. It is also possible to verify
Servlet specific constructs such as request and session attributes. The following test
asserts that binding/validation failed:
mockMvc.perform(post("/persons"))
.andExpect(status().isOk())
.andExpect(model().attributeHasErrors("person"));
Many times when writing tests, it’s useful to dump the result of the performed request.
This can be done as follows, where print() is a static import from
MockMvcResultHandlers :
mockMvc.perform(post("/persons"))
.andDo(print())
.andExpect(status().isOk())
.andExpect(model().attributeHasErrors("person"));
As long as request processing causes an unhandled exception, the print() method will
print all the available result data to System.out .
In some cases, you may want to get direct access to the result and verify something that
cannot be verified otherwise. This can be done by appending .andReturn() at the end
after all expectations:
MvcResult mvcResult = mockMvc.perform(post("/persons")).andExpect(status().isOk()).andReturn();
When all tests repeat the same expectations, you can define the common expectations once
when building the MockMvc :
standaloneSetup(new SimpleController())
.alwaysExpect(status().isOk())
.alwaysExpect(content().contentType("application/json;charset=UTF-8"))
.build()
Note that the expectation is always applied and cannot be overridden without
creating a separate MockMvc instance.
When JSON response content contains hypermedia links created with
Spring HATEOAS, the resulting links can
be verified:
mockMvc.perform(get("/people").accept(MediaType.APPLICATION_JSON))
.andExpect(jsonPath("$.links[?(@.rel == self)].href").value("http:
When XML response content contains hypermedia links created with
Spring HATEOAS, the resulting links can
be verified:
Map<String, String> ns = Collections.singletonMap("ns", "http://www.w3.org/2005/Atom");
mockMvc.perform(get("/handle").accept(MediaType.APPLICATION_XML))
.andExpect(xpath("/person/ns:link[@rel=self]/@href", ns).string("http://localhost:8080/people"));
When setting up a MockMvc , you can register one or more Filter instances:
mockMvc = standaloneSetup(new PersonController()).addFilters(new CharacterEncodingFilter()).build();
Registered filters will be invoked through MockFilterChain from spring-test and the
last filter will delegates to the DispatcherServlet .
Further Server-Side Test Examples
The framework’s own tests include
many
sample tests intended to demonstrate how to use Spring MVC Test. Browse these examples
for further ideas. Also the
spring-mvc-showcase has full test
coverage based on Spring MVC Test.
Client-side tests are for code using the RestTemplate . The goal is to define expected
requests and provide "stub" responses:
RestTemplate restTemplate = new RestTemplate();
MockRestServiceServer mockServer = MockRestServiceServer.createServer(restTemplate);
mockServer.expect(requestTo("/greeting")).andRespond(withSuccess("Hello world", MediaType.TEXT_PLAIN));
mockServer.verify();
In the above example, MockRestServiceServer — the central class for client-side REST
tests — configures the RestTemplate with a custom ClientHttpRequestFactory that
asserts actual requests against expectations and returns "stub" responses. In this case
we expect a single request to "/greeting" and want to return a 200 response with
"text/plain" content. We could define as many additional requests and stub responses as
necessary.
Once expected requests and stub responses have been defined, the RestTemplate can be
used in client-side code as usual. At the end of the tests mockServer.verify() can be
used to verify that all expected requests were performed.
Just like with server-side tests, the fluent API for client-side tests requires a few
static imports. Those are easy to find by searching "MockRest*". Eclipse users
should add "MockRestRequestMatchers.*" and "MockRestResponseCreators.*" as "favorite
static members" in the Eclipse preferences under Java → Editor → Content Assist →
Favorites. That allows using content assist after typing the first character of the
static method name. Other IDEs (e.g. IntelliJ) may not require any additional
configuration. Just check the support for code completion on static members.
Further Examples of Client-side REST Tests
Spring MVC Test’s own tests include
example
tests of client-side REST tests.
The PetClinic application, available on
Github, illustrates several features
of the Spring TestContext Framework in a JUnit 4.5+ environment. Most test
functionality is included in the AbstractClinicTests , for which a partial listing
is shown below:
import static org.junit.Assert.assertEquals;
@ContextConfiguration
public abstract class AbstractClinicTests extends AbstractTransactionalJUnit4SpringContextTests {
@Autowired
protected Clinic clinic;
@Test
public void getVets() {
Collection<Vet> vets = this.clinic.getVets();
assertEquals("JDBC query must show the same number of vets",
super.countRowsInTable("VETS"), vets.size());
Vet v1 = EntityUtils.getById(vets, Vet.class, 2);
assertEquals("Leary", v1.getLastName());
assertEquals(1, v1.getNrOfSpecialties());
assertEquals("radiology", (v1.getSpecialties().get(0)).getName());
}
}
Notes:
-
This test case extends the
AbstractTransactionalJUnit4SpringContextTests class, from
which it inherits configuration for Dependency Injection (through the
DependencyInjectionTestExecutionListener ) and transactional behavior (through the
TransactionalTestExecutionListener ).
-
The
clinic instance variable — the application object being tested — is set by
Dependency Injection through @Autowired semantics.
-
The
getVets() method illustrates how you can use the inherited
countRowsInTable() method to easily verify the number of rows in a given table, thus
verifying correct behavior of the application code being tested. This allows for
stronger tests and lessens dependency on the exact test data. For example, you can add
additional rows in the database without breaking tests.
-
Like many integration tests that use a database, most of the tests in
AbstractClinicTests depend on a minimum amount of data already in the database
before the test cases run. Alternatively, you might choose to populate the database
within the test fixture set up of your test cases — again, within the same
transaction as the tests.
The PetClinic application supports three data access technologies: JDBC, Hibernate, and
JPA. By declaring @ContextConfiguration without any specific resource locations, the
AbstractClinicTests class will have its application context loaded from the default
location, AbstractClinicTests-context.xml , which declares a common DataSource .
Subclasses specify additional context locations that must declare a
PlatformTransactionManager and a concrete implementation of Clinic .
For example, the Hibernate implementation of the PetClinic tests contains the following
implementation. For this example, HibernateClinicTests does not contain a single line
of code: we only need to declare @ContextConfiguration , and the tests are inherited
from AbstractClinicTests . Because @ContextConfiguration is declared without any
specific resource locations, the Spring TestContext Framework loads an application
context from all the beans defined in AbstractClinicTests-context.xml (i.e., the
inherited locations) and HibernateClinicTests-context.xml , with
HibernateClinicTests-context.xml possibly overriding beans defined in
AbstractClinicTests-context.xml .
@ContextConfiguration
public class HibernateClinicTests extends AbstractClinicTests { }
In a large-scale application, the Spring configuration is often split across multiple
files. Consequently, configuration locations are typically specified in a common base
class for all application-specific integration tests. Such a base class may also add
useful instance variables — populated by Dependency Injection, naturally — such as a
SessionFactory in the case of an application using Hibernate.
As far as possible, you should have exactly the same Spring configuration files in your
integration tests as in the deployed environment. One likely point of difference
concerns database connection pooling and transaction infrastructure. If you are
deploying to a full-blown application server, you will probably use its connection pool
(available through JNDI) and JTA implementation. Thus in production you will use a
JndiObjectFactoryBean or <jee:jndi-lookup> for the DataSource and
JtaTransactionManager . JNDI and JTA will not be available in out-of-container
integration tests, so you should use a combination like the Commons DBCP
BasicDataSource and DataSourceTransactionManager or HibernateTransactionManager
for them. You can factor out this variant behavior into a single XML file, having the
choice between application server and a local configuration separated from all other
configuration, which will not vary between the test and production environments. In
addition, it is advisable to use properties files for connection settings. See the
PetClinic application for an example.
Consult the following resources for more information about testing:
-
JUnit: "A programmer-oriented testing framework for Java".
Used by the Spring Framework in its test suite.
-
TestNG: A testing framework inspired by JUnit with added support
for annotations, test groups, data-driven testing, distributed testing, etc.
-
MockObjects.com: Web site dedicated to mock objects, a
technique for improving the design of code within test-driven development.
-
"Mock Objects": Article in Wikipedia.
-
EasyMock: Java library " that provides Mock Objects for
interfaces (and objects through the class extension) by generating them on the fly
using Java’s proxy mechanism. " Used by the Spring Framework in its test suite.
-
JMock: Library that supports test-driven development of Java
code with mock objects.
-
Mockito: Java mock library based on the
test spy pattern.
-
DbUnit: JUnit extension (also usable with Ant and
Maven) targeted for database-driven projects that, among other things, puts your
database into a known state between test runs.
-
The Grinder: Java load testing framework.
|
|