Files
crawler-plugin/backend-java/src/test/java/com/nanri/aiimage/config/CatchSilenceRatchetTest.java
T
huangzd1997 62a1b50067 feat(phase-3): AC-9~12 后端任务引擎稳定性(队列隔离/心跳降级/清理瘦投影/终态与超时)
- AC-9(S1-B2/B3):视频/图像任务改走独立 videoQueueExecutor(aiimage.task-queue.video-max-concurrent,
  默认 6),不再与结果文件组装共用 12 格 taskQueueExecutor;TaskQueueGate 增 queue 标签区分指标;
  scheduled worker 本地派发被拒改回队(requeue),不再压回 16 线程调度池内联组装。
- AC-10(S1-B4):CollectDataService.updateProgress 去掉任务锁,改无条件短事务 + updated_at 乐观 CAS,
  只写 result_json/updated_at 两列;TaskHeartbeatService 对 SPI 进度写异常降级,
  TaskHeartbeatVo 新增 progressDegraded/warning,alive 仍为 true。
- AC-11(S1-B5/B6):ModuleHistoryCleanupService 批查与四路指针查询全部瘦投影;
  application.yml 增 server.shutdown=graceful 与 spring.lifecycle.timeout-per-shutdown-phase=30s;
  虚拟线程池 destroy 改为 await 在途任务(上限 aiimage.task-queue.shutdown-await-seconds)。
- AC-12(S1-B1/B7/B8/B9):PENDING 僵尸重试计数可到 MAX 并就地翻 FAILED 进 exhaustedJobs;
  修正 selectAdminTaskDetail 的双转义(>= -> >=)并按真实 SQL 修正迁移基准账本;
  MyBatis default-statement-timeout=60s(AIIMAGE_DB_DEFAULT_STATEMENT_TIMEOUT_SECONDS);
  店铺数据两处删除收进 @Transactional,对象回收沿用 afterCommit 注册。
- 契约激活:PendingPhase3*Test 14 例全部去 @Disabled;同步改写被新契约反转的既有判据
  (CollectDataProgressThrottleTest 锁/updateById 口径、OwnerRouting 的内联分支改显式关闭派发形态、
  FaultInjection 指标按新 queue 标签查找)与三处棘轮(catch total 1031->1034、
  notRethrow 582->585、超管调用点 17->18,均逐条记名)。
2026-10-28 21:05:33 +08:00

679 lines
51 KiB
Java
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
package com.nanri.aiimage.config;
import com.nanri.aiimage.config.SilentCatchScanner.Kind;
import com.nanri.aiimage.config.SilentCatchScanner.Result;
import com.nanri.aiimage.config.SilentCatchScanner.Site;
import org.junit.jupiter.api.Test;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.LinkedHashMap;
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.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* catch 静默形状的**只许减**棘轮。
*
* <p>统计三件事(口径写死在这里,防止又变成"把文件数当处数"):
* <ul>
* <li>统计命令:{@code SilentCatchScanner.scanTree(src/main/java)}(本类的 {@link #TREE});</li>
* <li>分母是哪棵树:{@code crawler-plugin/backend-java/src/main/java} 工作树,只算 {@code *.java};</li>
* <li>单位:处(一个 catch 块 = 一处)。</li>
* </ul>
*
* <p>基线来源:2026-10-08 12:0x 实测(HEAD {@code 274ad017})total=1000 / 不重抛=559 /
* 只 log=249 / 空体=56。本轮改动往 main 里加了 **1 处** catch(拒起闸门读基线时的
* {@code catch (IOException e} ⇒ 重抛成 IllegalStateException),它是 RETHROW 形状、
* 不进气味三格,所以 total 基线随之从 1000 抬到 1001;那三格的基线一个字没动。
*
* <p>"只 log" 这一格本轮按严格口径重测得 <b>172</b>(块内每条顶层语句都是 log 调用才算),
* 低于用户给的 249——两边口径不同(宽松版把"log + 紧跟 return null"也算进去)。
* 这里两条都钉:≤249 是验收口径,≤172 是本轮严格口径的实测值,
* 免得日后有人拿"249 还没用完"当额度往里加只 log 的吞异常块。
*/
class CatchSilenceRatchetTest {
/** 分母树:main 源码树(不含测试树——测试里的 catch 是夹具,不是现网出口)。 */
private static final Path TREE = moduleRoot().resolve("src/main/java");
// ==== 验收基线(用户 2026-10-08 12:0x 实测,HEAD 274ad017,单位:处)====
// 10-17 心跳证据两处 fail-open 抬 559 -> 561,逐处出处见 STRICT_NOT_RETHROW 上方注释。
// 10-18 外观专利失败兜底自吞抬 561 -> 562,逐处出处同下。
// 10-24 损耗监控三处带锚点的 fail-open 抬 562 -> 564,逐处出处见 STRICT_NOT_RETHROW 上方注释。
// 10-25 B15 join 无界收口抬 564 -> 569,逐处出处见 STRICT_NOT_RETHROW 上方注释。
// 10-26 第二轮 CR-Fix 2 抬 569 -> 573,逐处出处见 STRICT_NOT_RETHROW 上方注释(4 处必要 fail-open)。
static final int GIVEN_TOTAL = 1000;
// 10-27 「整表都要跑完」专项抬 573 -> 577(2 枚新增不重抛 + 2 枚既有整批抛出改逐条跳过,逐处记名见 STRICT_TOTAL 上方)。
// 10-27 同日第二批抬 577 -> 579(批量入库逐批容错+folder 去重逐条目容错,两处都是 log.warn+计数+continue,
// 逐处记名见 STRICT_TOTAL 上方注释)。
// 10-28 V179 采集被过滤行追溯抬 579 -> 582(审计件三枚:逐批插入容错/回流簿记容错/尾 sheet 降级,
// 逐处记名见 STRICT_TOTAL 上方注释)。
// 10-28 Phase 3 抬 582 -> 585(心跳降级一枚 + 优雅停机两枚中断恢复,逐处记名见 STRICT_TOTAL 上方注释)。
static final int GIVEN_NOT_RETHROW = 585;
static final int GIVEN_LOG_ONLY = 249;
static final int GIVEN_EMPTY = 56;
// ==== 本轮严格口径重测(SilentCatchScanner 在同一棵树上跑出来的四个数)====
// total 里含本轮拒起闸门新加的那 1 处:它是 RETHROW 形状(catch (IOException e) ⇒ 抛 IllegalState),
// 所以 rethrow 385→386、total 1000→1001,而气味三格一个都没动:
// notRethrow 559、empty 56 与验收基线**逐字相同**,这就是两套口径互为对账的证据。
/**
* 1000(验收基线)+ 拒起闸门那批新增的 1 处 + {@code BuildInfoLogger.read()} 的 1 处 = 1002。
* BuildInfoLogger 那一处不是吞掉:它打 {@code [build-info-missing]} 的 WARN 并返回可区分的
* "章存在但没盖住"状态,巡检按锚点数得到。抬这一格是为了把出处留在这份 diff 里,
* 而不是让后来人以为基线是自然涨上来的。
* 10-17 再 +2,逐处记名:{@code TaskHeartbeatLivenessService.stamp()}(心跳证据写失败只 WARN,
* 心跳接口不许因证据写不下去而 500)与同类 {@code lastHeartbeatMillis()}(读证据失败一律落到 0=
* 「没有证据」,判死线据此放宽)。两处都是 fail-open 且方向是「少杀一个任务」,与上面
* BuildInfoLogger 同形状;本仓实测基线由 1001 起(原记 1002 留有 1 格无人认领的额度),
* 加这 2 处后实测 1003。
* 10-18 再 +1:{@code AppearancePatentTaskService.fallbackAssembleResultFile()} 的兜底自吞
* (log.warn + return false)——{@code ResultFileJobHandler#fallbackAssembleOnFailure} 的接口
* 契约明确要求「实现应自吞异常(兜底失败只记日志,不影响 job 已终态失败的事实)」,与
* DeleteBrandRunService 同名兜底同形状;Worker 侧另有 catch 双保险,让判死作业的兜底每轮
* stuck 扫描幂等重入。实测 1004。
* 10-24 损耗监控(cost-guard)本笔新增 6 处,逐处点名(同批先写后摘、没留在树上的 6 处:
* SHA-256 指纹改走 {@code DigestUtil.sha256Hex}、env 读数改纯正则前置校验、共享密钥扫描的
* 自吞交给 {@code scan()} 已有的那枚、当日用量读数改成直接抛(客户端把轮询失败当
* 「维持上一次读数」处理,比伪造一组零值诚实)、{@code resume()} 的吞异常改成外抛——
* 它返回 false 时控制器仍回「已继续任务」,那是假成功):
* <ul>
* <li>{@code LlmKeyGate.Gate.acquire()} 两枚:{@code InterruptedException} ⇒ 复位中断位并重抛
* IllegalStateException;{@code RuntimeException} ⇒ 先 {@code permits.release()} 再原样重抛,
* 少了这一处排队令牌就永久漏一个(两枚都是 RETHROW 形状);</li>
* <li>{@code LlmKeyGate.Gate.waitForInterval()} 一枚:同为 InterruptedException 重抛形状;</li>
* <li>{@code CostGuardScheduler.scan()} 一枚:调度线程整轮异常只打 {@code [cost-guard]} WARN,
* 下一轮照跑——让它抛出等于这条监控自己变成噪声源;</li>
* <li>{@code UserTaskGuardService.pause()} 一枚:单个账号的暂停写失败不能中止整轮扫描
* (否则排在这之后的账号这轮全不被检查),下一轮还会再判一次;</li>
* <li>{@code UserTaskGuardService.load()} 一枚:读不到闸门状态按「未暂停」走——数据库抖动
* 不该把全体用户的合法任务一起冻住,真失控由下一轮重新置位。</li>
* </ul>
* 本格实测 1004:这 6 处落进的是 1004 之前已被更早删腾出、无人认领的额度里(上一笔整树实测
* 997,见 RETHROW_FLOOR 上方),所以基线不抬反而按实测收到 1003;**再 +1 是同一时段
* {@code ba20f5ed feat(workbench-client)} 那枚新增 catch,不属本批、也未由本批记名**,
* 该由那一笔自己把出处补进这份 diff。每一处本批的新增都在这里点名。
* 不重抛/只 log/空体三格上限一个字没动。
*
* <p>10-24 Phase 7 EasyExcel→POI 收口再 +4,逐处点名(全部是 RETHROW 形状,气味三格未动):
* <ul>
* <li>{@code ExcelStreamReader.readOoxml} 三枚:{@code OpenXML4JException}(坏包)、
* {@code SAXException}(sheet XML 坏了)、{@code RuntimeException}(POI 解析期异常)
* 全部经 {@code toContractException} 转成 IOException 或原样重抛,不吞;</li>
* <li>{@code ExcelStreamReader.readHssf} 一枚:{@code RuntimeException} 同上收口。</li>
* </ul>
* 这 4 处是替换 EasyExcel 监听器后的等价出口(原实现的 catch 只在 {@code runRead} 一处,
* 但监听器内部另有 POI 的异常分诊);实测 total 1008。
*
* <p>10-25 B15 任务活性收口再 +10(同时替换掉 2 处 join 侧的旧 catch,整树实测 1015),
* 逐处点名——{@code join()} 没有时间界,下面四类出口改成带截止的等待后,超时必须各有去处:
* <ul>
* <li>{@code FutureDeadline.await} 一枚:超时先 cancel 该 future,再重抛带标签的
* TimeoutException(RETHROW);</li>
* <li>{@code AppearancePatentLlmClient.runBatches} 两枚:超时/执行失败与中断都收口成该批
* {@code BatchOutcome} 失败(NOT_RETHROW,替换原来那一枚 {@code catch (Exception)});</li>
* <li>{@code BrandTaskService.buildAndUploadResult} 三枚:超时/中断/执行失败按 IOException
* 或原异常重抛(RETHROW,替换原来那一枚 {@code catch (CompletionException)});</li>
* <li>{@code SimilarAsinLlmService} 的类目与合规两个 prepass 各两枚:超时/执行失败只 WARN
* 并继续(LOG_ONLY),中断复位中断位后退出等待(NOT_RETHROW)。这两处预计算本就是
* 逐行链路的缓存,缺结果的行会走单行回退,所以等待侧超时不需要炸掉整条任务。</li>
* </ul>
* 同批实测 notRethrow 569、logOnly 176、empty 56;气味三格只按这三处实测值抬,形状未放宽。
*
* <p>10-26 抬 1015 -> 1024(第二轮 CR-Fix 2,共 9 处新增 catch,逐处记名):
* <ul>
* <li>{@code WorkbenchClientPackageService.confirmPackage} 一枚:{@code DuplicateKeyException}
* 并发冲突按 objectKey 幂等或转业务错误(RETHROW);</li>
* <li>{@code WorkbenchClientPackageService.rejectCredentialFiles} 两枚:{@code BusinessException}
* 原样重抛、{@code IOException} 清对象后转业务错误(RETHROW);</li>
* <li>{@code WorkbenchClientPackageService.removeRejectedObject} 一枚:{@code RuntimeException}
* 清理失败只 WARN,不让存储异常盖掉业务错误(LOG_ONLY);</li>
* <li>{@code WorkbenchClientPackageService.deleteTempQuietly} 一枚:{@code IOException}
* 删临时文件失败只 WARN(LOG_ONLY);</li>
* <li>{@code OssStorageService.downloadWorkbenchClientObjectToTempFile} 两枚:外层
* {@code Exception} 转 {@code storageFailure} 重抛(RETHROW),内层清理失败只 WARN(LOG_ONLY);</li>
* <li>{@code CostGuardScheduler} 一枚:平台自费告警推送失败只 WARN 并保留基线待下轮重试
* (NOT_RETHROW,log+return);</li>
* <li>{@code SimilarAsinLlmService} 一枚:{@code InterruptedException} 恢复中断位后上抛
* (RETHROW)。</li>
* </ul>
* 9 处均为 CR-02/05/10/20 的必要出口,不是把已有异常改回吞掉;同批实测 total 1024、
* notRethrow 573、logOnly 179、empty 56。
*
* <p>10-27 整表跑完专项抬 1024 -&gt; 1026(用户口径:整表都要跑完,单项坏了跳过它继续下一项,
* 只有 LLM 密钥欠费/失效那一类才允许直接判任务失败),逐处记名:
* <ul>
* <li>{@code BrandTaskStorageService.rebuildAggregate} 一枚:单片载荷读不到时
* log.warn+记跳片号+{@code continue}(NOT_RETHROW)。此前一片抛就把整份聚合丢掉,
* 而三个调用方(finalizeTask/abort/tryRecoverCompletedRunningTask)都没有就地 try,
* 一个坏分片=整任务不产出;同批把 {@code completed} 的判据从 {@code chunks.size()}
* (DB 行数)改成「真正读到的片数」,缺数据不再被判成已收齐。</li>
* <li>{@code AppearancePatentLlmBatchPipeline.collectPendingLlmCandidates} 一枚:
* 同为 log.warn+计数+{@code continue}(NOT_RETHROW)。collect 跑在批循环<b>之前</b>,
* 一抛就走不到循环体内那道 {@code finally releaseRowInspection},本轮已申领的行要挂满
* 处理中 TTL(15 分钟),且 {@code terminalizeRoundExhaustedRows} 跟着一起不执行。</li>
* </ul>
* 另有两枚<b>既有</b> RETHROW 出口按同一口径改成「跳过该项」,形状从 RETHROW 迁入气味两格
* (total 不变、rethrow −2、notRethrow +2、logOnly +2):{@code BrandTaskStorageService.getParsedPayload}
* 与 {@code BrandTaskStorageService.getAllFileAggregates}——两处此前一个文件的缓存/聚合读不到
* 就整批抛,把已读到的其余文件一起抹掉;改后逐条 WARN 跳过,调用方按「尚未收齐」可重试。
* ⚠ 这两处不是把异常静默吞掉:跳过都带 {@code [brand-storage]} 锚点 WARN,且
* {@code BrandTaskStorageServiceFaultToleranceTest} 钉住「其余项照常出」与
* 「全项坏掉仍大声抛」两条,缺数据一律不得冒充已完成。
* 同批实测 total 1026、rethrow 393(仍高于下限 380,本格不动)、notRethrow 577、logOnly 181、empty 56。
*
* <p>10-27 同日第二批(B49 非 ★ 收尾)再抬 total 1026 -&gt; 1028、notRethrow 577 -&gt; 579,逐处记名:
* <ul>
* <li>{@code QueryAsinService.flushInsert} 一枚:ASIN 导入按批 try/catch,坏批点名后其余批照常入库
* (此前坏批直接冒到 {@code runImportTask},后面的批次一个都跑不到),log.warn+计数(NOT_RETHROW);
* 有坏批时任务落 failed——admin 页只在 failed 分支显示 errorMessage,留在 success 就是
* 把"没入库"说成"导入完成"。</li>
* <li>{@code DedupeRunService.packageFolderDedupeResultsAsZip} 一枚:folder 模式逐条目容错,
* 一个都没写进时拒绝交空包(NOT_RETHROW);aborted 仍落 FAILED,非 folder 分支零改动。</li>
* </ul>
* 第三处 {@code PublishTaskService} 只改文案、不加 catch;SUCCESS 的
* {@code file_task.error_message} 保持留空(缺口写 {@code biz_file_result.error_message}),
* 因为 {@code TaskRetryEligibility}/{@code SimilarAsinStaleReopenSupport} 会按 errorMessage
* 字面量分类,写进去等于替一条正常任务编一个失败理由。
* 同批实测 total 1028、rethrow 393(未动)、notRethrow 579、logOnly 181(未动)、empty 56(未动)。
*
* <p>10-28 采集「被过滤行」追溯(V179,结果 Excel 第 3 个 sheet)抬 total 1028 -&gt; 1031,逐处记名。
* 三枚都是<b>审计件不得打掉交付</b>那一形,块体各只有一句带 {@code [collect-data]} 锚点的 WARN:
* <ul>
* <li>{@code CollectDataFilteredRowStore.writeBatch} 一枚:被过滤行按批 INSERT,坏批点名后
* 其余批照常落库(口径照 {@code CollectDataInvalidAsinBatchWriter})。这份明细不参与任何
* 判定,为它打掉用户已采回的数据是拿可追溯性换交付;跳过的批会从四类计数与已落库行数
* 的差里冒出来,sheet 上写「另有 N 行未逐条记录」,不是静默少给。</li>
* <li>{@code CollectDataFilteredRowStore.markResolved} 一枚:补测回流只盖时间戳+追加一句。
* 必要性是实测的——{@code CollectDataBrandRecheckScheduler} 抓住 {@code apply()} 的抛出后
* <b>整组留队重放</b>,这里若外抛,一次簿记失败会让已注入的任务永远重排。</li>
* <li>{@code CollectDataExcelAssemblyService.writeFilteredSheet} 一枚:尾 sheet 读不动就交付
* 前两表、缺这张审计表。同批我先写的第二枚("清单不完整"那行的内层 catch)已删掉:
* 那只是本地 POI 写,写不动说明整份 workbook 都写不动,该由
* {@code writeWorkbookStreaming} 的既有出口处理,与前两张 sheet 同姿势。</li>
* </ul>
*
* <p>10-28 Phase 3(v1.1 后端任务引擎稳定性)抬 total 1031 -&gt; 1034,三处逐条记名:
* <ul>
* <li>{@code TaskHeartbeatService.touchFileTaskIfRunning} 一枚:模块进度写抛任何运行时异常
* (S1-B4 的 40902 就是这一类)都降级成 {@code progressDegraded=true},块体一条 WARN 带
* taskId/moduleType;不接住就等于心跳继续 500/40902,客户端会当"任务不在了"。</li>
* <li>{@code TaskFileJobConfig.taskQueueVirtualThreadExecutor} 的 {@code shutdown()} 一枚:
* await 期间被中断只恢复中断标记(S1-B6 优雅停机),不吞别的东西。</li>
* <li>{@code TaskFileJobConfig.videoQueueExecutor} 一枚:信号量 acquire 被中断只恢复中断标记
* (S1-B2 视频独立许可,照抄 taskQueueExecutor 的既有形状)。</li>
* </ul>
*/
static final int STRICT_TOTAL = 1034;
/**
* 重抛型 catch 的**下限**(不是上限):本轮把两处吞异常改成重抛之后实测 388。
* 这一格只能涨不能跌——它是"异常会往外走"的总量,把它钉成"只许减"就等于拦着别人修吞异常。
*/
// 10-09 下调 388 -> 387,出处点名:提交 b633bd48「摘 13 处零引用私有方法」删掉了
// DeleteBrandRunService 里一个无人调用的私有方法,它的 catch 体是
// `throw new BusinessException("生成删除品牌结果文件失败: " + ...)` —— 那是 RETHROW 形状,
// 随死代码一起离开树;实测重抛数 387、不重抛与只 log 两数未涨 ⇒ 没有任何一处"异常会往外走"
// 被改回吞掉。这一格的本意是"重抛只许涨不许跌",所以调基线必须带着这样的逐处出处;
// 拿"总数变小了"当理由不算——那种情况下真正要看的是不重抛那一侧有没有涨。
// 10-09 再下调 387 -> 386,出处点名:去重库按公司收口那一笔删掉了 DedupeTotalDataService.deleteFromExcel
// 的两个零调用者重载,其中 `throw new BusinessException("删除 Excel 匹配数据失败", e)` 是 RETHROW 形状,
// 随死代码一起离开树;实测重抛 386、不重抛与只 log 两数未涨(那两格仍绿)=> 没有任何一处「异常会往外走」被改回吞掉。
// 10-19 再下调 386 -> 385,出处点名(用户授权「逐处记名调这一格」):Phase 3 的 3B 迁移把
// ShopDataCrawlTaskService 的私有 `writeJson(Object, String)` 并进底座已有的
// `AbstractFileTaskPipeline.writeJson(ObjectMapper, Object, String)`——那一枚 catch 的体是
// `throw new BusinessException(message)`(RETHROW 形状、不带 cause),本支文案「序列化店铺数据抓取结果分片失败」
// 逐字带到调用点,失败形状与线协议一字未动(golden 的 submit-result 分片各例对撞相等)。
// 四份逐字同名件并成一份 ⇒ 树里少了一处「异常会往外走」的**实例**,不是少了一种会外走的异常;
// 本笔只从树上摘掉这一处 RETHROW 形状的 catch,不重抛侧一个字节没动:同批实测 notRethrow 562、
// logOnly 173、empty 55 三格仍在上限内(未涨)=> 没有任何一处出口被改回吞掉。
// 10-19 再下调 385 -> 383,出处点名(同一项用户授权「逐处记名调这一格」的第二笔,形状与上一笔逐字相同):
// Phase 3 的 3A 迁移把 AppearancePatentTaskService 的两处同名序列化 catch 并进底座
// `AbstractFileTaskPipeline.writeJson(ObjectMapper, Object, String)`——① 私有
// `writeJson(Object, String)`(体是 `throw new BusinessException(message)`,7 个调用点的文案逐字
// 带到调用点);② 建单里那段 `try { setRequestJson(writeValueAsString(request)) … } catch (Exception ex)
// { throw new BusinessException("序列化解析结果失败") }`,失败形状与线协议一字未动。
// 本笔另摘的三枚零调用私有件(abbreviate/resultLookupKeysForResultRows/isHistoryFileBuilding)
// 里没有 catch,所以 RETHROW 只降这两格;不重抛/只 log/空体三格同批复跑未涨(三格判据一条没放宽)。
// 10-19 再下调 383 -> 381,出处点名(同一项用户授权的第三笔,形状与上一笔逐字相同):
// Phase 3 的 3C 迁移把 CollectDataService 的两处序列化 catch 并进底座
// `AbstractFileTaskPipeline.writeJson(ObjectMapper, Object, String)`——① 私有
// `writeJson(Object, String)`(体是 `throw new BusinessException(message)`,唯一调用点的文案
// 「采集结果序列化失败」逐字带到调用点);② 建单 `persistParsedTask` 里那段
// `try { setRequestJson(writeValueAsString(…)) … setResultJson(writeValueAsString(…)) }
// catch (Exception ex) { throw new BusinessException("序列化任务信息失败") }`。
// 两支文案、异常类型、不带 cause 这三条线协议事实一字未动(golden 建单 4 段+回传 15 段逐字节相等)。
// ⚠ 本支还有第三处同形状(`persistStats` 的 try 包 15 行 put 加一次序列化),**这笔没并它**:
// 用户授权的范围是两处,第三处要再降一格须另行记名。不重抛/只 log/空体三格同批复跑未涨
// ——这三格是上限、且常量就等于上一次记下的实测值,所以「绿」本身就证成「未涨过那一数」。
// ⚠ 历史数不等于现状数(本笔踩过,记法留在这里给下一个读的人):total 是**上限**,
// 只在新增加时红,删掉 catch 从不回头核对 ⇒ 常量上方那些「实测 1003/1004」会与现实脱钩。
// 复现办法(本笔实测用过的):把 STRICT_TOTAL 与三格上限临时压到 0、把本格下限抬到 99999,
// 单跑本类一次,断言文案里就是当前整树实测值。本笔读到的数是 **total=998、rethrow=381**;
// 与 1004 差的那 6 格里本笔只占 2(另 4 处是更早几笔静默摘掉的,不在本笔账上、也无从追认)。
// 判据一格未放宽:本格仍按实测下限钉住,四格上限原样不动(要收紧得逐处记名另笔请示)。
// 10-19 再下调 381 -> 380,出处点名(同一项授权的续笔,用户 2026-10-19 拍板「按顺序」第①项):
// 3C 第五笔把 CollectDataService 的**第三处**同形状序列化 catch 并进同一枚底座件——
// `persistStats` 那段 `try { 15 行 payload.put(…) … task.setResultJson(writeValueAsString(payload)) }
// catch (Exception ex) { throw new BusinessException("保存采集统计失败") }`。文案、异常类型、
// 不带 cause 三条线协议事实逐字带到调用点(回传 15 段 golden 逐字节复现,那 15 段每段都过这一格)。
// 并档顺带把捕获面从「建 map +序列化」收回「序列化」:LinkedHashMap.put 对这些值不可能抛,
// 所以没有出口被改回吞掉;不重抛/只 log 两格的上限值恰等于上一次记录的实测值(562/173),
// 绿即证这两格未涨;⚠ empty 那格常量是 56 而上一次记录是 55,绿只证「≤56」、不证未涨——
// 别把这句读成三格都被重新证明过。
// 整树实测(复现办法同上:上限压 0、下限抬 99999 各单跑本类一次):**total=997、rethrow=380**
// (上一笔读的是 998/381,本笔各 −1,与本笔摘掉的那一处 RETHROW 形状对得上账)。
static final int RETHROW_FLOOR = 380;
/**
* 10-17 抬 559 -> 561,逐处记名(两处都是新增的 fail-open 证据读写,不是把已有出口改回吞掉):
* 1){@code TaskHeartbeatLivenessService.stamp()}:心跳证据写失败只 WARN——心跳接口不许因为
* 「记不下证据」而 500,那会让客户端整轮心跳线程崩掉,反而制造更多孤儿任务;
* 2){@code TaskHeartbeatLivenessService.lastHeartbeatMillis()}:读证据失败一律落到 0=「没有证据」,
* 判死线据此**放宽**(顶多让任务多活一会儿,最终仍由未启动宽限与 stale-repair 兜底)。
* 两处的误差方向都是「少杀一个任务」,与这一格想拦的「异常到此为止、外面看不见」不同性质;
* 抬格是为了把出处留在这份 diff 里,而不是让后来人以为基线自然涨上来的。
* 10-18 抬 561 -> 562,逐处记名:{@code AppearancePatentTaskService.fallbackAssembleResultFile()}——
* 失败兜底组装的自吞出口(接口契约要求,见 {@code ResultFileJobHandler#fallbackAssembleOnFailure}),
* 与 {@code DeleteBrandRunService.fallbackAssembleResultFile} 同形状、同性质:兜底失败不得掩盖
* 作业已终态失败的事实,也不得打断 stuck 扫描对终态失败作业的幂等重入。形状是 log+return false,
* 因此只进本格与 total,不进 STRICT_LOG_ONLY(严格口径不数 log 后接 return)。
* 10-24 抬 562 -> 564,逐处记名(损耗监控 cost-guard 的三处 fail-open,都带 {@code [cost-guard]}
* 日志锚点、巡检按锚点数得到,不是「异常到此为止外面看不见」那种无声出口):
* 1){@code CostGuardScheduler.scan()}:整轮扫描异常只 WARN——这条监控抛出就等于自己变成
* 现网噪声源,而下一轮 fixedDelay 照跑,暂停判定不会因此停摆;
* 2){@code UserTaskGuardService.pause()}:单个账号的暂停写失败若外抛,{@code runOnce} 的
* 逐账号循环就地中止,排在这之后的账号这一轮全部不被检查(最坏晚一个间隔才暂停=多烧钱);
* 3){@code UserTaskGuardService.load()}:读不到闸门状态按「未暂停」走——一次库抖动不该把
* 全体用户的合法任务一起冻住,真失控由下一轮扫描重新置位(方向是「少冻一个号」)。
* 其中 1)、2) 块体只有一句 log,故同时进 STRICT_LOG_ONLY;3) 是 log+return,不进。
* 同批先写后摘、没留在树上的 6 处静默出口见 total 那一格的点名。
* 10-25 抬 564 -> 569,逐处记名(B15 join 无界收口,共 6 处新增不重抛、替换掉 1 处旧的):
* {@code AppearancePatentLlmClient.runBatches} 两枚(超时/执行失败、中断各收口成该批失败),
* {@code SimilarAsinLlmService} 类目与合规两个 prepass 各两枚(超时/执行失败只 WARN,
* 中断复位中断位后退出等待)。两处预计算的缺行都会走单行回退,不是把已有出口改回吞掉。
* 10-26 抬 569 -> 573(第二轮 CR-Fix 2,4 处新增不重抛,逐处记名):
* {@code WorkbenchClientPackageService.removeRejectedObject}(清理失败只 WARN,不让存储异常
* 盖掉业务错误)、{@code deleteTempQuietly}(删临时文件失败只 WARN)、
* {@code OssStorageService.downloadWorkbenchClientObjectToTempFile} 内层清理(同上)、
* {@code CostGuardScheduler}(平台自费告警推送失败 log+return,保留基线待下轮重试)。
* 四处的误差方向都是「不让清理/告警失败掩盖主错误」,不是把异常静默吞掉。
* 10-27 抬 573 -> 577(「整表都要跑完」专项,4 处不重抛,逐处记名见 STRICT_TOTAL 上方注释):
* 新增 {@code BrandTaskStorageService.rebuildAggregate} 与
* {@code AppearancePatentLlmBatchPipeline.collectPendingLlmCandidates} 两枚逐片跳过;
* 另有 {@code BrandTaskStorageService.getParsedPayload}/{@code getAllFileAggregates} 两枚
* 既有「整批抛出」出口按同口径改成逐条跳过(自 RETHROW 迁入本格)。
* 10-27 同日第二批再抬 577 -&gt; 579(2 枚逐批/逐条目容错:{@code QueryAsinService.flushInsert}
* 与 {@code DedupeRunService.packageFolderDedupeResultsAsZip},块体都是 log.warn+计数,
* 坏项点名、其余照常交付,逐处记名见 STRICT_TOTAL 上方注释)。
* 10-28 再抬 579 -&gt; 582(V179 采集「被过滤行」三枚审计件容错:{@code CollectDataFilteredRowStore.writeBatch}
* 逐批插入、{@code CollectDataFilteredRowStore.markResolved} 回流簿记、
* {@code CollectDataExcelAssemblyService.writeFilteredSheet} 尾 sheet 降级;三处都是带
* {@code [collect-data]} 锚点的 log.warn+善后,块体除第一枚外各带一句状态置位/返回值,
* 逐处记名见 STRICT_TOTAL 上方注释)。
* 10-28 Phase 3 再抬 582 -&gt; 585(后端任务引擎三枚,均为「异常到此为止」的必要形状):
* {@code TaskHeartbeatService.touchFileTaskIfRunning}(S1-B4 进度写降级成 progressDegraded,
* 块体 log.warn 带 taskId/moduleType)、{@code TaskFileJobConfig.taskQueueVirtualThreadExecutor}
* 的 {@code shutdown()} 与 {@code TaskFileJobConfig.videoQueueExecutor}(S1-B6/S1-B2,
* {@code InterruptedException} 只恢复中断标记),逐处记名见 STRICT_TOTAL 上方注释。
*/
static final int STRICT_NOT_RETHROW = 585;
/**
* 10-17 抬 172 -> 173,出处就是上面点名过的 {@code TaskHeartbeatLivenessService.stamp()}:
* 块体只有「取到 key 名 + log.warn」一句,写心跳证据失败时既不重试也不抛出——
* 心跳接口不许因为「记不下证据」而 500。同类的 {@code lastHeartbeatMillis()} 读失败还要
* 落 0 返回,形状是 log+return 默认值,因此不进这一格。
* 10-24 抬 173 -> 175,出处即上面 STRICT_NOT_RETHROW 里点名过的 cost-guard 两处:
* {@code CostGuardScheduler.scan()} 与 {@code UserTaskGuardService.pause()}——块体各只有一句
* {@code log.warn}/{@code log.error},都是带锚点的 fail-open,不是把已有出口改回吞掉。
* 10-25 抬 175 -> 176,出处即上面点名过的 {@code SimilarAsinLlmService} 类目/合规 prepass
* 两个超时出口之一(两处形状相同,其中一处按块内语句判定落进本格,另一处因复位中断位
* 多一条语句只进 NOT_RETHROW)。块体只有一句带 {@code [similar-asin][llm]} 锚点的 WARN,
* 缺结果的行走单行回退,不是无声吞掉。
* 10-26 抬 176 -> 179(第二轮 CR-Fix 2,3 处新增 log-only):{@code WorkbenchClientPackageService}
* 的 removeRejectedObject/deleteTempQuietly 与 {@code OssStorageService} 的临时文件清理内层,
* 三处都只 WARN 且带 path/objectKey 锚点;主错误由外层重抛,清理失败不得盖掉它。
* 10-27 抬 179 -> 181(「整表都要跑完」专项,2 处):{@code BrandTaskStorageService.getParsedPayload}
* 与 {@code getAllFileAggregates} 的逐条跳过出口——块体各只有一句带 {@code [brand-storage]}
* 锚点的 WARN。两处此前是「一个文件坏 ⇒ 整批抛出」,改后其余文件照常返回,坏的那条点名可查;
* 同批 {@code rebuildAggregate} 与外观专利候选收集因块内另有计数/continue 只进 NOT_RETHROW。
* 10-28 抬 181 -> 182(V179 采集「被过滤行」的 {@code CollectDataFilteredRowStore.writeBatch}):
* 块体只有一句带 {@code [collect-data]} 锚点的 WARN(taskId+chunk+err),坏批点名后其余批照常
* 落库。同批另两处({@code markResolved} 追加 return、{@code writeFilteredSheet} 置 incomplete 位)
* 因块内多一句只进 NOT_RETHROW。
*/
static final int STRICT_LOG_ONLY = 182; // 严格口径:块内每条顶层语句都是 log 调用才算
static final int STRICT_EMPTY = 56;
/**
* 注释/字符串/文本块里的 {@code "catch ("} 字样条数。本轮实测 **0**——
* 于是"扫描器 total == grep 字面量口径"这条等式是**直接成立**的,不需要中间项。
* 把它单独钉死是因为:一旦有人往日志文案或注释里写 {@code catch (},
* 正确词法会不数它,两口径就此分家,而"≤ 基线"的棘轮对分母变小是沉默的。
*/
static final int BASELINE_DECOY = 0;
private static volatile Result cached;
private static Result tree() {
Result r = cached;
if (r == null) {
synchronized (CatchSilenceRatchetTest.class) {
r = cached;
if (r == null) {
r = SilentCatchScanner.scanTree(TREE);
cached = r;
}
}
}
return r;
}
/**
* 分母自证:扫描器数出的 total 与一份**独立**的简单口径(原始文件里字面量
* {@code "catch ("} 的出现次数,等价于 {@code grep -o "catch (" | wc -l})必须对得上账:
*
* <pre>naive == scanned + decoy</pre>
*
* <p>为什么不是直接 {@code naive == scanned}:字面量口径会把注释里、字符串里、文本块里的
* {@code catch (} 字样也数进去(本轮实测 7 处)。一个**正确**的词法必须不数它们,
* 所以两口径天然差这 7。把差值单独钉住({@link #BASELINE_DECOY})才是有用的断言:
* 词法若写坏、把真代码当字符串吃掉,total 会**变小**而"≤ 基线"照样绿,
* 但那些块会立刻变成 decoy ⇒ decoy 超基线 ⇒ 红。这正是 818 vs 1000 那版 bug 的显形方式。
*/
@Test
void scannerTotalAndDecoyAccountForTheIndependentNaiveCount() {
Map<String, String> raw = readTree();
int naive = SilentCatchScanner.countNaiveLiteral(raw);
List<SilentCatchScanner.Decoy> decoys = SilentCatchScanner.decoyOccurrences(raw);
int scanned = tree().total();
assertEquals(naive, scanned + decoys.size(),
() -> "对不上账:字面量口径 " + naive + " 处,扫描器 " + scanned
+ " 处,注释/字面量里的假 catch " + decoys.size() + " 处。"
+ "两口径的差只能是假 catch,多出来或少出来都说明有一边在漏数");
assertTrue(decoys.size() <= BASELINE_DECOY,
() -> "有 " + decoys.size() + " 处 \"catch (\" 字样落在注释或字符串里(基线 "
+ BASELINE_DECOY + ")。这一旦不为 0,下面那条『两口径直接相等』就得改成带中间项,"
+ "而分母变小对『≤ 基线』的棘轮是沉默的——所以宁可现在就来找一找是谁写的:" + decoys);
assertEquals(naive, scanned,
"扫描器数出的 total 必须等于独立简单口径(grep \"catch (\")的 total");
assertTrue(scanned > 900,
() -> "扫描器只数到 " + scanned + " 处,不像整棵 main 树(词法吃掉大段就会这样)");
assertTrue(naive > 950, () -> "字面量口径只有 " + naive + ",连独立分母都没站住");
}
/**
* 四个数各自 ≤ 基线(只许减)。两套基线一起钉:
* 验收口径(用户给的 1000/559/249/56)与本轮严格口径重测(994/554/170/55)。
* 只钉前者会留下 6/5/79/1 的额度被人当预算花掉,只钉后者则对不上验收数字,所以两把尺都摆在这儿。
*/
@Test
void fourNumbersMustNotGrow() {
Result r = tree();
assertTrue(r.total() <= STRICT_TOTAL,
() -> "catch 总数超过 " + STRICT_TOTAL + "(= 验收基线 " + GIVEN_TOTAL
+ " 再加上 STRICT_TOTAL 常量上方逐处记名的两处评审增量):现在是 " + r.total()
+ "。新增 catch 块要么别加,要么同批减掉一处同形状的");
assertTrue(r.count(Kind.RETHROW) >= RETHROW_FLOOR,
() -> "重抛型 catch 跌到 " + r.count(Kind.RETHROW) + ",低于下限 " + RETHROW_FLOOR
+ "。有人把一处『异常会往外走』的出口改回了吞掉——这一格只许涨不许跌");
assertTrue(r.notRethrowIncludingLogOnly() <= GIVEN_NOT_RETHROW,
() -> "不重抛(块体非空且不含 throw)超过验收基线 " + GIVEN_NOT_RETHROW + ":现在是 "
+ r.notRethrowIncludingLogOnly());
assertTrue(r.notRethrowIncludingLogOnly() <= STRICT_NOT_RETHROW,
() -> "不重抛超过本轮严格口径实测 " + STRICT_NOT_RETHROW + ":现在是 "
+ r.notRethrowIncludingLogOnly() + ",这一格就是「异常到此为止、外面看不见」的总数");
assertTrue(r.count(Kind.LOG_ONLY) <= GIVEN_LOG_ONLY,
() -> "只 log 的吞异常块超过验收基线 " + GIVEN_LOG_ONLY + ":现在是 " + r.count(Kind.LOG_ONLY));
assertTrue(r.count(Kind.LOG_ONLY) <= STRICT_LOG_ONLY,
() -> "只 log 的吞异常块超过本轮严格口径实测 " + STRICT_LOG_ONLY + ":现在是 "
+ r.count(Kind.LOG_ONLY) + "(严格口径=块内每条顶层语句都是 log 调用;"
+ "验收基线 249 那一版把『log 后紧跟 return』也算进来了,所以更宽)");
assertTrue(r.count(Kind.EMPTY) <= GIVEN_EMPTY,
() -> "空体 catch 超过验收基线 " + GIVEN_EMPTY + ":现在是 " + r.count(Kind.EMPTY));
assertTrue(r.count(Kind.EMPTY) <= STRICT_EMPTY,
() -> "空体 catch 超过本轮严格口径实测 " + STRICT_EMPTY + ":现在是 " + r.count(Kind.EMPTY)
+ ",空体是三类高危出口里最贵的一种(连日志都不留)");
}
/**
* 恒等式:total = rethrow + notRethrow(含只 log) + empty。
*
* <p>不这么钉的话,往分类器里加一个"新格子"就能把气味块从三格里悄悄搬走,
* 三个数字同时下降而总噪声一点没少——这正是"内部搬家"绕过棘轮的形状。
*/
@Test
void categoriesPartitionTheWholeDenominator() {
Result r = tree();
int rethrow = r.count(Kind.RETHROW);
int silent = r.notRethrowIncludingLogOnly();
int empty = r.count(Kind.EMPTY);
assertEquals(r.total(), rethrow + silent + empty,
() -> "分类没覆盖全部 catch:total=" + r.total() + " 而 rethrow+notRethrow+empty="
+ (rethrow + silent + empty) + ",有块掉在缝里了");
assertTrue(rethrow > 0 && silent > 0 && empty > 0,
() -> "某一格是 0,说明分类器根本没往那里判过:rethrow=" + rethrow
+ " notRethrow=" + silent + " empty=" + empty);
}
/** 每条气味块都要能定位到 文件:行号——只有标量的棘轮会被"这里加一条那里减一条"绕过去。 */
@Test
void everySilentSiteIsLocatable() {
List<Site> sites = tree().sites();
assertTrue(sites.stream().allMatch(s -> s.line() > 0), "有 catch 的定位行号是 0,清单没法用");
long distinctFiles = tree().byFile().keySet().size();
assertTrue(distinctFiles > 100,
() -> "只有 " + distinctFiles + " 个文件带 catch,分母不像整棵树");
// 单位自证:文件数 != 处数。若两者相等,说明我(或后人)把"每文件一处"当成了口径。
assertTrue(sites.size() != distinctFiles,
() -> "处数(" + sites.size() + ")恰好等于文件数(" + distinctFiles
+ ")——这几乎不可能是真的,倒像是把文件数当成了处数");
}
/**
* 注入自证(正例):内存里造四种形状的 catch,扫描器必须一种都不放过、且判对类。
*
* <p>没有这一条,"四个数都 ≤ 基线"完全可能是恒真的——分类器返回空清单时它照样绿。
*/
@Test
void injectedSitesAreCountedAndClassified() {
Map<String, String> injected = new LinkedHashMap<>();
injected.put("Harness.java", String.join("\n",
"class Harness {",
" void emptyBody() { try { work(); } catch (Exception e) { } }",
" void logOnly() { try { work(); } catch (Exception e) { log.warn(\"skip\"); } }",
" void swallowWithSideEffect() { try { work(); } catch (Exception e) { marks.add(1); } }",
" void rethrows() { try { work(); } catch (Exception e) { throw new IllegalStateException(e); } }",
" void logThenReturn() { try { work(); } catch (Exception e) { log.warn(\"x\"); return; } }",
"}",
""));
Result r = SilentCatchScanner.scanSources(injected);
assertEquals(5, r.total(), "注入的 5 处 catch 没全数出来");
assertEquals(1, r.count(Kind.EMPTY), "空体那处没判成 EMPTY");
assertEquals(1, r.count(Kind.LOG_ONLY), "只有 log 的那处没判成 LOG_ONLY");
assertEquals(2, r.count(Kind.NOT_RETHROW),
"带副作用的不重抛(marks.add / log+return)应是 2 处");
assertEquals(1, r.count(Kind.RETHROW), "重抛那处不该被算成静默");
assertEquals(3, r.notRethrowIncludingLogOnly(),
"不重抛这一格(含只 log)应是 3 处:marks.add 那处 + log 后接 return 那处 + 纯 log 那处"
+ "(空体单列一格,不在这格里)");
// 反证:同一份内容里如果一个字都不加,总数就是 0——证明上面的数字来自注入而非主树
assertEquals(0, SilentCatchScanner.scanSources(Map.of()).total());
}
/**
* 注入自证(词法陷阱):字符字面量与转义引号不许吃掉后半棵树。
*
* <p>这是用户点名的坑:{@code '\"'} 与 {@code '\''} 处理不对,后面的 {@code catch} 就整片消失
* (翻车版扫出 818 vs 真实 1000)。这里用一份小夹具把两种陷阱和真 catch 混在一起,
* 要求扫描器只数到真 catch,同时独立字面量口径必须数到更多——两口径的差值本身就是证据。
*/
@Test
void charLiteralsAndEscapedQuotesDoNotBlindTheLexer() {
// 文本块里的 \\ 会变成一个反斜杠,于是夹具里是货真价实的 \" 与 '\'' 与 '\\'
String trapSource = """
class Trap {
String decoy = "a decoy \\" catch ( inside a string";
char apostrophe = '\\'';
char backChar = '\\\\';
char quoteChar = '"';
String after = "still here";
void real() { try { work(); } catch (Exception e) { marks.add(1); } }
void alsoReal() { try { work(); } catch (IllegalStateException e) { } }
}
""";
Map<String, String> trap = Map.of("Trap.java", trapSource);
int naive = SilentCatchScanner.countNaiveLiteral(trap);
int scanned = SilentCatchScanner.scanSources(trap).total();
assertEquals(2, scanned,
() -> "真 catch 只有 2 处,扫描器数出 " + scanned
+ " 处——字面量一处理错,后面的代码就整段被吞(818 vs 1000 那个形状)");
assertNotEquals(naive, scanned,
"字符串里的 decoy catch 也被数进来了:说明扫描器根本没在剥字符串(两口径此刻必须不同)");
assertTrue(naive > scanned,
() -> "字面量口径(" + naive + ")应大于词法口径(" + scanned + "),因为夹具里埋了一条假 catch");
assertEquals(1, naive - scanned, "两口径的差应当正好是字符串里那一条 decoy");
}
/** 打当前四格计数与假 catch 清单(口径复核用,不产生断言)。 */
@Test
void printCurrentCounts() {
Result r = tree();
Map<String, String> raw = readTree();
System.out.println("CATCH total=" + r.total() + " rethrow=" + r.count(Kind.RETHROW)
+ " notRethrow(incl logOnly)=" + r.notRethrowIncludingLogOnly()
+ " logOnly=" + r.count(Kind.LOG_ONLY) + " empty=" + r.count(Kind.EMPTY)
+ " files=" + r.byFile().size()
+ " naive=" + SilentCatchScanner.countNaiveLiteral(raw)
+ " decoy=" + SilentCatchScanner.decoyOccurrences(raw).size());
System.out.println("DECOY_BEGIN");
SilentCatchScanner.decoyOccurrences(raw).forEach(d ->
System.out.println("DECOY " + d.file() + ":" + d.line() + " | " + d.context()));
System.out.println("DECOY_END");
}
// ==== §2 后端「静默出口成片」那行的**另一半**:三类出口必须含 throw 或显式锚点 ====
/**
* 任务书这一行写的是两件事:①扫描器进测试做只许减棘轮(上面那批用例);②回传/落库/扣次数
* 三类必须含 throw 或显式锚点。<b>②从来没被测过</b>——{@code Site.hasAnchor()} 在扫描器里
* 躺了几天、一个调用者都没有,而那行格子一直按"达标"计。现在把它做成真判据。
*
* <p>锚点约定是 ASCII 的 {@code [tag]}:扫描器的正则是
* {@code \[[A-Za-z0-9_.-]{3,}\]},中文方括号标签根本匹配不上。任务书里写的
* {@code [静默降级]} 属**命名与代码不一致**,这里按代码为准,锚点用 {@code [silent-degrade]}。
*
* <p>台账逐处按文件点名(只钉总数=允许"内部搬家"绕过,见本仓反复出现的那族错误)。
*/
@Test
void threeCategoriesMustRethrowOrCarryAnchor() {
Map<String, Integer> gap = gapLedger(tree().sites());
assertEquals(GAP_LEDGER, gap, () -> "三类静默出口台账变了:实测 " + gap
+ "(合计 " + gap.values().stream().mapToInt(Integer::intValue).sum() + ")"
+ "。新增要逐处记名,收掉要连这个常量一起降。");
assertFalse(gap.isEmpty(), "台账是空的 ⇒ 三类里一处静默出口都没扫到,这条判据恒真");
}
/**
* 注入自证:四种形状要判出三种结果——带 throw 放过、带锚点放过、两者都没有才记缺口,
* 无关类别连进名单都不许进。没有这条,上面那个 assertEquals 可能是"扫描器什么都不返回"的假绿。
*/
@Test
void anchorAndThrowBothCloseTheGapOnlyWhenActuallyPresent() {
Map<String, String> src = new LinkedHashMap<>();
src.put("Feed.java", "class T { void f() { try { report(feed); } "
+ "catch (Exception e) { log.warn(\"feed down\"); } } }");
src.put("Anchored.java", "class T { void f() { try { report(feed); } "
+ "catch (Exception e) { log.warn(\"[silent-degrade] feed down\"); } } }");
src.put("Throwing.java", "class T { void f() { try { report(feed); } "
+ "catch (Exception e) { throw new IllegalStateException(e); } } }");
src.put("Unrelated.java", "class T { void f() { try { socket.close(); } "
+ "catch (Exception e) { log.warn(\"x\"); } } }");
Map<String, Integer> gap = gapLedger(SilentCatchScanner.scanSources(src).sites());
assertEquals(Map.of("Feed.java", 1), gap,
() -> "只该抓到『既没 throw 也没锚点』的那一处,实抓 " + gap);
}
/**
* 三类判据:块体里出现这些字样才算回传/落库/扣次数的出口。
* 名单刻意窄——宁可少收,也不把无关 catch 卷进台账(卷进来会让"只许减"变成没人敢动的死数)。
*/
private static final Map<String, java.util.regex.Pattern> CATEGORY = Map.of(
"回传", java.util.regex.Pattern.compile("回传|report|feed|Result|notify|Notify"),
"落库", java.util.regex.Pattern.compile("\\.save\\(|\\.insert|\\.update|Mapper|Repository|updateById"),
"扣次数", java.util.regex.Pattern.compile("次数|deduct|Deduct|usage|Usage|refund|Refund|balance|Balance"));
/**
* 三类里"既没重抛也没锚点"的那些 catch,按文件计数。
*
* <p>RETHROW 直接排除(那正是我们要的形状);锚点判定走 {@link Site#hasAnchor()},
* 它看的是 rawBody——{@code body} 剥过注释,会把字符串里的 {@code [tag]} 一起剥掉,
* 于是"打了锚点"反而判成没锚点(扫描器 javadoc 里记着这条,别改回去)。
*/
private static Map<String, Integer> gapLedger(List<Site> sites) {
Map<String, Integer> out = new java.util.TreeMap<>();
for (Site s : sites) {
if (s.kind() == Kind.RETHROW) {
continue;
}
boolean hit = false;
for (java.util.regex.Pattern p : CATEGORY.values()) {
if (p.matcher(s.rawBody()).find()) {
hit = true;
break;
}
}
if (hit && !s.hasAnchor()) {
out.merge(s.file(), 1, Integer::sum);
}
}
return out;
}
/** 10-09 实测基线:三类里"吞掉且没有锚点"的 11 处(按文件点名)。收掉一处就往下改。 */
private static final Map<String, Integer> GAP_LEDGER = Map.ofEntries(
Map.entry("com/nanri/aiimage/modules/convert/service/ConvertRunService.java", 1),
Map.entry("com/nanri/aiimage/modules/dedupe/service/DedupeRunService.java", 2),
Map.entry("com/nanri/aiimage/modules/dedupe/service/DedupeTotalDataService.java", 1),
Map.entry("com/nanri/aiimage/modules/deletebrand/service/DeleteBrandRunService.java", 1),
Map.entry("com/nanri/aiimage/modules/deletebrand/service/DeleteBrandTaskStorageService.java", 1),
Map.entry("com/nanri/aiimage/modules/pricetrack/service/PriceTrackTaskService.java", 1),
Map.entry("com/nanri/aiimage/modules/shopmatch/service/ShopMatchTaskService.java", 1),
Map.entry("com/nanri/aiimage/modules/similarasin/service/SimilarAsinImagePrefetchService.java", 1),
Map.entry("com/nanri/aiimage/modules/similarasin/service/support/SimilarAsinPipelineSupport.java", 1),
Map.entry("com/nanri/aiimage/modules/split/service/SplitRunService.java", 1));
private static Map<String, String> readTree() {
Map<String, String> out = new LinkedHashMap<>();
try (var walk = Files.walk(TREE)) {
for (Path p : walk.filter(Files::isRegularFile)
.filter(p -> p.getFileName().toString().endsWith(".java")).sorted().toList()) {
out.put(TREE.relativize(p).toString().replace('\\', '/'),
new String(Files.readAllBytes(p), StandardCharsets.UTF_8));
}
} catch (IOException e) {
throw new UncheckedIOException(e);
}
return out;
}
private static Path moduleRoot() {
Path here = Path.of("").toAbsolutePath();
if (Files.isDirectory(here.resolve("src/main/java"))) {
return here;
}
Path nested = here.resolve("backend-java");
if (Files.isDirectory(nested.resolve("src/main/java"))) {
return nested;
}
throw new IllegalStateException("无法定位 backend-java 模块目录(cwd=" + here + ")");
}
}