test(任务骨架): 把"还欠多少重复"钉成棘轮,并订正 3.6k 这个数

架构评审里给的「任务生命周期约 3.6k 行冗余」经逐行差分不成立:骨架 TaskFinalizeSupport
早已存在,9 支 *TaskService 里 7 支已委托,跨文件逐字重复只有 208 行;真正改不动的是
16 个文件里 130 处手抄的「模块归属谓词」——它决定漏一行还是多放行一行,两处口径各自成立,
不是能机械合并的副本。

本支不重写那 130 处,只把债务钉住:谓词出现次数 ≤130、文件数==16、委托数 ≥7,
只许降不许升;每条断言带"能红"自检。
This commit is contained in:
2026-10-07 20:01:32 +08:00
parent ab2605d1d1
commit 4660e02efc
@@ -0,0 +1,169 @@
package com.nanri.aiimage.common.task;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
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.stream.Stream;
import com.nanri.aiimage.testutil.SourceScan;
import org.junit.jupiter.api.Test;
/**
* 任务面「生命周期骨架」的账(2026-10-07 架构三期,第 5 项)。
*
* <p>评审时那句「~3.6k 行冗余」是我自己给的,实跑之后<b>不成立</b>,这里换成量出来的数:
* 九个 {@code *TaskService} 归一化后共 15,295 行,跨文件<b>逐字</b>相同的 8 行窗口只覆盖 208 行
* (按页 0.4%–6.8% 不等)。所以"抽骨架"不是去重——那是一场重写,而骨架<b>早就抽过了</b>:
* {@code TaskFinalizeSupport}(loadTaskForExecution / loadTaskMapByIds / markResultFailed /
* acquireTaskLockOrThrow / selectTasksByIdsInBatches)今天被 14 个 {@code *TaskService} 中的 7 个委托,
* 类注释里还点名留了三处非同构变体(PriceTrack 要求缓存行 requestJson 非空、ShopMatch 带新旧复活防护、
* Withdraw 先按 limit(50) 归一化 id)。剩下的重复不是行,是<b>同一条安全谓词被手抄的遍数</b>:
* 「这一行是不是这个模块的」{@code !MODULE_TYPE.equals(x.getModuleType())} 在 <b>16</b> 个文件里写了
* <b>130</b> 遍。第 3 项那个超管判定是同一缺陷的小一号版本(19 遍),那个已经收口成出口,这个还没有。</p>
*
* <p>抄本身不是 bug,<b>改不动</b>才是:归属谓词漏一处的表现是某一页的检查静默变成"谁都能读",
* 不报错、不 403。今天动它要一次改到 16 个文件,代价太大,所以这里先把<b>遍数钉成棘轮</b>:
* 只许降不许升。升了就是在新增第十七处手写归属——那种新增应当接进 {@code TaskFinalizeSupport}
* 或新的归属出口,而不是把这个数字调大。</p>
*
* <p>两条判据各带自检:锚点必须真能抓到这一形,否则"16 个文件 / 130 处"的 0 命中与扫不到同形。</p>
*/
class TaskLifecycleDebtRatchetTest {
private static final String MODULE_OWNERSHIP = "!MODULE_TYPE.equals(";
@Test
void handWrittenModuleOwnershipIsPinnedAtOneHundredThirtyAndCannotGrow() {
int occurrences = 0;
List<String> files = new ArrayList<>();
for (Path file : mainSources()) {
int n = count(read(file), MODULE_OWNERSHIP);
if (n > 0) {
occurrences += n;
files.add(file.getFileName().toString());
}
}
// 自检:分母本身要说得出数("扫到 16 个文件"与"扫描坏了返回空"是两种红法,别混)
assertThat(files).as("手写模块归属谓词的文件数").hasSize(16);
// 自检:锚点必须真抓得到这一形,否则上一条与下面那条棘轮都是恒绿
assertThat(count("if (task == null || !MODULE_TYPE.equals(task.getModuleType())) {", MODULE_OWNERSHIP))
.as("锚点自检:这一形抓不到,棘轮等于没写").isEqualTo(1);
assertThat(occurrences)
.as("src/main 里手抄的模块归属谓词遍数(棘轮:只许降。要降就把它接进 TaskFinalizeSupport)")
.isLessThanOrEqualTo(130);
}
@Test
void lifecycleHelpersAreAlreadySharedSoDoNotAddASecondCopy() {
String support = read(mainRoot().resolve("modules/task/service/TaskFinalizeSupport.java"));
assertThat(support).as("骨架必须是静态工具,否则各页还是要自己 new 一份")
.contains("public final class TaskFinalizeSupport");
for (String helper : List.of("loadTaskForExecution", "loadTaskMapByIds", "markResultFailed",
"acquireTaskLockOrThrow", "selectTasksByIdsInBatches")) {
assertThat(support)
.as("骨架里那个叫 %s 的零件不见了:各页会退回本地再抄一遍", helper)
.contains(helper + "(");
}
// 委托面:*TaskService 里走骨架的页数只许升不许降。掉下 7 就说明有人又开始本地抄。
int delegating = 0;
for (Path file : mainSources()) {
String name = file.getFileName().toString();
if (name.endsWith("TaskService.java") && read(file).contains("TaskFinalizeSupport.")) {
delegating++;
}
}
assertThat(delegating)
.as("委托给 TaskFinalizeSupport 的 *TaskService 数(实测 7:PatrolDelete/PriceTrack/ProductRisk/"
+ "QueryAsin/ShopDataCrawl/ShopMatch/Withdraw)")
.isGreaterThanOrEqualTo(7);
}
private static int count(String text, String needle) {
int n = 0;
for (int i = text.indexOf(needle); i >= 0; i = text.indexOf(needle, i + needle.length())) {
n++;
}
return n;
}
private static List<Path> mainSources() {
Path root = mainRoot();
try (Stream<Path> walk = Files.walk(root)) {
List<Path> files = walk.filter(p -> p.toString().endsWith(".java")).toList();
assertThat(files).as("src/main 扫到的 .java 数").hasSizeGreaterThan(400);
return files;
} catch (IOException e) {
throw new IllegalStateException("扫描失败: " + root, e);
}
}
private static Path mainRoot() {
Path here = Path.of("").toAbsolutePath();
Path direct = here.resolve("src/main/java/com/nanri/aiimage");
if (Files.isDirectory(direct)) {
return direct;
}
Path nested = here.resolve("backend-java").resolve("src/main/java/com/nanri/aiimage");
if (Files.isDirectory(nested)) {
return nested;
}
throw new IllegalStateException("无法定位 backend-java 源码目录(cwd=" + here + ")");
}
private static String read(Path file) {
if (!Files.isRegularFile(file)) {
fail("找不到 " + file + " —— 用例依赖以 backend-java 为工作目录运行,别让扫描静默通过");
}
try {
// 判据打在「剥掉注释的代码」上:本类的三种形状里,棘轮/委托数/骨架零件都是
// "必须存在或次数等于 N"那一形 —— 吃原文的话,TaskFinalizeSupport 的类注释只要还写着
// 「loadTaskForExecution」这几个名字,方法被删断言照样绿(假绿=护栏没写)。
// 2026-10-07 实测:src/main 全部锚点 raw 与 stripped 同数(130/16、7),所以剥注释不改账。
return SourceScan.withoutComments(Files.readString(file, StandardCharsets.UTF_8));
} catch (IOException e) {
throw new IllegalStateException("读取失败: " + file, e);
}
}
/**
* 负对照:剥注释这件事本身要能红能绿。
*
* <p>缺了后一半,{@code withoutComments} 写坏成"整行都删"也会一路绿;缺了前一半,
* 有人把骨架零件改名而在类注释里留一句说明,"零件不见了"就变成假红。</p>
*/
@Test
void commentTextFeedsNeitherShape() {
String proseOnly = SourceScan.withoutComments("""
/** 骨架里有 loadTaskForExecution( 与 TaskFinalizeSupport. 这些名字,只是文档。 */
class C {
// if (task == null || !MODULE_TYPE.equals(task.getModuleType())) { }
void h() { }
}
""");
assertThat(count(proseOnly, MODULE_OWNERSHIP))
.as("注释里的归属谓词不得算命中(棘轮分母会被文档喂大)").isZero();
assertThat(proseOnly).doesNotContain("loadTaskForExecution(").doesNotContain("TaskFinalizeSupport.");
assertThat(proseOnly).as("剥注释不许把代码骨架一起吃掉(类声明还在)")
.contains("class C").contains("void h()");
String realCode = SourceScan.withoutComments("""
class C {
void h() {
if (task == null || !MODULE_TYPE.equals(task.getModuleType())) { throw new BizException(); }
}
}
""");
assertThat(count(realCode, MODULE_OWNERSHIP))
.as("同一把尺子必须抓得到真代码,否则「0 命中」与「扫不到」同形").isEqualTo(1);
// 字符串字面量里的 // 不算注释:口径写坏了会把整行吃掉,这里钉住
assertThat(SourceScan.withoutComments("String u = \"https://a\"; // tail").contains("https://a"))
.isTrue();
}
}