diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/deletebrand/service/DeleteBrandStaleTaskService.java b/backend-java/src/main/java/com/nanri/aiimage/modules/deletebrand/service/DeleteBrandStaleTaskService.java
index baeb27a38..8890b9a52 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/deletebrand/service/DeleteBrandStaleTaskService.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/deletebrand/service/DeleteBrandStaleTaskService.java
@@ -12,6 +12,7 @@ import com.nanri.aiimage.modules.queryasin.service.QueryAsinTaskService;
import com.nanri.aiimage.modules.productrisk.service.ProductRiskTaskService;
import com.nanri.aiimage.modules.patroldelete.service.PatrolDeleteTaskCacheService;
import com.nanri.aiimage.modules.patroldelete.service.PatrolDeleteTaskService;
+import com.nanri.aiimage.modules.pricetrack.service.PriceTrackLoopRunStaleService;
import com.nanri.aiimage.modules.pricetrack.service.PriceTrackTaskCacheService;
import com.nanri.aiimage.modules.pricetrack.service.PriceTrackTaskService;
import com.nanri.aiimage.modules.similarasin.service.SimilarAsinTaskService;
@@ -75,6 +76,8 @@ public class DeleteBrandStaleTaskService {
private final ProductRiskTaskCacheService productRiskTaskCacheService;
private final PriceTrackTaskService priceTrackTaskService;
private final PriceTrackTaskCacheService priceTrackTaskCacheService;
+ /** 跟价循环批次(biz_price_track_loop_run)的卡死轮次兜底回收。 */
+ private final PriceTrackLoopRunStaleService priceTrackLoopRunStaleService;
private final ShopMatchTaskService shopMatchTaskService;
private final ShopMatchTaskCacheService shopMatchTaskCacheService;
private final PatrolDeleteTaskService patrolDeleteTaskService;
@@ -112,6 +115,10 @@ public class DeleteBrandStaleTaskService {
failStaleDeleteBrandTasks();
ProductRiskStaleCheckStats stats = failStaleProductRiskResolveTasks();
PriceTrackStaleCheckStats priceTrackStats = failStalePriceTrackTasks();
+ // 跟价轮次(父实体)的卡死回收:上面那条只覆盖 biz_file_task 子任务,
+ // 轮次本身停 RUNNING 无人管(前端页面一关就再没有任何驱动)
+ PriceTrackLoopRunStaleService.StaleLoopRunStats priceTrackLoopStats =
+ priceTrackLoopRunStaleService.failStaleLoopRuns();
ShopMatchStaleCheckStats shopMatchStats = failStaleShopMatchTasks();
ShopMatchStaleCheckStats patrolDeleteStats = failStalePatrolDeleteTasks();
ShopMatchStaleCheckStats queryAsinStats = failStaleQueryAsinTasks();
@@ -126,9 +133,10 @@ public class DeleteBrandStaleTaskService {
// 周期每 2 分钟一轮,各模块 summary 合并为单行,避免定期刷屏
// 注意:每段占位符数量必须与实参一致——此前每段 5 个占位符只传 4 个参数,
// 导致 withdraw 之后的取值整体错位、末尾 elapsedMs/thread 打成字面量
- log.info("[stale-check] summary product-risk(s={} f={} x={} p={}) price-track(s={} f={} x={} p={}) shop-match(s={} f={} x={} p={}) patrol-delete(s={} f={} x={} p={}) query-asin(s={} f={} x={} p={}) withdraw(s={} f={} x={} p={}) no-upload(c={} f={} x={}) resume(s={} r={} k={} u={}) elapsedMs={} thread={}",
+ log.info("[stale-check] summary product-risk(s={} f={} x={} p={}) price-track(s={} f={} x={} p={}) price-track-loop(s={} f={} p={} r={} x={}) shop-match(s={} f={} x={} p={}) patrol-delete(s={} f={} x={} p={}) query-asin(s={} f={} x={} p={}) withdraw(s={} f={} x={} p={}) no-upload(c={} f={} x={}) resume(s={} r={} k={} u={}) elapsedMs={} thread={}",
stats.scannedTaskCount, stats.finalizedTaskCount, stats.failedTaskCount, stats.skippedTaskCount,
priceTrackStats.scannedTaskCount, priceTrackStats.finalizedTaskCount, priceTrackStats.failedTaskCount, priceTrackStats.skippedTaskCount,
+ priceTrackLoopStats.scannedLoopRunCount, priceTrackLoopStats.failedLoopRunCount, priceTrackLoopStats.stoppedLoopRunCount, priceTrackLoopStats.finalizedLoopRunCount, priceTrackLoopStats.skippedLoopRunCount,
shopMatchStats.scannedTaskCount, shopMatchStats.finalizedTaskCount, shopMatchStats.failedTaskCount, shopMatchStats.skippedTaskCount,
patrolDeleteStats.scannedTaskCount, patrolDeleteStats.finalizedTaskCount, patrolDeleteStats.failedTaskCount, patrolDeleteStats.skippedTaskCount,
queryAsinStats.scannedTaskCount, queryAsinStats.finalizedTaskCount, queryAsinStats.failedTaskCount, queryAsinStats.skippedTaskCount,
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/pricetrack/service/PriceTrackLoopRunStaleService.java b/backend-java/src/main/java/com/nanri/aiimage/modules/pricetrack/service/PriceTrackLoopRunStaleService.java
new file mode 100644
index 000000000..41a012a04
--- /dev/null
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/pricetrack/service/PriceTrackLoopRunStaleService.java
@@ -0,0 +1,246 @@
+package com.nanri.aiimage.modules.pricetrack.service;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
+import com.nanri.aiimage.modules.pricetrack.mapper.PriceTrackLoopRunMapper;
+import com.nanri.aiimage.modules.pricetrack.model.entity.PriceTrackLoopRunEntity;
+import com.nanri.aiimage.modules.task.mapper.FileTaskMapper;
+import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+
+import java.time.LocalDateTime;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+/**
+ * 跟价循环批次(biz_price_track_loop_run)「卡死轮次」的兜底回收。
+ *
+ *
为什么需要:轮次的推进(下一店 / 下一轮 / 收尾)全部由前端页面驱动——
+ * 前端在 while 循环里调 dispatch-next 拿子任务、轮询子任务结束后调 child-finished。
+ * 页面一关这个驱动就没了,轮次会永久停在 RUNNING:既没有子任务在跑,也没有任何人
+ * 来推进它。生产库 2026-09-22 存量 146 条 RUNNING,其中 125 条是这种僵尸,
+ * 最早的可追溯到 4 月。
+ *
+ *
关键约束:不能拿 loop_run.updated_at 当判据。子任务长跑期间没有任何东西
+ * 会刷新轮次表(心跳只写 biz_file_task 与 Redis 的 price-track:task:heartbeat),
+ * 所以一个正在正常跟价、子任务已跑了 36 小时的轮次,它的 updated_at 同样停在
+ * 36 小时前——按 updated_at 判死会误杀长任务。判据必须落在 active_task_id 指向的
+ * 那条子任务上。
+ *
+ *
处置分四种:
+ *
+ * - 用户已请求停止(stop_requested=1)→ STOPPED,尊重停止意图(与 dispatchNext /
+ * handleChildFinished 的既有语义一致)
+ * - active_task_id 为空且超过阈值 → FAILED,前端已停止派发下一店
+ * - active_task_id 指向的子任务行已不存在 → FAILED,事件链断了(用户回来也会在
+ * child-finished 报「子任务不存在」)
+ * - 子任务已终态但轮次没推进 → 补推进,复用 {@link PriceTrackLoopRunService#syncLoopRunAfterChildTerminal}
+ * 把前端漏掉的那次 child-finished 补上
+ *
+ * 子任务仍在 RUNNING 的轮次一律跳过:子任务自身由跟价子任务判死线
+ * (DeleteBrandStaleTaskService.failStalePriceTrackTasks)负责,它转终态后本服务
+ * 下一轮自然接住。
+ *
+ * 刻意不做自动续跑:跟价是写操作(会真实改价),让一个用户早就关掉页面的
+ * 轮次自己重新跑起来,风险不可接受。这也与 TaskResumeService 刻意排除写操作模块的
+ * 原则一致。
+ *
+ *
由 DeleteBrandStaleTaskService 的 stale-check 巡检线每 2 分钟调用一次
+ * (沿用 P1-8 约定:委派式判死统一挂该线,不自建 @Scheduled)。
+ */
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class PriceTrackLoopRunStaleService {
+
+ private static final String STATUS_RUNNING = "RUNNING";
+ private static final String STATUS_FAILED = "FAILED";
+ private static final String STATUS_STOPPED = "STOPPED";
+
+ /** 子任务终态集合,与 PriceTrackLoopRunService.isChildTaskTerminal 口径一致。 */
+ private static final Set CHILD_TERMINAL_STATUSES = Set.of("SUCCESS", "FAILED", "STOPPED");
+
+ /** 单轮最多扫描的轮次数,其余留给下一轮(每 2 分钟一次),避免一次扫太多拖慢巡检。 */
+ static final int MAX_LOOP_RUNS_PER_SCAN = 200;
+
+ private final PriceTrackLoopRunMapper loopRunMapper;
+ private final FileTaskMapper fileTaskMapper;
+ private final PriceTrackLoopRunService loopRunService;
+
+ /**
+ * 「轮次在等前端派发下一店」超过多少分钟算废弃(默认 120)。
+ *
+ * 这个阈值等于「放弃等待用户回来」的时间:前端把轮次 id 存在 localStorage,
+ * 用户重新打开页面会自动 resume,所以只要没判死就还能接着跑;判死后用户再打开
+ * 会看到失败,需要重新配置店铺重跑。取 2 小时是因为正常的两店间隔只有几秒
+ * (前端 while 循环紧接着调 dispatch-next),2 小时足以排除任何正常瞬态。
+ */
+ @Value("${aiimage.price-track.loop-run-stale-minutes:120}")
+ private long staleMinutes = 120;
+
+ /**
+ * 回收卡死的跟价轮次。
+ *
+ * @return 单轮统计,合并进 stale-check 的 summary 日志
+ */
+ public StaleLoopRunStats failStaleLoopRuns() {
+ StaleLoopRunStats stats = new StaleLoopRunStats();
+ long minutes = Math.max(1L, staleMinutes);
+ LocalDateTime now = LocalDateTime.now();
+ LocalDateTime threshold = now.minusMinutes(minutes);
+
+ // 候选取「RUNNING 且(active 为空但已陈旧,或 active 非空)」:
+ // active 为空且 updated_at 很新 = 前端正在两店之间正常派发(正常只持续几秒),绝不碰。
+ List candidates = loopRunMapper.selectList(
+ new LambdaQueryWrapper()
+ .eq(PriceTrackLoopRunEntity::getStatus, STATUS_RUNNING)
+ .and(w -> w.isNull(PriceTrackLoopRunEntity::getActiveTaskId)
+ .lt(PriceTrackLoopRunEntity::getUpdatedAt, threshold)
+ .or().isNotNull(PriceTrackLoopRunEntity::getActiveTaskId))
+ .last("limit " + MAX_LOOP_RUNS_PER_SCAN));
+ stats.scannedLoopRunCount = candidates.size();
+ if (candidates.isEmpty()) {
+ return stats;
+ }
+
+ // 批量取子任务,避免逐条 selectById(候选最多 200 条)
+ Set childIds = candidates.stream()
+ .map(PriceTrackLoopRunEntity::getActiveTaskId)
+ .filter(id -> id != null && id > 0)
+ .collect(Collectors.toSet());
+ Map childById = childIds.isEmpty()
+ ? Map.of()
+ : fileTaskMapper.selectBatchIds(childIds).stream()
+ .collect(Collectors.toMap(FileTaskEntity::getId, task -> task,
+ (a, b) -> a, LinkedHashMap::new));
+
+ log.info("[stale-check] price-track-loop candidates={} threshold={} staleMinutes={}",
+ candidates.size(), threshold, minutes);
+
+ for (PriceTrackLoopRunEntity entity : candidates) {
+ try {
+ reclaimLoopRun(entity, childById, now, stats);
+ } catch (Exception ex) {
+ // 单条失败不影响其余:本轮跳过,2 分钟后下一轮自然重试
+ stats.skippedLoopRunCount++;
+ log.warn("[stale-check] price-track-loop 回收单条失败 loopRunId={} msg={}",
+ entity.getId(), ex.getMessage(), ex);
+ }
+ }
+ return stats;
+ }
+
+ /** 单条轮次的回收分流。 */
+ private void reclaimLoopRun(PriceTrackLoopRunEntity entity, Map childById,
+ LocalDateTime now, StaleLoopRunStats stats) {
+ boolean stopRequested = Boolean.TRUE.equals(entity.getStopRequested());
+ Long activeTaskId = entity.getActiveTaskId();
+
+ // ① active 为空:前端在两店之间停止了(正常只持续几秒,超过阈值说明页面已关且没再打开)
+ if (activeTaskId == null || activeTaskId <= 0) {
+ if (stopRequested) {
+ markStopped(entity, now, stats);
+ } else {
+ markFailed(entity, "循环长时间无进展(前端已停止派发下一店),已自动结束", now, stats);
+ }
+ return;
+ }
+
+ FileTaskEntity child = childById.get(activeTaskId);
+ // ② 子任务行已不存在:事件链已断,用户回来也会在 child-finished 报「子任务不存在」
+ if (child == null) {
+ if (stopRequested) {
+ markStopped(entity, now, stats);
+ } else {
+ markFailed(entity, "循环子任务已不存在,循环已自动结束", now, stats);
+ }
+ return;
+ }
+
+ // ③ 子任务还在跑:判死交给跟价子任务判死线,本轮不动轮次(它终态后下一轮自然接住)
+ if (!isChildTerminal(child)) {
+ stats.skippedLoopRunCount++;
+ return;
+ }
+
+ // ④ 子任务已终态但轮次仍 RUNNING:前端漏掉了那次 child-finished,服务端补推进
+ if (stopRequested) {
+ // 停止意图优先于补推进(否则点完停止循环还会自己转起来)
+ markStopped(entity, now, stats);
+ return;
+ }
+ try {
+ loopRunService.syncLoopRunAfterChildTerminal(activeTaskId);
+ stats.finalizedLoopRunCount++;
+ log.info("[stale-check] price-track-loop 补推进漏掉的收尾 loopRunId={} childTaskId={} childStatus={}",
+ entity.getId(), activeTaskId, child.getStatus());
+ } catch (Exception ex) {
+ // 补推进失败(子任务不属于该循环 / 上下文缺失等)→ 判死,不留孤儿
+ markFailed(entity, "循环子任务收尾异常,循环已自动结束", now, stats);
+ log.warn("[stale-check] price-track-loop 补推进失败改判死 loopRunId={} childTaskId={} msg={}",
+ entity.getId(), activeTaskId, ex.getMessage());
+ }
+ }
+
+ private void markStopped(PriceTrackLoopRunEntity entity, LocalDateTime now, StaleLoopRunStats stats) {
+ if (casUpdateStatus(entity.getId(), STATUS_STOPPED, null, now)) {
+ stats.stoppedLoopRunCount++;
+ log.info("[stale-check] price-track-loop 回收为已停止 loopRunId={} userId={}",
+ entity.getId(), entity.getUserId());
+ } else {
+ // 影响 0 行 = 这几秒内已被并发改写(前端刚好推进了轮次),不覆盖
+ stats.skippedLoopRunCount++;
+ }
+ }
+
+ private void markFailed(PriceTrackLoopRunEntity entity, String reason, LocalDateTime now, StaleLoopRunStats stats) {
+ if (casUpdateStatus(entity.getId(), STATUS_FAILED, reason, now)) {
+ stats.failedLoopRunCount++;
+ log.warn("[stale-check] price-track-loop 判失败 loopRunId={} userId={} round={}/{} shopIndex={} reason={}",
+ entity.getId(), entity.getUserId(), entity.getCurrentRound(), entity.getTargetRounds(),
+ entity.getCurrentShopIndex(), reason);
+ } else {
+ stats.skippedLoopRunCount++;
+ }
+ }
+
+ /**
+ * 字段级 CAS 更新:只从 RUNNING 改。
+ *
+ * 不用整行 updateById——那会拿读取时的快照覆盖并发写入的字段(前端在这几秒内
+ * 刚好推进轮次、或用户刚好点了停止),既有 bindChildTask / requestStop 也出于同样
+ * 原因走字段级更新。影响 0 行即视为已被并发改写,调用方按跳过处理。
+ */
+ private boolean casUpdateStatus(Long loopRunId, String status, String errorMessage, LocalDateTime now) {
+ return loopRunMapper.update(null, new LambdaUpdateWrapper()
+ .eq(PriceTrackLoopRunEntity::getId, loopRunId)
+ .eq(PriceTrackLoopRunEntity::getStatus, STATUS_RUNNING)
+ .set(PriceTrackLoopRunEntity::getStatus, status)
+ .set(PriceTrackLoopRunEntity::getActiveTaskId, null)
+ .set(PriceTrackLoopRunEntity::getErrorMessage, errorMessage)
+ .set(PriceTrackLoopRunEntity::getFinishedAt, now)
+ .set(PriceTrackLoopRunEntity::getUpdatedAt, now)) > 0;
+ }
+
+ private static boolean isChildTerminal(FileTaskEntity child) {
+ String status = child.getStatus();
+ return status != null && CHILD_TERMINAL_STATUSES.contains(status.trim().toUpperCase(Locale.ROOT));
+ }
+
+ /** 单轮统计(合并进 stale-check 的 summary 日志,避免定期刷屏)。 */
+ public static final class StaleLoopRunStats {
+ public int scannedLoopRunCount;
+ /** 补推进(子任务已终态、轮次漏了收尾)的条数。 */
+ public int finalizedLoopRunCount;
+ public int failedLoopRunCount;
+ public int stoppedLoopRunCount;
+ public int skippedLoopRunCount;
+ }
+}
diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/deletebrand/service/DeleteBrandStaleTaskServiceTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/deletebrand/service/DeleteBrandStaleTaskServiceTest.java
index fa456fcd3..0786d33b2 100644
--- a/backend-java/src/test/java/com/nanri/aiimage/modules/deletebrand/service/DeleteBrandStaleTaskServiceTest.java
+++ b/backend-java/src/test/java/com/nanri/aiimage/modules/deletebrand/service/DeleteBrandStaleTaskServiceTest.java
@@ -11,6 +11,7 @@ import com.nanri.aiimage.modules.task.mapper.FileTaskMapper;
import com.nanri.aiimage.modules.task.mapper.TaskScopeStateMapper;
import com.nanri.aiimage.modules.task.model.dto.TaskScopeLastChunkDto;
import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
+import com.nanri.aiimage.modules.pricetrack.service.PriceTrackLoopRunStaleService;
import com.nanri.aiimage.modules.task.service.TaskDistributedLockService;
import com.nanri.aiimage.modules.task.service.TaskFileJobService;
import com.nanri.aiimage.modules.task.service.TaskHeartbeatPositionService;
@@ -61,6 +62,7 @@ class DeleteBrandStaleTaskServiceTest {
@Mock private ProductRiskTaskCacheService productRiskTaskCacheService;
@Mock private TaskHeartbeatPositionService taskHeartbeatPositionService;
@Mock private TaskResumeService taskResumeService;
+ @Mock private PriceTrackLoopRunStaleService priceTrackLoopRunStaleService;
@BeforeAll
static void initializeTableInfo() {
@@ -379,6 +381,9 @@ class DeleteBrandStaleTaskServiceTest {
// 续跑巡检在判死主流程里被调用:默认返回空统计(无中断任务可续跑);
// 只有跑到 failStaleRunningTasks 的用例会用到,故 lenient
lenient().when(taskResumeService.resumeInterruptedTasks()).thenReturn(new TaskResumeService.ResumeStats());
+ // 跟价轮次兜底回收同样在判死主流程里被调用:默认返回空统计
+ lenient().when(priceTrackLoopRunStaleService.failStaleLoopRuns())
+ .thenReturn(new PriceTrackLoopRunStaleService.StaleLoopRunStats());
}
private void noUploadTaskLockAvailable() {
@@ -400,8 +405,8 @@ class DeleteBrandStaleTaskServiceTest {
return new DeleteBrandStaleTaskService(
fileTaskMapper, deleteBrandTaskCacheService, deleteBrandTaskStorageService, deleteBrandRunService,
productRiskTaskService, productRiskTaskCacheService,
- null, null, null, null, null, null, null, null, null, null,
- null, null, null,
+ null, null, priceTrackLoopRunStaleService, null, null, null, null, null, null, null,
+ null, null, null, null,
deleteBrandProgressProperties, null, taskDistributedLockService, taskFileJobService, null,
taskScopeStateMapper, taskHeartbeatPositionService, taskResumeService);
}
diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/deletebrand/service/TaskModuleCoverageTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/deletebrand/service/TaskModuleCoverageTest.java
index 05e76fe7e..0b3b5bf12 100644
--- a/backend-java/src/test/java/com/nanri/aiimage/modules/deletebrand/service/TaskModuleCoverageTest.java
+++ b/backend-java/src/test/java/com/nanri/aiimage/modules/deletebrand/service/TaskModuleCoverageTest.java
@@ -76,7 +76,7 @@ class TaskModuleCoverageTest {
private static DeleteBrandStaleTaskService serviceForDelegatedChecks() {
return new DeleteBrandStaleTaskService(
null, null, null, null, null, null, null, null, null, null, null, null, null, null, null,
- null,
+ null, null,
mock(BrandTaskService.class),
mock(AppearancePatentTaskService.class),
mock(SimilarAsinTaskService.class),
diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/pricetrack/service/PriceTrackLoopRunStaleServiceTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/pricetrack/service/PriceTrackLoopRunStaleServiceTest.java
new file mode 100644
index 000000000..ab8899d93
--- /dev/null
+++ b/backend-java/src/test/java/com/nanri/aiimage/modules/pricetrack/service/PriceTrackLoopRunStaleServiceTest.java
@@ -0,0 +1,264 @@
+package com.nanri.aiimage.modules.pricetrack.service;
+
+import com.baomidou.mybatisplus.core.MybatisConfiguration;
+import com.baomidou.mybatisplus.core.conditions.Wrapper;
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
+import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
+import com.nanri.aiimage.modules.pricetrack.mapper.PriceTrackLoopRunMapper;
+import com.nanri.aiimage.modules.pricetrack.model.entity.PriceTrackLoopRunEntity;
+import com.nanri.aiimage.modules.task.mapper.FileTaskMapper;
+import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
+import org.apache.ibatis.builder.MapperBuilderAssistant;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
+import org.springframework.test.util.ReflectionTestUtils;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.isNull;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * 跟价轮次卡死回收契约。
+ *
+ * 核心是「不能拿 loop_run.updated_at 当判据」——子任务长跑期间轮次表不被刷新,
+ * 正在正常跟价的轮次同样表现为 updated_at 陈旧。判据必须落在 active_task_id 指向的
+ * 那条子任务上(存在性 / 终态与否)。
+ */
+class PriceTrackLoopRunStaleServiceTest {
+
+ private final PriceTrackLoopRunMapper loopRunMapper = mock(PriceTrackLoopRunMapper.class);
+ private final FileTaskMapper fileTaskMapper = mock(FileTaskMapper.class);
+ private final PriceTrackLoopRunService loopRunService = mock(PriceTrackLoopRunService.class);
+
+ @BeforeEach
+ void initTableInfo() {
+ // LambdaWrapper 需要实体列缓存,单测无 Spring/MyBatis 上下文,手动初始化
+ MybatisConfiguration configuration = new MybatisConfiguration();
+ TableInfoHelper.initTableInfo(new MapperBuilderAssistant(configuration, ""), PriceTrackLoopRunEntity.class);
+ TableInfoHelper.initTableInfo(new MapperBuilderAssistant(configuration, ""), FileTaskEntity.class);
+ }
+
+ private PriceTrackLoopRunStaleService service() {
+ PriceTrackLoopRunStaleService svc =
+ new PriceTrackLoopRunStaleService(loopRunMapper, fileTaskMapper, loopRunService);
+ ReflectionTestUtils.setField(svc, "staleMinutes", 120L);
+ return svc;
+ }
+
+ // ---------- ① active 为空:前端已停,等不到下一店派发 ----------
+
+ @Test
+ void active_为空时判失败并清掉_active_task_id() {
+ when(loopRunMapper.selectList(any())).thenReturn(List.of(loopRun(1L, null, false)));
+ when(loopRunMapper.update(isNull(), any())).thenReturn(1);
+
+ PriceTrackLoopRunStaleService.StaleLoopRunStats stats = service().failStaleLoopRuns();
+
+ assertEquals(1, stats.failedLoopRunCount);
+ assertEquals(1, stats.scannedLoopRunCount);
+ Map params = updateParams();
+ assertTrue(params.containsValue("FAILED"), "应落 FAILED:" + params);
+ assertTrue(params.containsValue("循环长时间无进展(前端已停止派发下一店),已自动结束"));
+ // active_task_id 必须一并置空:否则终态行仍指向一个旧子任务,后续反查会误命中
+ assertTrue(params.values().stream().anyMatch(v -> v == null), "应清空 active_task_id:" + params);
+ }
+
+ @Test
+ void 候选查询携带_updated_at_陈旧阈值_新鲜的空_active_不进候选() {
+ // 真实过滤发生在 SQL 层,此处断言谓词里确实带了阈值参数(漏了就会把正常瞬态也捞进来)
+ when(loopRunMapper.selectList(any())).thenReturn(List.of());
+
+ PriceTrackLoopRunStaleService.StaleLoopRunStats stats = service().failStaleLoopRuns();
+
+ assertEquals(0, stats.scannedLoopRunCount);
+ verify(loopRunMapper, never()).update(isNull(), any());
+ Map params = selectParams();
+ assertTrue(params.values().stream().anyMatch(v -> v instanceof LocalDateTime),
+ "候选查询应带 updated_at 阈值:" + params);
+ }
+
+ // ---------- ② 子任务行已不存在:事件链断了 ----------
+
+ @Test
+ void 子任务行不存在时判失败() {
+ when(loopRunMapper.selectList(any())).thenReturn(List.of(loopRun(2L, 99L, false)));
+ when(fileTaskMapper.selectBatchIds(any())).thenReturn(List.of());
+ when(loopRunMapper.update(isNull(), any())).thenReturn(1);
+
+ PriceTrackLoopRunStaleService.StaleLoopRunStats stats = service().failStaleLoopRuns();
+
+ assertEquals(1, stats.failedLoopRunCount);
+ assertTrue(updateParams().containsValue("循环子任务已不存在,循环已自动结束"));
+ verify(loopRunService, never()).syncLoopRunAfterChildTerminal(any());
+ }
+
+ // ---------- ③ 子任务已终态:补推进 ----------
+
+ @Test
+ void 子任务已终态时补推进而不是判死() {
+ when(loopRunMapper.selectList(any())).thenReturn(List.of(loopRun(3L, 99L, false)));
+ when(fileTaskMapper.selectBatchIds(any())).thenReturn(List.of(child(99L, "SUCCESS")));
+
+ PriceTrackLoopRunStaleService.StaleLoopRunStats stats = service().failStaleLoopRuns();
+
+ assertEquals(1, stats.finalizedLoopRunCount);
+ assertEquals(0, stats.failedLoopRunCount);
+ verify(loopRunService).syncLoopRunAfterChildTerminal(99L);
+ verify(loopRunMapper, never()).update(isNull(), any());
+ }
+
+ @Test
+ void 补推进抛异常时改判死_不留孤儿() {
+ when(loopRunMapper.selectList(any())).thenReturn(List.of(loopRun(4L, 99L, false)));
+ when(fileTaskMapper.selectBatchIds(any())).thenReturn(List.of(child(99L, "FAILED")));
+ doThrow(new IllegalStateException("子任务不属于当前循环"))
+ .when(loopRunService).syncLoopRunAfterChildTerminal(99L);
+ when(loopRunMapper.update(isNull(), any())).thenReturn(1);
+
+ PriceTrackLoopRunStaleService.StaleLoopRunStats stats = service().failStaleLoopRuns();
+
+ assertEquals(1, stats.failedLoopRunCount);
+ assertTrue(updateParams().containsValue("循环子任务收尾异常,循环已自动结束"));
+ }
+
+ // ---------- ④ 子任务仍在跑:交给子任务判死线,轮次不动 ----------
+
+ @Test
+ void 子任务仍在跑时跳过_绝不碰轮次() {
+ when(loopRunMapper.selectList(any())).thenReturn(List.of(loopRun(5L, 99L, false)));
+ when(fileTaskMapper.selectBatchIds(any())).thenReturn(List.of(child(99L, "RUNNING")));
+
+ PriceTrackLoopRunStaleService.StaleLoopRunStats stats = service().failStaleLoopRuns();
+
+ assertEquals(1, stats.skippedLoopRunCount);
+ assertEquals(0, stats.failedLoopRunCount);
+ verify(loopRunMapper, never()).update(isNull(), any());
+ verify(loopRunService, never()).syncLoopRunAfterChildTerminal(any());
+ }
+
+ // ---------- 用户停止意图优先 ----------
+
+ @Test
+ void 用户已请求停止时落_STOPPED_而不是_FAILED() {
+ when(loopRunMapper.selectList(any())).thenReturn(List.of(loopRun(6L, null, true)));
+ when(loopRunMapper.update(isNull(), any())).thenReturn(1);
+
+ PriceTrackLoopRunStaleService.StaleLoopRunStats stats = service().failStaleLoopRuns();
+
+ assertEquals(1, stats.stoppedLoopRunCount);
+ assertEquals(0, stats.failedLoopRunCount);
+ Map params = updateParams();
+ assertTrue(params.containsValue("STOPPED"), "应落 STOPPED:" + params);
+ // stop_requested 本就是 true,无需(也不应)改写:只改状态与收尾字段
+ assertTrue(!params.containsValue(false));
+ }
+
+ @Test
+ void 停止意图优先于补推进() {
+ when(loopRunMapper.selectList(any())).thenReturn(List.of(loopRun(7L, 99L, true)));
+ when(fileTaskMapper.selectBatchIds(any())).thenReturn(List.of(child(99L, "SUCCESS")));
+ when(loopRunMapper.update(isNull(), any())).thenReturn(1);
+
+ PriceTrackLoopRunStaleService.StaleLoopRunStats stats = service().failStaleLoopRuns();
+
+ assertEquals(1, stats.stoppedLoopRunCount);
+ // 否则点完「停止循环」还会自己转起来
+ verify(loopRunService, never()).syncLoopRunAfterChildTerminal(any());
+ }
+
+ // ---------- CAS 并发保护 ----------
+
+ @Test
+ void CAS_影响0行时计入跳过_不谎报判死数() {
+ when(loopRunMapper.selectList(any())).thenReturn(List.of(loopRun(8L, null, false)));
+ // 这几秒内前端刚好推进了轮次,UPDATE 因 status 已不是 RUNNING 而影响 0 行
+ when(loopRunMapper.update(isNull(), any())).thenReturn(0);
+
+ PriceTrackLoopRunStaleService.StaleLoopRunStats stats = service().failStaleLoopRuns();
+
+ assertEquals(0, stats.failedLoopRunCount);
+ assertEquals(1, stats.skippedLoopRunCount);
+ }
+
+ @Test
+ void 单条异常不影响其余条目() {
+ when(loopRunMapper.selectList(any())).thenReturn(List.of(loopRun(9L, null, false), loopRun(10L, null, false)));
+ when(loopRunMapper.update(isNull(), any()))
+ .thenThrow(new IllegalStateException("db down"))
+ .thenReturn(1);
+
+ PriceTrackLoopRunStaleService.StaleLoopRunStats stats = service().failStaleLoopRuns();
+
+ assertEquals(1, stats.failedLoopRunCount);
+ assertEquals(1, stats.skippedLoopRunCount);
+ }
+
+ // ---------- helpers ----------
+
+ private static PriceTrackLoopRunEntity loopRun(Long id, Long activeTaskId, boolean stopRequested) {
+ PriceTrackLoopRunEntity entity = new PriceTrackLoopRunEntity();
+ entity.setId(id);
+ entity.setUserId(7L);
+ entity.setStatus("RUNNING");
+ entity.setActiveTaskId(activeTaskId);
+ entity.setStopRequested(stopRequested);
+ entity.setCurrentRound(1);
+ entity.setTargetRounds(1);
+ entity.setCurrentShopIndex(0);
+ entity.setUpdatedAt(LocalDateTime.now().minusHours(3));
+ return entity;
+ }
+
+ private static FileTaskEntity child(Long id, String status) {
+ FileTaskEntity task = new FileTaskEntity();
+ task.setId(id);
+ task.setModuleType("PRICE_TRACK");
+ task.setStatus(status);
+ return task;
+ }
+
+ private Map selectParams() {
+ ArgumentCaptor> captor = wrapperCaptor();
+ verify(loopRunMapper).selectList(captor.capture());
+ return paramsOf(captor.getValue());
+ }
+
+ private Map updateParams() {
+ ArgumentCaptor> captor = wrapperCaptor();
+ verify(loopRunMapper).update(isNull(), captor.capture());
+ return paramsOf(captor.getValue());
+ }
+
+ @SuppressWarnings("unchecked")
+ private static ArgumentCaptor> wrapperCaptor() {
+ return ArgumentCaptor.forClass(Wrapper.class);
+ }
+
+ /**
+ * 读取 wrapper 参数容器:MyBatis-Plus 是在生成 SQL 片段时才把参数写进
+ * paramNameValuePairs,故先触发一次。
+ */
+ @SuppressWarnings("unchecked")
+ private static Map paramsOf(Wrapper wrapper) {
+ wrapper.getSqlSegment();
+ if (wrapper instanceof LambdaUpdateWrapper) {
+ ((LambdaUpdateWrapper) wrapper).getSqlSet();
+ }
+ Map params =
+ (Map) ReflectionTestUtils.getField(wrapper, "paramNameValuePairs");
+ assertNotNull(params, "wrapper 参数容器字段名可能已变化(paramNameValuePairs)");
+ return params;
+ }
+}