fix(客户10-08): 分组名收到同公司唯一、去重按分组写不再 403、登录态失效前端会真退出

付费客户「先锋-团队」一次报的四件事,根因各自独立,这一版一起收:

1) 去重数据汇总「新增导入」选自己公司的分组提交必 403。DedupeTotalDataService
   .resolveAccessScope 给 company_super_admin 时只开了 wholeCompany 那一支、groupIds
   留空集,而写侧闸门 resolveWritableGroup / ensureImportTaskAccess 只认 allUsers 与
   groupIds——读侧宽、写侧窄,表现就是「下拉选得到、提交就 403」,且 403 是 HTTP 状态
   不是中文文案,前端只能显示 Request failed with status code 403。改为同一口径把本公司的
   分组 id 一起带上(src/main/.../DedupeTotalDataService.java:86,104,112 + 注释)。

2) 「暂无分组」与「分组名称已存在」是同一行的两面:老「先锋」的组长 uid=1188 已被删,
   分组 id=33 成了孤儿行,仍占着全平台唯一的组名;而 list() 只按 created_by_id 筛,
   这一行被每一个公司的 tab 静默排除(生产 13 个分组里 2 个组长只落在旧列 user_id 上)。
   V153 给 biz_shop_manage_group 加 company_id(建组按组长定死、改名按组长当前公司纠回,
   顺手治「移人」造成的落值漂移),唯一键换成 uk_company_group_name(company_id, group_name),
   先 ADD 后 DROP。校验收窄到本公司,文案也从「分组名称已存在」改成「本公司内已存在同名分组」。
   MySQL 唯一索引里 NULL 互不相异 ⇒ 迁移上线后 (NULL,'先锋') 不挡 (3,'先锋'),
   客户当场就能建组,不需要先清那两行孤儿数据。

3) 删号/凭证过期后「软件还能用、没有强制退出」:前端 http 拦截器只认业务码 4011(互踢),
   JWT 过期或被拒返回的 401 一路静默,页面停在原处。新增 handleSessionExpired(),
   401 与「code/status=401」都清本地登录态并跳 /login?expired=1;匿名 401 不收口
   (那是常态噪声,且没登录态可清)。403 仍不触发下线——那是权限缺口,不能说成登录坏了。

4) 互踢(客户要「支持同时登录」)走配置不改码:AIIMAGE_AUTH_SINGLE_DEVICE_ENABLED=false,
   开关只有 3 个消费点、OFF 支已有用例钉着。这里只把公司超管的角色串收成
   DeviceSessionPolicy.COMPANY_SUPER_ADMIN,并记下它 src/main 仍有 22 处手抄比较
   (SuperAdminPredicateSingleOutletTest 那支绊线只管 super_admin,别以为它也在守这一串)。

⚠ 本提交带着并行会话 10-07 那批分组公司归属校验一起上线(ShopManageGroupService 的
ensureLeaderSharesOperatorCompany / resolveMembers 公司校验等,约 58 行):HEAD 里这个类
连 companyScope 字段都没有,我的写侧代码压在同一处,逐 hunk 拆不出「纯本批」的一版,
拆出来的也编不过。他那支 ShopManageGroupCompanyScopeTest(5 例)一并收了,否则这 58 行进仓
却没有用例。他的 ShopKey*/AdminUserService/admin-frontend-vue 账号页那批一个字没动,仍在
工作树里等他自己发。

验证:mvn -o clean test 全量在 detached worktree(HEAD + 本批白名单)跑;定向 8 支类 61 例 0 红;
shopkey+dedupe 整包 130 例 0 红;本批判据变异自证 6/6 被杀(每轮还原后与注入前哈希逐字节一致);
前端 node --test 21 例 0 红、变异 3/3。回滚:jar 单独回退即可,V153 的手术式回滚见
backend-java/docs/rollback-V153-shop-manage-group-company-id.sql(不要 DROP COLUMN,它是资产)。
This commit is contained in:
2026-10-08 19:04:51 +08:00
parent de526f51c6
commit a24d7b9bac
15 changed files with 1091 additions and 38 deletions
@@ -0,0 +1,133 @@
package com.nanri.aiimage.modules.dedupe.service;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.mapper.AdminUserMapper;
import com.nanri.aiimage.common.mapper.ShopManageGroupMapper;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.model.entity.ShopManageGroupEntity;
import com.nanri.aiimage.common.service.CompanyScopeSupport;
import com.nanri.aiimage.modules.dedupe.mapper.DedupeTotalDataMapper;
import com.nanri.aiimage.modules.shopkey.service.ShopManageGroupService;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.http.HttpStatus;
import org.springframework.test.util.ReflectionTestUtils;
import org.springframework.web.server.ResponseStatusException;
import java.util.List;
import java.util.Set;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.Mockito.when;
/**
* 公司超级管理员在「按分组读写去重总数据」这条链上的闸门(2026-10-08 客户现网报 403)。
*
* <p>客户账号 uid=1206(company_id=3)自己建了分组 id=36,后台下拉能选到它,点「上传并导入」
* 得到的是 axios 那句 {@code Request failed with status code 403}——因为写侧闸门
* {@code resolveAccessibleGroup} 只认 {@code allUsers} 与 {@code groupIds},而公司超管那一支
* {@code AccessScope} 过去只填了 {@code userIds + wholeCompany}(读侧用),groupIds 是空集。
* 读侧有 {@code wholeCompany} 兜着所以列表是好的,两边不对称就是"看得到、动不了"。</p>
*
* <p>断言打在闸门的行为上(抛不抛)而不是打在集合内容上:把 {@code resolveAccessScope} 里补
* groupIds 那一行删掉,前两条用例必须一红一松手;把 {@code listCompanyGroupIds} 换成"不筛公司"
* 则第三条必须红——这两向都红才说明这一行真的在执行口径,而不是恰好没被走到。</p>
*/
@ExtendWith(MockitoExtension.class)
class DedupeTotalDataCompanySuperAdminGroupAccessTest {
private static final long OPERATOR_ID = 1206L;
private static final long OWN_COMPANY_ID = 3L;
private static final long OWN_COMPANY_GROUP_ID = 36L;
private static final long OTHER_COMPANY_GROUP_ID = 33L;
@Mock
private DedupeTotalDataMapper dedupeTotalDataMapper;
@Mock
private AdminUserMapper adminUserMapper;
@Mock
private ShopManageGroupMapper shopManageGroupMapper;
@Mock
private ShopManageGroupService shopManageGroupService;
@Mock
private CompanyScopeSupport companyScopeSupport;
@InjectMocks
private DedupeTotalDataService service;
private void stubCompanySuperAdmin() {
AdminUserEntity operator = new AdminUserEntity();
operator.setId(OPERATOR_ID);
operator.setUsername("u1206");
operator.setRole("company_super_admin");
operator.setIsAdmin(1);
operator.setCompanyId(OWN_COMPANY_ID);
when(adminUserMapper.selectById(OPERATOR_ID)).thenReturn(operator);
when(companyScopeSupport.memberUserIds(OWN_COMPANY_ID)).thenReturn(List.of(OPERATOR_ID));
}
private void stubGroup(Long groupId) {
ShopManageGroupEntity group = new ShopManageGroupEntity();
group.setId(groupId);
group.setGroupName("g" + groupId);
when(shopManageGroupMapper.selectById(groupId)).thenReturn(group);
}
private ShopManageGroupEntity resolveWritableGroup(Long groupId) {
AdminUserEntity operator = new AdminUserEntity();
operator.setId(OPERATOR_ID);
operator.setRole("company_super_admin");
operator.setCompanyId(OWN_COMPANY_ID);
return ReflectionTestUtils.invokeMethod(service, "resolveWritableGroup", groupId, operator);
}
@Test
@DisplayName("公司超管写本公司名下的分组:闸门放行(修复前这里必 403)")
void companySuperAdminWritesGroupOfOwnCompany() {
stubCompanySuperAdmin();
stubGroup(OWN_COMPANY_GROUP_ID);
when(shopManageGroupService.listCompanyGroupIds(List.of(OPERATOR_ID)))
.thenReturn(Set.of(OWN_COMPANY_GROUP_ID));
assertThat(resolveWritableGroup(OWN_COMPANY_GROUP_ID).getId()).isEqualTo(OWN_COMPANY_GROUP_ID);
}
@Test
@DisplayName("公司超管查导入任务进度走同一把尺子:不再报「无权查看该导入任务」")
void importTaskAccessUsesSameRuler() {
stubCompanySuperAdmin();
when(shopManageGroupService.listCompanyGroupIds(List.of(OPERATOR_ID)))
.thenReturn(Set.of(OWN_COMPANY_GROUP_ID));
ReflectionTestUtils.invokeMethod(service, "ensureImportTaskAccess", OWN_COMPANY_GROUP_ID,
ReflectionTestUtils.invokeMethod(service, "resolveAccessScope", OPERATOR_ID));
}
@Test
@DisplayName("别家公司的分组仍然 403:补 groupIds 不等于把闸门放开成全平台")
void groupOfAnotherCompanyStillForbidden() {
stubCompanySuperAdmin();
stubGroup(OTHER_COMPANY_GROUP_ID);
// 组长不在本公司成员集里 ⇒ listCompanyGroupIds 不会返回它
when(shopManageGroupService.listCompanyGroupIds(List.of(OPERATOR_ID))).thenReturn(Set.of());
assertThatThrownBy(() -> resolveWritableGroup(OTHER_COMPANY_GROUP_ID))
.isInstanceOfSatisfying(ResponseStatusException.class, ex -> {
assertThat(ex.getStatusCode()).isEqualTo(HttpStatus.FORBIDDEN);
assertThat(ex.getReason()).isEqualTo("无权操作该分组数据");
});
}
@Test
@DisplayName("分组 id 缺失仍走中文业务错误,不被公司维度兜成放行")
void missingGroupStillRejectedBeforeScope() {
assertThatThrownBy(() -> resolveWritableGroup(0L))
.isInstanceOf(BusinessException.class)
.hasMessage("请选择分组");
}
}
@@ -0,0 +1,260 @@
package com.nanri.aiimage.modules.shopkey.service;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.mapper.AdminUserMapper;
import com.nanri.aiimage.common.mapper.ShopManageGroupMapper;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.model.entity.ShopManageGroupEntity;
import com.nanri.aiimage.common.service.CompanyScopeSupport;
import com.nanri.aiimage.modules.shopkey.mapper.ShopManageGroupMemberMapper;
import com.nanri.aiimage.modules.shopkey.model.dto.ShopManageGroupCreateRequest;
import com.nanri.aiimage.modules.shopkey.model.dto.ShopManageGroupUpdateRequest;
import com.nanri.aiimage.modules.shopkey.model.entity.ShopManageGroupMemberEntity;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.junit.jupiter.MockitoSettings;
import org.mockito.quality.Strictness;
import org.springframework.test.util.ReflectionTestUtils;
import java.util.List;
import java.util.concurrent.atomic.AtomicReference;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* 分组名的唯一性范围(V153 起:同一家公司内唯一,2026-10-08 定档)。
*
* <p>要防的是两种"错了不报错"的形状:</p>
* <ol>
* <li><b>写侧漏落 company_id</b>:这一列是 NULL 的分组会被所有公司的 tab 排除在外,
* 而 MyBatis-Plus 对 null 字段直接不出现在 INSERT 列清单里 ⇒ 静默落库成 NULL。
* 所以断言打在<b>送进 insert/updateById 的那个实体</b>上,不是打在方法没抛异常上。</li>
* <li><b>校验用 eq(col, null) 而不是 isNull</b>:{@code company_id = NULL} 在 MySQL 里恒不成立,
* 于是"查占用者"永远查不到,这条校验整支形同删掉——而它长得像在工作。</li>
* </ol>
*
* <p>SQL 片段字面量取自媒体实跑(脱敏后逐字),不是推理;{@code paramNameValuePairs} 必须在
* {@code getSqlSegment()} 求值<b>之后</b>再读,否则断的是一个空 map。</p>
*/
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
class ShopManageGroupCompanyNameUniquenessTest {
private static final Long LEADER_ID = 1206L;
private static final Long OPERATOR_ID = 1206L;
private static final Long COMPANY_ID = 3L;
private static final Long OTHER_COMPANY_ID = 1L;
private ShopManageGroupMapper groupMapper;
private ShopManageGroupMemberMapper memberMapper;
private AdminUserMapper userMapper;
private CompanyScopeSupport companyScope;
private ShopManageGroupService service;
@Mock
private com.nanri.aiimage.modules.shopkey.mapper.ShopManageMapper shopManageMapper;
@BeforeEach
void setUp() {
TableInfoHelper.initTableInfo(new MapperBuilderAssistant(new MybatisConfiguration(), ""),
ShopManageGroupEntity.class);
TableInfoHelper.initTableInfo(new MapperBuilderAssistant(new MybatisConfiguration(), ""),
ShopManageGroupMemberEntity.class);
groupMapper = org.mockito.Mockito.mock(ShopManageGroupMapper.class);
memberMapper = org.mockito.Mockito.mock(ShopManageGroupMemberMapper.class);
userMapper = org.mockito.Mockito.mock(AdminUserMapper.class);
companyScope = org.mockito.Mockito.mock(CompanyScopeSupport.class);
service = new ShopManageGroupService(groupMapper, memberMapper, List.of(), shopManageMapper,
null, null, userMapper, companyScope);
// 打桩照 CompanyScopeSupport 的真实语义来:取不到公司就抛,而不是把 null 传下去。
// 上一版这里直接回传 getCompanyId(),结果 null 一路走到别人的 equals 里 NPE,
// 测出来的是"桩不像真实现",不是被测代码的缺陷。
when(companyScope.requireCompanyId(any(AdminUserEntity.class))).thenAnswer(invocation -> {
AdminUserEntity account = invocation.getArgument(0);
if (account == null || account.getCompanyId() == null || account.getCompanyId() <= 0) {
throw new BusinessException("归属账号不存在或没有所属公司");
}
return account.getCompanyId();
});
}
private AdminUserEntity user(Long id, String role, Long companyId) {
AdminUserEntity user = new AdminUserEntity();
user.setId(id);
user.setUsername("u" + id);
user.setRole(role);
user.setIsAdmin("normal".equals(role) ? 0 : 1);
user.setCompanyId(companyId);
return user;
}
/** 脱敏:MP 在 segment 里只放 {@code #{ew.paramNameValuePairs.MPGENVALn}} 占位,值单独断。 */
private static String masked(String segment) {
String sql = segment.replaceAll("#\\{ew\\.paramNameValuePairs\\.MPGENVAL\\d+}", "?");
assertThat(sql).as("脱敏必须把每个 MP 占位符都换成 ?").doesNotContain("MPGENVAL").doesNotContain("#{");
return sql;
}
@SuppressWarnings({"unchecked", "rawtypes"})
private LambdaQueryWrapper<ShopManageGroupEntity> captureCountQuery() {
ArgumentCaptor<LambdaQueryWrapper> captor = ArgumentCaptor.forClass(LambdaQueryWrapper.class);
verify(groupMapper).selectCount(captor.capture());
return (LambdaQueryWrapper<ShopManageGroupEntity>) captor.getValue();
}
private void stubEmptyNameSlot() {
when(groupMapper.selectCount(any())).thenReturn(0L);
}
// ---------- 1. 校验查询必须带公司谓词 ----------
@Test
@DisplayName("重名校验:按公司筛,实测渲染逐字比对")
void duplicateCheckIsScopedByCompany() {
stubEmptyNameSlot();
ReflectionTestUtils.invokeMethod(service, "ensureGroupNameUnique", "先锋", null, COMPANY_ID);
LambdaQueryWrapper<ShopManageGroupEntity> query = captureCountQuery();
String sql = masked(query.getSqlSegment());
assertThat(sql).as("名字与公司两条腿都必须 AND 在一起")
.isEqualTo("(group_name = ? AND company_id = ?)");
// 先求值 segment 再读 pairs,否则断的是空 map。绑定顺序由 MP 决定,不假设它跟片段同序。
assertThat(query.getParamNameValuePairs().values())
.containsExactlyInAnyOrder("先锋", COMPANY_ID);
}
@Test
@DisplayName("重名校验:归属为 NULL 时必须走 IS NULL,不能渲染成 company_id = NULL(恒不成立=校验形同删掉)")
void nullCompanyUsesIsNullNotEqualsNull() {
stubEmptyNameSlot();
ReflectionTestUtils.invokeMethod(service, "ensureGroupNameUnique", "先锋", null, null);
LambdaQueryWrapper<ShopManageGroupEntity> query = captureCountQuery();
String sql = masked(query.getSqlSegment());
assertThat(sql).as("NULL 归属要按 IS NULL 比,而不是绑一个 null 进去")
.isEqualTo("(group_name = ? AND company_id IS NULL)");
assertThat(sql).as("绝不允许出现 company_id = ? 且绑定值是 null 的形状")
.doesNotContain("company_id = ?");
assertThat(query.getParamNameValuePairs().values()).containsExactly("先锋");
}
@Test
@DisplayName("重名校验:本公司内已存在才报,且文案不说\"全平台\"(V153 之后那句是假话)")
void messageSpeaksCompanyScopeOnly() {
when(groupMapper.selectCount(any())).thenReturn(1L);
assertThatThrownBy(() -> ReflectionTestUtils.invokeMethod(
service, "ensureGroupNameUnique", "先锋", 36L, COMPANY_ID))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("本公司")
.hasMessageNotContaining("全平台");
}
@Test
@DisplayName("重名校验:编辑自己时把自己排除在外(否则任何一次改名都自撞)")
void updateExcludesOwnRow() {
stubEmptyNameSlot();
ReflectionTestUtils.invokeMethod(service, "ensureGroupNameUnique", "先锋", 36L, COMPANY_ID);
LambdaQueryWrapper<ShopManageGroupEntity> query = captureCountQuery();
assertThat(masked(query.getSqlSegment()))
.isEqualTo("(group_name = ? AND company_id = ? AND id <> ?)");
assertThat(query.getParamNameValuePairs().values())
.containsExactlyInAnyOrder("先锋", COMPANY_ID, 36L);
}
// ---------- 2. 写侧必须把 company_id 落进去 ----------
@Test
@DisplayName("建组:INSERT 的实体带 company_id(从组长账号推),漏落就会静默造出孤儿行")
void createPersistsCompanyFromLeader() {
stubEmptyNameSlot();
when(userMapper.selectById(LEADER_ID)).thenReturn(user(LEADER_ID, "company_super_admin", COMPANY_ID));
AtomicReference<ShopManageGroupEntity> inserted = new AtomicReference<>();
when(groupMapper.insert(any(ShopManageGroupEntity.class))).thenAnswer(invocation -> {
ShopManageGroupEntity entity = invocation.getArgument(0);
// 真库里 insert 后主键由自增回填,create() 末尾会 selectById(id) 再回显。
// 桩不填 id 的话 toVoList 拿 null 去查成员,测到的是桩不像真实现。
entity.setId(36L);
inserted.set(entity);
return 1;
});
when(groupMapper.selectById(any())).thenAnswer(invocation -> inserted.get());
// toVoList 会按组长/组员 id 批量取账号回显用户名,桩不给就 NPE 在回显上,
// 而这条用例要断的是"送进 insert 的那个实体带没带 company_id"。
when(userMapper.selectBatchIds(any()))
.thenReturn(List.of(user(LEADER_ID, "company_super_admin", COMPANY_ID)));
ShopManageGroupCreateRequest request = new ShopManageGroupCreateRequest();
request.setGroupName("先锋");
request.setCreatedById(LEADER_ID);
request.setMemberUserIds(List.of());
service.create(request, OPERATOR_ID, false);
assertThat(inserted.get().getCompanyId()).as("归属必须随建组一次定死").isEqualTo(COMPANY_ID);
assertThat(inserted.get().getGroupName()).isEqualTo("先锋");
}
@Test
@DisplayName("建组:组长账号没有公司 ⇒ 抛,不允许落成 NULL 继续写")
void createRejectsLeaderWithoutCompany() {
when(userMapper.selectById(LEADER_ID)).thenReturn(user(LEADER_ID, "company_super_admin", null));
ShopManageGroupCreateRequest request = new ShopManageGroupCreateRequest();
request.setGroupName("先锋");
request.setCreatedById(LEADER_ID);
request.setMemberUserIds(List.of());
assertThatThrownBy(() -> service.create(request, OPERATOR_ID, false))
.isInstanceOf(BusinessException.class);
verify(groupMapper, org.mockito.Mockito.never()).insert(any(ShopManageGroupEntity.class));
}
@Test
@DisplayName("改名:按组长当前公司回写,组长被移去别家时这一列跟着纠回来(落值漂移的自愈点)")
void renameRewritesCompanyFromCurrentLeader() {
stubEmptyNameSlot();
ShopManageGroupEntity stored = new ShopManageGroupEntity();
stored.setId(36L);
stored.setGroupName("先锋1");
stored.setCreatedById(LEADER_ID);
stored.setCompanyId(OTHER_COMPANY_ID); // 落值还是老公司 —— 模拟"移人"之后
when(groupMapper.selectById(36L)).thenReturn(stored);
when(userMapper.selectById(LEADER_ID)).thenReturn(user(LEADER_ID, "company_super_admin", COMPANY_ID));
AtomicReference<ShopManageGroupEntity> updated = new AtomicReference<>();
when(groupMapper.updateById(any(ShopManageGroupEntity.class))).thenAnswer(invocation -> {
updated.set(invocation.getArgument(0));
return 1;
});
ShopManageGroupUpdateRequest request = new ShopManageGroupUpdateRequest();
request.setGroupName("先锋");
request.setMemberUserIds(List.of());
service.update(36L, OPERATOR_ID, false, request);
assertThat(updated.get().getCompanyId()).as("改名必须顺手把归属纠回组长当前公司").isEqualTo(COMPANY_ID);
assertThat(updated.get().getGroupName()).isEqualTo("先锋");
// 校验查询用的是纠回来之后的公司,不是那一列的旧值(改名场景自带 id <> 自己)
LambdaQueryWrapper<ShopManageGroupEntity> check = captureCountQuery();
String sql = masked(check.getSqlSegment());
assertThat(sql).isEqualTo("(group_name = ? AND company_id = ? AND id <> ?)");
assertThat(check.getParamNameValuePairs().values()).contains(COMPANY_ID);
assertThat(check.getParamNameValuePairs().values()).doesNotContain(OTHER_COMPANY_ID);
}
}
@@ -0,0 +1,155 @@
package com.nanri.aiimage.modules.shopkey.service;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.mapper.AdminUserMapper;
import com.nanri.aiimage.common.mapper.ShopManageGroupMapper;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.model.entity.ShopManageGroupEntity;
import com.nanri.aiimage.common.service.CompanyScopeSupport;
import com.nanri.aiimage.modules.shopkey.mapper.ShopManageGroupMemberMapper;
import com.nanri.aiimage.modules.shopkey.model.dto.ShopManageGroupCreateRequest;
import com.nanri.aiimage.modules.shopkey.model.entity.ShopManageGroupMemberEntity;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* 分组的归属边界(2026-10-07 定案):与建号那条同一口径——站点超管不替其他公司管分组,
* 而超管(站点与公司两档)不属于任何分组。
*
* <p>分组表没有 {@code company_id} 列,归属只能从组长账号推,所以这里的断言全部打在
* 「组长/组员的 company_id 有没有被真的比过」上,而不是打在角色字符串上:把
* {@code ensureLeaderSharesOperatorCompany} 那一行删掉,四条用例必须同时松手。</p>
*/
class ShopManageGroupCompanyScopeTest {
private ShopManageGroupMapper groupMapper;
private ShopManageGroupMemberMapper memberMapper;
private AdminUserMapper userMapper;
private CompanyScopeSupport companyScope;
private ShopManageGroupService service;
@BeforeEach
void setUp() {
TableInfoHelper.initTableInfo(new MapperBuilderAssistant(new MybatisConfiguration(), ""),
ShopManageGroupEntity.class);
TableInfoHelper.initTableInfo(new MapperBuilderAssistant(new MybatisConfiguration(), ""),
ShopManageGroupMemberEntity.class);
groupMapper = mock(ShopManageGroupMapper.class);
memberMapper = mock(ShopManageGroupMemberMapper.class);
userMapper = mock(AdminUserMapper.class);
companyScope = mock(CompanyScopeSupport.class);
service = new ShopManageGroupService(groupMapper, memberMapper, List.of(), null, null, null,
userMapper, companyScope);
// 真实实现就是「取账号自己的 company_id,取不到就抛」,这里按同一语义打桩而不是逐个用例喂值
when(companyScope.requireCompanyId(any(AdminUserEntity.class))).thenAnswer(invocation ->
invocation.getArgument(0, AdminUserEntity.class).getCompanyId());
}
private AdminUserEntity user(Long id, String role, Long companyId) {
AdminUserEntity user = new AdminUserEntity();
user.setId(id);
user.setUsername("u" + id);
user.setRole(role);
user.setIsAdmin("normal".equals(role) ? 0 : 1);
user.setCompanyId(companyId);
return user;
}
private ShopManageGroupCreateRequest request(Long leaderId, List<Long> memberIds) {
ShopManageGroupCreateRequest request = new ShopManageGroupCreateRequest();
request.setGroupName("g-" + leaderId + "-" + memberIds);
request.setCreatedById(leaderId);
request.setMemberUserIds(memberIds);
return request;
}
@Test
@DisplayName("建组:站点超管不能替别家公司建分组——组长是别家的人就挡下,且一行不写")
void superAdminCannotCreateGroupForAnotherCompany() {
when(userMapper.selectById(1L)).thenReturn(user(1L, "super_admin", 1L));
when(userMapper.selectById(50L)).thenReturn(user(50L, "admin", 7L));
assertThatThrownBy(() -> service.create(request(50L, List.of()), 1L, true))
.isInstanceOfSatisfying(BusinessException.class, ex ->
assertThat(ex.getMessage()).contains("本公司"));
verify(groupMapper, never()).insert(any(ShopManageGroupEntity.class));
}
@Test
@DisplayName("组员:公司超管永不入组,站点超管操作者也绕不过这一条")
void companySuperAdminNeverBecomesMember() {
when(userMapper.selectById(1L)).thenReturn(user(1L, "super_admin", 1L));
when(userMapper.selectById(50L)).thenReturn(user(50L, "admin", 1L));
when(userMapper.selectBatchIds(any())).thenReturn(List.of(user(60L, "company_super_admin", 1L)));
assertThatThrownBy(() -> service.create(request(50L, List.of(60L)), 1L, true))
.isInstanceOfSatisfying(BusinessException.class, ex ->
assertThat(ex.getMessage()).isEqualTo("超级管理员不属于任何分组"));
verify(memberMapper, never()).insert(any(ShopManageGroupMemberEntity.class));
}
@Test
@DisplayName("组员:站点超管账号同样不得入组(老实现只在非超管分支才查这一条)")
void siteSuperAdminNeverBecomesMember() {
when(userMapper.selectById(1L)).thenReturn(user(1L, "super_admin", 1L));
when(userMapper.selectById(50L)).thenReturn(user(50L, "admin", 1L));
when(userMapper.selectBatchIds(any())).thenReturn(List.of(user(61L, "super_admin", 1L)));
assertThatThrownBy(() -> service.create(request(50L, List.of(61L)), 1L, true))
.isInstanceOfSatisfying(BusinessException.class, ex ->
assertThat(ex.getMessage()).isEqualTo("超级管理员不属于任何分组"));
}
@Test
@DisplayName("组员:别家公司的普通账号不能拉进本公司分组(超管操作者以前能)")
void memberMustShareLeaderCompany() {
when(userMapper.selectById(1L)).thenReturn(user(1L, "super_admin", 1L));
when(userMapper.selectById(50L)).thenReturn(user(50L, "admin", 1L));
when(userMapper.selectBatchIds(any())).thenReturn(List.of(user(62L, "normal", 7L)));
assertThatThrownBy(() -> service.create(request(50L, List.of(62L)), 1L, true))
.isInstanceOfSatisfying(BusinessException.class, ex ->
assertThat(ex.getMessage()).contains("本公司"));
verify(memberMapper, never()).insert(any(ShopManageGroupMemberEntity.class));
}
@Test
@DisplayName("正样本配对:本公司组长 + 本公司普通员工照常落库——上面四条 never 只有这条成立才有东西可反证")
void sameCompanyLeaderAndMemberAreSaved() {
when(userMapper.selectById(1L)).thenReturn(user(1L, "super_admin", 1L));
when(userMapper.selectById(50L)).thenReturn(user(50L, "admin", 1L));
when(userMapper.selectBatchIds(any())).thenReturn(List.of(user(63L, "normal", 1L)));
when(groupMapper.insert(any(ShopManageGroupEntity.class))).thenAnswer(invocation -> {
invocation.getArgument(0, ShopManageGroupEntity.class).setId(9L);
return 1;
});
ShopManageGroupEntity saved = new ShopManageGroupEntity();
saved.setId(9L);
saved.setGroupName("saved");
saved.setCreatedById(50L);
when(groupMapper.selectById(9L)).thenReturn(saved);
service.create(request(50L, List.of(63L)), 1L, true);
ArgumentCaptor<ShopManageGroupMemberEntity> captor =
ArgumentCaptor.forClass(ShopManageGroupMemberEntity.class);
verify(memberMapper).insert(captor.capture());
assertThat(captor.getValue().getUserId()).isEqualTo(63L);
assertThat(captor.getValue().getGroupId()).isEqualTo(9L);
}
}
@@ -47,9 +47,11 @@ import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class ShopManageGroupServiceTest {
/** 实跑(MP 3.5.7,TableInfo 手工初始化)打出来的 {@code list(5L, List.of(11L))} 脱敏整串:每个字符都取自媒体,不是推测。 */
/** 实跑(MP 3.5.7,TableInfo 手工初始化)打出来的 {@code list(5L, List.of(11L))} 脱敏整串:每个字符都取自媒体,不是推测。
* 2026-10-08:公司那一腿从 {@code created_by_id IN (?)} 长成两列一起认(生产 13 个分组里 2 个的组长
* 只落在旧列 user_id 上,单列筛会把它们从每一个公司 tab 里静默删掉),与 {@code listCompanyGroupIds} 对齐。 */
private static final String OR_GROUP_MASKED =
"((created_by_id = ? OR (user_id = ?)) AND (created_by_id IN (?))) ORDER BY id ASC";
"((created_by_id = ? OR (user_id = ?)) AND (created_by_id IN (?) OR (user_id IN (?)))) ORDER BY id ASC";
/** M2(I-1 点名的那个形状)实测渲染出来的样子:OR 的左半边逃出括号组。整串比对对它必红。 */
private static final String FLAT_OR_MASKED =
@@ -110,8 +112,8 @@ class ShopManageGroupServiceTest {
assertThat(sql).contains(" OR ").contains(" IN (");
assertThat(q.getParamNameValuePairs().values())
.as("三个占位符 = created_by_id / user_id / 公司成员集各一个绑定")
.hasSize(3)
.as("四个占位符 = created_by_id / user_id 各一个绑定 + 公司成员集两列各一个绑定")
.hasSize(4)
.contains(5L, 11L);
}