feat(公司tab): 批次 2/3/4 再接 8 页,注册表收到 16 页——用户页回流 company_id 按新边界改写反向钉

「切 tab 数据还一样」的根因一直是分母小于现实:批次 1 只登记 8 页,本轮按控制方
三次点名扩到 16 页(company-scope.ts 是唯一清单,routes.ts 的 companyScoped 逐页对平)。

批次 2(五页 ASIN 中心):去重总数据 / 不符合ASIN / 查询ASIN / 最低价ASIN / 商品类目。
批次 3(两页店铺中心):撞款监控、店铺数据记录。这两页没有归属列可筛,归属口径是
「本公司账号名下的店铺」——后端由 DataReadScope 推公司 → 成员账号 → biz_shop_manage.
created_by_id,前端只把 activeId 当 company_id 送下去。空成员集必须交空集合,绝不能
退化成 null(null 在这里=全量,那样第二家会看到全部数据)。
批次 4(用户管理):后端早就认 company_id(只对站点超管生效,公司超管恒锁本公司),
断的是前端——UserListQuery 里连这个字段都没有,三家 tab 看的是同一份全量列表。

三处口径改动,逐条说明:
1)company-user-list.test.ts 的反向钉被改写。2026-10-04 定案把公司维度从用户页整体摘掉,
   那条钉的原文是「列表查询/筛选/行渲染不允许出现公司维度」。控制方 2026-10-05 明确要
   用户管理区分公司 tab,所以钉的边界收窄成两半:渲染层(行级公司列、「所属公司」标签、
   筛选状态、顶栏公司名)仍不得回流;请求层的 company_id 是这次加回来的,尺子换成
   「取值口唯一」——页面每处 companyId 都必须等于 companyTab.requestCompanyId,且
   normalizeUserPageParams/toUserListQuery 两只白名单构造器体内不许出现公司值。
   新增一支行为钉:往归一化里传 companyId 必须被丢掉,这是 users.ts 读原始入参的全部理由
   (写成 normalized.companyId 时 TS 照样绿、运行时恒 undefined)。
2)align-dup-console 那条 watch 看守的 token 扩到含 reload。变异自证里「删掉 void
   loadConsole()」当场全绿:体里的清筛选项守住了,重新取数那半没人守。批次 3/4 三对
   token 一起写到 reload 为止(批次 1/2 的老条目不动)。
3)公司管理页补正/反向两把尺子:company-config-entry-super-only 新增「吃公司 tab 的页面
   集合恰好等于 COMPANY_SCOPED_PAGES 的 pageFiles」——按代码真值比,不按清单比,所以
   清单不改一字而往 CompaniesPage.vue 里塞 store 也会红。谓词带括号,否则 import 行也算消费者。

菜单权限(admin_columns)本轮不动:MenusPage 只消费 /api/admin/permission-menus 这一份全局
菜单字典,切 tab 一样是数据本身全局,不是筛选坏了。真问题在写侧——PermissionMenuService
create/update/delete 只有 ensureAdminOperatorIfPresent(isAdmin 即放行),公司管理员改的是
全平台的菜单行。收窄为仅站点超管 vs 给 permission_menu 加归属列,两种改法代价差一个量级,
留给控制方定档。

护栏:G1 发送口 22 个 / 页面分组 17、watch 体看守 10 对、operation-guide 的 tab 文案 15 页
(撞款监控是显式豁免,另有一条自检盯「豁免落空」)。
变异自证 12/12 全杀(前端 10 + 公司管理反向钉 2),分母钉死在 27 例。
门禁:后端全量 3823 例 / 0 失败 / 0 错误 / 7 skipped,BUILD SUCCESS;admin-frontend-vue
1741 例 / 0 红;vue-tsc rc=0。首轮后端 4 红是另一路 task_partial 改动与本轮编译抢跑,
单跑 13 例已绿,本笔不含他们的任何文件。

未上线:jar 与 admin-vue 都没出包,V147 未在生产执行。
This commit is contained in:
2026-10-06 02:32:59 +08:00
parent e5e36aa713
commit 16583f578d
87 changed files with 3519 additions and 459 deletions
@@ -93,7 +93,7 @@ import org.junit.jupiter.api.Test;
* ① {@code readScope(} 的结果必须<b>被赋值给一个变量</b>({@code List<Long> scoped = …readScope(…);} 与
* {@code ReadScope s = …readScope(…);} 两种形状都认);找不到赋值目标 = 裸语句、结果被丢掉 ⇒ 红。
* ② 该变量必须出现在 handler 体内<b>另一条方法调用的实参列表</b>里(扣掉它自己那条赋值语句,
* 单层括号够用,今天两页都是这一形)。只要求"在别处被引用一次"不够:
* 实参表按 {@link #callsOf} 的配对括号取,见第 13 条)。只要求"在别处被引用一次"不够:
* {@code if (scoped != null) throw …} 是装饰,不算把范围交给谁 ⇒ 控制语句关键字不认。</li>
* <li><b>调了出口不等于把公司参数交给了出口</b>(本轮新增的断言 D)。现网最难查的一刀是
* {@code dataReadScope.readScope(operator, null)}:参数照样收下(B 绿)、{@code readScope(} 照样写在
@@ -102,18 +102,35 @@ import org.junit.jupiter.api.Test;
* D 因此先按 {@link Block#boundCompanyParam()} 从<b>声明窗口</b>里取出被绑定到
* {@code company_id} 的<b>变量名</b>(不硬编码 {@code companyId}:这一支改叫 {@code orgId} 就用
* {@code orgId} 判),再要求它作为整词实参出现在 {@code readScope}/{@code resolveScope} 的参数表里
* (单层括号,复用 {@link #CALL_ARGUMENTS};私有收口方法 {@code resolveScope(request, companyId)}
* (实参表按 {@link #callsOf} 的配对括号取,见第 13 条;私有收口方法 {@code resolveScope(request, companyId)}
* 那一形算,Task 11 模板鼓励的正是它)。只写在 {@code if (companyId != null)} 里、或只出现在
* {@code @Operation} 文案里,都不算消费——沿用 C 的 {@link #NOT_VALUE_CONSUMERS} 那把尺子,不放宽。
* 射程与 A/B/C 同源:同一个 {@code takesCompanyParam()} 谓词、同一份
* {@link #READ_SCOPE_ALLOWLIST}(一条豁免同时免 A/B/C/D,不许另起第二张表),并且只咬
* {@code viaRequestParam()} 那一族(F-C 的同一把尺子:{@code getParameter("company_id")} 给不出
* 绑定变量名,D 对它无从判定)。取不到绑定名 = 形状不认识 ⇒ 判红并报形状,不许静默放过。
* D 的代价与射程一并交代(本轮报告有逐条清单):{@link #CALL_ARGUMENTS} 只吃单层括号,于是
* {@code readScope(operator, normalize(companyId))} 这种嵌套写法会判红(误伤合规代码,改写法或补宽
* D 的取法都算核对过);非 {@code Long} 型公司参数取不到绑定名,同样判红;而"handler 之外的私有
* D 的代价与射程一并交代:非 {@code Long} 型公司参数取不到绑定名,判红并报形状;而"handler 之外的私有
* 收口方法里把公司参数硬写成 {@code null}"这一族 D 看不见——块边界止于该 handler 自己的闭括号
* (第 7 条),{@code AdminImageVideoTaskController.scopeOf} 正是它,那一处是<b>故意</b>传 null 的。</li>
* <li><b>两条正门,一套判据</b>(批次 2/3 新增)。{@code DataReadScope} 现在有两个出口:
* {@code readScope(} 按账号集合给范围(去重库、查询 ASIN、最低价 ASIN、历史、视频),
* {@code readCompanyId(} 给"归属已物化成 {@code company_id} 列"的表(品牌库、商品类目——
* 那两张表的 {@code uploader_user_id} 在生产是 0 行非空,按账号筛等于把全部历史从每个公司 tab 里
* 静默删掉,理由写在 {@code DataReadScope#readCompanyId} 的注释里)。两条门共用 A/B/C/D 四条判据:
* {@link #SCOPE_DOORS} 供 A 与 C 逐条跑,{@link #SCOPE_CALLEE_NAMES} 供 D 认被调名,
* <b>名单只写一次</b>(红因消息与自检断言咬的是拼出来的同一个标签,两处各写一遍会随哈希顺序漂红)。
* 每条门各自带能红/能绿两向探针(全局约束 15 那把尺子):只在 {@code readScope} 上验过,
* 等于第二道门上的返回值与入参没人看守。</li>
* <li><b>取实参表按配对括号,不按单层括号正则</b>(10-05 批次 2/3 实跑)。原先 C 的第 ② 步与 D 都用
* {@code ([\w$]*)\s*\(([^()]*)\)},实参表里只要还有一次方法调用就整条看不见。而第 7 条把块边界钉死在
* handler 自己的闭括号上、断言 A 因此要求正门调用必须内联,两支约束合起来把合规接线逼成了
* {@code service.page(page, operator.id(), memberIds)} 这一形——本轮实跑 6 记假红
* (DedupeTotalData/InvalidAsin/QueryAsin×2/SkipPriceAsin×2)。判据把合规写法判红的下一步,
* 就是有人为了让它绿而把接线挪回块外的私有方法里,那是护栏逼人拆护栏。
* 现按 {@link #callsOf} 逐字符配对取(深度计数,字符串与字符字面量内的括号不计数,口径同第 5 条),
* 嵌套调用自己也入表。放宽的两枚正探针与一枚"嵌套了但没带公司参数"的负探针
* ({@code readScope(operator, operator.getCompanyId())} 整词大小写敏感、照旧红)成对写死:
* 少了负探针,"放宽"两个字就等于把 C 与 D 关掉。</li>
* </ol>
*
* <p>取样键:可执行行里出现 {@code company_id} <b>或</b> {@code companyId}(裸 token 即入样本,交给逐 handler
@@ -153,13 +170,57 @@ class CompanyIdParamGoesThroughReadScopeTest {
* 断言 C 的<b>射程下限</b>(复评 I-1):Task 8 已经接线的两页必须真被 C 扫到。
* 不钉这一条的话,"取样集非空"自检可以由任何一支别的 handler 满足,而这两页哪天改了
* mapping 注解 / 换了参数形状就会静默脱离射程——分母由本轮自己造,等于没有分母。
*
* <p>10-05 批次 2/3(去重库、品牌库、查询ASIN、最低价ASIN、商品类目)把样本面扩到了
* {@link #READ_COMPANY_ID_CALL} 那条正门上,所以这里补两条同样口径的射程下限:
* 那五页哪天改了参数形状,静默脱离的是这一页的 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";
/**
* 射程下限的<b>唯一一份</b>名单:C 与 D 两条射程断言共用它,不许各写一份(两处各写就会有一处先漂)。
* 这七支是"切 tab 数据还是一样"这次报障正对着的页面 —— 用户报的五页(去重库、品牌库、最低价ASIN、
* 商品类目、查询ASIN)加批次 1 已接线的两页(图片历史、图片视频任务)。
*/
private static final List<String> WIRED_PAGE_KEYS = List.of(
SCOPE_CAUGHT_HISTORY_KEY,
SCOPE_CAUGHT_VIDEO_KEY,
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);
private static final String READ_SCOPE_CALL = "readScope(";
/**
* 第二个被认可的正门(10-05 批次 2/3):{@code DataReadScope.readCompanyId(operator, companyId)}。
*
* <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) ...})
* 依然红。</p>
*/
private static final String READ_COMPANY_ID_CALL = "readCompanyId(";
private static final List<String> SCOPE_DOORS = List.of(READ_SCOPE_CALL, READ_COMPANY_ID_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";
@@ -178,9 +239,21 @@ class CompanyIdParamGoesThroughReadScopeTest {
*/
private static final Pattern SCOPE_ASSIGNMENT = Pattern.compile("([A-Za-z_$][\\w$]*)\\s*=(?!=)");
/** 断言 C 第 ② 步的消费形状:{@code 名字(实参)},单层括号(现有两页都是这一形)。 */
private static final Pattern CALL_ARGUMENTS =
Pattern.compile("([A-Za-z_$][\\w$]*)\\s*\\(([^()]*)\\)");
/**
* 断言 C 第 ② 步与断言 D 共用的消费形状:{@code 名字(实参表)}。
*
* <p><b>为什么不再是正则</b>(10-05 批次 2/3 实测):原先用 {@code ([\w$]*)\s*\(([^()]*)\)}
* 只吃单层括号,于是 {@code service.page(page, operator.id(), memberIds)} 这种"实参表里还有一次
* 方法调用"的写法整条看不见——而断言 A 要求正门调用必须写在 handler 块<b>内</b>(私有收口方法在
* 块边界之外不算),恰恰把六支 handler 逼成了这一形(本轮实跑 6 记假红:
* DedupeTotalData/QueryAsin×2/SkipPriceAsin×2/InvalidAsin)。判据把合规写法判红,
* 下一步就是有人为了让它绿而把接线挪回块外——那是护栏逼人拆护栏。
* 现按<b>配对括号</b>逐字符取实参表:深度计数,字符串字面量与字符字面量里的括号不计数
* (口径同第 5 条"方法体开行"的判据,不是新尺子),嵌套调用自己也入表(
* {@code readScope(operator.user(), companyId)} 里的 {@code user()} 也在,但它不是正门、不影响判定)。</p>
*/
private record Call(String callee, String arguments) {
}
/**
* 控制语句关键字:读了变量但<b>没把它交给任何人</b>。{@code if (scoped != null) throw …} 这种装饰
@@ -190,12 +263,21 @@ class CompanyIdParamGoesThroughReadScopeTest {
"if", "for", "while", "switch", "do", "catch", "synchronized", "return", "throw", "else", "try");
/**
* 断言 D 认的两个被调名:{@code readScope} 是唯一出口本身,{@code resolveScope} 是 Task 11 模板
* 鼓励的"controller 里的私有收口方法"那一形(它内部再去 readScope)。除此之外的调用都不算
* "把公司参数交给了出口"——尤其 {@code readScope(operator, null)} 里那个 {@code null}。
* 断言 D 认的三个被调名:{@code readScope} 是按账号集合给范围的唯一出口,
* {@code resolveScope} 是 Task 11 模板鼓励的"controller 里的私有收口方法"那一形(它内部再去
* readScope),{@code readCompanyId} 是归属已物化成 {@code company_id} 列那两张表
* (品牌库、商品类目)的正门(见 {@link #READ_COMPANY_ID_CALL} 的理由)。
* 除此之外的调用都不算"把公司参数交给了出口"——尤其 {@code readScope(operator, null)} 里那个 {@code null}。
*/
private static final String RESOLVE_SCOPE_CALL = "resolveScope(";
private static final Set<String> SCOPE_CALLEES = Set.of("readScope", "resolveScope");
/**
* 名单只写一次:Set 给 D 判定用,拼好的标签给 D 的红因消息与自检断言用。
* 直接从 {@code Set} 拼会随哈希顺序变 ⇒ 消息里的名字顺序不稳定,而自检断言咬的是整串字面量,
* 那就等于一条会自己漂红的用例。
*/
private static final List<String> SCOPE_CALLEE_NAMES = List.of("readScope", "resolveScope", "readCompanyId");
private static final Set<String> SCOPE_CALLEES = Set.copyOf(SCOPE_CALLEE_NAMES);
private static final String SCOPE_CALLEE_LABEL = String.join("/", SCOPE_CALLEE_NAMES);
/**
* 断言 D 的取绑定名(两把锚一起用):先在声明窗口里找 {@code name = "company_id"}
@@ -352,6 +434,95 @@ 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));
}
""";
/**
* 断言 C 第 ② 步的<b>嵌套实参探针</b>(形状逐字抄现网:{@code DedupeTotalDataController.page})。
* <p>10-05 批次 2/3 实跑 6 记假红全在这一形上——断言 A 要求正门调用写在 handler 块<b>内</b>,
* 于是"把 operatorId 单独传下去"天然长成 {@code service.page(page, operator.id(), memberIds)}。
* 单层括号的取法看不见 {@code memberIds},判据就把合规接线判红;下一步必然有人为了变绿把
* 整段挪到块外的私有方法里——那是护栏逼人拆护栏。放宽后的判据必须有这枚正样本,
* 否则"放宽"两个字没有可证内容。</p>
*/
private static final String SCOPE_NESTED_ARG_PROBE = """
@GetMapping("/probe")
public String nestedArg(@RequestParam(name = "company_id", required = false) Long companyId) {
List<Long> memberIds = operator.superAdmin()
? dataReadScope.readScope(user, companyId).userIdsOr(null)
: null;
return String.valueOf(dedupeTotalDataService.page(page, memberIds, operator.id()));
}
""";
/**
* 断言 D 的<b>嵌套实参探针</b>(正):公司参数经过一次归一化才进出口。
* 与上一枚同一条放宽,但咬的是 D:{@code readScope} 自己的实参表里嵌套了调用,
* 里面确实带着 {@code companyId} ⇒ 必须绿(旧正则在这一形上判红,那是误伤)。
*/
private static final String SCOPE_NESTED_DOOR_ARG_PROBE = """
@GetMapping("/probe")
public String nestedDoorArg(@RequestParam(name = "company_id", required = false) Long companyId) {
List<Long> scoped = dataReadScope.readScope(operator, normalizeCompany(companyId)).userIdsOr(null);
return String.valueOf(shopService.page(page, scoped));
}
""";
/**
* 断言 D 的<b>嵌套负探针</b>(放宽的边界,与上一枚成对):进出口的是
* {@code operator.getCompanyId()} —— 括号取法宽了,"没带 tab 那个值"这一刀不许跟着宽。
* 整词判据大小写敏感(源码里那个名字是 {@code CompanyId},不是 {@code companyId}),
* 嵌套层里也确实取不到被绑定的那个变量名 ⇒ 照旧红。少了这一枚,上面那条正断言就等于把 D 关掉。
*/
private static final String SCOPE_NESTED_DOOR_ARG_FOREIGN_PROBE = """
@GetMapping("/probe")
public String nestedDoorArgForeign(@RequestParam(name = "company_id", required = false) Long companyId) {
List<Long> scoped = dataReadScope.readScope(operator, operator.getCompanyId()).userIdsOr(null);
return String.valueOf(shopService.page(page, scoped));
}
""";
@Test
@DisplayName("每个收公司 id 参数的 handler 都走唯一出口、显式写了 name = \"company_id\","
+ "而且 tab 传下来的那个值真被交给了出口(A/B/C/D)")
@@ -382,8 +553,8 @@ class CompanyIdParamGoesThroughReadScopeTest {
.isTrue();
assertThat(probe.text())
.as("块边界自检:handler 块必须止于与 mapping 注解同缩进的 } 行 —— "
+ "否则尾随私有方法里的 readScope( 会替这支没接出口的 handler 过关")
.doesNotContain(READ_SCOPE_CALL);
+ "否则尾随私有方法里的正门调用会替这支没接出口的 handler 过关")
.satisfies(text -> assertThat(anyScopeDoor(text)).isFalse());
assertThat(probe.spanText())
.as("块边界自检的反面证据:readScope( 确实写在收口之后的尾随方法里")
.contains(READ_SCOPE_CALL);
@@ -405,6 +576,16 @@ 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 没有区分度、只是重复劳动。
@@ -422,12 +603,12 @@ class CompanyIdParamGoesThroughReadScopeTest {
assertThat(companyIdArgProbeReason(SCOPE_PASSED_NULL_PROBE, "SCOPE_PASSED_NULL_PROBE", CAMEL_PARAM))
.as("断言 D 自检(负样本):readScope(operator, null) —— 公司参数没进出口 ⇒ 必须判红")
.isNotNull()
.contains("没进任何 readScope/resolveScope 的实参列表");
.contains("没进任何 " + SCOPE_CALLEE_LABEL + " 的实参列表");
assertThat(companyIdArgProbeReason(SCOPE_ONLY_IF_DECOR_PROBE, "SCOPE_ONLY_IF_DECOR_PROBE", CAMEL_PARAM))
.as("断言 D 自检(负样本 2):companyId 只被 if 读了一次、进出口的是 null ⇒ 同样要红"
+ "(控制语句不算消费,与 C 同一把尺子)")
.isNotNull()
.contains("没进任何 readScope/resolveScope 的实参列表");
.contains("没进任何 " + SCOPE_CALLEE_LABEL + " 的实参列表");
assertThat(companyIdArgProbeReason(SCOPE_PASSED_THROUGH_HELPER_PROBE, "SCOPE_PASSED_THROUGH_HELPER_PROBE", CAMEL_PARAM))
.as("断言 D 自检(正样本):companyId 交给同文件私有 resolveScope(request, companyId) ⇒ 判据不许恒红")
.isNull();
@@ -435,6 +616,43 @@ 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 + " 的实参列表");
// 配对括号取实参表(放宽)的成对证据:两枚正样本必须绿(否则 6 支已接线 handler 假红),
// 一枚"嵌套了但没带公司参数"的样本必须照旧红(否则放宽 = 把 D 关掉)。
assertThat(scopeProbeReason(SCOPE_NESTED_ARG_PROBE, "SCOPE_NESTED_ARG_PROBE"))
.as("断言 C 自检(嵌套实参表·正样本):service.page(page, memberIds, operator.id()) —— "
+ "消费方实参表里另有一次方法调用时也必须认得下 memberIds,"
+ "判红即护栏假红(批次 2/3 实测 6 支 handler 全撞这一形)")
.isNull();
assertThat(companyIdArgProbeReason(SCOPE_NESTED_DOOR_ARG_PROBE, "SCOPE_NESTED_DOOR_ARG_PROBE", CAMEL_PARAM))
.as("断言 D 自检(嵌套实参表·正样本):readScope(operator, normalizeCompany(companyId)) —— "
+ "被绑定的名字嵌在一层调用里也算交出去了")
.isNull();
assertThat(scopeProbeReason(SCOPE_NESTED_DOOR_ARG_FOREIGN_PROBE, "SCOPE_NESTED_DOOR_ARG_FOREIGN_PROBE"))
.as("断言 D 负样本的前提:readScope(operator, operator.getCompanyId()) 三步全绿 —— "
+ "接住了、也喂给 service 了,所以这一刀今天只有 D 会喊")
.isNull();
assertThat(companyIdArgProbeReason(
SCOPE_NESTED_DOOR_ARG_FOREIGN_PROBE, "SCOPE_NESTED_DOOR_ARG_FOREIGN_PROBE", CAMEL_PARAM))
.as("断言 D 自检(放宽的边界):进出口的是 operator.getCompanyId(),嵌套层里并没有被绑定的"
+ "那个变量名 ⇒ 必须照旧红。这条不红,上面那条『嵌套也算』就等于把 D 关掉了")
.isNotNull()
.contains("没进任何 " + SCOPE_CALLEE_LABEL + " 的实参列表");
// 断言 C 的分母由本轮实扫得出(不写死数字):扫进射程的 handler 键、走完两步的正样本支数、红因先攒后判。
List<String> scopeCaughtSample = new ArrayList<>();
@@ -469,9 +687,10 @@ class CompanyIdParamGoesThroughReadScopeTest {
boolean takesCompanyParam = handler.takesCompanyParam();
// 断言 A:收了公司 id 参数的 handler 必须在该 handler 体内走唯一出口(handler 级豁免)。
if (takesCompanyParam && !READ_SCOPE_ALLOWLIST.contains(exemptionKey(rel, handler))) {
assertThat(handler.text())
.as(where + " 收了公司 id 参数,但该 handler 体内没有出现 readScope( —— 文件里别处接了不算")
.contains(READ_SCOPE_CALL);
assertThat(anyScopeDoor(handler.text()))
.as(where + " 收了公司 id 参数,但该 handler 体内没走过任一正门 —— "
+ "文件里别处接了不算(私有收口方法在这支 handler 的闭括号之外,不算在内)")
.isTrue();
}
// 断言 B:显式 name= 只咬 @RequestParam 那一族(F-C:getParameter("company_id") 的下划线
// 本来就在串里,那个形状永远给不出 name = "company_id",合规写法不该被逼着改写法才绿)。
@@ -482,7 +701,7 @@ class CompanyIdParamGoesThroughReadScopeTest {
}
// 断言 C(复评 I-1):体内写了 readScope( 只说明"算过",不说明"用出去了"。
// 白名单只免 A 不免 C——被豁免的那支哪天自己算了个范围又丢掉,一样得红。
if (takesCompanyParam && handler.text().contains(READ_SCOPE_CALL)) {
if (takesCompanyParam && anyScopeDoor(handler.text())) {
scopeCaughtSample.add(exemptionKey(rel, handler));
String dropped = handler.scopeCatchFailure();
if (dropped == null) {
@@ -530,23 +749,26 @@ class CompanyIdParamGoesThroughReadScopeTest {
+ " 支 handler,走完『接住变量 → 当实参传出去』两步的是 0 支 —— 判据恒红或形状不认,不可信")
.isPositive();
assertThat(scopeCaughtSample)
.as("断言 C 的射程必须覆盖 Task 8 已接线的两页(改名/换 mapping 会让它静默脱离射程,分母不能自造)")
.contains(SCOPE_CAUGHT_HISTORY_KEY, SCOPE_CAUGHT_VIDEO_KEY);
.as("断言 C 的射程必须覆盖已接线的那 " + WIRED_PAGE_KEYS.size()
+ " 页(改名/换 mapping/换参数形状会让它静默脱离射程,分母不能自造)")
.contains(WIRED_PAGE_KEYS.toArray(new String[0]));
assertThat(scopeDiscarded)
.as("范围算了但没接住(断言 C):readScope( 的结果要么没赋给变量,要么赋了却没交给任何方法调用")
.as("范围算了但没接住(断言 C):两条正门(readScope( / readCompanyId()的结果要么没赋给变量,"
+ "要么赋了却没交给任何方法调用")
.isEmpty();
// 断言 D 的取样自检与分母(与 C 同一族纪律):空样本 = D 空转,射程不含已接线的页 = 静默脱离。
assertThat(companyIdArgSample)
.as("断言 D 取样集非空自检:一支『用 @RequestParam 收了公司 id 参数、体内又调了 "
+ "readScope/resolveScope』的 handler 都没扫到 ⇒ D 一行都没评")
+ SCOPE_CALLEE_LABEL + "』的 handler 都没扫到 ⇒ D 一行都没评")
.isNotEmpty();
assertThat(companyIdArgSample)
.as("断言 D 的射程必须覆盖已接线的那两页(改名/换 mapping 会让它静默脱离射程,分母不能自造)")
.contains(SCOPE_CAUGHT_HISTORY_KEY, SCOPE_CAUGHT_VIDEO_KEY);
.as("断言 D 的射程必须覆盖已接线的那 " + WIRED_PAGE_KEYS.size()
+ " 页(改名/换 mapping/换参数形状会让它静默脱离射程,分母不能自造)")
.contains(WIRED_PAGE_KEYS.toArray(new String[0]));
assertThat(companyIdArgMissing)
.as("公司参数没被交给出口(断言 D):readScope/resolveScope 的实参列表里没有出现被绑定到 "
+ "company_id 的那个变量名 —— 参数收下、出口也调了,tab 却是死的")
.as("公司参数没被交给出口(断言 D):" + SCOPE_CALLEE_LABEL
+ " 的实参列表里没有出现被绑定到 company_id 的那个变量名 —— 参数收下、出口也调了,tab 却是死的")
.isEmpty();
}
@@ -587,9 +809,9 @@ class CompanyIdParamGoesThroughReadScopeTest {
assertThat(handler.takesCompanyParam())
.as(probeName + " 的 handler 没被认成收公司 id 参数,断言 C 根本不会触发 ⇒ 探针失效")
.isTrue();
assertThat(handler.text())
.as(probeName + " 的 handler 体内没有 readScope( ,断言 C 扫不到它 ⇒ 探针失效")
.contains(READ_SCOPE_CALL);
assertThat(anyScopeDoor(handler.text()))
.as(probeName + " 的 handler 体内两条正门都没走(readScope( / readCompanyId(),断言 C 扫不到它 ⇒ 探针失效")
.isTrue();
return handler.scopeCatchFailure();
}
@@ -674,6 +896,91 @@ class CompanyIdParamGoesThroughReadScopeTest {
return line.contains(SNAKE_PARAM) || line.contains(CAMEL_PARAM);
}
/** 两条正门之一有没有在这段文本里出现过(A/C 的判据都走它,不各写一份)。 */
private static boolean anyScopeDoor(String text) {
return SCOPE_DOORS.stream().anyMatch(text::contains);
}
/**
* 逐字符扫出所有 {@code 名字(实参表)}:实参表按<b>配对括号</b>取(深度计数到 0 为止),
* 字符串/字符字面量内的括号不计数。嵌套调用<b>也入表</b>(扫描指针停在 {@code (} 之后而不是
* 跳过整条调用),否则 {@code readScope(operator.user(), companyId)} 里那一层就取不到。
* 括号不配平(切块把一条语句截断了)时,这条调用记到文末为止——宁可多算一次消费,
* 也不让"取不到实参表"变成静默放过;真正的截断形状由结构守卫负责。
*/
private static List<Call> callsOf(String src) {
List<Call> calls = new ArrayList<>();
int i = 0;
while (i < src.length()) {
char c = src.charAt(i);
if (c == '"' || c == '\'') {
i = skipLiteral(src, i, c);
continue;
}
boolean identifierStart = Character.isJavaIdentifierStart(c);
if (!identifierStart) {
i++;
continue;
}
int from = i;
while (i < src.length() && Character.isJavaIdentifierPart(src.charAt(i))) {
i++;
}
int open = i;
while (open < src.length() && Character.isWhitespace(src.charAt(open))) {
open++;
}
if (open >= src.length() || src.charAt(open) != '(') {
continue;
}
int close = matchingClose(src, open);
calls.add(new Call(src.substring(from, i), src.substring(open + 1, close)));
// 不跳到 close:嵌套调用也要被扫到
i = open + 1;
}
return calls;
}
/** 从 {@code quote} 处跳过一段字面量,返回其后的下标(处理 {@code \\} 转义,未闭合则到文末)。 */
private static int skipLiteral(String src, int quote, char marker) {
int i = quote + 1;
while (i < src.length()) {
char c = src.charAt(i);
if (c == '\\') {
i += 2;
continue;
}
if (c == marker) {
return i + 1;
}
i++;
}
return i;
}
/** {@code open} 处的 {@code (} 对应的 {@code )} 下标;取不到(不配平)返回文末。 */
private static int matchingClose(String src, int open) {
int depth = 0;
int i = open;
while (i < src.length()) {
char c = src.charAt(i);
if (c == '"' || c == '\'') {
i = skipLiteral(src, i, c);
continue;
}
if (c == '(') {
depth++;
} else if (c == ')') {
depth--;
if (depth == 0) {
return i;
}
}
i++;
}
return src.length();
}
private static boolean isMappingLine(String line) {
return MAPPING_ANNOTATIONS.stream().anyMatch(line::startsWith);
}
@@ -908,20 +1215,32 @@ class CompanyIdParamGoesThroughReadScopeTest {
*/
String scopeCatchFailure() {
String src = text();
for (int at = src.indexOf(READ_SCOPE_CALL); at >= 0;
at = src.indexOf(READ_SCOPE_CALL, at + READ_SCOPE_CALL.length())) {
for (String door : SCOPE_DOORS) {
String reason = scopeCatchFailureFor(src, door);
if (reason != null) {
return reason;
}
}
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())) {
// 语句边界:往前取最近的 ';' 或 '{'(方法体开行),往后取第一个 ';'。
int stmtStart = Math.max(src.lastIndexOf(SEMICOLON, at), src.lastIndexOf(WINDOW_OPEN, at)) + 1;
int stmtEnd = src.indexOf(SEMICOLON, at);
String statement = stmtEnd < 0 ? src.substring(stmtStart) : src.substring(stmtStart, stmtEnd + 1);
String target = assignedTo(statement, at - stmtStart);
if (target == null) {
return " 的 readScope( 是条裸语句:算完了没赋给任何变量,范围算了但没接住"
+ "(要写成 List<Long> scoped = dataReadScope.readScope(…)…; 再把 scoped 交出去)";
return " 的 " + door + " 是条裸语句:算完了没赋给任何变量,范围算了但没接住"
+ "(要写成 List<Long> scoped = dataReadScope." + door.replace("(", "")
+ "(…)…; 再把 scoped 交出去)";
}
String rest = src.substring(0, stmtStart) + (stmtEnd < 0 ? "" : src.substring(stmtEnd + 1));
if (!passedAsArgument(rest, target)) {
return " 的 readScope( 结果赋给了 `" + target + "`,但 handler 体内没有任何方法调用的"
return " 的 " + door + " 结果赋给了 `" + target + "`,但 handler 体内没有任何方法调用的"
+ "实参列表用到 `" + target + "`:范围接住了却没交出去(把 service 那层的实参改成 "
+ "null 就是这个形状)";
}
@@ -940,15 +1259,14 @@ class CompanyIdParamGoesThroughReadScopeTest {
return target;
}
/** {@code id} 有没有落在某个 {@code 名字(…)} 的实参列表里;控制语句关键字读它不算"交出去"。 */
/** {@code id} 有没有落在某个 {@code 名字(…)} 的实参表里;控制语句关键字读它不算"交出去"。 */
private static boolean passedAsArgument(String src, String id) {
Matcher call = CALL_ARGUMENTS.matcher(src);
Pattern use = Pattern.compile("(?<!\\w)" + Pattern.quote(id) + "(?!\\w)");
while (call.find()) {
if (NOT_VALUE_CONSUMERS.contains(call.group(1))) {
for (Call call : callsOf(src)) {
if (NOT_VALUE_CONSUMERS.contains(call.callee())) {
continue;
}
if (use.matcher(call.group(2)).find()) {
if (use.matcher(call.arguments()).find()) {
return true;
}
}
@@ -961,7 +1279,7 @@ class CompanyIdParamGoesThroughReadScopeTest {
*/
boolean hasScopeCall() {
String src = text();
return src.contains(READ_SCOPE_CALL) || src.contains(RESOLVE_SCOPE_CALL);
return anyScopeDoor(src) || src.contains(RESOLVE_SCOPE_CALL);
}
/**
@@ -1005,16 +1323,19 @@ class CompanyIdParamGoesThroughReadScopeTest {
/**
* 断言 D:被绑定到 {@code company_id} 的那个变量名,必须作为<b>整词实参</b>出现在这一支 handler
* 体内某一次 {@code readScope}/{@code resolveScope} 调用的参数表里(单层括号,复用
* {@link #CALL_ARGUMENTS} 的形状,与 A/B/C 同一个 handler 窗口)。
* 体内某一次 {@link #SCOPE_CALLEE_LABEL} 调用的参数表里(实参表由 {@link #callsOf} 按配对括号取,
* 与 A/B/C 同一个 handler 窗口)。
* <ul>
* <li>{@code dataReadScope.readScope(operator, companyId)} ⇒ 绿;</li>
* <li>{@code dataReadScope.readCompanyId(user, companyId)}(第二条正门)⇒ 绿;</li>
* <li>{@code resolveScope(request, companyId)}(私有收口方法内部再去 readScope)⇒ 绿;</li>
* <li>{@code readScope(operator, normalizeCompany(companyId))} ⇒ <b>绿</b>:嵌套写法自 10-05
* 批次 2/3 起算消费(第 13 条:旧单层正则在这一形上判红,而那正是断言 A 逼出来的形状),
* 探针 {@link #SCOPE_NESTED_DOOR_ARG_PROBE};</li>
* <li>{@code dataReadScope.readScope(operator, null)} ⇒ <b>红</b>;</li>
* <li>{@code readScope(operator, operator.getCompanyId())} ⇒ <b>红</b>:源里那个名字是
* {@code CompanyId}(大写 C,整词判据大小写敏感,咬不住它);而 {@link #CALL_ARGUMENTS}
* 只吃单层括号,看不穿 {@code readScope(operator, normalize(companyId))} 这种嵌套写法 ——
* 两种都落在"没进参数表"那一侧(后者是会误伤合规写法的已知形状,见类注释第 11 条与本轮报告);</li>
* {@code CompanyId}(大写 C,整词判据大小写敏感,咬不住它),嵌套层里也确实没有
* {@code companyId} ⇒ 探针 {@link #SCOPE_NESTED_DOOR_ARG_FOREIGN_PROBE},"放宽"的边界由它钉住;</li>
* <li>只在 {@code if (companyId != null)} 里读一次、或只在 {@code @Operation} 文案里提一句
* ⇒ <b>红</b>:控制语句关键字沿用 {@link #NOT_VALUE_CONSUMERS} 那把尺子(与 C 同源,不放宽),
* 而注释与文档行根本进不到 {@link #text()} 里。</li>
@@ -1028,19 +1349,18 @@ class CompanyIdParamGoesThroughReadScopeTest {
+ "Long 变量名 那一形),这支的公司参数是怎么进出口的无从判定 —— 必须人工核对,"
+ "不许当作\"这支没收公司参数\"静默放过";
}
Matcher call = CALL_ARGUMENTS.matcher(text());
Pattern use = Pattern.compile("(?<!\\w)" + Pattern.quote(bound) + "(?!\\w)");
while (call.find()) {
String callee = call.group(1);
// 与 C 同一条纪律:控制语句读它一次不算"把值交给谁";D 只认出口那两个被调名。
for (Call call : callsOf(text())) {
String callee = call.callee();
// 与 C 同一条纪律:控制语句读它一次不算"把值交给谁";D 只认出口那几个被调名。
if (NOT_VALUE_CONSUMERS.contains(callee) || !SCOPE_CALLEES.contains(callee)) {
continue;
}
if (use.matcher(call.group(2)).find()) {
if (use.matcher(call.arguments()).find()) {
return null;
}
}
return " 的公司参数 `" + bound + "` 没进任何 readScope/resolveScope 的实参列表"
return " 的公司参数 `" + bound + "` 没进任何 " + SCOPE_CALLEE_LABEL + " 的实参列表"
+ "(`readScope(operator, null)`、`readScope(operator, operator.getCompanyId())` 就是这个形状:"
+ "参数收下了、出口也调了、算出来的范围也交出去了,唯独 tab 传下来的那个值被换成了别的来源"
+ " ⇒ 接口 200、页面正常、切 tab 数字永远不动,而 A/B/C 三条全绿没人喊)";
@@ -116,4 +116,33 @@ class DataReadScopeTest {
() -> dataReadScope.readScope(user(5L, "admin", null), null))
.isInstanceOf(com.nanri.aiimage.common.exception.BusinessException.class);
}
// ---- 第二条正门:归属已物化成 company_id 列的表(品牌库、商品类目)----
// 这一道门的语义与 readScope 相反方向:返回的是"要筛哪个公司",null = 不筛。
// 非超管一律 null(他们的可见集本来就锁在自己的分组上,再叠一层公司会把"靠分组可见"的行整批删掉,
// 见 DataReadScope#readCompanyId 的注释)。这三条若不写,把 `return null` 改成
// `return companyScope.requireCompanyId(operator)` 不会让任何现有用例变红——而那一改的后果是
// 品牌库里靠分组可见的历史行从每个非超管账号下消失。
@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();
}
}
@@ -0,0 +1,185 @@
package com.nanri.aiimage.common.util;
import com.alibaba.excel.EasyExcel;
import com.nanri.aiimage.common.exception.BusinessException;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
import java.io.ByteArrayOutputStream;
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.Map;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;
import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* ExcelStreamReader 的异常出口契约(现网缺陷:带单元格图片的 xlsx 解析失败时
* POI 的 ExcelAnalysisException 原样冒到 GlobalExceptionHandler,用户拿到 HTTP 500 且看不到真因)。
*/
class ExcelStreamReaderParseFailureTest {
@TempDir
Path tempDir;
/** 生产现场形状:xlsx 包里有一个未声明 content type 的 media 部件。 */
@Test
void parseFailureOnMalformedPackageSurfacesAsIoExceptionWithReason() throws Exception {
Path bad = tempDir.resolve("cellimage-no-content-type.xlsx");
Files.write(bad, packageWithUndeclaredMediaPart());
IOException thrown = assertThrows(IOException.class,
() -> ExcelStreamReader.readFirstSheet(bad.toFile(), noopHandler()));
String reason = rawParseFailureMessageOf(bad);
assertTrue(thrown.getMessage().contains(reason),
"消息里要能看到底层真因 [" + reason + "],实际=" + thrown.getMessage());
}
/** 反向钉:读全部 sheet 的入口同样收口(另有 6 个调用点走这条)。 */
@Test
void parseFailureOnReadAllSheetsAlsoSurfacesAsIoException() throws Exception {
Path bad = tempDir.resolve("cellimage-no-content-type-all.xlsx");
Files.write(bad, packageWithUndeclaredMediaPart());
assertThrows(IOException.class, () -> ExcelStreamReader.readAllSheets(bad.toFile(), noopHandler()));
}
/** 反向钉:调用方在 onRow 里抛的业务异常不能被改写成 IOException,否则 400 语义会塌成"文件坏了"。 */
@Test
void handlerBusinessExceptionIsNotRewrittenIntoIoException() throws Exception {
Path good = writeWorkbook();
BusinessException thrown = assertThrows(BusinessException.class, () -> ExcelStreamReader
.readFirstSheet(good.toFile(), rowHandlerThatThrows(
new BusinessException("品牌列缺失,请检查表头"))));
assertEquals("品牌列缺失,请检查表头", thrown.getMessage());
}
/** 调用方抛的运行时异常原样透传,不借"解析失败"这条路被包成 IOException。 */
@Test
void handlerRuntimeExceptionPropagatesUnchanged() throws Exception {
Path good = writeWorkbook();
IllegalStateException failure = new IllegalStateException("行处理失败");
IllegalStateException thrown = assertThrows(IllegalStateException.class,
() -> ExcelStreamReader.readFirstSheet(good.toFile(), rowHandlerThatThrows(failure)));
assertSame(failure, thrown);
}
/** 调用方抛的受检异常走 IOException 契约,且不把内部包装类漏给调用方。 */
@Test
void handlerCheckedExceptionSurfacesAsIoExceptionWithReason() throws Exception {
Path good = writeWorkbook();
IOException thrown = assertThrows(IOException.class, () -> ExcelStreamReader.readFirstSheet(
good.toFile(), rowHandlerThatThrows(new Exception("行数据超出上限 5000"))));
assertTrue(thrown.getMessage().contains("行数据超出上限 5000"),
"消息里要能看到调用方抛出的真因,实际=" + thrown.getMessage());
}
/** 好文件照旧能读完(保证收口没有把正常路径一起改掉)。 */
@Test
void validWorkbookStillReadsRows() throws Exception {
Path good = writeWorkbook();
StringBuilder seen = new StringBuilder();
assertDoesNotThrow(() -> ExcelStreamReader.readFirstSheet(
good.toFile(), (sheetName, sheetNo, rowIndex, headerMap, rowMap) ->
seen.append(rowMap.get(0))));
assertEquals("Nike", seen.toString());
}
private Path writeWorkbook() {
Path file = tempDir.resolve("ok.xlsx");
List<List<String>> head = List.of(List.of("品牌"), List.of("ASIN"));
List<List<String>> data = List.of(List.of("Nike", "B01ABC"));
EasyExcel.write(file.toFile()).head(head).sheet("Sheet1").doWrite(data);
return file;
}
private ExcelStreamReader.SheetRowHandler noopHandler() {
return new ExcelStreamReader.SheetRowHandler() {
@Override
public void onRow(String sheetName, Integer sheetNo, int rowIndex,
Map<Integer, String> headerMap, Map<Integer, String> rowMap) {
}
};
}
private ExcelStreamReader.SheetRowHandler rowHandlerThatThrows(Exception failure) {
return new ExcelStreamReader.SheetRowHandler() {
@Override
public void onRow(String sheetName, Integer sheetNo, int rowIndex,
Map<Integer, String> headerMap, Map<Integer, String> rowMap) throws Exception {
throw failure;
}
};
}
/** 直接喂同一个坏包,取 POI 自己报出来的真因文本,用来断言它没被收口吞掉。 */
private String rawParseFailureMessageOf(Path badFile) throws IOException {
String message = null;
try (var input = Files.newInputStream(badFile)) {
EasyExcel.read(input).sheet(0).headRowNumber(1).doRead();
throw new AssertionError("构造的坏包必须让 EasyExcel 抛异常,否则这条用例证明不了收口");
} catch (RuntimeException ex) {
Throwable deepest = ex;
while (deepest.getCause() != null) {
deepest = deepest.getCause();
}
message = deepest.getMessage();
}
assertTrue(message != null && message.length() > 20,
"底层真因文本应当有信息量,实际=" + message);
return message;
}
private byte[] packageWithUndeclaredMediaPart() throws IOException {
ByteArrayOutputStream bytes = new ByteArrayOutputStream();
try (ZipOutputStream zip = new ZipOutputStream(bytes, StandardCharsets.UTF_8)) {
put(zip, "[Content_Types].xml", """
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
<Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>
<Default Extension="xml" ContentType="application/xml"/>
<Override PartName="/xl/workbook.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"/>
</Types>""");
put(zip, "_rels/.rels", """
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
<Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="xl/workbook.xml"/>
</Relationships>""");
put(zip, "xl/workbook.xml", """
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
<sheets><sheet name="Sheet1" sheetId="1" r:id="rId1"/></sheets>
</workbook>""");
put(zip, "xl/_rels/workbook.xml.rels", """
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
<Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/cellImages" Target="cellimages.xml"/>
</Relationships>""");
put(zip, "xl/cellimages.xml", """
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<cellImages xmlns="http://www.wps.cn/officeDocument/2020/cellImage"/>""");
zip.putNextEntry(new ZipEntry("xl/media/cellimage1.jpeg"));
zip.write(new byte[]{(byte) 0xFF, (byte) 0xD8, (byte) 0xFF, (byte) 0xD9});
zip.closeEntry();
}
return bytes.toByteArray();
}
private void put(ZipOutputStream zip, String name, String content) throws IOException {
zip.putNextEntry(new ZipEntry(name));
zip.write(content.getBytes(StandardCharsets.UTF_8));
zip.closeEntry();
}
}