Junit5入门指南：从基础到实践

# 1. Junit5简介

## Junit5概述
JUnit 5 是 JUnit 社区发布的基于 Java 8+ 的单元测试框架。它提供了新的编程模型和扩展模型，同时保持与 JUnit 4 的兼容性。JUnit 5 由三个不同的子项目组成：JUnit Platform、JUnit Jupiter 和 JUnit Vintage。

## Junit5与Junit4的区别
与 JUnit 4 相比，JUnit 5 提供了许多新的功能和改进，包括对 Java 8+ 功能的全面支持、新的扩展模型、重复测试、条件测试、动态测试和 Lambda 表达式的支持。

## Junit5的优势和特点
JUnit 5 在架构、扩展性、灵活性和插件方面都有很大改进，同时保持了向后兼容性。它还提供了优秀的注解支持，使得测试用例编写更加简洁、灵活。JUnit 5 的模块化设计使得开发者可以选择性地使用所需的模块，以满足不同项目的需求。

# 2. Junit5基础知识

在本章中，我们将介绍Junit5的基础知识，包括安装与配置、测试生命周期以及断言和断言方法的使用。

### Junit5的安装与配置

Junit5的安装非常简单，我们可以通过Maven或Gradle进行依赖配置。

#### Maven配置
首先，在pom.xml文件中添加以下依赖：

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

然后，在build节点下配置maven-surefire-plugin插件，确保使用Junit5来执行测试：

<build>
    <plugins>
        <plugin>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>3.0.0-M5</version>
        </plugin>
    </plugins>
</build>

#### Gradle配置
在build.gradle文件中添加以下依赖：

dependencies {
    testImplementation('org.junit.jupiter:junit-jupiter-api:5.7.2')
}

test {
    useJUnitPlatform()
}

配置完成后，我们就可以开始使用Junit5进行测试了。

### Junit5的测试生命周期

Junit5提供了多个注解来定义测试生命周期的各个阶段，包括@BeforeAll、@BeforeEach、@AfterEach和@AfterAll。这些注解可以用于方法级别或类级别。

@BeforeAll注解表示在所有测试开始之前执行，该注解的方法必须是静态方法。

@BeforeEach注解表示在每个测试之前执行，该注解的方法会在每个@Test注解的方法之前执行。

@AfterEach注解表示在每个测试之后执行，该注解的方法会在每个@Test注解的方法之后执行。

@AfterAll注解表示在所有测试结束之后执行，该注解的方法必须是静态方法。

下面是一个示例：

import org.junit.jupiter.api.*;

public class Junit5LifecycleTest {

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

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

    @Test
    void test1() {
        System.out.println("Test 1");
    }

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

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

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

运行上述代码，输出结果如下：

Before all tests
Before each test
Test 1
After each test
Before each test
Test 2
After each test
After all tests

### Junit5中的断言和断言方法

Junit5提供了丰富的断言方法，用于判断测试结果是否符合预期。常用的断言方法有：

- `assertEquals(expected, actual)`：判断两个对象或两个原始数据类型是否相等。
- `assertTrue(booleanCondition)`：判断给定的条件是否为true。
- `assertFalse(booleanCondition)`：判断给定的条件是否为false。
- `assertNull(object)`：判断给定的对象是否为null。
- `assertNotNull(object)`：判断给定的对象是否不为null。
- `assertArrayEquals(expectedArray, actualArray)`：判断两个数组是否相等。
- `assertSame(expected, actual)`：判断两个对象引用是否指向同一个对象。

下面是一个使用断言的示例：

import org.junit.jupiter.api.*;

public class Junit5AssertionTest {

    @Test
    void testEquals() {
        String expected = "Hello";
        String actual = "Hello";
        assertEquals(expected, actual, "The strings are not equal");
    }

    @Test
    void testNull() {
        Object obj = null;
        assertNull(obj, "The object is not null");
    }

    @Test
    void testArrayEquals() {
        int[] expected = {1, 2, 3};
        int[] actual = {1, 2, 3};
        assertArrayEquals(expected, actual, "The arrays are not equal");
    }
}

运行上述代码，如果所有的断言都通过，将不会有任何输出；如果断言失败，则会输出错误信息。

本章我们介绍了Junit5的基础知识，包括安装与配置、测试生命周期以及断言和断言方法的使用。接下来，我们将在第三章中介绍Junit5的测试注解。

# 3. Junit5测试注解

### @Test注解的使用

在Junit5中，使用`@Test`注解来标记要进行单元测试的方法。这个注解的使用与Junit4相似，只不过在Junit5中，`@Test`注解的完全限定名是`org.junit.jupiter.api.Test`。

下面是一个使用`@Test`注解进行单元测试的示例代码：

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;

public class CalculatorTest {

    @Test
    public void testAdd() {
        int result = Calculator.add(3, 4);
        assertEquals(7, result, "Addition failed");
    }
}

在上面的示例中，我们使用`@Test`注解来标记`testAdd`方法，在这个方法中，我们调用了 `Calculator` 类的 `add` 方法进行加法运算，并使用`assertEquals`方法进行断言，确保结果是正确的。

### @BeforeEach和@AfterEach注解的作用

在编写单元测试时，我们经常需要在每个测试方法执行前后执行一些特定操作。在Junit5中，我们可以使用`@BeforeEach`和`@AfterEach`注解来实现这个功能。

`@BeforeEach`注解表示在每个测试方法执行前执行的方法。例如：

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;

public class CalculatorTest {

    @BeforeEach
    public void setUp() {
        System.out.println("Initializing...");
    }

    @Test
    public void testAdd() {
        int result = Calculator.add(3, 4);
        assertEquals(7, result, "Addition failed");
    }
}

在上面的示例中，我们使用`@BeforeEach`注解来标记`setUp`方法，该方法会在每个测试方法执行前打印出"Initializing..."。

`@AfterEach`注解表示在每个测试方法执行后执行的方法，用法与`@BeforeEach`相似。

### @BeforeAll和@AfterAll注解的用法

有时，我们希望在所有测试方法运行前后执行一次特定操作，可以使用`@BeforeAll`和`@AfterAll`注解来实现。

`@BeforeAll`注解表示在所有测试方法运行前执行的静态方法，并且只会执行一次。例如：

import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;

public class CalculatorTest {

    @BeforeAll
    public static void setUp() {
        System.out.println("Initializing...");
    }

    @Test
    public void testAdd() {
        int result = Calculator.add(3, 4);
        assertEquals(7, result, "Addition failed");
    }
}

在上面的示例中，我们使用`@BeforeAll`注解来标记`setUp`方法，该方法会在所有测试方法运行前打印出"Initializing..."。由于`@BeforeAll`注解的方法必须是静态的，因此使用`@BeforeAll`时要注意方法的访问修饰符和返回类型。

类似地，`@AfterAll`注解表示在所有测试方法运行后执行的静态方法，用法与`@BeforeAll`相似。

以上就是关于Junit5测试注解的介绍。在接下来的章节中，我们将继续学习Junit5的其他特性和用法。

# 4. Junit5参数化测试

Junit5中的参数化测试可以帮助我们更方便地编写和执行一系列具有相同测试逻辑但不同输入参数的测试用例。在本章中，我们将介绍Junit5参数化测试的概念、注解的使用以及最佳实践。

#### Junit5中参数化测试的概念

参数化测试是指使用不同的参数进行多次测试的一种方法。在Junit5中，我们可以通过使用`@ParameterizedTest`注解来定义参数化测试方法，同时使用`@ValueSource`、`@CsvSource`等注解来指定参数的取值方式。

#### @ParameterizedTest注解的使用

`@ParameterizedTest`注解用于标记参数化测试方法。在该注解下，我们可以使用`@ValueSource`、`@CsvSource`等注解来指定参数的来源。下面是一个示例：

@ParameterizedTest
@ValueSource(ints = {1, 2, 3})
void testSquare(int num) {
    int result = Calculator.square(num);
    assertEquals(num * num, result);
}

在上述示例中，使用`@ValueSource`注解指定了参数的取值为1、2、3。测试方法`testSquare`接收一个整型参数`num`，通过断言判断传入参数的平方是否与计算结果一致。

#### 参数化测试的最佳实践

在进行参数化测试时，我们可以使用`@MethodSource`注解指定一个方法来提供测试参数。下面是一个基于方法提供参数的示例：

@ParameterizedTest
@MethodSource("numProvider")
void testCube(int num) {
    int result = Calculator.cube(num);
    assertEquals(num * num * num, result);
}

static Stream<Integer> numProvider() {
    return Stream.of(1, 2, 3);
}

在上述示例中，`testCube`方法通过`@MethodSource`注解指定了一个名为`numProvider`的方法来提供参数。该方法返回一个`Stream<Integer>`，其中包含了参数1、2、3。测试方法`testCube`以每个参数调用一次，通过断言判断传入参数的立方是否与计算结果一致。

参数化测试还可以使用`@CsvSource`、`@CsvFileSource`等注解来指定参数的来源，以及使用自定义的参数解析器来扩展测试参数的灵活性。

#### 总结

本章介绍了Junit5中参数化测试的概念、注解的使用和最佳实践。通过使用参数化测试，我们可以更方便地编写和执行具有相同测试逻辑但不同输入参数的测试用例，提高测试代码的可维护性和代码覆盖率。

在下一章中，我们将介绍Junit5的扩展与集成，学习如何扩展Junit5的功能以及与其他库的集成使用。

# 5. Junit5扩展与集成

在本章中，我们将介绍Junit5中扩展的概念，并深入讨论Junit5插件的开发和使用。我们还会探讨Junit5与其他库（如Mockito等）的集成，帮助你更好地应用Junit5于实际项目中。让我们开始吧！

### Junit5中扩展的简介

在Junit5中，通过扩展（Extension）的机制，我们可以对测试执行过程进行定制化的操作。Junit5提供了丰富的扩展点，如`BeforeAllCallback`、`AfterAllCallback`、`BeforeEachCallback`、`AfterEachCallback`等，允许我们在测试执行的各个阶段注入自定义逻辑。

### Junit5插件的开发和使用

#### 开发Junit5插件

开发Junit5插件需要实现`Extension`接口，并在相应的扩展点上加入定制化逻辑。以下是一个简单的示例，展示了如何编写一个简单的Junit5插件：

import org.junit.jupiter.api.extension.ExtensionContext;
import org.junit.jupiter.api.extension.TestInstancePostProcessor;

public class CustomExtension implements TestInstancePostProcessor {
    @Override
    public void postProcessTestInstance(Object testInstance, ExtensionContext context) throws Exception {
        // 在测试实例创建之后执行的自定义逻辑
        System.out.println("Custom logic after test instance creation");
    }
}

#### 使用Junit5插件

使用自定义的Junit5插件也非常简单，只需在测试类或方法上通过`@ExtendWith`注解引入即可：

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;

@ExtendWith(CustomExtension.class)
public class MyTest {
    @Test
    void myTest() {
        // 测试方法体
    }
}

### Junit5与Mockito等其他库的集成

Mockito是一个流行的Java单元测试库，用于模拟对象行为。在Junit5中，与Mockito的集成也是十分便捷的。

#### Mockito与Junit5集成示例

以下是一个简单的示例，演示了如何在Junit5测试中使用Mockito：

import org.junit.jupiter.api.Test;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.junit.jupiter.api.extension.ExtendWith;

@ExtendWith(MockitoExtension.class)
public class MockitoIntegrationTest {
    @Mock
    private MyService myService;

    @Test
    void testDoSomething() {
        // 模拟myService的行为，并进行测试
    }
}

在本章中，我们深入探讨了Junit5扩展的概念、Junit5插件的开发与使用，以及Junit5与Mockito等其他库的集成。通过对Junit5的扩展与集成的理解，我们可以更灵活地应用Junit5于实陃项目中，提升单元测试的效率与可靠性。

希望这些内容对你有所帮助！

# 6. Junit5的实际应用

Junit5不仅可以进行基本的单元测试，还能在实际项目中发挥更大的作用。本章将介绍如何在实际项目中应用Junit5，并提供一些最佳实践和注意事项。

### 如何在实际项目中应用Junit5

#### 步骤一：添加Junit5依赖

首先，在项目的构建文件中添加Junit5依赖。以Maven为例，添加以下代码到pom.xml文件中：

<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-engine</artifactId>
    <version>5.x.x</version>
    <scope>test</scope>
</dependency>

注意替换5.x.x为Junit5的实际版本号。

#### 步骤二：编写测试类

创建一个测试类，使用Junit5的相关注解编写测试方法。举例来说，假设我们要测试一个名为Calculator的类：

import org.junit.jupiter.api.Test;

public class CalculatorTest {

    @Test
    void testAddition() {
        Calculator calculator = new Calculator();
        int result = calculator.add(2, 3);
        assertEquals(5, result, "Addition failed!");
    }
}

在上述例子中，我们使用了`@Test`注解来标注测试方法，`assertEquals`方法来断言测试结果。

#### 步骤三：运行测试

使用IDE或命令行工具来运行测试。如果使用Maven构建项目，可以运行以下命令：

mvn test

运行测试后，将会输出测试结果，展示每个测试方法的执行情况。

### Junit5最佳实践与注意事项

在实际项目中使用Junit5时，有一些最佳实践和注意事项需要考虑：

#### 1. 使用合适的断言方法

Junit5提供了多种断言方法，如`assertEquals`、`assertNotNull`等。根据具体的测试场景选择合适的断言方法，以便更清晰地表达测试意图。

#### 2. 使用参数化测试

Junit5的参数化测试功能可以让我们更方便地编写针对不同输入的测试用例。合理使用参数化测试可以提高测试覆盖率。

#### 3. 使用扩展和插件

Junit5提供了扩展和插件机制，可以通过自定义扩展或第三方插件来增强测试功能。例如，Mockito扩展可以与Junit5集成，方便进行单元测试中的mock操作。

#### 4. 遵循测试金字塔原则

在实际项目中，按照测试金字塔原则，应该保持良好的测试层次结构：大量的单元测试，少量的集成测试，更少的端到端测试。合理划分不同层次的测试可以提高测试效率和可维护性。

### Junit5与持续集成的结合

Junit5与持续集成工具的结合非常紧密，可以通过持续集成工具自动运行测试，并生成测试报告。将Junit5与持续集成工具（如Jenkins、Travis CI等）集成，可以实现测试的自动化执行和报告的生成、发布。

### 总结

在实际应用中，Junit5不仅仅是一个单元测试框架，还是一种测试驱动开发（TDD）和行为驱动开发（BDD）的工具。通过遵循最佳实践和注意事项，合理运用Junit5能够提高测试效率和可维护性，从而提升项目质量。