Spring MVC测试框架详解

Spring MVC测试框架详解——服务端测试

随着RESTful Web Service的流行，测试对外的Service是否满足期望也变的必要的。从Spring 3.2开始Spring了Spring Web测试框架，如果版本低于3.2，请使用spring-test-mvc项目（合并到spring3.2中了）。

 

Spring MVC测试框架提供了对服务器端和客户端（基于RestTemplate的客户端）提供了支持。

 

对于服务器端：在Spring 3.2之前，我们测试时一般都是直接new控制器，注入依赖，然后判断返回值。但是我们无法连同Spring MVC的基础设施（如DispatcherServlet调度、类型转换、数据绑定、拦截器等）一起测试，另外也没有现成的方法测试如最终渲染的视图（@ResponseBody生成的JSON/XML、JSP、Velocity等）内容是否正确。从Spring 3.2开始这些事情都可以完成了。而且可以测试完整的Spring MVC流程，即从URL请求到控制器处理，再到视图渲染都可以测试。

 

对于客户端：不需要启动服务器即可测试我们的RESTful 服务。

 

1 服务器端测试

我的环境：JDK7、Maven3、spring4、Servlet3

 

首先添加依赖

如下是spring-context和spring-webmvc依赖：

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>${spring.version}</version>
</dependency>

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>${spring.version}</version>
</dependency>

版本信息：<spring.version>4.0.0.RELEASE</spring.version>

 

如下是测试相关的依赖（junit、hamcrest、mockito、spring-test）：

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>${junit.version}</version>
    <scope>test</scope>
</dependency>

<dependency>
    <groupId>org.hamcrest</groupId>
    <artifactId>hamcrest-core</artifactId>
    <version>${hamcrest.core.version}/version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-core</artifactId>
    <version>${mockito.core.version}</version>
    <scope>test</scope>
</dependency>

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>${spring.version}</version>
    <scope>test</scope>
</dependency>

版本信息：<junit.version>4.11</junit.version>、<hamcrest.core.version>1.3</hamcrest.core.version>、<mockito.core.version>1.9.5</mockito.core.version>

 

然后准备测试相关配置

实体：

package com.sishuok.mvc.entity;
import java.io.Serializable;
public class User implements Serializable {
    private Long id;
    private String name;
    //省略getter/setter等
}

 

控制器：

package com.sishuok.mvc.controller;
//省略import
@Controller
@RequestMapping("/user")
public class UserController {

    @RequestMapping("/{id}")
    public ModelAndView view(@PathVariable("id") Long id, HttpServletRequest req) {
        User user = new User();
        user.setId(id);
        user.setName("zhang");

        ModelAndView mv = new ModelAndView();
        mv.addObject("user", user);
        mv.setViewName("user/view");
        return mv;
    }
}

 

XML风格配置：

spring-config.xml：加载非web层组件 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
       ">
    <!-- 通过web.xml中的 org.springframework.web.context.ContextLoaderListener 加载的  -->
    <!-- 请参考 http://jinnianshilongnian.iteye.com/blog/1602617  -->
    <context:component-scan base-package="com.sishuok.mvc">
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>
</beans>

 

spring-mvc.xml：加载和配置web层组件 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd
       ">
    <!-- 通过web.xml中的 org.springframework.web.servlet.DispatcherServlet 加载的  -->
    <!-- 请参考 http://jinnianshilongnian.iteye.com/blog/1602617  -->
    <context:component-scan base-package="com.sishuok.mvc" use-default-filters="false">
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>
    <mvc:annotation-driven/>
    <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

 

web.xml配置：此处就不贴了，请前往github查看。

 

对于context:component-scan注意事项请参考《context:component-scan扫描使用上的容易忽略的use-default-filters》和《第三章 DispatcherServlet详解 ——跟开涛学SpringMVC》。

 

等价的注解风格配置： 

AppConfig.java：等价于spring-config.xml

package com.sishuok.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.stereotype.Controller;

@Configuration
@ComponentScan(basePackages = "com.sishuok.mvc", excludeFilters = {
        @ComponentScan.Filter(type = FilterType.ANNOTATION, value = {Controller.class})
})
public class AppConfig {
}

 

MvcConfig.java：等价于spring-mvc.xml

package com.sishuok.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.stereotype.Controller;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;
import org.springframework.web.servlet.view.InternalResourceViewResolver;

@Configuration
@EnableWebMvc
@ComponentScan(basePackages = "com.sishuok.mvc", useDefaultFilters = false, includeFilters = {
        @ComponentScan.Filter(type = FilterType.ANNOTATION, value = {Controller.class})
})
public class MvcConfig extends WebMvcConfigurationSupport {

    @Bean
    public ViewResolver viewResolver() {
        InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
        viewResolver.setPrefix("/WEB-INF/jsp/");
        viewResolver.setSuffix(".jsp");
        return viewResolver;
    }

}

WebInitializer.java：注册相应的web.xml中的组件

package com.sishuok.config;

import org.springframework.web.WebApplicationInitializer;
import org.springframework.web.context.ContextLoaderListener;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.filter.CharacterEncodingFilter;
import org.springframework.web.servlet.DispatcherServlet;

import javax.servlet.DispatcherType;
import javax.servlet.FilterRegistration;
import javax.servlet.ServletException;
import javax.servlet.ServletRegistration;
import java.util.EnumSet;

public class WebInitializer implements WebApplicationInitializer {

    @Override
    public void onStartup(javax.servlet.ServletContext sc) throws ServletException {

        AnnotationConfigWebApplicationContext rootContext = new AnnotationConfigWebApplicationContext();
        rootContext.register(AppConfig.class);
        sc.addListener(new ContextLoaderListener(rootContext));

        //2、springmvc上下文
        AnnotationConfigWebApplicationContext springMvcContext = new AnnotationConfigWebApplicationContext();
        springMvcContext.register(MvcConfig.class);
        //3、DispatcherServlet
        DispatcherServlet dispatcherServlet = new DispatcherServlet(springMvcContext);
        ServletRegistration.Dynamic dynamic = sc.addServlet("dispatcherServlet", dispatcherServlet);
        dynamic.setLoadOnStartup(1);
        dynamic.addMapping("/");

        //4、CharacterEncodingFilter
        CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter();
        characterEncodingFilter.setEncoding("utf-8");
        FilterRegistration filterRegistration =
                sc.addFilter("characterEncodingFilter", characterEncodingFilter);
        filterRegistration.addMappingForUrlPatterns(EnumSet.of(DispatcherType.REQUEST), false, "/");

    }
}

对于WebInitializer，请参考《Spring4新特性——Groovy Bean定义DSL》

到此基本的配置就搞定了，接下来看看如何测试吧。 

 

1.1 以前的测试方式

package com.sishuok.mvc.controller;
//省略import
public class UserControllerTest {

    private UserController userController;

    @Before
    public void setUp() {
        userController = new UserController();
        //安装userCtroller依赖 比如userService
    }

    @Test
    public void testView() {
        MockHttpServletRequest req = new MockHttpServletRequest();
        ModelAndView mv = userController.view(1L, req);

        ModelAndViewAssert.assertViewName(mv, "user/view");
        ModelAndViewAssert.assertModelAttributeAvailable(mv, "user");

    }
}

准备控制器：我们通过new方式创建一个，然后手工查找依赖注入进去（比如从spring容器获取/new的）；

Mock Request：此处使用Spring提供的Mock API模拟一个HttpServletRequest，其他的Servlet API也提供了相应的Mock类，具体请查看Javadoc；

访问控制器方法：通过直接调用控制器方法进行访问，此处无法验证Spring MVC框架的类型转换、数据验证等是否正常；

ModelAndViewAssert：通过这个Assert API验证我们的返回值是否正常；

 

对于单元测试步骤请参考：加速Java应用开发速度3——单元/集成测试+CI 

 

这种方式的缺点已经说过了，如不能走Spring MVC完整流程（不能走Servlet的过滤器链、SpringMVC的类型转换、数据验证、数据绑定、拦截器等等），如果做基本的测试没问题，这种方式就是纯粹的单元测试，我们想要的功能其实是一种集成测试，不过后续部分不区分。

 

1.2 安装测试环境

spring mvc测试框架提供了两种方式，独立安装和集成Web环境测试（此种方式并不会集成真正的web环境，而是通过相应的Mock API进行模拟测试，无须启动服务器）。

 

独立测试方式

public class UserControllerStandaloneSetupTest {
    private MockMvc mockMvc;
    @Before
    public void setUp() {
        UserController userController = new UserController();
        mockMvc = MockMvcBuilders.standaloneSetup(userController).build();
    }
}

1、首先自己创建相应的控制器，注入相应的依赖

2、通过MockMvcBuilders.standaloneSetup模拟一个Mvc测试环境，通过build得到一个MockMvc

3、MockMvc：是我们以后测试时经常使用的API，后边介绍

 

集成Web环境方式

//XML风格
@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration(value = "src/main/webapp")
@ContextHierarchy({
        @ContextConfiguration(name = "parent", locations = "classpath:spring-config.xml"),
        @ContextConfiguration(name = "child", locations = "classpath:spring-mvc.xml")
})

//注解风格
//@RunWith(SpringJUnit4ClassRunner.class)
//@WebAppConfiguration(value = "src/main/webapp")
//@ContextHierarchy({
//        @ContextConfiguration(name = "parent", classes = AppConfig.class),
//        @ContextConfiguration(name = "child", classes = MvcConfig.class)
//})
public class UserControllerWebAppContextSetupTest {

    @Autowired
    private WebApplicationContext wac;
    private MockMvc mockMvc;

    @Before
    public void setUp() {
        mockMvc = MockMvcBuilders.webAppContextSetup(wac).build();
    }
}

1、@WebAppConfiguration：测试环境使用，用来表示测试环境使用的ApplicationContext将是WebApplicationContext类型的；value指定web应用的根；

2、@ContextHierarchy：指定容器层次，即spring-config.xml是父容器，而spring-mvc.xml是子容器，请参考《第三章 DispatcherServlet详解 ——跟开涛学SpringMVC》

3、通过@Autowired WebApplicationContext wac：注入web环境的ApplicationContext容器；

4、然后通过MockMvcBuilders.webAppContextSetup(wac).build()创建一个MockMvc进行测试；

 

到此测试环境就搭建完成了，根据需要选择使用哪种方式即可。相关配置请前往github查看。

 

1.3、HelloWorld

@Test
public void testView() throws Exception {
    MvcResult result = mockMvc.perform(MockMvcRequestBuilders.get("/user/1"))
            .andExpect(MockMvcResultMatchers.view().name("user/view"))
            .andExpect(MockMvcResultMatchers.model().attributeExists("user"))
            .andDo(MockMvcResultHandlers.print())
            .andReturn();

    Assert.assertNotNull(result.getModelAndView().getModel().get("user"));
}

1、mockMvc.perform执行一个请求；

2、MockMvcRequestBuilders.get("/user/1")构造一个请求

3、ResultActions.andExpect添加执行完成后的断言

4、ResultActions.andDo添加一个结果处理器，表示要对结果做点什么事情，比如此处使用MockMvcResultHandlers.print()输出整个响应结果信息。

5、ResultActions.andReturn表示执行完成后返回相应的结果。

 

整个测试过程非常有规律：

1、准备测试环境

2、通过MockMvc执行请求

3.1、添加验证断言

3.2、添加结果处理器

3.3、得到MvcResult进行自定义断言/进行下一步的异步请求

4、卸载测试环境

 

对于单元测试步骤请参考：加速Java应用开发速度3——单元/集成测试+CI。

 

1.4、了解测试API

Spring mvc测试框架提供了测试MVC需要的API，主要包括Servlet/JSP Mock、MockMvcBuilder、MockMvc、RequestBuilder、ResultMatcher、ResultHandler、MvcResult等。另外提供了几个静态工厂方法便于测试：MockMvcBuilders、MockMvcRequestBuilders、MockMvcResultMatchers、MockMvcResultHandlers。在使用时请使用静态方法导入方便测试，如：

import static org.springframework.test.web.servlet.setup.MockMvcBuilders.*;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.*;

 

Servlet/JSP API Mock 

提供了对Servlet 3 相应API的Mock，如：

MockServletContext

MockHttpServletRequest

MockHttpServletResponse

……

具体请查看spring-test模块的org.springframework.mock.web包。

 

 

MockMvcBuilder/MockMvcBuilders

MockMvcBuilder是用来构造MockMvc的构造器，其主要有两个实现：StandaloneMockMvcBuilder和DefaultMockMvcBuilder，分别对应之前的两种测试方式。对于我们来说直接使用静态工厂MockMvcBuilders创建即可：

MockMvcBuilders.webAppContextSetup(WebApplicationContext context)：指定WebApplicationContext，将会从该上下文获取相应的控制器并得到相应的MockMvc；

MockMvcBuilders.standaloneSetup(Object... controllers)：通过参数指定一组控制器，这样就不需要从上下文获取了；

 

其中DefaultMockMvcBuilder还提供了如下API：

addFilters(Filter... filters)/addFilter(Filter filter, String... urlPatterns)：添加javax.servlet.Filter过滤器

defaultRequest(RequestBuilder requestBuilder)：默认的RequestBuilder，每次执行时会合并到自定义的RequestBuilder中，即提供公共请求数据的；

alwaysExpect(ResultMatcher resultMatcher)：定义全局的结果验证器，即每次执行请求时都进行验证的规则；

alwaysDo(ResultHandler resultHandler)：定义全局结果处理器，即每次请求时都进行结果处理；

dispatchOptions：DispatcherServlet是否分发OPTIONS请求方法到控制器；

 

StandaloneMockMvcBuilder继承了DefaultMockMvcBuilder，又提供了如下API：

setMessageConverters(HttpMessageConverter<?>...messageConverters)：设置HTTP消息转换器；

setValidator(Validator validator)：设置验证器；

setConversionService(FormattingConversionService conversionService)：设置转换服务；

addInterceptors(HandlerInterceptor... interceptors)/addMappedInterceptors(String[] pathPatterns, HandlerInterceptor... interceptors)：添加spring mvc拦截器；

setContentNegotiationManager(ContentNegotiationManager contentNegotiationManager)：设置内容协商管理器；

setAsyncRequestTimeout(long timeout)：设置异步超时时间；

setCustomArgumentResolvers(HandlerMethodArgumentResolver... argumentResolvers)：设置自定义控制器方法参数解析器；

setCustomReturnValueHandlers(HandlerMethodReturnValueHandler... handlers)：设置自定义控制器方法返回值处理器；

setHandlerExceptionResolvers(List<HandlerExceptionResolver> exceptionResolvers)/setHandlerExceptionResolvers(HandlerExceptionResolver... exceptionResolvers)：设置异常解析器；

setViewResolvers(ViewResolver...resolvers)：设置视图解析器；

setSingleView(View view)：设置单个视图，即视图解析时总是解析到这一个（仅适用于只有一个视图的情况）；

setLocaleResolver(LocaleResolver localeResolver)：设置Local解析器；

setFlashMapManager(FlashMapManager flashMapManager)：设置FlashMapManager，如存储重定向数据；

setUseSuffixPatternMatch(boolean useSuffixPatternMatch)：设置是否是后缀模式匹配，如“/user”是否匹配"/user.*"，默认真即匹配；

setUseTrailingSlashPatternMatch(boolean useTrailingSlashPatternMatch)：设置是否自动后缀路径模式匹配，如“/user”是否匹配“/user/”，默认真即匹配；

addPlaceHolderValue(String name, String value) ：添加request mapping中的占位符替代；

 

因为StandaloneMockMvcBuilder不会加载Spring MVC配置文件，因此就不会注册我们需要的一些组件，因此就提供了如上API用于注册我们需要的相应组件。

 

MockMvc

使用之前的MockMvcBuilder.build()得到构建好的MockMvc；这个是mvc测试的核心API，对于该API的使用方式如下：

MvcResult result = mockMvc.perform(MockMvcRequestBuilders.get("/user/1"))
       .andExpect(MockMvcResultMatchers.view().name("user/view"))
       .andExpect(MockMvcResultMatchers.model().attributeExists("user"))
       .andDo(MockMvcResultHandlers.print())
       .andReturn();

perform：执行一个RequestBuilder请求，会自动执行SpringMVC的流程并映射到相应的控制器执行处理；

andExpect：添加ResultMatcher验证规则，验证控制器执行完成后结果是否正确；

andDo：添加ResultHandler结果处理器，比如调试时打印结果到控制台；

andReturn：最后返回相应的MvcResult；然后进行自定义验证/进行下一步的异步处理；

 

另外还提供了以下API：

setDefaultRequest：设置默认的RequestBuilder，用于在每次perform执行相应的RequestBuilder时自动把该默认的RequestBuilder合并到perform的RequestBuilder中；

setGlobalResultMatchers：设置全局的预期结果验证规则，如我们通过MockMvc测试多个控制器时，假设它们都想验证某个规则时，就可以使用这个；

setGlobalResultHandlers：设置全局的ResultHandler结果处理器；

  

RequestBuilder/MockMvcRequestBuilders

从名字可以看出，RequestBuilder用来构建请求的，其提供了一个方法buildRequest(ServletContext servletContext)用于构建MockHttpServletRequest；其主要有两个子类MockHttpServletRequestBuilder和MockMultipartHttpServletRequestBuilder（如文件上传使用），即用来Mock客户端请求需要的所有数据。

 

MockMvcRequestBuilders主要API：

MockHttpServletRequestBuilder get(String urlTemplate, Object... urlVariables)：根据uri模板和uri变量值得到一个GET请求方式的MockHttpServletRequestBuilder；如get("/user/{id}", 1L)；

MockHttpServletRequestBuilder post(String urlTemplate, Object... urlVariables)：同get类似，但是是POST方法；

MockHttpServletRequestBuilder put(String urlTemplate, Object... urlVariables)：同get类似，但是是PUT方法；

MockHttpServletRequestBuilder delete(String urlTemplate, Object... urlVariables) ：同get类似，但是是DELETE方法；

MockHttpServletRequestBuilder options(String urlTemplate, Object... urlVariables)：同get类似，但是是OPTIONS方法；

MockHttpServletRequestBuilder request(HttpMethod httpMethod, String urlTemplate, Object... urlVariables)：提供自己的Http请求方法及uri模板和uri变量，如上API都是委托给这个API；

MockMultipartHttpServletRequestBuilder fileUpload(String urlTemplate, Object... urlVariables)：提供文件上传方式的请求，得到MockMultipartHttpServletRequestBuilder；

RequestBuilder asyncDispatch(final MvcResult mvcResult)：创建一个从启动异步处理的请求的MvcResult进行异步分派的RequestBuilder；

 

接下来再看看MockHttpServletRequestBuilder和MockMultipartHttpServletRequestBuilder API：

MockHttpServletRequestBuilder API：

MockHttpServletRequestBuilder header(String name, Object... values)/MockHttpServletRequestBuilder headers(HttpHeaders httpHeaders)：添加头信息；

MockHttpServletRequestBuilder contentType(MediaType mediaType)：指定请求的contentType头信息；

MockHttpServletRequestBuilder accept(MediaType... mediaTypes)/MockHttpServletRequestBuilder accept(String... mediaTypes)：指定请求的Accept头信息；

MockHttpServletRequestBuilder content(byte[] content)/MockHttpServletRequestBuilder content(String content)：指定请求Body体内容；

MockHttpServletRequestBuilder cookie(Cookie... cookies)：指定请求的Cookie；

MockHttpServletRequestBuilder locale(Locale locale)：指定请求的Locale；

MockHttpServletRequestBuilder characterEncoding(String encoding)：指定请求字符编码；

MockHttpServletRequestBuilder requestAttr(String name, Object value) ：设置请求属性数据；

MockHttpServletRequestBuilder sessionAttr(String name, Object value)/MockHttpServletRequestBuilder sessionAttrs(Map<String, Object> sessionAttributes)：设置请求session属性数据；

MockHttpServletRequestBuilder flashAttr(String name, Object value)/MockHttpServletRequestBuilder flashAttrs(Map<String, Object> flashAttributes)：指定请求的flash信息，比如重定向后的属性信息；

MockHttpServletRequestBuilder session(MockHttpSession session) ：指定请求的Session；

MockHttpServletRequestBuilder principal(Principal principal) ：指定请求的Principal；

MockHttpServletRequestBuilder contextPath(String contextPath) ：指定请求的上下文路径，必须以“/”开头，且不能以“/”结尾；

MockHttpServletRequestBuilder pathInfo(String pathInfo) ：请求的路径信息，必须以“/”开头；

MockHttpServletRequestBuilder secure(boolean secure)：请求是否使用安全通道；

MockHttpServletRequestBuilder with(RequestPostProcessor postProcessor)：请求的后处理器，用于自定义一些请求处理的扩展点；

 

MockMultipartHttpServletRequestBuilder继承自MockHttpServletRequestBuilder，又提供了如下API：

MockMultipartHttpServletRequestBuilder file(String name, byte[] content)/MockMultipartHttpServletRequestBuilder file(MockMultipartFile file)：指定要上传的文件；

 

ResultActions

调用MockMvc.perform(RequestBuilder requestBuilder)后将得到ResultActions，通过ResultActions完成如下三件事：

ResultActions andExpect(ResultMatcher matcher) ：添加验证断言来判断执行请求后的结果是否是预期的；

ResultActions andDo(ResultHandler handler) ：添加结果处理器，用于对验证成功后执行的动作，如输出下请求/结果信息用于调试；

MvcResult andReturn() ：返回验证成功后的MvcResult；用于自定义验证/下一步的异步处理；

 

ResultMatcher/MockMvcResultMatchers

ResultMatcher用来匹配执行完请求后的结果验证，其就一个match(MvcResult result)断言方法，如果匹配失败将抛出相应的异常；spring mvc测试框架提供了很多***ResultMatchers来满足测试需求。注意这些***ResultMatchers并不是ResultMatcher的子类，而是返回ResultMatcher实例的。Spring mvc测试框架为了测试方便提供了MockMvcResultMatchers静态工厂方法方便操作；具体的API如下：

HandlerResultMatchers handler()：请求的Handler验证器，比如验证处理器类型/方法名；此处的Handler其实就是处理请求的控制器；

RequestResultMatchers request()：得到RequestResultMatchers验证器；

ModelResultMatchers model()：得到模型验证器；

ViewResultMatchers view()：得到视图验证器；

FlashAttributeResultMatchers flash()：得到Flash属性验证；

StatusResultMatchers status()：得到响应状态验证器；

HeaderResultMatchers header()：得到响应Header验证器；

CookieResultMatchers cookie()：得到响应Cookie验证器；

ContentResultMatchers content()：得到响应内容验证器；

JsonPathResultMatchers jsonPath(String expression, Object ... args)/ResultMatcher jsonPath(String expression, Matcher<T> matcher)：得到Json表达式验证器；

XpathResultMatchers xpath(String expression, Object... args)/XpathResultMatchers xpath(String expression, Map<String, String> namespaces, Object... args)：得到Xpath表达式验证器；

ResultMatcher forwardedUrl(final String expectedUrl)：验证处理完请求后转发的url（绝对匹配）；

ResultMatcher forwardedUrlPattern(final String urlPattern)：验证处理完请求后转发的url（Ant风格模式匹配，@since spring4）；

ResultMatcher redirectedUrl(final String expectedUrl)：验证处理完请求后重定向的url（绝对匹配）；

ResultMatcher redirectedUrlPattern(final String expectedUrl)：验证处理完请求后重定向的url（Ant风格模式匹配，@since spring4）；

 

得到相应的***ResultMatchers后，接着再调用其相应的API得到ResultMatcher，如ModelResultMatchers.attributeExists(final String... names)判断Model属性是否存在。具体请查看相应的API。再次就不一一列举了。

 

 

ResultHandler/MockMvcResultHandlers

ResultHandler用于对处理的结果进行相应处理的，比如输出整个请求/响应等信息方便调试，Spring mvc测试框架提供了MockMvcResultHandlers静态工厂方法，该工厂提供了ResultHandler print()返回一个输出MvcResult详细信息到控制台的ResultHandler实现。

 

 

MvcResult

即执行完控制器后得到的整个结果，并不仅仅是返回值，其包含了测试时需要的所有信息，如：

MockHttpServletRequest getRequest()：得到执行的请求；

MockHttpServletResponse getResponse()：得到执行后的响应；

Object getHandler()：得到执行的处理器，一般就是控制器；

HandlerInterceptor[] getInterceptors()：得到对处理器进行拦截的拦截器；

ModelAndView getModelAndView()：得到执行后的ModelAndView；

Exception getResolvedException()：得到HandlerExceptionResolver解析后的异常；

FlashMap getFlashMap()：得到FlashMap；

Object getAsyncResult()/Object getAsyncResult(long timeout)：得到异步执行的结果；

 

1.5 测试示例

测试普通控制器 

//测试普通控制器
mockMvc.perform(get("/user/{id}", 1)) //执行请求
        .andExpect(model().attributeExists("user")) //验证存储模型数据
        .andExpect(view().name("user/view")) //验证viewName
        .andExpect(forwardedUrl("/WEB-INF/jsp/user/view.jsp"))//验证视图渲染时forward到的jsp
        .andExpect(status().isOk())//验证状态码
        .andDo(print()); //输出MvcResult到控制台

 

测试普通控制器，但是URL错误，即404

//找不到控制器，404测试
MvcResult result = mockMvc.perform(get("/user2/{id}", 1)) //执行请求
        .andDo(print())
        .andExpect(status().isNotFound()) //验证控制器不存在
        .andReturn();
Assert.assertNull(result.getModelAndView()); //自定义断言

 

得到MvcResult自定义验证    

MvcResult result = mockMvc.perform(get("/user/{id}", 1))//执行请求
        .andReturn(); //返回MvcResult
Assert.assertNotNull(result.getModelAndView().getModel().get("user")); //自定义断言

 

验证请求参数绑定到模型数据及Flash属性 

mockMvc.perform(post("/user").param("name", "zhang")) //执行传递参数的POST请求(也可以post("/user?name=zhang"))
        .andExpect(handler().handlerType(UserController.class)) //验证执行的控制器类型
        .andExpect(handler().methodName("create")) //验证执行的控制器方法名
        .andExpect(model().hasNoErrors()) //验证页面没有错误
        .andExpect(flash().attributeExists("success")) //验证存在flash属性
        .andExpect(view().name("redirect:/user")); //验证视图

 

验证请求参数验证失败出错  

mockMvc.perform(post("/user").param("name", "admin")) //执行请求
        .andExpect(model().hasErrors()) //验证模型有错误
        .andExpect(model().attributeDoesNotExist("name")) //验证存在错误的属性
        .andExpect(view().name("showCreateForm")); //验证视图

 

文件上传 

//文件上传
byte[] bytes = new byte[] {1, 2};
mockMvc.perform(fileUpload("/user/{id}/icon", 1L).file("icon", bytes)) //执行文件上传
        .andExpect(model().attribute("icon", bytes)) //验证属性相等性
        .andExpect(view().name("success")); //验证视图

 

JSON请求/响应验证

测试时需要安装jackson Json和JsonPath依赖： 

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>${jackson2.version}</version>
</dependency>

<dependency>
    <groupId>com.jayway.jsonpath</groupId>
    <artifactId>json-path</artifactId>
    <version>${jsonpath.version}</version>
    <scope>test</scope>
</dependency>

版本：<jsonpath.version>0.9.0</jsonpath.version>、<jackson2.version>2.2.3</jackson2.version> 

String requestBody = "{\"id\":1, \"name\":\"zhang\"}";
mockMvc.perform(post("/user")
            .contentType(MediaType.APPLICATION_JSON).content(requestBody)
            .accept(MediaType.APPLICATION_JSON)) //执行请求
        .andExpect(content().contentType(MediaType.APPLICATION_JSON)) //验证响应contentType
        .andExpect(jsonPath("$.id").value(1)); //使用Json path验证JSON 请参考http://goessner.net/articles/JsonPath/

String errorBody = "{id:1, name:zhang}";
MvcResult result = mockMvc.perform(post("/user")
        .contentType(MediaType.APPLICATION_JSON).content(errorBody)
        .accept(MediaType.APPLICATION_JSON)) //执行请求
        .andExpect(status().isBadRequest()) //400错误请求
        .andReturn();

Assert.assertTrue(HttpMessageNotReadableException.class.isAssignableFrom(result.getResolvedException().getClass()));//错误的请求内容体

 

XML请求/响应验证

测试时需要安装spring oxm和xstream依赖： 

<dependency>
    <groupId>com.thoughtworks.xstream</groupId>
    <artifactId>xstream</artifactId>
    <version>${xsream.version}</version>
    <scope>test</scope>
</dependency>

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-oxm</artifactId>
    <version>${spring.version}</version>
    <scope>test</scope>
</dependency>

版本：<xstream.version>1.4.4</xstream.version>

//XML请求/响应
String requestBody = "<user><id>1</id><name>zhang</name></user>";
mockMvc.perform(post("/user")
        .contentType(MediaType.APPLICATION_XML).content(requestBody)
        .accept(MediaType.APPLICATION_XML)) //执行请求
        .andDo(print())
        .andExpect(content().contentType(MediaType.APPLICATION_XML)) //验证响应contentType
        .andExpect(xpath("/user/id/text()").string("1")); //使用XPath表达式验证XML 请参考http://www.w3school.com.cn/xpath/

String errorBody = "<user><id>1</id><name>zhang</name>";
MvcResult result = mockMvc.perform(post("/user")
        .contentType(MediaType.APPLICATION_XML).content(errorBody)
        .accept(MediaType.APPLICATION_XML)) //执行请求
        .andExpect(status().isBadRequest()) //400错误请求
        .andReturn();

Assert.assertTrue(HttpMessageNotReadableException.class.isAssignableFrom(result.getResolvedException().getClass()));//错误的请求内容体

 

异常处理  

//异常处理
MvcResult result = mockMvc.perform(get("/user/exception")) //执行请求
        .andExpect(status().isInternalServerError()) //验证服务器内部错误
        .andReturn();

Assert.assertTrue(IllegalArgumentException.class.isAssignableFrom(result.getResolvedException().getClass()));

 

静态资源 

//静态资源
mockMvc.perform(get("/static/app.js")) //执行请求
        .andExpect(status().isOk()) //验证状态码200
        .andExpect(content().string(CoreMatchers.containsString("var")));//验证渲染后的视图内容包含var

mockMvc.perform(get("/static/app1.js")) //执行请求
        .andExpect(status().isNotFound());  //验证状态码404

异步测试 

//Callable
MvcResult result = mockMvc.perform(get("/user/async1?id=1&name=zhang")) //执行请求
        .andExpect(request().asyncStarted())
        .andExpect(request().asyncResult(CoreMatchers.instanceOf(User.class))) //默认会等10秒超时
        .andReturn();

mockMvc.perform(asyncDispatch(result))
        .andExpect(status().isOk())
        .andExpect(content().contentType(MediaType.APPLICATION_JSON))
        .andExpect(jsonPath("$.id").value(1));

//DeferredResult
result = mockMvc.perform(get("/user/async2?id=1&name=zhang")) //执行请求
        .andExpect(request().asyncStarted())
        .andExpect(request().asyncResult(CoreMatchers.instanceOf(User.class)))  //默认会等10秒超时
        .andReturn();

mockMvc.perform(asyncDispatch(result))
        .andExpect(status().isOk())
        .andExpect(content().contentType(MediaType.APPLICATION_JSON))
        .andExpect(jsonPath("$.id").value(1));

此处请在第一次请求时加上 andExpect(request().asyncResult(CoreMatchers.instanceOf(User.class)))这样会等待结果返回/超时，无须自己设置线程等待了；此处注意request().asyncResult一定是在第一次请求发出；然后第二次通过asyncDispatch进行异步请求。

 

添加自定义过滤器

mockMvc = webAppContextSetup(wac).addFilter(new MyFilter(), "/*").build();
mockMvc.perform(get("/user/1"))
        .andExpect(request().attribute("filter", true));

 

全局配置 

mockMvc = webAppContextSetup(wac)
        .defaultRequest(get("/user/1").requestAttr("default", true)) //默认请求 如果其是Mergeable类型的，会自动合并的哦mockMvc.perform中的RequestBuilder
        .alwaysDo(print())  //默认每次执行请求后都做的动作
        .alwaysExpect(request().attribute("default", true)) //默认每次执行后进行验证的断言
        .build();

mockMvc.perform(get("/user/1"))
        .andExpect(model().attributeExists("user"));

 

以上代码请参考 我的github。更多参考示例请 前往Spring github。

 

 

只要记住测试步骤，按照步骤操作，整个测试过程是非常容易理解的：

1、准备测试环境

2、通过MockMvc执行请求

3.1、添加验证断言

3.2、添加结果处理器

3.3、得到MvcResult进行自定义断言/进行下一步的异步请求

4、卸载测试环境

 

对于单元测试步骤请参考：加速Java应用开发速度3——单元/集成测试+CI。

 

下一篇介绍RestTemplate客户端测试。

 

 

欢迎加入spring群134755960进行交流。

 

参考

http://docs.spring.io/spring/docs/4.0.0.RELEASE/spring-framework-reference/htmlsingle/#spring-mvc-test-framework 

 

Spring MVC测试框架详解——客户端测试

 

上一篇《Spring MVC测试框架详解——服务端测试》已经介绍了服务端测试，接下来再看看如果测试Rest客户端，对于客户端测试以前经常使用的方法是启动一个内嵌的jetty/tomcat容器，然后发送真实的请求到相应的控制器；这种方式的缺点就是速度慢；自Spring 3.2开始提供了对RestTemplate的模拟服务器测试方式，也就是说使用RestTemplate测试时无须启动服务器，而是模拟一个服务器进行测试，这样的话速度是非常快的。

 

2 RestTemplate客户端测试

整个环境在上一篇《Spring MVC测试框架详解——服务端测试》基础上进行构建。

 

UserRestController控制器

@RestController
@RequestMapping("/users")
public class UserRestController {

    private UserService userService;

    @Autowired
    public UserRestController(UserService userService) {
        this.userService = userService;
    }

    @RequestMapping(value = "/{id}", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
    public User findById(@PathVariable("id") Long id) {
        return userService.findById(1L);
    }

    @RequestMapping(method = RequestMethod.POST)
    public ResponseEntity<User> save(@RequestBody User user, UriComponentsBuilder uriComponentsBuilder) {
        //save user
        user.setId(1L);
        MultiValueMap headers = new HttpHeaders();
        headers.set("Location", uriComponentsBuilder.path("/users/{id}").buildAndExpand(user.getId()).toUriString());
        return new ResponseEntity(user, headers, HttpStatus.CREATED);
    }

    @RequestMapping(value = "/{id}", method = RequestMethod.PUT, consumes = MediaType.APPLICATION_JSON_VALUE)
    @ResponseStatus(HttpStatus.NO_CONTENT)
    public void update(@RequestBody User user) {
        //update by id
    }

    @RequestMapping(value = "/{id}", method = RequestMethod.DELETE)
    public void delete(@PathVariable("id") Long id) {
        //delete by id
    }
}

 

UserService

package com.sishuok.mvc.service;

import com.sishuok.mvc.entity.User;

public interface UserService {
    public User findById(Long id);
}

 

UserServiceImpl

package com.sishuok.mvc.service;

import com.sishuok.mvc.entity.User;
import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl implements UserService {

    public User findById(Long id) {
        User user = new User();
        user.setId(id);
        user.setName("zhang");
        return user;
    }
}

 

AbstractClientTest测试基类

public abstract class AbstractClientTest {

    static RestTemplate restTemplate;
    ObjectMapper objectMapper; //JSON
    Jaxb2Marshaller marshaller; //XML
    String baseUri = "http://localhost:8080/users";

    @Before
    public void setUp() throws Exception {
        objectMapper = new ObjectMapper(); //需要添加jackson jar包

        marshaller = new Jaxb2Marshaller(); //需要添加jaxb2实现（如xstream）
        marshaller.setPackagesToScan(new String[] {"com.sishuok"});
        marshaller.afterPropertiesSet();

        restTemplate = new RestTemplate();
    }
}

  

 

2.1 使用内嵌Jetty方式启动容器进行

需要添加jetty依赖：

<dependency>
    <groupId>org.eclipse.jetty</groupId>
    <artifactId>jetty-server</artifactId>
    <version>${jetty.version}</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.eclipse.jetty</groupId>
    <artifactId>jetty-webapp</artifactId>
    <version>${jetty.version}</version>
    <scope>test</scope>
</dependency>

 

如果要测试JSP，请添加

<dependency>
    <groupId>org.eclipse.jetty</groupId>
    <artifactId>jetty-jsp</artifactId>
    <version>${jetty.version}</version>
    <scope>test</scope>
</dependency>

版本：<jetty.version>8.1.8.v20121106</jetty.version>

 

 

测试示例(EmbeddedJettyClientTest.java)

public class EmbeddedJettyClientTest extends AbstractClientTest {

    private static Server server;

    @BeforeClass
    public static void beforeClass() throws Exception {
        //创建一个server
        server = new Server(8080);
        WebAppContext context = new WebAppContext();
        String webapp = "spring-mvc-test/src/main/webapp";
        context.setDescriptor(webapp + "/WEB-INF/web.xml");  //指定web.xml配置文件
        context.setResourceBase(webapp);  //指定webapp目录
        context.setContextPath("/");
        context.setParentLoaderPriority(true);

        server.setHandler(context);
        server.start();
    }

    @AfterClass
    public static void afterClass() throws Exception {
        server.stop(); //当测试结束时停止服务器
    }

    @Test
    public void testFindById() throws Exception {
        ResponseEntity<User> entity = restTemplate.getForEntity(baseUri + "/{id}", User.class, 1L);

        assertEquals(HttpStatus.OK, entity.getStatusCode());
        assertThat(entity.getHeaders().getContentType().toString(), containsString(MediaType.APPLICATION_JSON_VALUE));
        assertThat(entity.getBody(), hasProperty("name", is("zhang")));
    }
    //省略其他，请参考github
}

 

 

此处通过内嵌Jetty启动一个web容器，然后使用RestTemplate访问真实的uri进行访问，然后进行断言验证。

 

这种方式的最大的缺点是如果我只测试UserRestController，其他的组件也会加载，属于集成测试，速度非常慢。伴随着Spring Boot项目的发布，我们可以使用Spring Boot进行测试。

 

2.2 使用Spring Boot进行测试

spring boot请参考spring boot官网 和《Spring Boot——2分钟构建spring web mvc REST风格HelloWorld》进行入门。通过spring boot我们可以只加载某个控制器进行测试。更加方便。

 

添加spring-boot-starter-web依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>${spring.boot.version}</version>
    <scope>test</scope>
</dependency>

版本：<spring.boot.version>0.5.0.BUILD-SNAPSHOT</spring.boot.version>，目前还处于SNAPSHOT版本。

 

 

测试示例(SpringBootClientTest.java)

public class SpringBootClientTest extends AbstractClientTest {

    private static ApplicationContext ctx;

    @BeforeClass
    public static void beforeClass() throws Exception {
        ctx = SpringApplication.run(Config.class); //启动服务器 加载Config指定的组件
    }

    @AfterClass
    public static void afterClass() throws Exception {
        SpringApplication.exit(ctx);//退出服务器
    }


    @Test
    public void testFindById() throws Exception {
        ResponseEntity<User> entity = restTemplate.getForEntity(baseUri + "/{id}", User.class, 1L);

        assertEquals(HttpStatus.OK, entity.getStatusCode());
        assertThat(entity.getHeaders().getContentType().toString(), containsString(MediaType.APPLICATION_JSON_VALUE));
        assertThat(entity.getBody(), hasProperty("name", is("zhang")));
    }

    //省略其他，请参考github

    @Configuration
    @EnableAutoConfiguration
    static class Config {

        @Bean
        public EmbeddedServletContainerFactory servletContainer() {
            return new JettyEmbeddedServletContainerFactory();
        }

        @Bean
        public UserRestController userController() {
            return new UserRestController(userService());
        }

        @Bean
        public UserService userService() {
            //Mockito请参考 http://stamen.iteye.com/blog/1470066
            UserService userService = Mockito.mock(UserService.class);
            User user = new User();
            user.setId(1L);
            user.setName("zhang");
            Mockito.when(userService.findById(Mockito.any(Long.class))).thenReturn(user);
            return userService;
//            return new UserServiceImpl(); //此处也可以返回真实的UserService实现
        }
    }

}

 

通过SpringApplication.run启动一个服务器，然后Config.xml是Spring的Java配置方式，此处只加载了UserRestController及其依赖UserService，对于UserService可以通过如Mockito进行模拟/也可以注入真实的实现，Mockito请参考《单元测试系列之2：模拟利器Mockito》。可以通过EmbeddedServletContainerFactory子类指定使用哪个内嵌的web容器（目前支持：jetty/tomcat）。

 

这种方式的优点就是速度比内嵌Jetty容器速度快，但是还是不够快且还需要启动一个服务器（开一个端口），因此Spring 3.2提供了模拟Server的方式进行测试。即服务器是通过Mock技术模拟的而不是真的启动一个服务器。

 

上述两种方式对于如果服务还不存在的情况也是无法测试的，因此Mock Server进行测试时最好的选择。

 

2.3 使用Mock Service Server进行测试

通过Mock Service Server方式的优点：

不需要启动服务器；

可以在服务还没写好的情况下进行测试，这样可以进行并行开发/测试。

 

对于Mock Service Server主要操作步骤：

1、通过MockRestServiceServer创建RestTemplate的Mock Server；

2、添加客户端请求断言，即用于判断客户端请求的断言；

3、添加服务端响应，即返回给客户端的响应；

 

为了方便测试，请静态导入：

import static org.springframework.test.web.client.*;
import static org.springframework.test.web.client.match.MockRestRequestMatchers.*;
import static org.springframework.test.web.client.response.MockRestResponseCreators.*;

 

测试示例(MockServerClientTest.java)

public class MockServerClientTest extends AbstractClientTest {

    private MockRestServiceServer mockServer;

    @Before
    public void setUp() throws Exception {
        super.setUp();
        //模拟一个服务器
        mockServer = createServer(restTemplate);
    }

    @Test
    public void testFindById() throws JsonProcessingException {
        String uri = baseUri + "/{id}";
        Long id = 1L;
        User user = new User();
        user.setId(1L);
        user.setName("zhang");
        String userJson = objectMapper.writeValueAsString(user);
        String requestUri = UriComponentsBuilder.fromUriString(uri).buildAndExpand(id).toUriString();

        //添加服务器端断言
        mockServer
                .expect(requestTo(requestUri))
                .andExpect(method(HttpMethod.GET))
                .andRespond(withSuccess(userJson, MediaType.APPLICATION_JSON));

        //2、访问URI（与API交互）
        ResponseEntity<User> entity = restTemplate.getForEntity(uri, User.class, id);

        //3.1、客户端验证
        assertEquals(HttpStatus.OK, entity.getStatusCode());
        assertThat(entity.getHeaders().getContentType().toString(), containsString(MediaType.APPLICATION_JSON_VALUE));
        assertThat(entity.getBody(), hasProperty("name", is("zhang")));

        //3.2、服务器端验证（验证之前添加的服务器端断言）
        mockServer.verify();
    }
    //省略其他，请参考github
}

  

测试步骤：

1、准备测试环境

首先创建RestTemplate，然后通过MockRestServiceServer.createServer(restTemplate)创建一个Mock Server，其会自动设置restTemplate的requestFactory为RequestMatcherClientHttpRequestFactory（restTemplate发送请求时都通过ClientHttpRequestFactory创建ClientHttpRequest）。

2、调用API

即restTemplate.getForEntity(uri, User.class, id)访问rest web service；

3、断言验证

3.1、客户端请求断言验证

如mockServer.expect(requestTo(requestUri)).andExpect(method(HttpMethod.GET))：即会验证之后通过restTemplate发送请求的uri是requestUri，且请求方法是GET；

3.2、服务端响应断言验证

首先通过mockServer.andRespond(withSuccess(new ObjectMapper().writeValueAsString(user), MediaType.APPLICATION_JSON));返回给客户端响应信息；

然后restTemplate就可以得到ResponseEntity，之后就可以通过断言进行验证了；

4、 卸载测试环境

 

对于单元测试步骤请参考：加速Java应用开发速度3——单元/集成测试+CI。

 

2.4 了解测试API

 

MockRestServiceServer

用来创建模拟服务器，其提供了createServer(RestTemplate restTemplate)，传入一个restTemplate即可创建一个MockRestServiceServer；在createServer中：

MockRestServiceServer mockServer = new MockRestServiceServer();
RequestMatcherClientHttpRequestFactory factory = mockServer.new RequestMatcherClientHttpRequestFactory();

restTemplate.setRequestFactory(factory);

即模拟一个ClientHttpRequestFactory，然后设置回RestTemplate，这样所有发送的请求都会到这个MockRestServiceServer。拿到MockRestServiceServer后，接着就需要添加请求断言和返回响应，然后进行验证。

 

 

RequestMatcher/MockRestRequestMatchers

RequestMatcher用于验证请求信息的验证器，即RestTemplate发送的请求的URI、请求方法、请求的Body体内容等等；spring mvc测试框架提供了很多***RequestMatchers来满足测试需求；类似于《Spring MVC测试框架详解——服务端测试》中的***ResultMatchers；注意这些***RequestMatchers并不是ResultMatcher的子类，而是返回RequestMatcher实例的。Spring mvc测试框架为了测试方便提供了MockRestRequestMatchers静态工厂方法方便操作；具体的API如下：

RequestMatcher anything()：即请求可以是任何东西；

RequestMatcher requestTo(final Matcher<String> matcher)/RequestMatcher requestTo(final String expectedUri)/RequestMatcher requestTo(final URI uri)：请求URI必须匹配某个Matcher/uri字符串/URI；

RequestMatcher method(final HttpMethod method)：请求方法必须匹配某个请求方法；

RequestMatcher header(final String name, final Matcher<? super String>... matchers)/RequestMatcher header(final String name, final String... expectedValues)：请求头必须匹配某个Matcher/某些值；

ContentRequestMatchers content()：获取内容匹配器，然后可以通过如contentType(String expectedContentType)进行ContentType匹配等，具体请参考javadoc；

JsonPathRequestMatchers jsonPath(String expression, Object ... args)/RequestMatcher jsonPath(String expression, Matcher<T> matcher)：获取Json路径匹配器/直接进行路径匹配，具体请参考javadoc；

XpathRequestMatchers xpath(String expression, Object... args)/XpathRequestMatchers xpath(String expression, Map<String, String> namespaces, Object... args)：获取Xpath表达式匹配器/直接进行Xpath表达式匹配，具体请参考javadoc；

 

ResponseCreator/MockRestResponseCreators

ResponseCreator用于创建返回给客户端的响应信息，spring mvc提供了静态工厂方法MockRestResponseCreators进行操作；具体的API如下：

DefaultResponseCreator withSuccess() ：返回给客户端200（OK）状态码响应；

DefaultResponseCreator withSuccess(String body, MediaType mediaType)/DefaultResponseCreator withSuccess(byte[] body, MediaType contentType)/DefaultResponseCreator withSuccess(Resource body, MediaType contentType)：返回给客户端200（OK）状态码响应，且返回响应内容体和MediaType；

DefaultResponseCreator withCreatedEntity(URI location)：返回201（Created）状态码响应，并返回响应头“Location=location"；

DefaultResponseCreator withNoContent() ：返回204（NO_CONTENT）状态码响应；

DefaultResponseCreator withBadRequest() ：返回400（BAD_REQUEST）状态码响应；

DefaultResponseCreator withUnauthorizedRequest() ：返回401（UNAUTHORIZED）状态码响应；

DefaultResponseCreator withServerError() ：返回500（SERVER_ERROR）状态码响应；

DefaultResponseCreator withStatus(HttpStatus status)：设置自定义状态码；

 

对于DefaultResponseCreator还提供了如下API：

DefaultResponseCreator body(String content) /DefaultResponseCreator body(byte[] content)/DefaultResponseCreator body(Resource resource)：内容体响应，对于String content 默认是UTF-8编码的；

DefaultResponseCreator contentType(MediaType mediaType) ：响应的ContentType；

DefaultResponseCreator location(URI location) ：响应的Location头；

DefaultResponseCreator headers(HttpHeaders headers)：设置响应头；

 

2.5 测试示例

 

测试查找

请参考之前的testFindById；

 

测试新增

提交JSON数据进行新增

@Test
public void testSaveWithJson() throws Exception {
    User user = new User();
    user.setId(1L);
    user.setName("zhang");
    String userJson = objectMapper.writeValueAsString(user);

    String uri = baseUri;
    String createdLocation = baseUri + "/" + 1;

    mockServer
            .expect(requestTo(uri))  //验证请求URI
            .andExpect(jsonPath("$.name").value(user.getName())) //验证请求的JSON数据
            .andRespond(withCreatedEntity(URI.create(createdLocation)).body(userJson).contentType(MediaType.APPLICATION_JSON)); //添加响应信息


    restTemplate.setMessageConverters(Arrays.<HttpMessageConverter<?>>asList(new MappingJackson2HttpMessageConverter()));
    ResponseEntity<User> responseEntity = restTemplate.postForEntity(uri, user, User.class);

    assertEquals(createdLocation, responseEntity.getHeaders().get("Location").get(0));
    assertEquals(HttpStatus.CREATED, responseEntity.getStatusCode());
    assertEquals(user, responseEntity.getBody());

    mockServer.verify();
}

提交XML数据进行新增

@Test
public void testSaveWithXML() throws Exception {
    User user = new User();
    user.setId(1L);
    user.setName("zhang");
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    marshaller.marshal(user, new StreamResult(bos));
    String userXml = bos.toString();

    String uri = baseUri;
    String createdLocation = baseUri + "/" + 1;

    mockServer
            .expect(requestTo(uri))  //验证请求URI
            .andExpect(xpath("/user/name/text()").string(user.getName())) //验证请求的JSON数据
            .andRespond(withCreatedEntity(URI.create(createdLocation)).body(userXml).contentType(MediaType.APPLICATION_XML)); //添加响应信息

    restTemplate.setMessageConverters(Arrays.<HttpMessageConverter<?>>asList(new Jaxb2RootElementHttpMessageConverter()));
    ResponseEntity<User> responseEntity = restTemplate.postForEntity(uri, user, User.class);

    assertEquals(createdLocation, responseEntity.getHeaders().get("Location").get(0));
    assertEquals(HttpStatus.CREATED, responseEntity.getStatusCode());

    assertEquals(user, responseEntity.getBody());

    mockServer.verify();
}

  

测试修改 

@Test
public void testUpdate() throws Exception {
    User user = new User();
    user.setId(1L);
    user.setName("zhang");

    String uri = baseUri + "/{id}";

    mockServer
            .expect(requestTo(uri))  //验证请求URI
            .andExpect(jsonPath("$.name").value(user.getName())) //验证请求的JSON数据
            .andRespond(withNoContent()); //添加响应信息

    restTemplate.setMessageConverters(Arrays.<HttpMessageConverter<?>>asList(new MappingJackson2HttpMessageConverter()));
    ResponseEntity responseEntity = restTemplate.exchange(uri, HttpMethod.PUT, new HttpEntity<>(user), (Class) null, user.getId());

    assertEquals(HttpStatus.NO_CONTENT, responseEntity.getStatusCode());

    mockServer.verify();
}

 

测试删除 

@Test
public void testDelete() throws Exception {
    String uri = baseUri + "/{id}";
    Long id = 1L;

    mockServer
            .expect(requestTo(baseUri + "/" + id))  //验证请求URI
            .andRespond(withSuccess()); //添加响应信息

    ResponseEntity responseEntity = restTemplate.exchange(uri, HttpMethod.DELETE, HttpEntity.EMPTY, (Class) null, id);
    assertEquals(HttpStatus.OK, responseEntity.getStatusCode());

    mockServer.verify();
}

 

通过Mock Server的最大好处是不需要启动服务器，且不需要服务预先存在就可以测试；如果服务已经存在，通过Spring Boot进行测试也是个不错的选择。

 

 

再来回顾下测试步骤

1、准备测试环境

首先创建RestTemplate，然后通过MockRestServiceServer.createServer(restTemplate)创建一个Mock Server，其会自动设置restTemplate的requestFactory为RequestMatcherClientHttpRequestFactory（restTemplate发送请求时都通过ClientHttpRequestFactory创建ClientHttpRequest）。

2、调用API

即restTemplate.getForEntity(uri, User.class, id)访问rest web service；

3、断言验证

3.1、客户端请求断言验证

如mockServer.expect(requestTo(requestUri)).andExpect(method(HttpMethod.GET))：即会验证之后通过restTemplate发送请求的uri是requestUri，且请求方法是GET；

3.2、服务端响应断言验证

首先通过mockServer.andRespond(withSuccess(new ObjectMapper().writeValueAsString(user), MediaType.APPLICATION_JSON));返回给客户端响应信息；

然后restTemplate就可以得到ResponseEntity，之后就可以通过断言进行验证了；

4、 卸载测试环境

 

对于单元测试步骤请参考：加速Java应用开发速度3——单元/集成测试+CI。

 

测试示例请参考

https://github.com/zhangkaitao/spring4-showcase/tree/master/spring-mvc-test/src/test/java/com/sishuok/mvc/client 

 

欢迎加入spring群134755960进行交流。