使用JUnit进行Java单元测试的基本方法

目录#

环境搭建
JUnit 5 架构核心
编写你的第一个单元测试
JUnit 核心注解详解
断言：验证测试结果
假设：有条件地执行测试
测试生命周期：@BeforeEach, @AfterEach等
异常测试
参数化测试
常见实践与最佳实践
总结
参考

环境搭建#

在开始之前，你需要将JUnit 5添加到你的项目中。如果你使用Maven，请在pom.xml中添加以下依赖：

<dependencies>
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter</artifactId>
        <version>5.9.2</version> <!-- 请使用最新版本 -->
        <scope>test</scope>
    </dependency>
</dependencies>
 
<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>3.0.0-M9</version>
        </plugin>
    </plugins>
</build>

如果你使用Gradle，在build.gradle中添加：

dependencies {
    testImplementation 'org.junit.jupiter:junit-jupiter:5.9.2'
}
 
test {
    useJUnitPlatform()
}

JUnit 5 架构核心#

JUnit 5由三个主要子项目组成：

JUnit Platform：在JVM上启动测试框架的基础。
JUnit Jupiter：包含用于编写测试的新编程模型和扩展模型。它提供了@Test等注解。
JUnit Vintage：用于支持在JUnit 5平台上运行JUnit 3和JUnit 4编写的测试。

对于新项目，我们主要与JUnit Jupiter交互。

编写你的第一个单元测试#

假设我们有一个简单的Calculator类：

// src/main/java/com/example/Calculator.java
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 double divide(int a, int b) {
        if (b == 0) {
            throw new IllegalArgumentException("除数不能为零");
        }
        return (double) a / b;
    }
}

对应的单元测试类如下：

// src/test/java/com/example/CalculatorTest.java
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
 
class CalculatorTest {
 
    private final Calculator calculator = new Calculator();
 
    @Test
    void testAdd() {
        // 准备 (Arrange)
        int a = 5;
        int b = 3;
        int expectedResult = 8;
 
        // 执行 (Act)
        int actualResult = calculator.add(a, b);
 
        // 断言 (Assert)
        assertEquals(expectedResult, actualResult, "5 + 3 应该等于 8");
    }
}

测试结构解析（AAA模式）：

Arrange：准备测试所需的数据和对象。
Act：调用被测试的方法。
Assert：验证结果是否符合预期。

JUnit核心注解详解#

注解	描述
`@Test`	标记一个方法为测试方法。
`@BeforeEach`	在每个`@Test`方法之前执行。常用于初始化公共资源。
`@AfterEach`	在每个`@Test`方法之后执行。常用于清理资源（如关闭流）。
`@BeforeAll`	在所有测试方法执行之前执行一次。方法必须是`static`。
`@AfterAll`	在所有测试方法执行之后执行一次。方法必须是`static`。
`@DisplayName`	为测试类或方法设置一个易读的显示名称。
`@Disabled`	禁用测试类或方法。

示例：

import org.junit.jupiter.api.*;
 
class AdvancedCalculatorTest {
 
    private Calculator calculator;
 
    @BeforeAll
    static void setUpBeforeAll() {
        System.out.println("这个测试类开始执行...");
    }
 
    @BeforeEach
    void setUp() {
        calculator = new Calculator(); // 在每个测试前重新初始化，保证测试隔离
        System.out.println("准备测试...");
    }
 
    @AfterEach
    void tearDown() {
        System.out.println("测试完成。");
    }
 
    @AfterAll
    static void tearDownAfterAll() {
        System.out.println("这个测试类所有测试已执行完毕。");
    }
 
    @Test
    @DisplayName("测试两个正数相乘")
    void testMultiplyPositiveNumbers() {
        assertEquals(15, calculator.multiply(3, 5));
    }
 
    @Test
    @Disabled("这个测试尚未实现")
    void testDisabled() {
        // TODO: 实现这个测试
    }
}

断言：验证测试结果#

断言是测试的核心，用于验证实际结果是否与预期一致。JUnit Jupiter的断言位于org.junit.jupiter.api.Assertions类中。

常用断言方法：

assertEquals(expected, actual)：检查两个值是否相等。
assertNotEquals(unexpected, actual)：检查两个值是否不相等。
assertTrue(condition)：检查条件是否为真。
assertFalse(condition)：检查条件是否为假。
assertNull(object)：检查对象是否为null。
assertNotNull(object)：检查对象是否不为null。
assertSame(expected, actual)：检查两个对象引用是否指向同一个对象。
assertNotSame(unexpected, actual)：检查两个对象引用是否不指向同一个对象。
assertThrows(exceptionType, executable)：检查执行代码块是否抛出了指定类型的异常。
assertAll(groupName, executables...)： 组合断言，执行所有断言，即使其中一些失败也会继续执行其余的。

示例：

@Test
void testVariousAssertions() {
    String nullString = null;
    String actualString = "Hello JUnit";
 
    // 基本断言
    assertNotNull(actualString);
    assertNull(nullString);
    assertTrue(actualString.startsWith("Hello"));
 
    // 组合断言：所有断言都会被执行，然后一起报告失败
    assertAll("字符串属性测试",
        () -> assertEquals("Hello JUnit", actualString),
        () -> assertTrue(actualString.length() > 5),
        () -> assertFalse(actualString.isEmpty())
    );
}

假设：有条件地执行测试#

假设（Assumptions）用于在特定条件不满足时跳过测试，而不是使测试失败。这常用于测试需要特定环境（如操作系统、数据库连接）的情况。

常用假设方法：

assumeTrue(condition)
assumeFalse(condition)

示例：

@Test
void testOnlyOnCiServer() {
    // 假设环境变量 "ENV" 的值是 "CI"
    assumeTrue("CI".equals(System.getenv("ENV")));
    // 只有当上面假设成立时，下面的断言才会执行
    assertEquals(2, calculator.add(1, 1));
}
 
@Test
void testOnlyOnDeveloperWorkstation() {
    assumeFalse("CI".equals(System.getenv("ENV")));
    // 这个测试在CI服务器上会被跳过
    // ... 执行一些开发环境的特定测试
}

测试生命周期#

通过@BeforeEach和@AfterEach等注解，JUnit提供了清晰的生命周期管理，确保每个测试都在一个干净、独立的环境中运行，这是单元测试的一个关键原则。

异常测试#

测试方法是否按预期抛出异常。

传统方式：

@Test
void testException() {
    Exception exception = assertThrows(IllegalArgumentException.class, () -> {
        calculator.divide(10, 0);
    });
    // 还可以进一步检查异常信息
    assertEquals("除数不能为零", exception.getMessage());
}

参数化测试#

参数化测试允许你使用不同的参数多次运行同一个测试，极大地减少了代码重复。

你需要添加依赖：

<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-params</artifactId>
    <version>5.9.2</version>
    <scope>test</scope>
</dependency>

示例：

import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;
import org.junit.jupiter.params.provider.CsvSource;
 
class ParameterizedCalculatorTest {
 
    private Calculator calculator = new Calculator();
 
    @ParameterizedTest
    @ValueSource(ints = {1, 2, 3, 5})
    void testAddWithValueSource(int number) {
        // 每个数字都会运行一次这个测试
        assertEquals(number + 1, calculator.add(number, 1));
    }
 
    @ParameterizedTest(name = "{0} + {1} = {2}") // 为每次测试生成清晰的名称
    @CsvSource({
        "0, 1, 1",
        "1, 2, 3",
        "5, 5, 10"
    })
    void testAddWithCsvSource(int a, int b, int expected) {
        assertEquals(expected, calculator.add(a, b));
    }
}

常见实践与最佳实践#

测试命名：测试方法名应具有描述性。可以使用@DisplayName或遵循methodName_Scenario_ExpectedResult的命名约定（如divide_DivisorIsZero_ThrowsException）。
一个断言一个行为：理想情况下，一个测试方法只测试一个明确的行为。这使得测试失败时原因更清晰。
测试隔离：每个测试都应该是独立的，不依赖于其他测试的执行顺序或状态。使用@BeforeEach来设置每个测试的初始状态。
不测试实现细节：测试公共接口的行为，而不是私有方法。这样即使重构代码，只要行为不变，测试就无需修改。
使用assertAll进行相关断言：对于验证一个对象的多个属性，使用assertAll可以一次性看到所有失败。
保持测试快速：单元测试应该非常快，以便能频繁运行。避免文件I/O、数据库访问或网络调用（这些属于集成测试范畴）。使用Mock对象（如Mockito）来隔离依赖。
F.I.R.S.T.原则：
- Fast（快速）
- Independent（独立）
- Repeatable（可重复）
- Self-Validating（自验证）
- Timely（及时）

总结#

JUnit 5是一个强大而灵活的框架，为Java单元测试提供了坚实的基础。通过掌握其核心注解、断言、生命周期管理和参数化测试等特性，你可以编写出结构清晰、维护性高且可靠的单元测试。记住，好的单元测试是代码信心的来源，是重构的安全网，也是活生生的文档。将单元测试作为开发过程中不可或缺的一部分，必将显著提升你的软件质量。

参考#

JUnit 5官方用户指南
JUnit 5 GitHub仓库
书籍：《JUnit in Action》 by Catalin Tudose
mocking框架：Mockito，常用于与JUnit结合模拟依赖对象。