私有方法测试策略：行为驱动的间接验证与最佳实践

public class UserService {

    private 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)) {
            String msg = String.format("Username = '%s' is being used by another user!", username);
            throw new UsernameIsInUseException(msg);
        }
        // 如果用户名不存在且不为"dummy"，则继续
    }
}

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.*;

public class UserServiceTest {

    @Mock
    private UserRepository userRepository; // 模拟 UserRepository

    @InjectMocks
    private UserService userService; // 注入模拟对象到 UserService

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this); // 初始化模拟对象
    }

    @Test
    void create_shouldThrowUsernameUnavailableException_whenUsernameIsDummy() {
        // 1. 设置模拟行为 (此场景下，userRepository的方法不应被调用)
        // doNothing().when(userRepository).existsByUsername(anyString()); // 可以选择不设置，因为期望不被调用

        // 2. 执行待测方法
        User dummyUser = new User("dummy", "password");
        UsernameUnavailableException exception = assertThrows(
                UsernameUnavailableException.class,
                () -> userService.create(dummyUser)
        );

        // 3. 验证结果和交互
        assertEquals("Username = 'dummy' is cannot be used!", exception.getMessage());
        // 验证 userRepository 的方法未被调用
        verify(userRepository, never()).existsByUsername(anyString());
        verify(userRepository, never()).save(any(User.class));
    }

    @Test
    void create_shouldThrowUsernameIsInUseException_whenUsernameAlreadyExists() {
        // 1. 设置模拟行为：当调用 existsByUsername("existingUser") 时返回 true
        when(userRepository.existsByUsername("existingUser")).thenReturn(true);

        // 2. 执行待测方法
        User existingUser = new User("existingUser", "password");
        UsernameIsInUseException exception = assertThrows(
                UsernameIsInUseException.class,
                () -> userService.create(existingUser)
        );

        // 3. 验证结果和交互
        assertEquals("Username = 'existingUser' is being used by another user!", exception.getMessage());
        // 验证 existsByUsername 被调用一次，save 未被调用
        verify(userRepository, times(1)).existsByUsername("existingUser");
        verify(userRepository, never()).save(any(User.class));
    }

    @Test
    void create_shouldSaveUserSuccessfully_whenUsernameIsValidAndUnique() {
        // 1. 设置模拟行为：当调用 existsByUsername("newUser") 时返回 false，
        //    当调用 save(any(User.class)) 时返回传入的用户对象
        User newUser = new User("newUser", "password");
        when(userRepository.existsByUsername("newUser")).thenReturn(false);
        when(userRepository.save(any(User.class))).thenReturn(newUser);

        // 2. 执行待测方法
        User savedUser = userService.create(newUser);

        // 3. 验证结果和交互
        assertNotNull(savedUser);
        assertEquals("newUser", savedUser.getUsername());
        // 验证 existsByUsername 和 save 都被调用一次
        verify(userRepository, times(1)).existsByUsername("newUser");
        verify(userRepository, times(1)).save(any(User.class));
    }

    // 假设 User 类和 UserRepository 接口定义如下
    static class User {
        String username;
        String password;
        // 构造函数、getter/setter
        public User(String username, String password) {
            this.username = username;
            this.password = password;
        }
        public String getUsername() { return username; }
        public void setUsername(String username) { this.username = username; }
        public String getPassword() { return password; }
        public void setPassword(String password) { this.password = password; }
    }

    interface UserRepository {
        boolean existsByUsername(String username);
        User save(User user);
    }

    // 假设异常类定义如下
    static class UsernameUnavailableException extends RuntimeException {
        public UsernameUnavailableException(String message) { super(message); }
    }
    static class UsernameIsInUseException extends RuntimeException {
        public UsernameIsInUseException(String message) { super(message); }
    }
}