深入了解单元测试框架：JUnit 5、Mockito和 AssertJ

好的，我会将这篇文章扩充一倍，并详细描述 mockStatic 等内容。

深入了解单元测试框架：JUnit 5、Mockito和 AssertJ

在现代软件开发中，单元测试是确保代码质量和稳定性的重要手段。本文将详细介绍如何使用 JUnit 5 进行单元测试，并结合 Mockito 进行 Mock 操作，以及使用 AssertJ 进行断言。

1. JUnit 5 简介

JUnit 5 是 Java 平台上最流行的单元测试框架之一。它由三个子项目组成：JUnit Platform、JUnit Jupiter 和 JUnit Vintage。

• JUnit Platform：提供启动测试框架的基础设施，支持不同的测试引擎。
• JUnit Jupiter：包含新的编程模型和扩展模型，用于编写测试和扩展。
• JUnit Vintage：支持运行基于 JUnit 3 和 JUnit 4 的测试，确保旧版测试的兼容性。

1.1 安装和配置

在 Maven 项目中，可以通过以下依赖来引入 JUnit 5：

<dependency>
    <groupId>org.junit.jupitergroupId>
    <artifactId>junit-jupiterartifactId>
    <version>5.11.0version>
    <scope>testscope>
dependency>
<dependency>
    <groupId>org.mockitogroupId>
    <artifactId>mockito-coreartifactId>
    <version>5.11.0version>
    <scope>testscope>
dependency>

1.2 基本用法

JUnit 5 提供了许多注解来简化测试的编写：

• @Test：标记一个方法为测试方法。
• @BeforeEach：在每个测试方法执行前运行。
• @AfterEach：在每个测试方法执行后运行。
• @BeforeAll：在所有测试方法执行前运行。
• @AfterAll：在所有测试方法执行后运行。

示例代码：

// Calculator 类
public class Calculator {

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

    public int subtract(int a, int b) {
        return a - b;
    }

    public int multiply(int a, int b) {
        return a * b;
    }

    public int divide(int a, int b) {
        if (b == 0) {
            throw new IllegalArgumentException("Division by zero is not allowed.");
        }
        return a / b;
    }
}

import org.junit.jupiter.api.*;

public class CalculatorTest {

    private Calculator calculator;

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

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

    @Test
    void testSubtraction() {
        Assertions.assertEquals(1, calculator.subtract(3, 2));
    }
}

2. Mockito

Mockito 是一个流行的 Java Mock 框架，用于创建和配置 Mock 对象。

2.1 Mockito 基本用法

User 类

public class User {
    private int id;
    private String name;

    public User(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }
}

UserRepository 接口

public interface UserRepository {
    User findById(int id);
}

UserService 类

public class UserService {
    private UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public User getUser(int id) {
        return userRepository.findById(id);
    }
}

Mockito 提供了简单的 API 来创建和配置 Mock 对象

import static org.mockito.Mockito.*;
import org.junit.jupiter.api.Test;

public class UserServiceTest {

    @Test
    void testGetUser() {
        UserRepository mockRepo = mock(UserRepository.class);
        UserService userService = new UserService(mockRepo);

        when(mockRepo.findById(1)).thenReturn(new User(1, "Lee"));

        User user = userService.getUser(1);
        Assertions.assertEquals("Lee", user.getName());
    }
}

2.2 使用 mockStatic 方法

在某些情况下，我们需要模拟静态方法。Mockito 提供了 mockStatic 方法来实现这一功能。以下是一个示例：

Utility 类

public class Utility {
    public static String getGreeting() {
        return "Hello, World!";
    }
}

使用 mockStatic 模拟静态方法

import static org.mockito.Mockito.*;
import org.junit.jupiter.api.Test;
import org.mockito.MockedStatic;

public class UtilityTest {

    @Test
    void testStaticMethod() {
        try (MockedStatic<Utility> mockedStatic = mockStatic(Utility.class)) {
            mockedStatic.when(Utility::getGreeting).thenReturn("Mocked Greeting");

            String greeting = Utility.getGreeting();
            Assertions.assertEquals("Mocked Greeting", greeting);
        }
    }
}

3. AssertJ

AssertJ 是一个流行的断言库，提供了流畅和丰富的断言语法。

3.1 基本用法

AssertJ 提供了许多方便的断言方法：

import static org.assertj.core.api.Assertions.*;
import org.junit.jupiter.api.Test;

public class AssertJTest {

    @Test
    void testAssertions() {
        String name = "Lee";
        assertThat(name).isNotNull()
                        .startsWith("L")
                        .endsWith("e")
                        .isEqualTo("Lee");
    }
}

3.2 复杂对象断言

AssertJ 允许对复杂对象进行断言：

public class Person {
    private String name;
    private int age;

    // getters and setters
}

public class AssertJComplexTest {

    @Test
    void testComplexAssertions() {
        Person person = new Person("Lee", 30);
        assertThat(person).isNotNull();
        assertThat(person.getName()).isEqualTo("Lee");
        assertThat(person.getAge()).isGreaterThan(20);
    }
}

4. 进阶内容

为了进一步提升单元测试的质量和覆盖率，可以考虑以下几点：

• 参数化测试：使用 JUnit 5 的 @ParameterizedTest 注解，可以在一个测试方法中运行多个参数组合，减少重复代码。
• 测试覆盖率工具：集成 JaCoCo 等测试覆盖率工具，确保代码的每个部分都经过测试。
• 持续集成：将单元测试集成到 CI/CD 管道中，确保每次代码变更都经过自动化测试。

4.1 参数化测试

参数化测试允许在一个测试方法中运行多个参数组合，减少重复代码。JUnit 5 提供了 @ParameterizedTest 注解来实现这一功能：

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

public class ParameterizedTestExample {

    @ParameterizedTest
    @ValueSource(strings = {"racecar", "radar", "level"})
    void testPalindrome(String candidate) {
        Assertions.assertTrue(isPalindrome(candidate));
    }

    boolean isPalindrome(String str) {
        return str.equals(new StringBuilder(str).reverse().toString());
    }
}

4.2 使用 JaCoCo 进行测试覆盖率分析

JaCoCo 是一个开源的代码覆盖率工具，可以集成到 Maven 或 Gradle 构建中。以下是 Maven 项目的配置示例：

<build>
    <plugins>
        <plugin>
            <groupId>org.jacocogroupId>
            <artifactId>jacoco-maven-pluginartifactId>
            <version>0.8.7version>
            <executions>
                <execution>
                    <goals>
                        <goal>prepare-agentgoal>
                    goals>
                execution>
                <execution>
                    <id>reportid>
                    <phase>prepare-packagephase>
                    <goals>
                        <goal>reportgoal>
                    goals>
                execution>
            executions>
        plugin>
    plugins>
build>

4.3 持续集成中的单元测试

将单元测试集成到 CI/CD 管道中，可以确保每次代码变更都经过自动化测试。以下是一个简单的 GitHub Actions 配置示例：

name: Java CI

on: [push, pull_request]

jobs:
  build:

    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v2
    - name: Set up JDK 11
      uses: actions/setup-java@v2
      with:
        java-version: '11'
    - name: Build with Maven
      run: mvn clean install
    - name: Run tests
      run: mvn test

5. 结论

通过结合使用 JUnit 5、Mockito、AssertJ，可以编写出强大且灵活的单元测试。这些工具各有优势，能够满足不同的测试需求。通过参数化测试、测试覆盖率工具和持续集成，可以进一步提升测试的质量和覆盖率，确保代码的稳定性和可靠性。

5.1 结合使用 JUnit 5、Mockito 和 AssertJ

在实际项目中，通常需要结合使用多个测试框架和工具来实现全面的测试覆盖。以下是一个综合示例，展示了如何使用 JUnit 5 进行测试，Mockito 进行 Mock 操作，以及 AssertJ 进行断言。

综合示例

import org.junit.jupiter.api.*;
import org.mockito.*;
import static org.mockito.Mockito.*;
import static org.assertj.core.api.Assertions.*;

public class UserServiceTest {

    @Mock
    private UserRepository userRepository;

    @InjectMocks
    private UserService userService;

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
    }

    @Test
    void testGetUser() {
        User mockUser = new User(1, "Lee");
        when(userRepository.findById(1)).thenReturn(mockUser);

        User user = userService.getUser(1);

        assertThat(user).isNotNull();
        assertThat(user.getName()).isEqualTo("Lee");
        assertThat(user.getId()).isEqualTo(1);
    }
}

在示例中，使用了 JUnit 5 的注解来管理测试生命周期，使用 Mockito 来创建和配置 Mock 对象，并使用 AssertJ 来进行断言。这种组合使用可以充分发挥各个工具的优势，编写出高质量的单元测试。