问题分析：Mockito与Optional的默认行为
在进行单元测试时，我们通常会使用mocking框架（如mockito）来隔离被测试单元（system under test, sut）与外部依赖，确保测试的焦点仅在于sut本身的逻辑。然而，当依赖的方法返回optional类型时，如果不进行适当的模拟，可能会遇到意料之外的行为。
考虑以下服务层updateUser方法：
@Override
public UserDTO updateUser(String id, UserDTO updatedUser) {
// 1. 根据updatedUser中的userName查找现有用户
Optional<UserEntity> 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。
Web Accessibility (WCAG 2 AA))
下载
将 WCAG 2 AA 无障碍标准应用于设计系统、UI 组件和网页——通过可运行的验证器进行对比度计算，采用设计 token 模式使颜色天生可访问，设定排版和焦点状态规则，并提供语义检查清单。适用于构建或审查 UI。
解决方案：显式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<UserEntity> 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<Email> emails;
private List<String> 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<Email> getEmails() { return emails; }
public void setEmails(List<Email> emails) { this.emails = emails; }
public List<String> getRoles() { return roles; }
public void setRoles(List<String> 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; 
