作者：汽车事业后端研发 陶凯
前言
近两年来，单测这玩意儿又火起来了！各厂开始重视单测通过、覆盖率；连带着，程序猿们的日常也多了一丝严谨。不再是简单的写写代码，提交提交 bug，大家都开始追求那个绿绿的通过率。这不仅仅是为了指标要求，也是为了看到那一行行代码的满足感，更是为了团队的效率和软件质量的稳步提升。
说到单测，不得不说到那些古老的项目，代码行数能跑马拉松，单测啥的就是传说中的“空白篇”。看那代码，一坨坨的，层层调用，简直就像套娃，拆开一个又一个，没完没了。补存量代码的单测，这活儿啊，简直就是人看了心碎，狗看了流泪。这时候，团队合作的重要性就体现出来了。团队成员一条心，拿起武器就是干，那些年的单测债，终于是还清了。虽然过程枯燥无味、让人疲惫，但是看着那代码质量一步步上去，咱们也算是拨云见日，全身上下通透爽快！
我猜，其他团队的小伙伴们也有这种烦恼，今天在这里，我就把单测经验打包分享一番，希望能给大家带来点帮助，一起向着更高的代码质量冲刺！
解题思路
针对庞大的单测债务，我们要战略上进行藐视、战术上进行重视，不要有太大的压力，化繁为简，日拱一卒，具体思路如下：
•mock 大法：考虑项目的外部依赖、服务器成本、环境隔离等多方因素的限制，与其花费大量时间、成本在这些方面上，不如采用 mock 的形式。使用 mock 不仅能够规避外部依赖、解决成本问题，而且“预设-check”的形式，可以轻松模拟各种边界条件和异常情况，以测试代码的健壮性，总结一下就是：省事、省力、省成本。
•分而治之：将整个项目的测试任务细分成小块，比如按照模块、功能或者类别；确定哪些部分最关键、风险最高，优先编写这些部分的测试。遂以日常需求为本，将代码分为存量代码和增量代码，存量代码的单测从简处理，增量代码的单测认真覆盖。以重要程度为准，将代码分为核心代码和非核心代码；核心代码应详尽详，非核心代码量“时”而行。通过以上分析确定高低优先级，按模块或者功能补充单测。
•工利其器：通过工具生成单测代码，研发在此基础上进行调参，进而覆盖大部分的逻辑分支，以此方式释放更多的时间，让大家聚焦更重要的工作。
•重构优化：针对“坏味道”的代码进行重构重写，尤其是那种一个方法上千行、满篇 if else for 循环的代码。
落地实践
讲完思路，讲落地。面对蛛网一般错综复杂的调用链路，面对形形色色的接口形式，最终采用 JUnit 4、Mockito 组合的方式进行单元测试，具体的落地策略可以如下：
题外话：如今 JUnit 已经迭代到 5.x，Mockito 也进入了 5.x 阶段，在 20 年最开始补充单测的时候，项目用的是 JUnit 5.x + Mockito 5.x，但因为遇到问题时可参考资料较少，随后降级到 JUnit 4.x + Mockito 3.x 实现。
说说为什么没有使用 PowerMockito
在 mockito-inline 中，已经支持 mock 静态类和方法、final 类等。已经能够满足日常的单测场景，在我使用 PowerMockito 的场景大部分都是 mock 一个类的私有方法。
那么大家不妨想想，什么情况下你需要 mock 一个私有方法？对，当你需要 mock 一个类的私有方法时，往往是因为这个类的公共方法或其他方法内部调用了这个私有方法。使用 PowerMockito 来 mock 私有方法需要 @PrepareForTest 注解，而这可能会导致 JaCoCo 等代码覆盖率工具无法正确测量被 @PrepareForTest 注解标记的类的覆盖率。这种情况下，我花了大量时间，浪费大量精力，写了大量代码，最后的到一个不能提升指标完成率的结果，我是不乐意的。
那么大家不妨再想想，我们 mock 的私有方法都是一些什么样的逻辑？要么是又臭又长的、要么是超多分支判断的，要么是一些公共使用的。这是我们应该考虑的是优化这类代码，以单测促重构。
技术栈
POM 依赖配置
<dependencies> <!-- ===== 单测-begin ===== --> <!-- mockito-core --> <dependency> <groupId>org.mockito</groupId> <artifactId>mockito-core</artifactId> <version>3.12.4</version> <scope>test</scope> </dependency> <!-- mockito-inline 用于mock静态方法 --> <dependency> <groupId>org.mockito</groupId> <artifactId>mockito-inline</artifactId> <version>3.12.4</version> <scope>test</scope> <exclusions> <exclusion> <artifactId>mockito-core</artifactId> <groupId>org.mockito</groupId> </exclusion> </exclusions> </dependency> <!-- ===== 单测-end ===== --></dependencies>
复制代码
POM 插件配置
<plugin> <groupId>org.jacoco</groupId> <artifactId>jacoco-maven-plugin</artifactId> <version>0.8.3</version> <executions> <!--在unit测试之前--> <execution> <id>pre-unit-test</id> <goals> <goal>prepare-agent</goal> </goals> <configuration> <!--如果surefire插件有设置argLine，则jacoco参数必须以下面形式引入 否则会出现surefire 插件的参数覆盖jacoco功能参数，无法生成 jacoco.exec 文件，导致覆盖率一直为0，可见下面surefire 插件配置--> <propertyName>jacocoArgLine</propertyName> </configuration> </execution> <!-- Default value 参照官网配置 https://www.eclemma.org/jacoco/trunk/doc/report-mojo.html --> <execution> <id>report</id> <phase>test</phase> <goals> <goal>report</goal> </goals> </execution> <!-- Default value 参照官网配置 https://www.eclemma.org/jacoco/trunk/doc/report-aggregate-mojo.html --> <execution> <id>report-aggregate</id> <phase>test</phase> <goals> <goal>report-aggregate</goal> </goals> </execution> </executions></plugin><plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-surefire-report-plugin</artifactId> <version>2.22.2</version></plugin><!--是maven里执行测试用例的插件，默认使用JUnit并执行测试用例（如果配置jacocoArgLine，则此插件配置要在最后，否则获取不到配置项）--><plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-surefire-plugin</artifactId> <version>2.22.2</version> <configuration> <!--忽略测试失败配置：继续打印报告及执行其它module的测试--> <testFailureIgnore>true</testFailureIgnore> <!--跳过测试阶段配置--> <skipTests>false</skipTests> <!--argLine作用指定VM参数--> <argLine>-Dfile.encoding=UTF-8 ${jacocoArgLine}</argLine> <!--如果surefire插件有设置argLine，则下面jacoco必须设置propertyName来形式引入 否则会出现surefire 插件的参数覆盖jacoco功能参数，无法生成 jacoco.exec 文件，导致覆盖率一直为0--> </configuration></plugin>
复制代码
以上，版本自行查询、修改。
第一步：清除杂兵，减少基数
此步骤旨在：消除需要覆盖的代码行的基数。如日常开发中的注解组件：lombok、mapstruct 等，其注解会生成 class 文件。尤其是 lombok 的 @Data、@Builder 注解，一个 10 个字段的类其生成的 eaquals 和 hash 方法就不止 20 行，内部 builder 类代码行数不下原类的 3 倍，同时生成的代码分支较多，较难覆盖，我的解决思路是排除。
lombok 插件
解决方案：在项目根目录中，常见一个名为 lombok.config 的文件，配置如下：
## 声明根配置文件config.stopBubbling=true# 排除单测统计（起作用生成@Generated注解，避免jacoco扫描）lombok.addLombokGeneratedAnnotation=true
复制代码
mapstruct 插件
解决方案：通过升级 mapstruct 版本至 1.3.1 版本及以上。
在 mapstruct 高版本中，生成的代码类上存在 @Generated 注解，该注解声明此类由程序自动生成，告诉 jacoco 在统计单测覆盖率或者其他审计工具进行审计时忽略该类。
第二步：反射出战，摧枯拉朽（进度：0%~25%）
此步骤旨在：节省非核心代码的单测编写时间，让大家有更多时间聚焦更重要的事情。 如 POJO 类、Enum、Mybatis 生成的的 Example、Wrapper 等类，这些类大多为 setter、getter 方法，尤其是 Example 和 Wrapper 类，还内置了一些 eq、between、in 等方法。这些方法的单测如果全部覆盖效果明显，但是意义不大，因此本人取巧，通过反射自动覆盖其 setter、getter 和一些常见的入参类型的方法。反射代码具体实现如下：
package com.xx.xx;
import com.google.common.collect.Lists;import com.google.common.reflect.ClassPath;import lombok.extern.slf4j.Slf4j;import org.junit.Before;import org.junit.Test;import org.junit.runner.RunWith;import org.mockito.junit.MockitoJUnitRunner;
import java.lang.reflect.Constructor;import java.lang.reflect.Method;import java.lang.reflect.Modifier;import java.math.BigDecimal;import java.util.ArrayList;import java.util.Date;import java.util.List;import java.util.Set;
/** * @version 1.0.0 * @date 2024-01-26 19:36 */@Slf4j@RunWith(MockitoJUnitRunner.class)public class PojoCoverTest {
/** * 需要覆盖的包集合 */ private final static List<String> POJO_PACKAGE_LIST = Lists.newArrayList( // --- domain "com.xx.xx.xx.cache.promotion", "com.xx.xx.xx.domain", "com.xx.xx.xx.dto", "com.xx.xx.xx.enums", "com.xx.xx.xx.json", "com.xx.xx.xx.param", "com.xx.xx.xx.pay", "com.xx.xx.xx.result", "com.xx.xx.xx.vo", //--- publish "com.xx.xx.xx.publish.base", "com.xx.xx.xx.publish.result", "com.xx.xx.xx.publish.vo", //--- rpc "com.xx.xx.xx.rpc.vo", "com.xx.xx.xx.rpc.dto", //--- shop "com.xx.xx.xx.shop.param", "com.xx.xx.xx.shop.result", //--- web "com.xx.xx.xx.web.bo", "com.xx.xx.xx.web.config", "com.xx.xx.xx.web.controller.param", "com.xx.xx.xx.web.model", "com.xx.xx.xx.web.vo", //--- service "com.xx.xx.xx.service.event", "com.xx.xx.xx.service.factor.dto", "com.xx.xx.xx.service.factor.enums", "com.xx.xx.xx.service.impl.delivery.param", "com.xx.xx.xx.service.param", "com.xx.xx.xx.service.vo" );
/** * 类加载器 */ private ClassLoader classLoader = null;
@Before public void before() { // 获取当前类加载器 classLoader = Thread.currentThread().getContextClassLoader(); }
/** * 反射执行所有：pojo、enum、exlpame 等基础domain类。 */ @Test public void domainCoverTest() { // 获取class loader for (String packageName : POJO_PACKAGE_LIST) { try { // 加载指定包以及子包的类 ClassPath classPath = ClassPath.from(classLoader); Set<ClassPath.ClassInfo> classInfos = classPath.getTopLevelClassesRecursive(packageName); log.error(">>>>>>> domainCoverTest, packageName:{}, classSize:{}", packageName, classInfos.size()); // 覆盖单测 for (ClassPath.ClassInfo classInfo : classInfos) { this.coverDomain(classInfo.load()); } } catch (Throwable e) { log.error(">>>>>>> domainCoverTest Exception package:{}", packageName, e); } } }
private void coverDomain(Class<?> clazz) { boolean canInstance = this.canInstance(clazz); if (!canInstance) { return; }
// 枚举，执行所有值 if (clazz.isEnum()) { Object[] enumList = clazz.getEnumConstants(); for (Object enumField : enumList) { // 输出每一行枚举值 String enumString = enumField.toString(); } }
// 执行外部类的所有方法 Object outerInstance = null; try { outerInstance = clazz.getDeclaredConstructor().newInstance(); this.method(clazz, outerInstance); } catch (Throwable ignored) { }
// 执行指定内部类的方法 for (Class<?> innerClass : clazz.getDeclaredClasses()) { try { boolean innerCanInstance = this.canInstance(clazz); if (!innerCanInstance) { continue; } boolean isStatic = Modifier.isStatic(innerClass.getModifiers()); Object innerClazzInstance = null; if (isStatic) { Constructor<?> constructor = innerClass.getDeclaredConstructor(); constructor.setAccessible(true); innerClazzInstance = constructor.newInstance(); } else { Constructor<?> constructor = innerClass.getDeclaredConstructor(clazz); constructor.setAccessible(true); innerClazzInstance = constructor.newInstance(outerInstance); } this.method(innerClass, innerClazzInstance); } catch (Throwable ignored) { } } }
private boolean canInstance(Class<?> clazz) { int modifiers = clazz.getModifiers(); boolean isAnnotation = clazz.isAnnotation(); boolean isInterface = clazz.isInterface(); boolean isEnum = clazz.isEnum(); boolean isAbstract = Modifier.isAbstract(modifiers); boolean isNative = Modifier.isNative(modifiers); log.error(">>>>>>> coverDomain class:{}, isAnnotation:{}, isInterface:{}, isEnum:{}, isAbstract:{}, isNative:{}", clazz.getName(), isAnnotation, isInterface, isEnum, isAbstract, isNative); if (isAnnotation || isInterface || isAbstract || isNative) { return false; } // 如果是静态类或者final类，且不是枚举类也不处理 return isEnum || (!Modifier.isFinal(modifiers)); }
/** * 通过反射调用指定实例的方法 * * @param clazz 方法所属的类对象 * @param instance 方法所属的实例对象 */ private void method(Class<?> clazz, Object instance) { for (Method method : clazz.getDeclaredMethods()) { if (!Modifier.isStatic(method.getModifiers())) { method.setAccessible(true); } Class<?>[] parameterTypes = method.getParameterTypes(); try { if (parameterTypes.length == 0) { method.invoke(instance); } else { // null 值覆盖 try { Object[] parameters = new Object[parameterTypes.length]; for (int i = 0; i < parameterTypes.length; i++) { Class<?> paramType = parameterTypes[i]; parameters[i] = this.getValue(paramType, true); } method.invoke(instance, parameters); } catch (Throwable ignore) { } // 非 null 值覆盖 try { Object[] parameters = new Object[parameterTypes.length]; for (int i = 0; i < parameterTypes.length; i++) { Class<?> paramType = parameterTypes[i]; parameters[i] = this.getValue(paramType, false); } method.invoke(instance, parameters); } catch (Throwable ignore) { } } } catch (Throwable ignored) { } } }
/** * 通过类的type 返回对应的默认值， 如果有其他类型请大家自行补充 * * @param type 入参字段类型 * @return 返回对应字段的默认值 */ private Object getValue(Class<?> type, boolean useNull) { if (type.isPrimitive()) { if (type.equals(boolean.class)) { return false; } else if (type.equals(char.class)) { return '\0'; } else if (type.equals(byte.class)) { return (byte) 0; } else if (type.equals(short.class)) { return (short) 0; } else if (type.equals(int.class)) { return 0; } else if (type.equals(long.class)) { return 0L; } else if (type.equals(float.class)) { return 0F; } else if (type.equals(double.class)) { return 0.0; } } if (useNull) { return null; } if (type.equals(String.class)) { return "1"; } else if (type.equals(Integer.class)) { return 1; } else if (type.equals(Long.class)) { return 1L; } else if (type.equals(Double.class)) { return 1.1D; } else if (type.equals(Float.class)) { return 1.1F; } else if (type.equals(Byte.class)) { return Byte.valueOf("1"); } else if (type.equals(List.class)) { return new ArrayList<>(); } else if (type.equals(Short.class)) { return Short.valueOf("1"); } else if (type.equals(Date.class)) { return new Date(); } else if (type.equals(Boolean.class)) { return true; } else if (type.equals(BigDecimal.class)) { return BigDecimal.ONE; } else { // 对于非原始类型和String，我们不提供默认值，即不传递参数 return null; } }}
复制代码
点击并拖拽以移动
代码释义：将指定包名下的类通过反射执行代码逻辑；通过反射执行类以及内部类的方法，如方法参数为基本数据类型、Date、BigDecimal 等则设置默认值进行覆盖（枚举遍历输出枚举值）。
实战效果如下图，单单以 domain 模块为例（其实在 common、mananger、publish、rpc、task 等模块中也有部分 pojo 类），如将 domain 推到 100%，则全量单测覆盖率增加 18%以上。加上其他模块的 pojo 类、enum 类等，全量单测覆盖率基数提升 25%不困难。
第三步：法宝致胜，快速生成（进度：25%~60%）
完成第二步，我们解决了非核心的边缘代码的单测，此时项目基本上会有一个 20%~25%的基础覆盖率。下面我们就要对 util、service、controller 进行覆盖，此时我们可以使用工具帮助我们快速生成单测。推荐 Diffblue、SquareTest 或者 TestMe，这三个工具都是用过，从功能和生成单测的质量排序：Diffblue > SquareTest > TestMe。
Diffblue 是收费的，基于 AI 实现，国内好像没法办使用了，之前通过一些技数手段用过，单测效果 very good！其配套能力丰富、能批量生成，生成单测的质量也是杠杠的。
SquareTest 目前也收费了，复杂类的单测覆盖率在 20~40%左右，简单的单测覆盖率在 50~80%，综合平均覆盖率在 30~50%左右，去年也是痛下决心花了数百大洋交了个懒人费。SquareTest 官方网站： Squaretest - Java Unit Test Generator for IntelliJ IDEA （内含视频教程呦！）
TestMe 是免费的，同样的单测质量和功能性比前两者有所不如，毕竟免费嘛，要求这么多干嘛😜。
实战效果如下图（采用 SquareTest），红色框内的我也补充了部分类的详细单测，记忆中是从 55%推到 60%的，也就是说 SquareTest 将我的单测从 26%推到了 55%，对于这个有着 10 年年龄的代码库，能提升了 29%还是满意的。
讲到单测工具，不得不提这两年很火的 AI，上文提到的 Diffblue 就是基于 AI 实现。在我任职的公司也提供了内部的 AI 工具，名为：joyCoder。
在使用 joyCoder 时，其单测通过率相比 SquareTest 更高一些，覆盖率也更好一些，但使用过程中也有一些不便：
1.一个类的行数超过 2000 行，它就拒绝给我生成单测了
2.无法直接生成文件，需要创建单测类后再将生成代码 copy 进去。
3.需要告知 joycoder 单测要求，不然常常生成示例代码。
基于以上我将 joyCoder 作为增量代码的单测生成利器。将 SquareTest 作为存量代码的单测生成利器。
增量代码的单测在 joyCoder 的生成的基础上，在进行手动调参。完成超高的单测覆盖。
第四步：特例分析，内功小成（进度：60%~70%）
针对工具生成单测的时候一些覆盖不到的代码，手动调整时高频遇到的一些问题进行整理。
mock 静态方法
以下示例中 SkuImportUtil 是一个静态类，有 public static 方法 getSkusFromExcel。
@Testpublic void importSkus_setEx_true() { // mock MultipartFile MultipartFile file = new MockMultipartFile("file", "test.xlsx", "application/vnd.ms-excel", "excel".getBytes()); // mock SkuImportUtil MockedStatic<SkuImportUtil> mocked = mockStatic(SkuImportUtil.class); mocked.when(() -> SkuImportUtil.getSkusFromExcel(eq(file), any(StringBuilder.class), anyInt())).thenReturn(Sets.newHashSet("1")); // mock cache when(cacheService.setEx(anyString(), anyString(), anyLong(), eq(false))).thenReturn(true); // call Result<String> result = performanceController.importSkus(file); assert ResultCodeEnum.SUCCESS.getCode().equals(result.getCode());}
复制代码
mock 自调用（public 方法）
自调用表示一个对象在其自身的其他方法中调用自己的方法，如存在一类，该类存在 A、B 两个方法，A 方法内部调用本类的 B 方法。
这里 mock 的是自调用方法中的被 public 修饰的被调用方。
以下示例中存在 PerformanceController 类，存在两个 public 类：doSave 和 doUpdate，其中 doSave 方法内部调用了 doUpdate 方法。
简化代码如下：
@RequestMapping("doSave")@ResponseBodypublic Result<String> doSave(@RequestBody PerformanceConfigParam param) { String pin = PinSupport.getPin(); log.info("PerformanceController.doSave pin:{}, param:{}", pin, JSON.toJSONString(param)); String importSkuKey = param.getImportSkuKey(); if (StringUtils.isNotBlank(importSkuKey)) { // 导入模式 ... } else { // 录入模式 ... } // 参数校验 ...
// 保存数据 return this.doUpdate(param);}
@RequestMapping("doUpdate")@ResponseBodypublic Result<String> doUpdate(@RequestBody PerformanceConfigParam param) { String pin = PinSupport.getPin(); LogTypeEnum.DEFAULT.info("PerformanceController.doUpdate pin:{}, param:{}", pin, JSON.toJSONString(param)); // 1.数据预校验 ... // 2.数据预处理 ... // 3.数据库操作 ... }
复制代码
示例单测如下：
@RunWith(MockitoJUnitRunner.class)public class PerformanceControllerSpyTest { @Spy @InjectMocks private PerformanceController performanceController;
@Mock private CacheService cacheService;
@Test public void save_import() { // mock cache when(cacheService.get(anyString())).thenReturn("[1,2]"); // mock doUpdate doReturn(Result.success(true)).when(performanceController).doUpdate(any()); // call PerformanceConfigParam param = new PerformanceConfigParam(); param.setImportSkuKey("cacheKey"); performanceController.doSave(param); // assert assert "0".equals(result.getCode()); }}
复制代码
需注意，这里 mock 类需要使用 @Spy 进行标记，并且 mock 本类其他方法时，需要先 doXxx().when().xxx(); 不然会真实调用。
mock final 类
在切面类中常常用到一个 Method 类，此类是一个 final 类，mock 被 final 修饰的类可能引发不可预知的异常。
mock final 类常常出现于 AOP 切面中，单测示例代码如下
@Testpublic void secKey_empty() throws Throwable { // mock ProceedingJoinPoint ProceedingJoinPoint joinPoint = mock(ProceedingJoinPoint.class); // mock MethodSignature MethodSignature signature = mock(MethodSignature.class); when(joinPoint.getSignature()).thenReturn(signature); // mock Method (final) Method method = mock(Method.class); when(method.getName()).thenReturn("mockMethod"); when(signature.getMethod()).thenReturn(method); // mock param JosBaseParam param = new JosOrderQuery(); when(joinPoint.getArgs()).thenReturn(new Object[]{param}); // mock duccConfig when(josDucc.getAppSecKeyConfig()).thenReturn(new HashMap<>()); // call josSecKeyAspect.around(joinPoint);}
复制代码
mock 多次调用不同结果
适用于一个方法内多次调用某个方法，常见遍历处理某些数据，处理结果为空、异常、正常等个判断。
示例代码
public void delSkuTemplateRelationByTemplateId(Long templateId) { List<Long> skuList = skuGroupCacheUtil.getTemplateSkuIdsByTemplateIdNew(templateId); if (skuList == null) { return; } List<RSkuTemplateRelation> cacheList = new ArrayList<>(); List<RSkuTemplateRelation> deleteList = new ArrayList<>(); for (Long sku : skuList) { List<RSkuTemplateRelation> relationList = rSkuTemplateService.getSkuTemplateRelationBySku(sku); if (relationList == null) { continue; } for (RSkuTemplateRelation relation : relationList) { if (Long.valueOf("99").equals(relation.getModelId())) { deleteList.add(relation); } else { cacheList.add(relation); } } } cacheService.batchOriginalSetEx(cacheList); cacheService.originalDel(deleteList);}
复制代码
示例单测
使用 eq() 进行匹配，它告诉 Mockito 只有当 mock 的方法的参数等于某个值的时，才认为方法调用是正确的。
@Testpublic void delSkuTemplateRelationByTemplateId() throws Exception { // mock 查询为空场景 when(skuGroupCacheUtil.getTemplateSkuIdsByTemplateIdNew(anyLong())).thenReturn(Lists.newArrayList(1L, 2L, 3L)); when(rSkuTemplateService.getSkuTemplateRelationBySku(eq(1L))).thenReturn(null); // mock 正常结果 RSkuTemplateRelation r2 = new RSkuTemplateRelation(); r2.setModelId(2L); when(rSkuTemplateService.getSkuTemplateRelationBySku(eq(2L))).thenReturn(Lists.newArrayList(r2)); // mock 异常结果 RSkuTemplateRelation r3 = new RSkuTemplateRelation(); r3.setModelId(99L); when(rSkuTemplateService.getSkuTemplateRelationBySku(eq(3L))).thenReturn(Lists.newArrayList(r3)); // mock cache batchOriginalSetEx doNothing().when(cacheService).batchOriginalSetEx(anyList()); // mock cache originalDel when(cacheService.originalDel(anyList())).thenReturn(1L); // call rSkuTemplateService.delSkuTemplateRelationByTemplateId(2L);}
复制代码
第五步：另辟蹊径，重增略存（进度：70%~85%）
此步骤旨在：基于研发资源长期紧张的情况下，重视增量单测，对新开发的功能进行重点测试，可以确保新加入的代码不会破坏现有的功能，保持软件质量。简略存量单测，对于已有的代码，如果资源有限，采取简略测试可以节省时间和成本。随着需求的更新换代，逐步完善单元测试，可以确保测试覆盖率随时间提高，而不是一开始就追求完美。
修改 private 方法的修饰符为 public
参考【落地实践】中第四步【mock 自调用（public 方法）】的形式，但是个人不建议这样搞，毕竟破坏了封装特性，降低了类、方法的安全性。建议通过设计模式，如策略、装饰器、工厂等实现，或这将其抽成为辅助类。
使用线上 JSON 化数据进行单测回放
此方案借鉴了公司的压测平台，通过录制生产环境的流量（包括入参、cookie 等），并在预发环境进行回放压测。具体操作是，基于生产环境的入参 JSON 和各依赖服务的返回结果 JSON 作为录制的单元测试数据，在单元测试中通过 jsonRead 方法进行反序列化后执行。
引入 POM 如下：
<!-- JSON 解析 --><dependency> <groupId>com.jayway.jsonpath</groupId> <artifactId>json-path</artifactId> <version>2.7.0</version></dependency>
复制代码
json 读取工具类
package com.xx.xx.xx;
import com.alibaba.fastjson.JSON;import com.alibaba.fastjson.TypeReference;import com.jayway.jsonpath.DocumentContext;import com.jayway.jsonpath.JsonPath;import lombok.extern.slf4j.Slf4j;
import java.io.File;import java.util.Objects;
/** * JsonReadUtil * https://github.com/json-path/JsonPath * * @version 1.0 * @date 2021-04-26 15:54:00 */@Slf4jpublic class JsonReadUtil {
/** * 从指定的文件路径中读取JSON数据并根据给定的JSON路径和类解析成指定的对象 * * @param filePath 文件路径 * @param jsonPath JSON路径 * @param clazz 解析的对象类型 * @return 解析后的对象，如果读取失败则返回null * @throws Exception 读取过程中可能抛出的异常 */ public <T> T readJson(String filePath, String jsonPath, Class<T> clazz) throws Exception { File file = new File(Objects.requireNonNull(this.getClass().getResource("/" + filePath)).toURI()); DocumentContext ctx = JsonPath.parse(file); Object read = ctx.read(jsonPath); if (read != null) { return JSON.parseObject(JSON.toJSONString(read), clazz); } else { return null; } }
/** * 从指定的JSON文件中读取指定路径的数据 * * @param filePath JSON文件路径 * @param jsonPath JSON数据路径 * @param type 数据类型的引用 * @return 读取到的数据对象 * @throws Exception 读取过程中可能出现的异常 */ public <T> T readJson(String filePath, String jsonPath, TypeReference<T> type) throws Exception { File file = new File(Objects.requireNonNull(this.getClass().getResource("/" + filePath)).toURI()); DocumentContext ctx = JsonPath.parse(file); Object read = ctx.read(jsonPath); if (read != null) { return JSON.parseObject(JSON.toJSONString(read), type); } else { return null; } }}
复制代码
单测代码示例
@Testpublic void validator_fail() throws Exception { PerformanceConfigParam param = new JsonReadUtil().readJson( "mock/SavePre03ShopGroupValidatorTest.json" , "$.fail_param" , PerformanceConfigParam.class ); param.setAvailableMap(new HashMap<Long, List<Long>>() {{ put(1L, Lists.newArrayList(100069042303L, 2L)); }}); List<LocShopProductInfoVO> locShopList = new JsonReadUtil().readJson( "mock/SavePre03ShopGroupValidatorTest.json" , "$.fail_locShopList" , new TypeReference<List<LocShopProductInfoVO>>() { } ); List<TemplateProviderRelation> tpRelationList = new JsonReadUtil().readJson( "mock/SavePre03ShopGroupValidatorTest.json" , "$.fail_tpRelationList" , new TypeReference<List<TemplateProviderRelation>>() { } );
List<ServiceProvider> serviceProviderList = new JsonReadUtil().readJson( "mock/SavePre03ShopGroupValidatorTest.json" , "$.fail_serviceProviderList" , new TypeReference<List<ServiceProvider>>() { } ); when(locShopDataEsSearchService.queryLocShopByShopIds(anyList())).thenReturn(locShopList); when(templateProviderRelationService.queryRelationByTemplateId(anyList())).thenReturn(tpRelationList); when(cacheService.setEx(anyString(), anyString(), anyLong(), anyBoolean())).thenReturn(true); when(serviceProviderDao.queryServiceProviderByIds(anyList())).thenReturn(serviceProviderList); savePre03ShopGroupValidator.validator(param);}
复制代码
单侧覆盖效果截图，准备了成功和失败的两个参数，覆盖率高达 97%（类中依赖较少，但是有很多的 list 转 map，map 遍历等行为）。
第六步：以单测促重构，登顶高峰（进度：85%~95%）
《重构：改善既有代码的设计》提出的观点强调了单元测试在软件开发中的重要性，尤其是在代码重构的过程中：
•安全保障：单元测试构建了重构的安全网，确保重构不会改变代码的预期行为。
•质量提升：单元测试促进开发者编写易于测试的模块化代码，间接提高代码质量。
•重构工具：单元测试不仅是检测质量的工具，还是推动代码结构优化的重要手段。
•代码文档：测试用例也充当了代码的实时文档，帮助理解和维护代码。
由此可见，单测不单单是质量检测工具，还是代码重构的重要手段，更是保证重构质量的重要工具。
那么在我们开发中如何重构呢？
1、不对自己不熟悉的代码进行重构（熟悉成本、试错成本、测试成本）
2、小步快进，如果要重构三层及以上依赖的防范则认为是架构级重构，需要完成至少 2 个架构师交叉评审、协调测试资源后才能重构。三层以下则认为是微重构，鼓励微重构。
3、一个类很多私有方法时，将私有方法转为辅助的函数类（方便单测、主次分离、主干清晰）。
4、多使用设计模式。
5、多使用分治思想。
6、精炼、抽象共有能力。
注意事项
1、上述中【落地实践】【第二步】反射注意事项。
建议单独建立一个 maven module，并在最后编译。因为用到了类加载器，避免对其他单测的影响，放到最后执行，通过<module>的顺序实现，代码片段如下
因为同项目下存在 war 包模块，则需要对其进行改造，在编译不仅打了 war 包，还要打出 jar 包（不会对已有产生影响），需要在 pom 中配置 plugin，如下
<!-- 将war下class打包附属jar，额外的操作不影响 --><plugin> <artifactId>maven-jar-plugin</artifactId> <version>3.2.0</version> <executions> <execution> <id>make-a-jar</id> <phase>package</phase> <goals> <goal>jar</goal> </goals> <configuration> <classifier>classes</classifier> <includes> <include>**/*.class</include> </includes> </configuration> </execution> </executions></plugin>
复制代码
以上完成整个配置。
2、包装类传 null 值要用 any() mock
在使用 Mockito 进行单元测试时，如果你需要 mock 一个方法，其参数是 Long 这样的包装类型，并且这个参数可能为 null，确实需要使用 any()而不是 anyLong()。
anyXxx()是用于匹配任何非 null 的 xxx 或 Xxx 类型的值，而 any()则更加通用，可以匹配任何类型的值，包括 null。
除此之外，还可以使用以下形式进行 mock（个人比较喜欢此类方法）
when(mockOrderService.queryOrderById(any(Long.class))).thenReturn(new Order());
复制代码
评论