Java Mock测试

什么是Mock测试？

在软件测试领域，Mock（模拟）是一种常用的测试手法，用于在测试环境中创建和模拟真实对象的行为。Mock对象能够模拟复杂的、真实环境中难以构造或不可控的对象，使得测试更加简单和可靠。

当我们进行单元测试时，希望测试的是特定代码单元的功能，而不是它所依赖的其他组件。这时，Mock对象就能派上用场，它们可以：

• 替代真实依赖，隔离被测代码
• 模拟各种场景，包括异常情况
• 验证被测代码与依赖的交互是否符合预期

提示

Mock测试是单元测试的重要辅助技术，能帮助你创建更简洁、更可靠、更快速的测试。

Java Mock测试框架

Java中有多个Mock测试框架，最常用的包括：

1. Mockito - 最流行的Java Mock框架
2. EasyMock - 较早的Mock框架
3. PowerMock - 扩展Mockito，可以模拟静态方法、构造函数等
4. JMockit - 功能全面的Mock框架

本文将主要介绍Mockito，因为它简单易用且功能强大，是大多数Java项目的首选。

开始使用Mockito

添加依赖

首先，需要在项目中添加Mockito依赖。

Maven:

xml

<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-core</artifactId>
    <version>5.3.1</version>
    <scope>test</scope>
</dependency>

Gradle:

gradle

testImplementation 'org.mockito:mockito-core:5.3.1'

基本用法

假设我们有一个UserService类，依赖于UserRepository来获取用户信息：

java

public class UserService {
    private UserRepository userRepository;
    
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    
    public User getUserById(String id) {
        return userRepository.findById(id);
    }
    
    public boolean isActive(String id) {
        User user = userRepository.findById(id);
        return user != null && user.isActive();
    }
}

下面是使用Mockito测试UserService的例子：

java

import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;

public class UserServiceTest {

    @Test
    public void testGetUserById() {
        // 创建mock对象
        UserRepository mockRepository = mock(UserRepository.class);
        
        // 配置mock行为
        User mockUser = new User("123", "John", true);
        when(mockRepository.findById("123")).thenReturn(mockUser);
        
        // 使用mock注入被测对象
        UserService userService = new UserService(mockRepository);
        
        // 执行测试
        User result = userService.getUserById("123");
        
        // 验证结果
        assertEquals("John", result.getName());
        
        // 验证交互
        verify(mockRepository).findById("123");
    }
    
    @Test
    public void testIsActive_withActiveUser() {
        UserRepository mockRepository = mock(UserRepository.class);
        when(mockRepository.findById("123")).thenReturn(new User("123", "John", true));
        
        UserService userService = new UserService(mockRepository);
        
        assertTrue(userService.isActive("123"));
    }
    
    @Test
    public void testIsActive_withInactiveUser() {
        UserRepository mockRepository = mock(UserRepository.class);
        when(mockRepository.findById("456")).thenReturn(new User("456", "Jane", false));
        
        UserService userService = new UserService(mockRepository);
        
        assertFalse(userService.isActive("456"));
    }
    
    @Test
    public void testIsActive_withNonExistentUser() {
        UserRepository mockRepository = mock(UserRepository.class);
        when(mockRepository.findById("789")).thenReturn(null);
        
        UserService userService = new UserService(mockRepository);
        
        assertFalse(userService.isActive("789"));
    }
}

Mockito核心概念

1. 创建Mock对象

创建Mock对象有两种主要方式：

java

// 方法1：使用mock()方法
UserRepository mockRepository = mock(UserRepository.class);

// 方法2：使用@Mock注解（需要初始化注解）
@Mock
UserRepository mockRepository;

@BeforeEach
public void setUp() {
    MockitoAnnotations.openMocks(this);
}

2. 配置Mock行为

使用when()-thenReturn()模式配置Mock对象的行为：

java

// 当调用findById("123")时，返回一个指定的User对象
when(mockRepository.findById("123")).thenReturn(new User("123", "John", true));

// 可以配置同一方法对不同参数的不同返回值
when(mockRepository.findById("456")).thenReturn(new User("456", "Jane", false));

// 配置抛出异常
when(mockRepository.findById("999")).thenThrow(new RuntimeException("User not found"));

// 配置多次调用的不同返回值
when(mockRepository.getNextUser())
    .thenReturn(new User("1", "First", true))
    .thenReturn(new User("2", "Second", true))
    .thenReturn(new User("3", "Third", true));

3. 验证交互

验证被测代码是否按预期与Mock对象交互：

java

// 验证findById("123")被调用了
verify(mockRepository).findById("123");

// 验证findById("123")被调用了确切的1次
verify(mockRepository, times(1)).findById("123");

// 验证findById("456")从未被调用
verify(mockRepository, never()).findById("456");

// 验证至少被调用一次
verify(mockRepository, atLeastOnce()).saveUser(any(User.class));

// 验证调用顺序
InOrder inOrder = inOrder(mockRepository);
inOrder.verify(mockRepository).findById("123");
inOrder.verify(mockRepository).saveUser(any(User.class));

4. 参数匹配器

当我们不关心方法的确切参数值，或者需要更灵活的匹配时，可以使用参数匹配器：

java

// 匹配任意User对象
when(mockRepository.saveUser(any(User.class))).thenReturn(true);

// 匹配任意字符串
when(mockRepository.findById(anyString())).thenReturn(new User("default", "Default", true));

// 匹配特定条件
when(mockRepository.findByName(argThat(name -> name.startsWith("J"))))
    .thenReturn(Arrays.asList(new User("1", "John", true), new User("2", "Jane", true)));

5. 使用@InjectMocks注入Mock

当被测类有多个依赖需要注入时，可以使用@InjectMocks：

java

@Mock
private UserRepository userRepository;

@Mock
private EmailService emailService;

@InjectMocks
private UserService userService;

@BeforeEach
public void setUp() {
    MockitoAnnotations.openMocks(this);
}

高级Mock技巧

1. 模拟void方法

对于没有返回值的方法，可以使用doNothing()、doThrow()等：

java

// 对void方法不做任何操作（默认行为，可以省略）
doNothing().when(mockRepository).deleteUser("123");

// 让void方法抛出异常
doThrow(new IllegalArgumentException()).when(mockRepository).deleteUser("456");

// 验证void方法的调用
verify(mockRepository).deleteUser("123");

2. Spy对象

Spy是部分Mock，它可以保留原有对象的行为，只覆盖特定方法：

java

// 创建一个真实对象的Spy
UserRepository repositorySpy = spy(new UserRepositoryImpl());

// 覆盖特定方法的行为
when(repositorySpy.findById("123")).thenReturn(new User("123", "Spy User", true));

// 调用其他未覆盖的方法会使用真实实现
repositorySpy.saveUser(new User("456", "New User", false));

警告

使用spy时，要避免使用when(spy.method()).thenReturn()这种方式，因为这会调用真实方法。应该使用doReturn().when(spy).method()方式。

3. 捕获参数

有时我们需要验证传递给Mock对象的参数值：

java

// 创建参数捕获器
ArgumentCaptor<User> userCaptor = ArgumentCaptor.forClass(User.class);

// 执行被测方法
userService.updateUserStatus("123", true);

// 捕获参数
verify(mockRepository).saveUser(userCaptor.capture());

// 验证捕获的参数
User capturedUser = userCaptor.getValue();
assertEquals("123", capturedUser.getId());
assertTrue(capturedUser.isActive());

实际应用场景

场景1：测试数据库服务

假设我们有一个使用数据库的用户注册服务：

java

public class UserRegistrationService {
    private UserRepository userRepository;
    private EmailService emailService;
    
    public UserRegistrationService(UserRepository userRepository, EmailService emailService) {
        this.userRepository = userRepository;
        this.emailService = emailService;
    }
    
    public boolean registerUser(String username, String email, String password) {
        if (userRepository.existsByUsername(username)) {
            return false;
        }
        
        User newUser = new User(UUID.randomUUID().toString(), username, email, password, false);
        boolean saved = userRepository.saveUser(newUser);
        
        if (saved) {
            emailService.sendVerificationEmail(email, username);
            return true;
        }
        
        return false;
    }
}

测试代码：

java

@Test
public void testRegisterUser_Success() {
    // 创建Mock对象
    UserRepository mockRepo = mock(UserRepository.class);
    EmailService mockEmail = mock(EmailService.class);
    
    // 配置Mock行为
    when(mockRepo.existsByUsername("newuser")).thenReturn(false);
    when(mockRepo.saveUser(any(User.class))).thenReturn(true);
    
    // 创建被测服务
    UserRegistrationService service = new UserRegistrationService(mockRepo, mockEmail);
    
    // 执行测试
    boolean result = service.registerUser("newuser", "newuser@example.com", "password123");
    
    // 验证结果
    assertTrue(result);
    
    // 验证交互
    verify(mockRepo).existsByUsername("newuser");
    verify(mockRepo).saveUser(any(User.class));
    verify(mockEmail).sendVerificationEmail("newuser@example.com", "newuser");
}

@Test
public void testRegisterUser_DuplicateUsername() {
    UserRepository mockRepo = mock(UserRepository.class);
    EmailService mockEmail = mock(EmailService.class);
    
    // 用户名已存在
    when(mockRepo.existsByUsername("existinguser")).thenReturn(true);
    
    UserRegistrationService service = new UserRegistrationService(mockRepo, mockEmail);
    
    boolean result = service.registerUser("existinguser", "user@example.com", "pass123");
    
    assertFalse(result);
    verify(mockRepo).existsByUsername("existinguser");
    verify(mockRepo, never()).saveUser(any(User.class));
    verify(mockEmail, never()).sendVerificationEmail(anyString(), anyString());
}

场景2：测试外部API调用

假设我们有一个天气服务，依赖外部API获取数据：

java

public class WeatherService {
    private WeatherApiClient apiClient;
    
    public WeatherService(WeatherApiClient apiClient) {
        this.apiClient = apiClient;
    }
    
    public WeatherReport getWeatherReport(String city) {
        try {
            WeatherData data = apiClient.getWeatherData(city);
            return new WeatherReport(
                city,
                data.getTemperature(),
                data.getHumidity(),
                data.getWindSpeed(),
                "Sunny"  // 简化示例，实际应基于数据计算
            );
        } catch (ApiException e) {
            return new WeatherReport(city, 0, 0, 0, "Unknown");
        }
    }
}

测试代码：

java

@Test
public void testGetWeatherReport_Success() {
    // 创建Mock API客户端
    WeatherApiClient mockClient = mock(WeatherApiClient.class);
    
    // 配置Mock行为
    WeatherData mockData = new WeatherData(25.5, 60, 10.2);
    when(mockClient.getWeatherData("Beijing")).thenReturn(mockData);
    
    // 创建被测服务
    WeatherService service = new WeatherService(mockClient);
    
    // 执行测试
    WeatherReport report = service.getWeatherReport("Beijing");
    
    // 验证结果
    assertEquals("Beijing", report.getCity());
    assertEquals(25.5, report.getTemperature());
    assertEquals(60, report.getHumidity());
    assertEquals(10.2, report.getWindSpeed());
    
    // 验证API被调用
    verify(mockClient).getWeatherData("Beijing");
}

@Test
public void testGetWeatherReport_ApiFailure() {
    WeatherApiClient mockClient = mock(WeatherApiClient.class);
    
    // 配置API抛出异常
    when(mockClient.getWeatherData("InvalidCity")).thenThrow(new ApiException("City not found"));
    
    WeatherService service = new WeatherService(mockClient);
    
    // 执行测试
    WeatherReport report = service.getWeatherReport("InvalidCity");
    
    // 验证结果 - 应返回默认值
    assertEquals("InvalidCity", report.getCity());
    assertEquals(0, report.getTemperature());
    assertEquals("Unknown", report.getCondition());
}

Mock测试的最佳实践

1. 只Mock必要的依赖: 只模拟那些难以在测试环境中构造或控制的依赖，不要过度使用Mock。

2. 避免Mock被测类: Mock主要用于隔离外部依赖，而不是被测试的类本身。

3. 保持测试简单: 每个测试方法应专注于测试一个特定场景或行为。

4. Mock行为要符合实际: 配置Mock对象时，确保它们的行为与实际对象相似。

5. 适当验证交互: 不要仅仅验证方法返回值，也要验证与依赖的交互是否正确。

6. 使用参数捕获器进行复杂验证: 当需要详细验证方法参数时，使用ArgumentCaptor。

7. 避免使用PowerMock: 尽量不要模拟静态方法、最终类等，这通常表明设计可能存在问题。

总结

Mock测试是Java单元测试的重要技术，它能够帮助我们:

• 隔离测试单元: 通过模拟依赖，使测试更加专注和可控
• 提高测试速度: 避免真实依赖带来的执行开销
• 模拟各种场景: 包括正常流程、异常流程和边界条件
• 验证代码交互: 确保代码与其依赖的交互方式符合预期

Mockito作为Java生态系统中最流行的Mock框架，提供了强大而易用的API，使得编写Mock测试变得简单高效。通过本文介绍的基础知识和实际案例，你应该能够开始在项目中应用Mock测试技术，编写更加健壮和可维护的单元测试。

练习

为了巩固所学知识，请尝试完成以下练习：

1. 创建一个OrderService类，它依赖于ProductRepository和PaymentGateway，实现下单功能。
2. 为OrderService编写完整的单元测试，使用Mockito模拟其依赖。
3. 测试不同场景：
   • 订单成功处理
   • 产品库存不足
   • 支付失败
   • 产品不存在

学习资源

• Mockito官方文档
• Baeldung的Mockito教程
• 《Practical Unit Testing with JUnit and Mockito》- Tomek Kaczanowski
• 《Test-Driven Development: By Example》- Kent Beck