first commit

tj

2025-06-05 2d549a04870d1315868a7cf19952b64e8071e711

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
package com.cloudroam.service.impl;
 
import com.cloudroam.mapper.GroupMapper;
import com.cloudroam.mapper.GroupPermissionMapper;
import com.cloudroam.mapper.PermissionMapper;
import com.cloudroam.model.GroupDO;
import com.cloudroam.model.GroupPermissionDO;
import com.cloudroam.model.PermissionDO;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.transaction.annotation.Transactional;
 
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
 
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
 
 
@SpringBootTest
@Transactional
@Rollback
@Slf4j
@ActiveProfiles("test")
public class PermissionServiceImplTest {
 
    @Autowired
    private PermissionServiceImpl permissionService;
 
    @Autowired
    private GroupMapper groupMapper;
 
    @Autowired
    private PermissionMapper permissionMapper;
 
    @Autowired
    private GroupPermissionMapper groupPermissionMapper;
 
    public Integer mockData() {
        GroupDO group = GroupDO.builder().name("测试分组1").info("just for test").build();
        PermissionDO permission1 = PermissionDO.builder().name("权限1").module("炉石传说").build();
        PermissionDO permission2 = PermissionDO.builder().name("权限2").module("炉石传说").build();
        groupMapper.insert(group);
        permissionMapper.insert(permission1);
        permissionMapper.insert(permission2);
        List<GroupPermissionDO> relations = new ArrayList<>();
        GroupPermissionDO relation1 = new GroupPermissionDO(group.getId(), permission1.getId());
        GroupPermissionDO relation2 = new GroupPermissionDO(group.getId(), permission2.getId());
        relations.add(relation1);
        relations.add(relation2);
        groupPermissionMapper.insertBatch(relations);
        return group.getId();
    }
 
    @Test
    public void getPermissionByGroupId() {
        Integer id = mockData();
        List<PermissionDO> permissions = permissionService.getPermissionByGroupId(id);
        assertTrue(permissions.size() > 0);
        boolean anyMatch = permissions.stream().anyMatch(permission -> permission.getName().equals("权限2"));
        assertTrue(anyMatch);
    }
 
    @Test
    public void getPermissionByGroupIds() {
        Integer id = mockData();
        List<PermissionDO> permissions = permissionService.getPermissionByGroupIds(Collections.singletonList(id));
        assertTrue(permissions.size() > 0);
        boolean anyMatch = permissions.stream().anyMatch(permission -> permission.getName().equals("权限2"));
        assertTrue(anyMatch);
    }
 
    @Test
    public void getPermissionMapByGroupIds() {
        Integer id = mockData();
        Map<Long, List<PermissionDO>> map = permissionService.getPermissionMapByGroupIds(Collections.singletonList(id));
        assertNotNull(map.get(id));
        boolean anyMatch = map.get(id).stream().anyMatch(permission -> permission.getName().equals("权限2"));
        assertTrue(anyMatch);
    }
 
    @Test
    public void structuringPermissions() {
        Integer id = mockData();
        List<PermissionDO> permissions = permissionService.getPermissionByGroupIds(Collections.singletonList(id));
        List<Map<String, List<Map<String, String>>>> structuringPermissions = permissionService.structuringPermissions(permissions);
        assertTrue(structuringPermissions.size() > 0);
        log.info("structuringPermissions: {}", structuringPermissions);
        boolean anyMatch = structuringPermissions.stream().anyMatch(it -> it.containsKey("炉石传说"));
        assertTrue(anyMatch);
    }
 
    @Test
    public void structuringPermissionsSimply() {
        Integer id = mockData();
        List<PermissionDO> permissions = permissionService.getPermissionByGroupIds(Collections.singletonList(id));
        Map<String, List<String>> structuringPermissions = permissionService.structuringPermissionsSimply(permissions);
        assertTrue(structuringPermissions.size() > 0);
        assertTrue(structuringPermissions.containsKey("炉石传说"));
        log.info("structuringPermissions: {}", structuringPermissions);
    }
}