246｜单元测试与可测试性设计：测试金字塔、Mock、契约和覆盖率质量

         /\
        /E2E\         端到端测试：少而精，覆盖关键业务流程
       /------\
      /  集成  \       集成测试：中等数量，验证组件交互
     /----------\
    /   单元测试   \    单元测试：数量最多，覆盖所有逻辑分支
   /--------------\

@Test
void shouldDeductBalanceWhenWithdrawSucceeds() {
    // Arrange
    var account = new Account("123", new Money(1000));
    // Act
    account.withdraw(new Money(200));
    // Assert
    assertEquals(new Money(800), account.balance());
}

@SpringBootTest
@Testcontainers
class OrderRepositoryTest {
    @Container
    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:15");
    
    @Test
    void shouldPersistAndRetrieveOrder() {
        orderRepository.save(order);
        var found = orderRepository.findById(order.getId());
        assertTrue(found.isPresent());
    }
}

@Test
void shouldApplyDiscountForVIPCustomer() {
    // Arrange —— 准备数据和前置条件
    var vip = new Customer("张三", CustomerLevel.VIP);
    var order = new Order(vip);
    order.addItem(new Item("键盘", new Money(500)));

    // Act —— 执行被测试的行为
    order.applyDiscount();

    // Assert —— 验证结果
    assertEquals(new Money(425), order.totalAmount());  // VIP 享 85 折
}

// 命名模式：should_预期行为_when_条件
shouldThrowInsufficientBalance_whenWithdrawExceedsBalance()
shouldReturnCachedValue_whenKeyExistsInCache()
shouldTimeoutAfter5Seconds_whenServiceUnavailable()

// 或者中文风格（适合团队非全英文环境）
应在余额不足时抛出异常()
缓存命中时不应调用数据库()

                        测试替身（Test Double）
                              |
        ┌─────────────────────┼─────────────────────┐
        |                     |                     |
     Dummy                  Stub                  Mock
   （只传参不调用）       （预设返回值）        （验证行为）
                              |
                           Fake                 Spy
                    （轻量级真实实现）      （记录调用信息）

// Stub 示例：只关心返回值
@Test
void shouldReturnUser_whenIdExists() {
    // Stub：预设行为
    when(userRepo.findById(1L)).thenReturn(Optional.of(new User("张三")));
    
    // Act & Assert：验证状态
    User user = userService.getUser(1L);
    assertEquals("张三", user.getName());
}

// Mock 示例：关心是否正确调用了依赖
@Test
void shouldSendEmail_whenOrderConfirmed() {
    // Act
    orderService.confirm(orderId);
    
    // Assert：验证行为 —— 确认 emailService.send() 被调用了一次
    verify(emailService, times(1)).send(
        argThat(email -> email.getTo().equals(order.getEmail()))
    );
}

// 基础 Mock
@Mock
private OrderRepository orderRepository;

// 参数匹配器
when(orderRepository.findById(anyLong())).thenReturn(Optional.of(order));
when(orderRepository.findByStatus(eq(Status.PAID))).thenReturn(List.of(order1, order2));

// 自定义参数匹配
argThat(order -> order.getAmount().compareTo(new Money(100)) > 0)

// 多次调用返回不同值
when(counter.next()).thenReturn(1, 2, 3, 4, 5);

// 抛出异常
when(paymentGateway.charge(any())).thenThrow(new PaymentFailedException());

// Void 方法的行为验证
doThrow(new IllegalStateException()).when(service).delete(anyLong());

// 验证调用次数
verify(repository, times(1)).save(any());
verify(repository, never()).delete(any());
verify(repository, atLeastOnce()).findById(anyLong());

// 验证调用顺序
InOrder inOrder = inOrder(repo1, repo2);
inOrder.verify(repo1).save(any());
inOrder.verify(repo2).updateStatus(any());

// 坏味道：Mock 了太多东西，测试只是在描述"步骤"
@Test
void shouldCreateOrder() {
    when(userRepo.findById(1L)).thenReturn(...);
    when(inventoryRepo.check(any())).thenReturn(...);
    when(pricingService.calculate(any())).thenReturn(...);
    when(paymentGateway.charge(any())).thenReturn(...);
    when(orderRepo.save(any())).thenReturn(...);
    when(notificationService.send(any())).thenReturn(...);
    
    orderService.create(request);
    
    verify(userRepo).findById(1L);
    verify(inventoryRepo).check(any());
    verify(pricingService).calculate(any());
    verify(paymentGateway).charge(any());
    verify(orderRepo).save(any());
    verify(notificationService).send(any());
}

// 不可测试 —— 依赖是硬编码的
public class OrderService {
    private final OrderRepository repo = new OrderRepositoryImpl(
        new DataSource("jdbc:mysql://...")
    );
}

// 可测试 —— 依赖从外部注入
public class OrderService {
    private final OrderRepository repo;
    
    public OrderService(OrderRepository repo) {
        this.repo = repo;
    }
}

// 好的单元测试：纯 Java，不启动 Spring
@Test
void shouldCalculateTotalPrice() {
    var pricingService = new PricingService(new FixedDiscountPolicy(0.1));
    var total = pricingService.calculate(List.of(item1, item2));
    assertEquals(new Money(900), total);
}

         ┌──────────────────────────┐
         │      领域模型（核心）       │
         │    → 纯单元测试，无需 Mock  │
         ├──────────────────────────┤
         │      应用服务层            │
         │    → Mock 端口接口即可      │
         ├──────────────────────────┤
         │      适配器层              │
         │    → 集成测试，连真实外部   │
         └──────────────────────────┘

// 坏：依赖系统时钟
if (LocalDate.now().isAfter(deadline)) { ... }

// 好：注入 Clock
public class DeadlineChecker {
    private final Clock clock;
    public boolean isOverdue(Order order) {
        return LocalDate.now(clock).isAfter(order.getDeadline());
    }
}
// 测试中：Clock.fixed(Instant.parse("2026-01-01T00:00:00Z"), ZoneOffset.UTC)

// 坏
Math.random();
// 好：注入 Random 实例，测试中用固定 seed
new Random(42);

// 坏：直接 new FileInputStream
// 好：依赖注入 InputStream/OutputStream，或封装为 FileStorage 接口

// 坏：静态调用无法替换
DiscountCalculator.getGlobalDiscount();

// 好：通过实例方法调用
discountPolicy.calculateDiscount(order);

// 可测试性满分
public Money calculateShippingFee(Address destination, Weight weight, ShippingPolicy policy) {
    if (policy.isFreeShipping(weight)) return Money.ZERO;
    return policy.calculate(destination, weight);
}
// 测试零 Mock，纯输入输出

@Test
void testDivide() {
    // 覆盖率 100%：每行都执行了
    assertEquals(2, calculator.divide(10, 5));  // 正常路径
    // 没有测：除以零、负数、溢出、精度丢失
}

public int findMax(int[ ] arr) {

    int max = arr[0];
    for (int i = 1; i < arr.length; i++) {
        if (arr[i] > max) {
            max = arr[i];  // 覆盖率 100%，实际少了边界处理
        }
    }
    return max;
}

// 测试只测了 {1,2,3}，没测 null、空数组、单元素、全相同值

// 原代码
if (a > b) { return a; }

// 变异体 1：把 > 改成 >=  —— 如果测试没变红，说明测试不够
// 变异体 2：把 > 改成 <   —— 如果测试没变红，说明测试不够  
// 变异体 3：去掉整个 if    —— 如果测试没变红，说明测试不够

<!-- Maven 配置 -->
<plugin>
    <groupId>org.pitest</groupId>
    <artifactId>pitest-maven</artifactId>
    <version>1.15.0</version>
    <configuration>
        <targetClasses>
            <param>com.example.domain.*</param>
        </targetClasses>
        <targetTests>
            <param>com.example.domain.*</param>
        </targetTests>
    </configuration>
</plugin>

  消费者A期望:             消费者B期望:              消费者C期望:
  GET /users/1             GET /users?page=1         POST /users
  {name, email}            {id, name, avatar}        body: {name, email}
        \                      |                      /
         \                     |                     /
          └────────────────────┼────────────────────┘
                               |
                       提供者验证: 所有契约都能满足
                               |
                         ✓ A: name ✓, email ✓
                         ✓ B: id ✓, name ✓, avatar ✓
                         ✓ C: POST 接受并创建 ✓

@ExtendWith(PactConsumerTestExt.class)
@PactTestFor(providerName = "user-service", port = "8080")
class UserServiceConsumerTest {
    
    @Pact(consumer = "order-service")
    V3Pact createPact(PactDslWithProvider builder) {
        return builder
            .given("user 1 exists")
            .uponReceiving("a request for user 1")
                .path("/users/1")
                .method("GET")
            .willRespondWith()
                .status(200)
                .headers(Map.of("Content-Type", "application/json"))
                .body("{\"id\": 1, \"name\": \"张三\", \"email\": \"zhangsan@example.com\"}")
            .toPact(V3Pact.class);
    }
    
    @Test
    @PactTestFor(pactMethod = "createPact")
    void shouldGetUser() {
        User user = userClient.getUser(1L);
        assertEquals("张三", user.getName());
        assertEquals("zhangsan@example.com", user.getEmail());
    }
}

@Provider("user-service")
@PactBroker(url = "https://pact-broker.example.com")
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class UserServiceProviderTest {
    
    @LocalServerPort
    int port;
    
    @BeforeEach
    void setUp() {
        // 准备测试数据
    }
    
    @TestTemplate
    @ExtendWith(PactVerificationInvocationContextProvider.class)
    void pactVerificationTestTemplate(PactVerificationContext context) {
        context.verifyInteraction();
    }
    
    @State("user 1 exists")
    void user1Exists() {
        userRepository.save(new User(1L, "张三", "zhangsan@example.com"));
    }
}

// 坏：测试之间共享可变数据
private static final List<Order> ORDERS = new ArrayList<>();
@BeforeAll
static void setUp() {
    ORDERS.add(new Order(...));  // 多个测试修改同一个列表 → 测试顺序依赖
}

// 好：每个测试自己造数据
@Test
void shouldCalculateTotal() {
    var orders = List.of(
        new Order(new Money(100)),
        new Order(new Money(200))
    );
    // ...
}

// Test Data Builder
Order anOrder() {
    return Order.builder()
        .id(1L)
        .customer(aCustomer())
        .items(List.of(anItem()))
        .build();
}