Java单元测试：如何验证和覆盖软删除Void方法的行为

public class UserService {
    private final UserRepository userRepository;

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

    public void deleteUser(String id) {
        var userEntity = userRepository.findById(Integer.valueOf(id))
                .orElseThrow(() -> new UserNotFoundException("Id not found"));
        if (userEntity.getLastAccessDate() == null) {
            throw new ProhibitedAccessException("Policy has been violated");
        }
        // 核心的软删除操作
        userRepository.delete(userEntity);
    }
}

public interface UserRepository extends JpaRepository<UserEntity, Integer> {
    @Modifying
    @Query("update UserEntity u set deleted = true where u = :userEntity")
    void delete(UserEntity userEntity);
}

@Test
void deleteUserTest(){
    final int id = 1;
    UserEntity userEntity = new UserEntity();
    // 假设用户未设置LastAccessDate，以便触发ProhibitedAccessException
    userEntity.setLastAccessDate(null); 

    var idString = String.valueOf(id);
    when(userRepository.findById(id)).thenReturn(Optional.of(userEntity));

    // 验证当LastAccessDate为null时，会抛出ProhibitedAccessException
    assertThrows(ProhibitedAccessException.class, () -> userService.deleteUser(idString));
}

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

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

import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

@ExtendWith(MockitoExtension.class)
class UserServiceTest {

    @Mock
    private UserRepository userRepository;

    @InjectMocks
    private UserService userService;

    @Test
    void deleteUser_shouldCallRepositoryDelete_whenPolicyAllows() {
        // 准备数据
        final int userId = 1;
        UserEntity userEntity = new UserEntity();
        userEntity.setId(userId);
        // 设置LastAccessDate，以允许删除操作通过策略检查
        userEntity.setLastAccessDate(LocalDateTime.now()); 

        String idString = String.valueOf(userId);

        // 模拟findById的行为
        when(userRepository.findById(userId)).thenReturn(Optional.of(userEntity));

        // 执行待测试方法
        userService.deleteUser(idString);

        // 验证：确保findById被调用一次
        verify(userRepository, times(1)).findById(userId);
        // 验证：确保delete方法在UserRepository上被调用一次，并且参数是userEntity
        verify(userRepository, times(1)).delete(userEntity); 
        // 也可以使用any()来匹配任何UserEntity实例，如果不需要精确匹配
        // verify(userRepository, times(1)).delete(any(UserEntity.class)); 
    }

    @Test
    void deleteUser_shouldThrowProhibitedAccessException_whenPolicyViolated() {
        // 准备数据
        final int userId = 2;
        UserEntity userEntity = new UserEntity();
        userEntity.setId(userId);
        // 设置LastAccessDate为null，以触发策略违规异常
        userEntity.setLastAccessDate(null); 

        String idString = String.valueOf(userId);

        // 模拟findById的行为
        when(userRepository.findById(userId)).thenReturn(Optional.of(userEntity));

        // 验证：抛出ProhibitedAccessException
        assertThrows(ProhibitedAccessException.class, () -> userService.deleteUser(idString));

        // 验证：findById被调用一次
        verify(userRepository, times(1)).findById(userId);
        // 验证：delete方法不应该被调用
        verify(userRepository, times(0)).delete(any(UserEntity.class)); 
    }
}

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
import org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager;

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

import static org.junit.jupiter.api.Assertions.assertTrue;

// 假设UserEntity和UserRepository已定义
// UserEntity.java
// @Entity
// public class UserEntity {
//     @Id @GeneratedValue private Integer id;
//     private String username;
//     private LocalDateTime lastAccessDate;
//     private boolean deleted; // 新增的软删除标志
//     // getters and setters
// }

@DataJpaTest // 启用JPA测试切片
class UserRepositoryIntegrationTest {

    @Autowired
    private UserRepository userRepository;

    @Autowired
    private TestEntityManager entityManager; // 用于直接操作数据库，如插入测试数据

    @Test
    void softDeleteUser_shouldSetDeletedFlagToTrue() {
        // Given: 准备一个未删除的用户实体并持久化到内存数据库
        UserEntity user = new UserEntity();
        user.setUsername("testuser");
        user.setLastAccessDate(LocalDateTime.now());
        user.setDeleted(false); // 初始状态为未删除

        // 使用TestEntityManager持久化，确保数据进入测试数据库
        user = entityManager.persistAndFlush(user); 
        Integer userId = user.getId();

        // When: 调用UserRepository的软删除方法
        userRepository.delete(user); // 这里调用的是带有@Modifying @Query的delete方法

        // 刷新EntityManager，确保事务中的更改被提交或同步到数据库
        entityManager.flush(); 
        entityManager.clear(); // 清除一级缓存，确保从数据库重新加载

        // Then: 验证用户的deleted标志是否已更新为true
        Optional<UserEntity> updatedUserOptional = userRepository.findById(userId);

        assertTrue(updatedUserOptional.isPresent(), "用户应该仍然存在于数据库中");
        assertTrue(updatedUserOptional.get().isDeleted(), "用户的deleted标志应该被设置为true");
    }
}