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
@@ -112,15 +112,20 @@ import org.junit.jupiter.api.Test;
* D 的代价与射程一并交代:非 {@code Long} 型公司参数取不到绑定名,判红并报形状;而"handler 之外的私有
* 收口方法里把公司参数硬写成 {@code null}"这一族 D 看不见——块边界止于该 handler 自己的闭括号
* (第 7 条),{@code AdminImageVideoTaskController.scopeOf} 正是它,那一处是<b>故意</b>传 null 的。</li>
* <li><b>几条正门,一套判据</b>(批次 2/3 新增;10-06 复验后加第三道)。{@code DataReadScope} 现在有三个出口:
* <li><b>几条正门,一套判据</b>(批次 2/3 新增;10-06 复验后加第二道,批次 6 加第三道)。出口现在有三个:
* {@code readScope(} 按账号集合给范围(去重库、查询 ASIN、最低价 ASIN、历史、视频),
* {@code readCompanyId(} 给"归属已物化成 {@code company_id} 列"的表(品牌库、商品类目——
* 那两张表的 {@code uploader_user_id} 在生产是 0 行非空,按账号筛等于把全部历史从每个公司 tab 里
* 静默删掉,理由写在 {@code DataReadScope#readCompanyId} 的注释里)。两条门共用 A/B/C/D 四条判据:
* {@code readCompanyIdOrOwn(} 给"归属物化成 {@code company_id} 列、可见集又不靠账号/分组"的表
* (今天只有店铺密钥,V150 起每公司一套),{@code resolveScopeCompanyId(} 给菜单字典那一棵树一套
* (V149 起,读写共用同一判据,见 {@link #RESOLVE_MENU_SCOPE_CALL} 的理由)。
* 三道门共用 A/B/C/D 四条判据:
* {@link #SCOPE_DOORS} 供 A 与 C 逐条跑,{@link #SCOPE_CALLEE_NAMES} 供 D 认被调名,
* <b>名单只写一次</b>(红因消息与自检断言咬的是拼出来的同一个标签,两处各写一遍会随哈希顺序漂红)。
* 每条门各自带能红/能绿两向探针(全局约束 15 那把尺子):只在 {@code readScope} 上验过,
* 等于第二道门上的返回值与入参没人看守。</li>
* 等于第二道门上的返回值与入参没人看守;第三道门(菜单字典)的三枚 {@code MENU_SCOPE_*} 探针同理。
* <p>批次 2 时这里还有<b>中间</b>那道 {@code readCompanyId(},服务品牌库 {@code biz_invalid_asin_data}
* 与商品类目 {@code biz_product_category} 两张物化列表。10-06 控制方把这两页定成全平台共享,
* 方法随之删除 ⇒ 门也从名单一起摘掉:名单里留一门没有实现者的门,等于给"把公司开关再接回那两张表"
* 预先铺好合规形状。这一族现在由 {@link #SHARED_TABLES_MUST_STAY_UNSCOPED} 反向钉住。</p></li>
* <li><b>取实参表按配对括号,不按单层括号正则</b>(10-05 批次 2/3 实跑)。原先 C 的第 ② 步与 D 都用
* {@code ([\w$]*)\s*\(([^()]*)\)},实参表里只要还有一次方法调用就整条看不见。而第 7 条把块边界钉死在
* handler 自己的闭括号上、断言 A 因此要求正门调用必须内联,两支约束合起来把合规接线逼成了
@@ -171,29 +176,35 @@ class CompanyIdParamGoesThroughReadScopeTest {
* 不钉这一条的话,"取样集非空"自检可以由任何一支别的 handler 满足,而这两页哪天改了
* mapping 注解 / 换了参数形状就会静默脱离射程——分母由本轮自己造,等于没有分母。
*
* <p>10-05 批次 2/3(去重库、品牌库、查询ASIN、最低价ASIN、商品类目)把样本面扩到了
* {@link #READ_COMPANY_ID_CALL} 那条正门上,所以这里补两条同样口径的射程下限:
* 那五页哪天改了参数形状,静默脱离的是这一页的 tab,不是这条用例。</p>
* <p>10-05 批次 2/3 把样本面扩到当时那条按物化列给范围的正门({@code readCompanyId})上,
* 并补了两条同样口径的射程下限(品牌库、商品类目)。10-06 那两页定案全平台共享、门随之删除,
* 这两条下限一起摘掉——剩下的六页哪天改了参数形状,静默脱离的是它自己的 tab,不是这条用例。</p>
*/
private static final String SCOPE_CAUGHT_HISTORY_KEY =
"com/nanri/aiimage/modules/imagehistory/controller/ImageHistoryController.java#@GetMapping(\"/history\")";
private static final String SCOPE_CAUGHT_VIDEO_KEY =
"com/nanri/aiimage/modules/imagevideo/controller/AdminImageVideoTaskController.java#@GetMapping";
private static final String SCOPE_CAUGHT_INVALID_ASIN_KEY =
"com/nanri/aiimage/modules/invalidasin/controller/InvalidAsinDataController.java#@GetMapping";
private static final String SCOPE_CAUGHT_PRODUCT_CATEGORY_KEY =
"com/nanri/aiimage/modules/productcategory/controller/ProductCategoryController.java#@GetMapping(\"/product-categories\")";
private static final String SCOPE_CAUGHT_DEDUPE_KEY =
"com/nanri/aiimage/modules/dedupe/controller/DedupeTotalDataController.java#@GetMapping";
private static final String SCOPE_CAUGHT_QUERY_ASIN_KEY =
"com/nanri/aiimage/modules/shopkey/controller/QueryAsinController.java#@GetMapping";
private static final String SCOPE_CAUGHT_SKIP_PRICE_ASIN_KEY =
"com/nanri/aiimage/modules/shopkey/controller/SkipPriceAsinController.java#@GetMapping";
/**
* V150(10-06「店铺密钥管理的数据按照公司区分」)接的第八支:这一页的正门是
* {@code readCompanyIdOrOwn}(表里没有账号列,只有 V150 新加的 {@code company_id})。
*/
private static final String SCOPE_CAUGHT_SHOP_KEY_KEY =
"com/nanri/aiimage/modules/shopkey/controller/ShopKeyController.java#@GetMapping";
/**
* 射程下限的<b>唯一一份</b>名单:C 与 D 两条射程断言共用它,不许各写一份(两处各写就会有一处先漂)。
* 这七支是"切 tab 数据还是一样"这次报障正对着的页面 —— 用户报的五页(去重库、品牌库、最低价ASIN、
* 商品类目、查询ASIN)加批次 1 已接线的两页(图片历史、图片视频任务)。
* 这六支是"切 tab 数据还是一样"这次报障正对着的页面里<b>今天仍按公司取数</b>的那些:
* 批次 1 的两页(图片历史、图片视频任务)+ 批次 2 剩下三页(去重库、查询ASIN、最低价ASIN)
* + V150 的店铺密钥。
* <p>品牌库、商品类目 2026-10-06 定案退回全平台共享({@link #SHARED_TABLES_MUST_STAY_UNSCOPED}),
* 它们的公司参数已从 controller 上摘掉,留在这里只会让 {@code contains(...)} 恒红——
* "不得回流"改由那一条反向钉看守,不靠射程名单。</p>
*/
private static final List<String> WIRED_PAGE_KEYS = List.of(
SCOPE_CAUGHT_HISTORY_KEY,
@@ -201,38 +212,36 @@ class CompanyIdParamGoesThroughReadScopeTest {
SCOPE_CAUGHT_DEDUPE_KEY,
SCOPE_CAUGHT_QUERY_ASIN_KEY,
SCOPE_CAUGHT_SKIP_PRICE_ASIN_KEY,
SCOPE_CAUGHT_INVALID_ASIN_KEY,
SCOPE_CAUGHT_PRODUCT_CATEGORY_KEY);
SCOPE_CAUGHT_SHOP_KEY_KEY);
private static final String READ_SCOPE_CALL = "readScope(";
/**
* 第二个被认可的正门(10-05 批次 2/3):{@code DataReadScope.readCompanyId(operator, companyId)}。
* 第二道正门(10-06 复验后补):{@code readCompanyIdOrOwn}。
*
* <p>它存在的理由不是省事:品牌库 {@code biz_invalid_asin_data} 实测 14,801 行里
* {@code uploader_user_id} 非空 <b>0</b> 行(实体没这字段、批量 INSERT 的列清单也没带,V145 补的列
* 一直是空的),走 {@code readScope} 那批账号集合等于把全部历史从每一个公司 tab 里静默删掉;
* 商品类目 {@code biz_product_category} 更是连账号列都没有(V147 才加的 company_id)。
* 这两页的归属是<b>物化列</b>,正门必须按列给。</p>
*
* <p>几条正门是并列的<b>白名单</b>而不是新的自由口径:判据 A/C/D 与 {@code readScope} 逐字共用,
* 只是把"出现过 readScope("换成"出现过任一正门"," companyId 进了 readScope 的实参表"换成
* "进了任一正门的实参表"。页里自己写 {@code if (companyId != null) ...} 那一族
* 依然红——名单只加在 {@code DataReadScope} 上,加不在页上。</p>
*/
private static final String READ_COMPANY_ID_CALL = "readCompanyId(";
/**
* 第三道正门(10-06 复验后补):{@code readCompanyIdOrOwn}。
*
* <p>它补的是 {@code readCompanyId} 在非超管那一支的洞:品牌库的"非超管不筛"靠账号/分组谓词兜底,
* 商品类目既没有账号列也没有分组可见集,返回 null 就是"每一家都读到整棵树"——
* 2026-10-06 逐节点复验实测公司 2 的 admin 在该页读到 412 行(含公司 1 的 394 个自建类目)。</p>
* <p>它补的是"归属物化成 {@code company_id} 列、且可见集不靠账号/分组"那一族表:今天的消费者是
* 店铺密钥 {@code biz_shop_key}(V150 起每公司一套),表里没有账号列,返回 null 等于把整张表交给每一家。</p>
*
* <p>入名单的前提是它仍然只是 {@code DataReadScope} 上的一个方法,不是页里自己写的 if:
* 第三条门若开在 controller 里,这一页的判据就没人看守了。</p>
* 第二条门若开在 controller 里,这一页的判据就没人看守了。</p>
*
* <p>原先这里还有中间那道 {@code readCompanyId(}:品牌库、商品类目两张物化列表用它在超管身上做
* "tab 选哪家"的开关。2026-10-06 控制方定案那两页全平台共享、不区分公司,方法已从
* {@code DataReadScope} 删除、全树零消费者,所以这道门连同它的三枚探针一起摘掉——
* 判据名单里留一门没有实现者的门,等于给"把公司开关再接回那两张表"预先铺好合规形状。</p>
*/
private static final String READ_OWN_COMPANY_ID_CALL = "readCompanyIdOrOwn(";
/**
* 第三道正门(10-06 批次 6 补):{@code resolveScopeCompanyId}——菜单字典({@code columns} 每家公司一套树)
* 的归属判据。它开在 {@code PermissionMenuService} 上而不是 {@code DataReadScope} 上,理由与 {@code readCompanyIdOrOwn}
* 那条"必须是共享方法、不许页里自己写 if"是同一条:读写两侧、{@code loadRawMenus} 的每一个取数、
* 建/改/删/排四道写侧闸门全都只从这一个方法拿公司 id,判据分两处迟早漂移成"读能看别家、写挡不住"。
*
* <p>与 {@code readCompanyIdOrOwn} 的差别是定案 D2 要求的,不是笔误:超管<b>不传</b>时这道门返回他自己的
* 公司(菜单字典没有"混着两家的树一起列"这种视图),非超管<b>传别家</b>时抛 403 而不是静默改成本公司。</p>
*/
private static final String RESOLVE_MENU_SCOPE_CALL = "resolveScopeCompanyId(";
private static final List<String> SCOPE_DOORS =
List.of(READ_SCOPE_CALL, READ_COMPANY_ID_CALL, READ_OWN_COMPANY_ID_CALL);
List.of(READ_SCOPE_CALL, READ_OWN_COMPANY_ID_CALL, RESOLVE_MENU_SCOPE_CALL);
private static final String EXPLICIT_PARAM_NAME = "name = \"company_id\"";
private static final String SNAKE_PARAM = "company_id";
private static final String CAMEL_PARAM = "companyId";
@@ -275,10 +284,11 @@ class CompanyIdParamGoesThroughReadScopeTest {
"if", "for", "while", "switch", "do", "catch", "synchronized", "return", "throw", "else", "try");
/**
* 断言 D 认的三个被调名:{@code readScope} 是按账号集合给范围的唯一出口,
* 断言 D 认的四个被调名:{@code readScope} 是按账号集合给范围的唯一出口,
* {@code resolveScope} 是 Task 11 模板鼓励的"controller 里的私有收口方法"那一形(它内部再去
* readScope),{@code readCompanyId} 是归属已物化成 {@code company_id} 列那两张表
* (品牌库、商品类目)的正门(见 {@link #READ_COMPANY_ID_CALL} 的理由)。
* readScope),{@code readCompanyIdOrOwn} 是"归属物化成 {@code company_id} 列、可见集不靠账号/分组"
* 那一族表(今天只有店铺密钥)的正门(见 {@link #READ_OWN_COMPANY_ID_CALL} 的理由),
* {@code resolveScopeCompanyId} 是菜单字典那一棵树一套的归属判据(见 {@link #RESOLVE_MENU_SCOPE_CALL} 的理由)。
* 除此之外的调用都不算"把公司参数交给了出口"——尤其 {@code readScope(operator, null)} 里那个 {@code null}。
*/
private static final String RESOLVE_SCOPE_CALL = "resolveScope(";
@@ -288,7 +298,7 @@ class CompanyIdParamGoesThroughReadScopeTest {
* 那就等于一条会自己漂红的用例。
*/
private static final List<String> SCOPE_CALLEE_NAMES =
List.of("readScope", "resolveScope", "readCompanyId", "readCompanyIdOrOwn");
List.of("readScope", "resolveScope", "readCompanyIdOrOwn", "resolveScopeCompanyId");
private static final Set<String> SCOPE_CALLEES = Set.copyOf(SCOPE_CALLEE_NAMES);
private static final String SCOPE_CALLEE_LABEL = String.join("/", SCOPE_CALLEE_NAMES);
@@ -448,64 +458,20 @@ class CompanyIdParamGoesThroughReadScopeTest {
""";
/**
* 第二条正门({@code readCompanyId})的<b>正探针</b>:形状逐字抄现网那一支
* ({@code InvalidAsinDataController.page} —— 先 {@code operator.user()} 把实体取出来,
* 再 {@code Long scopedCompanyId = dataReadScope.readCompanyId(user, companyId);},
* 最后把 {@code scopedCompanyId} 交给 service)。
* <p>它证明的是"判据不是只认 {@code readScope} 那一族":C 的第 ①/② 步和 D 都必须在这一形上判绿,
* 否则五页里靠物化列给范围的那两页会红在护栏上,而不是红在真缺陷上。</p>
*/
private static final String READ_COMPANY_ID_CAUGHT_PROBE = """
@GetMapping("/probe")
public String typedDoor(@RequestParam(name = "company_id", required = false) Long companyId) {
AdminUserEntity user = operator.user();
Long scopedCompanyId = dataReadScope.readCompanyId(user, companyId);
return String.valueOf(invalidAsinDataService.page(1, 15, scopedCompanyId));
}
""";
/**
* 第二条正门的<b>裸语句探针</b>(C 第 ① 步在该门上的"能红"证据):
* {@code scopeCatchFailure} 是对两条门<b>逐条</b>跑那两步的,只在 {@code readScope} 上验过不算验过——
* 少了这一枚,"第二道门根本没人看守它的返回值"就能悄悄进仓。
*/
private static final String READ_COMPANY_ID_DISCARD_PROBE = """
@GetMapping("/probe")
public String typedDoorDiscard(@RequestParam(name = "company_id", required = false) Long companyId) {
dataReadScope.readCompanyId(user, companyId);
return "ok";
}
""";
/**
* 第二条正门的<b>负探针</b>(D 在该门上的存在理由):出口调了、结果接住了、也喂给 service 了,
* 唯独进出口的是 {@code null} —— 与 {@link #SCOPE_PASSED_NULL_PROBE} 同一记刀,只是换了道门。
* A/B/C 三条前提在自检里逐条钉住为绿,才说明这一刀今天确实只有 D 会喊。
*/
private static final String READ_COMPANY_ID_PASSED_NULL_PROBE = """
@GetMapping("/probe")
public String typedDoorNull(@RequestParam(name = "company_id", required = false) Long companyId) {
AdminUserEntity user = operator.user();
Long scopedCompanyId = dataReadScope.readCompanyId(user, null);
return String.valueOf(invalidAsinDataService.page(1, 15, scopedCompanyId));
}
""";
/**
* 第三道正门({@code readCompanyIdOrOwn})的<b>正探针</b>:形状抄现网
* {@code ProductCategoryController.list} —— 门给什么是什么,controller 不自己补。
* C 的两步与 D 都必须在这一形上判绿,否则类目页红在护栏上而不是红在缺陷上。
* 第二道正门({@code readCompanyIdOrOwn})的<b>正探针</b>:形状抄现网
* {@code ShopKeyController.list} —— 门给什么是什么,controller 不自己补。
* C 的两步与 D 都必须在这一形上判绿,否则密钥页红在护栏上而不是红在缺陷上。
*/
private static final String READ_OWN_COMPANY_ID_CAUGHT_PROBE = """
@GetMapping("/probe")
public String thirdDoor(@RequestParam(name = "company_id", required = false) Long companyId) {
AdminUserEntity user = operator.user();
Long scopedCompanyId = dataReadScope.readCompanyIdOrOwn(user, companyId);
return String.valueOf(productCategoryService.list(null, scopedCompanyId));
return String.valueOf(shopKeyService.list(null, scopedCompanyId));
}
""";
/** 第三道正门的<b>裸语句探针</b>(C 第 ① 步在该门上的"能红"证据):算完直接丢,等于没筛。 */
/** 第二道正门的<b>裸语句探针</b>(C 第 ① 步在该门上的"能红"证据):算完直接丢,等于没筛。 */
private static final String READ_OWN_COMPANY_ID_DISCARD_PROBE = """
@GetMapping("/probe")
public String thirdDoorDiscard(@RequestParam(name = "company_id", required = false) Long companyId) {
@@ -514,13 +480,59 @@ class CompanyIdParamGoesThroughReadScopeTest {
}
""";
/** 第三道正门的<b>负探针</b>(D 在该门上的存在理由):进出口的是 {@code null},tab 恒不动。 */
/** 第二道正门的<b>负探针</b>(D 在该门上的存在理由):进出口的是 {@code null},tab 恒不动。 */
private static final String READ_OWN_COMPANY_ID_PASSED_NULL_PROBE = """
@GetMapping("/probe")
public String thirdDoorNull(@RequestParam(name = "company_id", required = false) Long companyId) {
AdminUserEntity user = operator.user();
Long scopedCompanyId = dataReadScope.readCompanyIdOrOwn(user, null);
return String.valueOf(productCategoryService.list(null, scopedCompanyId));
return String.valueOf(shopKeyService.list(null, scopedCompanyId));
}
""";
/**
* 第三道正门(菜单字典归属判据 {@code resolveScopeCompanyId})的<b>正探针</b>:
* 结果接进变量并喂给 {@code list(…)},公司参数本身进了门 —— C 与 D 都必须判它绿,
* 否则 {@code PermissionMenuController} 那六支 handler 全是假红。
*/
private static final String MENU_SCOPE_CAUGHT_PROBE = """
@GetMapping("/probe")
public String menuScopeDoor(@RequestParam(name = "company_id", required = false) Long companyId) {
AdminUserEntity user = operator.user();
Long scopeCompanyId = permissionMenuService.resolveScopeCompanyId(user, companyId);
return String.valueOf(permissionMenuService.list(user, "admin", false, scopeCompanyId));
}
""";
/** 第三道正门的<b>裸语句探针</b>(C 第 ① 步在该门上的"能红"证据):门调了、403 也发了,结果却没人接。 */
private static final String MENU_SCOPE_DISCARD_PROBE = """
@GetMapping("/probe")
public String menuScopeDoorDiscard(@RequestParam(name = "company_id", required = false) Long companyId) {
permissionMenuService.resolveScopeCompanyId(user, companyId);
return "ok";
}
""";
/** 第三道正门的<b>负探针</b>(D 在该门上的存在理由):门里进出的是 {@code null},切了 tab 取的还是操作者本公司。 */
private static final String MENU_SCOPE_PASSED_NULL_PROBE = """
@GetMapping("/probe")
public String menuScopeDoorNull(@RequestParam(name = "company_id", required = false) Long companyId) {
AdminUserEntity user = operator.user();
Long scopeCompanyId = permissionMenuService.resolveScopeCompanyId(user, null);
return String.valueOf(permissionMenuService.list(user, "admin", false, scopeCompanyId));
}
""";
/**
* 已摘掉那道门的<b>正样本探针</b>(形状抄退回前的 {@code InvalidAsinDataController.page}:
* 收 {@code company_id} 参数、体内调 {@code readCompanyId})。它现在应当被 A/C/D 三条同时判红——
* 红因必须落在"三条正门都没走"上,而不是"这段源码没被切成 handler"。
*/
private static final String RETIRED_DOOR_WIRED_PROBE = """
@GetMapping("/probe")
public String retiredDoorWired(@RequestParam(name = "company_id", required = false) Long companyId) {
Long scoped = dataReadScope.readCompanyId(user, companyId);
return String.valueOf(invalidAsinDataService.page(scoped));
}
""";
@@ -622,16 +634,6 @@ class CompanyIdParamGoesThroughReadScopeTest {
assertThat(scopeProbeReason(SCOPE_TYPE_FORM_PROBE, "SCOPE_TYPE_FORM_PROBE"))
.as("断言 C 自检(第二形):ReadScope s = dataReadScope.readScope(…) 且 s 进了 service.page(…) 的实参 ⇒ 同样要认")
.isNull();
// 第二条正门必须<b>各自</b>有能红/能绿两向证据:C 的判据是对 SCOPE_DOORS 逐条跑的,
// 只在 readScope 上验过,就等于没验过 readCompanyId —— 那一道门上的返回值会没人看守。
assertThat(scopeProbeReason(READ_COMPANY_ID_CAUGHT_PROBE, "READ_COMPANY_ID_CAUGHT_PROBE"))
.as("断言 C 自检(第二道门·正样本):Long scopedCompanyId = dataReadScope.readCompanyId(user, companyId) "
+ "且它进了 service.page(…) 的实参 ⇒ 该判这一形绿,判红就是护栏假红(现网品牌库/商品类目都是这形)")
.isNull();
assertThat(scopeProbeReason(READ_COMPANY_ID_DISCARD_PROBE, "READ_COMPANY_ID_DISCARD_PROBE"))
.as("断言 C 自检(第二道门·负样本):readCompanyId( 写成裸语句、结果当场丢掉 ⇒ 必须判红")
.isNotNull()
.contains("范围算了但没接住");
// 断言 D 的判据自检(两个方向都要,全局约束 15)。负探针要先证明"A/B/C 三条对它都判通过"——
// 这三条前提不成立就说明这段源码本来已经有人看守,D 没有区分度、只是重复劳动。
@@ -662,45 +664,80 @@ class CompanyIdParamGoesThroughReadScopeTest {
.as("断言 D 自检(改名那一族):参数声明叫 orgId、交出去的也是 orgId ⇒ 不许红"
+ "(这条同时钉住\"D 不许硬编码 companyId\":写死了它就会在这一支假红)")
.isNull();
// 第二道门上的 D:先钉 A/B/C 三条前提对它同样全绿(换了道门不等于换了缺陷形状),再钉 D 必须红。
String typedNullProbeText = String.join("\n", textsOf(sourceLines(READ_COMPANY_ID_PASSED_NULL_PROBE)));
assertThat(typedNullProbeText)
.as("断言 D(第二道门)负样本的前提(断言 A/B):readCompanyId( 在 handler 体内、name = \"company_id\" 也在")
.contains(READ_COMPANY_ID_CALL)
.contains(EXPLICIT_PARAM_NAME);
assertThat(scopeProbeReason(READ_COMPANY_ID_PASSED_NULL_PROBE, "READ_COMPANY_ID_PASSED_NULL_PROBE"))
.as("断言 D(第二道门)负样本的前提(断言 C):结果接进 scopedCompanyId 又喂给了 service ⇒ C 判它绿")
.isNull();
assertThat(companyIdArgProbeReason(
READ_COMPANY_ID_PASSED_NULL_PROBE, "READ_COMPANY_ID_PASSED_NULL_PROBE", CAMEL_PARAM))
.as("断言 D 自检(第二道门·负样本):readCompanyId(user, null) —— 出口调了、门也认了,"
+ "tab 传下来的值仍没进出口 ⇒ 同样必须判红(D 不能只咬 readScope 那一族)")
.isNotNull()
.contains("没进任何 " + SCOPE_CALLEE_LABEL + " 的实参列表");
// 第三道门同样要各自带能红/能绿两向证据:C 与 D 都是对 SCOPE_DOORS 逐条跑的,
// 少一枚探针就等于那道门上的返回值与入参没人看守(类目页正是走这道门的页)。
// 第二道门同样要各自带能红/能绿两向证据:C 与 D 都是对 SCOPE_DOORS 逐条跑的,
// 少一枚探针就等于那道门上的返回值与入参没人看守(店铺密钥页正是走这道门的页)。
assertThat(scopeProbeReason(READ_OWN_COMPANY_ID_CAUGHT_PROBE, "READ_OWN_COMPANY_ID_CAUGHT_PROBE"))
.as("断言 C 自检(第三道门·正样本):Long scopedCompanyId = readCompanyIdOrOwn(user, companyId) "
.as("断言 C 自检(第二道门·正样本):Long scopedCompanyId = readCompanyIdOrOwn(user, companyId) "
+ "且它进了 service.list(…) 的实参 ⇒ 判红就是护栏假红")
.isNull();
assertThat(companyIdArgProbeReason(
READ_OWN_COMPANY_ID_CAUGHT_PROBE, "READ_OWN_COMPANY_ID_CAUGHT_PROBE", CAMEL_PARAM))
.as("断言 D 自检(第三道门·正样本):companyId 真进了 readCompanyIdOrOwn 的实参表 ⇒ 不许红")
.as("断言 D 自检(第二道门·正样本):companyId 真进了 readCompanyIdOrOwn 的实参表 ⇒ 不许红")
.isNull();
assertThat(scopeProbeReason(READ_OWN_COMPANY_ID_DISCARD_PROBE, "READ_OWN_COMPANY_ID_DISCARD_PROBE"))
.as("断言 C 自检(第三道门·负样本):readCompanyIdOrOwn( 写成裸语句、结果当场丢掉 ⇒ 必须判红")
.as("断言 C 自检(第二道门·负样本):readCompanyIdOrOwn( 写成裸语句、结果当场丢掉 ⇒ 必须判红")
.isNotNull()
.contains("范围算了但没接住");
assertThat(scopeProbeReason(READ_OWN_COMPANY_ID_PASSED_NULL_PROBE, "READ_OWN_COMPANY_ID_PASSED_NULL_PROBE"))
.as("断言 D(第三道门)负样本的前提(断言 C):结果接进 scopedCompanyId 又喂给了 service ⇒ C 判它绿")
.as("断言 D(第二道门)负样本的前提(断言 C):结果接进 scopedCompanyId 又喂给了 service ⇒ C 判它绿")
.isNull();
assertThat(companyIdArgProbeReason(
READ_OWN_COMPANY_ID_PASSED_NULL_PROBE, "READ_OWN_COMPANY_ID_PASSED_NULL_PROBE", CAMEL_PARAM))
.as("断言 D 自检(第三道门·负样本):readCompanyIdOrOwn(user, null) ⇒ 必须判红")
.as("断言 D 自检(第二道门·负样本):readCompanyIdOrOwn(user, null) ⇒ 必须判红")
.isNotNull()
.contains("没进任何 " + SCOPE_CALLEE_LABEL + " 的实参列表");
// 第三道门(菜单字典)同样各自带能红/能绿两向证据:它今天有六个真实消费者
// (PermissionMenuController 的目录/新建/两页数据范围授权的读与写),只钉"名单里有这个名字"
// 而不验返回值与入参,等于那六支 handler 的 tab 可以随便坏。
assertThat(scopeProbeReason(MENU_SCOPE_CAUGHT_PROBE, "MENU_SCOPE_CAUGHT_PROBE"))
.as("断言 C 自检(第三道门·正样本):Long scopeCompanyId = resolveScopeCompanyId(user, companyId) "
+ "且它进了 permissionMenuService.list(…) ⇒ 判红就是护栏假红")
.isNull();
assertThat(companyIdArgProbeReason(MENU_SCOPE_CAUGHT_PROBE, "MENU_SCOPE_CAUGHT_PROBE", CAMEL_PARAM))
.as("断言 D 自检(第三道门·正样本):companyId 真进了 resolveScopeCompanyId 的实参表 ⇒ 不许红")
.isNull();
assertThat(scopeProbeReason(MENU_SCOPE_DISCARD_PROBE, "MENU_SCOPE_DISCARD_PROBE"))
.as("断言 C 自检(第三道门·负样本):resolveScopeCompanyId( 写成裸语句、结果当场丢掉 ⇒ 必须判红")
.isNotNull()
.contains("范围算了但没接住");
assertThat(scopeProbeReason(MENU_SCOPE_PASSED_NULL_PROBE, "MENU_SCOPE_PASSED_NULL_PROBE"))
.as("断言 D(第三道门)负样本的前提(断言 C):结果接进 scopeCompanyId 又喂给了 list ⇒ C 判它绿")
.isNull();
assertThat(companyIdArgProbeReason(
MENU_SCOPE_PASSED_NULL_PROBE, "MENU_SCOPE_PASSED_NULL_PROBE", CAMEL_PARAM))
.as("断言 D 自检(第三道门·负样本):resolveScopeCompanyId(user, null) ⇒ 必须判红")
.isNotNull()
.contains("没进任何 " + SCOPE_CALLEE_LABEL + " 的实参列表");
// 已摘掉的那道门不许再接回(全局约束 15 的"能红"方向)。这一族 handler(品牌库、商品类目)现在定案
// 全平台共享、不再收公司参数 ⇒ 它们已不进 A/C/D 的样本,"哪天有人把 ?company_id= 接回这两张表"
// 只剩这条探针还在求值,而今天真正拦它的是断言 A:C 与 D 在主循环里都以"体内有正门调用"为前提
// ({@link Block#hasScopeCall()}),只调已摘那道门时它们根本不求值 —— 把这层写成注释而不是三条全红,
// 是因为下一条要钉的就是"D 的名单里不许提前把 readCompanyId 加回来"。
// 前提同样要自证:探针真被切成 1 支收公司 id 参数的 handler、体内一条现存正门都没有、
// 但确实调了 readCompanyId( —— 否则"判红"只是"源码没读到"的另一种形状。
List<Block> retiredDoorBlocks = splitBlocks(sourceLines(RETIRED_DOOR_WIRED_PROBE)).handlers();
assertThat(retiredDoorBlocks)
.as("已摘门探针切不出 handler ⇒ 下面几条判红断言是空跑")
.hasSize(1);
Block retiredDoor = retiredDoorBlocks.get(0);
assertThat(retiredDoor.takesCompanyParam())
.as("已摘门探针没被认成收公司 id 参数(参数形状变了)⇒ A 不会对它求值,这条反向钉没有内容")
.isTrue();
assertThat(retiredDoor.text())
.as("已摘门探针的反面证据:它确实调了 readCompanyId(,这正是定案不许再接回的那一形")
.contains("readCompanyId(");
assertThat(anyScopeDoor(retiredDoor.text()))
.as("断言 A(已摘门):这条 handler 体内一条现存正门都没走过 ⇒ A 必然落进判红分支。"
+ "这里若为 true,说明探针混进了别的正门调用,A 不再是这一形的守门人,本用例失去内容")
.isFalse();
assertThat(retiredDoor.companyIdArgFailure())
.as("断言 D 对被调名单的看守:readCompanyId 一旦被人加回 SCOPE_CALLEE_NAMES(门还没接回、"
+ "名单先到),这一形就会被 D 判绿 ⇒ 这条必须保持判红")
.isNotNull();
// 配对括号取实参表(放宽)的成对证据:两枚正样本必须绿(否则 6 支已接线 handler 假红),
// 一枚"嵌套了但没带公司参数"的样本必须照旧红(否则放宽 = 把 D 关掉)。
assertThat(scopeProbeReason(SCOPE_NESTED_ARG_PROBE, "SCOPE_NESTED_ARG_PROBE"))
@@ -865,6 +902,138 @@ class CompanyIdParamGoesThroughReadScopeTest {
.isEmpty();
}
/**
* 10-06 定案"全平台共享、不区分公司"的两张表:{@code biz_invalid_asin_data}(品牌数据库)、
* {@code biz_product_category}(商品类目)。名单按 <b>module 目录</b>给而不是按 controller——
* 这两页的公司维度原先落在 entity 列、mapper 幂等键和 service 谓词上,只盯 controller 会漏掉那三段。
*
* <p>为什么不能只靠"退出 {@link #WIRED_PAGE_KEYS}":射程名单管的是"收了公司参数的 handler 必须走正门",
* 一页一旦不再收参数就不进样本,A/C/D 三条一起对它停止求值——"哪天有人把 {@code ?company_id=} 接回去"
* 恰好只剩这一条反向钉看得见。</p>
*/
private static final List<String> SHARED_TABLES_MUST_STAY_UNSCOPED = List.of(
"com/nanri/aiimage/modules/invalidasin",
"com/nanri/aiimage/modules/productcategory");
/** 这两张表的类型名锚:module 目录之外的引用者(自动导入那条写侧路)按它取样。 */
private static final List<String> SHARED_TABLE_TYPE_ANCHORS = List.of("InvalidAsinData", "ProductCategory");
/**
* 正样本目录:店铺密钥到今天仍是按公司取数的那一族({@code biz_shop_key},V150)。
* 同一把尺子必须在这里量出命中,否则"共享目录零命中"可能只是尺子坏了(全局约束 15)。
*/
private static final String STILL_SCOPED_MODULE_DIR = "com/nanri/aiimage/modules/shopkey";
private static final String DATA_READ_SCOPE_FILE = "com/nanri/aiimage/common/service/DataReadScope.java";
/** 公司 token 的尺子:整词大小写不敏感,比 {@code company_id}/{@code companyId} 两种写法都宽(含 {@code CompanyScopeSupport})。 */
private static final Pattern ANY_COMPANY_TOKEN = Pattern.compile("(?i)company");
@Test
@DisplayName("品牌库 / 商品类目已定案全平台共享:公司维度不许回流到这两张表的任何一处,出口上也不许再有那条门")
void companyDimensionMustNotFlowBackIntoTheTwoSharedTables() throws IOException {
// ① 尺子自证:同一把尺子必须在仍按公司取数的目录上量出命中,否则下面"共享目录零命中"全是空断言。
List<String> scopedHits = companyTokenLines(STILL_SCOPED_MODULE_DIR);
assertThat(scopedHits)
.as("公司 token 尺子在仍按公司取数的 %s 上零命中 ⇒ 尺子或取样坏了,后面的反向钉全是空断言",
STILL_SCOPED_MODULE_DIR)
.isNotEmpty();
// ② 两张共享表:目录里必须扫得到 .java(目录被改名/挪走也算红,那等于没人看守),且可执行行零公司 token。
for (String dir : SHARED_TABLES_MUST_STAY_UNSCOPED) {
assertThat(javaFilesUnder(dir))
.as("%s 扫不到 .java:目录被改名或挪走了,这条反向钉对它已经不再求值", dir)
.isNotEmpty();
assertThat(companyTokenLines(dir))
.as("品牌数据库 / 商品类目 2026-10-06 定案全平台共享(唯一键退回全局、页面不画公司 tab):"
+ "这两张表的 entity 列、mapper 幂等键、service 谓词、controller 参数都不许再出现公司维度"
+ "(只打可执行行,注释里『故意没有这一列』的说明不算)")
.isEmpty();
}
// ③ 目录外那几处引用这两张表的消费者同样不许带公司维度;锚本身要自证真取到了人。
List<String> consumers = sharedTableConsumerFiles();
assertThat(consumers)
.as("按类型名锚 %s 在两个 module 目录之外连自动导入那条写侧路都没取到 ⇒ 锚失效,这一族没人看守",
SHARED_TABLE_TYPE_ANCHORS)
.contains("com/nanri/aiimage/modules/collectdata/util/CollectDataInvalidAsinBatchWriter.java");
List<String> consumerHits = new ArrayList<>();
for (String rel : consumers) {
consumerHits.addAll(companyTokenLinesInFile(MAIN_ROOT.resolve(rel)));
}
assertThat(consumerHits)
.as("引用这两张表的外部消费者里出现了公司维度——自动导入「推不出公司就整批不写」那道闸门已定案放开,"
+ "把它接回去等于让整批 AUTO 行静默丢失")
.isEmpty();
// ④ 出口这一侧:readCompanyId 是专为这两页的「超管按 tab 选哪家」加的,两页退掉后全树零消费者,已删。
// 先钉同一族的 readCompanyIdOrOwn 还读得到,否则 noneMatch 只是"文件读空"的另一种绿。
List<String> scopeLines = executableLines(read(MAIN_ROOT.resolve(DATA_READ_SCOPE_FILE)));
assertThat(scopeLines)
.as("%s 里一行可执行行都没读到 ⇒ 门检查是空断言", DATA_READ_SCOPE_FILE)
.isNotEmpty();
assertThat(scopeLines.stream().anyMatch(line -> line.contains(READ_OWN_COMPANY_ID_CALL)))
.as("DataReadScope 上那条 OrOwn 门读不到了(改名或删除都要一起改这里):先确认这份文件真被扫到,"
+ "再谈『readCompanyId 不该存在』")
.isTrue();
assertThat(scopeLines.stream().noneMatch(line -> line.contains("readCompanyId(")))
.as("readCompanyId 又回到了 DataReadScope 上:品牌库/商品类目已定案共享,"
+ "一门没有实现者的正门留在出口名单里,等于给公司开关预先铺好合规形状")
.isTrue();
}
/** 某 module 目录(相对 {@code src/main/java},正斜杠)下的全部 {@code .java},按路径排序;目录不存在给空表,由调用方判红。 */
private static List<Path> javaFilesUnder(String moduleDir) throws IOException {
Path root = MAIN_ROOT.resolve(moduleDir);
if (!Files.isDirectory(root)) return List.of();
try (Stream<Path> walk = Files.walk(root)) {
return walk.filter(Files::isRegularFile)
.filter(p -> p.getFileName().toString().endsWith(".java"))
.sorted()
.collect(Collectors.toList());
}
}
/** 一个目录下所有可执行行上的公司 token,报 {@code 相对路径: 行文本}(不带行号:行号会随无关提交漂,文件名+原文足够定位)。 */
private static List<String> companyTokenLines(String moduleDir) throws IOException {
List<String> hits = new ArrayList<>();
for (Path file : javaFilesUnder(moduleDir)) {
hits.addAll(companyTokenLinesInFile(file));
}
return hits;
}
private static List<String> companyTokenLinesInFile(Path file) {
String rel = relativeKey(file);
return executableLines(read(file)).stream()
.filter(line -> ANY_COMPANY_TOKEN.matcher(line).find())
.map(line -> rel + ": " + line)
.collect(Collectors.toList());
}
/**
* 两个 module 目录之外、可执行行里点到这两张表类型名的 main 文件(相对 {@code src/main/java}、正斜杠、排序)。
* 口径同第 1 条:只打可执行行,注释里提一句类名不算引用。
*/
private static List<String> sharedTableConsumerFiles() throws IOException {
List<String> consumers = new ArrayList<>();
try (Stream<Path> walk = Files.walk(MAIN_ROOT)) {
List<Path> files = walk.filter(Files::isRegularFile)
.filter(p -> p.getFileName().toString().endsWith(".java"))
.sorted()
.collect(Collectors.toList());
for (Path file : files) {
String rel = relativeKey(file);
if (SHARED_TABLES_MUST_STAY_UNSCOPED.stream().anyMatch(rel::startsWith)) continue;
if (executableLines(read(file)).stream()
.anyMatch(line -> SHARED_TABLE_TYPE_ANCHORS.stream().anyMatch(line::contains))) {
consumers.add(rel);
}
}
}
return consumers;
}
/**
* 断言 C 的探针驱动器:先确认这段样本真被切成"1 支收公司 id 参数、体内写了 readScope(" 的 handler,
* 再跑 {@link Block#scopeCatchFailure()}。切不出 handler / 不认公司参数 / 没有 readScope( 这三种
@@ -880,7 +1049,8 @@ class CompanyIdParamGoesThroughReadScopeTest {
.as(probeName + " 的 handler 没被认成收公司 id 参数,断言 C 根本不会触发 ⇒ 探针失效")
.isTrue();
assertThat(anyScopeDoor(handler.text()))
.as(probeName + " 的 handler 体内两条正门都没走(readScope( / readCompanyId(),断言 C 扫不到它 ⇒ 探针失效")
.as(probeName + " 的 handler 体内一条正门都没走(" + String.join(" / ", SCOPE_DOORS)
+ "),断言 C 扫不到它 ⇒ 探针失效")
.isTrue();
return handler.scopeCatchFailure();
}
@@ -966,7 +1136,7 @@ class CompanyIdParamGoesThroughReadScopeTest {
return line.contains(SNAKE_PARAM) || line.contains(CAMEL_PARAM);
}
/** 两条正门之一有没有在这段文本里出现过(A/C 的判据都走它,不各写一份)。 */
/** 任一条正门有没有在这段文本里出现过(A/C 的判据都走它,不各写一份)。 */
private static boolean anyScopeDoor(String text) {
return SCOPE_DOORS.stream().anyMatch(text::contains);
}
@@ -1294,7 +1464,7 @@ class CompanyIdParamGoesThroughReadScopeTest {
return null;
}
/** 逐条正门跑"接住 → 交出去"两步:两条门都得走这两步,第二道门不能成为绕过第一道门判据的后门。 */
/** 逐条正门跑"接住 → 交出去"两步:三道门都得走这两步,后一道不能成为绕过前一道判据的后门。 */
private static String scopeCatchFailureFor(String src, String door) {
for (int at = src.indexOf(door); at >= 0;
at = src.indexOf(door, at + door.length())) {
@@ -1397,7 +1567,7 @@ class CompanyIdParamGoesThroughReadScopeTest {
* 与 A/B/C 同一个 handler 窗口)。
* <ul>
* <li>{@code dataReadScope.readScope(operator, companyId)} ⇒ 绿;</li>
* <li>{@code dataReadScope.readCompanyId(user, companyId)}(第二条正门)⇒ 绿;</li>
* <li>{@code dataReadScope.readCompanyIdOrOwn(user, companyId)}(第二条正门)⇒ 绿;</li>
* <li>{@code resolveScope(request, companyId)}(私有收口方法内部再去 readScope)⇒ 绿;</li>
* <li>{@code readScope(operator, normalizeCompany(companyId))} ⇒ <b>绿</b>:嵌套写法自 10-05
* 批次 2/3 起算消费(第 13 条:旧单层正则在这一形上判红,而那正是断言 A 逼出来的形状),
@@ -119,42 +119,22 @@ class DataReadScopeTest {
.isInstanceOf(com.nanri.aiimage.common.exception.BusinessException.class);
}
// ---- 第二条正门:归属已物化成 company_id 列的表(品牌库、商品类目)----
// 这一道门的语义与 readScope 相反方向:返回的是"要筛哪个公司",null = 不筛。
// 非超管一律 null(他们的可见集本来就锁在自己的分组上,再叠一层公司会把"靠分组可见"的行整批删掉,
// 见 DataReadScope#readCompanyId 的注释)。这三条若不写,把 `return null` 改成
// `return companyScope.requireCompanyId(operator)` 不会让任何现有用例变红——而那一改的后果是
// 品牌库里靠分组可见的历史行从每个非超管账号下消失。
// ---- 第二道正门 readCompanyIdOrOwn:归属已物化成 company_id 列、且可见集不靠账号/分组的表 ----
// 语义与 readScope 相反方向:返回的是"要筛哪个公司",null = 不筛。今天的消费者是店铺密钥
// biz_shop_key(V150 起每公司一套,表里没有账号列)。
//
// 这里原先还有一道 readCompanyId:为品牌库/商品类目那两个"物化列 + 非超管靠分组可见"的表而写,
// 非超管一律返回 null(叠一层公司会把靠分组可见的行整批删掉)。2026-10-06 控制方定案那两页
// 全平台共享、不区分公司,方法已从 DataReadScope 删除、全树零消费者,这三条用例一起摘掉。
// "不许再接回"由 CompanyIdParamGoesThroughReadScopeTest#companyDimensionMustNotFlowBackIntoTheTwoSharedTables
// 反向钉(它同时钉住出口上没有这道门),不靠这里留一份无人调用的行为规格。
// 这一道门与 readScope 只差非超管那一支,而那一支正是 10-06 逐节点复验抓到的洞:表里连账号列都没有,
// 非超管返回 null=把整张表交给每一家(实测公司 2 的 admin 读到 412 行、其中 394 行是公司 1 的数据)。
// 这三条若不写,把 `requireCompanyId` 改回 `return null` 不会让任何现有用例变红。
@Test
@DisplayName("第二道门:超管选公司 = 原样给回那一列的筛值")
void readCompanyIdForSuperAdminReturnsTheTab() {
assertThat(dataReadScope.readCompanyId(user(1L, "super_admin", 1L), 2L)).isEqualTo(2L);
}
@Test
@DisplayName("第二道门:超管不选 / 选 0 / 选负数都归一化成「不筛」,不是去查 0 号公司")
void readCompanyIdForSuperAdminNormalisesMissingAndNonPositive() {
assertThat(dataReadScope.readCompanyId(user(1L, "super_admin", 1L), null)).isNull();
assertThat(dataReadScope.readCompanyId(user(1L, "super_admin", 1L), 0L)).isNull();
assertThat(dataReadScope.readCompanyId(user(1L, "super_admin", 1L), -3L)).isNull();
}
@Test
@DisplayName("第二道门:非超管一律 null,别家的 tab 也不炸、也不筛")
void readCompanyIdForNonSuperAdminAlwaysMeansNoFilter() {
assertThat(dataReadScope.readCompanyId(user(5L, "admin", 2L), 2L)).isNull();
assertThat(dataReadScope.readCompanyId(user(5L, "admin", 2L), 7L)).isNull();
assertThat(dataReadScope.readCompanyId(user(5L, "admin", 2L), null)).isNull();
}
// ---- 第三道门 readCompanyIdOrOwn:归属物化列、且可见集不靠账号/分组的表(商品类目)----
// 与第二道门只差非超管那一支,而那一支正是 10-06 逐节点复验抓到的洞:biz_product_category 连账号列
// 都没有,非超管返回 null=把整棵树交给每一家(实测公司 2 的 admin 读到 412 行、其中 394 行是公司 1
// 的自建类目)。这三条若不写,把 `requireCompanyId` 改回 `return null` 不会让任何现有用例变红。
@Test
@DisplayName("第三道门:超管仍按 tab 走(tab 是视图开关,不是安全边界)")
@DisplayName("第二道门:超管仍按 tab 走(tab 是视图开关,不是安全边界)")
void readOwnDoorForSuperAdminFollowsTheTab() {
assertThat(dataReadScope.readCompanyIdOrOwn(user(1L, "super_admin", 1L), 2L)).isEqualTo(2L);
assertThat(dataReadScope.readCompanyIdOrOwn(user(1L, "super_admin", 1L), null)).isNull();
@@ -163,18 +143,18 @@ class DataReadScopeTest {
}
@Test
@DisplayName("第三道门:非超管钉本公司,带别家的 tab 也不越权、也不返回空")
@DisplayName("第二道门:非超管钉本公司,带别家的 tab 也不越权、也不返回空")
void readOwnDoorPinsNonSuperAdminToItsOwnCompany() {
when(companyScope.requireCompanyId(any(AdminUserEntity.class))).thenReturn(2L);
assertThat(dataReadScope.readCompanyIdOrOwn(user(5L, "admin", 2L), 2L)).isEqualTo(2L);
// 传 7(别家)必须还是 2:类目树没有"空树"这个可用视图,返回空集等于把那一家自己的自建项也删掉。
// 传 7(别家)必须还是 2:这类表没有"空视图"这个可用状态,返回空集等于把那一家自己的数据也删掉。
assertThat(dataReadScope.readCompanyIdOrOwn(user(5L, "admin", 2L), 7L)).isEqualTo(2L);
assertThat(dataReadScope.readCompanyIdOrOwn(user(5L, "admin", 2L), null)).isEqualTo(2L);
}
/** 「公司超级管理员」在这三道门里都按非超管处理——它不是 super_admin,这一支若漂了就是整家公司越权。 */
/** 「公司超级管理员」在这两道门里都按非超管处理——它不是 super_admin,这一支若漂了就是整家公司越权。 */
@Test
@DisplayName("第三道门:company_super_admin 按非超管钉本公司,不当站点超管")
@DisplayName("第二道门:company_super_admin 按非超管钉本公司,不当站点超管")
void readOwnDoorTreatsCompanySuperAdminAsNonSuperAdmin() {
when(companyScope.requireCompanyId(any(AdminUserEntity.class))).thenReturn(2L);
assertThat(dataReadScope.readCompanyIdOrOwn(user(9L, "company_super_admin", 2L), null)).isEqualTo(2L);