refactor(phase-3): 首迁 ShopMatch 接入管线底座,顺手补齐三件实测缺件

蓝图 §5 Phase 2 那条「两支公共件目前零生产调用方、契约可用只由单测证明」在本笔解除:
ShopMatchTaskService 现在真的继承 AbstractShopPayloadTaskPipeline,submitResult 的
「准入→取锁→按店名建索引→逐行合并→changed 闸门→重算状态」整段改为骨架调用,
本支只留 applyShopResultRow 与 onShopRowsRecomputed 两个钩子——判序(先合并再判 error)
留在被迁支里,家族层 javadoc 点名「刻意不沉」的就是它,没动。

底座缺件三件,都是「换不上就是本类缺件」那条规则的实测产物:
① newTaskHeader/newScopeRow 各加一枚带显式时刻的重载。ShopMatch 建单用的是
   now()=LocalDateTime.now(Asia/Shanghai) 且同一枚时刻复用给每一行结果行,
   底座原来只有默认时区、逐行各取一次那一版——直接套上去就把建单时间整体挪了,
   而这条快照量不出来(时钟刻意不进快照)。PriceTrack 那一派仍用五参/六参默认版。
② writeJson:Phase 2 登记「随 Phase 3 首迁同笔落」的那件,这笔落了。
   捕获账因此是净减(整树 total 1003→1002、RETHROW 387→386 正落在下限上、decoy 0),
   没有放宽任何一格;task 模块内部那三份逐字同名件仍未归并——归并会跌破 RETHROW 下限,
   那是「调整门禁判据」动作,与 Phase 0 三格守卫同批做,不在迁移笔里顺手干。
③ onPayloadIndexed(默认空实现):底座刻意不打日志,而 PriceTrack:617 有一句
   「received payloadShopCount/payloadKeys」卡在准入之后、行循环之前、每次回传恰好一次。
   没有这一格,那句要么丢、要么得挪位置——挪位置就是改现网可观测行为。

迁移登记的三处步序微差(可见结果相同,逐条对过 golden):shops 非空检查从锁内移到锁外、
锁内那次重复的 taskId 检查改由准入序列承担、旧 :670 那枚没人用的 workRoot 死局部变量摘掉
(组装在 processResultFileJob 里各建各的,本层从未写过那个目录)。

证据:shopmatch 两条 golden(建单 5 例+回传流水 5 例)迁移后逐字节未动;
CatchSilence/TaskLifecycleDebt/TaskStatusVocabulary/ArchitectureBoundary(task→业务 0)
四把尺同批复跑全绿;ShopMatchTaskService 2027→2026 行(readability 只许降这条满足)。
This commit is contained in:
2026-10-18 20:47:10 +08:00
parent 121ae9b064
commit 1be4d766bb
5 changed files with 384 additions and 144 deletions
@@ -130,6 +130,36 @@ class AbstractFileTaskPipelineTest {
verify(fileTaskMapper, times(1)).insert(task);
}
@Test
void explicitCreatedAtIsStampedVerbatimOnBothColumns() {
// ShopMatch:462→:484-485 用的是 now()=LocalDateTime.now(Asia/Shanghai),
// 底座默认那套是 JVM 时区——首迁实测出来的缺件,时刻只能由被迁支交进来。
java.time.LocalDateTime businessNow = java.time.LocalDateTime.of(2026, 10, 18, 9, 5, 3);
FileTaskEntity task = pipeline.newTaskHeader("SCHEDULED", "PYTHON_QUEUE", 7L, "dev", 2, businessNow);
assertEquals(businessNow, task.getCreatedAt());
assertEquals(businessNow, task.getUpdatedAt(), "两列同一个时刻(现网就复用同一枚 now)");
}
@Test
void fiveArgHeaderStillFallsBackToTheWallClock() {
java.time.LocalDateTime before = java.time.LocalDateTime.now();
FileTaskEntity task = pipeline.newTaskHeader("RUNNING", "PYTHON_QUEUE", 7L, "dev", 1);
assertTrue(!task.getCreatedAt().isBefore(before), "五参版仍是默认时区的 now()(PriceTrack:512-513 那一派)");
assertTrue(!task.getCreatedAt().isAfter(before.plusMinutes(1)));
}
@Test
void scopeRowsShareOneInstantWhenTheBranchPassesIt() {
java.time.LocalDateTime businessNow = java.time.LocalDateTime.of(2026, 10, 18, 9, 5, 3);
FileResultEntity first = pipeline.newScopeRow(1L, 9L, "a", "ua", null, 0, businessNow);
FileResultEntity second = pipeline.newScopeRow(1L, 9L, "b", "ub", null, 0, businessNow);
assertEquals(businessNow, first.getCreatedAt());
assertEquals(first.getCreatedAt(), second.getCreatedAt(),
"ShopMatch:503 把建单那一枚 now 复用给每一行,逐行各取一次就不是同一件事");
}
@Test
void scopeRowKeepsNullableColumnsUntouched() {
// ShopDataCrawl/ShopMatch 建单时不写 rowCount,AppearancePatent 不写 success:
@@ -364,6 +394,44 @@ class AbstractFileTaskPipelineTest {
return Files.write(dir.resolve(name), content.getBytes(StandardCharsets.UTF_8)).toFile();
}
// ------------------------------------------------------------------
// 序列化公共件(随 Phase 3 首迁落下那一件)
// ------------------------------------------------------------------
@Test
void writeJsonHandsBackExactlyWhatTheMapperProduced() throws Exception {
com.fasterxml.jackson.databind.ObjectMapper mapper =
mock(com.fasterxml.jackson.databind.ObjectMapper.class);
when(mapper.writeValueAsString(any())).thenReturn("{\"k\":1}");
assertEquals("{\"k\":1}", pipeline.writeJson(mapper, java.util.Map.of("k", 1), "序列化任务数据失败"));
verify(mapper, times(1)).writeValueAsString(any());
}
@Test
void writeJsonReplacesFailureWithTheBranchOwnMessageAndKeepsNoCause() throws Exception {
com.fasterxml.jackson.databind.ObjectMapper mapper =
mock(com.fasterxml.jackson.databind.ObjectMapper.class);
when(mapper.writeValueAsString(any())).thenThrow(new IllegalStateException("serializer blew up"));
BusinessException ex = assertThrows(BusinessException.class,
() -> pipeline.writeJson(mapper, new Object(), "task 不存在"));
assertEquals("task 不存在", ex.getMessage(), "文案逐字取被迁支现网那句(Python 按它决定要不要重试)");
assertNull(ex.getCause(), "七支的形状都是「不带 cause」——带上就等于悄悄改日志体积");
}
@Test
void writeJsonCatchesSerializerRuntimeExceptionsNotOnlyJsonOnes() throws Exception {
// 被迁支原样是宽捕获(catch (Exception));收窄成 JsonProcessingException 会让
// 序列化器自己抛的 RuntimeException 从「拒单」变成「冒出去」,那是行为变更,不归本件。
com.fasterxml.jackson.databind.ObjectMapper mapper =
mock(com.fasterxml.jackson.databind.ObjectMapper.class);
when(mapper.writeValueAsString(any())).thenThrow(new NullPointerException("getter threw"));
assertThrows(BusinessException.class, () -> pipeline.writeJson(mapper, new Object(), "序列化任务数据失败"));
}
/** 被测底座的具体子类:只补三个钩子,公共件一律不重写(重写就等于没沉)。 */
private static class TestPipeline extends AbstractFileTaskPipeline<Map<String, Object>> {
@@ -199,6 +199,85 @@ class AbstractShopPayloadTaskPipelineTest {
assertEquals("shop-match", tagged.submissionLockLogTag());
}
// ------------------------------------------------------------------
// 载荷观察点(首迁实测缺件:PriceTrack:617 那句 received 日志的位置)
// ------------------------------------------------------------------
@Test
void payloadIsObservedOnceAfterAdmissionAndBeforeTheRowLoop() {
when(fileResultMapper.selectList(any())).thenReturn(List.of(row("shop-a"), row("shop-b")));
pipeline.submitShopScopedResults(1L, List.of("Shop-A"), String::valueOf,
AbstractFileTaskPipeline.TerminalRejection.IDEMPOTENT, null);
assertEquals(List.of("observed", "handle:shop-a", "recomputed"), pipeline.order,
"观察点必须卡在「准入已过、索引已建、行还没开始处理」——早一秒晚一秒都拿不到 PriceTrack 那句日志的语义");
assertEquals(1, pipeline.observedTasks.size(), "每次回传恰好观察一次,不是每行一次");
assertSame(pipeline.loadedTask, pipeline.observedTasks.get(0), "拿到的是准入后的那一枚任务实体");
assertEquals(List.of("shop-a"), List.copyOf(pipeline.observedIndexes.get(0).keySet()),
"拿到的是归一化之后的索引(payloadKeys 就是它)");
}
@Test
void observationIsSkippedOnEveryRejectionPath() {
FileTaskEntity finished = runningTask();
finished.setStatus("SUCCESS");
pipeline.loadedTask = finished;
assertThrows(BusinessException.class, () -> pipeline.submitShopScopedResults(1L, List.of("Shop-A"),
String::valueOf, AbstractFileTaskPipeline.TerminalRejection.IDEMPOTENT, null));
pipeline.loadedTask = runningTask();
assertThrows(BusinessException.class, () -> pipeline.submitShopScopedResults(1L, List.of(),
String::valueOf, AbstractFileTaskPipeline.TerminalRejection.IDEMPOTENT, null));
assertThrows(BusinessException.class, () -> pipeline.submitShopScopedResults(0L, List.of("Shop-A"),
String::valueOf, AbstractFileTaskPipeline.TerminalRejection.IDEMPOTENT, null));
assertTrue(pipeline.order.isEmpty(), "被拒的回传一条都不该被观察到,否则 received 日志会在拒绝路径上冒出来");
}
@Test
void branchesThatDoNotOverrideTheObserverStillRunUnchanged() {
// ShopMatch 一个字都不改就走这条路径 ⇒ 默认实现必须是真空着:既不吞调用,也不替别人打日志。
// 这里刻意造一支**没有覆写观察点**的子类:它只需要能跑完,跑不完就是默认实现写坏了。
List<String> handled = new ArrayList<>();
AbstractShopPayloadTaskPipeline<String> untouched =
new AbstractShopPayloadTaskPipeline<String>(mock(FileTaskMapper.class), fileResultMapper,
lockService, mock(TaskFileJobService.class), mock(OssStorageService.class)) {
@Override
protected String moduleType() {
return MODULE_TYPE;
}
@Override
protected FileTaskEntity loadTaskForSubmission(Long taskId) {
return runningTask();
}
@Override
protected String normalizeShopKey(String rawShopName) {
return rawShopName == null ? null : rawShopName.trim().toLowerCase();
}
@Override
protected void applyShopResultRow(Long taskId, FileTaskEntity task, FileResultEntity row,
String shopKey, String incoming) {
handled.add(shopKey);
}
@Override
protected void onShopRowsRecomputed(FileTaskEntity task, List<FileResultEntity> latestRows) {
handled.add("recomputed:" + latestRows.size());
}
};
when(fileResultMapper.selectList(any())).thenReturn(List.of(row("shop-a")));
untouched.submitShopScopedResults(1L, List.of("Shop-A"), String::valueOf,
AbstractFileTaskPipeline.TerminalRejection.IDEMPOTENT, null);
assertEquals(List.of("shop-a", "recomputed:1"), handled,
"没覆写观察点的子类,段 3 骨架的产出与覆写前逐字相同(默认实现不改变任何形状)");
}
// ------------------------------------------------------------------
// 夹具
// ------------------------------------------------------------------
@@ -227,6 +306,10 @@ class AbstractShopPayloadTaskPipelineTest {
final List<Handled> handled = new ArrayList<>();
final List<List<FileResultEntity>> recomputed = new ArrayList<>();
final List<String> normalized = new ArrayList<>();
// 观察点契约用:副作用的**先后**才是这一格的內容,光数次数证明不了它卡在准入之后、行循环之前
final List<String> order = new ArrayList<>();
final List<FileTaskEntity> observedTasks = new ArrayList<>();
final List<java.util.Map<String, String>> observedIndexes = new ArrayList<>();
RuntimeException failOnHandle;
ShopPipeline(FileTaskMapper fileTaskMapper,
@@ -253,12 +336,20 @@ class AbstractShopPayloadTaskPipelineTest {
return rawShopName == null ? null : rawShopName.trim().toLowerCase();
}
@Override
protected void onPayloadIndexed(FileTaskEntity task, java.util.Map<String, String> payloadByShopKey) {
observedTasks.add(task);
observedIndexes.add(new java.util.LinkedHashMap<>(payloadByShopKey));
order.add("observed");
}
@Override
protected void applyShopResultRow(Long taskId,
FileTaskEntity task,
FileResultEntity row,
String shopKey,
String incoming) {
order.add("handle:" + shopKey);
if (failOnHandle != null) {
throw failOnHandle;
}
@@ -267,6 +358,7 @@ class AbstractShopPayloadTaskPipelineTest {
@Override
protected void onShopRowsRecomputed(FileTaskEntity task, List<FileResultEntity> latestRows) {
order.add("recomputed");
recomputed.add(latestRows);
}
}