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:
+298
-128
@@ -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 逼出来的形状),
|
||||
|
||||
+18
-38
@@ -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);
|
||||
|
||||
+45
-7
@@ -326,18 +326,56 @@ class CompanyScopeMigrationV145Test {
|
||||
}
|
||||
|
||||
/**
|
||||
* 破坏点:头注释喊了哨兵,哨兵却没探这两列 ⇒ "有人盯着摘 DEFAULT"这件事是假的。
|
||||
* 破坏点:头注释喊了哨兵,哨兵却没探这一列 ⇒ "有人盯着摘 DEFAULT"这件事是假的。
|
||||
* 这条把文档承诺与代码实现对齐(§10 护栏 1 的可执行部分)。
|
||||
*
|
||||
* <p>2026-10-06 口径变更后,本用例的"对齐对象"从 V145 的头注释移到了 V151 的头注释——
|
||||
* 那一笔才是现在的说法。两张表在这里分道:{@code biz_dedupe_total_data} 仍每公司一套,
|
||||
* DEFAULT 的倒计时还在;{@code biz_invalid_asin_data} 随「全平台共享」定案<b>退出</b>哨兵清单,
|
||||
* 它的 DEFAULT 从"待摘"翻转成 {@code NOT NULL} 的承重约束(新 jar 的 INSERT 不带这一列,
|
||||
* 靠默认值填)。所以这一支既要钉它真的不在了,也要钉"不在"这件事在版本化的迁移注释里有据可查——
|
||||
* 否则下一个人会照本文件头注释的旧承诺去执行 {@code DROP DEFAULT},把每次写入变成 1364。</p>
|
||||
*/
|
||||
@Test
|
||||
void startupSentinelActuallyWatchesTheTwoNewColumns() throws IOException {
|
||||
Path guard = ROOT.resolve("src/main/java/com/nanri/aiimage/modules/company/service/CompanyDefaultGuard.java");
|
||||
assertTrue(Files.isRegularFile(guard), "启动期 DEFAULT 哨兵应存在:" + guard);
|
||||
String text = raw(guard);
|
||||
void startupSentinelStillWatchesDedupeAndV151RecordsWhyTheSharedOneLeft() throws IOException {
|
||||
Path guardFile = ROOT.resolve("src/main/java/com/nanri/aiimage/modules/company/service/CompanyDefaultGuard.java");
|
||||
assertTrue(Files.isRegularFile(guardFile), "启动期 DEFAULT 哨兵应存在:" + guardFile);
|
||||
String text = raw(guardFile);
|
||||
assertTrue(text.contains("COMPANY_DEFAULT_STILL_PRESENT"), "哨兵标记串必须保持 ASCII 原样(巡检按它 grep docker logs)");
|
||||
assertTrue(text.contains("'" + INVALID + "'"), "哨兵要探品牌库的 company_id,否则 V145 的 DEFAULT 没人盯");
|
||||
assertTrue(text.contains("'" + DEDUPE + "'"), "哨兵要探去重库的 company_id");
|
||||
assertTrue(text.contains("COLUMN_DEFAULT"), "哨兵应真的读列元数据,而不是靠猜");
|
||||
|
||||
List<String> watched = probeTables(text);
|
||||
assertTrue(watched.contains(DEDUPE), "去重库仍按公司:它的 DEFAULT 必须还有人盯");
|
||||
assertFalse(watched.contains(INVALID),
|
||||
"品牌库已按「全平台共享」退出哨兵清单,哨兵不该再对它喊 DROP DEFAULT");
|
||||
|
||||
String sharedKeyMigration = raw(sharedKeyMigrationFile());
|
||||
assertTrue(sharedKeyMigration.contains(INVALID),
|
||||
"V151 的头注释要点名品牌库(它就是为这两张表退键而存在的)");
|
||||
assertTrue(sharedKeyMigration.contains("1364") && sharedKeyMigration.contains("DROP DEFAULT"),
|
||||
"退出哨兵的理由必须写在换键那一笔里:不写清 1364,"
|
||||
+ "本文件头注释那条旧承诺就会让人去摘一个现在摘不得的默认值");
|
||||
}
|
||||
|
||||
/** 取哨兵探针 SQL 的 {@code TABLE_NAME IN ('a', 'b')} 段;只认这一段,别把 {@code 'company_id'} 也算进来。 */
|
||||
private static List<String> probeTables(String guardSource) {
|
||||
Matcher inList = Pattern.compile("TABLE_NAME\\s+IN\\s*\\(([^)]*)\\)").matcher(guardSource);
|
||||
assertTrue(inList.find(), "哨兵源码里没有 TABLE_NAME IN (…) 这一段,取不到清单");
|
||||
List<String> tables = new ArrayList<>();
|
||||
Matcher quoted = Pattern.compile("'([^']+)'").matcher(inList.group(1));
|
||||
while (quoted.find()) {
|
||||
tables.add(quoted.group(1));
|
||||
}
|
||||
assertFalse(tables.isEmpty(), "IN 列表解析出 0 张表 ⇒ contains/assertFalse 两条都会恒真或恒假");
|
||||
return tables;
|
||||
}
|
||||
|
||||
private static Path sharedKeyMigrationFile() throws IOException {
|
||||
List<Path> hits = versionFiles().stream()
|
||||
.filter(p -> p.getFileName().toString().startsWith("V151__"))
|
||||
.toList();
|
||||
assertEquals(1, hits.size(), "V151(两张共享表退回全局唯一键)应存在且只有一个:" + hits);
|
||||
return hits.get(0);
|
||||
}
|
||||
|
||||
/** 破坏点:盘点文档没跟着改,下一个人按"取号起点"取号就撞号。 */
|
||||
|
||||
+553
@@ -0,0 +1,553 @@
|
||||
package com.nanri.aiimage.config;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.nio.file.Files;
|
||||
import java.nio.file.Path;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.regex.Matcher;
|
||||
import java.util.regex.Pattern;
|
||||
import java.util.stream.Stream;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertFalse;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
/**
|
||||
* V149({@code columns} 从"全平台一棵菜单字典"改成"每家公司一套树")的文件审计。
|
||||
* 设计:crawler-plugin/docs/ops/menu-company-tree-design-2026-10-06.md;
|
||||
* 定案三条:D1 同笔迁移重指存量授权、D2 站点超管可带 company_id、D3 不复制 admin_companies。
|
||||
*
|
||||
* <p>本仓 pom 无 H2、无 testcontainers,迁移跑不起来,所以文件审计是唯一能守住的层——
|
||||
* 与 {@link CompanyScopeMigrationV145Test} / {@link ProductCategoryMigrationV147Test} 同口径:
|
||||
* 断言打在剥掉注释后的可执行 SQL 上,注释里的内容另用 {@link #rawMigration()} 单独钉。</p>
|
||||
*
|
||||
* <p>这一版和 V145/V147 最大的不同:它不是"加一列",而是<b>加列 + 换键 + 复制 + 重指授权</b>四件事
|
||||
* 同批。只做前三件,第 2 家的账号一上线就掉光菜单(隐藏=静默删除);只做加列,
|
||||
* {@code findDataPermission} 这类"按 column_key 点查 + LIMIT 1"会在同名多行里借位拿到别家的行。
|
||||
* 所以下面每条破坏点都在问"这四件是不是真的都做完了、而且顺序对"。</p>
|
||||
*/
|
||||
class MenuTreeCompanyMigrationV149Test {
|
||||
|
||||
private static final Path ROOT = Path.of(System.getProperty("user.dir"));
|
||||
private static final Path DB_DIR = ROOT.resolve("src/main/resources/db");
|
||||
private static final String COLUMNS = "columns";
|
||||
private static final String GRANTS = "user_column_permission";
|
||||
/** 角色内在闸门那一行:设计定案 D3——唯一不复制的菜单。 */
|
||||
private static final String GATE_KEY = "admin_companies";
|
||||
|
||||
// ---------------------------------------------------------------- 取文件
|
||||
|
||||
private static List<Path> versionFiles() throws IOException {
|
||||
try (Stream<Path> s = Files.list(DB_DIR)) {
|
||||
return s.filter(p -> p.getFileName().toString().matches("^V\\d+(?:_\\d+)?__.*\\.sql$"))
|
||||
.sorted()
|
||||
.toList();
|
||||
}
|
||||
}
|
||||
|
||||
private static int versionOf(Path p) {
|
||||
Matcher m = Pattern.compile("^V(\\d+)(?:_\\d+)?__").matcher(p.getFileName().toString());
|
||||
return m.find() ? Integer.parseInt(m.group(1)) : -1;
|
||||
}
|
||||
|
||||
private static Path migration() throws IOException {
|
||||
List<Path> hits = versionFiles().stream()
|
||||
.filter(p -> p.getFileName().toString().startsWith("V149__"))
|
||||
.toList();
|
||||
assertFalse(hits.isEmpty(), "缺少 V149__*.sql:菜单树还没按公司分棵");
|
||||
assertEquals(1, hits.size(), "V149 只允许一个迁移文件(撞号会让两台 java 同时起不来)");
|
||||
return hits.get(0);
|
||||
}
|
||||
|
||||
private static String raw(Path file) throws IOException {
|
||||
return Files.readString(file, StandardCharsets.UTF_8);
|
||||
}
|
||||
|
||||
private static String rawMigration() throws IOException {
|
||||
return raw(migration());
|
||||
}
|
||||
|
||||
private static String statements() throws IOException {
|
||||
return normalize(stripComments(rawMigration()));
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------ SQL 预处理
|
||||
// 与 CompanyScopeMigrationV145Test 逐字同实现:注释里的 -- 与字符串里的 -- 是两件事,
|
||||
// 另写一版简化实现会让断言打在残缺 SQL 上。
|
||||
|
||||
private static String stripComments(String sql) {
|
||||
StringBuilder out = new StringBuilder(sql.length());
|
||||
int i = 0;
|
||||
while (i < sql.length()) {
|
||||
char c = sql.charAt(i);
|
||||
if (c == '\'') {
|
||||
int end = i + 1;
|
||||
while (end < sql.length()) {
|
||||
if (sql.charAt(end) == '\'') {
|
||||
if (end + 1 < sql.length() && sql.charAt(end + 1) == '\'') {
|
||||
end += 2;
|
||||
continue;
|
||||
}
|
||||
break;
|
||||
}
|
||||
end++;
|
||||
}
|
||||
out.append(sql, i, Math.min(end + 1, sql.length()));
|
||||
i = end + 1;
|
||||
continue;
|
||||
}
|
||||
if (c == '-' && i + 1 < sql.length() && sql.charAt(i + 1) == '-') {
|
||||
while (i < sql.length() && sql.charAt(i) != '\n') {
|
||||
i++;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
if (c == '/' && i + 1 < sql.length() && sql.charAt(i + 1) == '*') {
|
||||
int end = sql.indexOf("*/", i + 2);
|
||||
i = end < 0 ? sql.length() : end + 2;
|
||||
continue;
|
||||
}
|
||||
out.append(c);
|
||||
i++;
|
||||
}
|
||||
return out.toString();
|
||||
}
|
||||
|
||||
private static String normalize(String sql) {
|
||||
return sql.replaceAll("\\s+", " ").trim();
|
||||
}
|
||||
|
||||
private static long count(String haystack, String needle) {
|
||||
long n = 0;
|
||||
int i = haystack.indexOf(needle);
|
||||
while (i >= 0) {
|
||||
n++;
|
||||
i = haystack.indexOf(needle, i + needle.length());
|
||||
}
|
||||
return n;
|
||||
}
|
||||
|
||||
/** 抽出所有形如 {@code ALTER TABLE `x`} 的表名,用于"只动这几张表"的判据。 */
|
||||
private static List<String> alteredTables(String sql) {
|
||||
List<String> hits = new ArrayList<>();
|
||||
Matcher m = Pattern.compile("ALTER TABLE `([a-z_]+)`").matcher(sql);
|
||||
while (m.find()) {
|
||||
hits.add(m.group(1));
|
||||
}
|
||||
return hits;
|
||||
}
|
||||
|
||||
/**
|
||||
* 把旁路种子类的源切成"一条种子语句 = 一段":每个 {@code executeQuietly(} /
|
||||
* {@code executeUpdateQuietly(} 的起点到下一个标记的起点。
|
||||
* 只在<b>注释已剥、空白已归一</b>的源上切,所以类注释里那句"裸 {@code WHERE column_key = ...}"
|
||||
* 不会被当成一条种子喂给判据。
|
||||
*/
|
||||
private static List<String> seedStatements(String normalizedSource) {
|
||||
Matcher m = Pattern.compile("execute(?:Update)?Quietly\\(").matcher(normalizedSource);
|
||||
List<Integer> starts = new ArrayList<>();
|
||||
List<Integer> bodies = new ArrayList<>();
|
||||
while (m.find()) {
|
||||
starts.add(m.start());
|
||||
bodies.add(m.end());
|
||||
}
|
||||
List<String> regions = new ArrayList<>();
|
||||
for (int i = 0; i < bodies.size(); i++) {
|
||||
int to = i + 1 < starts.size() ? starts.get(i + 1) : normalizedSource.length();
|
||||
regions.add(normalizedSource.substring(bodies.get(i), to));
|
||||
}
|
||||
return regions;
|
||||
}
|
||||
|
||||
/**
|
||||
* 一把尺子:一段种子语句里凡按 {@code column_key} 认菜单的(写比较的,不是列清单里那个列名),
|
||||
* 就必须在同一段里钉住 {@code company_id}。返回"按 key 认菜单却没钉公司"的那些段。
|
||||
*/
|
||||
private static List<String> keyLookupsWithoutCompany(List<String> regions) {
|
||||
List<String> offenders = new ArrayList<>();
|
||||
for (String region : regions) {
|
||||
if (region.contains("column_key =") && !region.contains("company_id")) {
|
||||
offenders.add(region);
|
||||
}
|
||||
}
|
||||
return offenders;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------ 用例
|
||||
|
||||
/** 破坏点:取到已应用的号(原地改=两台都起不来),或者根本没落盘。 */
|
||||
@Test
|
||||
void migrationIsVersionedOneFourNine() throws IOException {
|
||||
Path file = migration();
|
||||
assertEquals(149, versionOf(file), "本迁移必须是 V149");
|
||||
assertTrue(file.getFileName().toString().matches("^V149__[A-Za-z0-9_.-]+\\.sql$"),
|
||||
"命名应 V149__<snake 描述>.sql:" + file.getFileName());
|
||||
}
|
||||
|
||||
/**
|
||||
* 破坏点:三段式少任何一段。少回填 ⇒ 第 3 段的 MODIFY 把存量行撞成 1048;
|
||||
* 少 MODIFY ⇒ 列可空,"没有归属的行"在任何公司的树上都不出现,而按 key 点查会判成"这个菜单不存在"。
|
||||
* 加列必须走<b>末位</b>(不许出现 {@code AFTER}):非末位加列能不能 INSTANT 取决于生产 MySQL 小版本,
|
||||
* 押错了是发版窗口第 1 段直接 1846,而这一列的位置没有任何语义。
|
||||
*/
|
||||
@Test
|
||||
void companyColumnIsAppendedBackfilledThenTightened() throws IOException {
|
||||
String sql = statements();
|
||||
assertTrue(sql.contains("ALTER TABLE `columns` ADD COLUMN `company_id` bigint NULL COMMENT"),
|
||||
"第 1 段应先加成可空:" + sql);
|
||||
assertEquals(1, count(sql, "ALGORITHM = INSTANT"), "只有加列这一条走 INSTANT");
|
||||
assertEquals(0, count(sql, " AFTER "), "末位加列才配得上 ALGORITHM = INSTANT,不许写 AFTER");
|
||||
assertTrue(sql.contains("UPDATE `columns` SET `company_id` = 1 WHERE `company_id` IS NULL;"),
|
||||
"存量归第 1 家必须带 IS NULL 限定(重跑才是 no-op,也不覆盖人工指定过的行)");
|
||||
assertTrue(sql.contains("ALTER TABLE `columns` MODIFY COLUMN `company_id` bigint NOT NULL DEFAULT 1"),
|
||||
"第 3 段收成 NOT NULL DEFAULT 1,它同时是回填没跑全的自检闸门(1048)");
|
||||
assertEquals(1, count(sql, "MODIFY COLUMN `company_id`"), "MODIFY 只许出现在建列定形状这一处");
|
||||
}
|
||||
|
||||
/**
|
||||
* 破坏点:新键没把 company_id 放第一位,或旧键还在。
|
||||
* 旧键 {@code uk_column_key} 不摘,第 2 家公司连"和别家同名"的菜单都建不出来——
|
||||
* 那不是看不到,是建不出,整套改造白做;而先 DROP 后 ADD 的写法会让中间态裸奔,
|
||||
* 且复制段直接撞旧键的全局唯一(1062)。
|
||||
*/
|
||||
@Test
|
||||
void uniqueKeysAreReplacedNotLayeredAndInThatOrder() throws IOException {
|
||||
String sql = statements();
|
||||
assertTrue(sql.contains("ADD UNIQUE KEY `uk_company_column_key` (`company_id`, `column_key`)"), sql);
|
||||
assertTrue(sql.contains("ADD UNIQUE KEY `uk_company_menu_type_route_path` (`company_id`, `menu_type`, `route_path`)"), sql);
|
||||
assertTrue(sql.contains("DROP INDEX `uk_column_key`"), "旧的全局键必须摘,否则第二棵树建不出来");
|
||||
assertTrue(sql.contains("DROP INDEX `uk_menu_type_route_path`"), "路径的全局键同理");
|
||||
assertTrue(sql.indexOf("ADD UNIQUE KEY `uk_company_column_key`") < sql.indexOf("DROP INDEX `uk_column_key`"),
|
||||
"顺序必须是先 ADD 后 DROP:中间任一步失败都还剩一个唯一键在守并发");
|
||||
assertTrue(sql.indexOf("ADD UNIQUE KEY `uk_company_menu_type_route_path`") < sql.indexOf("DROP INDEX `uk_menu_type_route_path`"));
|
||||
// 复制段(第 6 段)排在两条旧键摘掉之后,否则它撞的就是旧键。
|
||||
assertTrue(sql.indexOf("DROP INDEX `uk_column_key`") < sql.indexOf("INSERT INTO `columns`"),
|
||||
"换键必须早于复制段");
|
||||
assertEquals(4, count(sql, "ALGORITHM = INPLACE, LOCK = NONE"),
|
||||
"四条索引操作都要钉 INPLACE+LOCK=NONE,否则 MySQL 可以选 COPY 锁写");
|
||||
}
|
||||
|
||||
/**
|
||||
* 破坏点:驱动集硬编码"公司 2"。第三家开通时就得再发一版迁移。
|
||||
* 破坏点 2:把 {@code admin_companies} 也复制了——它是角色内在闸门(Java 的 SUPER_ADMIN_ONLY_KEYS
|
||||
* 与前端 SUPER_ADMIN_ONLY_MENU_KEYS 同值),别家树里有这一行只会多一个"谁也授不出去"的摆设。
|
||||
*/
|
||||
@Test
|
||||
void copyIsDrivenByTheCompanyTableAndSkipsTheRoleIntrinsicGate() throws IOException {
|
||||
String sql = statements();
|
||||
assertTrue(sql.contains("FROM `company` co"), "复制段的驱动集应是 company 全表,不是写死一个公司 id");
|
||||
assertTrue(sql.contains("JOIN `columns` src ON src.company_id = 1"), "源树固定取公司 1");
|
||||
assertTrue(sql.contains("WHERE co.id <> 1"), "对【所有】非 1 的公司做(含 status=0,少一家树就少一次启用检查)");
|
||||
assertTrue(sql.contains("AND src.column_key <> 'admin_companies'"),
|
||||
"定案 D3:admin_companies 不复制");
|
||||
assertTrue(sql.contains("AND NOT EXISTS ("), "复制段必须幂等(repair 重跑不插第二份)");
|
||||
assertEquals(1, count(sql, "INSERT INTO `columns`"), "本迁移只有一条插菜单行的语句");
|
||||
}
|
||||
|
||||
/**
|
||||
* 破坏点:副本照抄源行的 parent_id。那是全局 id,会把别家的子页面挂到厦门米椿花的分组下——
|
||||
* 而 {@code fk_columns_parent_id} 只保证父行【存在】,挡不住跨公司挂父,库侧不会喊。
|
||||
* 所以插入时父必须留 NULL,再按 (company_id, column_key) 认父。
|
||||
*/
|
||||
@Test
|
||||
void copiesReparentByColumnKeyNeverById() throws IOException {
|
||||
String sql = statements();
|
||||
assertTrue(sql.contains("SELECT co.id, src.name, src.column_key, src.menu_type, src.route_path, src.sort_order, NULL, src.created_at"),
|
||||
"插入段的 parent 位置必须是字面 NULL:" + sql);
|
||||
assertTrue(sql.contains("JOIN `columns` pcopy ON pcopy.company_id = copy.company_id AND pcopy.column_key = sp.column_key"),
|
||||
"认父要沿 (company_id, column_key) 走");
|
||||
assertTrue(sql.contains("SET copy.parent_id = pcopy.id"));
|
||||
assertTrue(sql.contains("AND copy.parent_id IS NULL"), "重跑时已认过父的行不再改动");
|
||||
assertEquals(1, count(sql, "SET copy.parent_id"), "认父只有一条语句");
|
||||
}
|
||||
|
||||
/**
|
||||
* 破坏点:第 8 段(去重)没跑就先重指。同一账号若同时挂着源行与副本,重指会撞
|
||||
* {@code (user_id, column_id)} 主键报 1062 —— 而这条只在 repair 重跑那种中途态才可能出现,
|
||||
* 所以它必须写在重指之前,而不是"反正今天 0 行"。
|
||||
*/
|
||||
@Test
|
||||
void duplicateGrantsArePrunedBeforeTheRepoint() throws IOException {
|
||||
String sql = statements();
|
||||
assertTrue(sql.contains("DELETE dup FROM `user_column_permission` dup"), "缺第 8 段的重指在重跑时会撞 1062");
|
||||
assertTrue(sql.indexOf("DELETE dup FROM") < sql.indexOf("UPDATE `user_column_permission` g"),
|
||||
"去重必须排在重指之前");
|
||||
assertEquals(1, count(sql, "DELETE dup FROM"), "去重只删副本那一侧,且只此一处");
|
||||
}
|
||||
|
||||
/**
|
||||
* 破坏点(定案 D1 的核心):只复制树不重指授权。存量 784 笔里公司 2 那 16 笔仍挂在
|
||||
* 公司 1 的行上,而读侧改成"只认本公司"之后,德阳的 2 只账号一上线掉光菜单——
|
||||
* 这是"隐藏=静默删除"的同一类事故,所以它必须是同笔迁移的动作而不是发布后的人工待办。
|
||||
*/
|
||||
@Test
|
||||
void existingGrantsAreRepointedToTheOwnCompanyCopy() throws IOException {
|
||||
String sql = statements();
|
||||
assertTrue(sql.contains("UPDATE `user_column_permission` g"), "第 9 段:存量授权重指向本公司副本");
|
||||
assertTrue(sql.contains("JOIN `columns` copy ON copy.company_id = u.company_id AND copy.column_key = src.column_key"),
|
||||
"认行按 column_key,不按 id 猜");
|
||||
assertTrue(sql.contains("SET g.column_id = copy.id"));
|
||||
assertTrue(sql.contains("WHERE u.company_id <> 1"),
|
||||
"驱动条件限定在\"不属于公司 1\",重跑时这一行都选不出来=no-op");
|
||||
assertEquals(1, count(sql, "SET g.column_id"), "改授权指针只有一条语句");
|
||||
}
|
||||
|
||||
/**
|
||||
* 破坏点:残留没让它响。四道闸门(临时表 must_be_zero NOT NULL,V143 那个"让约束替我喊"的家族)
|
||||
* 缺任何一道,对应的失效形状都是"树少一棵 / 父挂错家 / 授权挂别家 / 冒出无归属行"——
|
||||
* 四条全都不报错,只是某家公司侧边栏空白或按 key 点查判成"菜单不存在"。
|
||||
*/
|
||||
@Test
|
||||
void fourGatesFailTheMigrationOnAnyResidual() throws IOException {
|
||||
String sql = statements();
|
||||
assertTrue(sql.contains("CREATE TEMPORARY TABLE IF NOT EXISTS `_v149_gate` (`must_be_zero` INT NOT NULL)"),
|
||||
"闸门表必须是 NOT NULL 的一列——插 NULL 才抛 1048");
|
||||
assertEquals(4, count(sql, "INSERT INTO `_v149_gate`"), "四道闸门:齐套性/跨公司父/跨公司授权/无归属行");
|
||||
assertEquals(4, count(sql, "SELECT IF(COUNT(*) = 0, 0, NULL)"),
|
||||
"每道都必须是\"计数为 0 才插得进去\"的形状,写成了 SELECT 就永远不为 0");
|
||||
assertEquals(1, count(sql, "DROP TEMPORARY TABLE `_v149_gate`"), "闸门表用完要删");
|
||||
// 逐道点名,防"四道其实都探同一件事"
|
||||
assertTrue(sql.contains("LEFT JOIN `columns` cp ON cp.company_id = co.id AND cp.column_key = src.column_key"),
|
||||
"闸门 1 要按公司逐行核对齐套");
|
||||
assertTrue(sql.contains("WHERE c.company_id <> p.company_id"), "闸门 2 探跨公司父");
|
||||
assertTrue(sql.contains("WHERE c.company_id <> u.company_id"), "闸门 3 探跨公司授权");
|
||||
assertTrue(sql.contains("WHERE `company_id` IS NULL OR `company_id` <= 0"), "闸门 4 探无归属行");
|
||||
}
|
||||
|
||||
/**
|
||||
* 破坏点:写成裸 ALTER(不可重跑)。MySQL 的 DDL 不进事务,repair + 重启会从第一条语句重跑整个文件,
|
||||
* 裸 ALTER 在恢复路径上必撞 1060/1050。
|
||||
* 计数由本轮扫描得出、不自挑:五条条件 DDL(1 加列 + 2 加键 + 2 摘键)各配一份元数据判断与 PREPARE;
|
||||
* 唯一不守卫的那条是 MODIFY——它在已 NOT NULL 的列上重跑不报错,属于天生幂等。
|
||||
*/
|
||||
@Test
|
||||
void everyConditionalDdlIsGuardedByInformationSchema() throws IOException {
|
||||
String sql = statements();
|
||||
long alters = count(sql, "ALTER TABLE");
|
||||
assertEquals(6, alters, "本迁移应有 6 条 ALTER(5 条件 + 1 条 MODIFY),实际 " + alters);
|
||||
assertEquals(alters - 1, count(sql, "PREPARE stmt FROM @sql"), "五条条件 DDL 都要走 PREPARE");
|
||||
assertEquals(alters - 1, count(sql, "DEALLOCATE PREPARE stmt"), "PREPARE 名复用前必须 DEALLOCATE");
|
||||
assertEquals(alters - 1, count(sql, "information_schema"), "每条条件 DDL 各自要一次元数据存在性判断");
|
||||
assertEquals(1, count(sql, "MODIFY COLUMN"), "不守卫的那一条只能是 MODIFY");
|
||||
}
|
||||
|
||||
/** 破坏点:顺手改了 users / company,或建了持久表(菜单树的归属改造只该动这两张表)。 */
|
||||
@Test
|
||||
void touchesOnlyTheMenuCatalogAndItsGrants() throws IOException {
|
||||
String sql = statements();
|
||||
assertTrue(alteredTables(sql).stream().allMatch(COLUMNS::equals),
|
||||
"所有 ALTER 都只能打在 columns 上,实际动到了 " + alteredTables(sql));
|
||||
assertFalse(sql.contains("ALTER TABLE `users`"), "users.company_id 归 V143/V144 管,本迁移只读它");
|
||||
assertFalse(sql.contains("ALTER TABLE `company`"), "company 表结构不动");
|
||||
assertFalse(sql.replace("CREATE TEMPORARY TABLE", "").contains("CREATE TABLE"),
|
||||
"除闸门临时表外不建持久表");
|
||||
assertTrue(sql.contains("UPDATE `user_column_permission`"), "授权重指是本迁移的第二张写表");
|
||||
assertEquals(0, count(sql, "DELETE FROM `users`"), "绝不删账号");
|
||||
}
|
||||
|
||||
/** 破坏点:影响面是估的、DEFAULT 的倒计时没人接。锁表结论与摘 DEFAULT 的时点都只有配上实查数才站得住。 */
|
||||
@Test
|
||||
void headerCarriesMeasuredVolumesAndTheDefaultCountdown() throws IOException {
|
||||
String raw = rawMigration();
|
||||
assertTrue(raw.contains("52 行"), "columns 行数必须是生产实查值");
|
||||
assertTrue(raw.contains("784") && raw.contains("133"), "授权笔数/账号数必须是生产实查值(重指段的分母)");
|
||||
assertTrue(raw.contains("admin_companies"), "头注释要写明那一行不复制的理由,否则后人以为漏了");
|
||||
assertTrue(raw.contains("1048"), "MODIFY 兼作回填自检闸门这件事要写进注释");
|
||||
assertTrue(raw.contains("1364"), "DEFAULT 1 是为同批旧 jar 存在(旧实体没这列,insert 整列跳过会报它)");
|
||||
assertTrue(raw.contains("COMPANY_DEFAULT_STILL_PRESENT"),
|
||||
"摘 DEFAULT 的倒计时由启动期哨兵喊,头注释要点名那条 ASCII 签名");
|
||||
assertTrue(raw.contains("ALTER COLUMN company_id DROP DEFAULT"),
|
||||
"要给出摘除的安全写法(纯元数据),否则后人会照 V143 用 MODIFY 重建表");
|
||||
assertTrue(raw.contains("禁写成 MODIFY"), "下一版摘 DEFAULT 禁 MODIFY 这条要写在文件里");
|
||||
assertTrue(raw.contains("从第一条语句重跑整个文件"), "可重跑性是恢复路径的前提,注释要写明");
|
||||
}
|
||||
|
||||
/** 破坏点:验证段没核对"各家齐不齐"和"授权还挂不挂在别家"。这两条是上线当晚唯一能证伪的读数。 */
|
||||
@Test
|
||||
void shipsPostDeployVerificationSql() throws IOException {
|
||||
String raw = rawMigration();
|
||||
assertTrue(raw.contains("SELECT company_id, menu_type, COUNT(*) FROM columns GROUP BY company_id, menu_type"),
|
||||
"验证 SQL 要按公司×类型数行数");
|
||||
assertTrue(raw.contains("WHERE c.company_id <> u.company_id"), "验证 SQL 要复验跨公司授权残留");
|
||||
assertTrue(raw.contains("information_schema.STATISTICS"), "验证 SQL 要复验两条旧键已摘、两条新键在");
|
||||
}
|
||||
|
||||
/**
|
||||
* 破坏点:回滚被编成版本化迁移(Flyway 扫描路径里的 V*.sql 会在下次启动自动执行),
|
||||
* 或者回滚把"删副本"排在"重指授权"之前。
|
||||
*
|
||||
* <p>后者是这一版独有的陷阱:{@code user_column_permission} 的外键是 ON DELETE CASCADE,
|
||||
* 先删副本会把它名下授权一起删光——而 V149 之后账号名下"本来就该"挂的是副本行。
|
||||
* 写反的读数不是报错,是 133 只账号的菜单被清空。</p>
|
||||
*/
|
||||
@Test
|
||||
void rollbackRepointsGrantsBeforeDeletingTheCopiesAndStaysUnversioned() throws IOException {
|
||||
Pattern writesHistoryTable = Pattern.compile(
|
||||
"\\b(DELETE|UPDATE|INSERT|TRUNCATE|ALTER|DROP)\\b[^;]*\\bflyway_schema_history\\b",
|
||||
Pattern.CASE_INSENSITIVE);
|
||||
for (Path file : versionFiles()) {
|
||||
String executable = normalize(stripComments(raw(file)));
|
||||
assertFalse(writesHistoryTable.matcher(executable).find(),
|
||||
"回滚不许编成版本化迁移:" + file.getFileName() + " 的执行段写了 flyway_schema_history");
|
||||
}
|
||||
Path rollback = ROOT.resolve("docs/rollback-V149-permission-menu-company.sql");
|
||||
assertTrue(Files.isRegularFile(rollback), "回滚人工补丁必须存在:" + rollback);
|
||||
String whole = raw(rollback);
|
||||
assertTrue(whole.contains("flyway_schema_history"), "回滚必须删本版本历史行(漏掉=重装时 Flyway 跳过 V149)");
|
||||
String executable = normalize(stripComments(whole));
|
||||
assertTrue(executable.contains("SET g.column_id = src.id"), "回滚要先把授权指针挪回公司 1 的源行");
|
||||
assertTrue(executable.contains("DELETE FROM `columns` WHERE company_id <> 1"), "再删副本");
|
||||
assertTrue(executable.indexOf("SET g.column_id = src.id") < executable.indexOf("DELETE FROM `columns`"),
|
||||
"顺序不能反:FK 是 ON DELETE CASCADE,先删副本等于清空 133 只账号的菜单");
|
||||
assertTrue(whole.contains("ON DELETE CASCADE"), "注释要写明为什么这个顺序是陷阱");
|
||||
assertTrue(executable.contains("ADD UNIQUE KEY `uk_column_key` (`column_key`)"), "回滚要把两条全平台旧键加回来");
|
||||
assertTrue(executable.contains("ADD UNIQUE KEY `uk_menu_type_route_path` (`menu_type`, `route_path`)"));
|
||||
assertTrue(executable.contains("DROP INDEX `uk_company_column_key`"), "并摘掉两条按公司的新键");
|
||||
assertTrue(executable.contains("DROP INDEX `uk_company_menu_type_route_path`"));
|
||||
assertTrue(executable.indexOf("ADD UNIQUE KEY `uk_column_key`") < executable.indexOf("DROP INDEX `uk_company_column_key`"),
|
||||
"回滚同样是先 ADD 后 DROP:中间态必须还剩一个唯一键");
|
||||
assertTrue(executable.contains("CREATE TEMPORARY TABLE `_v149_rb_gate`"),
|
||||
"重指与删除之间要有闸门:漏一行就会被 CASCADE 静默吞掉");
|
||||
assertTrue(executable.contains("CREATE TABLE IF NOT EXISTS `columns_bak_v149_rollback`"),
|
||||
"删副本前必须整表留底");
|
||||
}
|
||||
|
||||
/**
|
||||
* 破坏点:头注释喊了哨兵,哨兵却没探这一列 ⇒ "有人盯着摘 DEFAULT"这件事是假的。
|
||||
* 这条把文档承诺与代码实现对齐(V145 同类用例的同口径)。
|
||||
*/
|
||||
@Test
|
||||
void startupSentinelActuallyWatchesTheMenuColumn() throws IOException {
|
||||
Path guard = ROOT.resolve("src/main/java/com/nanri/aiimage/modules/company/service/CompanyDefaultGuard.java");
|
||||
assertTrue(Files.isRegularFile(guard), "启动期 DEFAULT 哨兵应存在:" + guard);
|
||||
String text = raw(guard);
|
||||
assertTrue(text.contains("COMPANY_DEFAULT_STILL_PRESENT"), "哨兵标记串必须保持 ASCII 原样(巡检按它 grep docker logs)");
|
||||
assertTrue(text.contains("\"columns\""), "哨兵要探 columns.company_id,否则 V149 的 DEFAULT 没人盯");
|
||||
assertTrue(text.contains("'columns'"), "探针 SQL 的 IN 列表也要含它,只进清单是假盯");
|
||||
assertTrue(text.contains("COLUMN_DEFAULT"), "哨兵应真的读列元数据,而不是靠猜");
|
||||
}
|
||||
|
||||
/**
|
||||
* 破坏点:旁路种子(启动期自建表/键的那个初始化器)还按换列之前的全局口径建键。
|
||||
* 它一旦被执行,新库就会带着 {@code uk_column_key} 起来 ⇒ 第二家公司的树建不出来,
|
||||
* 而 V149 的 DROP 只在存量库跑过——这条是"不得回流"的反向钉。
|
||||
*/
|
||||
@Test
|
||||
void schemaInitializerKeepsTheCompanyScopedKeys() throws IOException {
|
||||
Path initializer = ROOT.resolve(
|
||||
"src/main/java/com/nanri/aiimage/modules/permission/service/PermissionMenuSchemaInitializer.java");
|
||||
String text = raw(initializer);
|
||||
assertTrue(text.contains("UNIQUE KEY uk_company_column_key (company_id, column_key)"),
|
||||
"建表要直接带复合键");
|
||||
assertFalse(text.contains("ADD UNIQUE KEY uk_column_key"), "不得再建全局 column_key 键");
|
||||
assertFalse(text.contains("ADD UNIQUE KEY uk_menu_type_route_path"), "不得再建全局 (menu_type, route_path) 键");
|
||||
assertFalse(text.contains("company_id BIGINT NULL COMMENT '归属公司:每家公司一套菜单树' AFTER"),
|
||||
"加列同样是末位追加,INSTANT 不押版本");
|
||||
assertTrue(text.contains("UPDATE columns SET company_id = 1 WHERE company_id IS NULL"),
|
||||
"种子路径也要把存量收成 NOT NULL 三段式的第 2 段");
|
||||
}
|
||||
|
||||
/**
|
||||
* 破坏点:旁路种子(生产默认关,但新库/本地/那条 `permission-schema-init.enabled=true` 的通道会跑)
|
||||
* 建出来的行没钉公司。V149 之后 {@code column_key} <b>只在单家公司内唯一</b>,这条通道里一句裸
|
||||
* {@code WHERE column_key = ...} 就是"把每一家的同名行都改一遍"——别家副本的 parent 被拍平、
|
||||
* 初始授权发给别家的行 id;而 {@code executeQuietly} 把 1048/1062 吞成一行 debug 日志,
|
||||
* 表现是"某一家一声不响少一套菜单"。
|
||||
*
|
||||
* <p>另一层:这里显式写 {@code company_id} 之后,这条通道就不再依赖列上那条 {@code DEFAULT 1},
|
||||
* 于是待办里那句 {@code ALTER TABLE columns ALTER COLUMN company_id DROP DEFAULT} 落地时
|
||||
* 不会把这里的建号变成 1364。所以本用例同时钉"列清单带公司"与"投影是真常量 1"。</p>
|
||||
*
|
||||
* <p>形状与 {@code PermissionCompanyMenuHiddenTest} 同一套:先证明取样集非空、
|
||||
* 再证明这把尺子认得出已知的一条违规(否则上面的 0 命中是恒绿)。</p>
|
||||
*/
|
||||
@Test
|
||||
void schemaInitializerSeedsEveryRowIntoTheTemplateCompany() throws IOException {
|
||||
String src = normalize(stripComments(raw(ROOT.resolve(
|
||||
"src/main/java/com/nanri/aiimage/modules/permission/service/PermissionMenuSchemaInitializer.java"))));
|
||||
List<String> regions = seedStatements(src);
|
||||
List<String> keyLookups = regions.stream().filter(r -> r.contains("column_key =")).toList();
|
||||
assertTrue(regions.size() >= 25, "种子语句取样集太小,扫描器多半没切开:" + regions.size());
|
||||
assertTrue(keyLookups.size() >= 12,
|
||||
"按 column_key 认菜单的种子语句取样集太小(换键后这类语句只会更多,不会更少):" + keyLookups.size());
|
||||
|
||||
assertEquals(count(src, "INSERT INTO columns ("), count(src, "INSERT INTO columns (company_id,"),
|
||||
"每条 INSERT 的列清单都要显式带 company_id,不许再让列 DEFAULT 兜");
|
||||
assertTrue(count(src, "INSERT INTO columns (company_id,") >= 6,
|
||||
"取样集自检:这条通道本就要种 4 个分组 + 18 条菜单 + 2 条 internal,INSERT 语句不该只剩几条");
|
||||
assertEquals(count(src, "INSERT INTO columns (company_id,"), count(src, "SELECT 1, "),
|
||||
"每条种子 INSERT 的投影都必须是常量 1(模板公司):换成别的数字就是在往别家插平台默认行");
|
||||
assertEquals(1, count(src, "data_col.company_id = old_col.company_id"),
|
||||
"初始授权必须把 data_col 收在 old_col 同一家,否则老账号拿到别家的数据权限行 id");
|
||||
|
||||
assertTrue(keyLookupsWithoutCompany(regions).isEmpty(),
|
||||
"这些种子语句按 column_key 认菜单却没钉公司,等于对每一家各改一遍:" + keyLookupsWithoutCompany(regions));
|
||||
|
||||
String scoped = " ( SELECT 1, 'x', 'admin_users' FROM columns WHERE company_id = 1 AND column_key = 'admin_users' ) ";
|
||||
String bare = " ( SELECT 1, 'x', 'admin_users' FROM columns WHERE column_key = 'admin_users' ) ";
|
||||
assertEquals(List.of(bare), keyLookupsWithoutCompany(List.of(scoped, bare)),
|
||||
"尺子自检:一条没钉公司的已知违规必须被抓到,同时已钉公司的那条不许误报");
|
||||
}
|
||||
|
||||
/**
|
||||
* 破坏点:读侧或写侧编一个"没带公司就回落公司 1"的临时分支。
|
||||
* 定案是路线甲(V149 与 jar 同批双台),混合窗口里旧 jar 靠列上的 DEFAULT 兜,不需要 Java 侧兜——
|
||||
* 而 Java 侧一旦有兜底,"忘了传公司"就从 1048/403 变成静默归到第 1 家。
|
||||
*
|
||||
* <p>断言形状:先确认扫描器抓得到锚点(0 命中=尺子坏了),再要求三种兜底写法各 0 命中。</p>
|
||||
*/
|
||||
@Test
|
||||
void serviceHasNoFallbackBranchToTheDefaultCompany() throws IOException {
|
||||
String src = raw(ROOT.resolve(
|
||||
"src/main/java/com/nanri/aiimage/modules/permission/service/PermissionMenuService.java"));
|
||||
assertTrue(src.contains("resolveScopeCompanyId"), "扫描器要能命中归属判据本身,否则下面的 0 命中不作数");
|
||||
assertEquals(0, count(src, "? 1L"), "不许出现 `x == null ? 1L` 这种回落默认公司");
|
||||
assertEquals(0, Pattern.compile("\\?\\s*1L\\b").matcher(src).results().count(), "同上,容空格拉写");
|
||||
assertFalse(src.contains("COMPANY_DEFAULT"), "不许在本类里另立默认公司常量");
|
||||
}
|
||||
|
||||
/**
|
||||
* 破坏点:目录取数留下"不带公司"的重载。生产上 operator 恒有 companyId,走不到无参那条,
|
||||
* 于是"跨公司混树"这条路永远只对新代码开放——按方法名精确匹配,不接受 {@code loadMenus(} 这种含二参的宽匹配。
|
||||
*
|
||||
* <p>判据用"括号里既无逗号也无嵌套括号"来认单参调用;抓不住的形状是 {@code loadMenus(resolve(a, b))}
|
||||
* 这种把唯一实参写成调用式的写法。下面那条阳性对照(喂一条已知违规)证明这把尺子不是恒绿的。</p>
|
||||
*/
|
||||
@Test
|
||||
void menuLoadingAlwaysCarriesACompany() throws IOException {
|
||||
String src = raw(ROOT.resolve(
|
||||
"src/main/java/com/nanri/aiimage/modules/permission/service/PermissionMenuService.java"));
|
||||
for (String method : List.of("loadMenus", "loadRawMenus")) {
|
||||
Pattern singleArg = Pattern.compile(method + "\\([^(),]*\\)");
|
||||
assertEquals(1, Pattern.compile("List<PermissionMenuEntity> " + method + "\\(").matcher(src).results().count(),
|
||||
method + " 只允许一个声明");
|
||||
assertEquals(0, singleArg.matcher(src).results().count(),
|
||||
method + " 不许有单参调用/重载:每个取数点都要显式带公司");
|
||||
assertEquals(1, singleArg.matcher("List<PermissionMenuEntity> rows = " + method + "(companyId);")
|
||||
.results().count(), "尺子自检:已知的一条单参调用必须被抓到,否则上面的 0 命中不作数");
|
||||
}
|
||||
}
|
||||
|
||||
/** 破坏点:盘点文档没跟着改,下一个人按"取号起点"取号就撞号。 */
|
||||
@Test
|
||||
void inventoryDocTracksV149() throws IOException {
|
||||
String text = raw(ROOT.resolve("docs/migration-inventory.md"));
|
||||
assertTrue(text.contains(migration().getFileName().toString()), "盘点文档应记录 V149 文件名");
|
||||
assertTrue(text.contains("V152"), "盘点文档应记下新的取号起点(V150/V151 已被同批占用)");
|
||||
// 取号起点是否真等于"当前最大值 + 1"由 MigrationInventoryTest 派生判定,这里不重复钉死字面号。
|
||||
}
|
||||
|
||||
/** 自检:本用例集扫的是真文件,且 normalize 后仍能命中关键串(0 命中的断言是恒绿的)。 */
|
||||
@Test
|
||||
void scannedSignaturesAreActuallyPresent() throws IOException {
|
||||
String sql = statements();
|
||||
assertTrue(sql.length() > 1000, "剥注释后的 SQL 太短,说明预处理把内容吃掉了:" + sql.length());
|
||||
assertTrue(count(sql, "ALTER TABLE") > 0 && count(sql, "information_schema") > 0
|
||||
&& count(sql, "INSERT INTO `columns`") > 0,
|
||||
"关键签名 0 命中=预处理或文件路径坏了,本类的断言全部不可信");
|
||||
}
|
||||
}
|
||||
@@ -68,13 +68,24 @@ class MigrationInventoryTest {
|
||||
}
|
||||
|
||||
/**
|
||||
* 已在生产 flyway_schema_history 中占位、但本地文件被改名让位的版本号。
|
||||
* 生产 131 之后直接装了 134/135(2026-09-25 20:46:16),132/133 从未落库;
|
||||
* 而 Flyway 未开 out-of-order,把新迁移编号改回 132/133 会导致启动期
|
||||
* "resolved migration not applied" 失败,所以这个洞只能永久保留、不能回填。
|
||||
* 后果:新迁移只能取当前最大值之上的号(详见 docs/migration-inventory.md)。
|
||||
* 不许再被占用的整数版本洞。两条来历不同,得分开记:
|
||||
*
|
||||
* <p><b>132/133</b>:已在生产 {@code flyway_schema_history} 中占位、但本地文件被改名让位的版本号。
|
||||
* 生产 131 之后直接装了 134/135(2026-09-25 20:46:16),132/133 从未落库;而 Flyway 未开
|
||||
* out-of-order,把新迁移编号改回 132/133 会导致启动期 "resolved migration not applied" 失败,
|
||||
* 所以这个洞只能永久保留、不能回填。</p>
|
||||
*
|
||||
* <p><b>148</b>:{@code V148__product_category_builtin_owned_by_company.sql}(内置类目归还厦门米椿花)
|
||||
* 从未上线,2026-10-06 控制方点名「商品类目做成共享的,不区分」⇒ 这一版的口径被整体推翻,
|
||||
* 文件连同 {@code ProductCategoryMigrationV148Test} 与 rollback 补丁一起删掉。
|
||||
* 与 132/133 不同,把新迁移编号写回 148 在 Flyway 语义上【是】可行的(生产最大值仍是 147)——
|
||||
* 这里禁它是共树并发的护栏:那一版是另一路会话此刻正在引用的号,删掉的文件可能被再次写出,
|
||||
* 而同号两个文件会让 Flyway 启动期报 "Found more than one migration with version 148",
|
||||
* 后果是两台 java 同时起不来。宁可让本用例红,也不把撞号留到运行期发现。</p>
|
||||
*
|
||||
* <p>共同后果:新迁移只能取当前最大值之上的号(详见 docs/migration-inventory.md)。</p>
|
||||
*/
|
||||
private static final Set<Integer> RETIRED_HOLES = Set.of(132, 133);
|
||||
private static final Set<Integer> RETIRED_HOLES = Set.of(132, 133, 148);
|
||||
|
||||
@Test
|
||||
void integerVersionsSequentialFromOne() throws IOException {
|
||||
|
||||
+58
-7
@@ -6,6 +6,7 @@ import java.io.IOException;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.nio.file.Files;
|
||||
import java.nio.file.Path;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.regex.Matcher;
|
||||
import java.util.regex.Pattern;
|
||||
@@ -231,19 +232,69 @@ class ProductCategoryMigrationV147Test {
|
||||
}
|
||||
|
||||
/**
|
||||
* 破坏点:V147 的 DEFAULT 1 没进启动期哨兵清单 ⇒ "下一次记得摘"这件事没人喊,
|
||||
* 而巡检按 {@code COMPANY_DEFAULT_STILL_PRESENT} 这条 ASCII 签名 grep docker logs。
|
||||
* 破坏点(2026-10-06 起方向相反):类目表随「商品类目做成所有公司共享」的定案<b>退出</b>了启动期
|
||||
* 哨兵清单,而它现在仍带 {@code DEFAULT 1}——这一列从"待摘的风险"翻转成了 {@code NOT NULL} 的
|
||||
* 承重约束:新 jar 的 INSERT/UPDATE 列清单都不带 company_id,靠默认值填。
|
||||
*
|
||||
* <p>所以这一支钉的是"哨兵必须不再对它喊"。清单与探针 SQL 的 IN 列表<b>两侧都要钉</b>:
|
||||
* 只摘一侧会重演本类要避免的那两种静默形状——清单里还在、IN 里没有 ⇒ 每次启动报"探不到"的 WARN;
|
||||
* IN 里还在、清单里没有 ⇒ 查到了却没人判定,而 {@code CompanyDefaultGuardTest} 的双向同源钉
|
||||
* 会红在那一张"仍按公司"的表上,不会红在这里。</p>
|
||||
*
|
||||
* <p>另一半:退出这件事必须在版本化的迁移注释里有据可查。只改代码不改说法,下一个人会照
|
||||
* 本文件头注释(V147 那一版写的是"记得摘 DEFAULT")或 {@code CompanyDefaultGuard} 给出的
|
||||
* {@code DROP DEFAULT} 语句去执行,代价是每次写入 1364,而且这张表的失败会直接顶到管理员面前。</p>
|
||||
*/
|
||||
@Test
|
||||
void startupSentinelWatchesTheProductCategoryColumn() throws IOException {
|
||||
void startupSentinelHasStoppedWatchingTheProductCategoryColumn() throws IOException {
|
||||
Path guard = ROOT.resolve("src/main/java/com/nanri/aiimage/modules/company/service/CompanyDefaultGuard.java");
|
||||
assertTrue(Files.isRegularFile(guard), "启动期 DEFAULT 哨兵应存在:" + guard);
|
||||
String text = raw(guard);
|
||||
assertTrue(text.contains("COMPANY_DEFAULT_STILL_PRESENT"), "哨兵标记串必须保持 ASCII 原样(巡检按它 grep)");
|
||||
assertTrue(text.contains("'" + TABLE + "'"),
|
||||
"探针 SQL 的 IN 列表要含 " + TABLE + "(不在 IN 里就查不到这一列,哨兵等于没探)");
|
||||
assertTrue(text.contains("\"" + TABLE + "\""),
|
||||
"WATCHED_TABLES 清单要含 " + TABLE + "(查到了却不在清单里,就没人去喊那条签名)");
|
||||
|
||||
assertFalse(probeInList(text).contains(TABLE),
|
||||
"探针 SQL 的 IN 列表不许再有 " + TABLE + ":查到了就等于还要人摘 DEFAULT");
|
||||
assertFalse(watchedTables(text).contains(TABLE),
|
||||
"WATCHED_TABLES 清单不许再有 " + TABLE + ":清单才是判定走不走的那一侧");
|
||||
|
||||
Path v151 = sharedKeyMigrationFile();
|
||||
String note = raw(v151);
|
||||
assertTrue(note.contains(TABLE), "退键那一笔要点名类目表:" + v151.getFileName());
|
||||
assertTrue(note.contains("DROP DEFAULT") && note.contains("1364"),
|
||||
"必须写明\"这一版的 DEFAULT 摘不得\"及其后果,否则 V147 头注释那条旧承诺仍然会被执行");
|
||||
}
|
||||
|
||||
/** 取探针 SQL 的 {@code TABLE_NAME IN ('a', 'b')} 段(单引号)。 */
|
||||
private static List<String> probeInList(String guardSource) {
|
||||
Matcher inList = Pattern.compile("TABLE_NAME\\s+IN\\s*\\(([^)]*)\\)").matcher(guardSource);
|
||||
assertTrue(inList.find(), "哨兵源码里没有 TABLE_NAME IN (…) 这一段,取不到清单");
|
||||
return quotedValues(inList.group(1), "'([^']+)'");
|
||||
}
|
||||
|
||||
/** 取 {@code WATCHED_TABLES = List.of("a", "b")} 那批双引号表名。 */
|
||||
private static List<String> watchedTables(String guardSource) {
|
||||
Matcher list = Pattern.compile("WATCHED_TABLES\\s*=\\s*List\\.of\\(([^)]*)\\)").matcher(guardSource);
|
||||
assertTrue(list.find(), "取不到 WATCHED_TABLES 清单:哨兵源码的形状变了,本用例的尺子要跟着改");
|
||||
return quotedValues(list.group(1), "\"([^\"]+)\"");
|
||||
}
|
||||
|
||||
/** 解析不出任何一条就当场判红:0 命中会让上面那两条 {@code assertFalse} 恒真。 */
|
||||
private static List<String> quotedValues(String segment, String quotePattern) {
|
||||
List<String> values = new ArrayList<>();
|
||||
Matcher quoted = Pattern.compile(quotePattern).matcher(segment);
|
||||
while (quoted.find()) {
|
||||
values.add(quoted.group(1));
|
||||
}
|
||||
assertFalse(values.isEmpty(), "从源码段里解析出 0 个表名 ⇒ 这段断言是恒绿的:" + segment);
|
||||
return values;
|
||||
}
|
||||
|
||||
private static Path sharedKeyMigrationFile() throws IOException {
|
||||
List<Path> hits = versionFiles().stream()
|
||||
.filter(p -> p.getFileName().toString().startsWith("V151__"))
|
||||
.toList();
|
||||
assertEquals(1, hits.size(), "V151(两张共享表退回全局唯一键)应存在且只有一个:" + hits);
|
||||
return hits.get(0);
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -0,0 +1,296 @@
|
||||
package com.nanri.aiimage.config;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.nio.file.Files;
|
||||
import java.nio.file.Path;
|
||||
import java.util.List;
|
||||
import java.util.regex.Matcher;
|
||||
import java.util.regex.Pattern;
|
||||
import java.util.stream.Stream;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertFalse;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
/**
|
||||
* V150({@code biz_shop_key} 加 company_id)的文件审计。
|
||||
* 需求:2026-10-06 控制方点名「店铺密钥管理的数据按照公司区分」;设计见迁移文件头 §1–§6。
|
||||
*
|
||||
* <p>为什么必须单独有一支:本仓 pom 无 H2、无 testcontainers,迁移跑不起来,文件审计是唯一能守住的那层
|
||||
* (与 {@link ProductCategoryMigrationV147Test}、{@link CompanyScopeMigrationV145Test} 同口径)。
|
||||
* V150 的三条关键决定全都"错了不报错":</p>
|
||||
* <ol>
|
||||
* <li>历史归属靠加列时记录的 {@code DEFAULT 1},而不是回填——写成可空列或补一条 UPDATE 都改成另一种语义;</li>
|
||||
* <li>唯一键 {@code uk_ziniao_token_hash} <b>刻意保持全局</b>(不像 V145/V147 那样按公司放宽),
|
||||
* 谁"顺手把它按公司放宽"就会让同一个令牌在两家公司各存一行、被 {@code ZiniaoApiKeyProvider}
|
||||
* 按令牌并成一条,白名单状态与代理地址互相顶掉;</li>
|
||||
* <li>回滚的默认档是<b>保留新列、只回 jar</b>,删列那一步留在注释里由人工解开(这张表没有账号列,
|
||||
* 列一删归属就再也分不回去)。</li>
|
||||
* </ol>
|
||||
*
|
||||
* <p>{@code stripComments}/{@code normalize} 逐字沿用 {@link CompanyScopeMigrationV145Test} 那一份实现:
|
||||
* 注释里的 {@code --} 与字符串字面量里的 {@code --} 是两件事,另写一版简化实现会让断言打在残缺 SQL 上。</p>
|
||||
*/
|
||||
class ShopKeyMigrationV150Test {
|
||||
|
||||
private static final Path ROOT = Path.of(System.getProperty("user.dir"));
|
||||
private static final Path DB_DIR = ROOT.resolve("src/main/resources/db");
|
||||
private static final String TABLE = "biz_shop_key";
|
||||
private static final String GLOBAL_UNIQUE_KEY = "uk_ziniao_token_hash";
|
||||
|
||||
// ---------------------------------------------------------------- 取文件
|
||||
|
||||
private static List<Path> versionFiles() throws IOException {
|
||||
try (Stream<Path> s = Files.list(DB_DIR)) {
|
||||
return s.filter(p -> p.getFileName().toString().matches("^V\\d+(?:_\\d+)?__.*\\.sql$"))
|
||||
.sorted()
|
||||
.toList();
|
||||
}
|
||||
}
|
||||
|
||||
private static Path migration() throws IOException {
|
||||
List<Path> hits = versionFiles().stream()
|
||||
.filter(p -> p.getFileName().toString().startsWith("V150__"))
|
||||
.toList();
|
||||
assertEquals(1, hits.size(),
|
||||
"V150 必须恰好一个迁移文件,实际 " + hits.size() + " 个(0 个=密钥表还没归属列;2 个=撞号,Flyway 启动即失败)");
|
||||
return hits.get(0);
|
||||
}
|
||||
|
||||
private static String raw(Path file) throws IOException {
|
||||
return Files.readString(file, StandardCharsets.UTF_8);
|
||||
}
|
||||
|
||||
private static String statements() throws IOException {
|
||||
return normalize(stripComments(raw(migration())));
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------ SQL 预处理
|
||||
// 与 CompanyScopeMigrationV145Test / ProductCategoryMigrationV147Test 逐字同实现,理由见类注释。
|
||||
|
||||
private static String stripComments(String sql) {
|
||||
StringBuilder out = new StringBuilder(sql.length());
|
||||
int i = 0;
|
||||
while (i < sql.length()) {
|
||||
char c = sql.charAt(i);
|
||||
if (c == '\'') {
|
||||
int end = i + 1;
|
||||
while (end < sql.length()) {
|
||||
if (sql.charAt(end) == '\'') {
|
||||
if (end + 1 < sql.length() && sql.charAt(end + 1) == '\'') {
|
||||
end += 2;
|
||||
continue;
|
||||
}
|
||||
break;
|
||||
}
|
||||
end++;
|
||||
}
|
||||
out.append(sql, i, Math.min(end + 1, sql.length()));
|
||||
i = end + 1;
|
||||
continue;
|
||||
}
|
||||
if (c == '-' && i + 1 < sql.length() && sql.charAt(i + 1) == '-') {
|
||||
while (i < sql.length() && sql.charAt(i) != '\n') {
|
||||
i++;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
if (c == '/' && i + 1 < sql.length() && sql.charAt(i + 1) == '*') {
|
||||
int end = sql.indexOf("*/", i + 2);
|
||||
i = end < 0 ? sql.length() : end + 2;
|
||||
continue;
|
||||
}
|
||||
out.append(c);
|
||||
i++;
|
||||
}
|
||||
return out.toString();
|
||||
}
|
||||
|
||||
private static String normalize(String sql) {
|
||||
return sql.replaceAll("\\s+", " ").trim();
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------ 用例
|
||||
|
||||
/** 破坏点:取到已应用的号(原地改=两台都起不来),或把这一版编成 V152(V150 就被跳开,归属列永远不加)。 */
|
||||
@Test
|
||||
void migrationIsVersionedOneFiveZero() throws IOException {
|
||||
Path file = migration();
|
||||
Matcher m = Pattern.compile("^V(\\d+)(?:_\\d+)?__").matcher(file.getFileName().toString());
|
||||
assertTrue(m.find(), "文件名应能抽出整数版本:" + file.getFileName());
|
||||
assertEquals(150, Integer.parseInt(m.group(1)), "本迁移必须是 V150(V149 之后的下一号)");
|
||||
assertTrue(file.getFileName().toString().matches("^V150__[A-Za-z0-9_.-]+\\.sql$"),
|
||||
"命名应 V150__<snake 描述>.sql:" + file.getFileName());
|
||||
}
|
||||
|
||||
/**
|
||||
* 破坏点 ①:加成可空 ⇒ 混合窗口里旧 jar 写进来的密钥行 {@code company_id} 为 NULL,
|
||||
* 而 {@code applyCompanyScope} 的 null 分支是「不裁剪」,这些行会同时出现在每一家的 tab 上。
|
||||
* 破坏点 ②:写 {@code MODIFY COLUMN} ⇒ 重建表并按"当时的列默认值"物化历史行,而本迁移没写回历史行,
|
||||
* 历史归属的全部依据就是加列那一刻记录的默认值(§6)。
|
||||
* 破坏点 ③:加 {@code AFTER} ⇒ 非末位列在 InnoDB 里要重建聚簇记录,INSTANT 的前提没了。
|
||||
* {@code DEFAULT 1} 必须<b>在场</b>:它是同批旧 jar 唯一能插进这张表的通道,摘它的是下一版。
|
||||
*/
|
||||
@Test
|
||||
void addsANotNullCompanyColumnWithInstantAndNeverModify() throws IOException {
|
||||
String sql = statements();
|
||||
assertTrue(sql.contains("ALTER TABLE `" + TABLE + "` ADD COLUMN `company_id` bigint NOT NULL DEFAULT 1"),
|
||||
TABLE + " 应一次到位加成 NOT NULL DEFAULT 1(DEFAULT 只为同批旧 jar 存在,摘除是下一版)");
|
||||
assertTrue(sql.contains("ALGORITHM = INSTANT"),
|
||||
"加列必须钉 INSTANT:前提不成立时 MySQL 直接报 1846,而不是悄悄退化成 COPY(§3)");
|
||||
assertFalse(sql.toUpperCase().contains(" AFTER "), "不许写 AFTER:非末位列加列会触发整表重建(§3)");
|
||||
assertFalse(sql.contains("MODIFY COLUMN"), "禁 MODIFY COLUMN——它会重建表并按当时的默认值物化历史行(§6)");
|
||||
assertFalse(sql.contains("ALTER TABLE `" + TABLE + "` DROP COLUMN"), "本版本不删列:归属一旦删掉就再也分不出是第几家公司(§2)");
|
||||
}
|
||||
|
||||
/**
|
||||
* 列注释里那句「历史行由本默认值给出,不可反推」是这一列存在理由的一半:
|
||||
* 它跟着 schema 走,将来接手的人不必翻迁移文件就知道第 1 家的行里混着窗口期的别家数据。
|
||||
*/
|
||||
@Test
|
||||
void columnCommentCarriesTheProvenanceLimitation() throws IOException {
|
||||
String sql = statements();
|
||||
assertTrue(sql.contains("本表无账号列"), "列注释要写明「本表无账号列」,否则后来人会试图按创建人反推归属");
|
||||
assertTrue(sql.contains("不可反推"), "列注释要写明历史归属「不可反推」,这是 §2 那个不可追回窗口的落点");
|
||||
}
|
||||
|
||||
/**
|
||||
* 破坏点:有人"顺手"补一条回填 UPDATE(这张表没有账号列,任何"按人回填"都是编数据);
|
||||
* 或者加了 created_by_id / 二级索引,把"刻意不做的事"做成了既成事实。
|
||||
* 计数取 0 而不是「不超过 1」:§2 的口径是历史行的 1 来自默认值,一条 DML 都不该有。
|
||||
*/
|
||||
@Test
|
||||
void writesNoDmlAtAllAndAddsNoIndex() throws IOException {
|
||||
String sql = statements();
|
||||
Matcher d = Pattern.compile("\\b(UPDATE|INSERT|DELETE|REPLACE)\\b", Pattern.CASE_INSENSITIVE).matcher(sql);
|
||||
int hits = 0;
|
||||
while (d.find()) {
|
||||
hits++;
|
||||
}
|
||||
assertEquals(0, hits, TABLE + " 的可执行段一条 DML 都不该有,实际命中 " + hits + " 条 DML 关键字");
|
||||
assertFalse(sql.contains("created_by_id"), "本版本不加 created_by_id:归属从本版本起由 service 显式落,反推那条路用不上(§2)");
|
||||
assertEquals(0, count(sql, "ADD INDEX") + count(sql, "ADD KEY"),
|
||||
"本版本不加二级索引:这张表是「一个紫鸟账号一行」量级,多挂一个单列索引就是 V139 那轮清掉的冗余形状");
|
||||
}
|
||||
|
||||
/**
|
||||
* 唯一键必须一动不动(§4)。这是本迁移与 V145/V147 最大的口径差别,所以钉成"可执行段里
|
||||
* 没有任何索引动作",而不是"索引动作少"——放宽那一步一旦发生,运行期的表现是两行并成一行、
|
||||
* 代理与白名单状态跨公司互相顶掉,不会有任何报错。
|
||||
*/
|
||||
@Test
|
||||
void uniqueKeyStaysGlobalAndTheReasonTravelsWithTheFile() throws IOException {
|
||||
String sql = statements();
|
||||
assertEquals(0, count(sql, "DROP INDEX") + count(sql, "ADD UNIQUE KEY"),
|
||||
"本版本不许动任何索引:uk_ziniao_token_hash 刻意保持全平台唯一(§4)");
|
||||
assertFalse(sql.contains(GLOBAL_UNIQUE_KEY),
|
||||
"可执行段里不该出现 " + GLOBAL_UNIQUE_KEY + "(它只应出现在解释为什么不动的注释里)");
|
||||
String whole = raw(migration());
|
||||
assertTrue(whole.contains(GLOBAL_UNIQUE_KEY), "「为什么不动唯一键」的理由必须写在迁移文件里,而不是只写在评审意见里");
|
||||
assertTrue(whole.contains("ZiniaoApiKeyProvider"), "理由的关键环是令牌聚合那一步:注释要点名 ZiniaoApiKeyProvider");
|
||||
}
|
||||
|
||||
/**
|
||||
* 破坏点:删掉存在性守卫 ⇒ DDL 不进事务,中途失败后按「repair → 重启」重跑会撞 1060(重复列)而彻底起不来。
|
||||
* 计数取 1 而不是「大于 0」:本文件的可执行段恰好查一次 information_schema(只查列),
|
||||
* 多一次说明有人加了没登记的索引/键动作,少一次就是守卫没了。
|
||||
*/
|
||||
@Test
|
||||
void addColumnIsGuardedByExistenceCheckAndReRunnable() throws IOException {
|
||||
String sql = statements();
|
||||
assertEquals(1, count(sql, "information_schema"),
|
||||
"可执行段应查 1 次 information_schema(列存在性),实际次数见消息");
|
||||
assertTrue(sql.contains("TABLE_NAME = '" + TABLE + "'"), "加列的守卫要按本表查");
|
||||
assertTrue(sql.contains("COLUMN_NAME = 'company_id'"), "加列的守卫要按列名查");
|
||||
assertTrue(count(sql, "PREPARE stmt FROM @sql") == 1 && count(sql, "EXECUTE stmt") == 1
|
||||
&& count(sql, "DEALLOCATE PREPARE stmt") == 1,
|
||||
"条件 DDL 必须走 PREPARE/EXECUTE 并收口(MySQL 不能在 IF 里直接写 DDL)");
|
||||
}
|
||||
|
||||
/**
|
||||
* 行数今天没实查(§2 写明),取证命令与不可追回窗口必须留在文件里。
|
||||
* 这一支钉的是"取证责任没被写成既成事实":文件里出现"行数已确认"这类话就是把它编完了。
|
||||
*/
|
||||
@Test
|
||||
void unprobedRowCountStaysAnExplicitDebtWithTheProbeQuery() throws IOException {
|
||||
String whole = raw(migration());
|
||||
assertTrue(whole.contains("SELECT COUNT(*) AS total"),
|
||||
"§2 要带上可实跑的取证 SQL,而不是只留一句「上线前查一下」");
|
||||
assertTrue(whole.contains("2026-10-04 14:55"), "不可追回窗口的锚点是第二家公司开通时刻,必须在文件里");
|
||||
assertTrue(whole.contains("没有实查") || whole.contains("未实查"), "行数没查过这件事必须写在文件里,不许读成已知");
|
||||
}
|
||||
|
||||
/**
|
||||
* 回滚是人工补丁,且在 Flyway 扫描路径之外。
|
||||
*
|
||||
* <p>本迁移的回滚默认档<b>一条 SQL 都不执行</b>:这张表没有账号列,删列就删掉了唯一的归属依据,
|
||||
* 所以 {@code DROP COLUMN} 留在注释里由人工解开,止损走"保留新列、只回 jar"那一档
|
||||
* (新列对旧 jar 是惰性的,{@code DEFAULT 1} 正好把旧 jar 插入的行接住)。
|
||||
* {@link CompanyScopeMigrationV145Test#rollbackStaysOutOfFlywayScanAndCoversTheHistoryRow} 按全目录
|
||||
* 钉"回滚不得版本化",本类只钉本迁移这一支的内容。</p>
|
||||
*/
|
||||
@Test
|
||||
void rollbackIsAHumanPatchThatDefaultsToKeepingTheColumn() throws IOException {
|
||||
Path doc = ROOT.resolve("docs/rollback-V150-shop-key-company.sql");
|
||||
assertTrue(Files.isRegularFile(doc), "V150 的人工回滚补丁必须存在:" + doc);
|
||||
String whole = raw(doc);
|
||||
assertTrue(whole.contains("flyway_schema_history"), "回滚必须写明删 version='150' 的历史行");
|
||||
assertTrue(whole.contains("'150'"), "回滚补丁要点名本版本号,后来人才知道删的是哪一行");
|
||||
String executable = normalize(stripComments(whole));
|
||||
assertTrue(executable.isEmpty(),
|
||||
"默认档不执行任何 SQL(删列是不可逆动作,必须留在注释里由人工解开),实际可执行段:" + executable);
|
||||
assertTrue(whole.contains("DROP COLUMN"), "删列那一步要在文件里,只是不许默认可执行");
|
||||
}
|
||||
|
||||
/**
|
||||
* 破坏点:V150 的 DEFAULT 1 没进启动期哨兵清单 ⇒ "下一次记得摘"这件事没人喊,
|
||||
* 而巡检按 {@code COMPANY_DEFAULT_STILL_PRESENT} 这条 ASCII 签名 grep docker logs。
|
||||
*/
|
||||
@Test
|
||||
void startupSentinelWatchesTheShopKeyColumn() throws IOException {
|
||||
Path guard = ROOT.resolve("src/main/java/com/nanri/aiimage/modules/company/service/CompanyDefaultGuard.java");
|
||||
assertTrue(Files.isRegularFile(guard), "启动期 DEFAULT 哨兵应存在:" + guard);
|
||||
String text = raw(guard);
|
||||
assertTrue(text.contains("COMPANY_DEFAULT_STILL_PRESENT"), "哨兵标记串必须保持 ASCII 原样(巡检按它 grep)");
|
||||
assertTrue(text.contains("'" + TABLE + "'"),
|
||||
"探针 SQL 的 IN 列表要含 " + TABLE + "(不在 IN 里就查不到这一列,哨兵等于没探)");
|
||||
assertTrue(text.contains("\"" + TABLE + "\""),
|
||||
"WATCHED_TABLES 清单要含 " + TABLE + "(查到了却不在清单里,就没人去喊那条签名)");
|
||||
}
|
||||
|
||||
/** 破坏点:盘点文档没跟着改 ⇒ 下一个人按"取号起点"取号就撞号,或按"最新版本"漏掉本文件。 */
|
||||
@Test
|
||||
void inventoryDocTracksTheShopKeyFile() throws IOException {
|
||||
Path doc = ROOT.resolve("docs/migration-inventory.md");
|
||||
String text = raw(doc);
|
||||
assertTrue(text.contains(migration().getFileName().toString()),
|
||||
"盘点文档应逐字保留本迁移文件名:" + migration().getFileName());
|
||||
assertTrue(text.contains("V147__product_category_company_scope.sql"),
|
||||
"盘点文档应同时保留更早的文件名:只钉最新一条会重演「推进概览时把旧条目挤掉」那一次回归");
|
||||
}
|
||||
|
||||
/** 自检:本用例集扫的是真文件,且 normalize 后仍能命中关键串(0 命中的断言是恒绿的)。 */
|
||||
@Test
|
||||
void scannedSignaturesAreActuallyPresent() throws IOException {
|
||||
String sql = statements();
|
||||
assertTrue(sql.length() > 120, "剥注释后的 SQL 太短,说明预处理把内容吃掉了:" + sql.length());
|
||||
assertTrue(count(sql, "ALTER TABLE") >= 1 && count(sql, "information_schema") > 0,
|
||||
"关键签名 0 命中=预处理或文件路径坏了,本类的断言全部不可信");
|
||||
String rollbackExecutable = normalize(stripComments(raw(ROOT.resolve("docs/rollback-V150-shop-key-company.sql"))));
|
||||
assertTrue(raw(ROOT.resolve("docs/rollback-V150-shop-key-company.sql")).contains("--"),
|
||||
"回滚补丁若一条注释都没有,上面那条「可执行段为空」就成了恒真断言");
|
||||
assertTrue(rollbackExecutable.isEmpty(), "回滚补丁的可执行段应当确实为空");
|
||||
}
|
||||
|
||||
private static int count(String haystack, String needle) {
|
||||
int n = 0, i = haystack.indexOf(needle);
|
||||
while (i >= 0) {
|
||||
n++;
|
||||
i = haystack.indexOf(needle, i + needle.length());
|
||||
}
|
||||
return n;
|
||||
}
|
||||
}
|
||||
+17
@@ -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);
|
||||
|
||||
+20
-5
@@ -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
|
||||
|
||||
+25
-25
@@ -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) {
|
||||
|
||||
+65
-23
@@ -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());
|
||||
|
||||
+45
-1
@@ -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() {
|
||||
|
||||
+3
-1
@@ -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) {
|
||||
|
||||
+2
-1
@@ -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) {
|
||||
|
||||
+18
-50
@@ -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);
|
||||
|
||||
+14
-20
@@ -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());
|
||||
|
||||
+22
-11
@@ -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
|
||||
|
||||
+90
-18
@@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
+536
@@ -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);
|
||||
}
|
||||
}
|
||||
-158
@@ -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;
|
||||
}
|
||||
}
|
||||
+103
-323
@@ -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());
|
||||
}
|
||||
}
|
||||
|
||||
+167
@@ -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;
|
||||
}
|
||||
}
|
||||
+345
@@ -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;
|
||||
}
|
||||
}
|
||||
+1
-2
@@ -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()
|
||||
|
||||
Reference in New Issue
Block a user