<!-- Spring Boot 测试 --><dependency>
    <groupId>org.springframework.boot</groupId>    <artifactId>spring-boot-starter-test</artifactId>    <scope>test</scope></dependency>

<!-- H2 内存数据库 --><dependency>
    <groupId>com.h2database</groupId>    <artifactId>h2</artifactId>    <scope>test</scope></dependency>

<!-- Mockito Inline (支持静态Mock) -->
<dependency>
    <groupId>org.mockito</groupId>    <artifactId>mockito-inline</artifactId>    <scope>test</scope></dependency>

<!-- Embedded Redis -->
<dependency>
    <groupId>it.ozimov</groupId>    <artifactId>embedded-redis</artifactId>    <version>0.7.3</version>    <scope>test</scope></dependency>

@SpringBootTest(classes = TestApplication.class)
@ActiveProfiles("testcase")
public abstract class BaseIntegrationTest {
    // 所有集成测试继承此类
}

public class YourServiceTest extends BaseCommonServiceTest {
    @Autowired    private YourService yourService;        @Test
    @DisplayName("测试核心业务流程")
    void testBusinessFlow() {        // 1. 准备数据
        YourEntity entity = createTestEntity();        // 2. 执行操作
        YourDTO result = yourService.process(entity);        // 3. 验证结果
        assertNotNull(result);        assertEquals(expectedValue, result.getValue());    }}

package com.yourcompany.yourapp.test;

import com.yourcompany.yourapp.test.config.TestContextConfig;
import org.apache.dubbo.spring.boot.autoconfigure.DubboAutoConfiguration;
import org.apache.dubbo.spring.boot.autoconfigure.DubboRelaxedBinding2AutoConfiguration;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;

/**
 * 测试专用启动类
 * 用于集成测试时启动应用
 */@SpringBootApplication(
    scanBasePackageClasses = {        TestContextConfig.class,    },    exclude = {        DataSourceAutoConfiguration.class,      // 排除自动数据源配置
        DubboAutoConfiguration.class,           // 排除Dubbo自动配置
        DubboRelaxedBinding2AutoConfiguration.class    })
public class TestApplication {
}

package com.yourcompany.yourapp.test.base;

import static org.mockito.ArgumentMatchers.any;

import com.aliyun.openservices.ons.api.ONSFactory;
import com.aliyun.openservices.ons.api.Producer;
import com.aliyun.openservices.ons.api.SendResult;
import com.yourcompany.yourapp.test.TestApplication;
import com.yourcompany.yourapp.thirdparty.oss.OSSClient;
import com.yourcompany.yourapp.thirdparty.oss.OssClientFactory;
import com.yourcompany.yourapp.thirdparty.oss.model.PutObjectResult;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.mockito.MockedStatic;
import org.mockito.Mockito;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.event.ContextClosedEvent;
import org.springframework.context.event.EventListener;
import org.springframework.test.context.ActiveProfiles;
import redis.embedded.RedisServer;
import redis.embedded.RedisServerBuilder;

@Slf4j
@ActiveProfiles("testcase")
@SpringBootTest(classes = TestApplication.class)
public abstract class BaseIntegrationTest {

    protected static RedisServer redisServer;    private static MockedStatic<ONSFactory> mockedOnsFactory;    private static MockedStatic<OssClientFactory> mockedOssClientFactory;
    @BeforeAll    public static void initBeforeClass() {        log.info("集成测试环境初始化开始...");
                // Mock RocketMQ Producer
        mockRocketMQ();                // Mock OSS Client
        mockOssClient();        // 启动内嵌Redis
        initRedis();        // 初始化Apollo配置
        initApolloConfig();                log.info("集成测试环境初始化完成");
    }        /**
     * Mock RocketMQ Producer     */    private static void mockRocketMQ() {        Producer mockProducer = Mockito.mock(Producer.class);        Mockito.doNothing().when(mockProducer).start();        Mockito.doNothing().when(mockProducer).shutdown();        Mockito.doReturn(new SendResult()).when(mockProducer).send(any());                mockedOnsFactory = Mockito.mockStatic(ONSFactory.class);
        mockedOnsFactory.when(() -> ONSFactory.createProducer(any())).thenReturn(mockProducer);    }        /**
     * Mock OSS Client     */    private static void mockOssClient() {        OSSClient mockOssClient = Mockito.mock(OSSClient.class);        PutObjectResult result = new PutObjectResult();        result.setStatusCode(200);        Mockito.when(mockOssClient.putObject(any())).thenReturn(result);                mockedOssClientFactory = Mockito.mockStatic(OssClientFactory.class);
        mockedOssClientFactory.when(() -> OssClientFactory.getOSSClient()).thenReturn(mockOssClient);    }        /**
     * 启动内嵌Redis服务
     */    protected static void initRedis() {        redisServer = new RedisServerBuilder()            .bind("localhost")            .port(6380)            .setting("requirepass <password>")            .build();        redisServer.start();        log.info("内嵌Redis启动成功，端口: 6380");
    }        /**
     * 初始化Apollo配置（本地模式）
     */    protected static void initApolloConfig() {        System.setProperty("app.id", "your-app-name");        System.setProperty("apollo.cacheDir", "src/test/resources");        System.setProperty("apollo.meta", "http://none");        System.setProperty("env", "local");        System.setProperty("apollo.bootstrap.enabled", "true");        log.info("Apollo配置初始化完成");
    }
    @AfterAll    public static void afterAll() {        // 关闭静态Mock
        if (mockedOnsFactory != null) {            mockedOnsFactory.close();        }        if (mockedOssClientFactory != null) {            mockedOssClientFactory.close();        }    }
    /**     * 监听Spring上下文关闭事件，停止Redis
     */    @EventListener    public void listener(ContextClosedEvent closedEvent) {        if (redisServer != null && redisServer.isActive()) {            redisServer.stop();            log.info("内嵌Redis已停止");
        }    }}

package com.yourcompany.yourapp.test.base;

import com.yourcompany.yourapp.test.config.TestDataSourceConfig;
import java.util.Map;
import javax.sql.DataSource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.io.ClassPathResource;
import org.springframework.jdbc.datasource.init.ResourceDatabasePopulator;

/**
 * 服务测试基类
 * 自动初始化多个数据源的Schema和测试数据
 */@Slf4j
public abstract class BaseCommonServiceTest extends BaseIntegrationTest implements InitializingBean {

    @Autowired(required = false)    private Map<String, DataSource> dataSourceMap;
    @Override    public void afterPropertiesSet() throws Exception {        doInitDatasource();    }
    /**     * 初始化所有数据源的Schema和测试数据
     * 使用单例标志位，确保只初始化一次
     */    void doInitDatasource() {        if (TestDataSourceConfig.isDatasourceInitialized()) {            return;        }                log.info("开始初始化测试数据库...");
        // 初始化各个数据源
        initDatabase("dataSourceMaster", "schema/master-schema.sql", "data/master-data.sql");        initDatabase("dataSourceSlaveOne", "schema/slaveone-schema.sql", "");        initDatabase("dataSourceSlaveTwo", "schema/master-schema.sql", "data/master-data.sql");        initDatabase("dataSourceSlaveThree", "schema/slavethree-schema.sql", "");        initDatabase("dataSourceDrdsMaster", "schema/drdsmaster-schema.sql", "data/drdsmaster-data.sql");        initDatabase("dataSourceCsCrm", "schema/cscrm-schema.sql", "");        initDatabase("dataSourceWareHouse", "schema/datawarehouse-schema.sql", "data/datawarehouse-data.sql");                TestDataSourceConfig.setDatasourceInitialized();
        log.info("测试数据库初始化完成");
    }
    /**     * 初始化指定数据源的表结构和数据
     * @param dataSourceKey 数据源标识
     * @param schemaLocation schema SQL文件路径
     * @param dataLocation 数据SQL文件路径（可为空）
     */    protected void initDatabase(String dataSourceKey, String schemaLocation, String dataLocation) {        if (dataSourceMap == null) {            log.warn("dataSourceMap为空，无法初始化数据库");
            return;        }
        DataSource dataSource = dataSourceMap.get(dataSourceKey);        if (dataSource == null) {            throw new IllegalArgumentException("未找到数据源: " + dataSourceKey);
        }
        ResourceDatabasePopulator populator = new ResourceDatabasePopulator();
        if (schemaLocation != null && !schemaLocation.isEmpty()) {            populator.addScript(new ClassPathResource(schemaLocation));        }
        if (dataLocation != null && !dataLocation.isEmpty()) {            populator.addScript(new ClassPathResource(dataLocation));        }
        try {            log.info("初始化数据源 [{}]", dataSourceKey);            populator.execute(dataSource);        } catch (Exception e) {            throw new RuntimeException("初始化数据库失败: " + dataSourceKey, e);
        }    }}

# 测试环境配置
spring.application.name=your-app-name
server.port=0

# H2数据库配置 - 主数据源
spring.datasource.druid.url=jdbc:h2:mem:master;MODE=MySQL;DB_CLOSE_DELAY=-1;DATABASE_TO_LOWER=TRUE
spring.datasource.druid.username=sa
spring.datasource.druid.password=
spring.datasource.druid.driver-class-name=org.h2.Driver
spring.datasource.druid.initial-size=1
spring.datasource.druid.min-idle=1
spring.datasource.druid.max-active=5

# H2数据库配置 - 从数据源1
spring.datasource.druid.slave-one.url=jdbc:h2:mem:slave1;MODE=MySQL;DB_CLOSE_DELAY=-1;DATABASE_TO_LOWER=TRUE
spring.datasource.druid.slave-one.username=sa
spring.datasource.druid.slave-one.password=
spring.datasource.druid.slave-one.driver-class-name=org.h2.Driver

# H2数据库配置 - 从数据源2（master的只读副本）
spring.datasource.druid.slave-two.url=jdbc:h2:mem:slave2;MODE=MySQL;DB_CLOSE_DELAY=-1;DATABASE_TO_LOWER=TRUE
spring.datasource.druid.slave-two.username=sa
spring.datasource.druid.slave-two.password=

# H2数据库配置 - 从数据源3
spring.datasource.druid.slave-three.url=jdbc:h2:mem:slave3;MODE=MySQL;DB_CLOSE_DELAY=-1;DATABASE_TO_LOWER=TRUE
spring.datasource.druid.slave-three.username=sa
spring.datasource.druid.slave-three.password=

# H2数据库配置 - DRDS主数据源
spring.datasource.druid.drds-master.url=jdbc:h2:mem:drds;MODE=MySQL;DB_CLOSE_DELAY=-1;DATABASE_TO_LOWER=TRUE
spring.datasource.druid.drds-master.username=sa
spring.datasource.druid.drds-master.password=

# H2数据库配置 - CS-CRM数据源
spring.datasource.druid.cs-crm.url=jdbc:h2:mem:cs_crm;MODE=MySQL;DB_CLOSE_DELAY=-1;DATABASE_TO_LOWER=TRUE
spring.datasource.druid.cs-crm.username=sa
spring.datasource.druid.cs-crm.password=

# H2数据库配置 - 数据仓库
spring.datasource.druid.warehouse.url=jdbc:h2:mem:warehouse;MODE=MySQL;DB_CLOSE_DELAY=-1;DATABASE_TO_LOWER=TRUE
spring.datasource.druid.warehouse.username=sa
spring.datasource.druid.warehouse.password=

# Redis配置（连接内嵌Redis）
redis.hostname=localhost
redis.port=6380
redis.password=<your-password>
redis.dbIndex=0

# 禁用Dubbo注册中心
dubbo.registry.address=N/A
dubbo.consumer.check=false
dubbo.registry.check=false

# 日志配置
logging.level.root=INFO
logging.level.com.yourcompany.yourapp=DEBUG
mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

// 独立的测试启动类
@SpringBootApplication(
    scanBasePackageClasses = {TestConfig.class},    exclude = {DataSourceAutoConfiguration.class})
public class TestApplication {}

// 事务自动回滚
@Transactional
@Rollback
@Test
void testCreate() {
    service.create(entity);    // 测试结束自动回滚
}

// 每个测试独立配置Mock
@BeforeEach
void setUp() {
    ExternalService mock = getMock(ExternalService.class);    when(mock.call()).thenReturn(testData);}

@SpringBootTest(classes = TestApplication.class)
@ActiveProfiles("test")
public abstract class BaseIntegrationTest {
    protected static EmbeddedRedis redisServer;
    protected static MockedStatic<StaticFactory> mockedFactory;
    @BeforeAll
    public static void initSharedResources() {
        // 启动内嵌服务
        startEmbeddedServices();
        // Mock静态类
        mockStaticDependencies();
    }    @AfterAll
    public static void cleanupSharedResources() {
        // 关闭Mock
        if (mockedFactory != null) {            mockedFactory.close();
        }    }    @EventListener(ContextClosedEvent.class)
    public void onContextClosed() {
        // 停止内嵌服务
        if (redisServer != null) {            redisServer.stop();
        }    }    private static void startEmbeddedServices() {
        // 实现内嵌服务启动逻辑
    }    private static void mockStaticDependencies() {
        // 实现静态Mock逻辑
    }}

@Configuration
@ComponentScan(
    basePackages = "com.yourcompany.yourapp",    excludeFilters = @ComponentScan.Filter(
        type = FilterType.REGEX,        pattern = ".*ProductionConfig"
    ))
@MapperScan("com.yourcompany.yourapp.mapper")
public class TestConfig {
        // Redis配置
    @Bean
    public RedisConnectionFactory redisConnectionFactory() {
        return new LettuceConnectionFactory("localhost", 6380);    }        // RestTemplate配置
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();    }        // MyBatis拦截器（兼容H2）
    @Bean
    public SqlCompatibilityInterceptor sqlInterceptor() {
        return new SqlCompatibilityInterceptor();    }}

package com.yourcompany.yourapp.test.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;

@Configuration
public class TestDataSourceConfig {

    private static volatile boolean datasourceInitialized = false;
    public static boolean isDatasourceInitialized() {        return datasourceInitialized;    }
    public static void setDatasourceInitialized() {        datasourceInitialized = true;    }
    /**     * 主数据源
     */    @Bean(name = "dataSourceMaster")    @Primary    @ConfigurationProperties(prefix = "spring.datasource.druid")    public DataSource dataSourceMaster() {        return new DruidDataSource();    }
    /**     * 从数据源1
     */    @Bean(name = "dataSourceSlaveOne")    @ConfigurationProperties(prefix = "spring.datasource.druid.slave-one")    public DataSource dataSourceSlaveOne() {        return new DruidDataSource();    }
    /**     * 从数据源2（master的只读副本）
     */    @Bean(name = "dataSourceSlaveTwo")    @ConfigurationProperties(prefix = "spring.datasource.druid.slave-two")    public DataSource dataSourceSlaveTwo() {        return new DruidDataSource();    }
    /**     * 从数据源3
     */    @Bean(name = "dataSourceSlaveThree")    @ConfigurationProperties(prefix = "spring.datasource.druid.slave-three")    public DataSource dataSourceSlaveThree() {        return new DruidDataSource();    }
    /**     * DRDS主数据源
     */    @Bean(name = "dataSourceDrdsMaster")    @ConfigurationProperties(prefix = "spring.datasource.druid.drds-master")    public DataSource dataSourceDrdsMaster() {        return new DruidDataSource();    }
    /**     * CS-CRM数据源
     */    @Bean(name = "dataSourceCsCrm")    @ConfigurationProperties(prefix = "spring.datasource.druid.cs-crm")    public DataSource dataSourceCsCrm() {        return new DruidDataSource();    }
    /**     * 数据仓库数据源
     */    @Bean(name = "dataSourceWareHouse")    @ConfigurationProperties(prefix = "spring.datasource.druid.warehouse")    public DataSource dataSourceWareHouse() {        return new DruidDataSource();    }
    /**     * 注入所有数据源到Map，方便BaseCommonServiceTest批量初始化
     */    @Bean    public Map<String, DataSource> dataSourceMap(            DataSource dataSourceMaster,            DataSource dataSourceSlaveOne,            DataSource dataSourceSlaveTwo,            DataSource dataSourceSlaveThree,            DataSource dataSourceDrdsMaster,            DataSource dataSourceCsCrm,            DataSource dataSourceWareHouse    ) {        Map<String, DataSource> map = new HashMap<>();        map.put("dataSourceMaster", dataSourceMaster);        map.put("dataSourceSlaveOne", dataSourceSlaveOne);        map.put("dataSourceSlaveTwo", dataSourceSlaveTwo);        map.put("dataSourceSlaveThree", dataSourceSlaveThree);        map.put("dataSourceDrdsMaster", dataSourceDrdsMaster);        map.put("dataSourceCsCrm", dataSourceCsCrm);        map.put("dataSourceWareHouse", dataSourceWareHouse);        return map;    }}

# 主数据源
spring.datasource.druid.url=jdbc:h2:mem:master;MODE=MySQL;DB_CLOSE_DELAY=-1;DATABASE_TO_LOWER=TRUE
spring.datasource.druid.username=sa
spring.datasource.druid.password=
spring.datasource.druid.driver-class-name=org.h2.Driver
spring.datasource.druid.initial-size=1
spring.datasource.druid.min-idle=1
spring.datasource.druid.max-active=5

# 从数据源1
spring.datasource.druid.slave-one.url=jdbc:h2:mem:slave1;MODE=MySQL;DB_CLOSE_DELAY=-1;DATABASE_TO_LOWER=TRUE
spring.datasource.druid.slave-one.username=sa
spring.datasource.druid.slave-one.password=
spring.datasource.druid.slave-one.driver-class-name=org.h2.Driver
spring.datasource.druid.slave-one.initial-size=1
spring.datasource.druid.slave-one.min-idle=1
spring.datasource.druid.slave-one.max-active=5

# ... 其他数据源配置类似

package com.yourcompany.yourapp.test.config;

import org.apache.dubbo.config.annotation.Reference;
import org.mockito.Mockito;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;

import java.lang.reflect.Field;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * Dubbo服务自动Mock配置
 * 扫描所有@Reference注解的字段，自动注入Mock对象
 */@Component
public class TestMockConfig implements BeanPostProcessor {

    /**     * Mock对象注册表
     * Key: 接口Class, Value: Mock对象实例
     */    private static final Map<Class<?>, Object> mockRegistry = new ConcurrentHashMap<>();
    @Override    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {        Field[] fields = bean.getClass().getDeclaredFields();                for (Field field : fields) {
            // 扫描@Reference注解（Dubbo服务）
            if (field.isAnnotationPresent(Reference.class)) {                mockAndInjectDubboService(bean, field);            }        }                return bean;
    }
    /**     * Mock Dubbo服务并注入
     */    private void mockAndInjectDubboService(Object bean, Field field) {        try {            Class<?> serviceInterface = field.getType();            // 从注册表获取或创建Mock对象
            Object mockObject = mockRegistry.computeIfAbsent(                serviceInterface,                clazz -> Mockito.mock(clazz)
            );            // 注入Mock对象到字段
            field.setAccessible(true);            field.set(bean, mockObject);                    } catch (Exception e) {
            throw new RuntimeException("Mock Dubbo服务失败: " + field.getName(), e);
        }    }
    /**     * 获取Mock对象，用于测试中配置Mock行为
     ** @param clazz 服务接口Class
     * @return Mock对象
     */    public static <T> T getMock(Class<T> clazz) {        Object mock = mockRegistry.get(clazz);        if (mock == null) {            throw new IllegalStateException("Mock对象未注册: " + clazz.getName());
        }        return (T) mock;    }        /**
     * 清空Mock注册表（仅用于特殊场景）
     */    public static void clearMockRegistry() {        mockRegistry.clear();    }}

@SpringBootTest
public class OrderServiceIntegrationTest extends BaseCommonServiceTest {

    @Autowired
    private OrderService orderService;  // 被测试的服务
        // OrderService内部依赖的Dubbo服务会被自动Mock

    @Test
    @DisplayName("测试订单创建（依赖外部用户服务）")
    void testCreateOrder() {
        // 1. 获取自动Mock的Dubbo服务
        UserRemoteService userService = TestMockConfig.getMock(UserRemoteService.class);        // 2. 配置Mock行为
        when(userService.getUserById(anyLong())).thenReturn(buildMockUser());        // 3. 执行业务操作
        OrderDTO order = orderService.createOrder(buildOrderRequest());
        // 4. 验证结果
        assertNotNull(order.getId());        assertEquals("PENDING", order.getStatus());        // 5. 验证Dubbo服务被调用
        verify(userService, times(1)).getUserById(anyLong());    }}

@Intercepts({
    @Signature(
        type = StatementHandler.class,        method = "prepare",        args = {Connection.class, Integer.class}    )})
public class SqlCompatibilityInterceptor implements Interceptor {
    private static final Pattern FORCE_INDEX_PATTERN =        Pattern.compile("FORCE\\s+INDEX\\s*\\([^)]*\\)", Pattern.CASE_INSENSITIVE);
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        StatementHandler handler = (StatementHandler) invocation.getTarget();        BoundSql boundSql = handler.getBoundSql();        String originalSql = boundSql.getSql();        // 兼容处理
        String compatibleSql = makeCompatible(originalSql);        // 更新SQL
        Field sqlField = boundSql.getClass().getDeclaredField("sql");        sqlField.setAccessible(true);        sqlField.set(boundSql, compatibleSql);                return invocation.proceed();
    }    private String makeCompatible(String sql) {
        // 移除FORCE INDEX
        sql = FORCE_INDEX_PATTERN.matcher(sql).replaceAll("");
        // 其他兼容处理...
        return sql;    }    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);    }}

<dependencies>
    <!-- Spring Boot 测试 -->    <dependency>        <groupId>org.springframework.boot</groupId>        <artifactId>spring-boot-starter-test</artifactId>        <scope>test</scope>    </dependency>    <!-- H2 内存数据库 -->    <dependency>        <groupId>com.h2database</groupId>        <artifactId>h2</artifactId>        <scope>test</scope>    </dependency>        <!-- Mockito (支持静态Mock) -->
    <dependency>        <groupId>org.mockito</groupId>        <artifactId>mockito-inline</artifactId>        <version>4.11.0</version>        <scope>test</scope>    </dependency>        <!-- AssertJ (流式断言) -->
    <dependency>        <groupId>org.assertj</groupId>        <artifactId>assertj-core</artifactId>        <scope>test</scope>    </dependency>    <!-- 内嵌Redis (可选) -->
    <dependency>        <groupId>it.ozimov</groupId>        <artifactId>embedded-redis</artifactId>        <version>0.7.3</version>        <scope>test</scope>    </dependency>        <!-- TestContainers (可选，用于真实数据库) -->
    <dependency>        <groupId>org.testcontainers</groupId>        <artifactId>mysql</artifactId>        <version>1.19.0</version>        <scope>test</scope>    </dependency></dependencies>

# H2 数据库配置
spring.datasource.url=jdbc:h2:mem:testdb;MODE=MySQL;DATABASE_TO_LOWER=TRUE;DB_CLOSE_DELAY=-1
spring.datasource.driver-class-name=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=

# H2 控制台 (可选，用于调试)
spring.h2.console.enabled=true
spring.h2.console.path=/h2-console

# Redis 配置 (内嵌)
spring.redis.host=localhost
spring.redis.port=6380
spring.redis.password=<your-password>

# MyBatis 配置
mybatis.configuration.map-underscore-to-camel-case=true
mybatis.mapper-locations=classpath*:mapper/**/*.xml

# 日志配置
logging.level.root=INFO
logging.level.com.yourcompany=DEBUG
logging.level.org.springframework.test=INFO

# 关闭不需要的自动配置
spring.autoconfigure.exclude=\
  org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration

-- 用户表
CREATE TABLE IF NOT EXISTS users (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,    username VARCHAR(50) NOT NULL UNIQUE,    email VARCHAR(100),    status VARCHAR(20),    create_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,    update_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,    INDEX idx_username (username),    INDEX idx_status (status));

-- 订单表
CREATE TABLE IF NOT EXISTS orders (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,    user_id BIGINT NOT NULL,    order_no VARCHAR(50) NOT NULL UNIQUE,    amount DECIMAL(10, 2),    status VARCHAR(20),    create_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,    INDEX idx_user_id (user_id),    INDEX idx_order_no (order_no));

-- 插入测试用户
INSERT INTO users (username, email, status) VALUES ('testuser1', 'test1@example.com', 'ACTIVE'),
('testuser2', 'test2@example.com', 'ACTIVE');

-- 插入测试订单
INSERT INTO orders (user_id, order_no, amount, status) VALUES (1, 'ORDER001', 100.00, 'PENDING'),
(1, 'ORDER002', 200.00, 'COMPLETED');

package com.yourcompany.yourapp;

@SpringBootApplication(
    scanBasePackageClasses = {TestConfig.class},    exclude = {        DataSourceAutoConfiguration.class,        // 排除其他不需要的自动配置
    })
public class TestApplication {
    // 仅作为测试启动入口，无需main方法
}

package com.yourcompany.yourapp.integration;

@SpringBootTest(classes = TestApplication.class)
@ActiveProfiles("test")
public abstract class BaseIntegrationTest {
        protected static RedisServer redisServer;
        @BeforeAll
    public static void init() {        startEmbeddedRedis();        mockStaticServices();    }        @AfterAll
    public static void cleanup() {        // 清理资源
    }        private static void startEmbeddedRedis() {
        try {            redisServer = RedisServer.builder()                .port(6380)                .setting("requirepass <password>")                .build();            redisServer.start();        } catch (Exception e) {            throw new RuntimeException("Redis启动失败", e);
        }    }        private static void mockStaticServices() {
        // Mock静态工厂类等
    }}

package com.yourcompany.yourapp.service;

@Transactional
@Rollback
public class UserServiceTest extends BaseIntegrationTest {
        @Autowired
    private UserService userService;        @Test
    @DisplayName("测试用户创建流程")
    void testCreateUser() {        // 准备测试数据
        UserCreateRequest request = UserCreateRequest.builder()            .username("newuser")            .email("new@example.com")            .build();        // 执行业务操作
        UserDTO result = userService.createUser(request);        // 验证结果
        assertNotNull(result.getId());        assertEquals("newuser", result.getUsername());        assertEquals("ACTIVE", result.getStatus());    }        @Test
    @DisplayName("测试重复用户名抛出异常")
    void testDuplicateUsername() {        UserCreateRequest request = UserCreateRequest.builder()            .username("testuser1") // 已存在
            .email("duplicate@example.com")            .build();                assertThrows(DuplicateUserException.class, () -> {
            userService.createUser(request);        });    }}

<plugin>
    <groupId>org.jacoco</groupId>    <artifactId>jacoco-maven-plugin</artifactId>    <version>0.8.11</version>    <executions>        <execution>            <goals>                <goal>prepare-agent</goal>            </goals>        </execution>        <execution>            <id>report</id>            <phase>test</phase>            <goals>                <goal>report</goal>            </goals>        </execution>        <execution>            <id>check</id>            <goals>                <goal>check</goal>            </goals>            <configuration>                <rules>                    <rule>                        <element>BUNDLE</element>                        <limits>                            <limit>                                <counter>LINE</counter>                                <value>COVEREDRATIO</value>                                <minimum>0.80</minimum>                            </limit>                        </limits>                    </rule>                </rules>            </configuration>        </execution>    </executions></plugin>

# 执行测试
mvn clean test

# 查看覆盖率报告
open target/site/jacoco/index.html

// ✅ 推荐: [被测试类名] + IntegrationTest
OrderServiceIntegrationTest.java
UserServiceIntegrationTest.java

// ✅ DAO层测试: [被测试类名] + Test
OrderMapperTest.java

// ❌ 避免
TestOrderService.java            // Test前缀不推荐
OrderServiceTests.java           // 多余的s
OrderServiceIT.java              // IT缩写不够清晰

@Test
@DisplayName("创建订单-成功场景")
void testCreateOrder() {
    // ...}

@Test
@DisplayName("创建订单-订单号重复时抛出异常")
void testCreateOrderWithDuplicateOrderNo() {
    // ...}

@Test
@DisplayName("导入数据-批量导入1000条数据")
void testImportData() {
    // ...}

@Test
@DisplayName("should_ReturnUser_When_ValidIdProvided")
void shouldReturnUserWhenValidIdProvided() {
    // ...}

@Test
@DisplayName("should_ThrowException_When_UserNotFound")
void shouldThrowExceptionWhenUserNotFound() {
    // ...}

// ✅ 推荐: build + 实体名
private OrderDTO buildOrder() {
    return OrderDTO.builder()        .orderName("测试订单_" + System.currentTimeMillis())
        .build();}

// ✅ 推荐: create + 实体名（需要持久化）
private OrderDTO createOrder() {
    OrderDTO order = buildOrder();    orderService.create(order);    return order;}

// ✅ 推荐: mock + 服务名 + 方法名
private void mockUserServiceGetUser() {
    UserRemoteService mock = TestMockConfig.getMock(UserRemoteService.class);    when(mock.getUserById(anyLong())).thenReturn(buildMockUser());}

@Test
@DisplayName("订单全链路集成测试")
@Transactional
@Rollback
void testOrderFullFlow() {
    // 1. 创建用户
    UserDTO user = userService.createUser(buildUserRequest());    // 2. 创建订单
    OrderDTO order = orderService.createOrder(user.getId(), buildOrderRequest());    assertNotNull(order.getOrderNo());    assertEquals("PENDING", order.getStatus());    // 3. 支付订单
    PaymentResult payment = orderService.pay(order.getId(), buildPaymentRequest());    assertTrue(payment.isSuccess());    // 4. 验证订单状态
    OrderDTO paidOrder = orderService.getById(order.getId());    assertEquals("PAID", paidOrder.getStatus());    // 5. 发货
    orderService.ship(order.getId());    // 6. 完成订单
    OrderDTO completedOrder = orderService.getById(order.getId());    assertEquals("COMPLETED", completedOrder.getStatus());}

@ParameterizedTest
@DisplayName("测试各种无效邮箱格式")
@ValueSource(strings = {
    "invalid",    "invalid@",    "@example.com",    "invalid@.com",    ""})
void testInvalidEmail(String invalidEmail) {
    UserCreateRequest request = UserCreateRequest.builder()        .username("testuser")        .email(invalidEmail)        .build();        assertThrows(ValidationException.class, () -> {
        userService.createUser(request);
    });}

@ParameterizedTest
@DisplayName("测试不同订单金额的手续费计算")
@CsvSource({
    "100.00, 1.00",    // 金额, 预期手续费
    "1000.00, 10.00",    "10000.00, 100.00"})
void testOrderFeeCalculation(BigDecimal amount, BigDecimal expectedFee) {
    OrderDTO order = orderService.createOrder(userId, amount);    assertEquals(expectedFee, order.getFee());}

@Test
@DisplayName("测试外部服务失败时的降级处理")
void testExternalServiceFailure() {
    // Mock外部服务抛出异常
    PaymentService paymentMock = TestMockConfig.getMock(PaymentService.class);    when(paymentMock.pay(any()))        .thenThrow(new RemoteServiceException("支付服务不可用"));
    // 执行业务操作
    OrderDTO order = orderService.createOrder(userId, buildOrderRequest());    PaymentResult result = orderService.pay(order.getId(), buildPaymentRequest());    // 验证降级处理
    assertFalse(result.isSuccess());    assertEquals("PAYMENT_SERVICE_ERROR", result.getErrorCode());    // 验证订单状态未变化
    OrderDTO unchangedOrder = orderService.getById(order.getId());    assertEquals("PENDING", unchangedOrder.getStatus());}

public class TestDataBuilder {
        public static UserCreateRequestBuilder userRequest() {
        return new UserCreateRequestBuilder();    }        public static OrderCreateRequestBuilder orderRequest() {
        return new OrderCreateRequestBuilder();    }        public static class UserCreateRequestBuilder {
        private String username = "testuser";        private String email = "test@example.com";        private String status = "ACTIVE";                public UserCreateRequestBuilder username(String username) {
            this.username = username;            return this;        }                public UserCreateRequestBuilder email(String email) {
            this.email = email;            return this;        }                public UserCreateRequest build() {
            return UserCreateRequest.builder()                .username(username + "_" + System.currentTimeMillis())                .email(email)                .status(status)                .build();        }    }}

// 使用示例
@Test
void testCreateUser() {
    UserCreateRequest request = TestDataBuilder.userRequest()        .username("customuser")        .email("custom@example.com")        .build();        UserDTO result = userService.createUser(request);
    assertNotNull(result);}

@Test
@DisplayName("测试查询大量订单的性能")
@Sql(scripts = "/test-data/large-orders.sql")
void testQueryLargeOrders() {
    List<OrderDTO> orders = orderService.queryByUserId(userId);    assertTrue(orders.size() >= 1000);}

@Test
@Sql(scripts = {
    "/test-data/setup-users.sql",    "/test-data/setup-orders.sql"})
@Sql(scripts = "/test-data/cleanup.sql", executionPhase = Sql.ExecutionPhase.AFTER_TEST_METHOD)
void testWithSpecificData() {
    // 测试逻辑
}

// 1. Dubbo远程服务（自动Mock）
@Reference
private UserRemoteService userRemoteService;

// 2. 静态工厂类（BaseIntegrationTest中已Mock）
ONSFactory.createProducer(...)           // RocketMQ
OssClientFactory.getOSSClient()          // 阿里云OSS

// 3. Apollo配置中心（BaseIntegrationTest中已配置本地模式）

@Test
@DisplayName("测试调用用户服务-不同响应场景")
void testCallUserService() {
    // 获取自动Mock的Dubbo服务
    UserRemoteService userService = TestMockConfig.getMock(UserRemoteService.class);    // 场景1: 正常返回用户
    UserDTO mockUser = UserDTO.builder()        .id(1001L)        .username("testuser")        .build();    when(userService.getUserById(1001L)).thenReturn(mockUser);    // 场景2: 用户不存在返回null
    when(userService.getUserById(9999L)).thenReturn(null);    // 场景3: 服务异常抛出RpcException
    when(userService.getUserById(0L))        .thenThrow(new RpcException("服务不可用"));
    // 执行测试
    UserDTO result1 = orderService.getUser(1001L);    assertNotNull(result1);        UserDTO result2 = orderService.getUser(9999L);
    assertNull(result2);        assertThrows(RpcException.class, () -> {
        orderService.getUser(0L);    });}

@Test
@DisplayName("测试创建订单时调用用户服务验证用户")
void testCreateOrderCallsUserService() {
    UserRemoteService userService = TestMockConfig.getMock(UserRemoteService.class);    // 配置Mock返回
    when(userService.getUserById(anyLong())).thenReturn(buildMockUser());    // 执行业务操作
    OrderDTO order = orderService.createOrder(1001L, buildOrderRequest());    // 验证Dubbo服务被正确调用
    ArgumentCaptor<Long> userIdCaptor = ArgumentCaptor.forClass(Long.class);    verify(userService, times(1)).getUserById(userIdCaptor.capture());    // 验证调用参数
    assertEquals(1001L, userIdCaptor.getValue());}

@SpringBootTest
public class OrderServiceIntegrationTest extends BaseCommonServiceTest {

    private UserRemoteService userService;
    private PaymentRemoteService paymentService;

    @BeforeEach
    void setUp() {
        // 获取Mock对象
        userService = TestMockConfig.getMock(UserRemoteService.class);        paymentService = TestMockConfig.getMock(PaymentRemoteService.class);        // 重置Mock状态（清除之前测试的配置）
        Mockito.reset(userService, paymentService);
        // 配置通用Mock行为
        when(userService.getUserById(anyLong())).thenReturn(buildDefaultUser());
    }
    @Test
    @DisplayName("测试场景1")
    void testScenario1() {
        // 特定场景的Mock配置
        when(paymentService.pay(any())).thenReturn(PaymentResult.success());
        // ...    }
    @Test
    @DisplayName("测试场景2")
    void testScenario2() {
        // 这个测试不会受到testScenario1中Mock配置的影响
        when(paymentService.pay(any())).thenReturn(PaymentResult.fail());
        // ...    }}

import static org.assertj.core.api.Assertions.*;

@Test
void testOrderCreation() {
    OrderDTO order = orderService.createOrder(userId, buildOrderRequest());    // 流式断言 - 更易读
    assertThat(order)        .isNotNull()        .extracting("orderNo", "userId", "status")        .containsExactly("ORDER001", userId, "PENDING");        assertThat(order.getAmount()).isPositive();
    assertThat(order.getCreateTime()).isBeforeOrEqualTo(LocalDateTime.now());}

@Test
void testOrderUpdate() {
    OrderDTO expected = buildExpectedOrder();    OrderDTO actual = orderService.updateOrder(orderId, buildUpdateRequest());    // 递归比较，忽略时间戳字段
    assertThat(actual)        .usingRecursiveComparison()        .ignoringFields("updateTime", "version")        .ignoringFieldsMatchingRegexes(".*Time")        .isEqualTo(expected);}