Mockito模拟Optional返回值技巧

问题分析：Mockito与Optional的默认行为

在进行单元测试时，我们通常会使用Mocking框架（如Mockito）来隔离被测试单元（System Under Test, SUT）与外部依赖，确保测试的焦点仅在于SUT本身的逻辑。然而，当依赖的方法返回Optional类型时，如果不进行适当的模拟，可能会遇到意料之外的行为。

考虑以下服务层updateUser方法：

@Override
public UserDTO updateUser(String id, UserDTO updatedUser) {
    // 1. 根据updatedUser中的userName查找现有用户
    Optional databaseUser = userRepository.findById(Integer.valueOf(updatedUser.getUserName()));
    // 2. 如果用户不存在，抛出异常
    if (databaseUser.isEmpty()) {
        throw new UserNotFoundException("User with the this id is not found");
    }
    // 3. 映射DTO到实体
    UserEntity entity = mapToUserEntity(updatedUser);
    // 4. 保存更新后的实体
    return map(userRepository.save(entity));
}

该方法首先通过userRepository.findById()查询用户是否存在，如果不存在则抛出UserNotFoundException。

在编写updateUser方法的单元测试时，我们可能会遇到“User with the this id is not found”的异常，即使我们预期用户是存在的。这是因为Mockito在模拟对象时，对于返回复杂类型（如Optional、集合、自定义对象等）的方法，如果没有明确指定其行为，它会返回其类型的默认值。对于Optional，其默认值是Optional.empty()。

原始测试代码片段如下：

@Test
void updateUserTest(){
    // ... 用户DTO数据准备 ...

    // 模拟roleRepository.findById的行为
    when(roleRepository.findById(any())).thenReturn(Optional.of(new UserDTO().setId(roleId)));

    // 将userDto映射为UserEntity
    UserEntity userEntity = userService.mapToUserEntity(userDto);

    // 模拟userRepository.save的行为
    when(userRepository.save(any())).thenReturn(userEntity.setId(id));

    // 调用被测方法
    userService.updateUser(String.valueOf(id), userDto);
    var actualUser = userService.updateUser(String.valueOf(id), userDto); // 再次调用

    // ... 断言 ...
}

在这个测试中，userRepository.findById()方法并没有被显式地模拟（stub）。因此，当updateUser方法内部调用userRepository.findById(Integer.valueOf(updatedUser.getUserName()))时，Mockito会返回Optional.empty()。这导致databaseUser.isEmpty()判断为真，进而触发UserNotFoundException。

解决方案：显式Stubbing Optional返回值

要解决这个问题，核心在于明确告诉Mockito，当userRepository.findById()被调用时，它应该返回一个包含预期UserEntity的Optional对象，而不是默认的空Optional。

我们需要在调用userService.updateUser之前，添加对userRepository.findById的模拟。模拟时需要注意findById的参数类型，它接收一个Integer类型的ID。在我们的userDto中，userName被设置为"12"，因此Integer.valueOf(updatedUser.getUserName())会是12。

以下是正确的模拟方式：

// 1. 准备一个预期由findById返回的UserEntity实例
// 这个实例应该代表数据库中已存在的用户
UserEntity existingUserEntity = new UserEntity(); // 实际项目中应根据需要填充数据
existingUserEntity.setId(Integer.valueOf(userDto.getUserName())); // 确保ID与查询匹配
// ... 填充existingUserEntity的其他属性 ...

// 2. 模拟userRepository.findById的行为，使其返回包含existingUserEntity的Optional
when(userRepository.findById(Integer.valueOf(userDto.getUserName())))
    .thenReturn(Optional.of(existingUserEntity));

// 3. 模拟userRepository.save的行为（如果尚未模拟）
// 注意：userEntity是userService.mapToUserEntity(userDto)的结果，是将被保存的实体
UserEntity mappedUserEntity = userService.mapToUserEntity(userDto);
when(userRepository.save(any(UserEntity.class))).thenReturn(mappedUserEntity);

通过以上修改，当updateUser方法内部调用userRepository.findById(12)时，它将收到一个非空的Optional，从而跳过isEmpty()检查并继续执行后续的更新逻辑。

完整测试代码示例

为了提供一个更清晰、完整的测试示例，我们将整合上述修改，并对原始测试进行一些优化，例如避免重复调用被测方法。

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

import java.time.LocalDateTime;
import java.util.List;
import java.util.Optional;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.when;
import static org.mockito.Mockito.verify;

// 假设这些是你的Service, Repository和DTO类
// import com.example.service.UserService;
// import com.example.repository.UserRepository;
// import com.example.repository.RoleRepository;
// import com.example.dto.UserDTO;
// import com.example.entity.UserEntity;
// import com.example.exception.UserNotFoundException;

class UserServiceTest {

    @Mock
    private UserRepository userRepository;

    @Mock
    private RoleRepository roleRepository;

    @InjectMocks
    private UserService userService; // 假设UserService中包含mapToUserEntity和map方法

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
        // 如果UserService依赖于其他Service或组件，也需要在这里Mock并注入
        // 例如：userService = new UserService(userRepository, roleRepository, ...);
        // 或者使用 @Spy 来部分Mock真实对象
    }

    @Test
    void updateUser_shouldUpdateExistingUserSuccessfully() {
        // 1. 准备测试数据
        final int userId = 12; // 对应updatedUser.getUserName()
        final long roleId = 2L;

        UserDTO userDto = new UserDTO();
        userDto.setUserName(String.valueOf(userId)); // 用于findById的ID
        userDto.setId(String.valueOf(1)); // 外部传入的ID，通常与userName对应的ID一致或用于其他目的
        userDto.setName(new UserDTO.Name("surname", "firstname", "patronymic"));
        userDto.setActive(true);
        userDto.setEmails(List.of(new UserDTO.Email("email@example.com", "external")));
        userDto.setRoles(List.of(String.valueOf(roleId)));
        userDto.setLastAccessDate(LocalDateTime.of(2022, 10, 25, 4, 20));
        userDto.setUnit(null);

        // 2. 模拟依赖行为

        // 模拟 userRepository.findById() 返回一个已存在的UserEntity
        UserEntity existingUserEntity = new UserEntity();
        existingUserEntity.setId(userId); // 确保ID匹配
        existingUserEntity.setUserName(String.valueOf(userId));
        // ... 填充 existingUserEntity 的其他必要属性，使其在业务逻辑中有效 ...
        when(userRepository.findById(userId)).thenReturn(Optional.of(existingUserEntity));

        // 模拟 userService.mapToUserEntity() 的结果 (如果该方法是SUT的一部分，则不需要Mock)
        // 假设userService.mapToUserEntity是userService内部方法，直接调用即可
        UserEntity mappedUserEntity = userService.mapToUserEntity(userDto);
        // 如果mapToUserEntity是私有方法或难以直接调用，可以考虑Mock UserService本身或使用ArgumentCaptor

        // 模拟 userRepository.save() 返回保存后的UserEntity
        // 注意：这里返回的mappedUserEntity是期望被保存的实体，可能带上更新后的ID或版本
        when(userRepository.save(any(UserEntity.class))).thenReturn(mappedUserEntity);

        // 模拟 roleRepository.findById()
        when(roleRepository.findById(any())).thenReturn(Optional.of(new Object())); // 假设返回任意非空对象即可

        // 3. 调用被测方法
        UserDTO actualUserDto = userService.updateUser(String.valueOf(userDto.getId()), userDto);

        // 4. 验证结果
        assertNotNull(actualUserDto);
        // 验证返回的DTO是否符合预期，这里可以根据具体业务逻辑进行更细致的断言
        // 例如：assertEquals(userDto.getName().getFirstName(), actualUserDto.getName().getFirstName());
        // 如果userService.map方法会改变DTO，则不能直接比较userDto和actualUserDto
        // 简单起见，这里假设它们是等价的，或者至少某些关键属性是等价的
        assertEquals(userDto.getUserName(), actualUserDto.getUserName());
        assertEquals(userDto.getEmails().get(0).getValue(), actualUserDto.getEmails().get(0).getValue());

        // 验证 userRepository.findById 和 userRepository.save 是否被调用
        verify(userRepository).findById(userId);
        verify(userRepository).save(any(UserEntity.class));
    }

    // 假设UserService中存在这些辅助方法用于测试
    // 实际项目中，这些方法可能在UserService内部或独立的Mapper类中
    private static class UserService {
        private UserRepository userRepository;
        private RoleRepository roleRepository;

        // 构造函数用于注入Mock
        public UserService(UserRepository userRepository, RoleRepository roleRepository) {
            this.userRepository = userRepository;
            this.roleRepository = roleRepository;
        }

        // 模拟的mapToUserEntity方法
        public UserEntity mapToUserEntity(UserDTO dto) {
            UserEntity entity = new UserEntity();
            entity.setId(Integer.valueOf(dto.getUserName())); // 假设userName是ID
            entity.setFirstName(dto.getName().getFirstName());
            entity.setLastName(dto.getName().getLastName());
            entity.setEmail(dto.getEmails().get(0).getValue());
            entity.setActive(dto.isActive());
            entity.setLastAccessDate(dto.getLastAccessDate());
            // ... 其他属性映射 ...
            return entity;
        }

        // 模拟的map方法
        public UserDTO map(UserEntity entity) {
            UserDTO dto = new UserDTO();
            dto.setId(String.valueOf(entity.getId()));
            dto.setUserName(String.valueOf(entity.getId())); // 假设userName和ID一致
            dto.setName(new UserDTO.Name(entity.getLastName(), entity.getFirstName(), ""));
            dto.setActive(entity.isActive());
            dto.setEmails(List.of(new UserDTO.Email(entity.getEmail(), "external")));
            dto.setLastAccessDate(entity.getLastAccessDate());
            // ... 其他属性映射 ...
            return dto;
        }

        // 实际的updateUser方法，与问题描述中相同
        public UserDTO updateUser(String id, UserDTO updatedUser) {
            Optional databaseUser = userRepository.findById(Integer.valueOf(updatedUser.getUserName()));
            if (databaseUser.isEmpty()) {
                throw new UserNotFoundException("User with the this id is not found");
            }
            UserEntity entity = mapToUserEntity(updatedUser);
            return map(userRepository.save(entity));
        }
    }

    // 模拟的UserDTO类及其内部类
    private static class UserDTO {
        private String id;
        private String userName;
        private Name name;
        private boolean active;
        private List emails;
        private List roles;
        private LocalDateTime lastAccessDate;
        private Object unit; // 假设unit是Object类型

        // Getters and Setters
        public String getId() { return id; }
        public UserDTO setId(String id) { this.id = id; return this; }
        public String getUserName() { return userName; }
        public void setUserName(String userName) { this.userName = userName; }
        public Name getName() { return name; }
        public void setName(Name name) { this.name = name; }
        public boolean isActive() { return active; }
        public void setActive(boolean active) { this.active = active; }
        public List getEmails() { return emails; }
        public void setEmails(List emails) { this.emails = emails; }
        public List getRoles() { return roles; }
        public void setRoles(List roles) { this.roles = roles; }
        public LocalDateTime getLastAccessDate() { return lastAccessDate; }
        public void setLastAccessDate(LocalDateTime lastAccessDate) { this.lastAccessDate = lastAccessDate; }
        public Object getUnit() { return unit; }
        public void setUnit(Object unit) { this.unit = unit; }

        public static class Name {
            private String surname;
            private String firstname;