前言

清代谴责小说家吴趼人在《痛史》中写道：“卷帙浩繁，望而生畏。”

意思是：“ 一部书的篇幅太长，让人看见就害怕。”编写单元测试用例也是如此，如果单元测试用例写起来又长又复杂，自然而然地会让人“望而生畏”，于是开始反感甚至于最终放弃。为了便于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的参数化测试新特性。

后记

本文只是抛砖引玉，起了个话题打了个底，希望大家继续深挖并完善。

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

前言

1. 简化模拟数据对象

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

1.2. 利用虚拟数据对象简化返回值模拟语句

1.3. 利用虚拟数据对象简化参数值模拟语句

2. 简化模拟依赖方法

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

2.2. 利用任意匹配参数简化模拟依赖方法

2.3. 利用do/thenAnswer简化模拟依赖方法

2.4. 利用Mock参数简化模拟链式调用方法

3. 简化验证数据对象

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

3.2. 利用数据对象相等简化返回值验证语句

3.3. 利用数据对象相等简化参数值验证语句

4. 简化验证依赖方法

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

5. 简化单元测试用例

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

5.2. 利用JUnit的参数化测试简化单元测试用例

后记

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

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

前言

1. 简化模拟数据对象

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

1.2. 利用虚拟数据对象简化返回值模拟语句

1.3. 利用虚拟数据对象简化参数值模拟语句

2. 简化模拟依赖方法

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

2.2. 利用任意匹配参数简化模拟依赖方法

2.3. 利用do/thenAnswer简化模拟依赖方法

2.4. 利用Mock参数简化模拟链式调用方法

3. 简化验证数据对象

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

3.2. 利用数据对象相等简化返回值验证语句

3.3. 利用数据对象相等简化参数值验证语句

4. 简化验证依赖方法

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

5. 简化单元测试用例

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

5.2. 利用JUnit的参数化测试简化单元测试用例

后记

热门文章

最新文章

相关课程

相关电子书

相关实验场景