单元测试与集成测试

为什么测试至关重要

测试不仅仅是"确认代码能跑"。对于专业工程师而言，自动化测试至少带来三个层面的价值：

测试金字塔

核心概念名词解释

单元测试：UserService

单元测试的目标是隔离测试一个类的逻辑，不涉及任何真实的外部依赖（数据库、网络等）。

@ExtendWith(MockitoExtension.class)  // 激活 Mockito 注解处理
class UserServiceTest {

    @Mock
    private UserRepository userRepository;  // Mock 依赖

    @Mock
    private PasswordEncoder passwordEncoder;

    @InjectMocks
    private UserServiceImpl userService;  // 被测类，依赖自动注入

    @Test
    @DisplayName("根据 ID 查询用户 — 用户存在时返回 DTO")
    void findById_UserExists_ReturnsDTO() {
        // Given（准备数据和 mock 行为）
        User user = User.builder().id(1L).username("alice").email("alice@example.com").build();
        Mockito.when(userRepository.findById(1L)).thenReturn(Optional.of(user));

        // When（执行被测方法）
        UserResponseDTO result = userService.findById(1L);

        // Then（断言结果）
        assertThat(result).isNotNull();
        assertThat(result.getUsername()).isEqualTo("alice");
        assertThat(result.getEmail()).isEqualTo("alice@example.com");
        verify(userRepository).findById(1L);  // 验证 mock 被正确调用
    }

    @Test
    @DisplayName("根据 ID 查询用户 — 用户不存在时抛出异常")
    void findById_UserNotFound_ThrowsException() {
        // Given
        Mockito.when(userRepository.findById(99L)).thenReturn(Optional.empty());

        // When & Then（断言异常）
        assertThatThrownBy(() -> userService.findById(99L))
            .isInstanceOf(EntityNotFoundException.class)
            .hasMessageContaining("99");
    }

    @Test
    @DisplayName("创建用户 — 邮箱已存在时抛出业务异常")
    void create_DuplicateEmail_ThrowsBusinessException() {
        // Given
        UserCreateDTO dto = new UserCreateDTO("bob", "existing@example.com", "Password1");
        Mockito.when(userRepository.existsByEmail("existing@example.com")).thenReturn(true);

        // When & Then
        assertThatThrownBy(() -> userService.create(dto))
            .isInstanceOf(BusinessException.class);
        verify(userRepository, never()).save(any());  // 确保未调用 save
    }
}

集成测试：MockMvc 测试 HTTP 接口

@SpringBootTest
@AutoConfigureMockMvc          // 自动配置 MockMvc
@Transactional                 // 每个测试后自动回滚，不污染数据
class UserControllerIntegrationTest {

    @Autowired
    private MockMvc mockMvc;

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

    @Autowired
    private UserRepository userRepository;

    @Test
    @DisplayName("POST /users — 创建用户成功返回 201")
    void createUser_ValidInput_Returns201() throws Exception {
        UserCreateDTO dto = new UserCreateDTO("testuser", "test@example.com", "Password1");

        mockMvc.perform(post("/users")
                .contentType(MediaType.APPLICATION_JSON)
                .content(objectMapper.writeValueAsString(dto)))
            .andExpect(status().isCreated())
            .andExpect(jsonPath("$.data.username").value("testuser"))
            .andExpect(jsonPath("$.data.email").value("test@example.com"))
            .andExpect(jsonPath("$.data.id").exists());
    }

    @Test
    @DisplayName("POST /users — 邮箱格式错误返回 400")
    void createUser_InvalidEmail_Returns400() throws Exception {
        UserCreateDTO dto = new UserCreateDTO("testuser", "not-an-email", "Password1");

        mockMvc.perform(post("/users")
                .contentType(MediaType.APPLICATION_JSON)
                .content(objectMapper.writeValueAsString(dto)))
            .andExpect(status().isBadRequest())
            .andExpect(jsonPath("$.code").value(400));
    }

    @Test
    @DisplayName("GET /users/{id} — 需要认证，未登录返回 401")
    void getUser_Unauthenticated_Returns401() throws Exception {
        mockMvc.perform(get("/users/1"))
            .andExpect(status().isUnauthorized());
    }
}

TestContainers：使用真实 PostgreSQL 测试

@SpringBootTest
@Testcontainers  // 激活 TestContainers 注解
class UserRepositoryTest {

    // 声明 PostgreSQL 容器（自动启动 Docker 容器）
    @Container
    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:16")
        .withDatabaseName("testdb")
        .withUsername("test")
        .withPassword("test");

    // 将容器的连接信息动态注入 Spring 配置
    @DynamicPropertySource
    static void configureProperties(DynamicPropertyRegistry registry) {
        registry.add("spring.datasource.url", postgres::getJdbcUrl);
        registry.add("spring.datasource.username", postgres::getUsername);
        registry.add("spring.datasource.password", postgres::getPassword);
    }

    @Autowired
    private UserRepository userRepository;

    @Test
    void findByEmail_ReturnsCorrectUser() {
        User user = User.builder()
            .username("alice")
            .email("alice@test.com")
            .passwordHash("hash")
            .build();
        userRepository.save(user);

        Optional<User> found = userRepository.findByEmail("alice@test.com");
        assertThat(found).isPresent();
        assertThat(found.get().getUsername()).isEqualTo("alice");
    }
}

测试覆盖率：JaCoCo

<plugin>
    <groupId>org.jacoco</groupId>
    <artifactId>jacoco-maven-plugin</artifactId>
    <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>
                        <limits>
                            <!-- 强制 Service 层覆盖率 ≥ 80% -->
                            <limit>
                                <counter>LINE</counter>
                                <minimum>0.80</minimum>
                            </limit>
                        </limits>
                    </rule>
                </rules>
            </configuration>
        </execution>
    </executions>
</plugin>