JUnit 5 详解

JUnit 是 Java 生态系统中最流行的测试框架之一，用于编写单元测试、集成测试等。JUnit 5 是其最新版本，提供了更多功能和灵活性，旨在提高测试的可读性、可维护性和可扩展性。JUnit 5 在设计上有别于之前的版本，并引入了全新的架构体系，使其适应现代 Java 开发的需求。

1. JUnit 5 的架构

JUnit 5 的设计遵循模块化和灵活性原则，整体分为三个子项目：

JUnit Platform：提供测试引擎运行和报告的基础平台，允许集成第三方测试框架。
JUnit Jupiter：JUnit 5 的核心模块，提供新的测试编写和扩展模型。
JUnit Vintage：用于兼容 JUnit 3 和 JUnit 4 的测试代码，使旧代码能够继续运行。

这种模块化的设计让 JUnit 5 非常灵活，支持多种测试引擎共存，还能与其他测试框架（如 Spock、Cucumber）集成。

2. JUnit 5 的关键特性

JUnit 5 引入了一些全新的特性，使得测试更加简洁、强大且灵活。以下是一些关键特性：

2.1 注解驱动

JUnit 5 采用了注解驱动的方式进行测试定义。与 JUnit 4 类似，但增加了更多强大的注解：

@Test：标记方法为测试方法。
@BeforeEach：在每个测试方法执行之前运行。
@AfterEach：在每个测试方法执行之后运行。
@BeforeAll：在所有测试方法之前执行，必须是静态方法。
@AfterAll：在所有测试方法之后执行，必须是静态方法。
@DisplayName：为测试类或方法设置自定义名称，以便在测试报告中提供更多描述性信息。
@Disabled：禁用测试类或方法，相当于忽略测试。

java 复制代码

import org.junit.jupiter.api.*;

class MyTests {

    @BeforeAll
    static void setupAll() {
        System.out.println("Before All tests");
    }

    @BeforeEach
    void setup() {
        System.out.println("Before each test");
    }

    @Test
    @DisplayName("Test for addition")
    void testAddition() {
        Assertions.assertEquals(2, 1 + 1);
    }

    @AfterEach
    void tearDown() {
        System.out.println("After each test");
    }

    @AfterAll
    static void tearDownAll() {
        System.out.println("After all tests");
    }
}

2.2 动态测试

JUnit 5 支持动态生成测试，这意味着你可以在运行时创建测试用例，而不是静态地定义所有的测试方法。通过 @TestFactory 注解，开发者可以编写返回 DynamicTest 的工厂方法来动态生成测试用例。

java 复制代码

import org.junit.jupiter.api.*;
import org.junit.jupiter.api.DynamicTest.*;

import java.util.Arrays;
import java.util.Collection;

class DynamicTestsExample {

    @TestFactory
    Collection<DynamicTest> dynamicTests() {
        return Arrays.asList(
            dynamicTest("Add Test", () -> Assertions.assertEquals(2, 1 + 1)),
            dynamicTest("Multiply Test", () -> Assertions.assertEquals(6, 2 * 3))
        );
    }
}

动态测试可以帮助处理基于数据驱动的测试场景或在运行时生成测试。

2.3 参数化测试

JUnit 5 增加了强大的参数化测试功能，允许开发者编写具有不同参数的测试用例。通过 @ParameterizedTest 注解，结合 @ValueSource、@CsvSource、@MethodSource 等，可以方便地为测试提供多组输入。

java 复制代码

import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.*;

class ParameterizedTestExample {

    @ParameterizedTest
    @ValueSource(strings = { "Hello", "JUnit", "5" })
    void testWithParameters(String input) {
        Assertions.assertTrue(input.length() > 0);
    }

    @ParameterizedTest
    @CsvSource({
        "1, 1, 2",
        "2, 3, 5",
        "4, 5, 9"
    })
    void testWithCsv(int a, int b, int result) {
        Assertions.assertEquals(result, a + b);
    }
}

参数化测试能大幅减少重复代码，尤其是在测试类似逻辑时，提高了测试的灵活性。

2.4 条件测试执行

JUnit 5 提供了根据条件执行测试的功能，允许开发者根据环境或上下文决定是否执行某些测试。主要的条件注解包括：

@EnabledOnOs / @DisabledOnOs：根据操作系统执行/禁用测试。
@EnabledOnJre / @DisabledOnJre：根据 Java 版本执行/禁用测试。
@EnabledIf / @DisabledIf：自定义执行条件。

java 复制代码

import org.junit.jupiter.api.*;
import org.junit.jupiter.api.condition.*;

class ConditionalTestExample {

    @Test
    @EnabledOnOs(OS.WINDOWS)
    void runOnlyOnWindows() {
        System.out.println("Runs only on Windows");
    }

    @Test
    @DisabledOnJre(JRE.JAVA_8)
    void notRunOnJava8() {
        System.out.println("Won't run on Java 8");
    }
}

这种条件执行使得测试能够适应不同的运行环境和场景，有助于跨平台测试和不同版本兼容性测试。

3. 使用 JUnit 5 编写测试

让我们通过几个常见的测试场景来看看如何在实际项目中应用 JUnit 5。

3.1 单元测试

单元测试是针对某个类或方法的细粒度测试，通常是白盒测试。JUnit 5 提供了简单直观的 API 编写单元测试。

java 复制代码

import org.junit.jupiter.api.*;

class Calculator {
    public int add(int a, int b) {
        return a + b;
    }

    public int divide(int a, int b) {
        return a / b;
    }
}

class CalculatorTest {

    private Calculator calculator;

    @BeforeEach
    void setUp() {
        calculator = new Calculator();
    }

    @Test
    void testAddition() {
        int result = calculator.add(2, 3);
        Assertions.assertEquals(5, result);
    }

    @Test
    void testDivision() {
        Assertions.assertThrows(ArithmeticException.class, () -> calculator.divide(1, 0));
    }
}

3.2 集成测试

集成测试用于验证多个模块或组件之间的协作是否正常。与单元测试不同，集成测试通常需要搭建更多的依赖，比如数据库、网络连接等。在 Spring Boot 项目中，通常使用 @SpringBootTest 来支持集成测试。

java 复制代码

import org.springframework.boot.test.context.SpringBootTest;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;

@SpringBootTest
class ApplicationTests {

    @Test
    void contextLoads() {
        // 验证 Spring 上下文是否正确加载
        assertThat(true).isTrue();
    }
}

4. JUnit 5 的最佳实践

4.1 测试代码应保持独立

每个测试方法都应该保持独立，不能依赖其他测试方法的结果。JUnit 5 的生命周期方法（如 @BeforeEach 和 @AfterEach）可以帮助确保测试状态的独立性。

4.2 使用有意义的断言

断言是验证测试结果的核心。JUnit 5 提供了丰富的断言方法（Assertions 类），通过它们可以清晰地描述测试期望。例如，可以使用 assertEquals、assertTrue 等方法验证结果。

java 复制代码

Assertions.assertEquals(expected, actual);

4.3 测试代码与业务逻辑分离

测试代码应保持与业务逻辑代码的分离。测试类通常放在 src/test/java 目录中，避免与生产代码混在一起。

4.4 测试命名应清晰

测试方法的命名应清晰地表明其测试的内容和期望结果。通常可以使用 should 或 when 这样的关键词，例如 shouldReturnCorrectSum() 或 whenDivideByZeroThrowException()。

4.5 使用 Mock 框架简化依赖

在测试涉及外部依赖时，可以使用 Mock 框架（如 Mockito）来模拟依赖，从而简化测试并减少不必要的外部资源开销。

java 复制代码

import static org.mockito.Mockito.*;

@Test
void testServiceWithMock() {
    MyService myService = mock(My

Service.class);
    when(myService.performAction()).thenReturn("Mocked Result");
}

5. JUnit 5 与构建工具的集成

JUnit 5 可以轻松集成到 Maven 或 Gradle 等构建工具中。以下是在 Maven 项目中配置 JUnit 5 的依赖：

5.1 Maven 配置

xml 复制代码

<dependencies>
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter-api</artifactId>
        <version>5.7.0</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter-engine</artifactId>
        <version>5.7.0</version>
        <scope>test</scope>
    </dependency>
</dependencies>

5.2 Gradle 配置

groovy 复制代码

dependencies {
    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.7.0'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.7.0'
}

通过这些配置，JUnit 5 就可以被构建工具识别并运行。

6. 结论

JUnit 5 是一个强大且灵活的测试框架，它通过模块化设计、扩展性增强和强大的新特性（如动态测试、参数化测试等）满足了现代 Java 开发的需求。无论是编写单元测试、集成测试还是其他类型的测试，JUnit 5 都提供了丰富的工具和支持。同时，它还兼容旧版 JUnit 测试代码，方便从 JUnit 4 逐步迁移到 JUnit 5。