Java基础教程（112）单元测试之使用Fixture：告别混乱测试，深度剖析Java单元测试中的Fixture利器-优快云博客

一、何为Fixture？绝非简单的“设置”

在单元测试中，Fixture（测试夹具）是指运行一个或多个测试所需的一系列前置条件和上下文环境。它不仅仅是在测试方法开头写几行初始化代码那么简单，而是一种系统化的设计模式。

其核心目的在于：

提供一致的基础环境：确保每个测试都在一个已知的、可控的状态下开始，这是测试可重复性的根本。
消除代码重复：将多个测试共用的准备和清理逻辑抽取出来，保持测试代码的DRY（Don't Repeat Yourself）。
提升可读性与可维护性：将繁琐的设置/清理逻辑与核心测试逻辑分离，让测试方法本身只关注“给定输入，断言输出”，意图更加清晰。

没有Fixture的测试代码常常充斥着重复的初始化语句，一旦被测对象的构造方式改变，修改起来将是噩梦。

二、JUnit中的Fixture演进：从经典到现代

JUnit框架对Fixture的支持经历了清晰的演进，体现了最佳实践的变化。

1. JUnit 4及之前的经典方式：setUp 和 tearDown

通过继承TestCase类并重写setUp()和tearDown()方法来实现。

setUp()：在每个测试方法之前运行。
tearDown()：在每个测试方法之后运行，通常用于释放资源（如关闭文件、数据库连接）。

这种方式的问题是强制使用了继承，不够灵活。

2. JUnit 5/ Jupiter的现代方式：注解驱动

JUnit 5引入了更强大、更灵活的注解系统，成为了当前的主流和推荐做法。

@BeforeEach：替代了setUp()。注解的方法会在每个@Test方法执行前运行。
@AfterEach：替代了tearDown()。注解的方法会在每个@Test方法执行后运行。
@BeforeAll / @AfterAll：用于执行所有测试开始前/后的一次性的、开销昂贵的初始化/清理工作（如启动嵌入式数据库）。这些方法必须是static的。

现代方式的核心优势：它基于注解而非继承，使得测试类可以更自由地组织，并与其他框架（如Mockito、Spring Test）无缝集成。

三、实战示例：Spring Boot服务层单元测试

假设我们有一个简单的用户服务UserService，它依赖一个用户仓库UserRepository。我们将为UserService的login方法编写单元测试。

1. 被测代码与依赖

// Repository 接口
public interface UserRepository {
    User findByUsername(String username);
    User save(User user);
}

// 实体类
@Data // Lombok 注解，生成getter, setter等
@AllArgsConstructor
public class User {
    private Long id;
    private String username;
    private String encryptedPassword;
}

// 服务类
@Service
public class UserService {
    private final UserRepository userRepository;
    private final PasswordEncoder passwordEncoder; // 密码编码器

    public UserService(UserRepository userRepository, PasswordEncoder passwordEncoder) {
        this.userRepository = userRepository;
        this.passwordEncoder = passwordEncoder;
    }

    public boolean login(String username, String rawPassword) {
        User user = userRepository.findByUsername(username);
        if (user == null) {
            return false;
        }
        return passwordEncoder.matches(rawPassword, user.getEncryptedPassword());
    }
}

2. 测试类与Fixture设置

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;

// 使用Mockito的扩展，简化Mock对象创建
@ExtendWith(MockitoExtension.class)
class UserServiceTest {

    // 被测系统 (System Under Test)
    private UserService userService;

    // 使用@Mock创建依赖的Mock对象
    @Mock
    private UserRepository userRepository;

    // 这是真实的编码器，因为其行为是确定且无副作用的，无需Mock
    private PasswordEncoder passwordEncoder = new BCryptPasswordEncoder();

    // 在多个测试中会用到的Fixture数据
    private User existingUser;
    private String correctRawPassword;
    private String hashedPassword;

    // FIXTURE 设置核心！
    @BeforeEach
    void setUp() {
        // 1. 初始化测试数据
        correctRawPassword = "mySecretPassword";
        hashedPassword = passwordEncoder.encode(correctRawPassword); // 对密码进行哈希
        existingUser = new User(1L, "alice", hashedPassword);

        // 2. 构造被测对象，注入Mock依赖和真实依赖
        userService = new UserService(userRepository, passwordEncoder);

        // 3. （可选但常见）设置Mock对象的通用行为。
        // 例如，让userRepository在接收到特定参数时返回我们准备好的Fixture数据。
        // 注意：更具体的行为可以在每个测试方法中覆盖。
        when(userRepository.findByUsername("alice")).thenReturn(existingUser);
        when(userRepository.findByUsername("unknownUser")).thenReturn(null);
    }

    // 接下来的测试方法都可以共享setUp中初始化的userService和测试数据
}

3. 编写具体的测试用例

现在，我们可以编写非常干净、专注的测试方法。

@Test
    void login_WithValidCredentials_ReturnsTrue() {
        // Act
        boolean result = userService.login("alice", correctRawPassword);

        // Assert
        assertTrue(result);
        // 可以验证Mock的交互
        verify(userRepository).findByUsername("alice");
    }

    @Test
    void login_WithInvalidPassword_ReturnsFalse() {
        // Act
        boolean result = userService.login("alice", "wrongPassword");

        // Assert
        assertFalse(result);
        verify(userRepository).findByUsername("alice");
    }

    @Test
    void login_WithNonExistentUser_ReturnsFalse() {
        // Act
        boolean result = userService.login("unknownUser", "anyPassword");

        // Assert
        assertFalse(result);
        verify(userRepository).findByUsername("unknownUser");
    }