title: 最佳单元测试实践
date: 2021/09/08 15:11

注：本文使用的是 SpringBootTest2.x + Junit4 + Mockito，本文的前提是你已经会使用这些工具了。

引言：常见单元测试方法

@RunWith(SpringRunner.class)    
@SpringBootTest(classes = Application.class)    // 1
@Transactional  // 2
@Rollback
public class HelloServiceTest {
    @Autowired
    private HelloService helloService;
    @Test
    public void sayHello() {
        helloService.sayHello("zhangsan");  // 3
这样的写法不符合规范的地方如下：
使用 @SpringBootTest注解将主启动类 Application 的 BeanDefintion 加入到了 Spring 容器中，从而加载了所有的 Bean，导致大量的时间耗费在于容器启动上。而且，如果被 @Component 注解的类里有多线程方法，那么在你执行单元测试的时候，由于多线程任务的影响，就可能对你的数据库造成了数据修改，即使你使用了事务回滚注解 @Transactional。
eg. 在我运行单元测试的时候，代码里的其他类的多线程中不停接收activeMQ消息，然后更新数据库中对应的数据。跟单元测试的执行过程交叉重叠，导致单元测试失败。其他组员在操作数据库的时候，也因为我无意中带起的多线程更改了数据库，造成了开发上的困难。
单元测试应与数据库完全隔离（不应受到外界环境的影响，违反了可重复的原则），数据库相关操作应使用 mock 代替。
没有使用断言（assert），无法实现自动化判断。
一、单元测试的原则
1.1 AIR 原则
Automatic（自动化的）：自动通过一系列的断言给出执行结果，而不需要人为去判断，在几十上百的测试用例下很难人为的去判断。
Independent（独立的）：测试用例之间不能相互依赖影响，是独立的
Repeatable（可重复的）：单元测试是可以重复执行的，不能受到外界环境的影响，如数据库、远程调用、中间件等外部依赖不能影响测试用例的执行。
1.2 BCDE 原则
保证被测试模块的交付质量。
B：Border，边界值测试，包括循环边界、特殊取值、特殊时间点、数据顺序等。
C：Correct，正确的输入，并得到预期的结果。
D：Design，与设计文档相结合，来编写单元测试。
E：Error，强制错误信息输入（如：非法数据、异常流程、业务允许外等），并得到预期的结果。
1.3 使用 Mock 对象
Mock 可以用来解除外部服务依赖，从而保证了测试用例的独立性
Mock 可以减少全链路测试数据准备，从而提高了编写测试用例的速度
传统的集成测试，需要准备全链路的测试数据，可能某些环节并不是你所熟悉的。最后，耗费了大量的时间和经历，并不一定得到你想要的结果。现在的单元测试，只需要模拟上游的输入数据，并验证给下游的输出数据，编写测试用例并进行测试的速度可以提高很多倍。
Mock可以模拟一些非正常的流程，从而保证了测试用例的代码覆盖率
根据单元测试的BCDE原则，需要进行边界值测试（Border）和强制错误信息输入（Error），这样有助于覆盖整个代码逻辑。在实际系统中，很难去构造这些边界值，也能难去触发这些错误信息。而 Mock 从根本上解决了这个问题：想要什么样的边界值，只需要进行Mock；想要什么样的错误信息，也只需要进行Mock。
Mock可以不用加载项目环境配置，从而保证了测试用例的执行速度

在进行集成测试时，我们需要加载项目的所有环境配置，启动项目依赖的所有服务接口。往往执行一个测试用例，需要几分钟乃至几十分钟。采用Mock实现的测试用例，不用加载项目环境配置，也不依赖其它服务接口，执行速度往往在几秒之内，大大地提高了单元测试的执行速度。
什么是集成测试？
集成测试是指在单元测试的基础上，将所有模块（或单元）按照设计要求（如根据结构图）组装成为子系统或系统，进行集成测试。
实践表明，一些模块虽然能够单独地工作，但并不能保证连接起来也能正常的工作。 一些局部反映不出来的问题，在全局上很可能暴露出来。
由于集成测试的单位是一整个系统，一般有专业的测试人员来进行，本文只做简单介绍，不继续探讨。
二、最佳实践
写好单元测试，以下两点尤为重要：
使用 Mock 脱离数据库
不使用@SpringBootTest注解加载全部 BeanDefinition，转而使用@ContextConfiguration注解加载需要的配置类
2.1 使用 Mock 代替数据库
mockito 为 Junit 提供了MockitoJUnitRunner用于解析单元类中 mockito 相关注解。当然使用 SpringRunner 也行，因为他内置了 MockitoTestExecutionListener 来处理 mockito 的注解。
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.Arrays;
import java.util.List;
@RunWith(MockitoJUnitRunner.class)
// 使用 SpringRunner 也行，因为他内置了 MockitoTestExecutionListener 来处理 mockito 的注解
// @RunWith(SpringRunner.class)
public class MockitoTest {
     * 如 UserService 是接口，则需 new 出他的实现类，如下：
     * <pre> {@code
     * @InjectMocks
     * private UserService userService = new UserServiceImpl();
     * }</pre>
     * 否则使用 @InjectMocks 注解无法注入
    @InjectMocks
    private UserService userService;
    @Mock
    private UserRepository userRepository;
    @Test
    public void test() {
        // 模拟依赖方法
        Mockito.when(userRepository.findAll())
                .thenReturn(Arrays.asList(new User(1, "zs"), new User(2, "ls")));
        // 调用被测方法
        List<User> users = userService.listAll();
        // 断言方法结果
        Assert.assertEquals(2, users.size());
        // 验证依赖方法
        // 是否只调用了一次 findAll() 方法
        Mockito.verify(userRepository).findAll();
        // 是否与 userRepository 对象再无交互
        Mockito.verifyNoMoreInteractions(userRepository);
注：如对象较大，则可在类路径下存放 json 文件，通过 Json 工具将其序列化成对象。
Junit5 版，注意 Test 注解的包名与上面不同
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.jupiter.MockitoExtension;
import java.util.Arrays;
import java.util.List;
@ExtendWith(MockitoExtension.class)
//@ExtendWith(SpringExtension.class)
public class MockitoTest {
    @InjectMocks
    private UserService userService;
    @Mock
    private UserRepository userRepository;
    @Test
    public void test() {
        // 模拟依赖方法
        Mockito.when(userRepository.findAll())
                .thenReturn(Arrays.asList(new User(1, "zs"), new User(2, "ls")));
        // 调用被测方法
        List<User> users = userService.listAll();
        // 断言方法结果
        Assertions.assertEquals(2, users.size());
        // 验证依赖方法
        // 是否只调用了一次 findAll() 方法
        Mockito.verify(userRepository).findAll();
        // 是否与 userRepository 对象再无交互
        Mockito.verifyNoMoreInteractions(userRepository);
如果一个方法的调用链路如下：Controller -> Service -> Repo，那么应该将其拆分成两个单元来测试：
TestController + mockService
TestService -> mockRepo
如果在测试Controller 的时 mock 了Repo（TestController + @Autowired Service + mockRepo），这样这就不能叫做单元测试了。
单元测试只保证每个单元能够单独地工作，但并不能保证连接起来也能正常的工作；上面这种多个跨了多个单元的应该使用集成测试。
2.2 只加载需要的 Bean
上面的写法只适用于不使用 Spring 给我们提供的功能情况下，但往往有的时候我们需要他们给我们提供的功能，就比如通过@Async注解启动异步任务。那么这种情况我们要怎样做单元测试呢？让我们回到没有 SpringBoot 的时代，看看 Spring Test 是怎样进行单元测试的。
Spring Test 为我们提供了@ContextConfiguration注解，该注解可以加载 Spring 的 xml 配置文件和配置类，使用方式如下：
被测试 bean：
@Component
public class AsyncService {
    private static final Logger log = LoggerFactory.getLogger(AsyncService.class);
    @Autowired
    private FeginClient feginClient;
    @Async
    public Future<Integer> startTask(String taskInstanceId) {
        log.info("taskInstanceId：「{}」", taskInstanceId);
        return new AsyncResult<>(feginClient.calc(taskInstanceId));
单元测试：
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.task.TaskExecutionAutoConfiguration;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.concurrent.ExecutionException;
@RunWith(SpringRunner.class)
// 只引入需要的 bean
@ContextConfiguration(classes = {
        // 被测 bean
        AsyncService.class,
        // 开启异步注解解析
        SpringTest2.AsyncTestConfig.class,
        // 线程池默认的自动配置类，如果自定义了则替换成自定义的配置类
        TaskExecutionAutoConfiguration.class
public class SpringTest2 {
     * 由于需要使用 Spring 提供的异步功能，故需要使用 Spring 提供的 Mock 注解
    @MockBean
    private FeginClient feginClient;
     * AsyncService 中依赖了 FeginClient，会将上面 mock 的对象进行 DI
    @Autowired
    private AsyncService asyncService;
    @Test
    public void testCalc() throws ExecutionException, InterruptedException {
        // 模拟依赖方法
        Mockito.when(feginClient.calc(ArgumentMatchers.anyString())).thenReturn(1);
        // 调用被测方法
        Integer result = asyncService.startTask("1").get();
        // 断言方法结果
        Assert.assertEquals(1, result.intValue());
        // 验证依赖方法
        Mockito.verify(feginClient).calc(ArgumentMatchers.anyString());
        Mockito.verifyNoMoreInteractions(feginClient);
    @EnableAsync