掌握JUnit 5参数化测试：高效测试Switch-Case逻辑与最佳实践

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

// 确保测试类加载MockitoExtension
@ExtendWith(MockitoExtension.class)
public class MyServiceTest {

    @Mock // 模拟RepoFactory的依赖
    private ConsentApplicationRepo consentApplicationRepo;

    @InjectMocks // 注入模拟的依赖到被测对象
    private MyService myService; // 假设这是包含switchCase方法的类

    // ... 测试方法
}

public class MyService {

    @InjectMocks
    private RepoFactory repoFactory; // 假设RepoFactory内部有getConsentApplicationRepo()

    // 假设这些是成员变量或通过构造函数注入
    private String custDataApiKey;
    private String creditParamApiKey;
    private String multiEntitiApiKey;
    private HttpHeaders httpHeaders; // 假设这是要修改的HttpHeader

    // 假设CrestApiServiceNameEnum和ConsentApplicationVO是已定义的枚举和VO
    // 并且serviceNameEnum和consentApplicationVo是方法内部或通过其他方式获取的
    public void switchCase(CrestApiServiceNameEnum serviceNameEnum, ConsentApplicationVO consentApplicationVo) {
        ConsentApplication consentApplication = repoFactory.getConsentApplicationRepo()
                .findOne(consentApplicationVo.getId());

        switch (CrestApiServiceNameEnum.getByCode(serviceNameEnum.getCode())) {
            case CUST_DATA:
                // newCrestApiTrack.setRepRefNo(null); // 假设这部分逻辑在其他地方处理或简化
                httpHeaders.add("API-KEY", custDataApiKey);
                break;
            case CREDIT_PARAM:
                httpHeaders.add("API-KEY", creditParamApiKey);
                break;
            case CONFIRM_MUL_ENT:
                httpHeaders.add("API-KEY", multiEntitiApiKey);
                break;
            default:
                // LOGGER.info("Unexpected value: " + CrestApiServiceNameEnum.getByCode(serviceNameEnum.getCode()));
                // 默认处理，可能抛出异常或返回特定值
                break;
        }
    }
}

// 假设这是您的业务逻辑类
public class ApiKeyService {

    // 假设这些API Key是通过构造函数或配置注入的
    private final String custDataApiKey;
    private final String creditParamApiKey;
    private final String multiEntitiApiKey;

    public ApiKeyService(String custDataApiKey, String creditParamApiKey, String multiEntitiApiKey) {
        this.custDataApiKey = custDataApiKey;
        this.creditParamApiKey = creditParamApiKey;
        this.multiEntitiApiKey = multiEntitiApiKey;
    }

    // 假设CrestApiServiceNameEnum是您的枚举
    public enum CrestApiServiceNameEnum {
        CUST_DATA("CUST_DATA"),
        CREDIT_PARAM("CREDIT_PARAM"),
        CONFIRM_MUL_ENT("CONFIRM_MUL_ENT"),
        UNKNOWN("UNKNOWN"); // 添加一个未知或默认值

        private final String code;

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

        public String getCode() {
            return code;
        }

        public static CrestApiServiceNameEnum getByCode(String code) {
            for (CrestApiServiceNameEnum e : values()) {
                if (e.getCode().equals(code)) {
                    return e;
                }
            }
            return UNKNOWN;
        }
    }

    /**
     * 根据服务名称枚举获取对应的API Key
     * @param serviceNameEnum 服务名称枚举
     * @return 对应的API Key，如果未匹配到则返回null或空字符串（根据业务需求）
     */
    public String getApiKeyForService(CrestApiServiceNameEnum serviceNameEnum) {
        switch (serviceNameEnum) {
            case CUST_DATA:
                return custDataApiKey;
            case CREDIT_PARAM:
                return creditParamApiKey;
            case CONFIRM_MUL_ENT:
                return multiEntitiApiKey;
            default:
                // 对于未预期的值，可以抛出异常、返回null或一个默认值
                // LOGGER.warn("Unexpected service name: " + serviceNameEnum);
                return null; // 或者抛出 IllegalArgumentException
        }
    }
}

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.EnumSource;
import org.junit.jupiter.params.provider.MethodSource;
import org.junit.jupiter.params.provider.Arguments;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.params.provider.Arguments.arguments;

import java.util.stream.Stream;

public class ApiKeyServiceTest {

    private ApiKeyService apiKeyService;

    // 模拟的API Key值
    private final String MOCK_CUST_DATA_API_KEY = "mockCustDataApiKey";
    private final String MOCK_CREDIT_PARAM_API_KEY = "mockCreditParamApiKey";
    private final String MOCK_MULTI_ENT_API_KEY = "mockMultiEntitiApiKey";

    @BeforeEach
    void setUp() {
        // 在每个测试方法执行前初始化被测对象
        apiKeyService = new ApiKeyService(
                MOCK_CUST_DATA_API_KEY,
                MOCK_CREDIT_PARAM_API_KEY,
                MOCK_MULTI_ENT_API_KEY
        );
    }

    // 使用 EnumSource 为每个枚举值提供参数
    @ParameterizedTest
    @EnumSource(ApiKeyService.CrestApiServiceNameEnum.class)
    void testGetApiKeyForService_EnumSource(ApiKeyService.CrestApiServiceNameEnum serviceNameEnum) {
        String expectedApiKey;
        switch (serviceNameEnum) {
            case CUST_DATA:
                expectedApiKey = MOCK_CUST_DATA_API_KEY;
                break;
            case CREDIT_PARAM:
                expectedApiKey = MOCK_CREDIT_PARAM_API_KEY;
                break;
            case CONFIRM_MUL_ENT:
                expectedApiKey = MOCK_MULTI_ENT_API_KEY;
                break;
            default: // 覆盖 UNKNOWN 或其他未处理的情况
                expectedApiKey = null;
                break;
        }
        assertEquals(expectedApiKey, apiKeyService.getApiKeyForService(serviceNameEnum),
                     "API Key should match for " + serviceNameEnum);
    }

    // 或者使用 MethodSource 提供更复杂的参数组合
    @ParameterizedTest
    @MethodSource("apiKeyServiceTestCases")
    void testGetApiKeyForService_MethodSource(ApiKeyService.CrestApiServiceNameEnum inputEnum, String expectedApiKey) {
        assertEquals(expectedApiKey, apiKeyService.getApiKeyForService(inputEnum),
                     "API Key should match for " + inputEnum);
    }

    // MethodSource 的参数提供方法，必须是静态的
    static Stream<Arguments> apiKeyServiceTestCases() {
        final String MOCK_CUST_DATA_API_KEY = "mockCustDataApiKey";
        final String MOCK_CREDIT_PARAM_API_KEY = "mockCreditParamApiKey";
        final String MOCK_MULTI_ENT_API_KEY = "mockMultiEntitiApiKey";

        return Stream.of(
                arguments(ApiKeyService.CrestApiServiceNameEnum.CUST_DATA, MOCK_CUST_DATA_API_KEY),
                arguments(ApiKeyService.CrestApiServiceNameEnum.CREDIT_PARAM, MOCK_CREDIT_PARAM_API_KEY),
                arguments(ApiKeyService.CrestApiServiceNameEnum.CONFIRM_MUL_ENT, MOCK_MULTI_ENT_API_KEY),
                arguments(ApiKeyService.CrestApiServiceNameEnum.UNKNOWN, null) // 测试默认情况
        );
    }
}