JUnit5参数化测试与Mockito使用教程

一分耕耘，一分收获！既然都打开这篇《JUnit 5参数化测试与Mockito实战指南》，就坚持看下去，学下去吧！本文主要会给大家讲到等等知识点，如果大家对本文有好的建议或者看到有不足之处，非常欢迎大家积极提出！在后续文章我会继续更新文章相关的内容，希望对大家都有所帮助！

本教程详细阐述了如何在JUnit 5的参数化测试（@ParameterizedTest）中，正确地将测试参数作为Mockito模拟对象方法的返回值。文章重点指出使用@ExtendWith(MockitoExtension.class)来替代JUnit 4的@RunWith是解决此类问题的关键，并提供了结合@MethodSource与Mockito进行高效单元测试的实践范例，帮助开发者避免常见的配置错误，实现灵活且可维护的测试逻辑。

参数化测试与Mocking的常见场景

在单元测试中，我们经常需要针对同一个逻辑，使用不同的输入数据进行多次测试。JUnit 5的参数化测试（@ParameterizedTest）为此提供了强大的支持。同时，为了隔离被测试单元（System Under Test, SUT）与外部依赖，我们通常会使用Mockito等模拟框架来模拟这些依赖的行为。

一个常见的测试场景是：被测试单元依赖于一个外部服务，该服务返回的数据结构或值会根据输入参数的不同而变化。在参数化测试中，我们希望根据当前测试的参数，动态地配置模拟外部服务的行为，使其返回与当前参数对应的特定值。例如，当测试参数为“成功代码S1”时，模拟服务返回一个包含S1的成功响应；当测试参数为“成功代码S2”时，则返回包含S2的响应。

初探：JUnit 4与JUnit 5集成差异引发的问题

在尝试将JUnit 5的参数化测试与Mockito结合时，开发者可能会遇到一些困惑。一个常见的误区是沿用JUnit 4中@RunWith(MockitoJUnitRunner.class)的习惯来启动Mockito。

考虑以下代码片段，它尝试使用@RunWith和@ParameterizedTest：

import org.junit.runner.RunWith; // JUnit 4 Runner
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.EnumSource;
import org.mockito.Mock; // Or @Mocked as in the original problem
import org.mockito.InjectMocks;
import org.mockito.junit.MockitoJUnitRunner; // JUnit 4 Mockito Runner

import static org.mockito.Mockito.when;
import static org.mockito.Mockito.any; // Argument matcher

// 假设 CodeEnum, Output, MockedObject, Foo 等类已定义

@RunWith(MockitoJUnitRunner.class) // 问题所在：JUnit 4 Runner
public class FooTest {

   @Mock // 原问题中使用的是 @Mocked，这里使用更通用的 @Mock
   MockedObject mockedObject;

   @InjectMocks
   Foo underTest;

   @ParameterizedTest
   @EnumSource(CodeEnum.class)
   public void test_ParametrizedTest(CodeEnum codeEnum) { // 参数名修正为 codeEnum
      Output expectedReturn = Output.builder().code(codeEnum).build();

      // Given
      // 尝试使用 any() 匹配器，但可能在不兼容的Runner环境下引发 Misplaced or misused argument matcher 异常
      when(mockedObject.method(any()))
          .thenReturn(expectedReturn);

      // when
      // val result = underTest.method(); // 假设 Foo.method() 会调用 mockedObject.method()

      // then
      // assertEquas(codeEnum, result.getCode()); // 假设断言会使用 codeEnum
   }
}

上述代码尝试在JUnit 5的@ParameterizedTest中使用JUnit 4的@RunWith(MockitoJUnitRunner.class)。这会导致运行时错误，例如org.mockito.exceptions.misusing.InvalidUseOfMatchersException。尽管这个错误信息提示了参数匹配器（如any()）的误用，但根本原因并非any()本身的问题，而是JUnit 4的测试运行器（Runner）与JUnit 5的扩展模型不兼容。JUnit 5不再使用@RunWith，而是引入了@ExtendWith注解来集成各种扩展功能（包括Mockito）。

解决方案：JUnit 5与Mockito的正确集成

在JUnit 5中，要正确集成Mockito，必须使用@ExtendWith(MockitoExtension.class)注解。这个注解告诉JUnit 5，在执行测试类时需要加载并应用Mockito的扩展，从而正确初始化@Mock和@InjectMocks注解的字段。

以下是结合@ParameterizedTest和@MethodSource的正确实践范例：

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.InjectMocks;
import org.mockito.Mock; // 标准Mockito注解
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;

/**
 * 辅助类定义，确保示例完整性。在实际项目中，这些类通常定义在单独的文件中。
 */
// 示例枚举类
public enum CodeEnum {
    S1("S1"),
    S2("S2");

    private final String code;

    CodeEnum(String code) {
        this.code = code;
    }

    public String getCode() {
        return code;
    }
}

// 示例输出数据类
public class Output {
    private final CodeEnum code;

    public static Builder builder() {
        return new Builder();
    }

    public CodeEnum getCode() {
        return code;
    }

    private Output(Builder builder) {
        this.code = builder.code;
    }

    public static class Builder {
        private CodeEnum code;

        public Builder code(CodeEnum code) {
            this.code = code;
            return this;
        }

        public Output build() {
            return new Output(this);
        }
    }
}

// 示例模拟输入类
public class MockedInput {
    // 可以在此定义字段，用于区分不同的模拟输入场景
}

// 示例被模拟的依赖类
public class MockedObject {
    public Output method(MockedInput input) {
        // 实际运行时此方法会被Mockito拦截并返回预设值
        throw new UnsupportedOperationException("This method should be mocked!");
    }
}

// 示例被测试的类 (System Under Test, SUT)
public class Foo {
    private final MockedObject mockedObject;

    // @InjectMocks 会尝试通过构造器或setter注入mock对象
    public Foo(MockedObject mockedObject) {
        this.mockedObject = mockedObject;
    }

    public Output method() {
        // 假设 Foo 的 method 方法内部会调用 mockedObject 的 method 方法
        // 这里为了示例，假设它总是调用 mockedObject.method(new MockedInput())
        // 实际情况中，MockedInput 可能由 Foo 内部逻辑生成或作为参数传入
        return mockedObject.method(new MockedInput());
    }
}


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

    @Mock // 使用标准的 @Mock 注解来创建模拟对象
    MockedObject mockedObject;

    @InjectMocks
    Foo underTest;

    /**
     * 参数化测试方法，通过 @MethodSource 获取测试数据。
     * 每个参数都直接用于配置模拟行为和进行断言。
     *
     * @param inputForMock 被用于模拟对象方法调用的输入参数
     * @param expectedReturnFromMock 模拟对象方法应返回的预期值
     */
    @ParameterizedTest
    @MethodSource("dataProvider")
    public void test_ParametrizedTest(MockedInput inputForMock, Output expectedReturnFromMock) {
        // Given: 配置模拟对象的行为
        // 当 mockedObject.method() 被调用时，如果传入的参数是 inputForMock，
        // 则返回 expectedReturnFromMock
        when(mockedObject.method(inputForMock))
            .thenReturn(expectedReturnFromMock);

        // When: 调用被测试单元的方法
        // 假设 underTest.method() 内部会调用 mockedObject.method(inputForMock)
        Output result = underTest.method();

        // Then: 验证结果
        assertEquals(expectedReturnFromMock.getCode(), result.getCode(),
                     "返回的 CodeEnum 应与预期值匹配");
    }

    /**
     * 数据提供方法，为参数化测试提供数据。
     * 返回一个 Stream<Arguments>，每个 Arguments 实例包含一组测试参数。
     */
    private static Stream<Arguments> dataProvider() {
        // 实例化 MockedInput 以便在测试数据中使用
        MockedInput mockedInput1 = new MockedInput();
        MockedInput mockedInput2 = new MockedInput();

        return Stream.of(
            // 第一组测试数据：当输入为 mockedInput1 时，返回 CodeEnum.S1
            Arguments.of(mockedInput1, Output.builder().code(CodeEnum.S1).build()),
            // 第二组测试数据：当输入为 mockedInput2 时，返回 CodeEnum.S2
            Arguments.of(mockedInput2, Output.builder().code(CodeEnum.S2).build())
        );
    }
}

在上述代码中：

1. @ExtendWith(MockitoExtension.class)：这是关键。它确保Mockito的注解（如@Mock, @InjectMocks）在JUnit 5测试运行前得到正确处理。
2. @ParameterizedTest 和 @MethodSource("dataProvider")：用于定义参数化测试和指定数据源方法。dataProvider方法返回Stream，其中每个Arguments实例包含一组用于测试方法的参数。
3. 动态模拟行为：在test_ParametrizedTest方法中，我们直接使用从dataProvider传入的inputForMock参数来配置when(mockedObject.method(inputForMock))。这样，每次参数化测试运行时，Mockito都会根据当前的inputForMock值来设置模拟对象的返回值expectedReturnFromMock。

关键点与注意事项

• JUnit版本兼容性：
  • JUnit 4：使用@RunWith(MockitoJUnitRunner.class)来集成Mockito。
  • JUnit 5 (JUnit Jupiter)：使用@ExtendWith(MockitoExtension.class)来集成Mockito。混用会导致不可预测的行为或错误。
• Mockito注解：
  • 在Mockito中，标准的模拟注解是@Mock。原问题中使用的@Mocked可能来自JMockit或其他模拟框架

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