Recently I came into one project which is using Spring MVC
for web-tier in the architecture. It
gave me a chance to use Spring MVC Test framework and Mockito mock framework
together in the unit testing of all Spring MVC controllers in the
application. I found that both of them
provide very good functionalities to test the controllers and would like to
show what I did with them.
Spring MVC Test framework
Before when unit testing MVC controllers we usually use MockHttpServletRequest and MockHttpServletResponse and directly send this mock request to
the controllers to do the unit testing, now in Spring 3.2 there is a new test
framework which is specially used for testing Spring MVC. It is Spring MVC Test framework. With this test framework you can test your
controllers just like you test them within a web container but without starting
a web container.
Spring MVC Test framework provides much nicer testing framework
to cover many aspects of testing in Spring MVC. With this framework apart from testing
business logic within controllers we can also test inbound/outbound
request/response serialization (such as JSON request to Java and Java to JSON
response), request mapping, request validation, content negotiation, exception
handling and etc.
In order to use it
you can add the below dependency into your project POM file.
<properties>
<spring.version>3.2.0.RELEASE</spring.version>
</properties>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${spring.version}</version>
<scope>provided</scope>
</dependency>
|
The key part of Spring MVC Test framework is MockMVC.
MockMVC will simulate the
internals of Spring MVC and MockMVC
is the entry point for Spring MVS testing.
The first step of using Spring MVC testing is to instantiate
one instance of MockMVC.
@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration(locations={"file:src/main/webapp/WEB-INF/mvc-dispatcher-servlet.xml",
"classpath:/META-INF/applicationContextForTest.xml"})
@TestExecutionListeners({
DependencyInjectionTestExecutionListener.class})
public
class ProductControllerTest {
@Autowired
private WebApplicationContext wac;
private MockMvc
mockMvc;
@Before
public void setup() {
this.mockMvc
= MockMvcBuilders.webAppContextSetup(this.wac).build();
// Details are omitted for brevity
}
}
|
After MockMVC is
created you can use MockMVC to do the
testing. You can create one HTTP
request and specify all the details of the request such as HTTP method, content
type, request parameters and etc. Then you can send this request through MockMVC and then verify the results.
RequestBuilder
requestBuilder = MockMvcRequestBuilders.get("/welocme");
this.mockMvc.perform(requestBuilder).
andExpect(MockMvcResultMatchers.status().isOk()).
andExpect(MockMvcResultMatchers.model().attribute("welcome_message",
"Welcome to use product: DELL Insprson")).
andExpect(MockMvcResultMatchers.model().size(1)).
andExpect(MockMvcResultMatchers.view().name("welcome"));
|
Mockito
Mockito is another testing mock framework. I find that it is quite easy and convenient
to use. First if you want to use it in
your project you can the following dependency to your project POM file. Here I use the version 1.9.5.
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-all</artifactId>
<version>1.9.5</version>
<scope>test</scope>
</dependency>
|
Mockito provides some annotations to simplify writing the
testing codes. @Mock and @InjectMocks
are the two annotations I am going to use.
@Mock is used to annotate the object to be mocked. In the unit testing when testing a method of
one object which has the dependency on another object, this dependent object
needs to be mocked. In my project there
is class called ProductController and another class ProductService.
ProductController uses ProductService to do actual work to serve the
requests ProductController is supposed to handle.
@Controller
@RequestMapping("/products")
public
class ProductController {
@Autowired
private ProductService productService;
// Details are omitted for brevity
}
|
When I test ProductController I have ProductService
as mock service so it can mock different responses from ProductService. Using @Mock annotation from Mockito it can
simply be done in my test class as the below:
@Mock
ProductService mockProductService;
|
Another step is to put this mock object into the object to
be tested. Mockito provides another very
useful annotation @InjectMocks to do. @InjectMocks is to annotate the object
where the mock object is injected into.
In my example it is ProductController. and I have the
following:
@InjectMocks
ProductController productController;
|
But in order to make mock object injection really happen
there is another thing needed to be done: invoke MockitoAnnotations.initMocks
method. So my test class will be as the
below:
public
class ProductControllerTest {
@InjectMocks
private ProductController productController;
@Mock
private ProductService
mockproductService;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
}
}
|
The basic functions of mock framework is to return a given
results when a specific method is invoke.
In Mockito it is done using Mockito.when(...).thenReturn(...)
public
class ProductControllerTest {
@InjectMocks
private ProductController productController;
@Mock
private ProductService
mockproductService;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
List<Product> products = new
ArrayList<Product>();
Product product1 = new Product();
product1.setId(new Long(1));
Product product2 = new Product();
product2.setId(new Long(2));
products.add(product1);
products.add(product2);
Mockito.when(mockproductService.findAllProducts()).thenReturn(products);
}
}
|
In the above example when findAllProducts
method in ProductService
is invoked the mocked ProductService will return a list
of Products specified before.
Put all together
The below is the code snippet that shows using both Spring MVC Testing and Mockito together for testing a controller.
@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration(locations={"file:src/main/webapp/WEB-INF/mvc-dispatcher-servlet.xml",
"classpath:/META-INF/applicationContextForTest.xml"})
@TestExecutionListeners({
DependencyInjectionTestExecutionListener.class})
public
class ProductControllerTest {
@Autowired
private WebApplicationContext wac;
private MockMvc mockMvc;
@InjectMocks
private ProductController productController;
@Mock
private ProductService
mockproductService;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
List<Product> products = new
ArrayList<Product>();
Product product1 = new Product();
product1.setId(new Long(1));
Product product2 = new Product();
product2.setId(new Long(2));
products.add(product1);
products.add(product2);
Mockito.when(mockproductService.findAllProducts()).thenReturn(products);
this.mockMvc =
MockMvcBuilders.webAppContextSetup(this.wac).build();
}
@Test
public void testMethod() throws Exception
{
List<Product> products = new
ArrayList<Product>();
Product product1 = new Product();
product1.setId(new Long(1));
Product product2 = new Product();
product2.setId(new Long(2));
products.add(product1);
products.add(product2);
RequestBuilder requestBuilder =
MockMvcRequestBuilders.get("/products");
this.mockMvc.perform(requestBuilder).
andExpect(MockMvcResultMatchers.status().isOk()).
andExpect(MockMvcResultMatchers.model().attribute("Products",
products)).
andExpect(MockMvcResultMatchers.model().size(2)).
andExpect(MockMvcResultMatchers.view().name("show_products"));
}
}
|
