前言
近两年来,单测这玩意儿又火起来了!各厂开始重视单测通过、覆盖率;连带着,程序猿们的日常也多了一丝严谨。不再是简单的写写代码,提交提交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。
@Test
public 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")
@ResponseBody
public 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")
@ResponseBody
public 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切面中,单测示例代码如下
@Test
public 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的方法的参数等于某个值的时,才认为方法调用是正确的。
@Test
public 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
*/
@Slf4j
public 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;
}
}
}
单侧参数示例
单测代码示例
@Test
public 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>
war包模块改造完后,单测模块如何引入?如下:
以上完成整个配置。
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());