Java编程技巧之单元测试用例简化方法

衣柜橱柜推拉门售后

前言

清代谴责小说家吴趼人在《痛史》中写道：“卷帙浩繁，望而生畏。”
意思是：“ 一部书的篇幅太长，让人看见就害怕。”编写单元测试用例也是如此，如果单元测试用例写起来又长又复杂，自然而然地会让人“望而生畏”，于是开始反感甚至于最终放弃。为了便于Java单元测试的推广，作者总结了十余种测试用例的简化方法，希望能够让大家编写单元测试用例时——“化繁为简、下笔如神”。
1. 简化模拟数据对象

1.1. 利用JSON反序列化简化数据对象赋值语句

利用JSON反序列化，可以简化大量的数据对象赋值语句。首先，加载JSON资源文件为JSON字符串；然后，通过JSON反序列化JSON字符串为数据对象；最后，用该数据对象来模拟类属性值、方法参数值和方法返回值。
原始用例：
List<UserCreateVO> userCreateList = new ArrayList<>();
UserCreateVO userCreate0 = new UserCreateVO();
userCreate0.setName("Changyi");
... // 约几十行
userCreateList.add(userCreate0);
UserCreateVO userCreate1 = new UserCreateVO();
userCreate1.setName("Tester");
... // 约几十行
userCreateList.add(userCreate1);
... // 约几十条
userService.batchCreate(userCreateList);简化用例：
String text = ResourceHelper.getResourceAsString(getClass(), path + "userCreateList.json");
List<UserCreateVO> userCreateList = JSON.parseArray(text, UserCreateVO.class);
userService.batchCreate(userCreateList);1.2. 利用虚拟数据对象简化返回值模拟语句

有时候，模拟的方法返回值在测试方法内部并不发生修改，只是起到一个透传的作用而已。对于这种情况，我们只需要模拟一个对象实例，但并不关心其内部具体内容。所以，可以直接用虚拟数据对象替换真实数据对象，从而简化了返回值模拟语句。
被测代码：
@GetMapping("/get")
public ExampleResult<UserVO> getUser(@RequestParam(value = "userId", required = true) Long userId) {
    UserVO user = userService.getUser(userId);
    return ExampleResult.success(user);
}原始用例：
// 模拟依赖方法
String path = RESOURCE_PATH + "testGetUser/";
String text = ResourceHelper.getResourceAsString(getClass(), path + "user.json");
UserVO user = JSON.parseObject(text, UserVO.class);
Mockito.doReturn(user).when(userService).getUser(user.getId());

// 调用测试方法
ExampleResult<UserVO> result = userController.getUser(user.getId());
Assert.assertEquals("结果编码不一致", ResultCode.SUCCESS.getCode(), result.getCode());
Assert.assertEquals("结果数据不一致", user, result.getData());简化用例：
// 模拟依赖方法
Long userId = 12345L;
UserVO user = Mockito.mock(UserVO.class); // 也可以使用new UserVO()
Mockito.doReturn(user).when(userService).getUser(userId);

// 调用测试方法
ExampleResult<UserVO> result = userController.getUser(userId);
Assert.assertEquals("结果编码不一致", ResultCode.SUCCESS.getCode(), result.getCode());
Assert.assertSame("结果数据不一致", user, result.getData());1.3. 利用虚拟数据对象简化参数值模拟语句

有时候，模拟的方法参数值在测试方法内部并不发生修改，只是起到一个透传的作用而已。对于这种情况，我们只需要模拟一个对象实例，但并不关心其内部具体内容。所以，可以直接用虚拟数据对象替换真实数据对象，从而简化参数值模拟语句。
被测代码：
@GetMapping("/create")
public ExampleResult<Void> createUser(@Valid @RequestBody UserCreateVO userCreate) {
    userService.createUser(userCreate);
    return ExampleResult.success();
}原始用例：
// 调用测试方法
String path = RESOURCE_PATH + "testCreateUser/";
String text = ResourceHelper.getResourceAsString(getClass(), path + "userCreate.json");
UserCreateVO userCreate = JSON.parseObject(text, UserCreateVO.class);
ExampleResult<Void> result = userController.createUser(userCreate);
Assert.assertEquals("结果编码不一致", ResultCode.SUCCESS.getCode(), result.getCode());

// 验证依赖方法
Mockito.verify(userService).createUser(userCreate);简化用例：
// 调用测试方法
UserCreateVO userCreate = Mockito.mock(UserCreateVO.class); // 也可以使用new UserCreateVO()
ExampleResult<Void> result = userController.createUser(userCreate);
Assert.assertEquals("结果编码不一致", ResultCode.SUCCESS.getCode(), result.getCode());

// 验证依赖方法
Mockito.verify(userService).createUser(userCreate);2. 简化模拟依赖方法

2.1. 利用默认返回值简化模拟依赖方法

模拟对象的方法是具有默认返回值的：当方法返回类型为基础类型时，默认返回值是0或false；当方法返回类型为对象类型时，默认返回值是null。在测试用例中，当需要模拟方法返回值为上述默认值时，我们可以省略这些模拟方法语句。当然，显式地写上这些模拟方法语句，可以让测试用例变得更便于理解。
原始用例：
Mockito.doReturn(false).when(userDAO).existName(userName);
Mockito.doReturn(0L).when(userDAO).countByCompany(companyId);
Mockito.doReturn(null).when(userDAO).queryByCompany(companyId, startIndex, pageSize);简化用例：
可以把以上模拟方法语句直接删除。
2.2. 利用任意匹配参数简化模拟依赖方法

在模拟依赖方法时，有些参数需要使用到后面加载的数据对象，比如下面案例中的UserCreateVO的name属性值。这样，我们就需要提前加载UserCreateVO对象，既让模拟方法语句看起来比较繁琐，又让加载UserCreateVO对象语句和使用UserCreateVO对象语句分离（优秀的代码，变量定义和初始化一般紧挨着变量使用代码）。
利用任意匹配参数就可以解决这些问题，使测试用例变得更简洁更便于维护。但是要注意，验证该方法时，不能再用任意匹配参数去验证，必须使用真实的值去验证。
原始用例：
// 模拟依赖方法
String path = RESOURCE_PATH + "testCreateUserWithSuccess/";
String text = ResourceHelper.getResourceAsString(getClass(), path + "userCreateVO.json");
UserCreateVO userCreateVO = JSON.parseObject(text, UserCreateVO.class);
Mockito.doReturn(false).when(userDAO).existName(userCreateVO.getName());
...

// 调用测试方法
Assert.assertEquals("用户标识不一致", userId, userService.createUser(userCreateVO));

// 验证依赖方法
Mockito.verify(userDAO).existName(userCreateVO.getName());
...简化用例：
// 模拟依赖方法
Mockito.doReturn(false).when(userDAO).existName(Mockito.anyString());
...

// 调用测试方法
String path = RESOURCE_PATH + "testCreateUserWithSuccess/";
String text = ResourceHelper.getResourceAsString(getClass(), path + "userCreateVO.json");
UserCreateVO userCreateVO = JSON.parseObject(text, UserCreateVO.class);
Assert.assertEquals("用户标识不一致", userId, userService.createUser(userCreateVO));

// 验证依赖方法
Mockito.verify(userDAO).existName(userCreateVO.getName());
...2.3. 利用do/thenAnswer简化模拟依赖方法

当一个方法需要调用多次，但返回值跟调用顺序无关，只跟输入参数有关的时，可以用映射来模拟方法不同返回值。先加载一个映射JSON资源文件，通过JSON.parseObject方法转化为映射，然后利用Mockito的doAnswer-when或when-thenAnswer语法来模拟方法返回对应值（根据指定参数返回映射中的对应值）。
原始用例：
String text = ResourceHelper.getResourceAsString(getClass(), path + "user1.json");
UserDO user1 = JSON.parseObject(text, UserDO.class);
Mockito.doReturn(user1).when(userDAO).get(user1.getId());
text = ResourceHelper.getResourceAsString(getClass(), path + "user2.json");
UserDO user2 = JSON.parseObject(text, UserDO.class);
Mockito.doReturn(user2).when(userDAO).get(user2.getId());
...简化用例：
String text = ResourceHelper.getResourceAsString(getClass(), path + "userMap.json");
Map<Long, UserDO> userMap = JSON.parseObject(text, new TypeReference<Map<Long, UserDO>>() {});
Mockito.doAnswer(invocation -> userMap.get(invocation.getArgument(0))).when(userDAO).get(Mockito.anyLong());2.4. 利用Mock参数简化模拟链式调用方法

在日常编码过程中，很多人都喜欢使用链式调用，这样可以让代码变得更简洁。对于链式调用，Mockito提供了更加简便的单元测试方法——提供Mockito.RETURNS_DEEP_STUBS参数，实现链式调用的对象自动mock。
被测代码：
public void addCorsMappings(CorsRegistry registry) {
    registry.addMapping("/**")
        .allowedOrigins("*")
        .allowedMethods("GET", "HEAD", "POST", "PUT", "DELETE", "OPTIONS")
        .allowCredentials(true)
        .maxAge(MAX_AGE)
        .allowedHeaders("*");
}原始用例：
正常情况下，每一个依赖对象及其调用方法都要mock，编写的代码如下：
@Test
public void testAddCorsMappings() {
    // 模拟依赖方法
    CorsRegistry registry = Mockito.mock(CorsRegistry.class);
    CorsRegistration registration = Mockito.mock(CorsRegistration.class);
    Mockito.doReturn(registration).when(registry).addMapping(Mockito.anyString());
    Mockito.doReturn(registration).when(registration).allowedOrigins(Mockito.any());
    Mockito.doReturn(registration).when(registration).allowedMethods(Mockito.any());
    Mockito.doReturn(registration).when(registration).allowCredentials(Mockito.anyBoolean());
    Mockito.doReturn(registration).when(registration).maxAge(Mockito.anyLong());
    Mockito.doReturn(registration).when(registration).allowedHeaders(Mockito.any());

    // 调用测试方法
    webAuthInterceptConfig.addCorsMappings(registry);

    // 验证依赖方法
    Mockito.verify(registry).addMapping("/**");
    Mockito.verify(registration).allowedOrigins("*");
    Mockito.verify(registration).allowedMethods("GET", "HEAD", "POST", "PUT", "DELETE", "OPTIONS");
    Mockito.verify(registration).allowCredentials(true);
    Mockito.verify(registration).maxAge(3600L);
    Mockito.verify(registration).allowedHeaders("*");
}简化用例：
利用Mockito.RETURNS_SELF参数编写的测试用例如下：
@Test
public void testAddCorsMapping() {
    // 模拟依赖方法
    CorsRegistry registry = Mockito.mock(CorsRegistry.class);
    CorsRegistration registration = Mockito.mock(CorsRegistration.class, Answers.RETURNS_SELF);
    Mockito.doReturn(registration).when(registry).addMapping(Mockito.anyString());

    // 调用测试方法
    webAuthInterceptConfig.addCorsMappings(registry);

    // 验证依赖方法
    Mockito.verify(registry).addMapping("/**");
    Mockito.verify(registration).allowedOrigins("*");
    Mockito.verify(registration).allowedMethods("GET", "HEAD", "POST", "PUT", "DELETE", "OPTIONS");
    Mockito.verify(registration).allowCredentials(true);
    Mockito.verify(registration).maxAge(3600L);
    Mockito.verify(registration).allowedHeaders("*");
}代码说明：

• 在mock对象时，对于自返回对象，需要指定Mockito.RETURNS_SELF参数；
  
• 在mock方法时，无需对自返回对象进行mock方法，因为框架已经mock方法返回了自身；
  
• 在verify方法时，可以像普通测试法一样优美地验证所有方法调用。
  

参数说明：
在mock参数中，有2个参数适合于mock链式调用：

• RETURNS_SELF参数：mock调用方法语句最少，适合于链式调用返回相同值；
  
• RETURNS_DEEP_STUBS参数：mock调用方法语句较少，适合于链式调用返回不同值。
  

3. 简化验证数据对象

3.1. 利用JSON序列化简化数据对象验证语句

利用JSON反序列化，可以简化大量的数据对象验证语句。首先，加载JSON资源文件为JSON字符串；然后，通过JSON序列化数据对象（方法返回值或方法参数值）为JSON字符串；最后，再验证两个JSON字符串是否一致。
原始用例：
List<UserVO> userList = userService.queryByCompanyId(companyId);
UserVO user0 = userList.get(0);
Assert.assertEquals("name不一致", "Changyi", user0.getName());
... // 约几十行
UserVO user1 = userList.get(1);
Assert.assertEquals("name不一致", "Tester", user1.getName());
... // 约几十行
... // 约几十条简化用例：
List<UserVO> userList = userService.queryByCompanyId(companyId);
String text = ResourceHelper.getResourceAsString(getClass(), path + "userList.json");
Assert.assertEquals("用户列表不一致", text, JSON.toJSONString(userList));小知识点：

• 如果数据对象中存在Map对象，为了保证序列化后的字段顺序一致，需要添加SerializerFeature.MapSortField特征。
  

JSON.toJSONString(userMap, SerializerFeature.MapSortField);

• 如果数据对象中存在随机对象，比如时间、随机数等，需要使用过滤器过滤这些字段。
  

排除所有类的属性字段：
List<UserVO> userList = ...;
SimplePropertyPreFilter filter = new SimplePropertyPreFilter();
filter.getExcludes().addAll(Arrays.asList("gmtCreate", "gmtModified"));
Assert.assertEquals("用户信息不一致", text, JSON.toJSONString(user, filter));排除单个类的属性字段：
List<UserVO> userList = ...;
SimplePropertyPreFilter filter = new SimplePropertyPreFilter(UserVO.class);
filter.getExcludes().addAll(Arrays.asList("gmtCreate", "gmtModified"));
Assert.assertEquals("用户信息不一致", text, JSON.toJSONString(user, filter));排除多个类的属性字段：
Pair<UserVO, CompanyVO> userCompanyPair = ...;
SimplePropertyPreFilter userFilter = new SimplePropertyPreFilter(UserVO.class);
userFilter.getExcludes().addAll(Arrays.asList("gmtCreate", "gmtModified"));
SimplePropertyPreFilter companyFilter = new SimplePropertyPreFilter(CompanyVO.class);
companyFilter.getExcludes().addAll(Arrays.asList("createTime", "modifyTime"));
Assert.assertEquals("用户公司对不一致", text, JSON.toJSONString(userCompanyPair, new SerializeFilter[]{userFilter, companyFilter});3.2. 利用数据对象相等简化返回值验证语句

在用Assert.assertEquals方法验证返回值时，可以直接指定基础类型值或数据对象实例。当数据对象实例不一致时，只要其数据对象相等（equals比较返回true），Assert.assertEquals方法也会认为其是相等的。所以，可以利用数据对象相等来替换JSON字符串验证，从而简化测试方法返回值验证语句。
原始用例：
List<Long> userIdList = userService.getAllUserIds(companyId);
String text = JSON.toJSONString(Arrays.asList(1L, 2L, 3L));
Assert.assertEquals("用户标识列表不一致", text, JSON.toJSONString(userIdList));简化用例：
List<Long> userIdList = userService.getAllUserIds(companyId);
Assert.assertEquals("用户标识列表不一致", Arrays.asList(1L, 2L, 3L), userIdList);小知识点:

• Assert.assertSame用于相同类实例验证——类实例相同；
  
• Assert.assertEquals用于相等类实例验证——类实例相同或相等（equals为true）。
  

注意：
这里不建议为了使用这个功能而重载equals方法，只建议针对相同或已重载equals方法的类实例使用。而针对未重载equals方法的类实例，建议转化为JSON字符串后再验证。
3.3. 利用数据对象相等简化参数值验证语句

在用Mockito.verify方法验证依赖方法参数时，可以直接指定基础类型值或数据对象实例。当数据对象实例不一致时，只要其数据对象相等（equals比较返回true），Mockito.verify方法也会认为其是相等的。所以，可以利用数据对象相等来替换ArgumentCaptor参数捕获，从而简化依赖方法参数值验证语句。
原始用例：
ArgumentCaptor<List<Long>> userIdListCaptor = CastHelper.cast(ArgumentCaptor.forClass(List.class));
Mockito.verify(userDAO).batchDelete(userIdListCaptor.capture());
Assert.assertEquals("用户标识列表不一致", Arrays.asList(1L, 2L, 3L), userIdListCaptor.getValue());简化用例：
Mockito.verify(userDAO).batchDelete(Arrays.asList(1L, 2L, 3L));注意：
这里不建议为了使用这个功能而重载equals方法，只建议针对相同或已重载equals方法的类实例使用。而针对未重载equals方法的类实例，建议先捕获参数转化为JSON字符串后再验证。
4. 简化验证依赖方法

4.1. 利用ArgumentCaptor简化验证依赖方法

当一个模拟方法被多次调用时，需要对每一次模拟方法调用进行验证，就显得模拟方法验证代码过于繁琐。这里，可以通过ArgumentCaptor来捕获参数值，然后通过getAllValues方法来获取参数值列表，最后对参数值列表进行统一验证即可。其中，即验证了方法调用次数（列表长度），又验证了方法参数值（列表数据）。
原始用例：
Mockito.verify(userDAO).get(user1.getId());
Mockito.verify(userDAO).get(user2.getId());
...简化用例：
ArgumentCaptor<Long> userIdCaptor = ArgumentCaptor.forClass(Long.class);
Mockito.verify(userDAO, Mockito.atLeastOnce()).get(userIdCaptor.capture());
text = ResourceHelper.getResourceAsString(getClass(), path + "userIdList.json");
Assert.assertEquals("用户标识列表不一致", text, JSON.toJSONString(userIdCaptor.getAllValues()));5. 简化单元测试用例

5.1. 利用直接测试私有方法简化单元测试用例

习惯性地，我们通过构造共有方法的测试用例，来覆盖公有方法及其私有方法的所有分支。这种方式没有问题，但有时候显得测试用例比较繁琐。我们可以直接测试私有方法，单独对私有方法进行全覆盖，从而减少对公有方法的测试用例。
被测代码：
public UserVO getUser(Long userId) {
    // 获取用户信息
    UserDO userDO = userDAO.get(userId);
    if (Objects.isNull(userDO)) {
        throw new ExampleException(ErrorCode.OBJECT_NONEXIST, "用户不存在");
    }
   
    // 返回用户信息
    UserVO userVO = new UserVO();
    userVO.setId(userDO.getId());
    userVO.setName(userDO.getName());
    userVO.setVip(isVip(userDO.getRoleIdList()));
    ...
    return userVO;
}
private static boolean isVip(List<Long> roleIdList) {
    for (Long roleId : roleIdList) {
        if (VIP_ROLE_ID_SET.contains(roleId)) {
            return true;
        }
    }
    return false;
}原始用例：
@Test
public void testGetUserWithVip() {
    // 模拟依赖方法
    String path = RESOURCE_PATH + "testGetUserWithVip/";
    String text = ResourceHelper.getResourceAsString(getClass(), path + "userDO.json");
    UserDO userDO = JSON.parseObject(text, UserDO.class);
    Mockito.doReturn(userDO).when(userDAO).get(userDO.getId());
   
    // 调用测试方法
    UserVO userVO = userService.getUser(userDO.getId());
    text = ResourceHelper.getResourceAsString(getClass(), path + "userVO.json");
    Assert.assertEquals("用户信息不一致", text, JSON.toJSONString(userVO));
   
    // 验证依赖方法
    Mockito.verify(userDAO).get(userDO.getId());
}
@Test
public void testGetUserWithNotVip() {
    ... // 代码跟testGetUserWithVip一致, 只是测试数据不同而已
}简化用例：
@Test
public void testGetUserWithNormal() {
    ... // 代码跟原testGetUserWithVip一致
}
@Test
public void testIsVipWithTrue() throws Exception {
    List<Long> roleIdList = ...; // 包含VIP角色标识
    Assert.assertTrue("返回值不为真", Whitebox.invokeMethod(UserService.class, "isVip", roleIdList));
}
@Test
public void testIsVipWithFalse() throws Exception {
    List<Long> roleIdList = ...; // 不含VIP角色标识
    Assert.assertFalse("返回值不为假", Whitebox.invokeMethod(UserService.class, "isVip", roleIdList));
}5.2. 利用JUnit的参数化测试简化单元测试用例

有时候我们会发现，同一方法的在不同场景下的单元测试，除了加载的数据不同之外，单元测试用例的代码基本完全一致。我们可以这样分析：虽然单元测试用例的场景不一样——执行代码的分支不一样，调用方法方法的顺序、次数、返回值不一样；但是，其调用的依赖方法的数量是完全一致的；所以，最终写出来的单元测试用例的代码也是完全一致的。这时，我们就可以采用JUnit的参数化测试来简化单元测试用例。
被测代码：
同上一章的测试代码。
原始用例：
同上一章的原始用例。
简化用例：
@ParameterizedTest
@ValueSource(strings = { "vip/", "notVip/"})
public void testGetUserWithNormal(String dir) {
    // 模拟依赖方法
    String path = RESOURCE_PATH + "testGetUserWithNormal/" + dir;
    String text = ResourceHelper.getResourceAsString(getClass(), path + "userDO.json");
    UserDO userDO = JSON.parseObject(text, UserDO.class);
    Mockito.doReturn(userDO).when(userDAO).get(userDO.getId());
   
    // 调用测试方法
    UserVO userVO = userService.getUser(userDO.getId());
    text = ResourceHelper.getResourceAsString(getClass(), path + "userVO.json");
    Assert.assertEquals("用户信息不一致", text, JSON.toJSONString(userVO));
   
    // 验证依赖方法
    Mockito.verify(userDAO).get(userDO.getId());
}如上简化用例所示：在资源目录testGetUserWithNormal中创建了两个目录vip和notVip，用于存储相同名称的JSON文件userDO.json和userVO.json，但是其文件内容根据场景又有所不同。
备注：本案例采用JUnit5.0的参数化测试新特性。
后记

本文只是抛砖引玉，起了个话题打了个底，希望大家继续深挖并完善。
原文链接
本文为阿里云原创内容，未经允许不得转载。