SpringBoot 教程核心功能-单元测试

1. JUnit5 简介

 

SpringBoot 2.2.0 版本开始引入 JUnit5 作为单元测试默认库

作为新版本的 JUnit 框架，JUnit5 与之前的版本的 JUnit 框架有很大的不同。由三个不同子项目的几个不同模块组成。

JUnit5 = JUnit Platform + JUnit Jupiter + JUnit Vintage

• JUnit Platform ：JUnit Platform 是在 JVM 上启动测试框架的的基础，不仅支持 JUnit 自制的测试引擎，其他测试引擎也可以接入
• JUnit Jupiter ：JUnit Jupiter 提供了 JUnit5 的新的编程模型，是 JUnit5 新特性的核心。内部包含了一个测试引擎，用于在 JUnit5 Platform 上运行。
• JUnit Vintage ：由于 JUnit 已经发展多年，为了照顾老项目，JUnit Vintage 提供了兼容 JUnit4.x，JUnit3.x 的测试引擎。

注意：SpringBoot 2.4 以上版本默认移除了 JUnit Vintage 的依赖。如果需要兼容 JUnit4 需要自行引入。如果要继续兼容 JUnit4 需要自行引入 JUnit Vintage。

    org.junit.vintage
    junit-vintage-engine
    test
    
        
            org.hamcrest
            hamcrest-core
        
    

单元测试的依赖：

        
            org.springframework.boot
            spring-boot-starter-test
            test
        

 

现在版本使用方式：

@SpringBootTest
class Boot05Web01ApplicationTests {

    @Test
    void contextLoads() {
    }
}

之前版本使用方式：

@SpringBootTest
@RunWith(SpringTest.class)
class XxxTests {
}

SpringBoot 整合 Junit 后

• 编写测试方法：@Test 标注（注意使用 Junit5 版本的注解）
• Junit 类具有 Spring 的功能， @Autowired、@Transaction 等 标注的测试方法

2.Junit5 常用注解

官方文档注解描述

• @Test ：表示方法是测试方法。但是与 JUnit4 不同，他的职责非常单一不能声明任何属性，拓展的测试将会有 Jupiter 提供额外测试。
• @ParameterizedTest：表示方法是参数化测试，下发有详细介绍。
• @RepeatedTest：表示方法可重复执行，下方会有详细介绍。
• @DisplayName：为测试类或者测试方法设置展示名称 
• @BeforeEach：表示在每个单元测试之前执行。
• @AfterEach：表示在每个单元测试之后执行。
• @BeforeAll：表示在所有单元测试之前执行。
• @AfterAll：表示在所有单元测试之后执行。
• @Tag：表示单元测试类别，类似于 Junit4 中的 @Categories
• @Disabled：表示测试或测试方法不执行，雷速与 Junit4 中的 @Ignore
• @Timeout：表示测试方法运行如果超过了指定时间将会返回错误
• @ExtendWith：为测试类或测试方法提供扩展类引用

@SpringBootTest //@SpringBootTest 就是一个复合注解，它内部包含 @ExtendWith({SpringExtension.class})。加上此注解表示支持 SpringBoot 功能
@DisplayName("测试 Junit5")
public class Junit5Test {
    @DisplayName("测试 testDisplayName")
    @Test
    void testDisplayName() {
        System.out.println(1);
    }

    @Test
    void test2() {
        System.out.println(2);
    }

    @RepeatedTest(value = 4)
    @Test
    void testRepeatedTest(){
        System.out.println(3);
    }

    @Disabled
    @Test
    void testDisabled() {
        System.out.println(5);
    }

    @Timeout(1) //执行时间超过1秒异常 java.util.concurrent.TimeoutException
    @Test
    void testTimeout() throws InterruptedException {
        Thread.sleep(1100);
    }

    /**
     * @ValueSource 注解为每次执行传入的参数
     *    本次输出的结果：
     *      每次开始前执行
     *      11
     *      每次结束执行
     *
     *      每次开始前执行
     *      22
     *      每次结束执行
     *
     *      每次开始前执行
     *      33
     *      每次结束执行
     */
    @ParameterizedTest
    @ValueSource(strings={"11","22","33","44","55"})
    void testParameterizedTest(String param) {
        System.out.println(param);
    }

    @BeforeEach
    void testBeforeEach() {
        System.out.println("每次开始前执行");
    }

    @AfterEach
    void testAfterEach() {
        System.out.println("每次结束执行");
    }

    //@BeforeAll 标注的方法必须是 static
    @BeforeAll
    static void testBeforeAll(){
        System.out.println("全部开始前执行");
    }

    //@AfterAll 标注的方法必须是 static
    @AfterAll
    static void testAfterAll() {
        System.out.println("全部结束后执行");
    }
}

3.断言

断言 Assertion 是测试方法中的核心部分，用来对测试需要满足的条件进行验证。这些断言的方法都是 org.junit.jupiter.api.Assertions 的静态方法。检查业务逻辑返回的数据是否合理。所有的测试运行结束以后，会有一个详细的测试报告。所有推荐使用断言机制。

3.1 简单断言

用来验证对单个值进行简单的验证。如：

方法	说明
assertEquals	判断两个对象或两个原始类型是否相等
assertNotEquals	判断两个对象或两个原始类型是否不相等
assertSame	判断两个对象引用是否指向同一个对象
assertNotSame	判断两个对象引用是否指向不同对象
assertTrue	判断给定的布尔值是否为 true
assertFalse	判断给定的布尔值是否为 false
assertNull	判断给定的对象引用是否为 null
assertNotNull	判断给定的对象引用是否不为 null

   /**
     * 断言：前面断言失败，后面的代码不会继续执行
     */
    @Test
    @DisplayName("测试简单断言")
    void testSimpleAssertions() {
        int v = add(2,3);
        //判定相等
        assertEquals(5,v);
//        assertEquals(6,v,"不相等");
        assertNotEquals(6,v);
        Object obj1 = new Object();
        Object obj2 = new Object();
//        assertSame(obj1,obj2,"两个对象不一样");
        assertNotSame(obj1,obj2);
        assertTrue(true);
        assertFalse(false);
        assertNull(null);
        assertNotNull(obj1);
    }

    int add(int i, int j){
        return i+j;
    }

3.2 数组断言

    @Test
    @DisplayName("测试数组断言")
    void testArray() {
        assertArrayEquals(new int[]{1,2}, new int[]{1,2});
    }

3.3 组合断言

    /**
     * 只有所有断言成功，才能往下走
     */
    @Test
    @DisplayName("测试组合断言")
    void testAll() {
        assertAll(
                ()->assertTrue(true),
                ()->assertEquals(1,2)
        );
    }

3.4 异常断言

    @Test
    @DisplayName("测试异常断言")
    void testException() {
        //断定业务逻辑一定出现异常
        assertThrows(ArithmeticException.class, ()->{
            int i=10/0;
        },"业务逻辑居然正常");
    }

3.5 超时断言

    @Timeout(1) //执行时间超过1秒异常 java.util.concurrent.TimeoutException
    @Test
    void testTimeout() throws InterruptedException {
        Thread.sleep(1100);
    }

3.6 快速失败

    @Test
    @DisplayName("测试快速失败")
    void testFail() {
        fail("测试失败");
    }

4.前置条件

Junit5 中的前置条件（assumptions 【假设】）类似于断言，不同支出在于不满足的断言 assertions 会使得测试方法失败，而不满足前置条件只会使得测试方法执行终止。

    @DisplayName("测试前置条件")
    @Test
    void testAssumptions() {
        Assumptions.assumeTrue(false,"结果不是 true");

    }

它和 @Disable 的效果类似，如下图。

 

5.嵌套测试

Junit5 可以通过 Java 中的内部类和 @Nested 注解实现嵌套测试，从而可以更好地把相关的测试方法组织在一起。在内部类中可以使用 @BeforeEach 和 @AfterEach 注解，而且嵌套层次没有限制。

嵌套测试情况下：

• 外侧的Test不能驱动内层类的Before(After)Each/All 之类的方法。
• 内层的Test可以驱动外侧的 Before(After)Each/All 之类的方法

@DisplayName("A stack")
class TestingAStackDemo {

    Stack