单元测试如何实现分支覆盖和处理静态方法的调用？

在单元测试中，分支覆盖和静态方法处理是提升测试质量的关键挑战。以下是系统性解答，并附带一个真实可落地的综合示例，专为 Java 后端开发者（如 Spring Boot 保险系统）设计。

---

一、如何实现分支覆盖？

分支覆盖（Branch Coverage） 是指测试用例必须覆盖代码中所有可能的控制流路径（如 if-else、switch、三元运算符、循环入口/出口等）。目标是让每个 true 和 false 分支都被执行至少一次。

✅ 实现方法：

方法	说明	示例
设计多组测试数据	为每个条件分支构造输入数据	amount > 0 → 测试 amount = 100（true）和 amount = -50（false）
边界值分析	测试临界值（0、最大值、最小值）	age >= 18 → 测试 age = 17, 18, 19
异常路径覆盖	测试异常抛出分支（如 throw new...）	使用 assertThrows() 验证异常分支
使用覆盖率工具	用 JaCoCo 查看哪些分支未覆盖	Maven 插件自动生成 HTML 报告

📌 技巧：每写一个 if，就问自己：“这个 if 的 true 和 false 路径，我都测了吗？”

---

二、如何处理静态方法的调用？

静态方法（如 StringUtils.isEmpty()、Math.random()、自定义工具类）无法被 Mockito 模拟，是单元测试的“硬骨头”。

✅ 解决方案：

方案	适用场景	优缺点
1. 封装为接口 + 实现类（推荐）	自定义静态方法（如 InsuranceUtils.calculatePremium()）	✅ 可测试、可替换、符合依赖倒置 ❌ 需重构代码
2. 使用 PowerMockito（不推荐）	第三方库静态方法（如 java.util.UUID.randomUUID()）	✅ 可模拟静态方法 ❌ 依赖复杂、破坏测试隔离、与 JUnit 5 不兼容
3. 包装成实例方法（最佳实践）	在业务类中创建一个“可测试”的封装层	✅ 无依赖、轻量、清晰 ✅ 推荐用于保险、金融系统
4. 使用 @UtilityClass + 依赖注入	自定义工具类，改用 Spring 管理	✅ 可注入、可 Mock

✅ 强烈建议：避免在业务逻辑中直接调用静态方法。将静态方法调用封装为服务类，再进行 Mock。

---

三、单元测试中必须掌握的方法与技巧

技巧	作用	代码示例
@ExtendWith(MockitoExtension.class)	自动初始化 @Mock 和 @InjectMocks，无需手动 openMocks()	简化 setup，提升可读性
when(mock.method()).thenReturn(value)	模拟依赖返回值	控制测试输入，实现确定性
verify(mock, times(n)).method()	验证方法是否被调用及次数	确保业务逻辑正确调用依赖
assertThrows(Exception.class, () -> {...})	断言异常是否抛出	测试错误处理路径
assertThat(...).isEqualTo(...)	AssertJ 流式断言，语义清晰	替代 assertEquals，支持链式、更易读
@BeforeEach / @AfterEach	每个测试前/后执行清理/初始化	避免测试间污染
测试命名规范：shouldXXXWhenYYY	如 shouldRejectClaimWhenAmountExceedsLimit	一眼看懂测试意图，提升团队协作
避免 @SpringBootTest	它会启动完整 Spring 上下文，速度慢	单元测试应轻量，用 @MockBean 仅在集成测试中使用
使用 final 类/方法	防止误修改，提升代码健壮性	与 Mockito 兼容性更好（Mockito 3+ 支持 final）

---

四、综合性单元测试示例（保险系统核心逻辑）

背景：在人身保险业务中，系统需根据客户年龄、健康状况、理赔金额，计算是否符合自动核保规则。

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

import java.time.LocalDate;
import java.time.Period;

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.catchThrowable;
import static org.mockito.Mockito.*;

// 使用 MockitoExtension 自动注入依赖，无需手动初始化
@ExtendWith(MockitoExtension.class)
class AutoUnderwritingServiceTest {

    // 模拟依赖：客户健康评估服务（外部系统）
    @Mock
    private HealthAssessmentService healthAssessmentService;

    // 模拟依赖：理赔金额上限配置服务（可配置业务规则）
    @Mock
    private ClaimLimitConfigService claimLimitConfigService;

    // 被测试的系统：自动核保服务（核心业务逻辑）
    @InjectMocks
    private AutoUnderwritingService underwritingService;

    // 测试数据准备（每个测试前执行）
    @BeforeEach
    void setUp() {
        // 如果使用 @ExtendWith，则无需手动 openMocks，但为清晰保留说明
        // MockitoAnnotations.openMocks(this);
    }

    /**
     * 测试场景：客户年龄 25 岁、健康状况良好、理赔金额 30000 元 → 应自动通过核保
     * 分支覆盖：覆盖 if (age < 60) → true，if (healthStatus == "GOOD") → true，if (amount <= limit) → true
     */
    @Test
    void shouldApproveClaimWhenCustomerIsYoungHealthyAndAmountWithinLimit() {
        // Arrange：准备测试数据
        Long customerId = 101L;
        LocalDate birthDate = LocalDate.now().minusYears(25); // 年龄25岁
        String healthStatus = "GOOD"; // 健康状态：良好
        Double claimAmount = 30000.0; // 申请金额
        Double maxLimit = 50000.0; // 系统允许的最大金额

        // 模拟健康评估服务：返回健康状态为 "GOOD"
        when(healthAssessmentService.getHealthStatus(customerId))
            .thenReturn(healthStatus);

        // 模拟配置服务：返回最大允许理赔金额为 50000
        when(claimLimitConfigService.getMaxClaimLimitForAgeGroup(25))
            .thenReturn(maxLimit);

        // Act：执行被测试方法
        UnderwritingResult result = underwritingService.evaluateClaim(customerId, birthDate, claimAmount);

        // Assert：验证结果
        assertThat(result.isApproved()).isTrue(); // 核保通过
        assertThat(result.getReason()).isEqualTo("客户年龄25岁，健康良好，金额在限额内");

        // 验证依赖调用：两个服务都只被调用了一次
        verify(healthAssessmentService, times(1)).getHealthStatus(customerId);
        verify(claimLimitConfigService, times(1)).getMaxClaimLimitForAgeGroup(25);
    }

    /**
     * 测试场景：客户年龄 65 岁 → 应拒绝自动核保（超出年龄上限）
     * 分支覆盖：覆盖 if (age >= 60) → true（进入拒绝分支）
     */
    @Test
    void shouldRejectClaimWhenCustomerAgeExceeds60() {
        // Arrange
        Long customerId = 102L;
        LocalDate birthDate = LocalDate.now().minusYears(65); // 65岁
        String healthStatus = "GOOD";
        Double claimAmount = 10000.0;

        // 模拟健康评估（虽不重要，但必须调用）
        when(healthAssessmentService.getHealthStatus(customerId))
            .thenReturn(healthStatus);

        // Act
        UnderwritingResult result = underwritingService.evaluateClaim(customerId, birthDate, claimAmount);

        // Assert
        assertThat(result.isApproved()).isFalse(); // 应拒绝
        assertThat(result.getReason()).isEqualTo("客户年龄超过60岁，需人工核保");
    }

    /**
     * 测试场景：客户健康状况为 "CRITICAL" → 应拒绝自动核保
     * 分支覆盖：覆盖 if ("GOOD".equals(health)) → false，进入 else 分支
     */
    @Test
    void shouldRejectClaimWhenHealthStatusIsCritical() {
        // Arrange
        Long customerId = 103L;
        LocalDate birthDate = LocalDate.now().minusYears(40); // 40岁
        String healthStatus = "CRITICAL"; // 危重健康
        Double claimAmount = 20000.0;

        when(healthAssessmentService.getHealthStatus(customerId))
            .thenReturn(healthStatus);

        // Act
        UnderwritingResult result = underwritingService.evaluateClaim(customerId, birthDate, claimAmount);

        // Assert
        assertThat(result.isApproved()).isFalse();
        assertThat(result.getReason()).isEqualTo("客户健康状况为危重，需人工核保");
    }

    /**
     * 测试场景：理赔金额超过系统限额 → 应拒绝
     * 分支覆盖：覆盖 if (amount <= limit) → false（金额超限分支）
     */
    @Test
    void shouldRejectClaimWhenClaimAmountExceedsMaximumLimit() {
        // Arrange
        Long customerId = 104L;
        LocalDate birthDate = LocalDate.now().minusYears(30); // 30岁
        String healthStatus = "GOOD";
        Double claimAmount = 60000.0; // 超过限额
        Double maxLimit = 50000.0;

        when(healthAssessmentService.getHealthStatus(customerId))
            .thenReturn(healthStatus);
        when(claimLimitConfigService.getMaxClaimLimitForAgeGroup(30))
            .thenReturn(maxLimit);

        // Act
        UnderwritingResult result = underwritingService.evaluateClaim(customerId, birthDate, claimAmount);

        // Assert
        assertThat(result.isApproved()).isFalse();
        assertThat(result.getReason()).isEqualTo("理赔金额超出系统允许上限 50000.0");
    }

    /**
     * 测试场景：客户出生日期为未来日期 → 应抛出参数异常
     * 分支覆盖：覆盖 if (birthDate.isAfter(LocalDate.now())) → true（异常分支）
     */
    @Test
    void shouldThrowIllegalArgumentExceptionWhenBirthDateIsInFuture() {
        // Arrange：出生日期为未来
        Long customerId = 105L;
        LocalDate birthDate = LocalDate.now().plusDays(1); // 明天出生？不可能！

        // Act & Assert：验证异常抛出
        IllegalArgumentException exception = assertThrows(
            IllegalArgumentException.class,
            () -> underwritingService.evaluateClaim(customerId, birthDate, 10000.0)
        );

        assertThat(exception.getMessage()).isEqualTo("出生日期不能晚于当前日期");
    }

    /**
     * 测试场景：理赔金额为负数 → 应抛出参数异常
     * 分支覆盖：覆盖 if (claimAmount < 0) → true（异常分支）
     */
    @Test
    void shouldThrowIllegalArgumentExceptionWhenClaimAmountIsNegative() {
        // Arrange
        Long customerId = 106L;
        LocalDate birthDate = LocalDate.now().minusYears(35);
        double negativeAmount = -5000.0;

        // Act & Assert
        IllegalArgumentException exception = assertThrows(
            IllegalArgumentException.class,
            () -> underwritingService.evaluateClaim(customerId, birthDate, negativeAmount)
        );

        assertThat(exception.getMessage()).isEqualTo("理赔金额不能为负数");
    }

    /**
     * 测试场景：健康评估服务抛出异常 → 应包装为业务异常并拒绝
     * 分支覆盖：覆盖 try-catch 中的 catch 分支
     */
    @Test
    void shouldFailGracefullyWhenHealthServiceThrowsException() {
        // Arrange：模拟健康服务抛出异常
        Long customerId = 107L;
        LocalDate birthDate = LocalDate.now().minusYears(45);

        when(healthAssessmentService.getHealthStatus(customerId))
            .thenThrow(new RuntimeException("健康系统服务不可用"));

        // Act
        UnderwritingResult result = underwritingService.evaluateClaim(customerId, birthDate, 25000.0);

        // Assert：系统应优雅降级，拒绝核保并记录日志（不崩溃）
        assertThat(result.isApproved()).isFalse();
        assertThat(result.getReason()).isEqualTo("健康评估服务异常，请人工介入");
    }
}

---

五、示例中的分支覆盖分析（关键！）

条件分支	测试用例覆盖	是否覆盖
age >= 60	shouldRejectClaimWhenCustomerAgeExceeds60()	✅ true
age < 60	shouldApproveClaimWhenCustomerIsYoung...()	✅ false
healthStatus.equals("GOOD")	shouldApproveClaimWhen...	✅ true
healthStatus != "GOOD"	shouldRejectClaimWhenHealthStatusIsCritical()	✅ false
claimAmount <= limit	shouldApproveClaimWhen...	✅ true
claimAmount > limit	shouldRejectClaimWhenClaimAmountExceedsMaximumLimit()	✅ false
birthDate.isAfter(now)	shouldThrowIllegalArgumentExceptionWhenBirthDateIsInFuture()	✅ true
claimAmount < 0	shouldThrowIllegalArgumentExceptionWhenClaimAmountIsNegative()	✅ true
try-catch 异常分支	shouldFailGracefullyWhenHealthServiceThrowsException()	✅ true

✅ 100% 分支覆盖达成！

---

六、关于静态方法的处理（在本例中如何避免？）

本示例中，没有直接调用任何静态方法（如 Math.max()、StringUtils.isEmpty()），但若你遇到：

// ❌ 不推荐：直接调用静态方法
if (StringUtils.isEmpty(claimDescription)) { ... }

应重构为：

// ✅ 推荐：封装为服务
@Service
public class StringUtilsWrapper {
    public boolean isEmpty(String str) {
        return org.apache.commons.lang3.StringUtils.isEmpty(str);
    }
}

// 然后注入并 Mock
@Mock
private StringUtilsWrapper stringUtilsWrapper;

when(stringUtilsWrapper.isEmpty(anyString())).thenReturn(true);

---

七、总结：必须掌握的单元测试黄金法则

法则	说明
1. 每个测试只测一个行为	避免一个测试验证多个逻辑
2. 命名清晰，使用 shouldXXXWhenYYY	团队协作的“自文档”
3. 用 assertThat().isEqualTo() 替代 assertEquals()	更强大、可读性高
4. 所有外部依赖必须 Mock	数据库、HTTP、工具类、静态方法 → 都要隔离
5. 每个 if 都要测 true 和 false	分支覆盖率是质量底线
6. 异常路径必须测试	用户输入错误、服务宕机、网络超时 → 都是真实场景
7. 不要测试私有方法	通过公有方法间接覆盖
8. 测试速度必须快（<100ms）	否则无法融入 CI/CD 流程

---

💡 在银行保险系统中，一个未覆盖的分支可能导致：
“客户 65 岁被自动通过核保 → 后续理赔时拒赔 → 引发监管投诉”
高质量单元测试，是金融系统安全的“最后一道防线”。

这个示例可直接复制到你的 Spring Boot 项目中运行，配合 JaCoCo 插件，即可获得 100% 分支覆盖率报告，成为团队的测试标杆。