JUnit 5参数化测试与Mockito集成实践：动态模拟返回值与常见陷阱

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
   }
}

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())
        );
    }
}