fix(phase-2): 任务活性与失败归因六格收口——在飞豁免/锚点分流/同源判据/回落一元化/巡检按账号分组

蓝图 docs/REFACTOR_PLAN.md Phase 2 的 ①②③④⑥ 五格+台账登记。⑤(failure_category)
未做,原因见文末,不以此笔冒充闭环。

① B74-02 卡死阈值二选一 → 选"扫描询问执行侧",没有抬阈值。
  取证:B 侧 24h 批次 costMs 实测 22,988 / 85,298 / 939,172(单行批次 15.6 分钟),
  A 侧今天 06:07:20 `STUCK_REQUEUE_EXHAUSTED jobId=23815 taskId=33179 stuckRequeueCount=20`,
  06:08 复位恢复、09:20 同样两条=环。真因不是批次长:`startJobHeartbeat` 在父任务终态时
  按 CR-08 刻意停止续期(stage=TERMINAL_STOP_RENEW),执行线程还在跑而 updated_at 冻结,
  扫描每 5 分钟扣一次计数。冻结是**无限期**的,抬到 16 分钟只把 20 次计满从 100 分钟拖到
  320 分钟,还把真遗骸回收拖慢 ⇒ 改为 TaskFileJobService 持内存在飞登记
  (markInFlight/clearInFlight/isInFlight),扫描对"本机线程还在跑"的行不重排也不计数;
  登记面随进程重启即空,遗骸回收形状不变。worker 侧登记在 activateRunningClaim 之后、
  注销在 finally(finishAfterExecution 之后再注销)。

③ B74-03 判死谓词分流(先取证后动手,红线照办)。
  取证:云助手只读 HGETALL+TTL 两枚 stall 键自洽——33179 pos="Linux后台抓取: 606/676"
  与当前 progressText 逐字相同、at 距 now 16,058s(4.46h)、TTL 余 16,342s ⇒ 键 TTL 设定
  32,400s = 9h = 窗口(180min)×3;33149 同样自洽。机制坐实:键一过期 evaluateAgainstSnapshot
  就把起点重锚到 now 并直接 ADVANCING ⇒ 每 9 小时白送一轮完整豁免,沉默客户端永远封不了口
  (11-02 那串"客户端仍在推进"即此形状)。改法:快照缺失/at 读不出与"指纹真变"分口,
  重建锚点锚到**客户端最后一次上报时刻**(位置哈希自己的 at,此前无人读过),再走同一条
  时间判据;客户端确在心跳时锚点仍新鲜 ⇒ 照旧 ADVANCING,判死线不提前(28919 教训在册)。
  P0-C2 快照按"更新即登记"补 3 支:沉默超窗不得豁免/at 读不出走同一条判据/心跳中照旧放行。

② B74-01 三格:landed 与 isJudged 收成同源(mergeLlmRowsIntoChunks 认的"塞回分片"不是结论,
  旧写法给只有 patentRisk 的行打 24h 标记 ⇒ 既不再是候选又无结论列);beginRowInspection 的
  Redis null 由"抢到"改判"未抢到"(抛异常的真降级照旧放行,两条不同路);
  deleteExtraTaskCacheKeys 原删的是从不写入的基键=删空气,改按 processed-rows:{taskId}:*
  游标 SCAN 删真实逐行标记(用 SCAN 不用 KEYS)。新断言做过反向验证:摘掉 isJudged 闸门
  即真红,不是白过。terminalizeRoundExhaustedRows 是按轮次上限终态化的唯一豁免,已写明。

④ B74-04 四台 JSON 回落收成唯一出处 TaskOwnerJsonFallback(result_json 正档先于 request_json;
  店铺采集此前只读 request_json ⇒ 列缺失的 39 行 RUNNING 存量行在不同校验里算出两个归属)。
  TaskOwnerReadSourceGuardrailTest 补回落面:四台不得再有本地回落写法,且顺序钉在那一处。

⑥ B73-03 巡检分组键按供应商账号折(供应商, 提取域, 排序后 query 的摘要——只落摘要,
  链接里的账密明文不进日志/告警面)。青果整个账号只有 1 条通道,旧 moduleKey|channel|密文
  让同一把 key 多开几枪就自己把用户的代理打成 channel_busy。另一半边界同样钉住:
  非链接型凭据(LLM 密钥)照旧逐模块分组,否则拿 A 渠道的结论冒充 B。

台账:SourceScanTest 裸名 23→24(新增 TaskOwnerJsonFallback.java 这一枚),
  与 2026-11-02 那次 22→23 同法逐笔写明是谁的哪一笔、为什么只能打在源码连线上。

门禁实录:mvn -o test 整量 **5256 例/0 失败/0 错误/19 skipped,BUILD SUCCESS**;
  mvn -o test-compile rc=0;定向面另点过(56/88/34+70/63/104 例全绿);
  本仓后端无 spotless/checkstyle ⇒ lint 与格式步如实登记、不是漏执行。

未做的一格(⑤ B51-R1 failure_category):取证显示 biz_file_task.error_message 的落库点
  **没有单一出口**(LambdaUpdateWrapper.set(errorMessage) 15 处+setErrorMessage 若干,
  合计约 25 处,且清 null 的分支也必须同步清列)。这不是"改一支方法"的量级,
  拿半截双写冒充 Expand 会变成列恒为 NULL 的死代码 ⇒ 留作单独一笔,蓝图保持未勾。
This commit is contained in:
2026-11-03 10:47:59 +08:00
parent 66621d8a16
commit 34f730d403
19 changed files with 653 additions and 64 deletions
@@ -235,6 +235,32 @@ class AppearancePatentRowMarkTimingTest {
verify(taskCacheService).releaseRowInspection(TASK_ID, List.of("r2"));
}
/**
* B74-01:landed(被塞回分片载荷)与 isJudged(有结论列)必须同源,谁说了算只能有一个。
*
* <p>发 2 行回 2 行、两行都落进分片,但 r2 只带 patentRisk——三列结论全空。旧写法按 landed
* 给它打 24 小时完成标记,于是它既不再是候选(被自己的标记挡着)又没有可出的结论,
* 只能等补检把标记连根撤掉才回来(现网 33179 的形状)。现在把完成标记打给 isJudged
* 不认的行即红。
*/
@Test
void landedButUnjudgedRowDoesNotGetACompletionMark() throws Exception {
String halfJudged = "[{\"rowToken\":\"r1\",\"asin\":\"B0A0000001\",\"title\":\"RUNNING SHOE\","
+ "\"url\":\"http://img/1.jpg\",\"groupKey\":\"g1\","
+ "\"titleRisk\":\"无侵权\",\"appearanceRisk\":\"无侵权\",\"conclusion\":\"无侵权\"},"
+ "{\"rowToken\":\"r2\",\"asin\":\"B0A0000002\",\"title\":\"COTTON BAG\","
+ "\"url\":\"http://img/2.jpg\",\"groupKey\":\"g2\",\"patentRisk\":\"无侵权\"}]";
when(taskCacheService.beginRowInspection(eq(TASK_ID), anyString())).thenReturn(true);
when(llmClient.inspectRows(any(), any(), any())).thenReturn(rows(halfJudged));
stubMergeWrite(2);
submit();
verify(taskCacheService).completeRowInspection(TASK_ID, List.of("r1"));
verify(taskCacheService, never()).completeRowInspection(TASK_ID, List.of("r2"));
verify(taskCacheService).releaseRowInspection(TASK_ID, List.of("r2"));
}
/** 回来的行一个都落不进分片(rowToken 被网关改写):整批都不能算完成。 */
@Test
void rowsThatMatchNoChunkRowStayRetryable() throws Exception {
@@ -20,6 +20,7 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@@ -221,4 +222,50 @@ class AppearancePatentTaskCacheServiceRowMarkTest {
assertEquals(0L, cache.rowInspectionRounds(TASK_ID, ROW_KEY));
}
/**
* B74-01:Redis 回 null(管道/事务态、集群未回包)必须按**没抢到**处理。
*
* <p>旧写法 {@code return first == null || first;} 把「读不出」读成「抢到了」,同一行可能被
* 两个入口同时发出去(双扣用户 LLM 次数、两路各自 CAS 同一行)。这与"Redis 抛异常"是两条路:
* 真降级在 catch 里放行,由持久化层 isJudged 兜底(见 beginAllowsRowThroughWhenRedisFails)。
*/
@Test
void beginTreatsNullReplyAsNotClaimed() {
when(valueOperations.setIfAbsent(anyString(), anyString(), any(Duration.class))).thenReturn(null);
assertFalse(cache.beginRowInspection(TASK_ID, ROW_KEY),
"null 不是 true:读不出就不能声称拿到了这一行");
}
/**
* B74-01:清任务缓存必须删掉**真实存在**的逐行完成标记。
*
* <p>旧实现删的是 {@code processedRowsKey(taskId)} 这枚从不被写入的基键=删空气,
* 任务清完后 24 小时内重建,行仍被标记挡着不再检测——声称保护但不保护。
*/
@Test
@SuppressWarnings("unchecked")
void deleteTaskCacheRemovesTheRealPerRowMarks() {
org.springframework.data.redis.core.Cursor<String> cursor =
mock(org.springframework.data.redis.core.Cursor.class);
when(cursor.hasNext()).thenReturn(true, true, false);
when(cursor.next()).thenReturn(
"appearance-patent:task:processed-rows:" + TASK_ID + ":r1",
"appearance-patent:task:processed-rows:" + TASK_ID + ":r2");
when(redisTemplate.scan(any())).thenReturn(cursor);
cache.deleteTaskCache(TASK_ID);
ArgumentCaptor<java.util.Collection<String>> deleted =
ArgumentCaptor.forClass(java.util.Collection.class);
verify(redisTemplate).delete(deleted.capture());
assertTrue(deleted.getValue().contains(
"appearance-patent:task:processed-rows:" + TASK_ID + ":r1"),
"逐行标记必须被真的删掉,否则「清完缓存」只是一句注释");
assertTrue(deleted.getValue().contains(
"appearance-patent:task:processed-rows:" + TASK_ID + ":r2"));
assertTrue(deleted.getValue().contains("appearance-patent:task:processed-rows:" + TASK_ID),
"基键一并清掉(今天它仍不存在,但它是这一族的目录名,不该留在册上)");
}
}
@@ -284,4 +284,46 @@ class TaskFileJobOwnerHandOffTest {
assertEquals(1, result.resetCount(),
"后管那枚人工复位按钮点的就是「把它排回去」,不得被归属守卫悄悄拒掉");
}
// ==================== B74-02 本机执行活性豁免(与上面「他机在跑」是同一判据的两半) ====================
@Test
void test_本机正在执行的作业不得被卡死扫描重排或判死() {
// 现网形状:2026-11-03 jobId=23815/taskId=33179 在 06:07:20 到 stuckRequeueCount=20,
// 而执行线程一直在跑——父任务终态后心跳按 CR-08 刻意停续期,updated_at 从此无限期冻结,
// 扫描只看时间戳就每 5 分钟扣一次计数。抬阈值救不了它(冻结不是「比 5 分钟长一点」)。
TaskFileJobEntity ownRunning = job(23815L, 33179L, "RUNNING", TASK_OWNER);
ownRunning.setStuckRequeueCount(20);
when(taskFileJobMapper.selectList(any())).thenReturn(List.of(ownRunning));
service.markInFlight(23815L);
TaskFileJobService.StuckJobResetResult result =
service.resetStuckRunningJobsDetailed(5, 10, TASK_OWNER);
assertEquals(0, result.resetCount());
assertTrue(result.exhaustedJobs().isEmpty(),
"线程还在跑就不许把它判死:判死后 markSuccess 的 .eq(status,RUNNING) 会丢掉成功状态");
verify(taskFileJobMapper, never()).update(isNull(), any(LambdaUpdateWrapper.class));
verify(applicationEventPublisher, never()).publishEvent(any());
}
@Test
void test_注销之后同一行必须回到可回收形状() {
// 登记面必须是"线程在跑期间"这一有界区间:漏注销=这行永远不被回收,遗骸比误判更贵。
TaskFileJobEntity ownRunning = job(23815L, 33179L, "RUNNING", TASK_OWNER);
ownRunning.setStuckRequeueCount(3);
when(taskFileJobMapper.selectList(any())).thenReturn(List.of(ownRunning));
when(taskFileJobMapper.update(isNull(), any(LambdaUpdateWrapper.class))).thenReturn(1);
when(taskFileJobMapper.selectBatchIds(any())).thenReturn(List.of(ownRunning));
service.markInFlight(23815L);
service.clearInFlight(23815L);
assertFalse(service.isInFlight(23815L));
TaskFileJobService.StuckJobResetResult result =
service.resetStuckRunningJobsDetailed(5, 10, TASK_OWNER);
assertEquals(1, result.resetCount(), "注销后必须照旧被回收,活性豁免不是豁免的通行证");
assertEquals(0, service.inFlightCount());
}
}
@@ -177,4 +177,56 @@ class TaskHeartbeatPositionStallExitsSnapshotTest {
verify(hash, never()).putAll(eq(STALL_KEY), any());
verify(redis, org.mockito.Mockito.never()).expire(eq(STALL_KEY), any(Duration.class));
}
// ==================== B74-03 分流(2026-11-03 按现网取证改判;更新即登记,不静默) ====================
private void givenPositionTextAt(String text, long reportedAtMillis) {
Map<Object, Object> position = new HashMap<>();
position.put("progressText", text);
position.put("at", String.valueOf(reportedAtMillis));
when(hash.entries(POSITION_KEY)).thenReturn(position);
}
@Test
void 停滞快照缺失但客户端已沉默超窗_不得再白送一轮豁免() {
// 现网形状(2026-11-02 任务 33179):本键 TTL = max(60, window×3) = 9 小时,键一消失
// 旧代码就把起点重锚到 now 并直接放行,于是每 9 小时白送一轮完整豁免窗口,沉默的客户端永远封不了口。
long anchor = Instant.now().toEpochMilli() - Duration.ofMinutes(40).toMillis();
givenPositionTextAt("正在抓取第 3 页", anchor);
when(hash.entries(STALL_KEY)).thenReturn(new HashMap<>());
assertThat(service.evaluateStall(7L, 30L))
.as("键消失只是没人记账,不等于「证据表明在推进」;最后一次上报已在 30 分钟窗口外 ⇒ STALLED")
.isEqualTo(TaskHeartbeatPositionService.StallState.STALLED);
org.mockito.ArgumentCaptor<Map<String, String>> written =
org.mockito.ArgumentCaptor.forClass((Class) Map.class);
verify(hash).putAll(eq(STALL_KEY), written.capture());
assertThat(written.getValue().get("at"))
.as("重建的锚点必须锚到客户端最后一次上报时刻;锚到 now 就是每轮重发免死牌")
.isEqualTo(String.valueOf(anchor));
}
@Test
void 快照在而时间戳读不出_走同一条时间判据_不再借用真进展出口() {
long anchor = Instant.now().toEpochMilli() - Duration.ofMinutes(45).toMillis();
givenPositionTextAt("正在抓取第 3 页", anchor);
when(hash.entries(STALL_KEY)).thenReturn(stallSnapshot("正在抓取第 3 页", 0L));
assertThat(service.evaluateStall(7L, 30L))
.as("`at` 读不出(管道/事务态)与「指纹变了」共用出口就是 B74-03 的病灶本体;"
+ "分流后两种形状都必须落到真实沉默时长上")
.isEqualTo(TaskHeartbeatPositionService.StallState.STALLED);
}
@Test
void 客户端仍在心跳时锚点重建照旧放行_分流不得把判死线提前() {
givenPositionText("正在抓取第 3 页");
when(hash.entries(STALL_KEY)).thenReturn(new HashMap<>());
assertThat(service.evaluateStall(7L, 30L))
.as("分流只吃掉「白送的豁免」:客户端刚刚上报过 ⇒ 锚点就是新鲜的,仍判 ADVANCING。"
+ "把仍在采集的任务判死会丢整批分片(28919 教训写在 isClientAdvancing 注释上)")
.isEqualTo(TaskHeartbeatPositionService.StallState.ADVANCING);
}
}
@@ -70,6 +70,47 @@ class TaskOwnerReadSourceGuardrailTest {
// 真正不允许的是反过来——只读快照,那正是相似ASIN 与发布当时的形状。
}
/**
* B74-04 的另一半尺子:上面那支只钉住「列优先」,没钉「列缺失时读哪枚 JSON」。
*
* <p>四台此前各有写法——三台回落 result_json、店铺采集回落 request_json,列缺失的存量行
* (实测 RUNNING 里 39 行)在不同校验里算出不同归属。回落顺序现在只有
* {@code TaskOwnerJsonFallback} 一个出处:任何一台改回本地读法,本格即红。
*/
@ParameterizedTest(name = "{0} 的任务归属回落必须走唯一出处")
@CsvSource({
"AppearancePatentTaskOwnership.java",
"SimilarAsinTaskOwnershipSupport.java",
"PublishTaskService.java",
"ShopDataCrawlTaskService.java",
})
void fallbackMustDelegateToOneSharedSource(String fileName) {
String source = SourceScan.withoutComments(SourceScan.sourceText(fileName));
assertThat(source)
.as(fileName + " 不得再有本地的任务归属 JSON 回落写法(result_json 侧)")
.doesNotContain("readTree(task.getResultJson()).path(\"ownerInstanceId\")");
assertThat(source)
.as(fileName + " 不得再有本地的任务归属 JSON 回落写法(request_json 侧)")
.doesNotContain("readTree(task.getRequestJson()).path(\"ownerInstanceId\")");
assertThat(source)
.as(fileName + " 必须经 TaskOwnerJsonFallback 读回落,四台共用同一个顺序")
.contains("TaskOwnerJsonFallback.ownerFrom(");
}
@Test
void 回落顺序在唯一出处里钉死_result_json_先于_request_json() {
String source = SourceScan.withoutComments(SourceScan.sourceText("TaskOwnerJsonFallback.java"));
int resultRead = source.indexOf("task.getResultJson()");
int requestRead = source.indexOf("task.getRequestJson()");
assertThat(resultRead).as("正档必须真的读 result_json").isGreaterThan(-1);
assertThat(requestRead).as("提交快照仍作次档(列与正档都没写上时还得兜住)").isGreaterThan(-1);
assertThat(resultRead)
.as("result_json 必须先于 request_json:它是 parse/交付快照,request_json 是提交时最旧的一手")
.isLessThan(requestRead);
}
@Test
void 转交作业的目标实例必须来自异常携带的任务当前_owner() {
String source = SourceScan.withoutComments(SourceScan.sourceText("TaskResultFileJobWorker.java"));
@@ -30,6 +30,7 @@ import com.nanri.aiimage.modules.task.mapper.FileResultMapper;
import com.nanri.aiimage.modules.task.model.entity.TaskFileJobEntity;
import com.nanri.aiimage.modules.withdraw.service.WithdrawTaskService;
import org.junit.jupiter.api.Test;
import org.mockito.InOrder;
import org.springframework.boot.context.event.ApplicationReadyEvent;
import org.springframework.context.event.EventListener;
@@ -52,6 +53,7 @@ import static org.mockito.ArgumentMatchers.contains;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.after;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.timeout;
import static org.mockito.Mockito.times;
@@ -536,6 +538,60 @@ class TaskResultFileJobWorkerStuckScanTest {
verify(taskFileJobService, never()).markFailureFinalized(any(), anyString());
}
/**
* B74-02 活性登记的半边判据:登记必须在 {@code activateRunningClaim} 成功之后、执行之前,
* 注销必须在 finally——顺序反了要么把没跑起来的行登记成在飞(永不可回收),要么让还在跑的行
* 被扫描扣计数(现网 jobId=23815/taskId=33179 的形状)。
*/
@Test
void test_执行线程在跑期间登记在飞且退出必注销() throws Exception {
TaskResultFileJobWorker worker = buildWorker();
TaskFileJobEntity job = runningJob(91L, 19L, "SIMILAR_ASIN");
TaskFileJobEntity claim = runningJob(91L, 19L, "SIMILAR_ASIN");
claim.setUpdatedAt(LocalDateTime.now());
when(taskFileJobService.activateRunningClaim(claim)).thenReturn(true);
invokeProcessClaimedWithHeartbeat(worker, job, claim);
InOrder inOrder = inOrder(taskFileJobService);
inOrder.verify(taskFileJobService).activateRunningClaim(claim);
inOrder.verify(taskFileJobService).markInFlight(91L);
inOrder.verify(taskFileJobService).clearInFlight(91L);
}
@Test
void test_claim已过期时不得登记在飞() throws Exception {
// 队里的 claim 在执行前就过期(行已被扫描翻走)——这一行不归本机跑,登记它等于永久豁免。
TaskResultFileJobWorker worker = buildWorker();
TaskFileJobEntity job = runningJob(92L, 20L, "SIMILAR_ASIN");
TaskFileJobEntity claim = runningJob(92L, 20L, "SIMILAR_ASIN");
claim.setUpdatedAt(LocalDateTime.now());
when(taskFileJobService.activateRunningClaim(claim)).thenReturn(false);
invokeProcessClaimedWithHeartbeat(worker, job, claim);
verify(taskFileJobService, never()).markInFlight(92L);
verify(taskFileJobService, never()).clearInFlight(92L);
}
private static TaskFileJobEntity runningJob(Long id, Long taskId, String moduleType) {
TaskFileJobEntity entity = new TaskFileJobEntity();
entity.setId(id);
entity.setTaskId(taskId);
entity.setModuleType(moduleType);
entity.setStatus("RUNNING");
return entity;
}
private static void invokeProcessClaimedWithHeartbeat(TaskResultFileJobWorker worker,
TaskFileJobEntity job,
TaskFileJobEntity claim) throws Exception {
java.lang.reflect.Method method = TaskResultFileJobWorker.class.getDeclaredMethod(
"processClaimedWithHeartbeat", TaskFileJobEntity.class, TaskFileJobEntity.class);
method.setAccessible(true);
method.invoke(worker, job, claim);
}
private static void setLong(TaskResultFileJobWorker worker, String fieldName, long value) throws Exception {
Field field = TaskResultFileJobWorker.class.getDeclaredField(fieldName);
field.setAccessible(true);
@@ -1102,6 +1102,56 @@ class UserApiSecretServiceTest {
assertThat(inspectionWrites.values()).containsOnly("passed");
}
/**
* B73-03:代理凭据的分组身份=**供应商账号**,不是「哪个模块里的哪一行配置」。
*
* <p>同一把青果 key 只是参数顺序写得不一样(或配在两行上),旧口径按 moduleKey|channel|密文
* 算成两组 ⇒ 一轮真打两枪提取;而青果整个账号只有 1 条通道(2026-11-02 用户在控制台核实),
* 第一枪还占着 ⇒ 第二枪必然 channel_busy,巡检自己把用户的代理打成「代理异常」。
* 现在折成 (供应商, 提取域, 归一化 query) ⇒ 同账号只出一枪。
*/
@Test
void schedulerProbesSameProxyAccountOnceAcrossParamOrder() {
UserApiSecretService service = newService();
String linkA = "enc:https://overseas.proxy.qg.net/get?key=QK&pwd=QP";
String linkB = "enc:https://overseas.proxy.qg.net/get?pwd=QP&key=QK";
stubInspectionStore(Map.of(
11L, storedRow(11L, "proxy", linkA),
12L, storedRow(12L, "proxy", linkB)));
when(checkService.probe(any(), anyString(), any())).thenReturn(outcome("passed", "ok", "代理可用", 120));
when(mapper.selectList(any())).thenReturn(List.of(
inspectionRow(1L, 11L, "proxy", linkA),
inspectionRow(2L, 12L, "proxy", linkB)), List.of());
var summary = service.checkAllForScheduler(500, 20);
verify(checkService, times(1)).probe(any(), anyString(), any());
assertThat(summary.probed()).isEqualTo(1);
assertThat(summary.checked()).isEqualTo(2);
assertThat(inspectionWrites.keySet()).containsExactlyInAnyOrder(11L, 12L);
}
/**
* 另一半边界:非链接型凭据(LLM 密钥)**不得**跟着一起折——
* 同一串密钥在两个模块/两条渠道上是两次独立探测,合并会拿 A 的结论冒充 B。
*/
@Test
void schedulerKeepsPerModuleGroupingForNonLinkSecrets() {
UserApiSecretService service = newService();
String sharedApiKey = "enc:sk-shared-LLMKEY";
stubInspectionStore(Map.of(
11L, storedRow(11L, "similar-asin", sharedApiKey),
12L, storedRow(12L, "appearance-patent", sharedApiKey)));
when(checkService.probe(any(), anyString(), any())).thenReturn(outcome("passed", "ok", "可用", 90));
when(mapper.selectList(any())).thenReturn(List.of(
inspectionRow(1L, 11L, "similar-asin", sharedApiKey),
inspectionRow(2L, 12L, "appearance-patent", sharedApiKey)), List.of());
service.checkAllForScheduler(500, 20);
verify(checkService, times(2)).probe(any(), anyString(), any());
}
/** 失败结论同样整组复用:否则一把欠费的 key 会按账号数重复付费提取。 */
@Test
void schedulerReusesFailedOutcomeAcrossSharedSecretGroup() {
@@ -39,7 +39,7 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
* 那条数是 {@code grep -rl 'sourceText('} 数出来的,而第 9 支是 {@code SourceScan.java:22} 里
* {@code public static String sourceText(String fileName)} 这行<b>被调方自己的声明</b>——它不是调用点。
* 所以真实形状是 <b>调用点/调用方/引用方三类数各自成立</b>(2026-10-28 v1.1 Phase 0 起调用方 16 支、
* 裸名 23 个,增量逐笔登记在 {@code REGISTERED_BARE_NAMES} 的注释里)。下面第 3 格把这些数同时钉住,
* 裸名 24 个,增量逐笔登记在 {@code REGISTERED_BARE_NAMES} 的注释里)。下面第 3 格把这些数同时钉住,
* 免得下一个人拿 {@code grep} 再数一遍又把声明算进去。</p>
*/
class SourceScanTest {
@@ -82,7 +82,14 @@ class SourceScanTest {
// TaskOwnerReadSourceGuardrailTest 要钉「被拒时必须先改挂再退回」这一枚顺序,
// 顺序错在 deferRunning 把行翻成 PENDING 之后 handOffToOwner 的 CAS 就打不中,
// 用 mock 造不出这个先后(它要跑的正是 catch 块里两行的次序),只能打在源码连线上。
"TaskResultFileJobWorker.java");
"TaskResultFileJobWorker.java",
// —— 2026-11-03 Phase 2 ④(B74-04 归属回落收成唯一出处)追加(1 名)——
// TaskOwnerReadSourceGuardrailTest 除了钉「列优先」,还必须钉住回落顺序本身:
// 四台此前各读各的 JSON(三台 result_json、店铺采集 request_json),列缺失的存量行
// 因此能算出两个归属。回落口径合并成 TaskOwnerJsonFallback 一处之后,判据只能打在
// "那一处确实按 result_json → request_json 的顺序读"这条源码连线上——mock 造不出
// "谁先谁后",四份夹具各测一遍照样全绿。
"TaskOwnerJsonFallback.java");
@TempDir
Path tmp;
@@ -98,7 +105,7 @@ class SourceScanTest {
}
@Test
void census_唯一裸名恰为23且与已登记集合相等() {
void census_唯一裸名恰为24且与已登记集合相等() {
Set<String> found = SourceScan.censusSourceTextCallSites().stream()
.map(SourceScan.CallSite::bareName)
.collect(Collectors.toSet());
@@ -106,7 +113,7 @@ class SourceScanTest {
assertThat(found)
.as("唯一裸名集合必须与类头台账逐字相等——多一个说明有人新引了单文件口径,少一个说明尺子漏扫")
.isEqualTo(REGISTERED_BARE_NAMES)
.hasSize(23);
.hasSize(24);
}
@Test