SpringBoot之单元测试JUnit5

1. Junit5介绍

SpringBoot2开始引入Junit5为单元测试的默认库。Junit5与之前版本的Junit框架变化很大。其由三个不同子项目的不同模块组成。

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

Tips： SpringBoot2.4以上版本移除默认对Vintage的依赖，如果需要兼容Junit4需要自行引入依赖。 For Maven:

<dependency>
    <groupId>org.junit.vintage</groupId>
    <artifactId>junit-vintage-engine</artifactId>
    <scope>test</scope>
    <exclusions>
        <exclusion>
            <groupId>org.hamcrest</groupId>
            <artifactId>hamcrest-core</artifactId>
        </exclusion>
    </exclusions>
</dependency>

For Gradle:

testImplementation("org.junit.vintage:junit-vintage-engine") {
    exclude group: "org.hamcrest", module: "hamcrest-core"
}

1. Junit5的变化

• 注解在 org.junit.jupiter.api 包中，断言在 org.junit.jupiter.api.Assertions 类中，前置条件在 org.junit.jupiter.api.Assumptions 类中。
• @Before 和@After 替换成@BeforeEach 和@AfterEach。
• @BeforeClass 和@AfterClass 替换成@BeforeAll 和@AfterAll。
• @Ignore 替换成@Disabled。
• @Category 替换成@Tag。
• @RunWith、@Rule 和@ClassRule 替换成@ExtendWith。

1. Junit5常用注释

• @Test: 表示方法是测试方法
• @DisplayName : 为测试类或者测试方法设置展示名称
• @BeforeEach : 表示在每个单元测试之前执行
• @BeforeEach : 表示在每个单元测试之前执行
• @AfterEach : 表示在每个单元测试之后执行
• @BeforeAll : 表示在所有单元测试之前执行
• @AfterAll : 表示在所有单元测试之后执行
• @Disabled : 表示测试类或测试方法不执行
• @Tag : 表示单元测试类别
• @Timeout : 表示测试方法运行如果超过了指定时间将会返回错误

@DisplayName( " 标准测试类 " )
public class StandardTests {
    @BeforeAll
    static void initAll() {
        System.out.println( " 所有单元测试之前执行 " );
    }

    @BeforeEach
    void init() {
        System.out.println( " 每个单元测试之前执行 " );
    }

    @Test
    @Tag( " 成功 " )
    void succeedingTest() {
        System.out.println( "a succeding test" );
    }

    @Test
    @Tag( " 失败 " )
    void failingTest() {
        System.out.println( "a failing test" );
    }

    @Test
    @Tag( " 超时 " )
    @Timeout(value = 100, unit = TimeUnit.MILLISECONDS)
    void failsIfExecutionTimeExceeds100Milliseconds() throws InterruptedException {
        Thread.sleep(500);
    }

    @Test
    @Tag( " 跳过 " )
    @Disabled( "for demonstration purposes" )
    void skippedTest() {
         // not executed
 }

    @AfterEach
    void tearDown() {
        System.out.println( " 每个单元测试之后执行 " );
    }

    @AfterAll
    static void tearDownAll() {
        System.out.println( " 所有单元测试之后执行 " );
    }
}

1. 参数化测试 参数化测试是JUnit5很重要的一个新特性，它使得用不同的参数多次运行测试成为了可能，也为我们的单元测试带来许多便利。

利用 @ValueSource等注解，指定入参，我们将可以使用不同的参数进行多次单元测试，而不需要每新增一个参数就新增一个单元测试，省去了很多冗余代码。

@ValueSource: 为参数化测试指定入参来源，支持八大基础类以及String类型,Class类型

@NullSource: 表示为参数化测试提供一个null的入参

@EnumSource: 表示为参数化测试提供一个枚举入参

@CsvFileSource：表示读取指定CSV文件内容作为参数化测试入参

@MethodSource：表示读取指定方法的返回值作为参数化测试入参

public class ParameterizedTestDemo {
    @ParameterizedTest
    @ValueSource(strings = { "one" ,  "two" ,  "three" })
    @DisplayName( " 值来源参数 " )
    public void parameterizedTest1(String string) {
        System.out.println(string);
    }

    @ParameterizedTest
    @MethodSource( "fruit" )
    @DisplayName( " 方法来源参数 " )
    public void testWithExplicitLocalMethodSource(String name) {
        System.out.println(name);
    }

    static Stream<String> fruit() {
        return Stream.of( "apple" ,  "banana" );
    }
}

1. 断言

断言（assertions）是测试方法中的核心部分，用来对测试需要满足的条件进行验证，并增加了一些适合与Java 8 lambdas一起使用的断言方法。这些断言方法都是 org.junit.jupiter.api.Assertions 的静态方法。

public class AssertionsDemo {
    @Test
    @DisplayName( " 简单断言 " )
    @Description( " 用来对单个值进行简单的验证 " )
    public void simple() {
        assertEquals(2, 2,  "simple math" );
        assertNotEquals(3, 2);

        assertNotSame(new Object(), new Object());
        Object obj = new Object();
        assertSame(obj, obj);

        assertFalse(1 > 2);
        assertTrue(1 < 2);

        assertNull(null);
        assertNotNull(new Object());
    }

    @Test
    @DisplayName( " 数组断言 " )
    @Description( " 通过 assertArrayEquals 方法来判断两个对象或原始类型的数组是否相等 " )
    public void array() {
        assertArrayEquals(new int[]{1, 2}, new int[] {1, 2});
    }
     /**

     * assertAll 方法接受多个 org.junit.jupiter.api.Executable 函数式接口的实例作为要验证的断言 
     * 可以通过 lambda 表达式很容易的提供这些断言 
     */
    @Test
    @DisplayName( " 组合断言 " )
    public void all() {
        assertAll( "Math" ,
                () -> assertEquals(2, 1 + 1),
                () -> assertTrue(1 > 0)
        );
    }

     /**
     * 在 JUnit4 时期，想要测试方法的异常情况时，需要用 @Rule 注解的 ExpectedException 变量还是比较麻烦的。 
     * 而 JUnit5 提供了一种新的断言方式 Assertions.assertThrows() , 配合函数式编程就可以进行使用。 
     */
    @Test
    @DisplayName( " 异常断言 " )
    public void exceptionTest() {
        ArithmeticException exception = Assertions.assertThrows(
                 // 扔出断言异常 
                ArithmeticException.class, () -> System.out.println(1 % 0));
    }

    @Test
    @DisplayName( " 超时断言 " )
    public void timeoutTest() {
         // 如果测试方法时间超过 1s 将会异常 
         Assertions.assertTimeout(Duration.ofMillis(1000), () -> Thread.sleep(500));
    }

    @Test
    @DisplayName( " 快速失败 " )
    @Description( "fail 方法直接使得测试失败 " )
    public void shouldFail() {
        fail( "This should fail" );
    }
}

1. 前置条件

JUnit 5 中的前置条件（assumptions【假设】）类似于断言，不同之处在于不满足的断言会使得测试方法失败，而不满足的前置条件只会使得测试方法的执行终止。前置条件可以看成是测试方法执行的前提，当该前提不满足时，就没有继续执行的必要。

@DisplayName( " 前置条件 " )
public class AssumptionsDemo {
    private final String environment =  "DEV" ;

    @Test
    @DisplayName( "simple" )
    public void simpleAssume() {
        assumeTrue(Objects.equals(this.environment,  "DEV" ));
        assumeFalse(() -> Objects.equals(this.environment,  "PROD" ));
    }

    @Test
    @DisplayName( "assume then do" )
    public void assumeThenDo() {
        assumingThat(
                Objects.equals(this.environment,  "DEV" ),
                () -> System.out.println( "In DEV" )
        );
    }
}

assumeTrue 和 assumFalse 确保给定的条件为 true 或 false，不满足条件会使得测试执行终止。assumingThat 的参数是表示条件的布尔值和对应的 Executable 接口的实现对象。只有条件满足时，Executable 对象才会被执行；当条件不满足时，测试执行并不会终止。