@ExtendWith(MockitoExtension.class)
class UserDomainServiceTest {

    @Mock
    private UserRepository userRepository;

    @Mock
    private PasswordEncoder passwordEncoder;

    @InjectMocks
    private UserDomainService userDomainService;

    @Test
    void shouldThrowExceptionWhenUsernameAlreadyExists() {
        // 给定：用户名已存在
        when(userRepository.findByUsername("zhangsan"))
            .thenReturn(Optional.of(existingUser()));

        // 当：尝试创建同名用户 → 则：抛出业务异常
        assertThrows(DuplicateUserException.class, () ->
            userDomainService.createUser("zhangsan", "password123"));
    }

    @Test
    void shouldReturnEncodedUserWhenCreateSuccessfully() {
        // 给定：用户名不存在，密码编码器正常工作
        when(userRepository.findByUsername("lisi"))
            .thenReturn(Optional.empty());
        when(passwordEncoder.encode("password123"))
            .thenReturn("$2a$10$encodedPassword");
        when(userRepository.save(any(User.class)))
            .thenAnswer(inv -> inv.getArgument(0));

        // 当：创建用户
        User result = userDomainService.createUser("lisi", "password123");

        // 则：返回已编码的用户对象
        assertNotNull(result);
        assertEquals("lisi", result.getUsername());
        assertEquals("$2a$10$encodedPassword", result.getPassword());
    }

    private User existingUser() {
        User user = new User();
        user.setId(1L);
        user.setUsername("zhangsan");
        return user;
    }
}

@WebMvcTest(UserController.class)
@Import(SecurityTestConfig.class)  // 导入测试专用的安全配置（跳过真实Token校验）
class UserControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private UserApplicationService userApplicationService;

    @Test
    void shouldReturn400WhenRequestBodyInvalid() throws Exception {
        // 发送缺少必填字段的JSON
        String invalidJson = """
            {
                "username": "",
                "email": "not-an-email"
            }
            """;

        mockMvc.perform(post("/api/users")
                .contentType(MediaType.APPLICATION_JSON)
                .content(invalidJson))
            .andExpect(status().isBadRequest())
            .andExpect(jsonPath("$.errors.username").exists())
            .andExpect(jsonPath("$.errors.email").exists());
    }

    @Test
    void shouldReturnUserDetailWith200() throws Exception {
        // 给定：Service层返回预定义的用户
        UserDTO mockUser = UserDTO.builder()
            .id(1L)
            .username("zhangsan")
            .email("zhangsan@example.com")
            .build();
        when(userApplicationService.getUserById(1L)).thenReturn(mockUser);

        // 当：请求用户详情 → 则：返回200 + JSON
        mockMvc.perform(get("/api/users/1")
                .header("Authorization", "Bearer test-token"))
            .andExpect(status().isOk())
            .andExpect(jsonPath("$.id").value(1))
            .andExpect(jsonPath("$.username").value("zhangsan"))
            .andExpect(jsonPath("$.email").value("zhangsan@example.com"));
    }

    @Test
    void shouldReturn401WhenTokenMissing() throws Exception {
        mockMvc.perform(get("/api/users/1"))
            .andExpect(status().isUnauthorized())
            .andExpect(jsonPath("$.message").value("缺少有效的认证Token"));
    }
}

@DataJpaTest
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
// ↑ 如果不想用H2自动替换，可以用这个注解保留真实数据库配置
class UserRepositoryTest {

    @Autowired
    private TestEntityManager entityManager;

    @Autowired
    private UserRepository userRepository;

    @BeforeEach
    void setUp() {
        // 每个测试方法前清理数据，保证用例独立性
        entityManager.getEntityManager()
            .createQuery("DELETE FROM User").executeUpdate();
    }

    @Test
    void shouldFindByUsernameWithExactMatch() {
        // 给定：插入一条用户数据
        User user = new User();
        user.setUsername("zhangsan");
        user.setEmail("zhangsan@example.com");
        user.setStatus(UserStatus.ACTIVE);
        entityManager.persistAndFlush(user);

        // 当：按用户名精确查询
        Optional<User> result = userRepository.findByUsername("zhangsan");

        // 则：找到且字段匹配
        assertTrue(result.isPresent());
        assertEquals("zhangsan@example.com", result.get().getEmail());
    }

    @Test
    void shouldReturnEmptyWhenUsernameNotFound() {
        Optional<User> result = userRepository.findByUsername("nonexistent");
        assertTrue(result.isEmpty());
    }

    @Test
    void shouldFindActiveUsersWithPagination() {
        // 插入20条数据，一半ACTIVE，一半INACTIVE
        for (int i = 0; i < 10; i++) {
            entityManager.persist(createUser("active-" + i, UserStatus.ACTIVE));
            entityManager.persist(createUser("inactive-" + i, UserStatus.INACTIVE));
        }
        entityManager.flush();

        // 分页查询ACTIVE用户，每页5条
        Pageable pageable = PageRequest.of(0, 5, Sort.by("username").ascending());
        Page<User> page = userRepository.findByStatus(UserStatus.ACTIVE, pageable);

        assertEquals(10, page.getTotalElements());
        assertEquals(2, page.getTotalPages());
        assertEquals(5, page.getContent().size());
    }

    private User createUser(String username, UserStatus status) {
        User user = new User();
        user.setUsername(username);
        user.setEmail(username + "@example.com");
        user.setStatus(status);
        return user;
    }
}

@SpringBootTest
@TestPropertySource(properties = {
    "spring.cloud.nacos.discovery.enabled=false",
    "spring.cloud.nacos.config.enabled=false",
    "spring.cloud.sentinel.enabled=false"
})
@ActiveProfiles("test")
class UserApplicationServiceIntegrationTest {

    @Autowired
    private UserApplicationService userApplicationService;

    @Autowired
    private UserRepository userRepository;

    @MockBean
    private OrderFeignClient orderFeignClient;    // 对其他微服务的调用全部Mock

    @MockBean
    private SmsGateway smsGateway;                 // 第三方API全部Mock

    @BeforeEach
    void setUp() {
        userRepository.deleteAll();

        // 准备测试数据
        User user = new User();
        user.setUsername("integration-test-user");
        user.setEmail("test@example.com");
        user.setStatus(UserStatus.ACTIVE);
        userRepository.save(user);
    }

    @Test
    void shouldCreateUserAndPublishEvent() {
        // 给定：Mock外部依赖的返回值
        when(smsGateway.sendVerificationCode(anyString(), anyString()))
            .thenReturn(SmsResult.success());

        // 当：调用创建用户的完整应用服务
        CreateUserCommand command = new CreateUserCommand(
            "newuser", "password123", "new@example.com");
        UserDTO result = userApplicationService.createUser(command);

        // 则：用户被持久化 + 外部Mock被正确调用
        assertNotNull(result.getId());
        assertEquals("newuser", result.getUsername());

        // 验证：短信网关被调用了（带正确的参数）
        verify(smsGateway, times(1))
            .sendVerificationCode(eq("new@example.com"), anyString());

        // 验证：因为注册流程不依赖订单服务，所以不应该调它
        verifyNoInteractions(orderFeignClient);
    }

    @Test
    void shouldRollbackTransactionWhenExternalCallFails() {
        // 给定：短信发送会失败
        when(smsGateway.sendVerificationCode(anyString(), anyString()))
            .thenThrow(new SmsSendException("短信服务不可用"));

        CreateUserCommand command = new CreateUserCommand(
            "rollback-user", "password123", "rollback@example.com");

        // 当：创建用户 → 则：抛出异常，数据回滚
        assertThrows(SmsSendException.class, () ->
            userApplicationService.createUser(command));

        // 验证：数据库中没有残留数据
        Optional<User> found = userRepository.findByUsername("rollback-user");
        assertTrue(found.isEmpty());
    }
}

<!-- pom.xml -->
<dependency>
    <groupId>org.testcontainers</groupId>
    <artifactId>testcontainers</artifactId>
    <version>1.18.3</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.testcontainers</groupId>
    <artifactId>mysql</artifactId>
    <version>1.18.3</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.testcontainers</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>1.18.3</version>
    <scope>test</scope>
</dependency>

# src/test/resources/application-test.yml
spring:
  # 测试环境的数据库配置先空着——Testcontainers会动态注入
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver

  # 关掉所有SpringCloud组件（测试环境不需要）
  cloud:
    nacos:
      discovery:
        enabled: false
      config:
        enabled: false
    sentinel:
      enabled: false

  # JPA的DDL策略：测试环境每次重新建表
  jpa:
    hibernate:
      ddl-auto: create-drop
    show-sql: false

  # 用内嵌Redis替代（不需要Docker的简化方案）
  redis:
    host: localhost
    port: 6379

# 日志级别：测试时只打印ERROR，减少干扰
logging:
  level:
    root: WARN
    com.example: DEBUG
    org.testcontainers: INFO
    com.github.dockerjava: WARN

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@ActiveProfiles("test")
@TestPropertySource(properties = {
    "spring.cloud.nacos.discovery.enabled=false",
    "spring.cloud.nacos.config.enabled=false",
    "spring.cloud.sentinel.enabled=false"
})
@Testcontainers   // 启用Testcontainers的JUnit5扩展
public abstract class BaseIntegrationTest {

    // 使用 singleton 容器模式：同一个JVM内只启动一次，多个测试类共享
    // 否则每个测试类都启动一个MySQL容器，内存和时间都扛不住
    static final MySQLContainer<?> MYSQL = new MySQLContainer<>("mysql:8.0")
        .withDatabaseName("testdb")
        .withUsername("test")
        .withPassword("test")
        .withReuse(true);   // 允许容器复用（需在 ~/.testcontainers.properties 中启用）

    static final GenericContainer<?> REDIS = new GenericContainer<>("redis:7.0-alpine")
        .withExposedPorts(6379)
        .withReuse(true);

    static {
        MYSQL.start();
        REDIS.start();
    }

    @DynamicPropertySource
    static void configureDatasource(DynamicPropertyRegistry registry) {
        // 动态注入Testcontainers的连接信息（端口是随机的）
        registry.add("spring.datasource.url", MYSQL::getJdbcUrl);
        registry.add("spring.datasource.username", MYSQL::getUsername);
        registry.add("spring.datasource.password", MYSQL::getPassword);
        registry.add("spring.redis.host", REDIS::getHost);
        registry.add("spring.redis.port", () -> REDIS.getMappedPort(6379));
    }
}

class UserServiceIntegrationTest extends BaseIntegrationTest {

    @Autowired
    private UserRepository userRepository;

    @Autowired
    private UserApplicationService userApplicationService;

    @MockBean
    private OrderFeignClient orderFeignClient;

    @MockBean
    private SmsGateway smsGateway;

    @BeforeEach
    void setUp() {
        // 每个测试方法前清空表，避免测试间相互污染
        userRepository.deleteAll();
    }

    @Test
    void shouldPersistUserToRealMysqlAndCacheToRealRedis() {
        // 当：通过应用服务创建用户
        CreateUserCommand cmd = new CreateUserCommand(
            "testuser", "pass123", "test@example.com");
        when(smsGateway.sendVerificationCode(anyString(), anyString()))
            .thenReturn(SmsResult.success());

        UserDTO result = userApplicationService.createUser(cmd);

        // 则：数据在真实MySQL中可查
        Optional<User> fromDb = userRepository.findByUsername("testuser");
        assertTrue(fromDb.isPresent());
        assertEquals("test@example.com", fromDb.get().getEmail());
        // 注意：Redis缓存的验证需要写额外的集成测试，
        // 这里只验证MySQL持久化链路
    }

    @Test
    void shouldRollbackWhenConstraintViolation() {
        // 先插入一条
        userRepository.save(createUser("existing", "existing@test.com"));

        // 尝试插入同名的 → 应该失败
        CreateUserCommand cmd = new CreateUserCommand(
            "existing", "pass123", "another@test.com");

        assertThrows(DataIntegrityViolationException.class, () ->
            userApplicationService.createUser(cmd));
    }

    private User createUser(String username, String email) {
        User u = new User();
        u.setUsername(username);
        u.setEmail(email);
        u.setStatus(UserStatus.ACTIVE);
        return u;
    }
}

<!-- pom.xml -->
<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <!-- surefire默认跑单元测试，排除集成测试 -->
            <configuration>
                <excludes>
                    <exclude>**/*IntegrationTest.java</exclude>
                </excludes>
            </configuration>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-failsafe-plugin</artifactId>
            <!-- failsafe专门跑集成测试（命名约定：*IT.java 或 *IntegrationTest.java） -->
            <executions>
                <execution>
                    <goals>
                        <goal>integration-test</goal>
                        <goal>verify</goal>
                    </goals>
                </execution>
            </executions>
            <configuration>
                <includes>
                    <include>**/*IntegrationTest.java</include>
                </includes>
            </configuration>
        </plugin>
    </plugins>
</build>

# mvn test       → 只跑单元测试（快）
# mvn verify     → 先跑单元测试，再跑集成测试（慢，需要Docker）

// ==================== Consumer端测试 ====================
@SpringBootTest(classes = FeignTestConfig.class)
@EnableFeignClients(clients = UserFeignClient.class)
class UserFeignClientContractTest {

    // WireMock 模拟 Provider 服务的HTTP响应
    @RegisterExtension
    static WireMockExtension wireMock = WireMockExtension.newInstance()
        .options(WireMockConfiguration.wireMockConfig().dynamicPort())
        .build();

    @DynamicPropertySource
    static void configureFeignUrl(DynamicPropertyRegistry registry) {
        registry.add("app.feign.user-service.url",
            () -> "http://localhost:" + wireMock.getPort());
    }

    @Autowired
    private UserFeignClient userFeignClient;

    @Test
    void shouldDeserializeResponseCorrectly() {
        // 用WireMock模拟Provider的返回
        wireMock.stubFor(get(urlEqualTo("/api/users/1"))
            .willReturn(aResponse()
                .withHeader("Content-Type", "application/json")
                .withBody("""
                    {
                        "id": 1,
                        "username": "zhangsan",
                        "email": "zhangsan@example.com"
                    }
                    """)));

        // 验证Consumer端的反序列化正确
        UserDTO result = userFeignClient.getUserById(1L);
        assertEquals(1L, result.getId());
        assertEquals("zhangsan", result.getUsername());
    }

    @Test
    void shouldHandleProvider5xxGracefully() {
        // 模拟Provider挂了
        wireMock.stubFor(get(urlEqualTo("/api/users/1"))
            .willReturn(aResponse().withStatus(503)));

        // 验证Consumer端的异常处理
        assertThrows(FeignException.ServiceUnavailable.class, () ->
            userFeignClient.getUserById(1L));
    }
}

// ==================== Provider端测试 ====================
@WebMvcTest(UserController.class)
class UserControllerContractTest {

    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private UserApplicationService userApplicationService;

    @Test
    void shouldMatchFeignClientContract() throws Exception {
        // Provider的Controller返回的JSON结构
        // 必须与Consumer的Feign接口定义一致
        when(userApplicationService.getUserById(1L))
            .thenReturn(UserDTO.builder()
                .id(1L).username("zhangsan")
                .email("zhangsan@example.com").build());

        String responseBody = mockMvc.perform(get("/api/users/1"))
            .andExpect(status().isOk())
            .andReturn().getResponse().getContentAsString();

        // 用JSON Schema验证响应结构的一致性
        JsonNode json = new ObjectMapper().readTree(responseBody);
        assertTrue(json.has("id"));
        assertTrue(json.has("username"));
        assertTrue(json.has("email"));
        assertEquals(1L, json.get("id").asLong());
    }
}

@ExtendWith(MockitoExtension.class)
class OrderMessageProducerTest {

    @Mock
    private KafkaTemplate<String, String> kafkaTemplate;

    @InjectMocks
    private OrderMessageProducer producer;

    @Test
    void shouldSendOrderCreatedEventWithCorrectPayload() throws Exception {
        // 给定：创建订单事件
        OrderCreatedEvent event = new OrderCreatedEvent(
            "ORDER-001", 1L, new BigDecimal("99.90"));

        // 当：发送消息
        producer.sendOrderCreated(event);

        // 则：验证消息以正确的格式发送到了正确的Topic
        ArgumentCaptor<String> topicCaptor = ArgumentCaptor.forClass(String.class);
        ArgumentCaptor<String> payloadCaptor = ArgumentCaptor.forClass(String.class);

        verify(kafkaTemplate).send(topicCaptor.capture(), payloadCaptor.capture());

        assertEquals("order-created-topic", topicCaptor.getValue());

        // 验证消息体的JSON结构
        JsonNode json = new ObjectMapper().readTree(payloadCaptor.getValue());
        assertEquals("ORDER-001", json.get("orderId").asText());
        assertEquals("99.90", json.get("amount").asText());
    }
}

@ExtendWith(MockitoExtension.class)
class OrderMessageConsumerTest {

    @Mock
    private OrderDomainService orderDomainService;

    @InjectMocks
    private OrderMessageConsumer consumer;

    @Test
    void shouldProcessOrderPaidMessageAndAck() {
        // 给定：模拟Kafka消费记录
        String messageBody = """
            {
                "orderId": "ORDER-001",
                "userId": 1,
                "amount": "99.90"
            }
            """;
        ConsumerRecord<String, String> record =
            new ConsumerRecord<>("order-paid-topic", 0, 0L, "key", messageBody);

        // 当：消费消息
        consumer.handleOrderPaid(record);

        // 则：验证业务逻辑被正确驱动
        verify(orderDomainService, times(1))
            .markOrderAsPaid(eq("ORDER-001"));
    }

    @Test
    void shouldNotThrowWhenDeserializationFails() {
        // 模拟损坏的消息体
        ConsumerRecord<String, String> record =
            new ConsumerRecord<>("order-paid-topic", 0, 0L, "key",
                "{broken json");

        // 不应该抛异常导致消费者卡住
        assertDoesNotThrow(() -> consumer.handleOrderPaid(record));
    }
}

# 最快：纯单元测试（不启动Spring容器）
mvn test -pl . -Dtest="*Test" -DfailIfNoTests=false

# 次快：切片测试（启动轻量Spring上下文）
mvn test -pl . -Dtest="*ControllerTest,*RepositoryTest"

# 较慢：集成测试（需要数据库/Redis就绪）
# 先启动依赖中间件
docker compose -f docker-compose-test.yml up -d mysql redis
# 再跑集成测试
mvn verify -pl . -Dtest="*IntegrationTest"
# 跑完关掉
docker compose -f docker-compose-test.yml down

# docker-compose-test.yml
version: '3.8'
services:
  mysql:
    image: mysql:8.0
    container_name: test-mysql
    environment:
      MYSQL_ROOT_PASSWORD: test123
      MYSQL_DATABASE: test_db
    ports:
      - "3307:3306"
    tmpfs:
      - /var/lib/mysql  # 数据全部在内存中，重启即清空

  redis:
    image: redis:7.0-alpine
    container_name: test-redis
    ports:
      - "6380:6379"

  kafka:
    image: confluentinc/cp-kafka:7.4.0
    container_name: test-kafka
    ports:
      - "9093:9093"
    environment:
      KAFKA_LISTENERS: PLAINTEXT://0.0.0.0:9093
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://localhost:9093
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1

#!/bin/bash
# run-all-tests.sh —— 本地全量测试一键脚本

set -e

echo "=== [1/4] 启动测试依赖中间件 ==="
docker compose -f docker-compose-test.yml up -d --wait mysql redis kafka

echo "=== [2/4] 纯单元测试 ==="
mvn test -Dtest="*Test" -DfailIfNoTests=false || {
    echo "❌ 单元测试失败，停止后续步骤"
    docker compose -f docker-compose-test.yml down
    exit 1
}

echo "=== [3/4] 切片测试 ==="
mvn test -Dtest="*ControllerTest,*RepositoryTest" || {
    echo "❌ 切片测试失败"
    docker compose -f docker-compose-test.yml down
    exit 1
}

echo "=== [4/4] Service集成测试 ==="
mvn verify -Dtest="*IntegrationTest" || {
    echo "❌ 集成测试失败"
    docker compose -f docker-compose-test.yml down
    exit 1
}

echo "=== 清理中间件 ==="
docker compose -f docker-compose-test.yml down

echo "✅ 全部测试通过！"

# 生成Jacoco聚合报告（多模块项目需要report-aggregate）
mvn clean verify jacoco:report

# 查看报告
# 浏览器打开: target/site/jacoco-aggregate/index.html

# 或者用命令行快速检查覆盖率是否达标
mvn jacoco:check
# 不达标会构建失败（阈值在pom.xml的jacoco-maven-plugin中配置）

<plugin>
    <groupId>org.jacoco</groupId>
    <artifactId>jacoco-maven-plugin</artifactId>
    <version>0.8.10</version>
    <executions>
        <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>
                            <limit>
                                <counter>BRANCH</counter>
                                <value>COVEREDRATIO</value>
                                <minimum>0.70</minimum>
                            </limit>
                        </limits>
                    </rule>
                </rules>
            </configuration>
        </execution>
    </executions>
</plugin>

为以下UserDomainService编写JUnit5 + Mockito测试用例：
- 覆盖正常路径和异常路径
- 每个测试方法使用given-when-then结构
- 使用@ExtendWith(MockitoExtension.class)
- 不要测试null参数（已经在Controller层校验）

[贴入源码]