@MockBean
private IUserMapper userMapper;
@Autowired
private UserService userService;

@Test
void testGetAllUsers() {
    List<User> expectedUsers = Arrays.asList(
          UserVo.builder().username("zhangsan").id("1").build(),
          UserVo.builder().username("lisi").id("2").build(),
    );
    
    Mockito.when(userMapper.getAllUsers()).thenReturn(expectedUsers);
    
    List<User> actualUsers = userService.getAllUsers();
    
    assertEquals(expectedUsers, actualUsers);
    Mockito.verify(userMapper).getAllUsers();
}

@Test
void testGetUserById() {
    String userId = "1";
    User expectedUser = new User(userId, "John");
    
    Mockito.when(userMapper.getUserById(userId)).thenReturn(expectedUser);
    
    User actualUser = userService.getUserById(userId);
    
    assertEquals(expectedUser, actualUser);
    Mockito.verify(userMapper).getUserById(userId);
}

@Test
void testSaveUser() {
    User user = new User("1", "John");
    
    userService.saveUser(user);
    
    Mockito.verify(userMapper).saveUser(user);
}

@Test
void testDeleteUser() {
    String userId = "1";
    
    userService.deleteUser(userId);
    
    Mockito.verify(userMapper).deleteUser(userId);
}

@Test
void testGetUserById_NonExistingUser() {
    String userId = "1";
    
    Mockito.when(userMapper.getUserById(userId)).thenReturn(null);
    
    assertThrows(UserNotFoundException.class, () -> {
        userService.getUserById(userId);
    });
    
    Mockito.verify(userMapper).getUserById(userId);
}

@Test
void testSaveUser_NullUser() {
    assertThrows(IllegalArgumentException.class, () -> {
        userService.saveUser(null);
    });
    
    Mockito.verify(userMapper, Mockito.never()).saveUser(ArgumentMatchers.any());
}

}

<details>
<summary>#### 常用方法</summary>
##### mock(Class<*T*> classToMock) 
创建一个模拟对象，用于代替真实对象的行为。

```java
UserService userServiceMock = Mockito.mock(UserService.class);

when(mock.method()).thenReturn(value)

定义模拟对象方法的行为，指定当调用方法时应该返回的值。

// 定义当调用 getUserById 方法并传入参数 1 时，返回一个名为 "zhangsan" 的 User 对象
User user = UserVo.builder().username("zhangsan").id("1").build();
Mockito.when(userServiceMock.getUserById(1)).thenReturn(user);

verify(mock).method()

验证模拟对象的方法是否被调用。

// 验证 getUserById 方法是否被调用
Mockito.verify(userServiceMock).getUserById(1);

verify(mock, times(n)).method()

验证模拟对象的方法被调用了特定的次数（n）。

// 验证 getUserById 方法被调用了2次
Mockito.verify(userServiceMock, Mockito.times(2)).getUserById(1);

verify(mock, atLeast(n)).method()

验证模拟对象的方法被调用了至少n次。

// 验证 getUserById 方法被调用了至少3次
Mockito.verify(userServiceMock, Mockito.atLeast(3)).getUserById(1);

verify(mock, never()).method()

验证模拟对象的方法从未被调用。

// 验证 addUser 方法从未被调用
Mockito.verify(userServiceMock, Mockito.never()).addUser(Mockito.any(User.class));

verifyNoMoreInteractions(mock)

验证模拟对象上的所有方法已经被验证，并且没有其他未验证的方法调用。

// 验证 userServiceMock 上的所有方法已经被验证，并且没有其他未验证的方法调用
Mockito.verifyNoMoreInteractions(userServiceMock);

doThrow(exception).when(mock).method()

指定当调用模拟对象的方法时应该抛出的异常。

// 指定当调用 deleteUser 方法并传入任何参数时，抛出一个名为"UserNotFoundException"的异常
Mockito.doThrow(new UserNotFoundException()).when(userServiceMock).deleteUser(Mockito.anyInt());

doAnswer(answer).when(mock).method()

指定模拟对象方法的调用应该如何进行自定义处理，例如执行回调函数或返回动态计算的结果。

// 定义当调用 updateUser 方法时，执行自定义的逻辑来修改用户对象
Mockito.doAnswer(invocation -> {
    User userToUpdate = invocation.getArgument(0);
    // 执行自定义逻辑来更新用户对象
    userToUpdate.setName("Updated Name");
    return userToUpdate;
}).when(userServiceMock).updateUser(Mockito.any(User.class));

PowerMock

导入依赖

<dependency>
    <groupId>org.powermock</groupId>
    <artifactId>powermock-api-mockito2</artifactId>
    <version>2.0.9</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.powermock</groupId>
    <artifactId>powermock-module-junit4</artifactId>
    <version>2.0.9</version>
    <scope>test</scope>
</dependency>

    testImplementation 'org.powermock:powermock-api-mockito2:2.0.9'
    testImplementation 'org.powermock:powermock-module-junit4:2.0.9'

```java
package com.sbc.unittest;

import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;

import java.util.List;
import java.util.UUID;

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

/**
 * @ClassName TestClassTest
 * @Description powermock 测试类
 * @Author songbaicheng
 * @Date 2023/8/14 12:09
 */
@RunWith(PowerMockRunner.class)
@PrepareForTest({TestClass.class, UUID.class})
class TestClassTest {

    @Test
    public void testGetUUID() throws Exception {

        PowerMockito.mockStatic(UUID.class);
        PowerMockito.doReturn(new UUID(0L, 0L)).when(UUID.randomUUID());

        TestClass testClass = new TestClass();
        String uuid = testClass.getUUID();

//        PowerMockito.verifyStatic(UUID.class);

        assertEquals("00000000-0000-0000-0000-000000000000", uuid);
    }

    @Test
    public void testSoutArray() {
        TestClass testClass = PowerMockito.spy(new TestClass());

        List mockIntegers = PowerMockito.mock(List.class);
        PowerMockito.doReturn(mockIntegers).when(testClass).soutArray();

        testClass.soutArray();
    }
}