单元测试#

1
<dependency>
2
    <groupId>org.mockito</groupId>
3
    <artifactId>mockito-core</artifactId>
4
    <scope>test</scope>
5
</dependency>

1
testImplementation 'org.mockito:mockito-core:<version>'

1
@Data
2
@Builder
3
public class User {
4
    private String id;
5
    private String username;
6
}

1
@Repository
2
public interface IUserMapper {
3
    List<User> getAllUsers();
4

5
    User getUserById(String id);
6

7
    void saveUser(User user);
8

9
    void deleteUser(String id);
10
}

1
@Service
2
public class UserService {
3

4
    @Autowired
5
    private IUserMapper userMapper;
6

7
    public List<User> getAllUsers() {
8
        return userMapper.getAllUsers();
9
    }
10

11
    public User getUserById(String id) {
12
        return userMapper.getUserById(id);
13
    }
14

15
    public void saveUser(User user) {
16
        userMapper.saveUser(user);
17
    }
18

19
    public void deleteUser(String id) {
20
        userMapper.deleteUser(id);
21
    }
22
}

1
@SpringBootTest
2
class UserServiceTest {
3

4
    @MockBean
5
    private IUserMapper userMapper;
6
    @Autowired
7
    private UserService userService;
8

9
    @Test
10
    void testGetAllUsers() {
11
        List<User> expectedUsers = Arrays.asList(
12
              UserVo.builder().username("zhangsan").id("1").build(),
13
              UserVo.builder().username("lisi").id("2").build(),
14
        );
15

16
        Mockito.when(userMapper.getAllUsers()).thenReturn(expectedUsers);
17

18
        List<User> actualUsers = userService.getAllUsers();
19

20
        assertEquals(expectedUsers, actualUsers);
21
        Mockito.verify(userMapper).getAllUsers();
22
    }
23

24
    @Test
25
    void testGetUserById() {
26
        String userId = "1";
27
        User expectedUser = new User(userId, "John");
28

29
        Mockito.when(userMapper.getUserById(userId)).thenReturn(expectedUser);
30

31
        User actualUser = userService.getUserById(userId);
32

33
        assertEquals(expectedUser, actualUser);
34
        Mockito.verify(userMapper).getUserById(userId);
35
    }
36

37
    @Test
38
    void testSaveUser() {
39
        User user = new User("1", "John");
40

41
        userService.saveUser(user);
42

43
        Mockito.verify(userMapper).saveUser(user);
44
    }
45

46
    @Test
47
    void testDeleteUser() {
48
        String userId = "1";
49

50
        userService.deleteUser(userId);
51

52
        Mockito.verify(userMapper).deleteUser(userId);
53
    }
54

55
    @Test
56
    void testGetUserById_NonExistingUser() {
57
        String userId = "1";
58

59
        Mockito.when(userMapper.getUserById(userId)).thenReturn(null);
60

61
        assertThrows(UserNotFoundException.class, () -> {
62
            userService.getUserById(userId);
63
        });
64

65
        Mockito.verify(userMapper).getUserById(userId);
66
    }
67

68
    @Test
69
    void testSaveUser_NullUser() {
70
        assertThrows(IllegalArgumentException.class, () -> {
71
            userService.saveUser(null);
72
        });
73

74
        Mockito.verify(userMapper, Mockito.never()).saveUser(ArgumentMatchers.any());
75
    }
76
}

1
<dependency>
2
    <groupId>org.powermock</groupId>
3
    <artifactId>powermock-api-mockito2</artifactId>
4
    <version>2.0.9</version>
5
    <scope>test</scope>
6
</dependency>
7
<dependency>
8
    <groupId>org.powermock</groupId>
9
    <artifactId>powermock-module-junit4</artifactId>
10
    <version>2.0.9</version>
11
    <scope>test</scope>
12
</dependency>

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

1
import java.util.ArrayList;
2
import java.util.List;
3
import java.util.UUID;
4

5
/**
6
 * @ClassName TestClass
7
 * @Description 测试 PowerMock 类
8
 */
9
public class TestClass {
10

11
    public String getUUID() {
12
        return UUID.randomUUID().toString();
13
    }
14

15
    public List<Integer> soutArray() {
16

17
        return new ArrayList<Integer>() {
18
            {
19
                add(2);
20
            }
21
        };
22
    }
23
}

1
package com.sbc.unittest;
2

3
import org.junit.jupiter.api.Test;
4
import org.junit.runner.RunWith;
5
import org.powermock.api.mockito.PowerMockito;
6
import org.powermock.core.classloader.annotations.PrepareForTest;
7
import org.powermock.modules.junit4.PowerMockRunner;
8

9
import java.util.List;
10
import java.util.UUID;
11

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

14
/**
15
 * @ClassName TestClassTest
16
 * @Description powermock 测试类
17
 * @Author songbaicheng
18
 * @Date 2023/8/14 12:09
19
 */
20
@RunWith(PowerMockRunner.class)
21
@PrepareForTest({TestClass.class, UUID.class})
22
class TestClassTest {
23

24
    @Test
25
    public void testGetUUID() throws Exception {
26

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

30
        TestClass testClass = new TestClass();
31
        String uuid = testClass.getUUID();
32

33
//        PowerMockito.verifyStatic(UUID.class);
34

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

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

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

45
        testClass.soutArray();
46
    }
47
}