Java中如何有效测试包含私有方法的公共方法

// 假设的User实体类
class User {
    private String username;
    private String password;
    private Long id;

    public User(String username, String password) {
        this.username = username;
    }

    public User(String username, String password, Long id) {
        this.username = username;
        this.password = password;
        this.id = id;
    }

    public String getUsername() { return username; }
    public Long getId() { return id; }
    // ... 其他getter/setter
}

// 假设的UserRepository接口
interface UserRepository {
    boolean existsByUsername(String username);
    User save(User user);
}

// 假设的自定义异常
class UsernameUnavailableException extends RuntimeException {
    public UsernameUnavailableException(String message) { super(message); }
}

class UsernameIsInUseException extends RuntimeException {
    public UsernameIsInUseException(String message) { super(message); }
}

// 待测试的UserService类
public class UserService {
    private final UserRepository userRepository;

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

    public User create(User user) {
        checkUsername(user.getUsername()); // 公共方法调用私有方法
        return userRepository.save(user);
    }

    private void checkUsername(String username) {
        if (username.equals("dummy")) {
            String msg = String.format("Username = '%s is cannot be used!", username);
            throw new UsernameUnavailableException(msg);
        } else if (!userRepository.existsByUsername(username)) {
            return; // 用户名可用
        }

        String msg = String.format("Username ='s%s' is being used by another user!", username);
        throw new UsernameIsInUseException(msg);
    }
}

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

class UserServiceTest {

    @Mock // 模拟UserRepository接口
    private UserRepository userRepository;

    @InjectMocks // 将模拟的userRepository注入到UserService实例中
    private UserService userService;

    @BeforeEach
    void setUp() {
        // 初始化所有@Mock和@InjectMocks注解的字段
        MockitoAnnotations.openMocks(this);
    }

    @Test
    void create_shouldThrowUsernameUnavailableException_whenUsernameIsDummy() {
        User dummyUser = new User("dummy", "password");

        // 断言create方法会抛出特定的异常
        UsernameUnavailableException exception = assertThrows(UsernameUnavailableException.class, () -> {
            userService.create(dummyUser);
        });

        // 验证异常消息
        assertEquals("Username = 'dummy is cannot be used!", exception.getMessage());

        // 验证userRepository的任何方法都没有被调用
        // 这间接证明了checkUsername在抛出异常前没有与userRepository交互
        verifyNoInteractions(userRepository);
    }

    @Test
    void create_shouldThrowUsernameIsInUseException_whenUsernameExists() {
        User existingUser = new User("existingUser", "password");
        // 模拟当existsByUsername被调用时返回true，表示用户名已存在
        when(userRepository.existsByUsername("existingUser")).thenReturn(true);

        // 断言create方法会抛出特定的异常
        UsernameIsInUseException exception = assertThrows(UsernameIsInUseException.class, () -> {
            userService.create(existingUser);
        });

        // 验证异常消息
        assertEquals(String.format("Username ='s%s' is being used by another user!", existingUser.getUsername()), exception.getMessage());

        // 验证userRepository.existsByUsername方法被调用了一次
        verify(userRepository, times(1)).existsByUsername("existingUser");
        // 验证userRepository.save方法从未被调用
        verify(userRepository, never()).save(any(User.class));
    }

    @Test
    void create_shouldSaveUserSuccessfully_whenUsernameIsAvailable() {
        User newUser = new User("newUser", "password");
        User savedUser = new User("newUser", "password", 1L); // 模拟保存后的用户

        // 模拟当existsByUsername被调用时返回false，表示用户名可用
        when(userRepository.existsByUsername("newUser")).thenReturn(false);
        // 模拟当save方法被调用时返回一个已保存的用户对象
        when(userRepository.save(any(User.class))).thenReturn(savedUser);

        // 调用create方法
        User result = userService.create(newUser);

        // 断言结果不为空，且与预期保存的用户匹配
        assertNotNull(result);
        assertEquals(savedUser.getUsername(), result.getUsername());
        assertEquals(savedUser.getId(), result.getId());

        // 验证userRepository.existsByUsername方法被调用了一次
        verify(userRepository, times(1)).existsByUsername("newUser");
        // 验证userRepository.save方法被调用了一次，且参数是任何User对象
        verify(userRepository, times(1)).save(any(User.class));
    }
}