JUnit 5 参数化测试与Mockito的正确集成实践

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

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