程序员社区
当前位置：IDEA激活码 > 未分类 > 正文

最佳单元测试实践

2022-02-04 分类：未分类 阅读(335)

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
    }
}

这样的写法不符合规范的地方如下：

  1. 使用 @SpringBootTest注解将主启动类 Application 的 BeanDefintion 加入到了 Spring 容器中，从而加载了所有的 Bean，导致大量的时间耗费在于容器启动上。而且，如果被 @Component 注解的类里有多线程方法，那么在你执行单元测试的时候，由于多线程任务的影响，就可能对你的数据库造成了数据修改，即使你使用了事务回滚注解 @Transactional。
    • eg. 在我运行单元测试的时候，代码里的其他类的多线程中不停接收activeMQ消息，然后更新数据库中对应的数据。跟单元测试的执行过程交叉重叠，导致单元测试失败。其他组员在操作数据库的时候，也因为我无意中带起的多线程更改了数据库，造成了开发上的困难。
  2. 单元测试应与数据库完全隔离（不应受到外界环境的影响，违反了可重复的原则），数据库相关操作应使用 mock 代替。
  3. 没有使用断言（assert），无法实现自动化判断。

一、单元测试的原则

1.1 AIR 原则

  • Automatic（自动化的）：自动通过一系列的断言给出执行结果，而不需要人为去判断，在几十上百的测试用例下很难人为的去判断。
  • Independent（独立的）：测试用例之间不能相互依赖影响，是独立的
  • Repeatable（可重复的）：单元测试是可以重复执行的，不能受到外界环境的影响，如数据库、远程调用、中间件等外部依赖不能影响测试用例的执行。

1.2 BCDE 原则

保证被测试模块的交付质量。

  • B：Border，边界值测试，包括循环边界、特殊取值、特殊时间点、数据顺序等。
  • C：Correct，正确的输入，并得到预期的结果。
  • D：Design，与设计文档相结合，来编写单元测试。
  • E：Error，强制错误信息输入（如：非法数据、异常流程、业务允许外等），并得到预期的结果。

1.3 使用 Mock 对象

  1. Mock 可以用来解除外部服务依赖，从而保证了测试用例的独立性

  2. Mock 可以减少全链路测试数据准备，从而提高了编写测试用例的速度

    传统的集成测试，需要准备全链路的测试数据，可能某些环节并不是你所熟悉的。最后，耗费了大量的时间和经历，并不一定得到你想要的结果。现在的单元测试，只需要模拟上游的输入数据，并验证给下游的输出数据，编写测试用例并进行测试的速度可以提高很多倍。

  3. Mock可以模拟一些非正常的流程，从而保证了测试用例的代码覆盖率

    根据单元测试的BCDE原则，需要进行边界值测试（Border）和强制错误信息输入（Error），这样有助于覆盖整个代码逻辑。在实际系统中，很难去构造这些边界值，也能难去触发这些错误信息。而 Mock 从根本上解决了这个问题：想要什么样的边界值，只需要进行Mock；想要什么样的错误信息，也只需要进行Mock。

  4. Mock可以不用加载项目环境配置，从而保证了测试用例的执行速度
    在进行集成测试时，我们需要加载项目的所有环境配置，启动项目依赖的所有服务接口。往往执行一个测试用例，需要几分钟乃至几十分钟。采用Mock实现的测试用例，不用加载项目环境配置，也不依赖其它服务接口，执行速度往往在几秒之内，大大地提高了单元测试的执行速度。

什么是集成测试？

集成测试是指在单元测试的基础上，将所有模块（或单元）按照设计要求（如根据结构图）组装成为子系统或系统，进行集成测试。

实践表明，一些模块虽然能够单独地工作，但并不能保证连接起来也能正常的工作。 一些局部反映不出来的问题，在全局上很可能暴露出来。

由于集成测试的单位是一整个系统，一般有专业的测试人员来进行，本文只做简单介绍，不继续探讨。

二、最佳实践

写好单元测试，以下两点尤为重要：

  1. 使用 Mock 脱离数据库
  2. 不使用@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，那么应该将其拆分成两个单元来测试：

  1. TestController + mockService
  2. 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
    @Configuration
    public static class AsyncTestConfig {
    }
}
赞(0) 打赏
未经允许不得转载：IDEA激活码 » 最佳单元测试实践

相关推荐

IDEA永久激活破解教程,IDEA激活码

pycharm激活破解教程,pycharm激活码

Java视频资源

Java电子书

DataGrip激活教程 Docker Git教程 IntellIJ idea IntelliJ IDEA激活码 Java Java IO Java基础 Java基础面试题 Java集合面试题 Java面试题 JVM JVM面试题 Linux MySQL MySQL面试题 Nginx PyCharm PyCharm激活 redis Redis SpringBoot SpringBoot SpringBoot面试题 Web开发 剑指Offer系列 多线程 多线程并发面试题 字符串面试题 数据库 数据库 数据结构与算法 未分类 爬虫 电子书 软件下载

一个分享Java & Python知识的社区