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
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
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.
org.springframework.mock.env package contains mock implementations of the
PropertySource abstractions (see Section 7.13.1, “Bean definition profiles”
and Section 7.13.2, “PropertySource abstraction”).
MockPropertySource are useful for developing out-of-container tests for code that
depends on environment-specific properties.
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
DataSources 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.
org.springframework.mock.web package contains a comprehensive set of Servlet API
mock objects that are useful for testing web contexts, controllers, and filters. These
mock objects are targeted at usage with Spring’s Web MVC framework and are generally more
convenient to use than dynamic mock objects such as EasyMock or
alternative Servlet API mock objects such as MockObjects. Since
Spring Framework 4.0, the set of mocks in the
org.springframework.mock.web package is
based on the Servlet 3.0 API.
For thorough integration testing of your Spring MVC and REST
conjunction with your
WebApplicationContext configuration for Spring MVC, see the
Spring MVC Test Framework.
org.springframework.test.util package contains several general purpose utilities
for use in unit and integration testing.
ReflectionTestUtils is a collection of reflection-based utility methods. Developers use
these methods in testing scenarios where they need to change the value of a constant, set
public field, invoke a non-
public setter method, or invoke a non-
configuration or lifecycle callback method when testing application code involving
use cases such as the following.
protectedfield access as opposed to
publicsetter methods for properties in a domain entity.
@Resource, which provides dependency injection for
protectedfields, setter methods, and configuration methods.
@PreDestroyfor lifecycle callback methods.
AopTestUtils is a collection of AOP-related utility methods. These methods can be used
to obtain a reference to the underlying target object hidden behind one or more Spring
proxies. For example, if you have configured a bean as a dynamic mock using a library
like EasyMock or Mockito and the mock is wrapped in a Spring proxy, you may need direct
access to the underlying mock in order to configure expectations on it and perform
verifications. For Spring’s core AOP utilities, see
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
|Unit testing Spring MVC Controllers|
To unit test your Spring MVC