feat(权限): admin_companies 从可见/可授予集合摘掉,提交时剥离不报错

This commit is contained in:
2026-10-04 20:55:43 +08:00
parent 898a8e2258
commit 5717efac92
2 changed files with 377 additions and 1 deletions
@@ -0,0 +1,309 @@
package com.nanri.aiimage.modules.permission;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatCode;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.argThat;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.nanri.aiimage.common.mapper.AdminUserMapper;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.modules.permission.mapper.PermissionMenuMapper;
import com.nanri.aiimage.modules.permission.mapper.UserColumnPermissionMapper;
import com.nanri.aiimage.modules.permission.model.dto.UserColumnPermissionUpdateRequest;
import com.nanri.aiimage.modules.permission.model.entity.PermissionMenuEntity;
import com.nanri.aiimage.modules.permission.model.entity.UserColumnPermissionEntity;
import com.nanri.aiimage.modules.permission.model.vo.PermissionMenuItemVo;
import com.nanri.aiimage.modules.permission.service.PermissionMenuService;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
/**
* admin_companies 只能由角色内在闸门管(设计文档 §8.1 的三处出口)。
*
* <p>菜单行本身要**留着**(历史 user_column_permission 数据无处安放,且「菜单管理」页还得能看见它),
* 所以断言的是"从可授予集合摘掉 + 提交时剥离",不是"库里删行"。</p>
*
* <p>两支源码扫描是绊线(防"三处出口里少了一处"),但源码文本判不出闸门是真在跑还是被写成
* {@code if (false)},所以同一文件里另有三支实跑用例 B1/B2/B3,逐个出口正反两面都钉:</p>
* <ul>
* <li>B1 出口 1(授权树 {@code list}):grantableOnly=true 时连超管都拿不到这一项(授不出去),
* grantableOnly=false(菜单管理页)时必须照旧看得到(这一行没被从目录里删掉)。</li>
* <li>B2 出口 2(当前用户有效菜单 {@code getUserColumnPermissions}):非超管历史上被授过也不下发,
* 但它的父分组与同组兄弟页必须原样保留——"顺手剪掉整组"是把用户管理页弄红的经典改法。</li>
* <li>B3 出口 3(提交授权 {@code updateUserColumnPermissions}):带这条 id 的整树提交必须
* 保存成功(绝不 403,09-16 的形状),只剥掉这一项,其余照常落库,且它绝不进"要删除"集合。</li>
* </ul>
*/
class PermissionCompanyMenuHiddenTest {
private static final String SERVICE = "PermissionMenuService.java";
private static final String KEY = "admin_companies";
/** 生产实查(2026-10 只读取证):这条菜单行 id=109,父分组 id=98,route_path=account/companies。 */
private static final Long GROUP_ID = 98L;
private static final Long COMPANY_MENU_ID = 109L;
private static final Long SIBLING_PAGE_ID = 110L;
/**
* MyBatis-Plus 的 lambda 列解析要实体的 TableInfo;本类不启动 Spring,而
* {@code loadRawMenus} 用 {@code LambdaQueryWrapper<PermissionMenuEntity>}、
* 授权落库前的有效性校验用 {@code .in(PermissionMenuEntity::getId, ...)},
* 级联清理与可授权用户查询用 {@code select(AdminUserEntity::getId, ...)}
* (静态缓存会被同 JVM 内先跑的其它用例顺带填上,所以必须显式初始化,否则单独跑本类就
* 「can not find lambda cache」)。同款初始化见 PermissionMenuServiceTest。
*/
@BeforeAll
static void initMybatisPlusTableInfo() {
MapperBuilderAssistant assistant = new MapperBuilderAssistant(new MybatisConfiguration(), "");
TableInfoHelper.initTableInfo(assistant, AdminUserEntity.class);
TableInfoHelper.initTableInfo(assistant, PermissionMenuEntity.class);
}
// ---------------------------------------------------------------- 源码扫描绊线
private String source() throws IOException {
Path root = Path.of("src/main/java/com/nanri/aiimage/modules/permission/service");
assertThat(root).as("用例依赖以 backend-java 为工作目录运行,别让守卫静默通过").isDirectory();
String text = Files.readString(root.resolve(SERVICE), StandardCharsets.UTF_8);
assertThat(text).as("扫描取样集非空自检").contains("getUserColumnPermissions");
return text;
}
@Test
void threeExitsAllReferenceTheSuperAdminOnlySet() throws IOException {
String text = source();
assertThat(text).contains("SUPER_ADMIN_ONLY_KEYS");
// 三个出口各自都要引用它:漏一个就留一条旁路(授权树能看见 / 当前用户菜单能带出 / 提交能写回)。
assertThat(text.split("SUPER_ADMIN_ONLY_KEYS", -1).length - 1)
.as("SUPER_ADMIN_ONLY_KEYS 至少被引用 4 次(1 次定义 + 3 处出口)")
.isGreaterThanOrEqualTo(4);
}
@Test
void grantIsStrippedInsteadOfRejected() throws IOException {
String text = source();
// 整树提交里带一个历史 admin_companies 绝不能 403:那会让"改密码/建号"这条链整体回滚(09-16 的形状)。
// 注:本仓库 AssertJ 无 doesNotContainMatch,这里用等价的 doesNotContainPattern(同为正则不匹配)。
assertThat(text).doesNotContainPattern("(?s)ensureGrantable[\\s\\S]{0,600}admin_companies[\\s\\S]{0,200}BusinessException");
assertThat(text).contains("log.warn");
}
// ---------------------------------------------------------------- B1:出口 1(授权树)
/**
* 出口 1 双向钉:授权树(grantableOnly=true)里连**超管**都拿不到这一项——超管自己都授不出去,
* 才堵死"从授权树把它勾给员工"这条旁路;而菜单管理页(grantableOnly=false)必须照旧看得到、
* 改得动这一行(菜单行留在库里,Task 4 不删行)。父分组与兄弟页不受影响。
*/
@Test
void grantTreeDropsSuperAdminOnlyMenuEvenForSuperAdminButCatalogKeepsIt() {
PermissionMenuMapper menuMapper = mock(PermissionMenuMapper.class);
UserColumnPermissionMapper permissionMapper = mock(UserColumnPermissionMapper.class);
AdminUserMapper userMapper = mock(AdminUserMapper.class);
PermissionMenuService service = new PermissionMenuService(menuMapper, permissionMapper, userMapper);
when(menuMapper.selectList(any())).thenReturn(catalog());
AdminUserEntity superAdmin = user(31L, "super_admin", 1);
List<PermissionMenuItemVo> grantTree = service.list(superAdmin, "admin", true);
assertThat(grantTree).extracting(PermissionMenuItemVo::getId)
.as("超管的授权树里也没有这条:谁也授不出去")
.doesNotContain(COMPANY_MENU_ID);
assertThat(grantTree).extracting(PermissionMenuItemVo::getId)
.as("父分组与同组兄弟页必须留着,否则整组被剪掉")
.containsExactly(GROUP_ID, SIBLING_PAGE_ID);
assertThat(grantTree).extracting(PermissionMenuItemVo::getColumnKey)
.doesNotContain(KEY);
List<PermissionMenuItemVo> catalogWithoutFilter = service.list(superAdmin, "admin", false);
assertThat(catalogWithoutFilter).extracting(PermissionMenuItemVo::getId)
.as("菜单管理页仍能管理这一行(不删行、不藏行)")
.contains(COMPANY_MENU_ID);
assertThat(service.list("admin")).extracting(PermissionMenuItemVo::getId)
.as("无操作者的目录查询同样保留")
.contains(COMPANY_MENU_ID);
}
// ---------------------------------------------------------------- B2:出口 2(当前用户菜单)
/**
* 出口 2:非超管历史上被授过这条也不下发(前端拿不到 key,侧边栏与守卫都无从显示)。
*
* <p>同时钉住两件不能被顺手弄坏的事:它的父分组仍随 {@code includeAncestorGroups=true} 下发,
* 同组兄弟页完全不受影响;以及喂给 {@code toItemVos} 的第二个参数(层级表)必须仍是全量目录——
* 一旦换成剪过的集合,只勾了子页面的用户({@code includeAncestorGroups=false} 那条路径,
* 父分组不在下发列表里)就解析不出父分组,rootColumnKey 退化成自己、侧边栏再也挂不上组。
* 下面那段 flat 断言钉的就是这一条,变异 R5 验过它真的会红。</p>
*/
@Test
void effectiveMenusForNonSuperAdminExcludeLegacyGrantButKeepGroupAndSibling() {
PermissionMenuMapper menuMapper = mock(PermissionMenuMapper.class);
UserColumnPermissionMapper permissionMapper = mock(UserColumnPermissionMapper.class);
AdminUserMapper userMapper = mock(AdminUserMapper.class);
PermissionMenuService service = new PermissionMenuService(menuMapper, permissionMapper, userMapper);
when(menuMapper.selectList(any())).thenReturn(catalog());
when(userMapper.selectById(7L)).thenReturn(user(7L, "admin", 1));
when(permissionMapper.selectByUserId(7L)).thenReturn(List.of(
grant(7L, COMPANY_MENU_ID), // 历史上被超管授过的直接授权(生产实查为 0 条,形状要钉住)
grant(7L, SIBLING_PAGE_ID)));
List<PermissionMenuItemVo> items = service.getUserColumnPermissions(null, 7L, "admin", true);
assertThat(items).extracting(PermissionMenuItemVo::getColumnKey)
.as("非超管即使被授过也不下发")
.doesNotContain(KEY);
assertThat(items).extracting(PermissionMenuItemVo::getId)
.doesNotContain(COMPANY_MENU_ID);
assertThat(items).extracting(PermissionMenuItemVo::getId)
.as("祖先分组与兄弟页都不能被连带剪掉")
.containsExactlyInAnyOrder(GROUP_ID, SIBLING_PAGE_ID);
assertThat(items.stream()
.filter(item -> SIBLING_PAGE_ID.equals(item.getId()))
.map(PermissionMenuItemVo::getRootColumnKey)
.toList())
.as("层级表仍是全量目录:兄弟页的根分组键要能解析出来")
.containsExactly("admin_account_group");
List<PermissionMenuItemVo> flat = service.getUserColumnPermissions(null, 7L, "admin", false);
assertThat(flat).extracting(PermissionMenuItemVo::getId).containsExactly(SIBLING_PAGE_ID);
assertThat(flat.stream().map(PermissionMenuItemVo::getRootColumnKey).toList())
.as("includeAncestorGroups=false 时父分组不在下发列表里,rootColumnKey 仍要能从全量目录解析出来"
+ "(把剪过的集合喂给 toItemVos 的第二个参数就会让它退化成自己,侧边栏再也挂不上分组)")
.containsExactly("admin_account_group");
}
// ---------------------------------------------------------------- B3:出口 3(提交授权)
/**
* 出口 3(超管操作者):整树提交里带这条历史 id 必须"剥离而不报错",且剥离不许变成静默改数据。
*
* <p>超管 + {@code menuType == null} 走的是既有的「整树替换」语义:{@code deleteByUserId} 先把
* 目标整个分区清空、再按提交集合重插。被剥掉的这条因此会从目标账号上消失——这是该分支
* 本来就有的 documented 行为(不是本任务的剥离引入的副作用),既有注释已写明"只增不删"仅适用于
* 数据权限那一类;本用例钉的是:其余项照常落库、被剥的这条绝不进 {@code deleteByUserIdAndColumnIds}
* 的按 id 删除集合、且提交不被 403 打断。
* {@code selectCount} 桩返回 1(不是 2)——钉住剥离发生在"无效菜单"校验之前,
* 被剥的 id 不会去撞菜单有效性检查。</p>
*/
@Test
void superAdminSaveStripsLegacyGrantInsteadOfFailing() {
PermissionMenuMapper menuMapper = mock(PermissionMenuMapper.class);
UserColumnPermissionMapper permissionMapper = mock(UserColumnPermissionMapper.class);
AdminUserMapper userMapper = mock(AdminUserMapper.class);
PermissionMenuService service = new PermissionMenuService(menuMapper, permissionMapper, userMapper);
when(userMapper.selectById(7L)).thenReturn(ownedNormalUser(7L, 30L));
when(menuMapper.selectList(any())).thenReturn(catalog());
when(menuMapper.selectCount(any())).thenReturn(1L);
when(menuMapper.selectOne(any())).thenReturn(null);
when(userMapper.selectList(any())).thenReturn(List.of());
UserColumnPermissionUpdateRequest request = new UserColumnPermissionUpdateRequest();
request.setColumnIds(List.of(COMPANY_MENU_ID, SIBLING_PAGE_ID));
assertThatCode(() -> service.updateUserColumnPermissions(
user(31L, "super_admin", 1), 7L, request, null)).doesNotThrowAnyException();
ArgumentCaptor<UserColumnPermissionEntity> inserted =
ArgumentCaptor.forClass(UserColumnPermissionEntity.class);
verify(permissionMapper, times(1)).insert(inserted.capture());
assertThat(inserted.getAllValues()).extracting(UserColumnPermissionEntity::getColumnId)
.as("合法项照常落库,被剥项不落库(09-16「整单失败」不许回来)")
.containsExactly(SIBLING_PAGE_ID);
verify(permissionMapper, never())
.deleteByUserIdAndColumnIds(any(), argThat(ids -> ids != null && ids.contains(COMPANY_MENU_ID)));
verify(permissionMapper, times(1)).deleteByUserId(7L);
}
/**
* 出口 3(普通管理员操作者):自己范围外、且历史上挂在目标身上的这条,既不能被"新增"回来,
* 也不能因为剥离而顺手被删掉——删除范围只由操作者可授予集算出来,与提交集合无关。
*/
@Test
void nonSuperAdminSaveStripsItFromGrantAndFromDeleteScope() {
PermissionMenuMapper menuMapper = mock(PermissionMenuMapper.class);
UserColumnPermissionMapper permissionMapper = mock(UserColumnPermissionMapper.class);
AdminUserMapper userMapper = mock(AdminUserMapper.class);
PermissionMenuService service = new PermissionMenuService(menuMapper, permissionMapper, userMapper);
when(userMapper.selectById(7L)).thenReturn(ownedNormalUser(7L, 30L));
when(menuMapper.selectList(any())).thenReturn(catalog());
when(menuMapper.selectOne(any())).thenReturn(null);
when(userMapper.selectList(any())).thenReturn(List.of());
// 操作者(普通管理员 30)自己并没有这条
when(permissionMapper.selectByUserId(30L)).thenReturn(List.of(grant(30L, SIBLING_PAGE_ID)));
when(permissionMapper.selectByUserId(7L)).thenReturn(List.of(grant(7L, COMPANY_MENU_ID)));
UserColumnPermissionUpdateRequest request = new UserColumnPermissionUpdateRequest();
request.setColumnIds(List.of(COMPANY_MENU_ID, SIBLING_PAGE_ID));
assertThatCode(() -> service.updateUserColumnPermissions(
user(30L, "admin", 1), 7L, request, "admin")).doesNotThrowAnyException();
ArgumentCaptor<UserColumnPermissionEntity> inserted =
ArgumentCaptor.forClass(UserColumnPermissionEntity.class);
verify(permissionMapper, times(1)).insert(inserted.capture());
assertThat(inserted.getAllValues()).extracting(UserColumnPermissionEntity::getColumnId)
.containsExactly(SIBLING_PAGE_ID);
verify(permissionMapper, never())
.deleteByUserIdAndColumnIds(any(), argThat(ids -> ids != null && ids.contains(COMPANY_MENU_ID)));
verify(permissionMapper, times(1)).deleteByUserIdAndColumnIds(eq(7L),
argThat(ids -> ids != null && ids.contains(SIBLING_PAGE_ID) && !ids.contains(COMPANY_MENU_ID)));
verify(permissionMapper, never()).deleteByUserId(any());
}
// ---------------------------------------------------------------- fixtures
/** 生产形状:一级分组 98 下挂公司管理 109 与另一个页面 110。 */
private List<PermissionMenuEntity> catalog() {
return List.of(
menu(GROUP_ID, null, "admin", 8, "admin_account_group"),
menu(COMPANY_MENU_ID, GROUP_ID, "admin", 9, KEY),
menu(SIBLING_PAGE_ID, GROUP_ID, "admin", 10, "admin_user_manage"));
}
private PermissionMenuEntity menu(Long id, Long parentId, String menuType, int sortOrder, String columnKey) {
PermissionMenuEntity entity = new PermissionMenuEntity();
entity.setId(id);
entity.setParentId(parentId);
entity.setMenuType(menuType);
entity.setColumnKey(columnKey);
entity.setName(columnKey);
entity.setRoutePath("route-" + id);
entity.setSortOrder(sortOrder);
return entity;
}
private UserColumnPermissionEntity grant(Long userId, Long columnId) {
UserColumnPermissionEntity entity = new UserColumnPermissionEntity();
entity.setUserId(userId);
entity.setColumnId(columnId);
return entity;
}
private AdminUserEntity user(Long id, String role, int isAdmin) {
AdminUserEntity entity = new AdminUserEntity();
entity.setId(id);
entity.setRole(role);
entity.setIsAdmin(isAdmin);
return entity;
}
private AdminUserEntity ownedNormalUser(Long id, Long createdById) {
AdminUserEntity entity = user(id, "normal", 0);
entity.setCreatedById(createdById);
return entity;
}
}