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.env
package
contains mock implementations of the
Environment
and
PropertySource
abstractions introduced
in Spring 3.1 (see Section 3.3, “Environment Abstraction” and Section 3.4, “PropertySource Abstraction”).
MockEnvironment
and
MockPropertySource
are useful for developing
out-of-container tests for code that depends on
environment-specific properties.
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.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.
![]() | Unit testing Spring MVC Controllers |
---|---|
To test your Spring MVC |
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 Cactus 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.
![]() | JUnit 3.8 support is deprecated |
---|---|
As of Spring 3.0, the legacy JUnit 3.8 base class hierarchy
(i.e.,
As of Spring 3.1, the JUnit 3.8 base classes in the Spring
TestContext Framework (i.e.,
|
Spring's integration testing support has the following primary goals:
To manage Spring IoC container caching between test execution.
To provide Dependency Injection of test fixture instances.
To provide transaction management appropriate to integration testing.
To supply Spring-specific base classes that assist developers in writing integration tests.
The next few sections describe each goal and provide links to implementation and configuration details.
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 context management and caching with the TestContext framework.
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.
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.
The org.springframework.test.jdbc
package
contains JdbcTestUtils
, which is a collection of
JDBC related utility functions intended to simplify standard database
testing scenarios. Note that AbstractTransactionalJUnit4SpringContextTests
and AbstractTransactionalTestNGSpringContextTests
provide convenience methods which delegate to
JdbcTestUtils
internally.
The spring-jdbc
module provides support for
configuring and launching an embedded database which can be used in
integration tests that interact with a database. For details, see Section 14.8, “Embedded database support” and Section 14.8.8, “Testing data access logic with an embedded database”.
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 respective Javadoc 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
either 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 { // class body... }
@ContextConfiguration(classes=TestConfig.class) public class ConfigClassApplicationContextTests { // class body... }
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 { // class body... }
@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 { // class body... }
![]() | Note |
---|---|
|
See Context
management and caching and the Javadoc for
@ContextConfiguration
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 { // class body... }
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 { // class body... }
Note that
@WebAppConfiguration
must be used
in conjunction with
@ContextConfiguration
, either
within a single test class or within a test class hierarchy. See
the Javadoc for
@WebAppConfiguration
for further
details.
@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 { // class body... }
@ContextConfiguration @ActiveProfiles({"dev", "integration"}) public class DeveloperIntegrationTests { // class body... }
![]() | Note |
---|---|
|
See Context
configuration with environment profiles and the Javadoc for
@ActiveProfiles
for examples and
further details.
@DirtiesContext
Indicates that the underlying Spring
ApplicationContext
has been
dirtied (i.e., modified or corrupted in some
manner) during the execution of a test and should be closed,
regardless of whether the test passed.
@DirtiesContext
is supported in the
following scenarios:
After the current test class, when declared on a class
with class mode set to AFTER_CLASS
, which
is the default class mode.
After each test method in the current test class, when
declared on a class with class mode set to
AFTER_EACH_TEST_METHOD.
After the current test, when declared on a method.
Use this annotation if a test has modified the context (for example, by replacing a bean definition). Subsequent tests are supplied a new context.
With JUnit 4.5+ or TestNG you can use
@DirtiesContext
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.
@DirtiesContext public class ContextDirtyingTests { // some tests that result in the Spring container being dirtied }
@DirtiesContext(classMode = ClassMode.AFTER_EACH_TEST_METHOD) public class ContextDirtyingTests { // some tests that result in the Spring container being dirtied }
@DirtiesContext @Test public void testProcessWhichDirtiesAppCtx() { // some logic that results in the Spring container being dirtied }
When an application context is marked dirty, it is removed from the testing framework's cache and closed; thus the underlying Spring container is rebuilt for any subsequent test that requires a context with the same set of resource locations.
@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 { // class body... }
@TestExecutionListeners
supports inherited listeners by default. See
the Javadoc 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 { // class body... }
![]() | Note |
---|---|
If the default conventions are sufficient for your test
configuration, you can avoid using
|
@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() { // logic to be executed before a transaction is started }
@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() { // logic to be executed after a transaction has ended }
@NotTransactional
The presence of this annotation indicates that the annotated test method must not execute in a transactional context.
@NotTransactional @Test public void testProcessWithoutTransaction() { // ... }
![]() | @NotTransactional is deprecated |
---|---|
As of Spring 3.0,
|
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
![]() | JSR-250 Lifecycle Annotations |
---|---|
In the Spring TestContext Framework
If a method within a test class is annotated with
|
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="Sun Microsystems Inc.") @Test public void testProcessWhichRunsOnlyOnSunJvm() { // some logic that should run only on Java VMs from Sun Microsystems }
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() { // some logic that should run only for unit and integration test groups }
@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 { // class body... }
@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() { // some logic that should not take longer than 1 second to execute }
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() { // ... }
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 Javadoc 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.
![]() | @Autowired ApplicationContext |
---|---|
As an alternative to implementing the
@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration public class MyTest { @Autowired private ApplicationContext applicationContext; // class body... } Similarly, if your test is configured to load a
@RunWith(SpringJUnit4ClassRunner.class) @WebAppConfiguration @ContextConfiguration public class MyWebAppTest { @Autowired private WebApplicationContext wac; // class body... } Dependency injection via
|
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.
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) // ApplicationContext will be loaded from "/app-config.xml" and // "/test-config.xml" in the root of the classpath @ContextConfiguration(locations={"/app-config.xml", "/test-config.xml"}) public class MyTest { // class body... }
@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 { // class body... }
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) // ApplicationContext will be loaded from // "classpath:/com/example/MyTest-context.xml" @ContextConfiguration public class MyTest { // class body... }
To load an ApplicationContext
for your tests using annotated classes (see
Section 5.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) // ApplicationContext will be loaded from AppConfig and TestConfig @ContextConfiguration(classes = {AppConfig.class, TestConfig.class}) public class MyTest { // class body... }
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 Javadoc
for @Configuration
. 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) // ApplicationContext will be loaded from the // static inner Config class @ContextConfiguration public class OrderServiceTest { @Configuration static class Config { // this bean will be injected into the OrderServiceTest class @Bean public OrderService orderService() { OrderService orderService = new OrderServiceImpl(); // set properties, etc. return orderService; } } @Autowired private OrderService orderService; @Test public void testOrderService() { // test the orderService } }
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. As
mentioned in the section called “Spring Testing Annotations” the TestContext
framework does not allow you to declare both
via @ContextConfiguration
, but this
does not mean that you cannot use both.
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.
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) // ApplicationContext will be loaded from TestConfig // and initialized by TestAppCtxInitializer @ContextConfiguration( classes = TestConfig.class, initializers = TestAppCtxInitializer.class) public class MyTest { // class body... }
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) // ApplicationContext will be initialized by EntireAppInitializer // which presumably registers beans in the context @ContextConfiguration(initializers = EntireAppInitializer.class) public class MyTest { // class body... }
@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) // ApplicationContext will be loaded from "/base-config.xml" // in the root of the classpath @ContextConfiguration("/base-config.xml") public class BaseTest { // class body... } // ApplicationContext will be loaded from "/base-config.xml" and // "/extended-config.xml" in the root of the classpath @ContextConfiguration("/extended-config.xml") public class ExtendedTest extends BaseTest { // class body... }
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) // ApplicationContext will be loaded from BaseConfig @ContextConfiguration(classes = BaseConfig.class) public class BaseTest { // class body... } // ApplicationContext will be loaded from BaseConfig and ExtendedConfig @ContextConfiguration(classes = ExtendedConfig.class) public class ExtendedTest extends BaseTest { // class body... }
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) // ApplicationContext will be initialized by BaseInitializer @ContextConfiguration(initializers=BaseInitializer.class) public class BaseTest { // class body... } // ApplicationContext will be initialized by BaseInitializer // and ExtendedInitializer @ContextConfiguration(initializers=ExtendedInitializer.class) public class ExtendedTest extends BaseTest { // class body... }
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 |
---|---|
|
Let's take a look at some examples with XML configuration and
@Configuration
classes.
<!-- app-config.xml --> <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>
package com.bank.service; @RunWith(SpringJUnit4ClassRunner.class) // ApplicationContext will be loaded from "classpath:/app-config.xml" @ContextConfiguration("/app-config.xml") @ActiveProfiles("dev") public class TransferServiceTest { @Autowired private TransferService transferService; @Test public void testTransferService() { // test the transferService } }
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 twice: once in the
production profile and once in the
dev 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 the
accountRepository
bean will be wired with a
reference to the development
DataSource
. And that's likely what we
want in an integration test.
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 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}) @ActiveProfiles("dev") public class TransferServiceTest { @Autowired private TransferService transferService; @Test public void testTransferService() { // test the transferService } }
In this variation, we have split the XML configuration into
three 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
As with the XML-based configuration example, we still annotate
TransferServiceTest
with
@ActiveProfiles("dev")
, but this time
we specify all three configuration classes via the
@ContextConfiguration
annotation. The
body of the test class itself remains completely unchanged.
Spring 3.2 introduces 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
.
Example 11.1. Conventions
@RunWith(SpringJUnit4ClassRunner.class) // defaults to "file:src/main/webapp" @WebAppConfiguration // detects "WacTests-context.xml" in same package // or static nested @Configuration class @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).
Example 11.2. Default Resource Semantics
@RunWith(SpringJUnit4ClassRunner.class) // file system resource @WebAppConfiguration("webapp") // classpath resource @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.
Example 11.3. Explicit Resource Semantics
@RunWith(SpringJUnit4ClassRunner.class) // classpath resource @WebAppConfiguration("classpath:test-web-resources") // file system resource @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
introduces a new
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
.
Example 11.4. Injecting Mocks
@WebAppConfiguration @ContextConfiguration public class WacTests { @Autowired WebApplicationContext wac; // cached @Autowired MockServletContext servletContext; // cached @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.
![]() | 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 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 |
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 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 |
---|---|
The TestContext framework does not instrument the manner in
which a test instance is instantiated. Thus the use of
|
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 |
---|---|
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 |
The first code listing shows a JUnit-based implementation of the
test class that uses @Autowired
for
field injection.
@RunWith(SpringJUnit4ClassRunner.class) // specifies the Spring configuration to load for this test fixture @ContextConfiguration("repository-config.xml") public class HibernateTitleRepositoryTests { // this instance will be dependency injected by type @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) // specifies the Spring configuration to load for this test fixture @ContextConfiguration("repository-config.xml") public class HibernateTitleRepositoryTests { // this instance will be dependency injected by type 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"> <!-- this bean will be injected into the HibernateTitleRepositoryTests class --> <bean id="titleRepository" class="com.foo.repository.hibernate.HibernateTitleRepository"> <property name="sessionFactory" ref="sessionFactory"/> </bean> <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <!-- configuration elided for brevity --> </bean> </beans>
![]() | Note |
---|---|
If you are extending from a Spring-provided test base class
that happens to use // ... @Autowired @Override public void setDataSource(@Qualifier("myDataSource") DataSource dataSource) { super.setDataSource(dataSource); } // ... The specified qualifier value indicates the specific
|
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 now 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.
Example 11.5. 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.
Example 11.6. 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(); // assert results } }
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.
Example 11.7. 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.
Example 11.8. 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(); // assert results } }
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 |
---|---|
Any before methods (such as methods
annotated with JUnit's |
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() { // logic to verify the initial state before a transaction is started } @Before public void setUpTestDataWithinTransaction() { // set up test data within the transaction } @Test // overrides the class-level defaultRollback setting @Rollback(true) public void modifyDatabaseWithinTransaction() { // logic which uses the test data and modifies database state } @After public void tearDownWithinTransaction() { // execute "tear down" logic within the transaction } @AfterTransaction public void verifyFinalDatabaseState() { // logic to verify the final state after transaction has rolled back } }
![]() | 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 // no expected exception! public void falsePositive() { updateEntityInHibernateSession(); // False positive: an exception will be thrown once the session is // finally flushed (i.e., in production code) } @Test(expected = GenericJDBCException.class) public void updateWithSessionFlush() { updateEntityInHibernateSession(); // Manual flush is required to avoid false positive in test sessionFactory.getCurrentSession().flush(); } // ... |
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 |
---|---|
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
|
The Spring TestContext Framework offers
full integration with JUnit 4.5+ through a custom runner (tested on
JUnit 4.5 – 4.10). 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() { // execute test logic... } }
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 |
---|---|
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 |
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("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 under
Java -> 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://localhost:8080/people"));
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
.
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", "text/plain")); // use RestTemplate ... 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.
Spring MVC Test's own tests include example tests of client-side REST tests.
The PetClinic application, available from the samples repository, 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; // import ... @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 testGetVets()
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 Java 5 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.
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.