Java 后端 / 系统课时

编写领域与服务单元测试

编写领域与服务单元测试

本课用订单支付示例建立两层单元测试:领域测试直接验证金额与状态规则,服务测试模拟仓储和支付网关,确认成功副作用与失败保护,全程不启动 Spring 容器。

学习目标

  • 使用 JUnit 5 与 AssertJ 验证业务规则和异常
  • 使用 Mockito 隔离仓储、网关等边界依赖
  • 同时检查状态变化、协作调用和禁止发生的操作

划分测试边界

领域对象测试使用真实对象,关注不变量,例如金额必须一致、已支付订单不能重复支付。服务测试同样使用真实领域对象,但把数据库仓储和外部支付网关替换为 Mock。

测试对象 真实对象 Mock 主要断言
领域规则 Order、值对象 无 状态、异常、不变量
服务协作 PaymentService、Order Repository、Gateway 结果、保存、禁止调用

单元测试不应加载数据库、HTTP 服务或完整 Spring 上下文;这些属于切片测试和集成测试的职责。

准备测试依赖

Spring Boot 3 的测试启动器包含 JUnit Jupiter、AssertJ 与 Mockito:

xml
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

依赖生效后,测试类可直接使用 @Test、AssertJ 断言和 Mockito 扩展。

实现被测业务

下面的项目代码定义订单规则、仓储边界、支付网关和服务协作。按注释保存为 src/main/java/com/example/order/PaymentDomain.java。

java
package com.example.order;

import java.math.BigDecimal;
import java.util.Optional;
import java.util.UUID;

final class Order {
    enum Status { CREATED, PAID }

    private final UUID id;
    private final BigDecimal total;
    private Status status = Status.CREATED;

    Order(UUID id, BigDecimal total) {
        if (total == null || total.signum() <= 0) {
            throw new IllegalArgumentException("订单金额必须大于 0");
        }
        this.id = id;
        this.total = total;
    }

    void markPaid(BigDecimal paidAmount) {
        // 状态与金额共同构成支付不变量。
        if (status != Status.CREATED) {
            throw new IllegalStateException("订单当前状态不允许支付");
        }
        if (total.compareTo(paidAmount) != 0) {
            throw new IllegalArgumentException("支付金额与订单金额不一致");
        }
        status = Status.PAID;
    }

    UUID id() {
        return id;
    }

    BigDecimal total() {
        return total;
    }

    Status status() {
        return status;
    }
}

interface OrderRepository {
    Optional<Order> findById(UUID id);
    Order save(Order order);
}

interface PaymentGateway {
    PaymentResult charge(UUID orderId, BigDecimal amount);
}

record PaymentResult(boolean approved, String transactionId) {}

final class PaymentRejectedException extends RuntimeException {
    PaymentRejectedException(String message) {
        super(message);
    }
}

final class PaymentService {
    private final OrderRepository repository;
    private final PaymentGateway gateway;

    PaymentService(OrderRepository repository, PaymentGateway gateway) {
        this.repository = repository;
        this.gateway = gateway;
    }

    void pay(UUID orderId) {
        // 外部网关批准后,才允许改变并保存领域状态。
        Order order = repository.findById(orderId)
                .orElseThrow(() -> new IllegalArgumentException("订单不存在"));
        PaymentResult result = gateway.charge(order.id(), order.total());
        if (!result.approved()) {
            throw new PaymentRejectedException("支付网关拒绝交易");
        }
        order.markPaid(order.total());
        repository.save(order);
    }
}

金额使用 BigDecimal.compareTo,因此 100.0 与 100.00 被视为数值相等。服务只在网关批准后修改并保存订单。

编写领域与服务测试

下面一个测试类覆盖两条领域规则和两条服务协作路径。领域用例不使用 Mock;服务用例只模拟边界依赖。

java
package com.example.order;

import static org.assertj.core.api.Assertions.*;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.*;

import java.math.BigDecimal;
import java.util.Optional;
import java.util.UUID;
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;

@ExtendWith(MockitoExtension.class)
class PaymentServiceTest {
    @Mock
    OrderRepository repository;

    @Mock
    PaymentGateway gateway;

    @InjectMocks
    PaymentService service;

    @Test
    void should_mark_order_paid_when_amount_matches() {
        Order order = new Order(UUID.randomUUID(), new BigDecimal("100.00"));

        order.markPaid(new BigDecimal("100.0"));

        assertThat(order.status()).isEqualTo(Order.Status.PAID);
    }

    @Test
    void should_keep_state_when_amount_is_wrong() {
        Order order = new Order(UUID.randomUUID(), new BigDecimal("100.00"));

        assertThatThrownBy(() -> order.markPaid(new BigDecimal("99.00")))
                .isInstanceOf(IllegalArgumentException.class)
                .hasMessage("支付金额与订单金额不一致");
        assertThat(order.status()).isEqualTo(Order.Status.CREATED);
    }

    @Test
    void should_save_order_when_gateway_approves() {
        UUID id = UUID.randomUUID();
        Order order = new Order(id, new BigDecimal("100.00"));
        when(repository.findById(id)).thenReturn(Optional.of(order));
        when(gateway.charge(id, order.total()))
                .thenReturn(new PaymentResult(true, "txn-001"));

        service.pay(id);

        assertThat(order.status()).isEqualTo(Order.Status.PAID);
        verify(gateway).charge(id, order.total());
        verify(repository).save(order);
    }

    @Test
    void should_not_save_order_when_gateway_rejects() {
        // 失败路径必须同时验证异常、状态和禁止发生的保存。
        UUID id = UUID.randomUUID();
        Order order = new Order(id, new BigDecimal("100.00"));
        when(repository.findById(id)).thenReturn(Optional.of(order));
        when(gateway.charge(id, order.total()))
                .thenReturn(new PaymentResult(false, null));

        assertThatThrownBy(() -> service.pay(id))
                .isInstanceOf(PaymentRejectedException.class)
                .hasMessage("支付网关拒绝交易");
        assertThat(order.status()).isEqualTo(Order.Status.CREATED);
        verify(repository, never()).save(any(Order.class));
    }
}

@InjectMocks 只创建被测服务并注入 Mock,不会启动 Spring。失败用例除了断言异常,还验证订单状态未改变且仓储未保存,防止只测到“抛错”却遗漏副作用。

运行与判断结果

在项目根目录执行:

bash
./mvnw test

预期输出:

text
Tests run: 4, Failures: 0, Errors: 0, Skipped: 0
BUILD SUCCESS
Total time: <TIME>

<TIME> 会随机器与依赖缓存变化。测试失败时应先阅读第一条断言差异或异常堆栈,不要通过删除断言、放宽验证或捕获异常让测试表面通过。

常见失误

不要 Mock Order 再验证 markPaid 被调用,因为这只能证明调用发生,不能证明领域规则正确。交互验证也只应用于有业务意义的副作用;若验证大量内部调用,正常重构也会频繁破坏测试。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

编写领域与服务单元测试

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通