feat(菜单权限): 每家公司一套菜单树(V149)+ 公司 tab 只在注册表页渲染

本批两件事,加上随本批一起入仓的并行会话在制品:

一、菜单权限按公司隔离(批次 6)
- V149 给 columns 加 company_id:先可空加列(末位、ALGORITHM=INSTANT)→ 回填公司 1 →
  MODIFY 收紧 NOT NULL;三段式缺一即撞 1048。同时建 (company_id, column_key) 复合键、
  把公司 2 的 16 笔授权按 column_key 改指向它自己的副本,三类 menu_type 全复制,
  admin_companies 作为角色内生闸门行不复制(D3)。
- 第三道归属门 PermissionMenuService.resolveScopeCompanyId:站点超管可带 company_id
  读写任意公司,非超管锁本公司、越界 403。它注册进 CompanyIdParamGoesThroughReadScopeTest
  的 SCOPE_DOORS,四条判据与 readScope / readCompanyIdOrOwn 共用——护栏在代码出口,不靠清单。
- 旁路种子 PermissionMenuSchemaInitializer 只种公司 1:31 段种子逐条钉公司,
  按 column_key 点查的 14 段全部带 company_id,否则摘了 DEFAULT 就是跨公司串写。
- CompanyService.create 同一次写入里给新公司复制模板树(D4)。

二、公司 tab 收口(批次 b)
tab 条挂在壳层,对 22 页全画;改为按正列表 companyTabAppliesTo(menuKey) 判定,
只有注册表页渲染。护栏钉在用户看见的那个出口。

三、并行会话在制品(控制方「全部提交」,未单独拆分——见下)
- V150 店铺密钥 biz_shop_key 按公司(readCompanyIdOrOwn + writeCompanyId 两道门)
- V151 品牌库/商品类目推翻为全平台共享:只退唯一键、company_id DEFAULT 保留为
  NOT NULL 承重约束(摘了每条 1364);删掉 ProductCategoryControllerCompanyScopeTest
  那支"按公司隔离"的旧护栏,readCompanyId 方法一并移除
- invalidasin 字段与外观专利合批的连带改动

为什么不拆笔:后端 3891 例 / 0 红、前端 1731 例 / 0 红这两个读数是"合起来的树"的读数,
拆成多笔会让每一笔落到从未一起验过的组合上,而这一版要直接上两台。

回滚脚本在 backend-java/docs/rollback-V149/V150/V151-*.sql,不放进 Flyway 扫描路径。
设计记录:docs/ops/menu-company-tree-design-2026-10-06.md
This commit is contained in:
2026-10-06 17:17:14 +08:00
parent e635fa8dcd
commit b7acfc0eef
84 changed files with 5118 additions and 1421 deletions
@@ -62,6 +62,23 @@ class AppearancePatentLlmClientTest {
assertThat(client.buildConclusion("无侵权", "无侵权", "")).isEqualTo("无侵权");
}
/**
* 商标维度查询失败、外观已判定:结论必须带着外观结论并标出「商标待复核」,
* 不能整格写「商标查询失败」把已判出的外观结论盖掉 —— 用户据此以为整单没检测,
* 而实际上只有商标那一维没核上。
*/
@Test
void conclusionKeepsAppearanceVerdictWhenBrandQueryFailed() {
assertThat(client.buildConclusion("商标查询失败", "无侵权", ""))
.isEqualTo("外观无侵权·商标待复核");
// 外观也没判出来时不编造结论:维持原文案
assertThat(client.buildConclusion("商标查询失败", "外观识别异常", ""))
.isEqualTo("商标查询失败");
assertThat(client.buildConclusion("商标查询失败", "", "")).isEqualTo("商标查询失败");
// 外观已判侵权:保守结论优先,且不引入新词形(分组传播按「侵权」精确命中)
assertThat(client.buildConclusion("商标查询失败", "侵权", "")).isEqualTo("侵权");
}
@Test
void skipBrandCheckWhenLlmTitleIsNone() throws Exception {
BrandCheckClient brandCheckClient = mock(BrandCheckClient.class);
@@ -285,8 +285,9 @@ class AppearancePatentSheetBuilderTest {
}
/**
* 结论列写「商标查询失败」时状态列必须判失败:
* 结论列没给出完整判定时状态列必须判失败:
* 历史缺陷是按「结论非空即成功」推状态,于是结论写着"商标查询失败"、状态却写"成功",自相矛盾。
* 两种没判完整的形状都要覆盖:外观也没判定(整格查询失败)、外观已判定但商标待复核。
*/
@Test
void test_sheet_builder_brand_query_failed_row_status_failed() throws Exception {
@@ -295,14 +296,26 @@ class AppearancePatentSheetBuilderTest {
AppearancePatentResultRowDto r = resultRow("2_1", "B01A", "US");
r.setTitleRisk("商标查询失败");
r.setAppearanceRisk("无侵权");
r.setConclusion("商标查询失败");
AppearancePatentSheetBuilder.buildResultSheet(wb, List.of(p), Map.of(
AppearancePatentSheetBuilder.rowKey(r), r));
r.setConclusion("外观无侵权·商标待复核");
AppearancePatentParsedRowVo p2 = parsedRow("2_2", "B01B", "US", "t", "", "");
AppearancePatentResultRowDto r2 = resultRow("2_2", "B01B", "US");
r2.setTitleRisk("商标查询失败");
r2.setAppearanceRisk("外观识别异常");
r2.setConclusion("商标查询失败");
AppearancePatentSheetBuilder.buildResultSheet(wb, List.of(p, p2), Map.of(
AppearancePatentSheetBuilder.rowKey(r), r,
AppearancePatentSheetBuilder.rowKey(r2), r2));
Row data = wb.getSheet("外观专利检测结果").getRow(1);
assertEquals("商标查询失败", data.getCell(9).getStringCellValue(), "标题维度保留查询失败文案");
assertEquals("商标查询失败", data.getCell(11).getStringCellValue(), "结论列保留查询失败文案");
assertEquals("无侵权", data.getCell(10).getStringCellValue(), "外观维度保留已判定结论");
assertEquals("外观无侵权·商标待复核", data.getCell(11).getStringCellValue(),
"结论列带上外观判定与待复核标记");
assertEquals("失败", data.getCell(12).getStringCellValue(), "商标没成功 → 状态失败");
Row both = wb.getSheet("外观专利检测结果").getRow(2);
assertEquals("商标查询失败", both.getCell(11).getStringCellValue(), "外观也没判定 → 结论仍是查询失败");
assertEquals("失败", both.getCell(12).getStringCellValue(), "两维都没判完整 → 状态失败");
}
}
@@ -318,6 +331,8 @@ class AppearancePatentSheetBuilderTest {
assertEquals("失败", AppearancePatentSheetBuilder.resolveResultStatus("LLM http 503: overloaded"));
assertEquals("失败", AppearancePatentSheetBuilder.resolveResultStatus(" "));
assertEquals("失败", AppearancePatentSheetBuilder.resolveResultStatus(null));
// 「含侵权二字即成功」这条判据不能把带待复核标记的结论读成成功
assertEquals("失败", AppearancePatentSheetBuilder.resolveResultStatus("外观无侵权·商标待复核"));
}
@Test
@@ -1,6 +1,5 @@
package com.nanri.aiimage.modules.collectdata.util;
import com.nanri.aiimage.common.service.CompanyScopeSupport;
import com.nanri.aiimage.modules.collectdata.model.vo.CollectDataResultRowVo;
import com.nanri.aiimage.modules.invalidasin.mapper.InvalidAsinDataMapper;
import com.nanri.aiimage.modules.invalidasin.model.entity.InvalidAsinDataEntity;
@@ -12,6 +11,7 @@ import java.util.ArrayList;
import java.util.List;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.anyList;
import static org.mockito.Mockito.doThrow;
@@ -28,28 +28,24 @@ import static org.mockito.Mockito.when;
* data_value 的批次不发起任何 insertBatchIgnore 调用;远程失败降级记录
* 计数(跳过写入),可恢复后继续,不抛出中断整个提交流程的异常。
*
* <p>归属那一笔(10-05 批次 3):实体与 INSERT 列清单此前都不带 company_id/uploader_user_id,
* V145 补的列全靠 DEFAULT 1 盖 ⇒ 第 2 家公司跑货源产生的行被记成第 1 家。写入器现在按
* 调用方给的任务发起账号推公司,<b>推不出公司就整批不写</b>(宁可少一条黑名单,也不把行盖成
* 别家公司 —— 那会让另一家的正常品牌被静默过滤)。</p>
* <p>归属那一笔的现网口径(控制方 2026-10-06 定案):这张黑名单<b>全平台共享、不按公司区分</b>,
* 写入器不再推公司、实体上也没有 company_id 可写({@code InvalidAsinDataServiceTest} 与
* {@code CompanyIdParamGoesThroughReadScopeTest} 分别钉住"预检不带公司列"和"这一族不许回流")。
* 10-05 那版"推不出公司就整批不写"的闸门一并放开:{@code uploader_user_id} 只记"哪个账号采出来的",
* 推不出账号照写 —— 少一条黑名单 = 下次同样的品牌再买一次代理费。</p>
*/
class CollectDataInvalidAsinBatchWriterTest {
/** 任务发起账号(biz_file_task.user_id)。 */
/** 任务发起账号(biz_file_task.user_id):只落 uploader_user_id 这一列,不参与可见性。 */
private static final Long UPLOADER = 7L;
/** 该账号归属的公司 —— 必须与 UPLOADER 不同值,否则断言分不清写进去的是哪个。 */
private static final Long UPLOADER_COMPANY = 2L;
private InvalidAsinDataMapper invalidAsinDataMapper;
private CompanyScopeSupport companyScopeSupport;
private CollectDataInvalidAsinBatchWriter writer;
@BeforeEach
void setUp() {
invalidAsinDataMapper = mock(InvalidAsinDataMapper.class);
companyScopeSupport = mock(CompanyScopeSupport.class);
when(companyScopeSupport.companyIdOrNull(UPLOADER)).thenReturn(UPLOADER_COMPANY);
writer = new CollectDataInvalidAsinBatchWriter(invalidAsinDataMapper, companyScopeSupport, 10);
writer = new CollectDataInvalidAsinBatchWriter(invalidAsinDataMapper, 10);
}
@Test
@@ -151,7 +147,7 @@ class CollectDataInvalidAsinBatchWriterTest {
when(invalidAsinDataMapper.insertBatchIgnore(anyList())).thenAnswer(
invocation -> ((List<?>) invocation.getArgument(0)).size());
CollectDataInvalidAsinBatchWriter smallWriter =
new CollectDataInvalidAsinBatchWriter(invalidAsinDataMapper, companyScopeSupport, 3);
new CollectDataInvalidAsinBatchWriter(invalidAsinDataMapper, 3);
List<CollectDataResultRowVo> rows = new ArrayList<>();
for (int i = 0; i < 10; i++) {
rows.add(row("B" + String.format("%09d", i + 1), "brand"));
@@ -211,12 +207,10 @@ class CollectDataInvalidAsinBatchWriterTest {
}
@Test
void test_batch_3_asin_normal_ownership_is_stamped_on_every_row() {
// 归属由任务发起账号推:每一行都带 company_id + uploader_user_id,
// 而不是留空让 DEFAULT 1 去盖(那会把第 2 家的行记成第 1 家,事后分不开)。
void test_batch_3_asin_normal_uploader_is_stamped_on_every_row() {
// uploader_user_id 每行都从调用方给的任务发起账号落,不留空(空了事后追不到是哪次采集采出来的)。
when(invalidAsinDataMapper.insertBatchIgnore(anyList())).thenAnswer(
invocation -> ((List<?>) invocation.getArgument(0)).size());
when(companyScopeSupport.companyIdOrNull(UPLOADER)).thenReturn(UPLOADER_COMPANY);
writer.writeBatch(List.of(row("B000000001", "nike"), row("B000000002", "zara")), UPLOADER);
@@ -225,21 +219,27 @@ class CollectDataInvalidAsinBatchWriterTest {
List<InvalidAsinDataEntity> entities = captor.getValue();
assertEquals(2, entities.size());
for (InvalidAsinDataEntity entity : entities) {
assertEquals(UPLOADER_COMPANY, entity.getCompanyId(), "company_id 来自发起账号,不是 DEFAULT");
assertEquals(UPLOADER, entity.getUploaderUserId(), "uploader_user_id 一并落,处置可回溯到人");
}
}
@Test
void test_batch_3_asin_invalid_owner_unresolved_skips_whole_batch() {
// 推不出公司(账号已删/没有公司):整批不写、返回 0、一次 insertBatchIgnore 都不发。
// 这一族的替代方案是"照常写、让 DEFAULT 盖一家",那是静默串数据,必须判红。
when(companyScopeSupport.companyIdOrNull(UPLOADER)).thenReturn(null);
void test_shared_asin_normal_unresolved_uploader_still_writes() {
// 10-06 定案「放开:照样写入」的钉子。账号已删/推不出归属时整批照写,只是那一列留空——
// 黑名单是全平台共享的,可见性不看这两列。原口径「推不出就整批不写」的后果是少一条黑名单 =
// 下次同样的品牌再买一次代理,那是为了一个不参与读过滤的列丢真实的降本数据。
when(invalidAsinDataMapper.insertBatchIgnore(anyList())).thenAnswer(
invocation -> ((List<?>) invocation.getArgument(0)).size());
int written = writer.writeBatch(List.of(row("B000000001", "nike"), row("B000000002", "zara")), UPLOADER);
int written = writer.writeBatch(List.of(row("B000000001", "nike"), row("B000000002", "zara")), null);
assertEquals(0, written, "归属推不出 ⇒ 一行都不写");
verify(invalidAsinDataMapper, never()).insertBatchIgnore(anyList());
assertEquals(2, written, "推不出发起账号也整批写入");
ArgumentCaptor<List<InvalidAsinDataEntity>> captor = ArgumentCaptor.forClass(List.class);
verify(invalidAsinDataMapper).insertBatchIgnore(captor.capture());
assertEquals(2, captor.getValue().size());
for (InvalidAsinDataEntity entity : captor.getValue()) {
assertNull(entity.getUploaderUserId(), "那一列留空即可,不许因此少写一行");
}
}
private static CollectDataResultRowVo row(String asin, String brand) {
@@ -36,10 +36,15 @@ import static org.mockito.Mockito.when;
* 还没摘,此后每个没显式传公司的写入都会被静默塞进默认那家——不报错、不丢数据,只在后台列表里
* 表现成"这条数据怎么在别家公司"。所以必须用代码在启动期喊出来,而不是写在注释里等人记得。</p>
*
* <p>V145 之后盯的是【一张清单】(users + 两张规则库 + V147 的 biz_product_category),不是一列:
* 漏登记的那张表等于没人盯,所以"探不到列"也要出声(见
* <p>V145 之后盯的是【一张清单】,不是一列:漏登记的那张表等于没人盯,所以"探不到列"也要出声(见
* {@link #unwatchedTableIsAnnouncedInsteadOfLookingClean})。清单与探针 SQL 的 IN 列表双向同源由
* {@link #watchedTablesMatchTheProbeSql} 钉住。</p>
*
* <p>清单也会随口径<b>缩短</b>:{@code biz_invalid_asin_data}(V145)与 {@code biz_product_category}
* (V147)已按 2026-10-06「品牌数据库/商品类目做成所有公司共享」的定案一并摘掉登记。这两列的
* {@code DEFAULT 1} 于是从"待摘的风险"翻转成"<b>承重</b>约束"——列还在库里,写入路径不再传公司,
* {@code NOT NULL} 就靠它填。此时哨兵再喊"去摘 DEFAULT",后果不是修好了而是每次写入 1364,
* 由 {@link #sharedTablesStayOutOfTheWatchList} 反向钉住不许回流。</p>
*/
class CompanyDefaultGuardTest {
@@ -125,7 +130,7 @@ class CompanyDefaultGuardTest {
@DisplayName("第二家公司已开通、users 的 DEFAULT 还在:打 ERROR 并带上哨兵标记")
void secondCompanyWithDefaultStillOnShoutsError() {
companies(2);
probeReturns("users=1", "biz_invalid_asin_data=null", "biz_dedupe_total_data=null");
probeReturns("users=1", "biz_dedupe_total_data=null");
guard.check();
@@ -136,18 +141,15 @@ class CompanyDefaultGuardTest {
}
@Test
@DisplayName("V145 的两张规则库带 DEFAULT:两张都要点出来,不许只报第一条")
void ruleTablesAreWatchedToo() {
@DisplayName("biz_dedupe_total_data 仍按公司:DEFAULT 还在必须点出来,不许因为它是清单第二条就漏掉")
void dedupeTableIsStillWatched() {
companies(2);
probeReturns("users=null",
"biz_invalid_asin_data=1",
"biz_dedupe_total_data=1");
probeReturns("users=null", "biz_dedupe_total_data=1");
guard.check();
assertThat(messageAt(Level.ERROR))
.contains(CompanyDefaultGuard.ALARM)
.contains("biz_invalid_asin_data.company_id DEFAULT=1")
.contains("biz_dedupe_total_data.company_id DEFAULT=1");
}
@@ -155,7 +157,7 @@ class CompanyDefaultGuardTest {
@DisplayName("给出的修复语句必须是 ALTER COLUMN ... DROP DEFAULT:MODIFY 会重建表、把派生归属洗掉")
void fixHintIsTheMetadataOnlyForm() {
companies(2);
probeReturns("users=null", "biz_invalid_asin_data=null", "biz_dedupe_total_data=1");
probeReturns("users=null", "biz_dedupe_total_data=1");
guard.check();
@@ -176,10 +178,10 @@ class CompanyDefaultGuardTest {
}
@Test
@DisplayName("三张表的 DEFAULT 都已摘掉:一声不响")
@DisplayName("清单里每一条的 DEFAULT 都已摘掉:一声不响")
void droppedDefaultKeepsQuiet() {
companies(3);
probeReturns("users=null", "biz_invalid_asin_data=null", "biz_dedupe_total_data=null");
probeReturns("users=null", "biz_dedupe_total_data=null");
guard.check();
@@ -191,7 +193,7 @@ class CompanyDefaultGuardTest {
@DisplayName("DEFAULT 是空串也按「已摘除」处理,别把空值读成还在")
void blankDefaultCountsAsDropped() {
companies(2);
probeReturns("users= ", "biz_invalid_asin_data=null", "biz_dedupe_total_data=null");
probeReturns("users= ", "biz_dedupe_total_data=null");
guard.check();
@@ -243,26 +245,46 @@ class CompanyDefaultGuardTest {
}
}
/**
* 反向钉,形状与 {@link #shopKeyTableIsWatchedToo} 相反。{@code biz_invalid_asin_data}(V145)
* 与 {@code biz_product_category}(V147)按 2026-10-06「这两页做成所有公司共享」的定案一起摘了登记,
* 但<b>列和 {@code DEFAULT 1} 都还在库里</b>——它们如今是 {@code NOT NULL} 的承重约束
* (写入路径不再传公司,全靠默认值填这一列)。
*
* <p>所以这一支演的是"探针<b>真的</b>把 {@code DEFAULT=1} 端上桌,哨兵必须一声不响"。
* 谁把这两张表加回 {@code WATCHED_TABLES}(那等于指挥运维去执行本类给出的 {@code DROP DEFAULT},
* 代价是每次写入 1364;品牌库那条还会被 {@code CollectDataInvalidAsinBatchWriter} 吞成 warn ⇒
* 接口报成功而黑名单静默少一批),就会在这里红。</p>
*
* <p>用 {@code probeReturnsOnly} 而不是 {@code probeReturns}:后者只按清单建行,未登记的表根本
* 进不了结果集——那样"哨兵没喊"是空转转出来的,不是判出来的。四张仍登记的表逐个给 {@code null},
* 既是这一支的正样本(少给一条就会撞 WARN 而红,说明"没喊"不是因为什么都没探到)。</p>
*/
@Test
@DisplayName("V147 的 biz_product_category 也在盯的清单里:摘 DEFAULT 那一步不许把它落下")
void productCategoryTableIsWatchedToo() {
@DisplayName("两张共享表故意不在清单里:探针端出 DEFAULT=1 也不许喊")
void sharedTablesStayOutOfTheWatchList() {
companies(2);
probeReturns("biz_product_category=1");
probeReturnsOnly("users=null",
"biz_dedupe_total_data=null",
"biz_shop_key=null",
"columns=null",
"biz_invalid_asin_data=1",
"biz_product_category=1");
guard.check();
assertThat(messageAt(Level.ERROR))
.contains(CompanyDefaultGuard.ALARM)
.contains("biz_product_category.company_id DEFAULT=1")
.contains("ALTER TABLE biz_product_category ALTER COLUMN company_id DROP DEFAULT")
.doesNotContain("MODIFY");
assertThat(CompanyDefaultGuard.WATCHED_TABLES)
.as("摘登记是定案的一部分:加回清单就等于让哨兵去喊一次真故障")
.doesNotContain("biz_invalid_asin_data", "biz_product_category");
assertThat(messageAt(Level.ERROR)).isEmpty();
assertThat(messageAt(Level.WARN)).isEmpty();
}
@Test
@DisplayName("探的是清单里这几张表的 company_id 列,表名列名写错就等于没探")
void probeReadsTheRightColumns() {
companies(2);
probeReturns("users=null", "biz_invalid_asin_data=null", "biz_dedupe_total_data=null");
probeReturns("users=null", "biz_dedupe_total_data=null");
guard.check();
@@ -277,6 +299,26 @@ class CompanyDefaultGuardTest {
}
}
/**
* V150 的 {@code biz_shop_key}:这一列的 DEFAULT 1 与前三张同形(只为同批旧 jar 存在),
* 而这张表<b>没有账号列</b>,历史归属的全部依据就是加列那一刻记录的默认值——
* 所以"摘 DEFAULT"这一步必须由哨兵盯着,漏摘的代价是第 2 家管理员新建的密钥静默归进第 1 家。
*/
@Test
@DisplayName("V150 的 biz_shop_key 也在盯的清单里:摘 DEFAULT 那一步不许把它落下")
void shopKeyTableIsWatchedToo() {
companies(2);
probeReturns("biz_shop_key=1");
guard.check();
assertThat(messageAt(Level.ERROR))
.contains(CompanyDefaultGuard.ALARM)
.contains("biz_shop_key.company_id DEFAULT=1")
.contains("ALTER TABLE biz_shop_key ALTER COLUMN company_id DROP DEFAULT")
.doesNotContain("MODIFY");
}
/**
* 双向钉同源。只钉"清单里的都在 SQL 里"会漏掉另一侧:有人往 SQL 的 IN 列表加了一张表、
* 却没加进 {@code WATCHED_TABLES},那么 {@link #check} 的逐表循环根本不会走到它——
@@ -307,7 +349,7 @@ class CompanyDefaultGuardTest {
private String probeSqlText() {
companies(2);
probeReturns("users=null", "biz_invalid_asin_data=null", "biz_dedupe_total_data=null");
probeReturns("users=null", "biz_dedupe_total_data=null");
guard.check();
ArgumentCaptor<String> sql = ArgumentCaptor.forClass(String.class);
verify(jdbcTemplate).queryForList(sql.capture());
@@ -9,17 +9,21 @@ import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.modules.company.mapper.CompanyMapper;
import com.nanri.aiimage.modules.company.model.dto.CompanySaveRequest;
import com.nanri.aiimage.modules.company.model.entity.CompanyEntity;
import com.nanri.aiimage.modules.permission.service.PermissionMenuService;
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 org.mockito.InOrder;
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.ArgumentMatchers.eq;
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
@@ -37,6 +41,7 @@ class CompanyServiceDirectoryTest {
private CompanyMapper companyMapper;
private AdminAuthSupport adminAuthSupport;
private PermissionMenuService permissionMenuService;
private CompanyService companyService;
@BeforeEach
@@ -46,7 +51,8 @@ class CompanyServiceDirectoryTest {
new MapperBuilderAssistant(new MybatisConfiguration(), ""), CompanyEntity.class);
companyMapper = mock(CompanyMapper.class);
adminAuthSupport = mock(AdminAuthSupport.class);
companyService = new CompanyService(companyMapper, adminAuthSupport);
permissionMenuService = mock(PermissionMenuService.class);
companyService = new CompanyService(companyMapper, adminAuthSupport, permissionMenuService);
}
private AdminUserEntity operator(String role, Long companyId) {
@@ -184,6 +190,44 @@ class CompanyServiceDirectoryTest {
assertThat(capturedSelectCount().getParamNameValuePairs()).containsValue("福州数富");
}
/**
* 设计文档 §2 D4 的那一行调用:每家公司一棵树之后,「新增公司」必须同批把菜单树建出来。
*
* <p>零菜单行的租户<b>全程不报错</b>——那家账号登录侧边栏全空、授权树一个勾都没有,
* 症状长得像"这个公司还没开通"。所以这一钉守的是 {@code create()} 里那次调用本身
* ({@code copyTreeFromTemplate} 的内部形状由 PermissionMenuServiceCompanyScopeTest 那三条盖),
* 而不是复制逻辑写得多对。</p>
*/
@Test
@DisplayName("超管新建公司:插行之后同一次写入里给它复制一套菜单树,模板取操作者本公司")
void createSeedsTheNewCompanyMenuTreeAfterInsert() {
when(companyMapper.selectCount(any())).thenReturn(0L);
// 真库里 insert 会回填自增 id;不模拟这一步就只能断出 copyTreeFromTemplate(null, …)。
when(companyMapper.insert(any(CompanyEntity.class))).thenAnswer(invocation -> {
invocation.getArgument(0, CompanyEntity.class).setId(77L);
return 1;
});
companyService.create(operator("super_admin", 5L), request("福州数富", null, null));
InOrder order = inOrder(companyMapper, permissionMenuService);
order.verify(companyMapper).insert(any(CompanyEntity.class));
// 模板公司取操作者的 5L 而不是硬编码 1L:厦门米椿花不再是"唯一有树的那家"以后,
// 抄公司 1 在眼下照样能跑,第三家开通时就把三家拴成一棵——那正是 §7 路线乙被否决的形状。
order.verify(permissionMenuService).copyTreeFromTemplate(77L, 5L);
}
@Test
@DisplayName("建公司被拒时不建树:重名那笔先抛,不许留下一套挂在不存在公司上的菜单")
void rejectedCreateDoesNotSeedMenuTree() {
when(companyMapper.selectCount(any())).thenReturn(1L);
assertThatThrownBy(() -> companyService.create(operator("super_admin", 1L), request("厦门米椿花", null, null)))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("已存在");
verify(permissionMenuService, never()).copyTreeFromTemplate(any(), any());
}
@Test
@DisplayName("公司名超过列宽 128 时先拒,别把 1406 抛成 500")
void createRejectsNameLongerThanColumn() {
@@ -6,6 +6,7 @@ import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.modules.company.mapper.CompanyMapper;
import com.nanri.aiimage.modules.company.model.entity.CompanyEntity;
import com.nanri.aiimage.modules.permission.service.PermissionMenuService;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
@@ -41,7 +42,8 @@ class CompanyServiceNameLookupTest {
TableInfoHelper.initTableInfo(
new MapperBuilderAssistant(new MybatisConfiguration(), ""), CompanyEntity.class);
companyMapper = mock(CompanyMapper.class);
companyService = new CompanyService(companyMapper, mock(AdminAuthSupport.class));
companyService = new CompanyService(companyMapper, mock(AdminAuthSupport.class),
mock(PermissionMenuService.class));
}
private CompanyEntity company(Long id, String name, int status) {
@@ -4,6 +4,7 @@ import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.modules.company.mapper.CompanyMapper;
import com.nanri.aiimage.modules.company.model.entity.CompanyEntity;
import com.nanri.aiimage.modules.permission.service.PermissionMenuService;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
@@ -49,7 +50,7 @@ class CompanyServiceRequireActiveTest {
}
private CompanyService service(CompanyMapper mapper) {
return new CompanyService(mapper, mock(AdminAuthSupport.class));
return new CompanyService(mapper, mock(AdminAuthSupport.class), mock(PermissionMenuService.class));
}
private CompanyEntity company(Long id, Integer status) {
@@ -1,10 +1,10 @@
package com.nanri.aiimage.modules.invalidasin.controller;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.modules.invalidasin.model.vo.InvalidAsinDataPageVo;
import com.nanri.aiimage.modules.invalidasin.service.InvalidAsinDataService;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.modules.permission.model.vo.PermissionMenuItemVo;
import com.nanri.aiimage.modules.permission.service.PermissionMenuService;
import org.junit.jupiter.api.BeforeEach;
@@ -20,13 +20,21 @@ import java.util.List;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.when;
/**
* 鉴权那一半(内网代理换真人、直连不许伪造 super_admin)+ 「全平台共享」的现网口径。
*
* <p>10-06 定案品牌数据库不区分公司:这里原先另有两条钉「tab 传什么都不算」的
* (超管不选 tab ⇒ 交给 service 的筛值是 null、非超管传别家 ⇒ 收窄成 null),它们吃的都是
* controller 上那个 {@code company_id} 形参,形参已随定案摘掉,两条一起删除。
* "公司维度不许回流"由 {@code CompanyIdParamGoesThroughReadScopeTest} 按 module 目录反向钉,
* 不靠本文件(这里连可断言的参数都没有了)。</p>
*/
@ExtendWith(MockitoExtension.class)
class InvalidAsinDataControllerTest {
@@ -36,8 +44,6 @@ class InvalidAsinDataControllerTest {
private AdminAuthSupport adminAuthSupport;
@Mock
private PermissionMenuService permissionMenuService;
@Mock
private com.nanri.aiimage.common.service.DataReadScope dataReadScope;
@InjectMocks
private InvalidAsinDataController controller;
@@ -60,13 +66,12 @@ class InvalidAsinDataControllerTest {
when(adminAuthSupport.currentRole(operator)).thenReturn(null);
when(permissionMenuService.getUserColumnPermissions(7L, "admin"))
.thenReturn(List.of(invalidAsinDataPermission()));
when(invalidAsinDataService.page(1L, 15L, "", "", "", 3L, 7L, false, null))
when(invalidAsinDataService.page(1L, 15L, "", "", "", 3L, 7L, false))
.thenReturn(new InvalidAsinDataPageVo());
when(dataReadScope.readCompanyId(operator, null)).thenReturn(null);
controller.page(1L, 15L, "", "", "", 3L, null, request);
controller.page(1L, 15L, "", "", "", 3L, request);
verify(invalidAsinDataService).page(1L, 15L, "", "", "", 3L, 7L, false, null);
verify(invalidAsinDataService).page(1L, 15L, "", "", "", 3L, 7L, false);
}
@Test
@@ -76,7 +81,7 @@ class InvalidAsinDataControllerTest {
request.addParameter("superAdmin", "true");
when(adminAuthSupport.requireUser(request)).thenThrow(new BusinessException(401, "未登录"));
assertThrows(BusinessException.class, () -> controller.page(1L, 15L, "", "", "", 3L, null, request));
assertThrows(BusinessException.class, () -> controller.page(1L, 15L, "", "", "", 3L, request));
verifyNoInteractions(invalidAsinDataService);
verify(permissionMenuService, never()).requireUserOperator(any());
@@ -89,52 +94,15 @@ class InvalidAsinDataControllerTest {
AdminUserEntity operator = user(1L, "super_admin");
when(adminAuthSupport.requireUser(request)).thenReturn(operator);
when(adminAuthSupport.currentRole(operator)).thenReturn("super_admin");
when(invalidAsinDataService.page(1L, 15L, "", "", "", 3L, 1L, true, 2L))
when(invalidAsinDataService.page(1L, 15L, "", "", "", 3L, 1L, true))
.thenReturn(new InvalidAsinDataPageVo());
when(dataReadScope.readCompanyId(operator, 2L)).thenReturn(2L);
controller.page(1L, 15L, "", "", "", 3L, 2L, request);
controller.page(1L, 15L, "", "", "", 3L, request);
verify(invalidAsinDataService).page(1L, 15L, "", "", "", 3L, 1L, true, 2L);
verify(invalidAsinDataService).page(1L, 15L, "", "", "", 3L, 1L, true);
verify(permissionMenuService, never()).getUserColumnPermissions(eq(1L), eq("admin"));
}
@Test
void superAdminWithoutCompanyTabStaysUnfiltered() {
// 反向钉:tab 没传公司(companyId=null)⇒ 交给 service 的筛值必须是 null(= 不筛)。
// 哪天有人把它硬写成某个默认公司,全量视图会静默变成一家的视图。
MockHttpServletRequest request = new MockHttpServletRequest();
AdminUserEntity operator = user(1L, "super_admin");
when(adminAuthSupport.requireUser(request)).thenReturn(operator);
when(adminAuthSupport.currentRole(operator)).thenReturn("super_admin");
when(dataReadScope.readCompanyId(operator, null)).thenReturn(null);
when(invalidAsinDataService.page(1L, 15L, "", "", "", 3L, 1L, true, null))
.thenReturn(new InvalidAsinDataPageVo());
controller.page(1L, 15L, "", "", "", 3L, null, request);
verify(invalidAsinDataService).page(1L, 15L, "", "", "", 3L, 1L, true, null);
}
@Test
void forgedCompanyTabForNonSuperAdminIsNarrowedToItsOwnCompany() {
// 非超管传别人的公司 id:出口给的是 null(不筛)而不是那家 —— 这页的隔离靠分组权限,
// 叠公司会把「靠分组可见」的行整批删掉。钉住"传什么都不算"的现网口径。
MockHttpServletRequest request = new MockHttpServletRequest();
AdminUserEntity operator = user(9L, "admin");
when(adminAuthSupport.requireUser(request)).thenReturn(operator);
when(adminAuthSupport.currentRole(operator)).thenReturn("admin");
when(permissionMenuService.getUserColumnPermissions(9L, "admin"))
.thenReturn(List.of(invalidAsinDataPermission()));
when(dataReadScope.readCompanyId(operator, 5L)).thenReturn(null);
when(invalidAsinDataService.page(1L, 15L, "", "", "", 3L, 9L, false, null))
.thenReturn(new InvalidAsinDataPageVo());
controller.page(1L, 15L, "", "", "", 3L, 5L, request);
verify(invalidAsinDataService).page(1L, 15L, "", "", "", 3L, 9L, false, null);
}
private AdminUserEntity user(Long id, String role) {
AdminUserEntity user = new AdminUserEntity();
user.setId(id);
@@ -4,7 +4,6 @@ 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.service.CompanyScopeSupport;
import com.nanri.aiimage.modules.invalidasin.mapper.InvalidAsinDataMapper;
import com.nanri.aiimage.modules.invalidasin.model.dto.InvalidAsinDataCreateRequest;
import com.nanri.aiimage.modules.invalidasin.model.dto.InvalidAsinDataUpdateRequest;
@@ -40,16 +39,10 @@ import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class InvalidAsinDataServiceTest {
/** 操作者 7L 所属公司。故意取 2 不取 1:DEFAULT 1 那家也能通过"非空"这一断言,取 2 才钉得住"真从会话来"。 */
private static final Long OPERATOR_COMPANY_ID = 2L;
@Mock
private InvalidAsinDataMapper invalidAsinDataMapper;
@Mock
private ShopManageGroupService shopManageGroupService;
/** 归属从操作者会话推导(create 里那唯一一处 requireCompanyId):不 mock 就是构造注入不到、整个 service 空指针。 */
@Mock
private CompanyScopeSupport companyScopeSupport;
@InjectMocks
private InvalidAsinDataService service;
@@ -63,7 +56,6 @@ class InvalidAsinDataServiceTest {
ShopManageGroupEntity group = group(9L, "group-a");
InvalidAsinDataEntity saved = data(91L, "MANUAL", 9L);
when(companyScopeSupport.requireCompanyId(7L)).thenReturn(OPERATOR_COMPANY_ID);
when(shopManageGroupService.listAccessibleGroupIds(7L, false)).thenReturn(Set.of(12L, 9L));
when(shopManageGroupService.getAccessibleById(9L, 7L, false)).thenReturn(group);
when(invalidAsinDataMapper.selectOne(any())).thenReturn(null);
@@ -83,21 +75,23 @@ class InvalidAsinDataServiceTest {
assertEquals("MANUAL", captor.getValue().getRecordSource());
assertEquals("group-a", item.getGroupName());
assertEquals("MANUAL", item.getRecordSource());
// 写侧归属:MANUAL 行的 company_id 必须真从操作者会话推导。V146 已摘掉该列的 DEFAULT 1,
// 没人推导就是 NULL —— 而 NULL 行在 readCompanyId 谓词下对所有公司 tab 都不可见(静默删除),
// 比"归属错一家"更难发现。
assertEquals(OPERATOR_COMPANY_ID, captor.getValue().getCompanyId());
assertEquals(7L, captor.getValue().getUploaderUserId());
// 重复预检必须与 V145 放宽后的唯一键 (company_id, data_value, brand) 同宽:少公司这一维,
// 第 2 家永远无法新增第 1 家已有的品牌(跨公司误报「ASIN 已存在」)。
// 重复预检与 V151 退回后的全局唯一键 (data_value, brand) 同宽。
// 这是反向钉(2026-10-06 定案「品牌数据库全平台共享,不区分」):预检再带上 company_id 的话,
// 键是全局的而预检是按家的 ⇒ 同一 ASIN 在第 2 家能插进去,撞库时报 1062 而不是「ASIN 已存在」,
// 用户看到的是一句 500。所以这里钉的是"谓词里没有公司维度",不是"没有正样本"。
ArgumentCaptor<LambdaQueryWrapper<InvalidAsinDataEntity>> unique =
ArgumentCaptor.forClass((Class) LambdaQueryWrapper.class);
verify(invalidAsinDataMapper).selectOne(unique.capture());
TableInfoHelper.initTableInfo(
new MapperBuilderAssistant(new MybatisConfiguration(), ""),
InvalidAsinDataEntity.class);
assertTrue(unique.getValue().getSqlSegment().contains("company_id"));
assertTrue(unique.getValue().getParamNameValuePairs().containsValue(OPERATOR_COMPANY_ID));
String uniqueSql = unique.getValue().getSqlSegment();
assertTrue(uniqueSql.contains("data_value"), "预检判据整段没了:换了写法,下面的排他就是空断言");
assertFalse(uniqueSql.contains("company_id"),
"ensureUnique 又带上了 company_id:唯一键已退回全局(V151),按家预检会让重复行撞 1062 而不是报「ASIN 已存在」");
assertFalse(uniqueSql.contains("group_id"),
"ensureUnique 又按分组预检了:全局键里没有分组这一维,同形状会漏判");
}
@Test
@@ -109,7 +103,7 @@ class InvalidAsinDataServiceTest {
when(invalidAsinDataMapper.selectList(any())).thenReturn(List.of(manual));
when(shopManageGroupService.buildGroupNameMap(any())).thenReturn(Map.of(9L, "group-a"));
InvalidAsinDataPageVo page = service.page(1, 15, "", "", "", 10L, 7L, false, null);
InvalidAsinDataPageVo page = service.page(1, 15, "", "", "", 10L, 7L, false);
ArgumentCaptor<LambdaQueryWrapper<InvalidAsinDataEntity>> captor = ArgumentCaptor.forClass((Class) LambdaQueryWrapper.class);
verify(invalidAsinDataMapper).selectCount(captor.capture());
@@ -133,7 +127,7 @@ class InvalidAsinDataServiceTest {
when(invalidAsinDataMapper.selectList(any())).thenReturn(List.of(automatic, orphan));
when(shopManageGroupService.buildGroupNameMap(any())).thenReturn(Map.of());
InvalidAsinDataPageVo page = service.page(1, 15, "", "", "", null, 1L, true, null);
InvalidAsinDataPageVo page = service.page(1, 15, "", "", "", null, 1L, true);
assertEquals(2, page.getItems().size());
assertEquals("AUTO", page.getItems().getFirst().getRecordSource());
@@ -147,7 +141,7 @@ class InvalidAsinDataServiceTest {
when(invalidAsinDataMapper.selectCount(any())).thenReturn(0L);
when(invalidAsinDataMapper.selectList(any())).thenReturn(List.of());
service.page(1, 15, "", "", "", 9L, 1L, true, null);
service.page(1, 15, "", "", "", 9L, 1L, true);
ArgumentCaptor<LambdaQueryWrapper<InvalidAsinDataEntity>> captor = ArgumentCaptor.forClass((Class) LambdaQueryWrapper.class);
verify(invalidAsinDataMapper).selectCount(captor.capture());
@@ -164,7 +158,7 @@ class InvalidAsinDataServiceTest {
when(invalidAsinDataMapper.selectCount(any())).thenReturn(0L);
when(invalidAsinDataMapper.selectList(any())).thenReturn(List.of());
service.page(1, 15, "", "B01", "acme", null, 1L, true, null);
service.page(1, 15, "", "B01", "acme", null, 1L, true);
ArgumentCaptor<LambdaQueryWrapper<InvalidAsinDataEntity>> captor = ArgumentCaptor.forClass((Class) LambdaQueryWrapper.class);
verify(invalidAsinDataMapper).selectCount(captor.capture());
@@ -141,8 +141,18 @@ class PermissionCompanyMenuHiddenTest {
return code.substring(from, end);
}
/**
* 每一处引用受控集的出口都要点名数到(原名 {@code threeExitsAllReferenceTheSuperAdminOnlySet})。
*
* <p>V149(每家公司一套菜单树,定案 D3)冒出第四处出口:{@code copyTreeFromTemplate} 给新公司复制
* 模板树时<b>不许</b>把 {@code admin_companies} 那一行复制过去——它是角色内在闸门,公司 2 的树里
* 根本没有这行才干净。按 {@code docs/plans/19-company-tab.md} 那条交代("要加第四处出口 = 未批准的
* 行为变化,须自带一记变异"),这一记已经跑了:变异点 {@code copyTree clones the role-intrinsic gate row}
* 被 {@code PermissionMenuServiceCompanyScopeTest} 的「建树:三种 menu_type 全复制、闸门行不复制」打死,
* 详见 {@code docs/ops/menu-company-tree-design-2026-10-06.md} §8。</p>
*/
@Test
void threeExitsAllReferenceTheSuperAdminOnlySet() throws IOException {
void everyExitReferencesTheSuperAdminOnlySet() throws IOException {
String text = source();
assertThat(text).contains("SUPER_ADMIN_ONLY_KEYS");
List<String> code = executableCodeLines(text);
@@ -151,30 +161,31 @@ class PermissionCompanyMenuHiddenTest {
// 注释必须真被滤掉了:javadoc 里那四处 SUPER_ADMIN_ONLY_KEYS 链接一旦混进取样集,上面的计数就又回到"数得出但没数代码"。
assertThat(code).as("扫描取样集自检: 注释行必须已被剔除")
.noneMatch(line -> line.contains("{@link") || line.trim().startsWith("*"));
assertThat(code).as("扫描取样集自检: 三处出口都落在 toItemVos/落库这条链上,扫描必须扫得到它")
assertThat(code).as("扫描取样集自检: 出口 1/2 落在 toItemVos/落库这条链上,扫描必须扫得到它")
.filteredOn(line -> line.contains("toItemVos(")).isNotEmpty();
// 三个出口各自都要引用它,而且只数代码:漏一个就留一条旁路(授权树能看见 / 当前用户菜单能带出 / 提交能写回)。
// 四个出口各自都要引用它,而且只数代码:漏一个就留一条旁路(授权树能看见 / 当前用户菜单能带出 /
// 提交能写回 / 新公司能拿到一行本该只在公司 1 树里存在的闸门菜单)。
// 旧写法是"SUPER_ADMIN_ONLY_KEYS 在整份文本里出现 ≥4 次",可 1 处定义 + 4 处 javadoc 就凑得满(三处过滤器全删仍剩 5 次),
// 三处过滤器全删(或移进注释 / if (false) / 死分支)它照样绿 —— 变异 R10 就是这一记。
// 现在逐口钉:负向("不是受控项才留下")= 出口 1 的 list(operator, menuType, grantableOnly)
// 与出口 2 的 getUserColumnPermissions(...) 各一条;正向("是受控项才进剥离集")
// = 出口 3 用来反解受控 id 的 superAdminOnlyMenuIds() 一条。行号会漂,所以只点方法名。
// 将来真要加第四处出口时,连同这三条期望一起改(当前口径:恰三处出口,不许多也不许少)。
// 现在逐口钉:负向("不是受控项才留下")= 出口 1 的 list(operator, menuType, grantableOnly)、
// 出口 2 的 getUserColumnPermissions(...)、出口 4 的 copyTreeFromTemplate(...) 各一条;
// 正向("是受控项才进剥离集")= 出口 3 用来反解受控 id 的 superAdminOnlyMenuIds() 一条。行号会漂,所以只点方法名。
// 将来真要加第五处出口时,连同这三条期望一起改(当前口径:恰四处出口,不许多也不许少)。
List<String> negative = code.stream().filter(line -> line.contains(NEGATIVE_FILTER)).toList();
List<String> positive = code.stream()
.filter(line -> line.contains(POSITIVE_FILTER))
.filter(line -> !line.contains(NEGATIVE_FILTER))
.toList();
assertThat(negative)
.as("出口 1(授权树)+ 出口 2(当前用户菜单)各一条负向过滤,少一条就是一条旁路")
.hasSize(2);
.as("出口 1(授权树)+ 出口 2(当前用户菜单)+ 出口 4(给新公司复制树)各一条负向过滤,少一条就是一条旁路")
.hasSize(3);
assertThat(positive)
.as("出口 3(提交剥离)的正向反解恰好一条")
.hasSize(1);
assertThat(code.stream().filter(line -> line.contains(GUARD_SET)).toList())
.as("1 处定义 + 3 处出口,全都得落在可执行行上")
.hasSizeGreaterThanOrEqualTo(4);
.as("1 处定义 + 4 处出口,全都得落在可执行行上")
.hasSizeGreaterThanOrEqualTo(5);
}
@Test
@@ -3,6 +3,7 @@ package com.nanri.aiimage.modules.permission.controller;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.modules.permission.model.dto.ImageVideoDataPermissionUpdateRequest;
import com.nanri.aiimage.modules.permission.model.dto.PermissionMenuCreateRequest;
import com.nanri.aiimage.modules.permission.model.dto.UserColumnPermissionUpdateRequest;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.modules.permission.model.vo.ImageVideoDataPermissionUserVo;
@@ -15,10 +16,10 @@ import org.junit.jupiter.api.io.TempDir;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;
import java.util.Map;
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.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
@@ -30,6 +31,12 @@ import static org.mockito.Mockito.when;
class PermissionMenuControllerTest {
/**
* 归属判据的返回值替身:与测试里传进去的 {@code 7L} 不同,这样"下游收到的是判据的结果"
* 这一条才有内容——若控制器仍传原文,verify 会拿 7L 与 99L 对不上而红。
*/
private static final Long RESOLVED_COMPANY = 99L;
@Test
void effectivePermissionEndpointAllowsAuthenticatedNormalUserToReadSelf() {
AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
@@ -125,12 +132,16 @@ class PermissionMenuControllerTest {
when(request.getHeader("X-Internal-Token")).thenReturn("shared-token");
when(request.getParameter("operatorId")).thenReturn("12");
when(service.requireAdminOperator(12L)).thenReturn(operator);
when(service.list(operator, "app", false)).thenReturn(List.of());
// 归属判据给什么,下游就查什么:这里故意返回与入参 7L 不同的 99L,
// 于是"控制器把 tab 原文往下传"和"控制器把判据的结果往下传"两种写法给不出同一个绿。
when(service.resolveScopeCompanyId(operator, 7L)).thenReturn(RESOLVED_COMPANY);
when(service.list(operator, "app", false, RESOLVED_COMPANY)).thenReturn(List.of());
controller.listMenus(request, "app", false);
controller.listMenus(request, "app", false, 7L);
verify(service).requireAdminOperator(12L);
verify(service).list(operator, "app", false);
verify(service).resolveScopeCompanyId(operator, 7L);
verify(service).list(operator, "app", false, RESOLVED_COMPANY);
verify(request, never()).getParameter("superAdmin");
}
@@ -146,10 +157,11 @@ class PermissionMenuControllerTest {
when(authSupport.requireAdmin(request)).thenThrow(authFailure);
when(request.getHeader("X-Internal-Token")).thenReturn("wrong-token");
assertThatThrownBy(() -> controller.listMenus(request, "app", false))
assertThatThrownBy(() -> controller.listMenus(request, "app", false, 7L))
.isSameAs(authFailure);
verify(service, never()).requireAdminOperator(anyLong());
verify(service, never()).list(any(AdminUserEntity.class), eq("app"), eq(false));
// 只 verify 某一组形参的 never() 会随控制器换签名一起失效,这里要的是「一次服务调用都没发生」。
verifyNoInteractions(service);
}
@Test
@@ -167,17 +179,20 @@ class PermissionMenuControllerTest {
body.setUserIds(List.of(20L));
when(authSupport.requireAdmin(request)).thenReturn(operator);
when(service.listImageVideoDataPermissionUsers(operator)).thenReturn(List.of(permissionUser));
when(service.updateImageVideoDataPermissionUsers(operator, List.of(20L))).thenReturn(1);
when(service.resolveScopeCompanyId(operator, 7L)).thenReturn(RESOLVED_COMPANY);
when(service.listImageVideoDataPermissionUsers(operator, RESOLVED_COMPANY)).thenReturn(List.of(permissionUser));
when(service.updateImageVideoDataPermissionUsers(operator, RESOLVED_COMPANY, List.of(20L))).thenReturn(1);
var listResponse = controller.listImageVideoDataPermissionUsers(request);
var updateResponse = controller.updateImageVideoDataPermissionUsers(request, body);
var listResponse = controller.listImageVideoDataPermissionUsers(request, 7L);
var updateResponse = controller.updateImageVideoDataPermissionUsers(request, 7L, body);
assertThat(listResponse.getData()).containsExactly(permissionUser);
assertThat(updateResponse.getData()).isEqualTo(1);
verify(authSupport, times(2)).requireAdmin(request);
verify(service).listImageVideoDataPermissionUsers(operator);
verify(service).updateImageVideoDataPermissionUsers(operator, List.of(20L));
// 两页数据范围授权本批只做到后端:读与写都先过判据、再按判据那一家取数(界面还没接 tab)。
verify(service, times(2)).resolveScopeCompanyId(operator, 7L);
verify(service).listImageVideoDataPermissionUsers(operator, RESOLVED_COMPANY);
verify(service).updateImageVideoDataPermissionUsers(operator, RESOLVED_COMPANY, List.of(20L));
}
@Test
@@ -195,16 +210,73 @@ class PermissionMenuControllerTest {
body.setUserIds(List.of(20L));
when(authSupport.requireAdmin(request)).thenReturn(operator);
when(service.listShopDataCrawlDataPermissionUsers(operator)).thenReturn(List.of(permissionUser));
when(service.updateShopDataCrawlDataPermissionUsers(operator, List.of(20L))).thenReturn(1);
when(service.resolveScopeCompanyId(operator, 7L)).thenReturn(RESOLVED_COMPANY);
when(service.listShopDataCrawlDataPermissionUsers(operator, RESOLVED_COMPANY)).thenReturn(List.of(permissionUser));
when(service.updateShopDataCrawlDataPermissionUsers(operator, RESOLVED_COMPANY, List.of(20L))).thenReturn(1);
var listResponse = controller.listShopDataCrawlDataPermissionUsers(request);
var updateResponse = controller.updateShopDataCrawlDataPermissionUsers(request, body);
var listResponse = controller.listShopDataCrawlDataPermissionUsers(request, 7L);
var updateResponse = controller.updateShopDataCrawlDataPermissionUsers(request, 7L, body);
assertThat(listResponse.getData()).containsExactly(permissionUser);
assertThat(updateResponse.getData()).isEqualTo(1);
verify(authSupport, times(2)).requireAdmin(request);
verify(service).listShopDataCrawlDataPermissionUsers(operator);
verify(service).updateShopDataCrawlDataPermissionUsers(operator, List.of(20L));
verify(service, times(2)).resolveScopeCompanyId(operator, 7L);
verify(service).listShopDataCrawlDataPermissionUsers(operator, RESOLVED_COMPANY);
verify(service).updateShopDataCrawlDataPermissionUsers(operator, RESOLVED_COMPANY, List.of(20L));
}
/**
* {@code company_id} 必须先交给归属判据、再由判据的结果决定建到哪家:控制器自己兜一个默认公司,
* 等于把「站超管指定别家」这条需求做成假的,而且缺省值会在前端没带参数时静默变成「只看公司 1」。
*/
@Test
void createMenuForwardsCompanyIdAndReorderForwardsOperator() {
AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
PermissionMenuService service = mock(PermissionMenuService.class);
HttpServletRequest request = mock(HttpServletRequest.class);
PermissionMenuController controller = new PermissionMenuController(authSupport, service);
AdminUserEntity operator = new AdminUserEntity();
operator.setId(1L);
operator.setRole("super_admin");
operator.setCompanyId(7L);
PermissionMenuCreateRequest createRequest = new PermissionMenuCreateRequest();
when(authSupport.requireAdmin(request)).thenReturn(operator);
when(service.resolveScopeCompanyId(operator, 7L)).thenReturn(RESOLVED_COMPANY);
controller.createMenu(request, createRequest, 7L);
controller.reorderColumns(request, Map.of("ordered_ids", List.of(2L, 1L)));
verify(service).resolveScopeCompanyId(operator, 7L);
verify(service).create(operator, RESOLVED_COMPANY, createRequest);
// 排序原先只有 ids 没有操作者,公司闸门就无处可查;换签名后必须确认操作者真到了 service。
verify(service).reorder(operator, List.of(2L, 1L));
}
/**
* 前端没带 {@code company_id} 时,控制器把 {@code null} 原样交给判据,自己一个字都不编:
* "那一家到底是哪家"由 {@code resolveScopeCompanyId} 定(非超管=本公司,超管=本公司那棵树),
* 下游拿到的是它的返回值而不是 {@code null},这样"缺省到底查了哪家"在两条断言里都留得下痕迹。
*/
@Test
void absentCompanyIdGoesToTheScopeDoorInsteadOfAnInventedDefault() {
AdminAuthSupport authSupport = mock(AdminAuthSupport.class);
PermissionMenuService service = mock(PermissionMenuService.class);
HttpServletRequest request = mock(HttpServletRequest.class);
PermissionMenuController controller = new PermissionMenuController(authSupport, service);
AdminUserEntity operator = new AdminUserEntity();
operator.setId(1L);
operator.setRole("admin");
operator.setCompanyId(7L);
when(authSupport.requireAdmin(request)).thenReturn(operator);
when(service.resolveScopeCompanyId(operator, null)).thenReturn(7L);
controller.listMenus(request, "admin", false, null);
controller.listImageVideoDataPermissionUsers(request, null);
controller.listShopDataCrawlDataPermissionUsers(request, null);
verify(service, times(3)).resolveScopeCompanyId(operator, null);
verify(service).list(operator, "admin", false, 7L);
verify(service).listImageVideoDataPermissionUsers(operator, 7L);
verify(service).listShopDataCrawlDataPermissionUsers(operator, 7L);
}
}
@@ -0,0 +1,536 @@
package com.nanri.aiimage.modules.permission.service;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
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.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.PermissionMenuCreateRequest;
import com.nanri.aiimage.modules.permission.model.dto.PermissionMenuUpdateRequest;
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.ImageVideoDataPermissionUserVo;
import com.nanri.aiimage.modules.permission.model.vo.PermissionMenuItemVo;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.stubbing.Answer;
import java.util.ArrayList;
import java.util.LinkedHashSet;
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.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.nullable;
import static org.mockito.Mockito.atLeast;
import static org.mockito.Mockito.clearInvocations;
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;
/**
* V149「每家公司一套菜单树」之后的归属判定(设计文档 §5、定案 D1/D2/D3)。
*
* <p>这些用例的共同写法是<b>让 mock 装作一间真库</b>:带了 {@code company_id} 条件就只回本公司的行,
* 没带就把别家那行也交出来。于是"少写一个公司条件"不会表现为一行代码没被覆盖,而表现为
* 返回值里冒出别家的 id —— 断言打在结果上,而不是打在"源码里有没有那一句"上。</p>
*
* <p>为什么值得这么绕:这一族的失效全是静默的。按 key 点查少一个条件就是 {@code LIMIT 1}
* 跨公司借位(页面显示已授权、账号永远拿不到那份权限);读侧不收窄就是两家的同名菜单混进同一个
* 响应(前端按 key 建树直接长错形)。两者都不抛异常、都不进巡检。</p>
*/
class PermissionMenuServiceCompanyScopeTest {
private static final long COMPANY_A = 1L;
private static final long COMPANY_B = 2L;
private static final Set<Object> KNOWN_COMPANIES = Set.of(COMPANY_A, COMPANY_B);
private static final String IMAGE_VIDEO_KEY = "admin_image_video_task_data";
private PermissionMenuMapper menuMapper;
private UserColumnPermissionMapper permissionMapper;
private AdminUserMapper userMapper;
private PermissionMenuService service;
/** lambda 条件要渲染成 SQL 才往 paramNameValuePairs 落值,而渲染依赖 TableInfo 缓存。 */
@BeforeAll
static void initMybatisPlusTableInfo() {
MapperBuilderAssistant assistant = new MapperBuilderAssistant(new MybatisConfiguration(), "");
TableInfoHelper.initTableInfo(assistant, PermissionMenuEntity.class);
TableInfoHelper.initTableInfo(assistant, AdminUserEntity.class);
}
@BeforeEach
void setUp() {
menuMapper = mock(PermissionMenuMapper.class);
permissionMapper = mock(UserColumnPermissionMapper.class);
userMapper = mock(AdminUserMapper.class);
service = new PermissionMenuService(menuMapper, permissionMapper, userMapper);
}
// --------------------------------------------------------------- 夹具
private static PermissionMenuEntity menu(long id, long companyId, String columnKey,
String menuType, Long parentId, int sortOrder) {
PermissionMenuEntity entity = new PermissionMenuEntity();
entity.setId(id);
entity.setCompanyId(companyId);
entity.setName(columnKey);
entity.setColumnKey(columnKey);
entity.setMenuType(menuType);
entity.setRoutePath("/" + columnKey);
entity.setParentId(parentId);
entity.setSortOrder(sortOrder);
return entity;
}
private static AdminUserEntity user(long id, String role, Long companyId) {
AdminUserEntity entity = new AdminUserEntity();
entity.setId(id);
entity.setUsername("u" + id);
entity.setRole(role);
entity.setCompanyId(companyId);
return entity;
}
private static UserColumnPermissionEntity grant(long userId, long columnId) {
UserColumnPermissionEntity entity = new UserColumnPermissionEntity();
entity.setUserId(userId);
entity.setColumnId(columnId);
return entity;
}
/** 先摸一次 getSqlSegment():MP 只在条件渲染时把值写进 paramNameValuePairs。 */
private static List<Object> params(LambdaQueryWrapper<?> query) {
assertThat(query.getSqlSegment()).isNotNull();
return new ArrayList<>(query.getParamNameValuePairs().values());
}
private static List<Object> params(LambdaUpdateWrapper<?> update) {
assertThat(update.getSqlSegment()).isNotNull();
return new ArrayList<>(update.getParamNameValuePairs().values());
}
/** 这条查询有没有按公司筛过——用"参数里出现了任一已知公司 id"来读,不认列名字符串。 */
private static boolean filteredByAnyCompany(LambdaQueryWrapper<?> query) {
return params(query).stream().anyMatch(KNOWN_COMPANIES::contains);
}
/**
* 一间真库:带公司条件只回那一家,不带就把两家都回出来(=借位)。
* 用例因此同时咬得住"条件漏了"(结果多出别家)与"条件写死了别家"(结果少了本该有的)。
*/
private static List<PermissionMenuEntity> fakeDbRows(List<PermissionMenuEntity> all,
LambdaQueryWrapper<PermissionMenuEntity> query) {
if (!filteredByAnyCompany(query)) {
return new ArrayList<>(all);
}
List<Object> values = params(query);
List<PermissionMenuEntity> hits = new ArrayList<>();
for (PermissionMenuEntity row : all) {
if (values.contains(row.getCompanyId())) {
hits.add(row);
}
}
return hits;
}
private static Answer<List<PermissionMenuEntity>> menusFromFakeDb(List<PermissionMenuEntity> all) {
return invocation -> fakeDbRows(all, invocation.getArgument(0));
}
/** 账号侧同一间真库:{@code grantableUserQuery} 少了公司条件就会把别家的人一起列进来。 */
private static List<AdminUserEntity> fakeDbUsers(List<AdminUserEntity> all,
LambdaQueryWrapper<AdminUserEntity> query) {
if (!filteredByAnyCompany(query)) {
return new ArrayList<>(all);
}
List<Object> values = params(query);
List<AdminUserEntity> hits = new ArrayList<>();
for (AdminUserEntity row : all) {
if (values.contains(row.getCompanyId())) {
hits.add(row);
}
}
return hits;
}
/**
* 两家公司各有一套同名 key 的树(A 家 id 个位/十位、B 家 id 1xx),
* 外加一条只在 A 家存在的角色内在闸门行 {@code admin_companies}。
*/
private List<PermissionMenuEntity> twoTrees() {
return new ArrayList<>(List.of(
menu(9, COMPANY_A, "admin_group_data", "admin", null, 5),
menu(10, COMPANY_A, "collect-data", "admin", 9L, 10),
menu(109, COMPANY_A, "admin_companies", "admin", null, 200),
menu(111, COMPANY_B, "admin_group_data", "admin", null, 5),
menu(110, COMPANY_B, "collect-data", "admin", 111L, 10)));
}
// ------------------------------------------------------------------ 用例
@Test
@DisplayName("非超管取菜单目录时,每一次取数都带他自己那一家")
void everyMenuQueryCarriesTheOperatorsCompany() {
when(userMapper.selectById(20L)).thenReturn(user(20L, "admin", COMPANY_B));
when(permissionMapper.selectByUserId(20L)).thenReturn(List.of());
when(menuMapper.selectList(any())).thenReturn(List.of());
service.list(user(20L, "admin", COMPANY_B), "admin", false);
ArgumentCaptor<LambdaQueryWrapper<PermissionMenuEntity>> captor =
ArgumentCaptor.forClass(LambdaQueryWrapper.class);
// 目录取数 + 可授予集合展开,两次都必须带公司;少任一次=别家的行混进同一个响应。
verify(menuMapper, atLeast(2)).selectList(captor.capture());
for (LambdaQueryWrapper<PermissionMenuEntity> query : captor.getAllValues()) {
assertThat(params(query)).contains(COMPANY_B);
}
}
@Test
@DisplayName("定案 D2:站点超管可以指定任意一家,非超管指定别家一律 403 且不落到任何查询")
void onlyTheSiteSuperAdminMayCrossCompanies() {
when(menuMapper.selectList(any())).thenReturn(List.of());
service.list(user(1L, "super_admin", COMPANY_A), "admin", false, COMPANY_B);
ArgumentCaptor<LambdaQueryWrapper<PermissionMenuEntity>> captor =
ArgumentCaptor.forClass(LambdaQueryWrapper.class);
verify(menuMapper).selectList(captor.capture());
assertThat(params(captor.getValue())).contains(COMPANY_B);
clearInvocations(menuMapper);
assertThatThrownBy(() -> service.list(user(20L, "admin", COMPANY_B), "admin", false, COMPANY_A))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("其他公司");
verify(menuMapper, never()).selectList(any());
}
@Test
@DisplayName("company_id 传 0 或负数是在查询之前就拒掉,不是拿去点查一轮")
void nonPositiveCompanyIdIsRejectedBeforeAnyQuery() {
assertThatThrownBy(() -> service.list(user(1L, "super_admin", COMPANY_A), "admin", false, 0L))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("company_id 无效");
assertThatThrownBy(() -> service.list(user(1L, "super_admin", COMPANY_A), "admin", false, -3L))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("company_id 无效");
verify(menuMapper, never()).selectList(any());
}
@Test
@DisplayName("内部数据权限行与可授权用户列表必须解析到同一家:少一个条件就把别家的人列进来")
void dataPermissionLookupAndUserListResolveToTheSameCompany() {
List<PermissionMenuEntity> all = List.of(
menu(75, COMPANY_A, IMAGE_VIDEO_KEY, "admin", null, 10),
menu(975, COMPANY_B, IMAGE_VIDEO_KEY, "admin", null, 10));
// selectOne 同真库:带公司条件命中本公司行;漏条件就 LIMIT 1 借位到 A 家那行。
when(menuMapper.selectOne(any())).thenAnswer(invocation ->
fakeDbRows(all, (LambdaQueryWrapper<PermissionMenuEntity>) invocation.getArgument(0)).get(0));
when(permissionMapper.selectByColumnId(75L)).thenReturn(List.of(grant(300L, 75L)));
when(permissionMapper.selectByColumnId(975L)).thenReturn(List.of(grant(400L, 975L)));
when(userMapper.selectList(any())).thenAnswer(invocation -> fakeDbUsers(
List.of(user(300L, "admin", COMPANY_A), user(400L, "admin", COMPANY_B)),
invocation.getArgument(0)));
List<ImageVideoDataPermissionUserVo> visible =
service.listImageVideoDataPermissionUsers(user(1L, "super_admin", COMPANY_B));
assertThat(visible).extracting(ImageVideoDataPermissionUserVo::getId).containsExactly(400L);
assertThat(visible).extracting(ImageVideoDataPermissionUserVo::isGranted).containsExactly(true);
}
@Test
@DisplayName("跨公司挂父被拒:外键只保证父行存在,挡不住挂到别家的分组上")
void crossCompanyParentIsRejected() {
PermissionMenuCreateRequest request = new PermissionMenuCreateRequest();
request.setName("新页面");
request.setColumnKey("brand-new");
request.setMenuType("admin");
request.setRoutePath("/brand-new");
request.setParentId(9L);
when(menuMapper.selectById(9L)).thenReturn(menu(9, COMPANY_A, "admin_group_data", "admin", null, 5));
assertThatThrownBy(() -> service.create(user(20L, "admin", COMPANY_B), null, request))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("同一公司");
verify(menuMapper, never()).insert(any(PermissionMenuEntity.class));
}
@Test
@DisplayName("整条祖先链都要同一家:父是同公司、上面挂着别家的分组也一样拒")
void crossCompanyAncestorIsRejected() {
PermissionMenuCreateRequest request = new PermissionMenuCreateRequest();
request.setName("新页面");
request.setColumnKey("brand-new");
request.setMenuType("admin");
request.setRoutePath("/brand-new");
request.setParentId(50L);
when(menuMapper.selectById(50L)).thenReturn(menu(50, COMPANY_B, "b-group", "admin", 9L, 5));
when(menuMapper.selectById(9L)).thenReturn(menu(9, COMPANY_A, "admin_group_data", "admin", null, 5));
assertThatThrownBy(() -> service.create(user(20L, "admin", COMPANY_B), null, request))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("同一公司");
verify(menuMapper, never()).insert(any(PermissionMenuEntity.class));
}
@Test
@DisplayName("同名 key 在别家已存在不算重复:查重范围=本公司(与 uk_company_column_key 同一条键)")
void sameColumnKeyInAnotherCompanyDoesNotBlockMyCreate() {
when(menuMapper.selectOne(any())).thenAnswer(invocation -> {
LambdaQueryWrapper<PermissionMenuEntity> query = invocation.getArgument(0);
// 带公司条件:B 家没有 collect-data ⇒ null;漏了条件:A 家那行就成"重复"。
return params(query).contains(COMPANY_B)
? null
: menu(10, COMPANY_A, "collect-data", "admin", 9L, 10);
});
when(menuMapper.insert(any(PermissionMenuEntity.class))).thenAnswer(invocation -> {
invocation.getArgument(0, PermissionMenuEntity.class).setId(777L);
return 1;
});
when(menuMapper.selectById(777L)).thenReturn(menu(777, COMPANY_B, "collect-data", "admin", null, 11));
PermissionMenuCreateRequest request = new PermissionMenuCreateRequest();
request.setName("德阳的采集页");
request.setColumnKey("collect-data");
request.setMenuType("admin");
request.setRoutePath("/collect-data");
request.setSortOrder(11);
assertThat(service.create(user(20L, "admin", COMPANY_B), null, request).getId()).isEqualTo(777L);
ArgumentCaptor<PermissionMenuEntity> captor = ArgumentCaptor.forClass(PermissionMenuEntity.class);
verify(menuMapper).insert(captor.capture());
assertThat(captor.getValue().getCompanyId()).isEqualTo(COMPANY_B);
assertThat(captor.getValue().getColumnKey()).isEqualTo("collect-data");
}
@Test
@DisplayName("改/删/排别家的菜单一律 403,而且改之前就被拒,不会先读后写地留痕")
void writesToAnotherCompanysMenuAreForbidden() {
when(menuMapper.selectById(10L)).thenReturn(menu(10, COMPANY_A, "collect-data", "admin", 9L, 10));
PermissionMenuUpdateRequest update = new PermissionMenuUpdateRequest();
update.setName("改名");
update.setColumnKey("collect-data");
update.setMenuType("admin");
update.setRoutePath("/collect-data");
assertThatThrownBy(() -> service.update(user(20L, "admin", COMPANY_B), 10L, update))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("其他公司");
assertThatThrownBy(() -> service.delete(user(20L, "admin", COMPANY_B), 10L))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("其他公司");
assertThatThrownBy(() -> service.reorder(user(20L, "admin", COMPANY_B), List.of(10L, 11L)))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("其他公司");
verify(menuMapper, never()).updateById(any(PermissionMenuEntity.class));
verify(menuMapper, never()).deleteById(anyLong());
verify(permissionMapper, never()).deleteByColumnId(any());
}
@Test
@DisplayName("同级重排的兄弟集按锚点行的公司筛:少了它会把两棵树的 sort_order 织在一起")
void reorderSiblingsAreCompanyScoped() {
// 锚点 111 属 B 家;A 家有一排同名兄弟(id 210/211、分组 212)——漏了公司条件就会一起进 siblings。
when(menuMapper.selectById(111L)).thenReturn(menu(111, COMPANY_B, "brand-check", "admin", 112L, 40));
when(menuMapper.selectList(any())).thenAnswer(menusFromFakeDb(List.of(
menu(110, COMPANY_B, "collect-data", "admin", 112L, 30),
menu(111, COMPANY_B, "brand-check", "admin", 112L, 40),
menu(210, COMPANY_A, "collect-data", "admin", 212L, 10),
menu(211, COMPANY_A, "brand-check", "admin", 212L, 20))));
service.reorder(user(20L, "admin", COMPANY_B), List.of(111L, 110L));
ArgumentCaptor<LambdaQueryWrapper<PermissionMenuEntity>> siblings =
ArgumentCaptor.forClass(LambdaQueryWrapper.class);
verify(menuMapper).selectList(siblings.capture());
assertThat(params(siblings.getValue())).contains(COMPANY_B);
// 交换 B 家这两行的顺序必然产生两次写入;关键是写入的 id 只能是 B 家那两个。
ArgumentCaptor<LambdaUpdateWrapper<PermissionMenuEntity>> updates =
ArgumentCaptor.forClass(LambdaUpdateWrapper.class);
verify(menuMapper, times(2)).update(nullable(PermissionMenuEntity.class), updates.capture());
for (LambdaUpdateWrapper<PermissionMenuEntity> update : updates.getAllValues()) {
assertThat(params(update)).containsAnyOf(110L, 111L);
assertThat(params(update)).doesNotContain(210L, 211L);
}
}
@Test
@DisplayName("给用户提交的授权 id 必须在【该用户自己】的树里:别家的行 id 报无效,不落库")
void grantIsBoundToTheTargetUsersOwnTree() {
when(userMapper.selectById(400L)).thenReturn(user(400L, "normal", COMPANY_B));
// A 家的 id 10 与 B 家的 id 110:本公司只认后者 ⇒ 带公司条件 count=1,漏条件 count=2。
when(menuMapper.selectCount(any())).thenAnswer(invocation ->
params((LambdaQueryWrapper<PermissionMenuEntity>) invocation.getArgument(0))
.contains(COMPANY_B) ? 1L : 2L);
when(menuMapper.selectList(any())).thenReturn(List.of());
UserColumnPermissionUpdateRequest request = new UserColumnPermissionUpdateRequest();
request.setColumnIds(List.of(10L, 110L));
assertThatThrownBy(() -> service.updateUserColumnPermissions(
user(1L, "super_admin", COMPANY_A), 400L, request, null))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("无效的菜单权限项");
verify(permissionMapper, never()).insert(any(UserColumnPermissionEntity.class));
verify(permissionMapper, never()).deleteByUserId(anyLong());
}
@Test
@DisplayName("回填集与有效菜单都只认目标账号那棵树:挂在别家行上的旧授权不复活")
void effectiveMenusOnlyComeFromTheUsersOwnTree() {
when(userMapper.selectById(400L)).thenReturn(user(400L, "normal", COMPANY_B));
when(permissionMapper.selectByUserId(400L)).thenReturn(List.of(grant(400L, 10L)));
when(menuMapper.selectList(any())).thenAnswer(menusFromFakeDb(twoTrees()));
assertThat(service.getUserColumnPermissions(user(1L, "super_admin", COMPANY_A), 400L, "admin"))
.isEmpty();
assertThat(service.getUserColumnIds(user(1L, "super_admin", COMPANY_A), 400L, "admin").getColumnIds())
.isEmpty();
// 同一个人换成 A 家的账号,同一笔授权就该生效——证明上面那两条空是因为公司,不是因为查不到行。
when(userMapper.selectById(400L)).thenReturn(user(400L, "normal", COMPANY_A));
assertThat(service.getUserColumnPermissions(user(1L, "super_admin", COMPANY_A), 400L, "admin"))
.extracting(PermissionMenuItemVo::getId).containsExactly(10L);
}
@Test
@DisplayName("权限判定遇到别家的 column_id 判「无权限」,方向是拒不是放")
void hasEffectiveColumnPermissionDeniesForeignColumnId() {
when(userMapper.selectById(400L)).thenReturn(user(400L, "normal", COMPANY_B));
when(menuMapper.selectById(10L)).thenReturn(menu(10, COMPANY_A, "collect-data", "admin", 9L, 10));
when(permissionMapper.selectByUserId(400L)).thenReturn(List.of(grant(400L, 10L)));
assertThat(service.hasEffectiveColumnPermission(400L, 10L)).isFalse();
// 拒在展开之前:一条目录查询都不该发生。
verify(menuMapper, never()).selectList(any());
}
@Test
@DisplayName("建树:三种 menu_type 全复制、闸门行不复制、父子指向按 key 落到本公司新行")
void copyTreeClonesEveryTypeAndRemapsParentsByKey() {
List<PermissionMenuEntity> template = new ArrayList<>(List.of(
menu(1, COMPANY_A, "app-collect", "app", null, 10),
menu(2, COMPANY_A, "app-child", "app", 1L, 20),
menu(3, COMPANY_A, "admin-group", "admin", null, 30),
menu(4, COMPANY_A, "admin-page", "admin", 3L, 40),
menu(5, COMPANY_A, "internal-thing", "internal", null, 50),
menu(109, COMPANY_A, "admin_companies", "admin", null, 60)));
List<PermissionMenuEntity> created = new ArrayList<>();
when(menuMapper.selectList(any())).thenAnswer(invocation -> {
LambdaQueryWrapper<PermissionMenuEntity> query = invocation.getArgument(0);
return params(query).contains(COMPANY_B)
? new ArrayList<>(created) : new ArrayList<>(template);
});
when(menuMapper.insert(any(PermissionMenuEntity.class))).thenAnswer(invocation -> {
PermissionMenuEntity row = invocation.getArgument(0);
row.setId(500L + created.size());
created.add(row);
return 1;
});
int inserted = service.copyTreeFromTemplate(COMPANY_B, COMPANY_A);
assertThat(inserted).isEqualTo(5);
assertThat(created).extracting(PermissionMenuEntity::getColumnKey)
.doesNotContain("admin_companies")
.containsExactlyInAnyOrder("app-collect", "app-child", "admin-group", "admin-page", "internal-thing");
assertThat(created).allSatisfy(row -> {
assertThat(row.getCompanyId()).isEqualTo(COMPANY_B);
assertThat(row.getMenuType()).isIn("app", "admin", "internal");
});
// 第二趟认父:父指向必须落在本公司新行上,绝不能是模板那排的全局 id。
Set<Long> copyIds = new LinkedHashSet<>();
created.forEach(row -> copyIds.add(row.getId()));
PermissionMenuEntity child = created.stream()
.filter(row -> "app-child".equals(row.getColumnKey())).findFirst().orElseThrow();
PermissionMenuEntity group = created.stream()
.filter(row -> "app-collect".equals(row.getColumnKey())).findFirst().orElseThrow();
assertThat(child.getParentId()).isEqualTo(group.getId());
assertThat(copyIds).contains(child.getParentId());
assertThat(child.getParentId()).isNotEqualTo(1L);
}
@Test
@DisplayName("建树可重跑:目标公司已有的 key 原样保留,第二次一行都不插")
void copyTreeIsIdempotentOnRerun() {
List<PermissionMenuEntity> template = new ArrayList<>(List.of(
menu(1, COMPANY_A, "app-collect", "app", null, 10),
menu(3, COMPANY_A, "admin-group", "admin", null, 30)));
List<PermissionMenuEntity> existing = new ArrayList<>(List.of(
menu(900, COMPANY_B, "app-collect", "app", null, 10),
menu(901, COMPANY_B, "admin-group", "admin", null, 30)));
when(menuMapper.selectList(any())).thenAnswer(invocation -> {
LambdaQueryWrapper<PermissionMenuEntity> query = invocation.getArgument(0);
return params(query).contains(COMPANY_B)
? new ArrayList<>(existing) : new ArrayList<>(template);
});
assertThat(service.copyTreeFromTemplate(COMPANY_B, COMPANY_A)).isZero();
verify(menuMapper, never()).insert(any(PermissionMenuEntity.class));
verify(menuMapper, never()).update(any(), any());
}
@Test
@DisplayName("建树不许靠默认值兜:模板公司缺失或操作者没归属都直接拒")
void copyTreeRefusesInsteadOfInventingADefaultCompany() {
when(menuMapper.selectList(any())).thenReturn(List.of());
assertThatThrownBy(() -> service.copyTreeFromTemplate(COMPANY_B, COMPANY_A))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("没有可复制的菜单树");
assertThatThrownBy(() -> service.copyTreeFromTemplate(COMPANY_B, null))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("没有所属公司");
assertThatThrownBy(() -> service.copyTreeFromTemplate(null, COMPANY_A))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("目标公司");
verify(menuMapper, never()).insert(any(PermissionMenuEntity.class));
// 给"自己"复制是条无意义的写入:早返回 0,一条查询都不发。
clearInvocations(menuMapper);
assertThat(service.copyTreeFromTemplate(COMPANY_A, COMPANY_A)).isZero();
verify(menuMapper, never()).selectList(any());
}
@Test
@DisplayName("判据要能咬住实现:不带公司条件时,夹具必须把别家的行也交出来")
void fakeDatabaseStubActuallyBites() {
// 自证尺子不是恒绿的:这些用例全部依赖「少一个 .eq(companyId) ⇒ 结果多出别家行」这个性质。
// 若夹具改成无脑只回本公司,上面那批断言就一条都咬不动了。
List<PermissionMenuEntity> all = twoTrees();
LambdaQueryWrapper<PermissionMenuEntity> withoutCompany =
new LambdaQueryWrapper<PermissionMenuEntity>().orderByAsc(PermissionMenuEntity::getSortOrder);
assertThat(filteredByAnyCompany(withoutCompany)).isFalse();
assertThat(fakeDbRows(all, withoutCompany)).extracting(PermissionMenuEntity::getId)
.contains(10L, 110L);
LambdaQueryWrapper<PermissionMenuEntity> withCompany =
new LambdaQueryWrapper<PermissionMenuEntity>().eq(PermissionMenuEntity::getCompanyId, COMPANY_B);
assertThat(filteredByAnyCompany(withCompany)).isTrue();
assertThat(fakeDbRows(all, withCompany)).extracting(PermissionMenuEntity::getId)
.containsExactlyInAnyOrder(110L, 111L)
.doesNotContain(10L, 109L);
}
}
@@ -1,158 +0,0 @@
package com.nanri.aiimage.modules.productcategory.controller;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.common.service.DataReadScope;
import com.nanri.aiimage.modules.productcategory.model.dto.ProductCategorySaveRequest;
import com.nanri.aiimage.modules.productcategory.service.ProductCategoryService;
import jakarta.servlet.http.HttpServletRequest;
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.springframework.mock.web.MockHttpServletRequest;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.when;
/**
* 「商品类目」controller 的正门接线(护栏 G2 断言 A 要求这些调用内联在 handler 块里,
* 本文件钉的是内联之后的<b>语义</b>:tab 的值确实进了出口、出口的结果确实交给了 service)。
*
* <p>G2 只看形状(有没有调、结果有没有被当实参用),看不见"把 service 那侧的实参改成 null"
* 这一记 —— 那一记由本文件的 {@code verify(service).list("面霜", 2L)} 负责。</p>
*/
@ExtendWith(MockitoExtension.class)
class ProductCategoryControllerCompanyScopeTest {
private static final Long OPERATOR_ID = 1L;
private static final Long COMPANY_ID = 2L;
@Mock
private ProductCategoryService productCategoryService;
@Mock
private AdminAuthSupport adminAuthSupport;
@Mock
private DataReadScope dataReadScope;
private ProductCategoryController controller() {
return new ProductCategoryController(productCategoryService, adminAuthSupport, dataReadScope);
}
@Test
@DisplayName("列表:tab 的公司 id 交给 readCompanyIdOrOwn,出口给什么 service 就用什么")
void listPassesTheTabValueThroughTheDoor() {
HttpServletRequest request = login();
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(user());
when(dataReadScope.readCompanyIdOrOwn(any(AdminUserEntity.class), eq(COMPANY_ID))).thenReturn(COMPANY_ID);
controller().list(request, "面霜", COMPANY_ID);
verify(dataReadScope).readCompanyIdOrOwn(any(AdminUserEntity.class), eq(COMPANY_ID));
verify(productCategoryService).list("面霜", COMPANY_ID);
}
@Test
@DisplayName("列表:非超管由出口判成\"不筛\",controller 不许自己补一个公司 id 进去")
void listUsesTheDoorsVerdictForNonSuperAdmin() {
HttpServletRequest request = login();
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(user());
when(dataReadScope.readCompanyIdOrOwn(any(AdminUserEntity.class), eq(COMPANY_ID))).thenReturn(null);
controller().list(request, "面霜", COMPANY_ID);
verify(productCategoryService).list("面霜", null);
}
@Test
@DisplayName("children / search / export 三支同样走出口,漏一支就是那一处的 tab 仍是装饰")
void everyReadEndpointGoesThroughTheDoor() {
HttpServletRequest request = login();
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(user());
when(dataReadScope.readCompanyIdOrOwn(any(AdminUserEntity.class), eq(COMPANY_ID))).thenReturn(COMPANY_ID);
// export 的返回要真喂给 ResponseEntity.contentLength(bytes.length):mock 给 null 会 NPE 在断言之前的装配里。
when(productCategoryService.export("面霜", COMPANY_ID)).thenReturn(new byte[0]);
ProductCategoryController controller = controller();
controller.children(request, 10L, 1L, 20L, COMPANY_ID);
controller.search(request, "面霜", 1L, 20L, COMPANY_ID);
controller.export(request, "面霜", COMPANY_ID);
verify(productCategoryService).children(10L, 1L, 20L, COMPANY_ID);
verify(productCategoryService).search("面霜", 1L, 20L, COMPANY_ID);
verify(productCategoryService).export("面霜", COMPANY_ID);
verify(dataReadScope, times(3))
.readCompanyIdOrOwn(any(AdminUserEntity.class), eq(COMPANY_ID));
}
/** 写侧口径(一期定案):归属由后端从操作者会话推导,请求体不带 company_id,controller 也不读 tab。 */
@Test
@DisplayName("新增:只把操作者 id 交给 service,公司由 service 从会话推导")
void createPassesOnlyTheOperator() {
HttpServletRequest request = login();
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(user());
ProductCategorySaveRequest body = new ProductCategorySaveRequest();
body.setName("面霜套装");
body.setParentId(10L);
controller().create(request, body);
ArgumentCaptor<Long> operatorId = ArgumentCaptor.forClass(Long.class);
verify(productCategoryService).create(eq(body), operatorId.capture());
assertEquals(OPERATOR_ID, operatorId.getValue());
verifyNoInteractions(dataReadScope);
}
/** 写侧闸门(10-06 逐节点复验后补):读侧已经收窄,写侧不收窄="藏起来的行照样能删"。 */
@Test
@DisplayName("更新/删除:把 writeCompanyId 的判定原样交给 service,controller 不自己补公司 id")
void writeEndpointsPassTheRowOwnershipGate() {
HttpServletRequest request = login();
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(user());
when(dataReadScope.writeCompanyId(any(AdminUserEntity.class))).thenReturn(COMPANY_ID);
ProductCategorySaveRequest body = new ProductCategorySaveRequest();
body.setName("面霜改名");
ProductCategoryController controller = controller();
controller.update(request, 300L, body);
controller.delete(request, 300L);
verify(productCategoryService).update(300L, body, COMPANY_ID);
verify(productCategoryService).delete(300L, COMPANY_ID);
}
/** 反向钉:闸门给 null(平台超管)时必须原样传 null——顺手补一个公司 id 会把超管锁死在本公司。 */
@Test
@DisplayName("更新:闸门判超管(null)时把 null 传下去,不补任何公司 id")
void writeGateKeepsTheSuperAdminVerdict() {
HttpServletRequest request = login();
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(user());
when(dataReadScope.writeCompanyId(any(AdminUserEntity.class))).thenReturn(null);
ProductCategorySaveRequest body = new ProductCategorySaveRequest();
body.setName("内置类目改名");
controller().update(request, 10L, body);
verify(productCategoryService).update(10L, body, null);
}
private MockHttpServletRequest login() {
MockHttpServletRequest request = new MockHttpServletRequest();
request.addHeader("X-Internal-Token", "irrelevant-here");
return request;
}
private AdminUserEntity user() {
AdminUserEntity user = new AdminUserEntity();
user.setId(OPERATOR_ID);
user.setRole("super_admin");
return user;
}
}
@@ -4,8 +4,6 @@ import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
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.service.CompanyScopeSupport;
import com.nanri.aiimage.modules.productcategory.mapper.ProductCategoryMapper;
import com.nanri.aiimage.modules.productcategory.model.dto.ProductCategorySaveRequest;
import com.nanri.aiimage.modules.productcategory.model.entity.ProductCategoryEntity;
@@ -20,16 +18,15 @@ import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.atLeastOnce;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
@@ -37,32 +34,34 @@ import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.when;
/**
* 「商品类目」按公司视图的那几条不变量(V147 / 需求 2026-10-05「切 tab 数据还一样」)。
* 「商品类目」这棵树的公司口径(控制方 2026-10-06 定案:全平台共享、不区分公司,
* 写侧同样是「谁都能改整棵树」)。
*
* <p>这一页的归属是<b>物化列</b>而不是账号集合,所以判据形状与 readScope 那一族不同:
* 可见集 = {@code company_id IN (0, X)},其中 0 是内置节点的哨兵。两支最容易静默坏掉的形状
* 都由本文件钉住:① 哨兵那半不许丢(丢了第 2 家是一棵空树,连自建根都挂不上);
* ② 给 LLM 用的那棵全局树不许被顺手加上公司谓词(加了货源归类的候选就按公司分叉)。</p>
* <p>类名里的 CompanyScope 是有意保留的:这一页确实按公司切过(V147 加列、V148 取消共享哨兵 0、
* 内置行归还第 1 家)。本文件现在钉的是<b>反向</b>不变量——四条读通路真正渲染出来的 SQL 里一个
* {@code company_id} 都不许出现。原先那族「{@code company_id = 这一家}、不许带哨兵 0」的单值谓词钉子,
* 以及跨公司 403、"公司账号改不动内置节点"那两道写侧闸门,随定案一起作废:现在没有归属值可比,
* 也没有"别人的行"这一说。</p>
*
* <p>为什么留 SQL 层的钉子,而不只靠源码文本扫描({@code CompanyIdParamGoesThroughReadScopeTest}
* 已按 module 目录反向钉过一遍):那把尺子读的是 Java 源码里的公司 token,谓词若来自这两个文件之外
* (mapper XML、公共分页/租户拦截器)它看不见;这里读的是 MyBatis-Plus 真正拼出来的那一段。</p>
*/
@ExtendWith(MockitoExtension.class)
class ProductCategoryCompanyScopeTest {
private static final long BUILTIN = 0L;
private static final Long OPERATOR_ID = 7L;
/** 故意取 2:DEFAULT 1 那一家通不过"值等于会话公司"这种断言,取 2 才钉得住"真从会话推导"。 */
private static final Long COMPANY_ID = 2L;
private static final Long BUILTIN_PARENT_ID = 10L;
/** 原来的"内置根"在定案后只是同一棵树上的一个普通节点,不再带归属含义。 */
private static final Long PARENT_ID = 10L;
@Mock
private ProductCategoryMapper productCategoryMapper;
@Mock
private CompanyScopeSupport companyScopeSupport;
private ProductCategoryService service;
@BeforeAll
static void initTableInfo() {
// Lambda 条件要解析列名,没有 TableInfo 时 getSqlSegment() 里根本不会出现 company_id。
// Lambda 条件要解析列名。没有 TableInfo 时 getSqlSegment() 里一个列名都不会出现,
// "不含 company_id"就变成恒真的空断言。
TableInfoHelper.initTableInfo(
new MapperBuilderAssistant(new MybatisConfiguration(), ""),
ProductCategoryEntity.class);
@@ -70,281 +69,112 @@ class ProductCategoryCompanyScopeTest {
@BeforeEach
void setUp() {
service = new ProductCategoryService(productCategoryMapper, companyScopeSupport);
}
@Test
@DisplayName("公司视图带哨兵 0:可见集是 (0, 该公司),只查自建会让第 2 家连自建根都挂不上")
void companyViewIncludesTheBuiltinSentinel() {
when(productCategoryMapper.selectList(any())).thenReturn(List.of(row(1L, null, "护肤品", BUILTIN)));
service.list(null, COMPANY_ID);
LambdaQueryWrapper<ProductCategoryEntity> query = capturedListWrapper();
assertTrue(query.getSqlSegment().contains("company_id IN"), query.getSqlSegment());
Map<String, Object> params = paramsOf(query);
assertTrue(params.containsValue(BUILTIN), "哨兵 0 必须留在可见集里:" + params);
assertTrue(params.containsValue(COMPANY_ID), "公司谓词丢了 tab 就是装饰:" + params);
service = new ProductCategoryService(productCategoryMapper);
}
/**
* 反向钉(新维度不许顺手回流到别的通路):{@link ProductCategoryService#list()} 唯一的消费者是
* 货源/外观的类目归类({@code SimilarAsinLlmService} 读的是全局树)。给它加公司谓词会让同一个
* "面霜"有 N 个 category_key、LLM 分类结果按公司分叉,那是成本不只是口径。
* 四条读通路(全局树、带关键字的树、分页 children、搜索)逐条渲染后汇总比对。
* 三条锚(ORDER BY / parent_id / LIKE)先自证"确实扫到了真 SQL",否则末尾那条否证是空断言。
*/
@Test
@DisplayName("给 LLM 用的全局树不带公司谓词:按公司切会让归类结果按公司分叉")
void globalTreeForTheLlmConsumerStaysUnscoped() {
when(productCategoryMapper.selectList(any())).thenReturn(List.of(row(1L, null, "护肤品", BUILTIN)));
@DisplayName("四条读通路渲染出的 SQL 里都没有 company_id:全局树、分页 children、搜索")
@SuppressWarnings("unchecked")
void noReadPathRendersACompanyPredicate() {
when(productCategoryMapper.selectList(any())).thenReturn(List.of(row(20L, PARENT_ID, "面霜")));
when(productCategoryMapper.selectCount(any())).thenReturn(1L);
when(productCategoryMapper.selectMaps(any())).thenReturn(List.of());
when(productCategoryMapper.selectBatchIds(any())).thenReturn(List.of(row(PARENT_ID, null, "护肤品")));
service.list();
service.list("面霜");
service.children(PARENT_ID, 1, 20);
service.search("面霜", 1, 20);
LambdaQueryWrapper<ProductCategoryEntity> query = capturedListWrapper();
String sql = query.getSqlSegment();
// 两条一起才算非恒真:只看"不含 company_id"时,一条空 segment(列名解析不到、wrapper 根本没拼)
// 也会通过,那条断言就变成恒绿。先证明 wrapper 真渲染了东西,再证明它一个实参都没带。
assertTrue(sql.contains("ORDER BY"), "wrapper 根本没渲染,下面的否证是空话:" + sql);
assertFalse(sql.contains("company_id"),
"无参 list() 被接上了公司谓词 —— 货源归类的候选树随之按公司分叉:" + sql);
assertTrue(query.getParamNameValuePairs().isEmpty(),
"全局树带出了实参(说明有谓词被塞进来):" + query.getParamNameValuePairs());
}
ArgumentCaptor<Wrapper<ProductCategoryEntity>> pageQueries = ArgumentCaptor.forClass(Wrapper.class);
verify(productCategoryMapper, atLeastOnce()).selectList(pageQueries.capture());
ArgumentCaptor<Wrapper<ProductCategoryEntity>> countQueries = ArgumentCaptor.forClass(Wrapper.class);
verify(productCategoryMapper, atLeastOnce()).selectCount(countQueries.capture());
// 「子类目数」徽章走全表聚合:它要是被加上公司谓词,数字就会和点开的那棵树不一致。
ArgumentCaptor<Wrapper<ProductCategoryEntity>> badgeQueries = ArgumentCaptor.forClass(Wrapper.class);
verify(productCategoryMapper, atLeastOnce()).selectMaps(badgeQueries.capture());
@Test
@DisplayName("搜索的公司谓词必须在整条 OR 之外:AND 结合更紧会让前两列命中不受公司约束")
void searchKeepsTheOrGroupWrappedBeforeTheCompanyPredicate() {
when(productCategoryMapper.selectCount(any())).thenReturn(0L);
when(productCategoryMapper.selectList(any())).thenReturn(List.of());
service.search("面霜", 1, 20, COMPANY_ID);
List<LambdaQueryWrapper<ProductCategoryEntity>> queries = capturedSearchWrappers();
for (LambdaQueryWrapper<ProductCategoryEntity> query : queries) {
String sql = query.getSqlSegment();
assertTrue(sql.contains(") AND company_id IN"),
"OR 组没有被包起来再 AND 公司(前两个 like 命中的行会跨公司):" + sql);
Map<String, Object> params = paramsOf(query);
assertTrue(params.containsValue("%面霜%"), sql);
assertTrue(params.containsValue(COMPANY_ID), sql);
List<Wrapper<ProductCategoryEntity>> queries = new ArrayList<>();
queries.addAll(pageQueries.getAllValues());
queries.addAll(countQueries.getAllValues());
queries.addAll(badgeQueries.getAllValues());
List<String> rendered = new ArrayList<>();
for (Wrapper<ProductCategoryEntity> query : queries) {
rendered.add(query.getSqlSegment());
}
assertEquals(2, queries.size(), "count 与 list 两条查询都要带公司谓词");
assertFalse(rendered.isEmpty(), "一条查询都没捕到:读通路的形状变了,后面的断言全是空话");
assertTrue(rendered.stream().anyMatch(sql -> sql.contains("ORDER BY")),
"捕到的全是没渲染的空调用(列名解析失败时 getSqlSegment() 给空串):" + rendered);
assertTrue(rendered.stream().anyMatch(sql -> sql.contains("parent_id")),
"分页 children 与徽章那几条查询没进样本(parent_id 谓词形状变了):" + rendered);
assertTrue(rendered.stream().anyMatch(sql -> sql.contains("LIKE")),
"搜索那条没进样本,「搜索那一支的过滤形状」没人看守:" + rendered);
assertFalse(rendered.stream().anyMatch(sql -> sql.contains("company_id")),
"有读通路又按公司筛了(2026-10-06 定案:全平台共享一棵树):" + rendered);
}
@Test
@DisplayName("分页 children 的 count 与 list 两条查询同源,且子类目数徽章也按可见集聚合")
void childrenScopeCountListAndChildBadgeTogether() {
@DisplayName("分页 children 补 level/path:父级按层批量取,那一列不再是类目名的副本")
void childrenPageCarriesPathAndLevel() {
when(productCategoryMapper.selectCount(any())).thenReturn(1L);
when(productCategoryMapper.selectList(any())).thenReturn(List.of(row(20L, BUILTIN_PARENT_ID, "面霜", COMPANY_ID)));
when(productCategoryMapper.selectList(any())).thenReturn(List.of(row(20L, PARENT_ID, "面霜")));
when(productCategoryMapper.selectMaps(any())).thenReturn(List.of());
when(productCategoryMapper.selectBatchIds(any())).thenReturn(List.of(row(PARENT_ID, null, "护肤品")));
service.children(BUILTIN_PARENT_ID, 1, 20, COMPANY_ID);
ProductCategoryListVo vo = service.children(null, 1, 20);
ArgumentCaptor<Wrapper<ProductCategoryEntity>> countCaptor = ArgumentCaptor.forClass(Wrapper.class);
verify(productCategoryMapper).selectCount(countCaptor.capture());
assertTrue(countCaptor.getValue().getSqlSegment().contains("company_id IN"));
LambdaQueryWrapper<ProductCategoryEntity> pageQuery = capturedListWrapper();
assertTrue(pageQuery.getSqlSegment().contains("company_id IN"));
assertTrue(pageQuery.getSqlSegment().contains("parent_id"));
// 「子类目数」徽章走全表聚合:不加公司谓词就会把别家子节点数算进来,数字与点开看到的树不一致。
ArgumentCaptor<Wrapper<ProductCategoryEntity>> badgeCaptor = ArgumentCaptor.forClass(Wrapper.class);
verify(productCategoryMapper).selectMaps(badgeCaptor.capture());
assertTrue(badgeCaptor.getValue().getSqlSegment().contains("company_id IN"),
badgeCaptor.getValue().getSqlSegment());
}
@Test
@DisplayName("新增:归属从操作者会话推导,不靠 V147 那个临时 DEFAULT 1")
void createStampsTheOperatorsCompany() {
when(companyScopeSupport.requireCompanyId(OPERATOR_ID)).thenReturn(COMPANY_ID);
when(productCategoryMapper.selectById(BUILTIN_PARENT_ID))
.thenReturn(row(BUILTIN_PARENT_ID, null, "护肤品", BUILTIN));
when(productCategoryMapper.selectCount(any())).thenReturn(0L);
when(productCategoryMapper.insert(any(ProductCategoryEntity.class))).thenAnswer(call -> {
call.getArgument(0, ProductCategoryEntity.class).setId(500L);
return 1;
});
when(productCategoryMapper.selectById(500L)).thenReturn(row(500L, BUILTIN_PARENT_ID, "面霜套装", COMPANY_ID));
service.create(saveRequest("面霜套装", BUILTIN_PARENT_ID), OPERATOR_ID);
ArgumentCaptor<ProductCategoryEntity> inserted = ArgumentCaptor.forClass(ProductCategoryEntity.class);
verify(productCategoryMapper).insert(inserted.capture());
assertEquals(COMPANY_ID, inserted.getValue().getCompanyId());
assertFalse(Boolean.TRUE.equals(inserted.getValue().getIsBuiltin()));
assertTrue(inserted.getValue().getCategoryKey().startsWith("custom_"));
// 同级重名预检的范围 = 可见集(自建 + 内置):漏了它,第 2 家能在内置"护肤品"下再建一个同名"面霜",
// 页面一排两个而货源归类不知落到哪个;反过来跨家同名必须放行(那正是 uk_company_category_key 要解的)。
// 第 0 条=同级重名预检;findItem 里那条「子类目数」聚合不在本断言射程内(它按 parent_id 数,
// 不带公司谓词——那是详情返回值的计数,与列表可见集两回事)。
LambdaQueryWrapper<ProductCategoryEntity> sibling = countWrappers().get(0);
assertTrue(sibling.getSqlSegment().contains("company_id IN"), sibling.getSqlSegment());
Map<String, Object> params = paramsOf(sibling);
assertTrue(params.containsValue(BUILTIN), "重名检查漏了内置那一半:" + params);
assertTrue(params.containsValue(COMPANY_ID), "重名检查漏了这一家自己:" + params);
}
@Test
@DisplayName("新增:父级挂在别家公司名下要 403,不能静默把行挪出可见集")
void createRejectsParentOwnedByAnotherCompany() {
Long foreignParentId = 77L;
when(companyScopeSupport.requireCompanyId(OPERATOR_ID)).thenReturn(COMPANY_ID);
when(productCategoryMapper.selectById(foreignParentId))
.thenReturn(row(foreignParentId, null, "别家的根", 3L));
BusinessException exception = assertThrows(BusinessException.class,
() -> service.create(saveRequest("面霜套装", foreignParentId), OPERATOR_ID));
assertEquals(403, exception.getCode());
verify(productCategoryMapper, never()).insert(any(ProductCategoryEntity.class));
}
@Test
@DisplayName("新增:内置节点(哨兵 0)当父级放行,否则第 2 家永远建不出子级")
void createAcceptsTheSharedBuiltinParent() {
when(companyScopeSupport.requireCompanyId(OPERATOR_ID)).thenReturn(COMPANY_ID);
when(productCategoryMapper.selectById(BUILTIN_PARENT_ID))
.thenReturn(row(BUILTIN_PARENT_ID, null, "护肤品", BUILTIN));
when(productCategoryMapper.selectCount(any())).thenReturn(0L);
when(productCategoryMapper.insert(any(ProductCategoryEntity.class))).thenAnswer(call -> {
call.getArgument(0, ProductCategoryEntity.class).setId(501L);
return 1;
});
when(productCategoryMapper.selectById(501L)).thenReturn(row(501L, BUILTIN_PARENT_ID, "自建子级", COMPANY_ID));
service.create(saveRequest("自建子级", BUILTIN_PARENT_ID), OPERATOR_ID);
ArgumentCaptor<ProductCategoryEntity> inserted = ArgumentCaptor.forClass(ProductCategoryEntity.class);
verify(productCategoryMapper).insert(inserted.capture());
assertEquals(COMPANY_ID, inserted.getValue().getCompanyId());
assertEquals(BUILTIN_PARENT_ID, inserted.getValue().getParentId());
}
@Test
@DisplayName("更新时按行自己的归属判可见集:内置行归 0、自建行归那一家,都不取 tab")
void updateUsesTheRowsOwnCompanyNotTheTab() {
ProductCategoryEntity custom = row(300L, BUILTIN_PARENT_ID, "面霜", COMPANY_ID);
when(productCategoryMapper.selectById(300L)).thenReturn(custom);
when(productCategoryMapper.selectById(BUILTIN_PARENT_ID))
.thenReturn(row(BUILTIN_PARENT_ID, null, "护肤品", BUILTIN));
when(productCategoryMapper.selectCount(any())).thenReturn(0L);
when(productCategoryMapper.updateById(any(ProductCategoryEntity.class))).thenReturn(1);
service.update(300L, saveRequest("面霜改名", BUILTIN_PARENT_ID), COMPANY_ID);
LambdaQueryWrapper<ProductCategoryEntity> sibling = countWrappers().get(0);
assertTrue(sibling.getSqlSegment().contains("company_id IN"), sibling.getSqlSegment());
Map<String, Object> params = paramsOf(sibling);
assertTrue(params.containsValue(COMPANY_ID), params.toString());
assertFalse(params.containsValue(3L),
"把行挪到可见集外的节点下面会让它从原本看得见它的 tab 里消失:" + params);
}
// ---- 写侧行归属闸门(10-06 逐节点复验后补)----
// 读侧已经把这一页收窄到本公司,写侧不收窄="藏起来的行照样能改名/删除",那是静默删除不是隔离。
// assertSameCompany 自己的判定由 CompanyScopeSupportTest 钉(本仓唯一一份),这里只钉"service 有没有
// 把这一刀落在正确的两个值上、被拒之后还写不写库"——所以桩按真方法的语义给:只有配对不对才抛。
@Test
@DisplayName("更新别家公司的行:闸门 403 且 updateById 一次都不跑")
void updateRejectsARowOwnedByAnotherCompany() {
Long foreignCompanyId = 3L;
when(productCategoryMapper.selectById(300L)).thenReturn(row(300L, null, "别家的根", foreignCompanyId));
stubSameCompanyJudgment();
BusinessException exception = assertThrows(BusinessException.class,
() -> service.update(300L, saveRequest("改名", null), COMPANY_ID));
assertEquals(403, exception.getCode());
verify(productCategoryMapper, never()).updateById(any(ProductCategoryEntity.class));
// 断言闸门拿到的是<b>行自己的</b>归属而不是 tab 之外的什么值:喂错第二个实参,这一刀形同没落。
verify(companyScopeSupport).assertSameCompany(eq(COMPANY_ID), eq(foreignCompanyId), any());
}
@Test
@DisplayName("更新内置节点(哨兵 0):公司账号一律拒,改了它所有公司的树与货源归类同一天跟着变")
void updateRejectsTheSharedBuiltinRow() {
when(productCategoryMapper.selectById(BUILTIN_PARENT_ID))
.thenReturn(row(BUILTIN_PARENT_ID, null, "护肤品", BUILTIN));
stubSameCompanyJudgment();
BusinessException exception = assertThrows(BusinessException.class,
() -> service.update(BUILTIN_PARENT_ID, saveRequest("护肤品改名", null), COMPANY_ID));
assertEquals(403, exception.getCode());
verify(productCategoryMapper, never()).updateById(any(ProductCategoryEntity.class));
}
@Test
@DisplayName("更新:本公司自己的行放行(闸门不该把这一页的正常编辑也拦死)")
void updateAcceptsTheRowsOwnCompany() {
when(productCategoryMapper.selectById(300L)).thenReturn(row(300L, null, "面霜", COMPANY_ID));
when(productCategoryMapper.selectCount(any())).thenReturn(0L);
when(productCategoryMapper.updateById(any(ProductCategoryEntity.class))).thenReturn(1);
stubSameCompanyJudgment();
service.update(300L, saveRequest("面霜改名", null), COMPANY_ID);
verify(productCategoryMapper).updateById(any(ProductCategoryEntity.class));
}
/** 反向钉(多隔离那一向):闸门判 null = 平台超管不限,顺手补一个公司 id 会把超管锁死在本公司。 */
@Test
@DisplayName("更新:超管口径(null)不调用行归属闸门,内置节点照样能改")
void superAdminUpdateSkipsTheRowGate() {
when(productCategoryMapper.selectById(BUILTIN_PARENT_ID))
.thenReturn(row(BUILTIN_PARENT_ID, null, "护肤品", BUILTIN));
when(productCategoryMapper.selectCount(any())).thenReturn(0L);
when(productCategoryMapper.updateById(any(ProductCategoryEntity.class))).thenReturn(1);
service.update(BUILTIN_PARENT_ID, saveRequest("护肤品改名", null), null);
verify(productCategoryMapper).updateById(any(ProductCategoryEntity.class));
verifyNoInteractions(companyScopeSupport);
}
@Test
@DisplayName("删除:闸门在数子级之前,别家的行连「有几个子节点」都不去查")
void deleteRejectsARowOwnedByAnotherCompany() {
Long foreignCompanyId = 3L;
when(productCategoryMapper.selectById(400L)).thenReturn(row(400L, null, "别家的叶子", foreignCompanyId));
stubSameCompanyJudgment();
BusinessException exception = assertThrows(BusinessException.class,
() -> service.delete(400L, COMPANY_ID));
assertEquals(403, exception.getCode());
verify(productCategoryMapper, never()).deleteById(anyLong());
verify(productCategoryMapper, never()).selectCount(any());
}
@Test
@DisplayName("删除:本公司自己的行放行并真删")
void deleteAcceptsTheRowsOwnCompany() {
when(productCategoryMapper.selectById(401L)).thenReturn(row(401L, null, "自建叶子", COMPANY_ID));
when(productCategoryMapper.selectCount(any())).thenReturn(0L);
stubSameCompanyJudgment();
service.delete(401L, COMPANY_ID);
verify(productCategoryMapper).deleteById(401L);
assertEquals("护肤品 / 面霜", vo.getItems().get(0).getPath());
assertEquals(1, vo.getItems().get(0).getLevel());
// 父级取的是批量那一条,不是每行一次 selectById。
ArgumentCaptor<List<Long>> ids = ArgumentCaptor.forClass(List.class);
verify(productCategoryMapper).selectBatchIds(ids.capture());
assertEquals(List.of(PARENT_ID), ids.getValue());
verify(productCategoryMapper, never()).selectById(anyLong());
}
/**
* 把 {@code assertSameCompany} 按<b>真方法的语义</b>桩上(第一参 ≠ 第二参才抛 403)。
* 不这么写的话 Mockito 对 void 方法默认"什么都不做",三条拒绝用例会因为错误的理由恒绿。
* 同级重名预检的判据只剩 {@code (name, parent_id)}。这一条是这一族里唯一还可能被"顺手加回去"的形状——
* 归属列整个删了,但只要有人把列加回来,{@code .eq(ProductCategoryEntity::getCompanyId, …)} 就能写,
* 而那一记不报错:第 2 家能建出与第 1 家同名的同级节点,两棵树各长一份。
*/
private void stubSameCompanyJudgment() {
org.mockito.Mockito.doAnswer(call -> {
Long operatorCompanyId = call.getArgument(0);
Long rowCompanyId = call.getArgument(1);
if (rowCompanyId == null || !rowCompanyId.equals(operatorCompanyId)) {
throw new BusinessException(403, call.getArgument(2, String.class));
}
return null;
}).when(companyScopeSupport).assertSameCompany(any(), any(), any());
@Test
@DisplayName("同级重名预检只看 name 与 parent_id:全平台共享后没有归属这一维可比")
@SuppressWarnings("unchecked")
void createSiblingUniquenessChecksNameAndParentOnly() {
when(productCategoryMapper.selectCount(any())).thenReturn(0L);
when(productCategoryMapper.insert(any(ProductCategoryEntity.class))).thenAnswer(call -> {
call.getArgument(0, ProductCategoryEntity.class).setId(300L);
return 1;
});
when(productCategoryMapper.selectById(300L)).thenReturn(row(300L, null, "面霜套装"));
service.create(saveRequest("面霜套装", null));
ArgumentCaptor<Wrapper<ProductCategoryEntity>> counts = ArgumentCaptor.forClass(Wrapper.class);
verify(productCategoryMapper, atLeastOnce()).selectCount(counts.capture());
LambdaQueryWrapper<ProductCategoryEntity> uniqueness =
(LambdaQueryWrapper<ProductCategoryEntity>) counts.getAllValues().get(0);
String sql = uniqueness.getSqlSegment();
// 实参表是惰性填充的:不先求值 segment,getParamNameValuePairs() 是空 map(正反两断言会双双恒真)。
Map<String, Object> params = uniqueness.getParamNameValuePairs();
assertTrue(sql.contains("name ="), "重名预检整段没了,下面的排他就是空断言:" + sql);
assertTrue(sql.contains("parent_id IS NULL"), "同级这一维没了,重名预检退成了全表比对:" + sql);
assertFalse(sql.contains("company_id"), "重名预检又按公司切了:" + sql);
assertTrue(params.containsValue("面霜套装"), params.toString());
}
@Test
@DisplayName("空关键字的直接搜索返回空页,不探库")
void blankKeywordSearchShortCircuits() {
ProductCategoryListVo vo = service.search(" ", 1, 20);
assertEquals(0L, vo.getTotal());
assertTrue(vo.getItems().isEmpty());
verifyNoInteractions(productCategoryMapper);
}
private ProductCategorySaveRequest saveRequest(String name, Long parentId) {
@@ -354,64 +184,14 @@ class ProductCategoryCompanyScopeTest {
return request;
}
private static ProductCategoryEntity row(Long id, Long parentId, String name, Long companyId) {
private static ProductCategoryEntity row(Long id, Long parentId, String name) {
ProductCategoryEntity entity = new ProductCategoryEntity();
entity.setId(id);
entity.setParentId(parentId);
entity.setName(name);
entity.setCategoryKey("cat_" + id);
entity.setSortOrder(100);
entity.setCompanyId(companyId);
entity.setIsBuiltin(companyId == BUILTIN);
entity.setIsBuiltin(false);
return entity;
}
@SuppressWarnings("unchecked")
private LambdaQueryWrapper<ProductCategoryEntity> capturedListWrapper() {
ArgumentCaptor<Wrapper<ProductCategoryEntity>> captor = ArgumentCaptor.forClass(Wrapper.class);
verify(productCategoryMapper).selectList(captor.capture());
return (LambdaQueryWrapper<ProductCategoryEntity>) captor.getValue();
}
/** create/update 之后 selectCount 至少两条(重名预检 + 详情里的子类目数),按调用顺序取。 */
@SuppressWarnings("unchecked")
private List<LambdaQueryWrapper<ProductCategoryEntity>> countWrappers() {
ArgumentCaptor<Wrapper<ProductCategoryEntity>> captor = ArgumentCaptor.forClass(Wrapper.class);
verify(productCategoryMapper, atLeastOnce()).selectCount(captor.capture());
return captor.getAllValues().stream()
.map(wrapper -> (LambdaQueryWrapper<ProductCategoryEntity>) wrapper)
.toList();
}
/**
* MyBatis-Plus 的实参表是<b>惰性</b>填充的:不先求值 {@code getSqlSegment()},
* {@code getParamNameValuePairs()} 是个空 map——那会让"含 0"与"不含 3"两个方向的断言同时恒真。
* 读参数一律走这里,别在测试里各自记得。
*/
private static Map<String, Object> paramsOf(LambdaQueryWrapper<ProductCategoryEntity> query) {
query.getSqlSegment();
return query.getParamNameValuePairs();
}
@SuppressWarnings("unchecked")
private List<LambdaQueryWrapper<ProductCategoryEntity>> capturedSearchWrappers() {
ArgumentCaptor<Wrapper<ProductCategoryEntity>> count = ArgumentCaptor.forClass(Wrapper.class);
verify(productCategoryMapper).selectCount(count.capture());
ArgumentCaptor<Wrapper<ProductCategoryEntity>> list = ArgumentCaptor.forClass(Wrapper.class);
verify(productCategoryMapper).selectList(list.capture());
return List.of((LambdaQueryWrapper<ProductCategoryEntity>) count.getValue(),
(LambdaQueryWrapper<ProductCategoryEntity>) list.getValue());
}
@Test
@DisplayName("空关键字的直接搜索返回空页,不探库")
void blankKeywordSearchShortCircuits() {
ProductCategoryListVo vo = service.search(" ", 1, 20, COMPANY_ID);
assertEquals(0L, vo.getTotal());
verify(productCategoryMapper, never()).selectCount(any());
verify(productCategoryMapper, never()).selectMaps(any());
// CompanyScopeSupport 有 (Long) 与 (AdminUserEntity) 两形:any() 会撞上重载歧义(javac 直接拒绝)。
verify(companyScopeSupport, never()).requireCompanyId(anyLong());
}
}
@@ -0,0 +1,167 @@
package com.nanri.aiimage.modules.shopkey.controller;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.common.service.DataReadScope;
import com.nanri.aiimage.modules.shopkey.model.dto.ShopKeyCreateRequest;
import com.nanri.aiimage.modules.shopkey.model.dto.ShopKeyUpdateRequest;
import com.nanri.aiimage.modules.shopkey.service.ShopKeyService;
import jakarta.servlet.http.HttpServletRequest;
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.springframework.mock.web.MockHttpServletRequest;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.when;
/**
* 「店铺密钥管理」controller 的正门接线(护栏 G2 断言 A 要求正门调用内联在 handler 块里,
* 本文件钉的是内联之后的<b>语义</b>:tab 的值确实进了出口、出口的结果确实交给了 service)。
*
* <p>G2 只看形状(有没有调、结果有没有被当实参用),看不见"把 service 那侧的实参改成 null"
* 这一记 —— 那一记由本文件的 {@code verify(service).page(1L, 15L, 2L)} 负责。</p>
*
* <p>口径参照 {@code ProductCategoryControllerCompanyScopeTest}:同一套"出口给什么就用什么"的两向钉,
* 少任何一向都会放开一类静默失效(正向量不到「出口被绕过」,反向量不到「controller 自己补公司 id」)。</p>
*/
@ExtendWith(MockitoExtension.class)
class ShopKeyControllerCompanyScopeTest {
private static final Long OPERATOR_ID = 11L;
private static final Long COMPANY_ID = 2L;
@Mock
private ShopKeyService shopKeyService;
@Mock
private AdminAuthSupport adminAuthSupport;
@Mock
private DataReadScope dataReadScope;
private ShopKeyController controller() {
return new ShopKeyController(shopKeyService, adminAuthSupport, dataReadScope);
}
@Test
@DisplayName("列表:tab 的公司 id 交给 readCompanyIdOrOwn,出口给什么 service 就用什么")
void pagePassesTheTabValueThroughTheDoor() {
HttpServletRequest request = login();
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(user());
when(dataReadScope.readCompanyIdOrOwn(any(AdminUserEntity.class), eq(COMPANY_ID))).thenReturn(COMPANY_ID);
controller().page(request, 1L, 15L, COMPANY_ID);
verify(dataReadScope).readCompanyIdOrOwn(any(AdminUserEntity.class), eq(COMPANY_ID));
verify(shopKeyService).page(1L, 15L, COMPANY_ID);
}
/**
* 反向钉:超管走"不筛"时出口返回 null,controller 必须原样把 null 传下去。
* 这里"顺手补一个公司 id"的后果是超管切到第 2 家以外时列表永远是第 2 家——
* 与本文件第一支同为正门语义的两半,缺任何一半都放行一次静默改口径。
*/
@Test
@DisplayName("列表:出口判超管(null)时把 null 传下去,不补任何公司 id")
void pageKeepsTheDoorsUnfilteredVerdict() {
HttpServletRequest request = login();
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(user());
when(dataReadScope.readCompanyIdOrOwn(any(AdminUserEntity.class), eq(COMPANY_ID))).thenReturn(null);
controller().page(request, 1L, 15L, COMPANY_ID);
verify(shopKeyService).page(1L, 15L, null);
}
/**
* 非超管带别家的 company_id 时,出口返回的是<b>会话那一家</b>(readCompanyIdOrOwn 的语义),
* controller 不许拿请求里的值再自己判一次——那正是"tab 不是安全边界"被写反的形状。
*/
@Test
@DisplayName("列表:出口按会话收窄后,交给 service 的是收窄值而不是请求里的值")
void pageUsesTheNarrowedValueNotTheRequestedOne() {
HttpServletRequest request = login();
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(user());
when(dataReadScope.readCompanyIdOrOwn(any(AdminUserEntity.class), eq(99L))).thenReturn(COMPANY_ID);
controller().page(request, 1L, 15L, 99L);
verify(shopKeyService).page(1L, 15L, COMPANY_ID);
}
@Test
@DisplayName("更新/删除/白名单检测:把 writeCompanyId 的判定原样交给 service,controller 不自己补公司 id")
void writeEndpointsPassTheRowOwnershipGate() {
HttpServletRequest request = login();
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(user());
when(dataReadScope.writeCompanyId(any(AdminUserEntity.class))).thenReturn(COMPANY_ID);
ShopKeyUpdateRequest body = new ShopKeyUpdateRequest();
body.setZiniaoAccountName("ziniao-a");
body.setZiniaoToken("token-a");
ShopKeyController controller = controller();
controller.update(request, 300L, body);
controller.delete(request, 300L);
controller.checkWhitelist(request, 300L);
verify(shopKeyService).update(300L, body, COMPANY_ID);
verify(shopKeyService).delete(300L, COMPANY_ID);
verify(shopKeyService).checkWhitelist(300L, COMPANY_ID);
verify(dataReadScope, times(3)).writeCompanyId(any(AdminUserEntity.class));
}
@Test
@DisplayName("写侧:闸门判超管(null)时把 null 传下去,否则超管被锁死在本公司")
void writeGateKeepsTheSuperAdminVerdict() {
HttpServletRequest request = login();
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(user());
when(dataReadScope.writeCompanyId(any(AdminUserEntity.class))).thenReturn(null);
ShopKeyUpdateRequest body = new ShopKeyUpdateRequest();
body.setZiniaoAccountName("ziniao-a");
body.setZiniaoToken("token-a");
controller().update(request, 300L, body);
verify(shopKeyService).update(300L, body, null);
}
/**
* 写侧口径(一期定案):归属由后端从操作者会话推导,请求体不带 company_id,
* 所以 create 这一支<b>不许</b>碰任何读门——碰了就是"建号归谁由前端说了算"。
*/
@Test
@DisplayName("新增:只把操作者 id 交给 service,公司由 service 从会话推导")
void createPassesOnlyTheOperator() {
HttpServletRequest request = login();
when(adminAuthSupport.requireAdminOrInternal(request)).thenReturn(user());
ShopKeyCreateRequest body = new ShopKeyCreateRequest();
body.setZiniaoAccountName("ziniao-a");
body.setZiniaoToken("token-a");
body.setRemarkName("备注");
controller().create(request, body);
ArgumentCaptor<Long> operatorId = ArgumentCaptor.forClass(Long.class);
verify(shopKeyService).create(eq(body), operatorId.capture());
assertEquals(OPERATOR_ID, operatorId.getValue());
verifyNoInteractions(dataReadScope);
}
private MockHttpServletRequest login() {
return new MockHttpServletRequest();
}
private AdminUserEntity user() {
AdminUserEntity user = new AdminUserEntity();
user.setId(OPERATOR_ID);
user.setRole("super_admin");
return user;
}
}
@@ -0,0 +1,345 @@
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.TableFieldInfo;
import com.baomidou.mybatisplus.core.metadata.TableInfo;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.service.CompanyScopeSupport;
import com.nanri.aiimage.common.mapper.AdminUserMapper;
import com.nanri.aiimage.modules.shopkey.mapper.ShopKeyMapper;
import com.nanri.aiimage.modules.shopkey.model.dto.ShopKeyCreateRequest;
import com.nanri.aiimage.modules.shopkey.model.dto.ShopKeyUpdateRequest;
import com.nanri.aiimage.modules.shopkey.model.entity.ShopKeyEntity;
import com.nanri.aiimage.modules.ziniao.service.ZiniaoApiKeyProvider;
import com.nanri.aiimage.modules.ziniao.service.ZiniaoAuthService;
import com.nanri.aiimage.modules.ziniao.service.ZiniaoShopIndexService;
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 java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
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.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* V150「店铺密钥管理按公司区分」的 service 侧闸门。
*
* <p>钉的是三件事,每一件都对应一种"接口 200、页面看不出来"的静默形状:</p>
* <ol>
* <li>读范围:{@code companyId} 非空时查询条件里必须真的出现 {@code company_id =},为空时一个条件都不许加。
* 只钉正向等于放行"永远筛第 1 家",只钉反向等于放行"超管被锁死在本公司"。</li>
* <li>写归属:{@code create} 的 {@code company_id} 由<b>操作者会话</b>推导,取不到公司时必须抛而不是落 null
* 让 {@code DEFAULT 1} 静默兜住——那正是本仓一期点名要消灭的"归属失真且不报错"。</li>
* <li>写闸门:跨公司的行必须被 {@code assertSameCompany} 拦下,且拦下之后<b>后面的动作一个都不许发生</b>
* ({@code updateById}/{@code deleteById}/出网探测)。读侧已经收窄而写侧不收窄="藏起来的密钥照样能删"。</li>
* </ol>
*
* <p>{@code CompanyScopeSupport} 用<b>真实现</b>(只 mock 它的 {@code AdminUserMapper}):
* {@code requireCompanyId} 的抛与 {@code assertSameCompany} 的比较都是本文件要验的语义,
* mock 掉等于把闸门本身换成"永远通过"的桩。</p>
*/
@ExtendWith(MockitoExtension.class)
class ShopKeyServiceCompanyScopeTest {
private static final Long OPERATOR_ID = 11L;
private static final Long OWN_COMPANY = 2L;
private static final Long OTHER_COMPANY = 1L;
private static final long ROW_ID = 300L;
@Mock
private ShopKeyMapper shopKeyMapper;
@Mock
private ZiniaoShopIndexService ziniaoShopIndexService;
@Mock
private ZiniaoApiKeyProvider ziniaoApiKeyProvider;
@Mock
private ZiniaoAuthService ziniaoAuthService;
@Mock
private AdminUserMapper adminUserMapper;
private ShopKeyService service;
@BeforeEach
@SuppressWarnings({"unchecked", "rawtypes"})
void setUp() {
// LambdaQueryWrapper 要把 ShopKeyEntity::getCompanyId 解析成列名,靠的是 MP 解析过的 TableInfo;
// 不先 initTableInfo 时断言打在"根本没渲染出来"的空串上,那是一枝恒绿的假断言。
TableInfoHelper.initTableInfo(
new MapperBuilderAssistant(new MybatisConfiguration(), ""), ShopKeyEntity.class);
service = new ShopKeyService(shopKeyMapper, ziniaoShopIndexService, ziniaoApiKeyProvider,
ziniaoAuthService, new CompanyScopeSupport(adminUserMapper));
}
// -------------------------------------------------------------- 读范围
@Test
@DisplayName("V150 加的列就是代码读写的那一列:companyId → company_id")
void entityMapsCompanyIdToTheColumnTheMigrationAdds() {
TableInfo tableInfo = TableInfoHelper.getTableInfo(ShopKeyEntity.class);
assertThat(tableInfo.getTableName()).isEqualTo("biz_shop_key");
assertThat(tableInfo.getFieldList().stream()
.filter(field -> "companyId".equals(field.getProperty()))
.map(TableFieldInfo::getColumn)
.collect(Collectors.toList()))
.as("实体必须有 companyId 字段且解析到 company_id:列名对不上时 WHERE 与 INSERT 一起打到不存在的列")
.containsExactly("company_id");
}
@Test
@SuppressWarnings({"unchecked", "rawtypes"})
void readScopeAddsTheCompanyCondition() {
stubPageQueries();
service.page(1L, 15L, OWN_COMPANY);
LambdaQueryWrapper<ShopKeyEntity> query = capturedCountQuery();
// 钉成等值而不是 contains("company"):把条件写成 company_id IS NOT NULL 也含 "company",
// 而那种写法在第 2 家的 tab 上会把第 1 家的行一起放出来。
assertThat(query.getSqlSegment()).contains("company_id =");
assertThat(query.getParamNameValuePairs()).containsValue(OWN_COMPANY);
}
@Test
void readScopeNullMeansUnfilteredAndNothingIsSubstituted() {
stubPageQueries();
service.page(1L, 15L, null);
// 与上一条对照才有意义:null 是超管「不筛」的判定,这里补一个默认公司就把超管锁死在本公司,
// 而"切 tab 数字不动"的报障会重新出现。
LambdaQueryWrapper<ShopKeyEntity> query = capturedCountQuery();
assertThat(query.getSqlSegment()).doesNotContain("company_id");
assertThat(query.getParamNameValuePairs()).isEmpty();
}
// -------------------------------------------------------------- 写归属
@Test
void createAttributesTheRowToTheOperatorCompanyNotToTheRequestBody() {
stubInsertAndReload(ROW_ID, OWN_COMPANY);
when(adminUserMapper.selectById(OPERATOR_ID)).thenReturn(operatorInCompany(OWN_COMPANY));
service.create(createRequest(), OPERATOR_ID);
ArgumentCaptor<ShopKeyEntity> inserted = ArgumentCaptor.forClass(ShopKeyEntity.class);
verify(shopKeyMapper).insert(inserted.capture());
assertThat(inserted.getValue().getCompanyId()).isEqualTo(OWN_COMPANY);
}
/**
* 请求体里根本没有 company_id 这个字段(一期定案:归属由后端从会话推导)。
* 这一支钉的是"别给 DTO 加一个 company_id 就完事"——加了之后前端传什么算什么,
* 而 {@code ShopKeyController.create} 不读任何门,归属就成了可写字段。
*/
@Test
@DisplayName("请求体不许带归属字段:create/update 两个 DTO 都不该有 companyId")
void requestDtoCarriesNoCompanyField() {
for (Class<?> dto : List.of(ShopKeyCreateRequest.class, ShopKeyUpdateRequest.class)) {
List<String> fields = Arrays.stream(dto.getDeclaredFields())
.map(field -> field.getName())
.collect(Collectors.toList());
assertThat(fields)
.as(dto.getSimpleName() + " 一旦出现 companyId,归属就从「后端按会话推导」变成「前端说了算」")
.doesNotContain("companyId")
.doesNotContain("company_id");
}
}
@Test
@DisplayName("操作者没有所属公司:抛,且一行都不许落库(不许让 DEFAULT 1 静默兜住)")
void createRefusesWhenTheOperatorHasNoCompany() {
when(adminUserMapper.selectById(OPERATOR_ID)).thenReturn(operatorInCompany(null));
assertThatThrownBy(() -> service.create(createRequest(), OPERATOR_ID))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("没有所属公司");
verify(shopKeyMapper, never()).insert(any(ShopKeyEntity.class));
}
// -------------------------------------------------------------- 写闸门
@Test
@DisplayName("更新别家公司的密钥:403 且 updateById 一次都不许发生")
void updateRefusesAnotherCompanysRow() {
stubSelectById(row(ROW_ID, OTHER_COMPANY));
assertThatThrownBy(() -> service.update(ROW_ID, updateRequest(), OWN_COMPANY))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("别家公司的紫鸟令牌");
verify(shopKeyMapper, never()).updateById(any(ShopKeyEntity.class));
}
@Test
@DisplayName("删除别家公司的密钥:403 且 deleteById 一次都不许发生")
void deleteRefusesAnotherCompanysRow() {
stubSelectById(row(ROW_ID, OTHER_COMPANY));
assertThatThrownBy(() -> service.delete(ROW_ID, OWN_COMPANY))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("别家公司的紫鸟令牌");
verify(shopKeyMapper, never()).deleteById(anyLong());
}
/**
* 手动白名单检测会<b>真的出网</b>(打一次紫鸟接口):跨公司拦不住的话,代价不只是"看到别家的行",
* 而是用别家的令牌消耗别家的上游配额、并把别家那行的失败计数改着玩。
*/
@Test
@DisplayName("检测别家公司密钥的白名单:403 且一次出网探测都不发")
void whitelistProbeRefusesAnotherCompanysRow() {
stubSelectById(row(ROW_ID, OTHER_COMPANY));
assertThatThrownBy(() -> service.checkWhitelist(ROW_ID, OWN_COMPANY))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("别家公司的紫鸟令牌");
verify(ziniaoAuthService, never()).probeApiKeyUpstream(anyString());
}
@Test
@DisplayName("同公司的行照常放行:闸门不是把这一页整个锁死")
void sameCompanyRowIsStillWritable() {
ShopKeyEntity existing = row(ROW_ID, OWN_COMPANY);
stubSelectById(existing);
service.delete(ROW_ID, OWN_COMPANY);
verify(shopKeyMapper).deleteById(ROW_ID);
}
@Test
@DisplayName("超管闸门给 null:别家的行也照删(写侧口径与读侧同源,不另立规矩)")
void superAdminGatePassesEveryRow() {
stubSelectById(row(ROW_ID, OTHER_COMPANY));
service.delete(ROW_ID, null);
verify(shopKeyMapper).deleteById(ROW_ID);
}
@Test
@DisplayName("行上没有归属(历史脏行):按跨公司处理拦下,不当成「谁的都不是」放过去")
void rowWithoutCompanyIsTreatedAsForeign() {
stubSelectById(row(ROW_ID, null));
assertThatThrownBy(() -> service.delete(ROW_ID, OWN_COMPANY))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("别家公司的紫鸟令牌");
verify(shopKeyMapper, never()).deleteById(anyLong());
}
// ------------------------------------------------------ 令牌查重的范围
/**
* 令牌查重<b>刻意保持跨公司全局</b>(迁移文件头 §4:同一个令牌在两家公司各存一行会被
* {@code ZiniaoApiKeyProvider} 按令牌并成一条,白名单状态与代理地址互相顶掉)。
*
* <p>这一支是对那条决定的<b>反向钉</b>:将来有人"顺手"把 {@code ensureTokenAvailable} 按
* {@code companyId} 收窄,数据库那把全局唯一键照样会撞 1062,而 service 侧的友好报错先没了 ——
* 症状变成"新增密钥偶发 500"。所以这里钉的是查重的谓词里<b>不许出现 company_id</b>。</p>
*/
@Test
@SuppressWarnings({"unchecked", "rawtypes"})
void tokenDedupePredicateStaysGlobal() {
when(adminUserMapper.selectById(OPERATOR_ID)).thenReturn(operatorInCompany(OWN_COMPANY));
when(shopKeyMapper.selectOne(any(LambdaQueryWrapper.class))).thenReturn(null);
stubInsertAndReload(ROW_ID, OWN_COMPANY);
service.create(createRequest(), OPERATOR_ID);
ArgumentCaptor<LambdaQueryWrapper> captor = ArgumentCaptor.forClass(LambdaQueryWrapper.class);
verify(shopKeyMapper).selectOne(captor.capture());
LambdaQueryWrapper<ShopKeyEntity> query = captor.getValue();
assertThat(query.getSqlSegment()).contains("ziniao_token_hash =");
assertThat(query.getSqlSegment()).doesNotContain("company_id");
}
// ---------------------------------------------------------------- 桩
@SuppressWarnings({"unchecked", "rawtypes"})
private void stubPageQueries() {
when(shopKeyMapper.selectCount(any(LambdaQueryWrapper.class))).thenReturn(0L);
when(shopKeyMapper.selectList(any(LambdaQueryWrapper.class))).thenReturn(List.of());
}
@SuppressWarnings({"unchecked", "rawtypes"})
private LambdaQueryWrapper<ShopKeyEntity> capturedCountQuery() {
ArgumentCaptor<LambdaQueryWrapper> captor = ArgumentCaptor.forClass(LambdaQueryWrapper.class);
verify(shopKeyMapper).selectCount(captor.capture());
return captor.getValue();
}
private void stubSelectById(ShopKeyEntity row) {
when(shopKeyMapper.selectById(ROW_ID)).thenReturn(row);
}
/**
* MP 的真 insert 会把自增主键回填进实体;mock 不会,所以这里用 thenAnswer 补那一步——
* 少了它,{@code create} 结尾的 {@code loadRow(entity.getId())} 会拿着 null 去查,
* 于是"归属落对了"这条断言红在"店铺密钥不存在"上,报的是错原因。
*/
private ShopKeyEntity stubInsertAndReload(Long id, Long companyId) {
ShopKeyEntity stored = row(id, companyId);
when(shopKeyMapper.insert(any(ShopKeyEntity.class))).thenAnswer(invocation -> {
ShopKeyEntity entity = invocation.getArgument(0);
entity.setId(id);
return 1;
});
when(shopKeyMapper.selectById(id)).thenReturn(stored);
return stored;
}
private static ShopKeyEntity row(Long id, Long companyId) {
ShopKeyEntity entity = new ShopKeyEntity();
entity.setId(id);
entity.setCompanyId(companyId);
entity.setZiniaoAccountName("ziniao-account");
entity.setZiniaoToken("old-token");
entity.setZiniaoTokenHash("old-hash");
entity.setIpWhitelistStatus("UNKNOWN");
entity.setIpWhitelistFailCount(0);
return entity;
}
private static AdminUserEntity operatorInCompany(Long companyId) {
AdminUserEntity user = new AdminUserEntity();
user.setId(OPERATOR_ID);
user.setCompanyId(companyId);
return user;
}
private static ShopKeyCreateRequest createRequest() {
ShopKeyCreateRequest request = new ShopKeyCreateRequest();
request.setZiniaoAccountName("ziniao-account");
request.setZiniaoToken("new-token");
return request;
}
private static ShopKeyUpdateRequest updateRequest() {
ShopKeyUpdateRequest request = new ShopKeyUpdateRequest();
request.setZiniaoAccountName("ziniao-account");
request.setZiniaoToken("new-token");
return request;
}
}
@@ -75,8 +75,7 @@ public class SimilarAsinLlmLocalVerify {
// 生产真实类目数据(导出自 biz_product_category),spy 类目服务按 parentId 过滤。
List<com.nanri.aiimage.modules.productcategory.model.entity.ProductCategoryEntity> categories = loadCategories(objectMapper);
ProductCategoryService categoryService = Mockito.spy(new ProductCategoryService(
Mockito.mock(com.nanri.aiimage.modules.productcategory.mapper.ProductCategoryMapper.class),
Mockito.mock(com.nanri.aiimage.common.service.CompanyScopeSupport.class)));
Mockito.mock(com.nanri.aiimage.modules.productcategory.mapper.ProductCategoryMapper.class)));
Mockito.doAnswer(invocation -> {
Long parentId = invocation.getArgument(0);
List<com.nanri.aiimage.modules.productcategory.model.vo.ProductCategoryItemVo> items = categories.stream()