JUnit5参数化测试与Mockito使用技巧

积累知识，胜过积蓄金银！毕竟在文章开发的过程中，会遇到各种各样的问题，往往都是一些细节知识点还没有掌握好而导致的，因此基础知识点的积累是很重要的。下面本文《JUnit5参数化测试与Mockito整合技巧》，就带大家讲解一下知识点，若是你对本文感兴趣，或者是想搞懂其中某个知识点，就请你继续往下看吧~

本文旨在解决在JUnit 5中使用@ParameterizedTest与Mockito进行单元测试时，常见的InvalidUseOfMatchersException错误。核心问题在于JUnit 4的测试运行器（@RunWith(MockitoJUnitRunner.class)）与JUnit 5的扩展模型不兼容。通过详细示例，我们将展示如何正确地使用JUnit 5的@ExtendWith(MockitoExtension.class)来集成Mockito，确保参数化测试能够顺利地定义和执行模拟对象的行为，从而编写出更健壮、更灵活的测试用例。

引言

在现代Java应用开发中，单元测试是保障代码质量不可或缺的一环。JUnit 5作为当前主流的测试框架，提供了强大的参数化测试功能（@ParameterizedTest），允许开发者使用不同的输入数据多次运行同一个测试方法，极大地提高了测试的效率和覆盖率。同时，Mockito作为流行的模拟框架，使得对外部依赖进行模拟变得轻而易举，从而能够隔离被测单元，专注于其自身的逻辑。

然而，当尝试将JUnit 5的参数化测试与Mockito结合使用时，一些开发者可能会遇到org.mockito.exceptions.misusing.InvalidUseOfMatchersException这样的错误。这个错误通常发生在尝试在when().thenReturn()等模拟定义中使用any()等参数匹配器时，表明Mockito的上下文环境不正确。

问题分析：JUnit 4 Runner与JUnit 5 Extension的冲突

InvalidUseOfMatchersException的出现，往往是由于JUnit 4的测试运行器（如@RunWith(MockitoJUnitRunner.class)）被错误地应用于JUnit 5的测试类上。JUnit 4使用@RunWith注解来指定测试运行器，而JUnit 5则引入了全新的扩展模型，通过@ExtendWith注解来注册扩展。

当你在一个使用了@ParameterizedTest（JUnit 5特性）的测试类中，同时使用@RunWith(MockitoJUnitRunner.class)时，就会发生冲突。MockitoJUnitRunner是为JUnit 4设计的，它无法正确地初始化Mockito的上下文以支持JUnit 5的生命周期和参数化测试机制。因此，当Mockito尝试解析any()等参数匹配器时，由于其内部状态未被正确管理，便会抛出InvalidUseOfMatchersException。

错误的示例（导致InvalidUseOfMatchersException）：

import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.EnumSource;
import org.junit.runner.RunWith; // JUnit 4 Runner
import org.mockito.Mocked; // Assuming this is @Mock, typo in original
import org.mockito.InjectMocks;
import org.mockito.junit.MockitoJUnitRunner; // JUnit 4 Runner
import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.assertEquals;

// 假设存在以下辅助类
enum CodeEnum {
    S1("S1"), S2("S2");
    private final String code;
    CodeEnum(String code) { this.code = code; }
    public String getCode() { return code; }
}

class Output {
    private CodeEnum code;
    public Output(CodeEnum code) { this.code = code; }
    public static Output.Builder builder() { return new Output.Builder(); }
    public CodeEnum getCode() { return code; }
    static class Builder {
        private CodeEnum code;
        public Builder code(CodeEnum code) { this.code = code; return this; }
        public Output build() { return new Output(code); }
    }
}

interface MockedObject {
    Output method(MockedInput input);
}

class Foo {
    private MockedObject mockedObject;
    public Foo(MockedObject mockedObject) { this.mockedObject = mockedObject; }
    // 假设 Foo.method() 内部会调用 mockedObject.method() 并传入某个 MockedInput
    public Output method() {
        // 实际实现中，这里会根据业务逻辑生成或获取 MockedInput
        // 为简化示例，我们假设它调用一个默认的或者在测试中被捕获的输入
        return mockedObject.method(new MockedInput("default_input_for_foo"));
    }
}

class MockedInput {
    private String value;
    public MockedInput(String value) { this.value = value; }
    // 需要重写 equals 和 hashCode 方法，以便 Mockito 正确匹配
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        MockedInput that = (MockedInput) o;
        return value != null ? value.equals(that.value) : that.value == null;
    }
    @Override
    public int hashCode() {
        return value != null ? value.hashCode() : 0;
    }
}

// @RunWith(MockitoJUnitRunner.class) // 这是导致问题的原因！
class FooTestIncorrect {
    @Mock // 注意：原始问题中的 @Mocked 可能是笔误，通常是 @Mock
    MockedObject mockedObject;
    @InjectMocks
    Foo underTest;

    @ParameterizedTest
    @EnumSource(CodeEnum.class)
    public void test_ParametrizedTest_with_any(CodeEnum codeEnum) {
        Output expectedReturn = Output.builder().code(codeEnum).build();

        // Given
        // 这里的 any() 在错误的 Runner 下可能导致问题
        when(mockedObject.method(any()))
            .thenReturn(expectedReturn);

        // when
        val result = underTest.method();

        // then
        assertEquals(codeEnum, result.getCode());
    }
}

解决方案：使用MockitoExtension

解决这个问题的关键在于，对于JUnit 5测试，我们应该使用@ExtendWith(MockitoExtension.class)来替代JUnit 4的@RunWith(MockitoJUnitRunner.class)。MockitoExtension是Mockito为JUnit 5提供的扩展，它能够正确地初始化和管理Mockito的生命周期，从而与JUnit 5的特性（包括参数化测试）无缝集成。

正确的实现方式：

import org.junit.jupiter.api.extension.ExtendWith; // JUnit 5 Extension
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
import org.mockito.Mock; // 正确的注解是 @Mock
import org.mockito.InjectMocks;
import org.mockito.junit.jupiter.MockitoExtension; // JUnit 5 Mockito Extension

import java.util.stream.Stream;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.when;

// 辅助类定义同上，此处省略重复代码

@ExtendWith(MockitoExtension.class) // 正确的JUnit 5 Mockito集成方式
public class FooTest {

    @Mock
    MockedObject mockedObject;

    @InjectMocks
    Foo underTest;

    /**
     * 数据提供者方法，为参数化测试提供输入和预期输出。
     * 每个 Arguments.of() 包含：
     * 1. 模拟对象方法所需的输入 (MockedInput)
     * 2. 模拟对象方法应返回的预期输出 (Output)
     */
    private static Stream<Arguments> dataProvider() {
        // 假设 mockedInput1 和 mockedInput2 是 MockedInput 的实例
        MockedInput mockedInput1 = new MockedInput("input_val_S1");
        MockedInput mockedInput2 = new MockedInput("input_val_S2");

        return Stream.of(
                Arguments.of(mockedInput1, Output.builder().code(CodeEnum.S1).build()),
                Arguments.of(mockedInput2, Output.builder().code(CodeEnum.S2).build())
        );
    }

    @ParameterizedTest
    @MethodSource("dataProvider")
    public void test_ParametrizedTest_with_Mockito(MockedInput inputForMock, Output expectedReturnFromMock) {
        // Given
        // 使用参数化测试提供的 inputForMock 来定义模拟对象的行为
        when(mockedObject.method(inputForMock))
            .thenReturn(expectedReturnFromMock);

        // When
        // 调用被测对象的方法。假设 Foo.method() 内部会以某种方式触发 mockedObject.method(inputForMock)
        // 例如，Foo 内部可能根据某种逻辑生成或获取到 inputForMock 并传递给 mockedObject
        val result = underTest.method();

        // Then
        // 验证被测方法的返回值是否符合预期，预期值来自参数化测试提供的 expectedReturnFromMock
        assertEquals(expectedReturnFromMock.getCode(), result.getCode());
    }
}

在上述修正后的代码中：

1. 我们移除了@RunWith(MockitoJUnitRunner.class)。
2. 我们添加了@ExtendWith(MockitoExtension.class)，这是JUnit 5与Mockito集成的标准方式。
3. @ParameterizedTest和@MethodSource用于提供测试数据。dataProvider()方法返回一个Stream，其中每个Arguments实例包含一对值：一个MockedInput用于设置模拟行为的输入，以及一个Output作为模拟方法的返回值。
4. 在test_ParametrizedTest_with_Mockito方法中，我们直接使用参数inputForMock来定义mockedObject.method()的模拟行为，并使用expectedReturnFromMock作为其返回值。这使得我们可以针对不同的输入，灵活地定义模拟对象的响应。
5. 断言部分也更新为使用expectedReturnFromMock.getCode()来与实际结果进行比较，确保逻辑的正确性。

关键点与最佳实践

• JUnit 5与Mockito的集成： 始终使用@ExtendWith(MockitoExtension.class)来在JUnit 5测试类中启用Mockito的注解（如@Mock, @InjectMocks）和功能。这是JUnit 5生态系统中的标准做法，与JUnit 4的@RunWith有本质区别。
• 参数化测试的数据源：
  • @EnumSource: 适用于测试数据来源于枚举类型的情况。
  • @MethodSource: 提供了更大的灵活性，可以从静态方法中提供任意类型的Stream作为测试数据，非常适合需要提供复杂对象作为参数，或者需要同时提供模拟输入和预期输出的场景。
• 模拟对象行为的定义： 在参数化测试中，可以通过测试方法的参数直接获取用于定义模拟行为的数据。这使得每个参数化测试迭代都可以拥有独立的模拟配置，从而实现更精细的测试覆盖。
• equals()和hashCode()的重要性： 当使用对象作为Mockito的参数匹配器（例如when(mockedObject.method(someObject))）时，如果someObject是一个自定义对象，确保该对象正确地重写了equals()和hashCode()方法。Mockito在匹配参数时会依赖这些方法来判断对象是否相等。

总结

通过将JUnit 4的@RunWith(MockitoJUnitRunner.class)替换为JUnit 5的@ExtendWith(MockitoExtension.class)，我们可以有效地解决在JUnit 5参数化测试中遇到的InvalidUseOfMatchersException问题。这种正确的集成方式不仅能让@ParameterizedTest与Mockito协同工作，还能帮助开发者编写出更清晰、更灵活、更易于维护的单元测试，从而提升整体代码质量和开发效率。理解JUnit 5的扩展模型与JUnit 4运行器之间的差异，是掌握现代Java单元测试框架的关键一步。

理论要掌握，实操不能落！以上关于《JUnit5参数化测试与Mockito使用技巧》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！