【阶段 8】测试：JUnit 5、Mockito 与 Testcontainers

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.2.5</version>
    <relativePath/>
</parent>

<properties>
    <java.version>17</java.version>
    <mybatis-plus.version>3.5.7</mybatis-plus.version>
    <jacoco.version>0.8.12</jacoco.version>
</properties>

<dependencies>
    <!-- Web + 参数校验 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-validation</artifactId>
    </dependency>

    <!-- MyBatis-Plus（Spring Boot 3 专用 starter） -->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-spring-boot3-starter</artifactId>
        <version>${mybatis-plus.version}</version>
    </dependency>

    <!-- MySQL 驱动 -->
    <dependency>
        <groupId>com.mysql</groupId>
        <artifactId>mysql-connector-j</artifactId>
        <scope>runtime</scope>
    </dependency>

    <!-- Lombok -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>

    <!-- 测试基础：JUnit 5 + Mockito + AssertJ + Hamcrest -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>

    <!-- Testcontainers：JUnit 5 集成 + MySQL 模块 -->
    <dependency>
        <groupId>org.testcontainers</groupId>
        <artifactId>junit-jupiter</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.testcontainers</groupId>
        <artifactId>mysql</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

docker run -d --name mysql-dev 
  -e MYSQL_ROOT_PASSWORD=root 
  -e MYSQL_DATABASE=demo 
  -p 3306:3306 
  mysql:8.0.36

-- 订单表
CREATE TABLE IF NOT EXISTS t_order (
    id           BIGINT AUTO_INCREMENT PRIMARY KEY,
    order_no     VARCHAR(64)    NOT NULL COMMENT '订单号',
    user_id      BIGINT         NOT NULL COMMENT '下单用户',
    product_id   BIGINT         NOT NULL COMMENT '商品ID',
    quantity     INT            NOT NULL COMMENT '购买数量',
    total_amount DECIMAL(10, 2) NOT NULL COMMENT '订单总金额',
    status       TINYINT        NOT NULL DEFAULT 1 COMMENT '1=待支付 2=已支付 3=已取消',
    created_at   DATETIME       NOT NULL COMMENT '创建时间'
);

-- 库存表
CREATE TABLE IF NOT EXISTS t_stock (
    id         BIGINT AUTO_INCREMENT PRIMARY KEY,
    product_id BIGINT NOT NULL COMMENT '商品ID',
    stock      INT    NOT NULL COMMENT '可用库存'
);

-- 商品表
CREATE TABLE IF NOT EXISTS t_product (
    id           BIGINT AUTO_INCREMENT PRIMARY KEY,
    product_name VARCHAR(128)   NOT NULL COMMENT '商品名',
    price        DECIMAL(10, 2) NOT NULL COMMENT '单价'
);

spring:
  application:
    name: demo
  datasource:
    url: jdbc:mysql://localhost:3306/demo?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai
    username: root
    password: root
    driver-class-name: com.mysql.cj.jdbc.Driver

mybatis-plus:
  configuration:
    map-underscore-to-camel-case: true   # 下划线列名自动映射到驼峰字段
  global-config:
    banner: false

import lombok.Data;
import org.slf4j.MDC;

@Data
public class ApiResult<T> {
    private int code;        // 0=成功，非 0=错误码
    private String message;  // 提示信息
    private T data;          // 业务数据
    private String traceId;  // 链路追踪 id

    public static <T> ApiResult<T> ok(T data) {
        ApiResult<T> r = new ApiResult<>();
        r.setCode(ErrorCode.SUCCESS.getCode());
        r.setMessage(ErrorCode.SUCCESS.getMessage());
        r.setData(data);
        r.setTraceId(MDC.get("traceId"));
        return r;
    }
    public static <T> ApiResult<T> ok() {
        return ok(null);
    }
    public static <T> ApiResult<T> fail(int code, String message) {
        ApiResult<T> r = new ApiResult<>();
        r.setCode(code);
        r.setMessage(message);
        r.setTraceId(MDC.get("traceId"));
        return r;
    }
    public static <T> ApiResult<T> fail(ErrorCode ec) {
        return fail(ec.getCode(), ec.getMessage());
    }
}

package com.example.demo.common;

/**
 * 统一错误码枚举。基础码与全系列保持一致，
 * 本篇按订单/库存场景扩展 ORDER_NOT_FOUND / STOCK_NOT_ENOUGH。
 */
public enum ErrorCode {
    SUCCESS(0, "success"),
    PARAM_ERROR(40001, "参数错误"),
    UNAUTHORIZED(40101, "未登录或登录已过期"),
    FORBIDDEN(40301, "无权限访问"),
    USER_NOT_FOUND(40401, "用户不存在"),
    ORDER_NOT_FOUND(40403, "订单不存在"),
    STOCK_NOT_ENOUGH(50002, "库存不足"),
    SYSTEM_ERROR(50000, "系统繁忙，请稍后重试");

    private final int code;
    private final String message;

    ErrorCode(int code, String message) {
        this.code = code;
        this.message = message;
    }

    public int getCode() {
        return code;
    }

    public String getMessage() {
        return message;
    }
}

package com.example.demo.exception;

import com.example.demo.common.ErrorCode;

/**
 * 统一业务异常：业务代码主动抛出，由全局异常处理器统一转成 ApiResult。
 */
public class BizException extends RuntimeException {
    private final int code;

    public BizException(ErrorCode ec) {
        super(ec.getMessage());
        this.code = ec.getCode();
    }

    public BizException(int code, String message) {
        super(message);
        this.code = code;
    }

    public int getCode() {
        return code;
    }
}

package com.example.demo.exception;

import com.example.demo.common.ApiResult;
import com.example.demo.common.ErrorCode;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

/**
 * 全局异常处理器：把各种异常统一转成 ApiResult。
 * 兜底异常对外只返回模糊提示，详细堆栈只进日志（防止泄露内部实现细节）。
 */
@Slf4j
@RestControllerAdvice
public class GlobalExceptionHandler {

    // 业务异常：直接透出错误码与提示
    @ExceptionHandler(BizException.class)
    public ApiResult<Void> handleBiz(BizException e) {
        log.warn("业务异常: code={}, message={}", e.getCode(), e.getMessage());
        return ApiResult.fail(e.getCode(), e.getMessage());
    }

    // 参数校验异常（@Valid 触发）：提示第一条校验错误
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ApiResult<Void> handleValid(MethodArgumentNotValidException e) {
        String msg = e.getBindingResult().getFieldErrors().stream()
                .findFirst()
                .map(f -> f.getField() + " " + f.getDefaultMessage())
                .orElse(ErrorCode.PARAM_ERROR.getMessage());
        return ApiResult.fail(ErrorCode.PARAM_ERROR.getCode(), msg);
    }

    // 兜底异常：对外模糊提示，详细堆栈进日志
    @ExceptionHandler(Exception.class)
    public ApiResult<Void> handleOther(Exception e) {
        log.error("系统异常", e);
        return ApiResult.fail(ErrorCode.SYSTEM_ERROR);
    }
}

package com.example.demo.service;

import com.example.demo.common.ErrorCode;
import com.example.demo.exception.BizException;

import java.math.BigDecimal;

/**
 * 订单金额计算器：纯逻辑类，不依赖任何 Bean，是单元测试的最佳练手对象。
 * 用 BigDecimal 而非 double，因为金额计算不允许浮点误差。
 */
public class OrderAmountCalculator {

    // 满 200 减 20（满减阈值和金额用常量，便于测试和调整）
    public static final BigDecimal FULL_REDUCTION_THRESHOLD = new BigDecimal("200");
    public static final BigDecimal FULL_REDUCTION_AMOUNT = new BigDecimal("20");

    /** 计算金额 = 单价 * 数量，入参非法直接抛业务异常 */
    public BigDecimal calculate(BigDecimal unitPrice, int quantity) {
        if (unitPrice == null) {
            throw new BizException(ErrorCode.PARAM_ERROR.getCode(), "商品单价不能为空");
        }
        if (unitPrice.compareTo(BigDecimal.ZERO) <= 0) {
            throw new BizException(ErrorCode.PARAM_ERROR.getCode(), "商品单价必须大于0");
        }
        if (quantity <= 0) {
            throw new BizException(ErrorCode.PARAM_ERROR.getCode(), "购买数量必须大于0");
        }
        return unitPrice.multiply(BigDecimal.valueOf(quantity));
    }

    /** 满减：总金额达到阈值减固定金额，否则原样返回 */
    public BigDecimal applyFullReduction(BigDecimal total) {
        if (total == null) {
            throw new BizException(ErrorCode.PARAM_ERROR.getCode(), "订单金额不能为空");
        }
        if (total.compareTo(FULL_REDUCTION_THRESHOLD) >= 0) {
            return total.subtract(FULL_REDUCTION_AMOUNT);
        }
        return total;
    }
}

package com.example.demo.service;

import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

import java.math.BigDecimal;

import static org.junit.jupiter.api.Assertions.assertEquals;

class OrderAmountCalculatorTest {

    private OrderAmountCalculator calculator;
    private int testCount;   // 用来演示 @BeforeEach 每个测试都会重置

    @BeforeEach
    void setUp() {
        // 每个测试方法执行前都会新建一个「干净」的 calculator，
        // 避免测试之间通过共享状态互相污染
        calculator = new OrderAmountCalculator();
        testCount = 0;
    }

    @AfterEach
    void tearDown() {
        // 这里演示「清理资源」的位置：真实场景常用来释放临时文件、清空缓存等
        calculator = null;
    }

    @Test
    @DisplayName("正常计算：单价乘以数量")
    void testCalculate() {
        BigDecimal total = calculator.calculate(new BigDecimal("99.00"), 3);
        // 用 compareTo 比较 BigDecimal，而不是 equals（equals 会连 scale 一起比）
        assertEquals(0, new BigDecimal("297.00").compareTo(total));
        testCount++;
        assertEquals(1, testCount);   // 证明这个测试里 testCount 是从 0 开始累加的
    }

    @Test
    @DisplayName("满减：达到 200 减 20")
    void testFullReduction() {
        BigDecimal result = calculator.applyFullReduction(new BigDecimal("250.00"));
        assertEquals(0, new BigDecimal("230.00").compareTo(result));
        assertEquals(0, testCount);   // 这个测试里的 testCount 仍然是 0（被 @BeforeEach 重置）
    }
}

package com.example.demo.service;

import com.example.demo.common.ErrorCode;
import com.example.demo.exception.BizException;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

import java.math.BigDecimal;

import static org.junit.jupiter.api.Assertions.*;

class OrderAmountCalculatorAssertTest {

    private final OrderAmountCalculator calculator = new OrderAmountCalculator();

    @Test
    @DisplayName("数量为 0 时抛参数异常")
    void testInvalidQuantity() {
        // assertThrows 会执行第二个参数里的代码，并断言它抛出了指定异常
        BizException ex = assertThrows(BizException.class,
                () -> calculator.calculate(new BigDecimal("99.00"), 0));
        // 进一步断言异常里的错误码，确保抛的是「参数错误」而不是别的业务异常
        assertEquals(ErrorCode.PARAM_ERROR.getCode(), ex.getCode());
    }

    @Test
    @DisplayName("单价为负时抛参数异常")
    void testNegativePrice() {
        assertThrows(BizException.class,
                () -> calculator.calculate(new BigDecimal("-1.00"), 1));
    }

    @Test
    @DisplayName("assertAll：一次校验多个字段")
    void testCalculateAll() {
        BigDecimal total = calculator.calculate(new BigDecimal("99.00"), 2);
        // assertAll 会执行所有断言并汇总失败，而不是第一个失败就停止
        assertAll("金额计算校验",
                () -> assertEquals(0, new BigDecimal("198.00").compareTo(total)),
                () -> assertNotNull(total),
                () -> assertTrue(total.compareTo(BigDecimal.ZERO) > 0)
        );
    }
}

package com.example.demo.service;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
import org.junit.jupiter.params.provider.MethodSource;
import org.junit.jupiter.params.provider.ValueSource;

import java.math.BigDecimal;
import java.util.stream.Stream;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;

class OrderAmountCalculatorParamTest {

    private final OrderAmountCalculator calculator = new OrderAmountCalculator();

    // 单参数：同一个单价，测不同数量
    @ParameterizedTest
    @ValueSource(ints = {1, 2, 5, 10})
    @DisplayName("合法数量：单价 * 数量")
    void testCalculateWithQuantity(int quantity) {
        BigDecimal expected = new BigDecimal("99.00").multiply(BigDecimal.valueOf(quantity));
        assertEquals(0, expected.compareTo(calculator.calculate(new BigDecimal("99.00"), quantity)));
    }

    // 多参数：单价、数量、期望金额
    @ParameterizedTest
    @CsvSource({
            "99.00, 2, 198.00",
            "199.00, 1, 199.00",
            "50.00, 4, 200.00"
    })
    @DisplayName("CSV 多组：单价/数量/期望金额")
    void testCalculateCsv(String price, int quantity, String expected) {
        assertEquals(0, new BigDecimal(expected).compareTo(
                calculator.calculate(new BigDecimal(price), quantity)));
    }

    // 复杂数据源：满减的边界值（刚好等于阈值、超过阈值、低于阈值）
    static Stream<org.junit.jupiter.params.provider.Arguments> provideFullReduction() {
        return Stream.of(
                org.junit.jupiter.params.provider.Arguments.of(new BigDecimal("199.99"), new BigDecimal("199.99")),
                org.junit.jupiter.params.provider.Arguments.of(new BigDecimal("200.00"), new BigDecimal("180.00")),
                org.junit.jupiter.params.provider.Arguments.of(new BigDecimal("500.00"), new BigDecimal("480.00"))
        );
    }

    @ParameterizedTest
    @MethodSource("provideFullReduction")
    @DisplayName("满减边界：199.99 不减 / 200 整减 20 / 500 减 20")
    void testFullReductionBoundary(BigDecimal total, BigDecimal expected) {
        assertEquals(0, expected.compareTo(calculator.applyFullReduction(total)));
    }
}

package com.example.demo.service;

import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Timeout;

import java.math.BigDecimal;

import static org.junit.jupiter.api.Assertions.assertEquals;

class OrderAmountCalculatorAdvancedTest {

    private static OrderAmountCalculator sharedCalculator;

    @BeforeAll
    static void initOnce() {
        // 只执行一次：适合昂贵的初始化，注意必须是 static。
        // 第 4 章启动 Testcontainers 容器就是典型的 @BeforeAll 场景
        sharedCalculator = new OrderAmountCalculator();
    }

    @Test
    @Timeout(1)   // 超过 1 秒算失败，防止死循环/慢查询拖垮整个测试套件
    @DisplayName("计算必须在 1 秒内完成")
    void testCalculateFast() {
        BigDecimal total = sharedCalculator.calculate(new BigDecimal("99.00"), 3);
        assertEquals(0, new BigDecimal("297.00").compareTo(total));
    }

    @Test
    @Disabled("满减规则待产品确认，先临时关闭")
    @DisplayName("满减：临时禁用")
    void testDisabled() {
        // 这个测试暂时不会运行，避免它一直红着干扰 CI
    }

    @Nested
    @DisplayName("满减相关测试")
    class FullReductionTests {
        @Test
        @DisplayName("达到阈值减 20")
        void testHitThreshold() {
            assertEquals(0, new BigDecimal("180.00").compareTo(
                    sharedCalculator.applyFullReduction(new BigDecimal("200.00"))));
        }
    }
}

@ExtendWith(MockitoExtension.class)   // ① 启用 Mockito
class OrderServiceImplTest {

    @Mock                              // ② 创建依赖的 Mock 替身
    private OrderMapper orderMapper;

    @Mock
    private StockService stockService;

    @Mock
    private ProductService productService;

    @InjectMocks                        // ③ 把上面的 Mock 自动注入被测试对象
    private OrderServiceImpl orderService;
}

package com.example.demo.service.impl;

import com.example.demo.common.ErrorCode;
import com.example.demo.dto.CreateOrderDTO;
import com.example.demo.entity.Order;
import com.example.demo.exception.BizException;
import com.example.demo.mapper.OrderMapper;
import com.example.demo.service.OrderService;
import com.example.demo.service.ProductService;
import com.example.demo.service.StockService;
import com.example.demo.vo.OrderVO;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.concurrent.atomic.AtomicLong;

/**
 * 订单服务实现。注意：这里只写业务规则，不关心数据库具体实现——这正是可测试的前提。
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class OrderServiceImpl implements OrderService {

    // 订单状态常量：避免魔法数字
    public static final int STATUS_PENDING = 1;   // 待支付
    public static final int STATUS_PAID = 2;      // 已支付
    public static final int STATUS_CANCELED = 3;  // 已取消

    private final OrderMapper orderMapper;
    private final StockService stockService;
    private final ProductService productService;

    // 订单号生成（教学简化版）：真实生产用分布式 ID 方案（如雪花算法），这里只做演示
    private final AtomicLong sequence = new AtomicLong(0);
    private final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMddHHmmss");

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Long createOrder(CreateOrderDTO dto) {
        // 1. 查单价（ProductService 内部会校验商品是否存在，不存在抛异常）
        BigDecimal price = productService.getPrice(dto.getProductId());

        // 2. 扣库存；返回 false 说明库存不足，抛业务异常让事务回滚
        boolean deducted = stockService.deduct(dto.getProductId(), dto.getQuantity());
        if (!deducted) {
            throw new BizException(ErrorCode.STOCK_NOT_ENOUGH);
        }

        // 3. 组装订单
        Order order = new Order();
        order.setOrderNo(generateOrderNo());
        order.setUserId(dto.getUserId());
        order.setProductId(dto.getProductId());
        order.setQuantity(dto.getQuantity());
        order.setTotalAmount(price.multiply(BigDecimal.valueOf(dto.getQuantity())));
        order.setStatus(STATUS_PENDING);
        order.setCreatedAt(LocalDateTime.now());

        // 4. 落库
        orderMapper.insert(order);
        log.info("订单创建成功, orderId={}, orderNo={}", order.getId(), order.getOrderNo());
        return order.getId();
    }

    @Override
    public OrderVO getOrder(Long id) {
        Order order = orderMapper.selectById(id);
        if (order == null) {
            // 查不到就抛「订单不存在」，而不是返回 null 让调用方自己判断
            throw new BizException(ErrorCode.ORDER_NOT_FOUND);
        }
        return toVO(order);
    }

    private String generateOrderNo() {
        String ts = LocalDateTime.now().format(formatter);
        long seq = sequence.incrementAndGet() % 1_000_000;
        return "O" + ts + String.format("%06d", seq);
    }

    private OrderVO toVO(Order order) {
        OrderVO vo = new OrderVO();
        vo.setId(order.getId());
        vo.setOrderNo(order.getOrderNo());
        vo.setUserId(order.getUserId());
        vo.setProductId(order.getProductId());
        vo.setQuantity(order.getQuantity());
        vo.setTotalAmount(order.getTotalAmount());
        vo.setStatus(order.getStatus());
        vo.setCreatedAt(order.getCreatedAt());
        return vo;
    }
}

package com.example.demo.dto;

import jakarta.validation.constraints.Min;
import jakarta.validation.constraints.NotNull;
import lombok.Data;

/** 创建订单入参：带 JSR-303 校验注解，第 3 章 Controller 测试会验证它们 */
@Data
public class CreateOrderDTO {
    @NotNull(message = "用户ID不能为空")
    private Long userId;

    @NotNull(message = "商品ID不能为空")
    private Long productId;

    @NotNull(message = "购买数量不能为空")
    @Min(value = 1, message = "购买数量至少为1")
    private Integer quantity;
}

package com.example.demo.vo;

import lombok.Data;

import java.math.BigDecimal;
import java.time.LocalDateTime;

/** 订单出参：按需裁剪字段，不直接暴露 Entity */
@Data
public class OrderVO {
    private Long id;
    private String orderNo;
    private Long userId;
    private Long productId;
    private Integer quantity;
    private BigDecimal totalAmount;
    private Integer status;
    private LocalDateTime createdAt;
}

// 打桩：当调用 productService.getPrice(100L) 时，返回 99.00
when(productService.getPrice(100L)).thenReturn(new BigDecimal("99.00"));

// 打桩：让方法抛异常（模拟依赖故障）
when(productService.getPrice(999L)).thenThrow(new BizException(ErrorCode.PARAM_ERROR.getCode(), "商品不存在"));

// 验证：断言 insert 被调用了恰好 1 次
verify(orderMapper, times(1)).insert(any(Order.class));

// 验证：断言 insert 从未被调用
verify(orderMapper, never()).insert(any(Order.class));

package com.example.demo.service;

import com.example.demo.common.ErrorCode;
import com.example.demo.dto.CreateOrderDTO;
import com.example.demo.entity.Order;
import com.example.demo.exception.BizException;
import com.example.demo.mapper.OrderMapper;
import com.example.demo.service.impl.OrderServiceImpl;
import com.example.demo.vo.OrderVO;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

import java.math.BigDecimal;

import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.ArgumentMatchers.*;
import static org.mockito.Mockito.*;

@ExtendWith(MockitoExtension.class)
class OrderServiceImplTest {

    @Mock
    private OrderMapper orderMapper;
    @Mock
    private StockService stockService;
    @Mock
    private ProductService productService;

    @InjectMocks
    private OrderServiceImpl orderService;

    private CreateOrderDTO dto;

    @BeforeEach
    void setUp() {
        // 每个测试前准备一份「干净」的入参，避免测试间互相污染
        dto = new CreateOrderDTO();
        dto.setUserId(1L);
        dto.setProductId(100L);
        dto.setQuantity(2);
    }

    // ==================== 正常分支 ====================

    @Test
    @DisplayName("创建订单成功：扣库存成功则落库，金额 = 单价 * 数量")
    void testCreateOrderSuccess() {
        // 打桩：商品单价 99 元
        when(productService.getPrice(100L)).thenReturn(new BigDecimal("99.00"));
        // 打桩：扣库存成功
        when(stockService.deduct(100L, 2)).thenReturn(true);

        Long orderId = orderService.createOrder(dto);

        assertNotNull(orderId);
        // 用 ArgumentCaptor 捕获真正落库的 Order 对象，校验字段值
        ArgumentCaptor<Order> captor = ArgumentCaptor.forClass(Order.class);
        verify(orderMapper, times(1)).insert(captor.capture());
        Order saved = captor.getValue();
        assertEquals(0, new BigDecimal("198.00").compareTo(saved.getTotalAmount()));
        assertEquals(2, saved.getQuantity());
        assertEquals(OrderServiceImpl.STATUS_PENDING, saved.getStatus());
    }

    @Test
    @DisplayName("查询订单成功：返回 VO")
    void testGetOrderSuccess() {
        Order order = new Order();
        order.setId(1L);
        order.setOrderNo("O20240101120000000001");
        order.setUserId(1L);
        order.setProductId(100L);
        order.setQuantity(2);
        order.setTotalAmount(new BigDecimal("198.00"));
        order.setStatus(1);
        when(orderMapper.selectById(1L)).thenReturn(order);

        OrderVO vo = orderService.getOrder(1L);

        assertNotNull(vo);
        assertEquals("O20240101120000000001", vo.getOrderNo());
        assertEquals(0, new BigDecimal("198.00").compareTo(vo.getTotalAmount()));
    }

    // ==================== 异常分支 ====================

    @Test
    @DisplayName("创建订单失败：库存不足抛 STOCK_NOT_ENOUGH 且不落库")
    void testCreateOrderStockNotEnough() {
        when(productService.getPrice(100L)).thenReturn(new BigDecimal("99.00"));
        when(stockService.deduct(100L, 2)).thenReturn(false);   // 模拟库存不足

        BizException ex = assertThrows(BizException.class, () -> orderService.createOrder(dto));
        assertEquals(ErrorCode.STOCK_NOT_ENOUGH.getCode(), ex.getCode());
        // 关键：库存不足时，绝对不允许落库
        verify(orderMapper, never()).insert(any(Order.class));
    }

    @Test
    @DisplayName("创建订单失败：商品不存在时直接抛异常，连库存都不扣")
    void testCreateOrderProductNotFound() {
        when(productService.getPrice(100L))
                .thenThrow(new BizException(ErrorCode.PARAM_ERROR.getCode(), "商品不存在"));

        assertThrows(BizException.class, () -> orderService.createOrder(dto));
        // 商品不存在时，不应该调用扣库存，也不应该落库
        verify(stockService, never()).deduct(anyLong(), anyInt());
        verify(orderMapper, never()).insert(any(Order.class));
    }

    @Test
    @DisplayName("查询订单失败：订单不存在抛 ORDER_NOT_FOUND")
    void testGetOrderNotFound() {
        when(orderMapper.selectById(999L)).thenReturn(null);

        BizException ex = assertThrows(BizException.class, () -> orderService.getOrder(999L));
        assertEquals(ErrorCode.ORDER_NOT_FOUND.getCode(), ex.getCode());
    }
}

@Spy
@InjectMocks
private OrderServiceImpl orderService;

@Test
void testSpyPartial() {
    // 只把 generateOrderNo 打桩成固定值，其他方法走真实逻辑
    doReturn("O_TEST_000001").when(orderService).generateOrderNo();
    // ...
}

// 假设 StockService 多了一个 void 方法 notifyLowStock()：
doThrow(new BizException(ErrorCode.SYSTEM_ERROR))
        .when(stockService).notifyLowStock(anyLong());

// 验证 void 方法被调用
verify(stockService, times(1)).notifyLowStock(100L);

@Test
void testCreateOrderSuccess() {
    // Arrange：准备数据和打桩
    when(productService.getPrice(100L)).thenReturn(new BigDecimal("99.00"));
    when(stockService.deduct(100L, 2)).thenReturn(true);

    // Act：执行被测方法
    Long orderId = orderService.createOrder(dto);

    // Assert：断言结果和副作用
    assertNotNull(orderId);
    verify(orderMapper, times(1)).insert(any(Order.class));
}

package com.example.demo;

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class DemoApplicationTest {

    @Test
    void contextLoads() {
        // 什么都不做：只要能成功启动容器，就说明 Bean 装配、配置、依赖注入都没问题
        // 这是每个项目都该有的「冒烟测试」，能第一时间暴露循环依赖、缺失 Bean 等问题
    }
}

package com.example.demo.service;

import com.example.demo.dto.CreateOrderDTO;
import com.example.demo.entity.Order;
import com.example.demo.entity.Product;
import com.example.demo.entity.Stock;
import com.example.demo.mapper.OrderMapper;
import com.example.demo.mapper.ProductMapper;
import com.example.demo.mapper.StockMapper;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.mock.mockito.MockBean;

import java.math.BigDecimal;

import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.*;

/**
 * 集成测试：@SpringBootTest 启动完整容器，验证真实 Bean 装配和调用链。
 * 只 @MockBean 掉数据访问层（避免连真实数据库），
 * OrderService -> StockService -> ProductService 的依赖注入全部真实走 Spring。
 */
@SpringBootTest
class OrderServiceIntegrationTest {

    @MockBean
    private OrderMapper orderMapper;
    @MockBean
    private StockMapper stockMapper;
    @MockBean
    private ProductMapper productMapper;

    @Autowired
    private OrderService orderService;   // 真实 Bean，内部的 StockService/ProductService 也是真实 Bean

    @Test
    @DisplayName("真实装配：走通创建订单调用链（数据层 Mock）")
    void testCreateOrderRealWiring() {
        // 打桩数据层：商品存在、库存充足
        Product product = new Product();
        product.setId(100L);
        product.setProductName("测试商品");
        product.setPrice(new BigDecimal("99.00"));
        when(productMapper.selectById(100L)).thenReturn(product);

        Stock stock = new Stock();
        stock.setId(1L);
        stock.setProductId(100L);
        stock.setStock(10);
        when(stockMapper.deductStock(100L, 2)).thenReturn(1);

        CreateOrderDTO dto = new CreateOrderDTO();
        dto.setUserId(1L);
        dto.setProductId(100L);
        dto.setQuantity(2);

        Long orderId = orderService.createOrder(dto);

        assertNotNull(orderId);
        verify(orderMapper, times(1)).insert(any(Order.class));
    }
}

package com.example.demo.controller;

import com.example.demo.common.ApiResult;
import com.example.demo.dto.CreateOrderDTO;
import com.example.demo.service.OrderService;
import com.example.demo.vo.OrderVO;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/orders")
@RequiredArgsConstructor
public class OrderController {

    private final OrderService orderService;

    @PostMapping
    public ApiResult<Long> createOrder(@Valid @RequestBody CreateOrderDTO dto) {
        return ApiResult.ok(orderService.createOrder(dto));
    }

    @GetMapping("/{id}")
    public ApiResult<OrderVO> getOrder(@PathVariable Long id) {
        return ApiResult.ok(orderService.getOrder(id));
    }
}

package com.example.demo.controller;

import com.example.demo.common.ErrorCode;
import com.example.demo.dto.CreateOrderDTO;
import com.example.demo.exception.BizException;
import com.example.demo.service.OrderService;
import com.example.demo.vo.OrderVO;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;

import java.math.BigDecimal;

import static org.hamcrest.Matchers.containsString;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.when;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

/**
 * 切片测试：只加载 MVC 层，用 @MockBean 替换掉 OrderService。
 * 注意这里不需要启动 DataSource，跑得飞快。
 */
@WebMvcTest(OrderController.class)
class OrderControllerTest {

    @Autowired
    private MockMvc mockMvc;          // 模拟 HTTP 请求

    @Autowired
    private ObjectMapper objectMapper; // 序列化 JSON

    @MockBean
    private OrderService orderService; // 替换掉真实的 Service

    // ==================== 正常分支 ====================

    @Test
    @DisplayName("创建订单成功：返回 code=0 和订单 ID")
    void testCreateOrderSuccess() throws Exception {
        CreateOrderDTO dto = new CreateOrderDTO();
        dto.setUserId(1L);
        dto.setProductId(100L);
        dto.setQuantity(2);

        when(orderService.createOrder(any(CreateOrderDTO.class))).thenReturn(1L);

        mockMvc.perform(post("/api/orders")
                        .contentType(MediaType.APPLICATION_JSON)
                        .content(objectMapper.writeValueAsString(dto)))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.code").value(0))
                .andExpect(jsonPath("$.data").value(1));
    }

    @Test
    @DisplayName("查询订单成功：返回订单数据")
    void testGetOrderSuccess() throws Exception {
        OrderVO vo = new OrderVO();
        vo.setId(1L);
        vo.setOrderNo("O20240101120000000001");
        vo.setTotalAmount(new BigDecimal("198.00"));
        when(orderService.getOrder(1L)).thenReturn(vo);

        mockMvc.perform(get("/api/orders/1"))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.code").value(0))
                .andExpect(jsonPath("$.data.orderNo").value("O20240101120000000001"));
    }

    // ==================== 异常分支 ====================

    @Test
    @DisplayName("创建订单：数量为 0 触发 @Valid 校验，返回 PARAM_ERROR")
    void testCreateOrderValidationFail() throws Exception {
        // quantity=0 违反了 @Min(value=1)，应被 GlobalExceptionHandler 转成参数错误码
        mockMvc.perform(post("/api/orders")
                        .contentType(MediaType.APPLICATION_JSON)
                        .content("{"userId":1,"productId":100,"quantity":0}"))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.code").value(ErrorCode.PARAM_ERROR.getCode()))
                .andExpect(jsonPath("$.message").value(containsString("购买数量")));
    }

    @Test
    @DisplayName("查询订单：订单不存在返回 ORDER_NOT_FOUND")
    void testGetOrderNotFound() throws Exception {
        when(orderService.getOrder(999L))
                .thenThrow(new BizException(ErrorCode.ORDER_NOT_FOUND));

        mockMvc.perform(get("/api/orders/999"))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.code").value(ErrorCode.ORDER_NOT_FOUND.getCode()));
    }
}

// 1. 带查询参数和请求头的 GET 请求
mockMvc.perform(get("/api/orders")
                .param("page", "1")
                .param("size", "10")
                .header("X-User-Id", "1"))
        .andExpect(status().isOk());

// 2. print()：把完整请求/响应打印到控制台，排错神器
mockMvc.perform(get("/api/orders/1"))
        .andDo(print());

// 3. 断言响应头 + 空 body 触发参数校验
mockMvc.perform(post("/api/orders")
                .contentType(MediaType.APPLICATION_JSON)
                .content("{}"))
        .andExpect(status().isOk())
        .andExpect(header().string("Content-Type", containsString("application/json")))
        .andExpect(jsonPath("$.code").value(ErrorCode.PARAM_ERROR.getCode()));

// 4. 访问不存在的路径，断言 404
mockMvc.perform(get("/api/not-exist"))
        .andExpect(status().isNotFound());

package com.example.demo.mapper;

import com.example.demo.entity.Order;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.mybatis.spring.boot.test.autoconfigure.MybatisTest;
import org.springframework.beans.factory.annotation.Autowired;

import java.math.BigDecimal;

import static org.junit.jupiter.api.Assertions.assertNotNull;

/**
 * 切片测试：只加载 MyBatis 层（Mapper + SqlSessionFactory），不加载 Controller/Service。
 * 完整可跑版本见第 4 章（那里会配上真实 MySQL 容器）。
 */
@MybatisTest
class OrderMapperSliceTest {

    @Autowired
    private OrderMapper orderMapper;

    @Test
    @DisplayName("插入订单后能查到")
    void testInsertAndSelect() {
        Order order = new Order();
        order.setOrderNo("O20240101120000000001");
        order.setUserId(1L);
        order.setProductId(100L);
        order.setQuantity(2);
        order.setTotalAmount(new BigDecimal("198.00"));
        order.setStatus(1);
        orderMapper.insert(order);

        assertNotNull(order.getId());
    }
}

// JPA 实体（仅作 @DataJpaTest 演示，与本系列 MyBatis-Plus 实体并存时注意区分）
package com.example.demo.entity;

import jakarta.persistence.*;
import lombok.Data;

import java.math.BigDecimal;

@Data
@Entity
@Table(name = "t_product")
public class ProductJpa {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "product_name", nullable = false)
    private String productName;

    @Column(nullable = false)
    private BigDecimal price;
}