单元测试

了解单元测试概念

什么叫单元测试？

单元测试（unit testing），是指对软件中的最小可测试单元进行检查和验证。Java里可测试单元单元——>java类

单元测试的意义

• 软件质量最简单、最有效的保证；
• 是目标代码最清晰、最有效的文档；
• 可以优化目标代码的设计；
• 是代码重构的保障；
• 是回归测试和持续集成的基石。

最后才修改一个 bug 的代价是在bug产生时修改它的代价的10倍！

TDD

TDD是测试驱动开发（Test-Driven Development）的英文简称，是敏捷开发中的一项核心实践和技术，也是一种设计方法论。

TDD的原理是在开发功能代码之前，先编写单元测试用例代码，测试代码确定需要编写什么产品代码。

原则上，在每次提交代码之前，要求接口的单元测试是功能完备的…

Junit4

单元测试常用注解

• @Before：初始化方法，在任何一个测试方法执行之前，必须执行的代码。对比 JUnit 3 ，和 setUp（）方法具有相同的功能。在该注解的方法中，可以进行一些准备工作，比如初始化对象，打开网络连接等。
• @After：释放资源，在任何一个测试方法执行之后，需要进行的收尾工作。对比 JUnit 3 ，和 tearDown（）方法具有相同的功能。
• @Test：测试方法，表明这是一个测试方法。在 JUnit 中将会自动被执行。对与方法的声明也有如下要求：名字可以随便取，没有任何限制，但是返回值必须为 void ，而且不能有任何参数。
  可以接收两个参数
  • expected：指定测试应当抛出的异常类型
  • timeout：指定测试超时时间【单位是毫秒】

  @Test(timeout=100, expected=NullPointerException) 
  public void sleep100() {
  	 Thread.sleep(100);
  }

• @Ignore：如果出于某种原因，如果不希望测试失败，希望它被忽略，可以采用@Ignore暂时禁用一个测试。
  注意：@Ignore 包含一个可选参数，如果您想记录一个测试被忽略的原因，可以指定其值。
  @Ignore(“Test is ignored as a demonstration”)
• @BeforeClass：针对所有测试，也就是整个测试类中，在所有测试方法执行前，都会先执行由它注解的方法，而且只执行一次。当然，需要注意的是，修饰符必须是 public static void xxxx ；此 Annotation 是 JUnit 4 新增的功能。
• @AfterClass：针对所有测试，也就是整个测试类中，在所有测试方法都执行完之后，才会执行由它注解的方法，而且只执行一次。当然，需要注意的是，修饰符也必须是 public static void xxxx ；此 Annotation 也是 JUnit 4 新增的功能，与 @BeforeClass 是一对。
• @RunWith 指定该测试类使用某个运行器
• @Parameters 指定测试类的测试数据集
• @Rule 重新制定测试类中方法的行为
• @FixMethodOrder 指定测试类中方法的执行顺序
  @FixMethodOrder注解是在类上进行注释的，并提供了三种顺序：
  • @FixMethodOrder(MethodSorters.DEFAULT)：默认的顺序，以确定但不可预期的顺序执行
  • @FixMethodOrder(MethodSorters.JVM)：按照JVM得到的方法顺序，也就是代码中定义的方法顺序
  • @FixMethodOrder(MethodSorters.NAME_ASCENDING)：按方法名字母顺序执行

      @FixMethodOrder(MethodSorters.NAME_ASCENDING)
     	public class TestMethodOrder {
     	}
  

• @Suite.SuiteClasses 测试套件

  @RunWith(Suite.class)
  @SuiteClasses({ATest.class, BTest.class, CTest.class})
  public class ABCSuite {
  }
  

执行顺序

@BeforeClass → @Before → @Test → @After → @AfterClass

例子

@RunWith(SpringRunner.class)
@ContextConfiguration(classes = {ExampleUnitTest.class})
@TestPropertySource(value = { "classpath:application.properties" })
public class ExampleUnitTest {
    @BeforeClass
    public static void beforeClass(){
        System.out.println("测试类开始前");
    }
    @Before
    public void before(){
        System.out.println("测试方法开始前");
    }
    @Ignore
    @Test
    public void testIgnore() {
        System.out.println("忽略的方法");
    }
    @Test
    public void test() throws Exception {
        System.out.println("测试方法");
    }
    @After
    public void after(){
        System.out.println("测试方法结束后");
    }
    @AfterClass
    public static void afterClass(){
        System.out.println("测试类结束后");
    }
}

断言

JUnit提供了所有原始类型、对象和数组的重载断言方法。参数顺序是期望值，后面是实际值。[可选地] 第一个参数可以是在失败时输出的字符串消息。

注意：有一个稍微不同的断言是 assertThat ， 第一个是可选参数用来在失败时进行输出，接下来是实际值，最后是一个Matcher对象。需要注意的是期望值和实际值与其他断言是相反的。

好用的单元测试工具 ——> org.hamcrest.Matchers.*
提供了很多好用的静态方法
for example:
判断Map中是否包含具体k-v的hasEntry

了解更多参考Matchers类的源码

常用方法	解释
assertArrayEquals(expecteds, actuals)	查看两个数组是否相等
assertEquals(expected, actual)	查看两个对象是否相等，类似于字符串比较使用的equals()方法
assertNotEquals(first, second)	查看两个对象是否不相等。
assertNull(object)	查看对象是否为空
assertNotNull(object)	查看对象是否不为空
assertSame(expected, actual)	查看两个对象的引用是否相等。类似于使用“==”比较两个对象
assertNotSame(unexpected, actual)	查看两个对象的引用是否不相等。类似于使用“!=”比较两个对象
assertTrue(condition)	查看运行结果是否为true
assertFalse(condition)	查看运行结果是否为false
assertThat(actual, matcher)	查看实际值是否满足指定的条件
fail()	让测试失败

示例：

public class AssertTests {
  	@Test
  	public void testAssertArrayEquals() {
    	byte[] expected = "trial".getBytes();
    	byte[] actual = "trial".getBytes();
    	assertArrayEquals("failure - byte arrays not same", expected, actual);
 	}
  	@Test
  	public void testAssertEquals() {
   		assertEquals("failure - strings are not equal", "text", "text");
  	}
  	@Test
  	public void testAssertFalse() {
    	assertFalse("failure - should be false", false);
  	}
  	@Test
  	public void testAssertNotNull() {
    	assertNotNull("should not be null", new Object());
  	}
  	@Test
  	public void testAssertNotSame() {
    	assertNotSame("should not be same Object", new Object(), new Object());
  	}
  	@Test
  	public void testAssertNull() {
    	assertNull("should be null", null);
  	}
  	@Test
  	public void testAssertSame() {
    	Integer aNumber = Integer.valueOf(768);
    	assertSame("should be same", aNumber, aNumber);
  	}
  	// JUnit Matchers assertThat
  	@Test
  	public void testAssertThatBothContainsString() {
    	assertThat("albumen", both(containsString("a")).and(containsString("b")));
  	}
  	@Test
  	public void testAssertThatHasItems() {
    	assertThat(Arrays.asList("one", "two", "three"), hasItems("one", "three"));
  	}
  	@Test
  	public void testAssertThatEveryItemContainsString() {
    	assertThat(Arrays.asList(new String[] { "fun", "ban", "net" }), everyItem(containsString("n")));
  	}
  	// Core Hamcrest Matchers with assertThat
  	@Test
  	public void testAssertThatHamcrestCoreMatchers() {
    	assertThat("good", allOf(equalTo("good"), startsWith("good")));
    	assertThat("good", not(allOf(equalTo("bad"), equalTo("good"))));
    	assertThat("good", anyOf(equalTo("bad"), equalTo("good")));
    	assertThat(7, not(CombinableMatcher.<Integer> either(equalTo(3)).or(equalTo(4))));
    	assertThat(new Object(), not(sameInstance(new Object())));
  	}
  	@Test
  	public void testAssertTrue() {
    	assertTrue("failure - should be true", true);
  	}
}

Spring Boot集成单元测试

pom依赖

<dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>5.1.6.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <version>2.0.5.RELEASE</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

• spring-boot-starter-test说明

引入spring-boot-starter-test后，有如下几个库：
• JUnit — The de-facto standard for unit testing Java applications.
• Spring Test & Spring Boot Test — Utilities and integration test support for Spring Boot applications.
• AssertJ — A fluent assertion library.
• Hamcrest — A library of matcher objects (also known as constraints or predicates).
• Mockito — A Java mocking framework.
• JSONassert — An assertion library for JSON.
• JsonPath — XPath for JSON.

案例

Service

@Service
public class UserService {
    public Integer addUser(String username){
        System.out.println("user dao adduser [username="+username+"]");
        if(username == null){
            return 0;
        }
        return 1;
    }
}

springboot启动类

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class,args);
    }
}

测试类

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserServiceTest {
    @Autowired
    private UserService userService;
    @Test
    public void addUser() throws Exception {
        Assert.assertEquals(Integer.valueOf(1),userService.addUser("wang"));
        Assert.assertEquals(Integer.valueOf(0),userService.addUser(null));
    }
}

注解盲点扫描

基础注解

// 当一个类用@RunWith注释或继承一个用@RunWith注释的类时，JUnit将调用它所引用的类来运行该类中的测试而不是开发者去在junit内部去构建它
// SpringRunner是SpringJUnit4ClassRunner的一个别名
@RunWith(SpringRunner.class)
// 注解制定了一个测试类运行了Spring Boot环境
// 使用SpringBootContextLoader作为默认的ContextLoader
// 自动搜索到SpringBootConfiguration注解的文件
// 提供一个webEnvironment环境，可以完整的允许一个web环境使用随机的端口或者自定义的端口
// 注册了TestRestTemplate类可以去做接口调用
@SpringBootTest
public class AppTest {
	// TODO: do something
}

补充注解

// @ContextConfiguration这个注解通常与@RunWith(SpringJUnit4ClassRunner.class)联合使用用来测试
// 当我们想要在某个测试类使用@Autowired注解来引入这些收集起来的bean时，只需要给这个测试类添加@ContextConfiguration注解来标注我们想要导入这个测试类的某些bean。
// SpringBoot一般不使用，@SpringBootTest已经集成
// @ContextConfiguration(locations = { "classpath:spring1.xml", "classpath:spring2.xml" }) 
@ContextConfiguration(classes = Config.class)
// 手动指定测试扫描bean的范围
@Configuration
@ComponentScanbasePackages = {"com.wang.test.config"）
// 指定配置文件，
@TestPropertySource(value = { "classpath:application-${spring.profiles.active}.properties" })
public class AppTest {
    @Value("${spring.application.name}")
    String applicationName;
    @Test
    public void testApp(){
        System.out.println(applicationName);
    }
}

Mock

Mock，模拟、模仿的意思，由于java是面向对象编程，所以在java中的Mock就是模拟对象

为什么要使用Mock?

在单元测试中，模拟对象可以模拟复杂的、真实的（非模拟）对象的行为， 如果真实的对象无法放入单元测试中，使用模拟对象就很有帮助。

Mockito

Mockito是GitHub上使用最广泛的Mock框架,并与JUnit结合使用.Mockito框架可以创建和配置mock对象.使用Mockito简化了具有外部依赖的类的测试开发

我们在写单元测试代码时，有时需要连接数据库、redis等获取数据，但是我们每个方法只关心放的内部逻辑是否正确，所以在写单元测试时可以将获取数据的逻辑用Mockito来mock数据

一般使用Mockito的步骤:

• 模拟任何外部依赖并将这些模拟对象插入测试代码中
• 执行测试中的代码
• 验证代码是否按照预期执行

关于Mockito的功能直接阅读下面的官方文档

Mockito中文文档
https://github.com/hehonghui/mockito-doc-zh/blob/master/README.md#0

案例

下面的案例选取交易的一个类来实现单元测试

隔离外部类

Case1. 被测类中被@Autowired 或 @Resource 注解标注的依赖对象，如何控制其返回值?

• 被测类MatchingServiceImpl

public class MatchingServiceImpl implements MatchingService {
    private static final Logger log = LoggerFactory.getLogger(MatchingServiceImpl.class);
    @Autowired
    private QuoteService quoteService;
    ...
    public MatchingResult matching(MatchingOrder buyOrder, MatchingOrder sellOrder) {
        int currentPrice = quoteService.getCurrentPriceByProduct(buyOrder.getProductCode());
        MatchingResult result = new MatchingResult();
        if (sellOrder != null && buyOrder != null && sellOrder.getPrice() <= buyOrder.getPrice()) {
    ...
  }
}

上述matching方法中的quoteService.getCurrentPriceByProduct(buyOrder.getProductCode());要访问Redis获取当前报价，这里我们需要把外部依赖quoteService mock掉，控制getCurrentPriceByProduct方法的返回值。使用mockito可以做到，具体如下：

• 测试类MatchingServiceImplTest

public class MatchingServiceImplTest extends MockitoBasedTest {
    /**
     * 被@Mock标注的对象会自动注入到被@InjectMocks标注的对象中
     */
    @Mock
    private QuoteService quoteService;
    /**
     * <pre>
     * 被测对象，用@InjectMocks标注，那些被@mock标注的对象就会自动注入其中。
     * 另一个注意点是这里的MatchingServiceImpl是直接new出来(Mockito 1.9版本后不new也可以)，而不是通过spring容器注入的。因为这里我不需要从spring容器中
     * 获得其他依赖，不需要database ，redis ，zookeeper，mq，啥都不依赖，所以直接new
     * </pre>
     */
    @InjectMocks
    private MatchingServiceImpl matchingService = new MatchingServiceImpl();
    @Test
    public void testMatching_SuccessWhenCurrentPriceBetweenBuyPriceAndSellPrice() {
        MatchingOrder buyOrder = new MatchingOrder();
        buyOrder.setPrice(1000);
        buyOrder.setCount(23);
        MatchingOrder sellOrder = new MatchingOrder();
        sellOrder.setPrice(800);
        sellOrder.setCount(20);
        // 方法打桩(Method stubbing)
        // when(x).thenReturn(y) ：当指定方法被调用时返回指定值
        Mockito.when(quoteService.getCurrentPriceByProduct(Mockito.anyString())).thenReturn(900);
        MatchingResult result = matchingService.matching(buyOrder, sellOrder);
        org.junit.Assert.assertEquals(true, result.isSuccess());// 断言撮合是否成功
        org.junit.Assert.assertEquals(20, result.getTradeCount());// 断言成交数量
        org.junit.Assert.assertEquals(900, result.getTradePrice()); // 断言最新报价是否符合预期
    }
}

Case2. 被测函数A调用被测类其他函数B，怎么控制函数B的返回值？

比如，MatchingServiceImpl中有个函数startBuyProcess，它里面调用了该类中的其他函数，如getTopSellOrder，matching，如何控制这两个函数的返回值？
这里要解决的问题其实是怎么对一个类”部分mock”–被测类的被测方法（如startBuyProcess）要真实执行，而另一些方法（如getTopSellOrder）则是要打桩（不真正进去执行）。

被测类MatchingServiceImpl

protected void startBuyProcess(MatchingOrder buyOrder, boolean waitForMatching) {
    while (true) {
        //对手方最优价
        MatchingOrder topSellOrder = getTopSellOrder(buyOrder.getProductCode());
        MatchingResult matchingResult = matching(buyOrder,topSellOrder);
        if(matchingResult.isSuccess()) {
            doMatchingSuccess(buyOrder,topSellOrder,matchingResult,MatchingType.BUY);
            if(buyOrder.getCount() <= 0) {
                break;
            }
        }else {
            if(waitForMatching) {
                //加入待撮合队列
                addToMatchingBuy(buyOrder);
            }else {
                //撤单
                sendCancleMsg(buyOrder);
            }
            break;
        }
    }
}

利用Mockito.spy()可以做到“部分Mock”

测试类MatchingServiceImplTest.testStartBuyProcess_InCaseOfMatchingSuccess

@Test
public void testStartBuyProcess_InCaseOfMatchingSuccess() {
    MatchingOrder buyOrder = new MatchingOrder();
    buyOrder.setPrice(700);
    buyOrder.setCount(23);
    // 用Mockito.spy()对matchingService进行部分打桩
    matchingService = Mockito.spy(matchingService);
    MatchingResult firstMatchingResult = new MatchingResult();
    firstMatchingResult.setSuccess(true);
    firstMatchingResult.setTradeCount(20);
    MatchingResult secondMatchingResult = new MatchingResult();
    secondMatchingResult.setSuccess(false);
    // doReturn(x).when(obj).method() 对方法打桩，打桩后，程序执行这些方法时将按照预期返回指定值，未被打桩的方法将真实执行
    // 两个doReturn表示第一次调用matchingService.matching时返回firstMatchingResult，第二次调用返回secondMatchingResult
    // 因为startBuyProcess里有个while循坏，可能会多次执行matching方法
    Mockito.doReturn(firstMatchingResult).doReturn(secondMatchingResult).when(matchingService)
            .matching(Mockito.any(MatchingOrder.class), Mockito.any(MatchingOrder.class));
    MatchingOrder sellOrder = new MatchingOrder();
    sellOrder.setPrice(600);
    sellOrder.setCount(20);
    // 对getTopSellOrder方法打桩
    Mockito.doReturn(sellOrder).when(matchingService).getTopSellOrder(Mockito.anyString());
    // 对外部依赖jedis的方法进行打桩
    Mockito.when(jedisClient.incrBy(Mockito.anyString(), Mockito.anyLong())).thenReturn(0L);
    // startBuyProcess是被测函数，不打桩，会真实执行
    matchingService.startBuyProcess(buyOrder, true);
    // 后面的校验和断言是测试doMatchingSuccess方法的行为的，这也是这个测试的目的
    // verify可用来校验，某个类的方法被执行过多少次，这里是校验jedisClient.zremFirst是否被执行过1次
    Mockito.verify(jedisClient, Mockito.times(1)).zremFirst(Mockito.anyString());
    org.junit.Assert.assertEquals(3, buyOrder.getCount());
    org.junit.Assert.assertEquals(0, sellOrder.getCount());
}

spy的用法已经演示完毕，下面从testStartBuyProcess_InCaseOfMatchingSuccess说下单元测试的“粒度”。

testStartBuyProcess_InCaseOfMatchingSuccess的目的是想测doMatchingSuccess，我们费了很大劲才把前面的一堆准备工作做完，才能去测doMatchingSuccess。

更好的实践应该是另起测试方法去单独测doMatchingSuccess，关注点也集中很多，doMatchingSuccess覆盖完了，再测startBuyProcess其实就只是覆盖下它本身的判断分支就行了。覆盖率照样达到，而且测试代码也更容易维护,testStartBuyProcess_InCaseOfMatchingSuccess由于考虑的职责太多，它很容易受到变化的影响，细小的东西改变，可能就会影响它的正常工作。

springboot+junit+mockito的上下文构建

@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(classes = TestApplication.class)
public abstract class MockitoBasedTest {
    @Before
    public void setUp() throws Exception {
        // 初始化测试用例类中由Mockito的注解标注的所有模拟对象
        MockitoAnnotations.initMocks(this);
    }
}
// 其他测试类继承MockitoBasedTest

备注：Mockito案例转载自 https://www.jb51.net/article/134904.htm

MockMVC

基于RESTful风格的SpringMVC的测试

对于前后端分离的项目而言，无法直接从前端静态代码中测试接口的正确性，因此可以通过MockMVC来模拟HTTP请求。基于RESTful风格的SpringMVC的测试，我们可以测试完整的Spring MVC流程，即从URL请求到控制器处理，再到视图渲染都可以测试。

入门示例

@RunWith(SpringRunner.class)
    @SpringBootTest
    @AutoConfigureMockMvc
    public class CourseControllerTest {
        @Autowired
        private MockMvc mockMvc;
        public void helloTest() throws Exception{
            mockMvc.perform(
                    //构造一个post请求
                    MockMvcRequestBuilders.post("/hello")
                    .contentType(MediaType.APPLICATION_JSON_UTF8)
            //andExpect，添加ResultMathcers验证规则，验证控制器执行完成后结果是否正确，【这是一个断言】
            .andExpect(MockMvcResultMatchers.status().is(200))
            .andExpect(MockMvcResultMatchers.content().contentType(MediaType.APPLICATION_JSON_UTF8))
            //假定返回的结果中，期望为hello，并给出期望值和实际值
            .andExpect(MockMvcResultMatchers.content().string("hello"))
            //添加ResultHandler结果处理器，比如调试时 打印结果(print方法)到控制台
            .andDo(print())
            //返回相应的MvcResult
            .andReturn();
    }

MockMvcBuilder

MockMvcBuilder是用来构造MockMvc的构造器，其主要有两个实现：StandaloneMockMvcBuilder和DefaultMockMvcBuilder，分别对应两种测试方式，即独立安装和集成Web环境测试（此种方式并不会集成真正的web环境，而是通过相应的Mock API进行模拟测试，无须启动服务器）。对于我们来说直接使用静态工厂MockMvcBuilders创建即可。

集成web环境方式

public class MockMvcTest {
    @Autowired
    private WebApplicationContext webApplicationContext;
    private MockMvc mockMvc;
    @Before
    public void setUp() {
        this.mockMvc = MockMvcBuilders.webAppContextSetup(this.webApplicationContext).build();   //构造MockMvc
    }
    @Test
    public void courseListTest() throws Exception{
        MvcResult name= mockMvc.perform(MockMvcRequestBuilders.get("/hello"))
                .andExpect(status().isOk())
                .andExpect(MockMvcResultMatchers.content().string("hello"))
                .andDo(print())
                .andReturn();
    }
}

独立测试方式

MockMvcBuilders.standaloneSetup(Object... controllers)：通过参数指定一组控制器，这样就不需要从上下文获取了；
public class PricingExportResultsRestServiceTest {
    @InjectMocks
    private PricingExportResultsRestService pricingExportResultsRestService;
    @Mock
    private ExportRateScheduleService exportRateScheduleService;
    @Mock
    private PricingUrlProvider pricingUrlProvider;
    private MockMvc mockMvc;
    @Before
    public void setup() {
        MockitoAnnotations.initMocks(this);
        mockMvc = MockMvcBuilders.standaloneSetup(pricingExportResultsRestService).build();  //构造MockMvc
    }
    ...
}
主要是两个步骤：
(1)首先自己创建相应的控制器，注入相应的依赖
(2)通过MockMvcBuilders.standaloneSetup模拟一个Mvc测试环境，通过build得到一个MockMvc

MockMvc

使用规范：

1. 准备测试环境
2. 通过MockMvc执行请求
3. 添加验证断言
4. 添加结果处理器
5. 得到MvcResult进行自定义断言/进行下一步的异步请求
6. 卸载测试环境

常用的API：

• mockMvc.perform : 执行一个请求；
• MockMvcRequestBuilders.get("/user/1") : 构造一个请求
• ResultActions.andExpect : 添加执行完成后的断言
• ResultActions.andDo : 添加一个结果处理器，表示要对结果做点什么事情，比如此处使用print()输出整个响应结果信息。
• ResultActions.andReturn : 表示执行完成后返回相应的结果，通过MvcResult接收响应数据

@Test
public void courseListTest() throws Exception{
    MvcResult mvcResult= mockMvc.perform(MockMvcRequestBuilders.get("/hello"))
            .andExpect(status().isOk())
            .andExpect(MockMvcResultMatchers.content().string("hello"))
            .andDo(print())
            .andReturn();     
    System.out.println(mvcResult.getResponse().getContentAsString());
}

 
 

 
 
1
2
3
4
5
6
7
8
9
10

控制台结果

RequestBuilder

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

通过抽象类MockMvcRequestBuilders提供方法生成MockHttpServletRequestBuilder

• 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提供的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提供的API

// 继承自MockHttpServletRequestBuilder，又提供了如下API
MockMultipartHttpServletRequestBuilder file(String name, byte[] content)/MockMultipartHttpServletRequestBuilder file(MockMultipartFile file) //指定要上传的文件；

ResultActions

调用MockMvc.perform(RequestBuilder requestBuilder)后将得到ResultActions
ResultActions提供了如下API

ResultActions andExpect(ResultMatcher matcher) // 添加验证断言来判断执行请求后的结果是否是预期的；
ResultActions andDo(ResultHandler handler) // 添加结果处理器，用于对验证成功后执行的动作，如输出下请求/结果信息用于调试；
MvcResult andReturn() // 返回验证成功后的MvcResult；用于自定义验证/下一步的异步处理；

ResultMatcher 验证器

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

MockMvcResultMatchers提供的API

andlerResultMatchers 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 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）

ResultHandler

ResultHandler用于对处理的结果进行相应处理的，Spring mvc测试框架提供了MockMvcResultHandlers静态工厂方法

MockMvcResultHandlers的API

ResultHandler log()
ResultHandler print()
ResultHandler print(OutputStream stream)
ResultHandler print(Writer writer)

关系梳理

• MockMvcBuilder——>通过MockMvcBuilders工厂方法生成MockMvcBuilder
• MockMvc——>通过MockMvc的perform方法接收RequestBuilder生成ResultActions
• RequestBuilder ——>通过MockMvcRequestBuilders工厂get、post…方法生成RequestBuilder
• ResultActions——>andExpect()、andDo()返回ResultActions，链式操作；andReturn()产生MvcResult对象
• ResultMatcher——>ResultActions的andExpect()方法接收ResultMatcher，进行结果校验
• ResultHandler——>ResultActions的andDo()方法接收ResultHandler，对结果进行处理
  

常用案例

1. 测试普通控制器

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到控制台

2. 得到MvcResult自定义验证

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

3. 验证请求参数绑定到模型数据及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")); //验证视图  

4. 文件上传

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")); //验证视图  

5. JSON请求/响应验证

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()));//错误的请求内容体

6. 异步测试

//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));  

7. 全局配置

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"));