Java Spring Boot中软删除Void方法的全面测试策略

import org.junit.jupiter.api.BeforeEach;
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.util.Date;
import java.util.Optional;

import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.*;

@ExtendWith(MockitoExtension.class)
class UserServiceTest {

    @Mock
    private UserRepository userRepository; // 模拟UserRepository

    @InjectMocks
    private UserService userService; // 注入被测试的UserService

    private UserEntity testUser;
    private final String TEST_USER_ID = "1";

    @BeforeEach
    void setUp() {
        testUser = new UserEntity();
        testUser.setId(Integer.valueOf(TEST_USER_ID));
        testUser.setName("Test User");
        // 初始状态，通常为未删除
        testUser.setDeleted(false);
    }

    /**
     * 测试：当用户有效且满足访问策略时，userService应成功调用userRepository的delete方法。
     */
    @Test
    void deleteUser_shouldCallRepositoryDelete_whenValidUserAndAccessDate() {
        // Arrange
        testUser.setLastAccessDate(new Date()); // 设置lastAccessDate以满足策略

        // 模拟userRepository.findById行为
        when(userRepository.findById(Integer.valueOf(TEST_USER_ID)))
                .thenReturn(Optional.of(testUser));

        // Act
        userService.deleteUser(TEST_USER_ID);

        // Assert
        // 验证userRepository.findById是否被调用了一次
        verify(userRepository, times(1)).findById(Integer.valueOf(TEST_USER_ID));
        // 验证userRepository.delete是否被调用了一次，并且传入的是正确的userEntity对象
        verify(userRepository, times(1)).delete(testUser);
    }

    /**
     * 测试：当用户不存在时，userService应抛出UserNotFoundException。
     */
    @Test
    void deleteUser_shouldThrowUserNotFoundException_whenUserNotFound() {
        // Arrange
        when(userRepository.findById(Integer.valueOf(TEST_USER_ID)))
                .thenReturn(Optional.empty()); // 模拟用户不存在

        // Act & Assert
        assertThrows(UserNotFoundException.class, () -> userService.deleteUser(TEST_USER_ID));

        // 验证userRepository.delete方法没有被调用
        verify(userRepository, never()).delete(any(UserEntity.class));
    }

    /**
     * 测试：当用户不满足访问策略（lastAccessDate为null）时，userService应抛出ProhibitedAccessException。
     */
    @Test
    void deleteUser_shouldThrowProhibitedAccessException_whenNoLastAccessDate() {
        // Arrange
        testUser.setLastAccessDate(null); // 设置lastAccessDate为null以违反策略

        when(userRepository.findById(Integer.valueOf(TEST_USER_ID)))
                .thenReturn(Optional.of(testUser));

        // Act & Assert
        assertThrows(ProhibitedAccessException.class, () -> userService.deleteUser(TEST_USER_ID));

        // 验证userRepository.delete方法没有被调用
        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 java.util.Date;
import java.util.Optional;

import static org.assertj.core.api.Assertions.assertThat;

// @DataJpaTest注解用于测试JPA组件。它会配置一个in-memory数据库（如H2）
// 并自动扫描@Entity和Spring Data JPA仓库。
@DataJpaTest
class UserRepositoryIntegrationTest {

    @Autowired
    private UserRepository userRepository; // 注入真实的UserRepository

    @Autowired
    private TestEntityManager entityManager; // 用于在测试中管理实体（持久化、查找、刷新等）

    /**
     * 测试：验证userRepository的delete方法是否正确执行软删除操作。
     */
    @Test
    void delete_shouldSoftDeleteUser() {
        // Arrange
        // 创建一个UserEntity实例并设置初始状态
        UserEntity user = new UserEntity();
        user.setName("Integration Test User");
        user.setDeleted(false); // 初始状态为未删除
        user.setLastAccessDate(new Date()); // 设置一个日期，虽然对于仓库测试不严格需要，但保持一致性

        // 使用TestEntityManager持久化用户到in-memory数据库
        UserEntity persistedUser = entityManager.persistAndFlush(user);
        // 清除EntityManager缓存，确保后续从数据库中获取的是最新状态
        entityManager.clear();

        // Act
        // 从数据库中重新获取用户，确保操作的是一个受管理的实体
        Optional<UserEntity> userOptional = userRepository.findById(persistedUser.getId());
        assertThat(userOptional).isPresent();
        UserEntity userToDelete = userOptional.get();

        // 调用userRepository的delete方法执行软删除
        userRepository.delete(userToDelete);
        // 刷新EntityManager，确保SQL语句被执行到数据库
        entityManager.flush();

        // Assert
        // 再次从数据库中查找用户，验证其deleted字段是否已更新为true
        UserEntity softDeletedUser = entityManager.find(UserEntity.class, persistedUser.getId());

        assertThat(softDeletedUser).isNotNull();
        assertThat(softDeletedUser.isDeleted()).isTrue(); // 断言软删除成功
        assertThat(softDeletedUser.getName()).isEqualTo("Integration Test User"); // 其他字段应保持不变
    }

    /**
     * 额外测试：验证软删除的用户是否可以被正确查询（如果你的查询排除了软删除用户）。
     * （这取决于你的findById或findAll方法是否考虑deleted字段）
     */
    @Test
    void findById_shouldReturnSoftDeletedUser_whenNotFiltered() {
        // Arrange
        UserEntity user = new UserEntity();
        user.setName("Another Test User");
        user.setDeleted(false);
        user.setLastAccessDate(new Date());
        UserEntity persistedUser = entityManager.persistAndFlush(user);
        entityManager.clear();

        UserEntity userToDelete = userRepository.findById(persistedUser.getId()).orElseThrow();
        userRepository.delete(userToDelete);
        entityManager.flush();
        entityManager.clear();

        // Act
        Optional<UserEntity> foundUser = userRepository.findById(persistedUser.getId());

        // Assert
        // 默认的findById不会过滤deleted=true的，所以应该还能找到
        assertThat(foundUser).isPresent();
        assertThat(foundUser.get().isDeleted()).isTrue();
    }
}