如何有效测试软删除（Soft-Delete）的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);
}

@ExtendWith(MockitoExtension.class)
class UserServiceTest {

    @Mock
    private UserRepository userRepository;

    @InjectMocks
    private UserService userService;

    @Test
    void deleteUserTest_ProhibitedAccess() {
        final int id = 1;
        UserEntity userEntity = new UserEntity(); // 默认lastAccessDate为null
        var idString = String.valueOf(id);

        when(userRepository.findById(id)).thenReturn(Optional.of(userEntity));

        // 预期抛出ProhibitedAccessException，因为lastAccessDate为null
        assertThrows(ProhibitedAccessException.class, () -> userService.deleteUser(idString));

        // 验证findById被调用，但delete方法不会被调用到
        verify(userRepository).findById(id);
        verify(userRepository, never()).delete(any(UserEntity.class));
    }
}

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.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;

@ExtendWith(MockitoExtension.class)
class UserServiceTest {

    @Mock
    private UserRepository userRepository;

    @InjectMocks
    private UserService userService;

    // 假设 UserEntity 和相关异常类已定义
    // ... (UserEntity, UserNotFoundException, ProhibitedAccessException 定义略)

    @Test
    void deleteUserTest_Success() {
        final int id = 1;
        UserEntity userEntity = new UserEntity();
        userEntity.setId(id);
        userEntity.setLastAccessDate(LocalDateTime.now()); // 设置非null的lastAccessDate

        var idString = String.valueOf(id);

        // 模拟findById返回一个合法的UserEntity
        when(userRepository.findById(id)).thenReturn(Optional.of(userEntity));

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

        // 验证findById方法被调用了一次，参数为id
        verify(userRepository, times(1)).findById(id);

        // 验证delete方法被调用了一次，参数为userEntity
        // 这是覆盖 userRepository.delete(userEntity) 的关键
        verify(userRepository, times(1)).delete(userEntity);

        // 确保没有其他交互（可选）
        verifyNoMoreInteractions(userRepository);
    }

    @Test
    void deleteUserTest_UserNotFound() {
        final int id = 2;
        var idString = String.valueOf(id);

        when(userRepository.findById(id)).thenReturn(Optional.empty());

        assertThrows(UserNotFoundException.class, () -> userService.deleteUser(idString));

        verify(userRepository, times(1)).findById(id);
        verify(userRepository, never()).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 org.springframework.test.context.ActiveProfiles;

import java.time.LocalDateTime;

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

@DataJpaTest // 用于测试JPA组件，如Repository
@ActiveProfiles("test") // 激活测试配置文件，可能指向H2内存数据库
class UserRepositoryIntegrationTest {

    @Autowired
    private UserRepository userRepository;

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

    @Test
    void softDeleteUserShouldSetDeletedFlagToTrue() {
        // 准备测试数据
        UserEntity user = new UserEntity();
        user.setName("Test User");
        user.setLastAccessDate(LocalDateTime.now());
        user.setDeleted(false); // 初始状态为未删除
        entityManager.persistAndFlush(user); // 插入并立即同步到数据库

        Integer userId = user.getId();
        assertNotNull(userId);
        assertFalse(userRepository.findById(userId).get().isDeleted()); // 确认初始状态

        // 执行软删除操作
        userRepository.delete(user); // 调用Repository的delete方法

        // 刷新EntityManager以确保所有挂起的更改都已同步到数据库
        entityManager.flush();
        // 清除EntityManager缓存，以确保从数据库重新加载最新的数据
        entityManager.clear();

        // 验证软删除是否成功
        Optional<UserEntity> deletedUserOptional = userRepository.findById(userId);
        assertTrue(deletedUserOptional.isPresent());
        assertTrue(deletedUserOptional.get().isDeleted()); // 断言deleted字段变为true
    }
}