<!-- SpringBoot 測試全家桶（包含 JUnit5、Mockito、AssertJ） -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
    <!-- 排除 JUnit4，強(qiáng)制 JUnit5 -->
    <exclusions>
        <exclusion>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<!-- 容器化中間件測試（TestContainers，生產(chǎn)集成測試核心） -->
<dependency>
    <groupId>org.testcontainers</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>1.19.3</version>
    <scope>test</scope>
</dependency>
<!-- MySQL 容器 -->
<dependency>
    <groupId>org.testcontainers</groupId>
    <artifactId>mysql</artifactId>
    <version>1.19.3</version>
    <scope>test</scope>
</dependency>
<!-- Redis 容器 -->
<dependency>
    <groupId>org.testcontainers</groupId>
    <artifactId>redis</artifactId>
    <version>1.19.3</version>
    <scope>test</scope>
</dependency>

src/
├── main/          # 業(yè)務(wù)代碼
└── test/
    ├── unit/      # 單元測試（單類）
    ├── integrate/ # 【集成測試專屬包】按業(yè)務(wù)模塊拆分
    │   ├── user/  # 用戶模塊集成測試
    │   ├── order/ # 訂單模塊集成測試
    │   └── mq/    # 消息隊(duì)列集成測試
    └── smoke/     # 生產(chǎn)冒煙測試（極簡用例，上線必跑）

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.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.annotation.Rollback;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.test.web.servlet.MockMvc;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
// 加載完整 Spring 上下文 = 真實(shí)運(yùn)行環(huán)境
@SpringBootTest
@AutoConfigureMockMvc
@DisplayName("訂單模塊 - 全鏈路集成測試")
public class OrderIntegrateTest {
    @Autowired
    private MockMvc mockMvc; // 模擬 HTTP 請求
    /**
     * 新增訂單 全鏈路集成測試
     * @Transactional + @Rollback(true)：執(zhí)行后自動(dòng)回滾DB，生產(chǎn)環(huán)境杜絕臟數(shù)據(jù)
     */
    @Test
    @Transactional
    @Rollback
    @DisplayName("正常創(chuàng)建訂單-全鏈路校驗(yàn)")
    void createOrderFullLink() throws Exception {
        String requestBody = "{\"userId\":10001,\"goodsId\":2001,\"num\":2}";
        // 1. 發(fā)起接口請求，模擬前端/網(wǎng)關(guān)調(diào)用
        mockMvc.perform(post("/api/order/create")
                        .contentType("application/json")
                        .content(requestBody))
                // 2. 斷言 HTTP 狀態(tài)碼
                .andExpect(status().isOk())
                // 3. 斷言返回碼、業(yè)務(wù)結(jié)果
                .andExpect(jsonPath("$.code").value(200))
                .andExpect(jsonPath("$.data.orderNo").exists())
                .andExpect(jsonPath("$.data.status").value(0));
        // 4. 底層會(huì)自動(dòng)調(diào)用 Service -> Mapper -> MySQL，事務(wù)結(jié)束自動(dòng)回滾
    }
}

@SpringBootTest
@DisplayName("跨服務(wù)調(diào)用集成測試")
public class FeignIntegrateTest {
    // 注入 Feign 遠(yuǎn)程調(diào)用客戶端（和業(yè)務(wù)代碼一致）
    @Autowired
    private UserFeignClient userFeignClient;
    @Test
    @DisplayName("調(diào)用用戶服務(wù)-查詢用戶信息")
    void callUserService() {
        // 1. 執(zhí)行遠(yuǎn)程調(diào)用（走注冊中心、負(fù)載均衡、Feign 攔截器）
        UserDTO user = userFeignClient.getUserInfo(10001L);
        // 2. 斷言結(jié)果，驗(yàn)證跨服務(wù)鏈路通暢
        org.assertj.core.api.Assertions.assertThat(user).isNotNull();
        org.assertj.core.api.Assertions.assertThat(user.getUserId()).isEqualTo(10001L);
        org.assertj.core.api.Assertions.assertThat(user.getUsername()).isNotBlank();
    }
}

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.data.redis.core.RedisTemplate;
import org.springframework.test.context.TestPropertySource;
import org.testcontainers.containers.MySQLContainer;
import org.testcontainers.containers.RedisContainer;
import org.testcontainers.junit.jupiter.Container;
import org.testcontainers.junit.jupiter.Testcontainers;
// 開啟容器測試
@Testcontainers
@SpringBootTest
@TestPropertySource(locations = "classpath:application-test-container.yml")
@DisplayName("MySQL+Redis 中間件集成測試")
public class MiddlewareIntegrateTest {
    // 固定 MySQL 容器（全局復(fù)用）
    @Container
    static MySQLContainer<?> mysql = new MySQLContainer<>("mysql:8.0")
            .withDatabaseName("test_db")
            .withUsername("root")
            .withPassword("123456");
    // 固定 Redis 容器
    @Container
    static RedisContainer<?> redis = new RedisContainer<>("redis:7.0");
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    @Test
    @DisplayName("Redis 讀寫集成校驗(yàn)")
    void testRedisOperate() {
        String key = "test:integrate:key";
        String value = "prod-test-data";
        // 寫入 Redis
        redisTemplate.opsForValue().set(key, value);
        // 讀取并斷言
        String result = redisTemplate.opsForValue().get(key);
        org.assertj.core.api.Assertions.assertThat(result).isEqualTo(value);
    }
}

spring:
  datasource:
    url: jdbc:mysql://${MYSQL_HOST}:${MYSQL_PORT}/test_db?useUnicode=true&characterEncoding=utf8
    username: root
    password: 123456
  redis:
    host: ${REDIS_HOST}
    port: ${REDIS_PORT}

@SpringBootTest
@DisplayName("RocketMQ 消息集成測試")
public class MqIntegrateTest {
    @Autowired
    private RocketMQTemplate rocketMQTemplate;
    // 測試 Topic
    private static final String TEST_TOPIC = "test_order_topic";
    @Test
    @DisplayName("消息發(fā)送+消費(fèi)全鏈路測試")
    void testMqSendAndConsume() throws InterruptedException {
        String msgBody = "order_10086";
        // 1. 發(fā)送消息（模擬業(yè)務(wù)投遞）
        rocketMQTemplate.syncSend(TEST_TOPIC, msgBody);
        // 2. 等待消費(fèi)（生產(chǎn)根據(jù)消費(fèi)耗時(shí)調(diào)整）
        Thread.sleep(1000);
        // 3. 業(yè)務(wù)側(cè)：查詢數(shù)據(jù)庫/緩存，驗(yàn)證消息是否被正常消費(fèi)、數(shù)據(jù)是否更新
        boolean consumeSuccess = checkOrderStatus("10086");
        org.assertj.core.api.Assertions.assertThat(consumeSuccess).isTrue();
    }
    // 模擬校驗(yàn)消費(fèi)結(jié)果（實(shí)際查DB/Redis）
    private boolean checkOrderStatus(String orderNo) {
        // 業(yè)務(wù)校驗(yàn)邏輯
        return true;
    }
}

@SpringBootTest
@DisplayName("Seata 分布式事務(wù)集成測試")
public class SeataTransactionTest {
    @Autowired
    private OrderService orderService;
    @Test
    @DisplayName("分布式事務(wù)異常-全局回滾校驗(yàn)")
    void testDistributedRollback() {
        try {
            // 該方法內(nèi)部：創(chuàng)建訂單 + 扣庫存 + 模擬異常
            orderService.createOrderWithError(10001L, 2001L);
        } catch (Exception e) {
            // 捕獲異常，繼續(xù)校驗(yàn)數(shù)據(jù)
        }
        // 斷言：訂單、庫存數(shù)據(jù)全部回滾，無臟數(shù)據(jù)
        boolean orderExist = orderMapper.existsOrder(10001L);
        int stock = stockMapper.getStock(2001L);
        org.assertj.core.api.Assertions.assertThat(orderExist).isFalse();
        org.assertj.core.api.Assertions.assertThat(stock).isEqualTo(原始庫存);
    }
}

@SpringBootTest
@DisplayName("Sentinel 熔斷降級集成測試")
public class SentinelDegradeTest {
    @Autowired
    private OrderApi orderApi;
    @Test
    @DisplayName("服務(wù)熔斷-降級邏輯校驗(yàn)")
    void testDegrade() {
        // 多次調(diào)用觸發(fā)熔斷（模擬生產(chǎn)服務(wù)不可用）
        for (int i = 0; i < 20; i++) {
            String result = orderApi.getOrderInfo(9999L);
            // 斷言：返回降級兜底數(shù)據(jù)
            org.assertj.core.api.Assertions.assertThat(result).contains("服務(wù)繁忙，請稍后重試");
        }
    }
}