fix(appearance-patent): 上游余额欠费即判任务终态,停止为空转的行烧出口

B46 那一笔(f3445c21)只做到「行级一次就停、归因写对」:撞上上游 403
insufficient_user_quota 后不再跑满 3 次重试,任务本身仍停在 RUNNING/WAIT_LLM
等 Python 继续回传分片。采集端(maixiang ap_worker)只看 /task/heartbeat 的
alive,读不到终态就继续为剩下的行按次付费买出口 IP——而那些行永远进不了 LLM,
钱白花。这一笔补上 Java 侧缺的那半步:欠费即把任务落终态 FAILED,心跳随即
回 alive=false,worker 下一跳收手。

- 判据只认 TaskRetryEligibility 的 BALANCE 类(欠费 + 密钥失效),复用现成分类器
  而非再抄一份字面量表;连接不可达 / 5xx / 429 / 抓取缺口一律照旧继续或按已有
  结果交付,判宽了就是拿用户整单给一次网络抖动陪葬。
- 停手点放在批管线的作业执行线程(LLM 批次就在这里跑),不在心跳线程;识别到
  欠费即停止后续批次,并回调宿主落终态(FileTaskMapper 与收尾口径在宿主手里)。
- 写终态前重读库里现状态:已 SUCCESS/COMPLETED/CANCELLED/FAILED 的一律不动,
  因此可重入,多入口命中也只写一次。
- 终态文案 = 生产者原文(客户端欠费归因 + 上游 lastErr)+ 可执行动作,原文一个
  字都不重写;不出现「请稍后重试」,不把欠费说成临时抖动。
This commit is contained in:
2026-10-27 15:53:10 +08:00
parent 07f973d9df
commit e08b5369d7
7 changed files with 605 additions and 5 deletions
@@ -180,7 +180,11 @@ class AppearancePatentCandidateCollectionFaultToleranceTest {
task -> "prompt",
task -> "sk-test",
(taskId, scopeHash, chunkIndex, rows) -> List.of(),
(preferred, fallback) -> preferred == null || preferred.isBlank() ? fallback : preferred);
(preferred, fallback) -> preferred == null || preferred.isBlank() ? fallback : preferred,
// 本夹具只驱动「候选收集」,永远不会进欠费终态分支;真进来了就说明测试形状变了
(fatalTask, failureMessage) -> {
throw new IllegalStateException("unexpected fatal llm failure: " + failureMessage);
});
}
private Set<String> releasedKeys() {
@@ -0,0 +1,367 @@
package com.nanri.aiimage.modules.appearancepatent.service;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.nanri.aiimage.common.retry.LlmBalanceGuard;
import com.nanri.aiimage.common.service.DistributedJobLockService;
import com.nanri.aiimage.common.service.ResultDownloadResolver;
import com.nanri.aiimage.common.task.TaskStatuses;
import com.nanri.aiimage.config.AppearancePatentProperties;
import com.nanri.aiimage.config.InstanceMetadata;
import com.nanri.aiimage.config.StorageProperties;
import com.nanri.aiimage.modules.appearancepatent.client.AppearancePatentLlmClient;
import com.nanri.aiimage.modules.appearancepatent.model.dto.AppearancePatentResultRowDto;
import com.nanri.aiimage.modules.appearancepatent.service.support.AppearancePatentResultJobSupport;
import com.nanri.aiimage.modules.appearancepatent.service.support.AppearancePatentRowOutcome;
import com.nanri.aiimage.modules.file.service.LocalFileStorageService;
import com.nanri.aiimage.modules.file.service.oss.OssStorageService;
import com.nanri.aiimage.modules.task.mapper.FileResultMapper;
import com.nanri.aiimage.modules.task.mapper.FileTaskMapper;
import com.nanri.aiimage.modules.task.mapper.TaskChunkMapper;
import com.nanri.aiimage.modules.task.mapper.TaskScopeStateMapper;
import com.nanri.aiimage.modules.task.model.entity.FileResultEntity;
import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
import com.nanri.aiimage.modules.task.model.entity.TaskChunkEntity;
import com.nanri.aiimage.modules.task.model.entity.TaskFileJobEntity;
import com.nanri.aiimage.modules.task.model.entity.TaskScopeStateEntity;
import com.nanri.aiimage.modules.task.service.TaskDistributedLockService;
import com.nanri.aiimage.modules.task.service.TaskFileJobService;
import com.nanri.aiimage.modules.task.service.TaskHeartbeatPositionService;
import com.nanri.aiimage.modules.task.service.TaskProgressLightAssembler;
import com.nanri.aiimage.modules.task.service.TaskProgressSnapshotService;
import com.nanri.aiimage.modules.task.service.TransientPayloadStorageService;
import com.nanri.aiimage.modules.usersecret.service.UserApiSecretService;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Spy;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.test.util.ReflectionTestUtils;
import org.springframework.transaction.PlatformTransactionManager;
import java.util.List;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* 上游 LLM 账户欠费(2026-10-27 现网 B46:403 {@code insufficient_user_quota})必须把外观专利
* <b>任务</b>立刻落成终态 FAILED。
*
* <p>为什么这是独立的一笔(而不是 B46 已经做完的那半):{@code f3445c21} 只让行级调用「一次就停、
* 归因写对」,任务本身还停在 RUNNING/WAIT_LLM 等 Python 继续回传分片。采集端只看
* {@code /task/heartbeat} 的 {@code alive},看不到终态就会继续为剩下的行<b>按次付费买出口 IP</b>,
* 而那些行永远进不了 LLM。任务变终态 → 心跳 {@code alive=false} → worker 下一跳收手。
*
* <p>反向半边同样重要:连接不可达 / 5xx / 429 / 抓取缺口都必须<b>照旧继续</b>,
* 判宽了就是拿用户的整单去给一次网络抖动陪葬。
*
* <p>夹具走 {@code service.submitLlmBatches} 这条<b>生产接线</b>(批管线 → 欠费处置回调 →
* 结果作业支撑 → FileTaskMapper),不手工 new 二十几个参数,以免测的是一套生产里不存在的 wiring。
* 异常原文一律用外部世界的字符串或本仓常量的<b>引用</b>,不手抄文案。
*/
@ExtendWith(MockitoExtension.class)
class AppearancePatentLlmArrearsTerminalTest {
private static final Long TASK_ID = 32901L;
private static final Long JOB_ID = 24110L;
private static final String SCOPE_HASH = "scope-hash-1";
private static final int CHUNK_INDEX = 1;
private static final String POINTER = "ptr-chunk-1.json";
/** 两行都还没有结论 ⇒ batchSize=1 时正好两批:第二批发不发,就是「烧不烧出口」的分界。 */
private static final String UNRESOLVED_ROWS =
"[{\"rowToken\":\"r1\",\"asin\":\"B0A0000001\",\"title\":\"RUNNING SHOE\",\"url\":\"http://img/1.jpg\",\"groupKey\":\"g1\"},"
+ "{\"rowToken\":\"r2\",\"asin\":\"B0A0000002\",\"title\":\"COTTON BAG\",\"url\":\"http://img/2.jpg\",\"groupKey\":\"g2\"}]";
/** 上游 403 原文(现网形状)。这是外部世界的字符串,不是本仓文案,抄它不算抄自家字面量。 */
private static final String QUOTA_403_BODY = "{\"error\":{\"message\":\"预扣费额度失败, 用户[151246]剩余额度: "
+ "฿0.029168, 需要预扣费额度: ฿0.032402\",\"type\":\"new_api_error\",\"code\":\"insufficient_user_quota\"}}";
@Mock private LocalFileStorageService localFileStorageService;
@Mock private OssStorageService ossStorageService;
@Mock private ResultDownloadResolver resultDownloadResolver;
@Mock private StorageProperties storageProperties;
@Mock private FileTaskMapper fileTaskMapper;
@Mock private FileResultMapper fileResultMapper;
@Mock private TaskScopeStateMapper taskScopeStateMapper;
@Mock private TaskChunkMapper taskChunkMapper;
@Spy private ObjectMapper objectMapper = new ObjectMapper();
@Mock private AppearancePatentLlmClient llmClient;
@Mock private AppearancePatentTaskCacheService taskCacheService;
@Mock private AppearancePatentProperties properties;
@Mock private TaskFileJobService taskFileJobService;
@Mock private TaskProgressSnapshotService taskProgressSnapshotService;
@Mock private TaskHeartbeatPositionService taskHeartbeatPositionService;
@Mock private TransientPayloadStorageService transientPayloadStorageService;
@Mock private PlatformTransactionManager transactionManager;
@Mock private DistributedJobLockService distributedJobLockService;
@Mock private TaskDistributedLockService taskDistributedLockService;
@Mock private InstanceMetadata instanceMetadata;
@Mock private TaskProgressLightAssembler taskProgressLightAssembler;
@Mock private UserApiSecretService userApiSecretService;
@InjectMocks private AppearancePatentTaskService service;
@BeforeAll
static void initializeMybatisMetadata() {
MapperBuilderAssistant assistant = new MapperBuilderAssistant(new MybatisConfiguration(), "");
TableInfoHelper.initTableInfo(assistant, FileTaskEntity.class);
TableInfoHelper.initTableInfo(assistant, FileResultEntity.class);
TableInfoHelper.initTableInfo(assistant, TaskChunkEntity.class);
TableInfoHelper.initTableInfo(assistant, TaskScopeStateEntity.class);
}
@BeforeEach
void setUp() {
lenient().when(properties.getLlmBatchSize()).thenReturn(1);
lenient().when(transientPayloadStorageService.isSharedWriteEnabled()).thenReturn(true);
lenient().when(transientPayloadStorageService.resolvePayload(eq(POINTER), anyString())).thenReturn(UNRESOLVED_ROWS);
lenient().when(transientPayloadStorageService.storeChunkPayloadVersioned(
anyString(), anyLong(), anyString(), any(), anyString())).thenReturn("sibling-1");
lenient().when(taskChunkMapper.selectById(anyLong())).thenReturn(chunk());
lenient().when(taskChunkMapper.update(any(), any())).thenReturn(1);
lenient().when(userApiSecretService.findPlainValue(any(), anyString())).thenReturn("");
}
// ===== (a) 欠费 → 作业路径把任务落成终态,并带上正确文案 =====
/**
* 上游 403 欠费原文进作业路径:任务必须立刻 FAILED+写明动作,且<b>第二批不再发出</b>
* (发一次就多扣一次用户 LLM 次数,而结论永远拿不到)。
*/
@Test
void upstreamQuotaFailureTerminalizesTaskAndStopsRemainingBatches() throws Exception {
FileTaskEntity task = submitFailingWith(new IllegalStateException(QUOTA_403_BODY));
FileTaskEntity written = capturedTerminalWrite();
assertEquals(TASK_ID, written.getId());
assertEquals(TaskStatuses.FileTask.FAILED, written.getStatus(), "欠费必须把任务落 FAILED,不许停在 RUNNING/WAIT_LLM");
assertNotNull(written.getFinishedAt(), "终态必须带 finished_at,否则读侧仍按在跑展示");
assertEquals(0, written.getSuccessFileCount());
assertEquals(1, written.getFailedFileCount());
// 生产者原文一个字都没被重写
assertTrue(written.getErrorMessage().contains(QUOTA_403_BODY), "实际: " + written.getErrorMessage());
// 可执行动作(充值/换密钥后重发)由本仓文案给出
assertTrue(written.getErrorMessage().contains(LlmBalanceGuard.TASK_TERMINAL_GUIDANCE),
"实际: " + written.getErrorMessage());
assertEquals(TaskStatuses.FileTask.FAILED, task.getStatus(), "内存实体也要同步:宿主随后据此决定不再停放");
verify(llmClient, times(1)).inspectRows(any(), any(), any());
}
/** 客户端把欠费包成 {@code REASON_LLM_BALANCE_DUE + lastErr} 那一层,同样必须落终态。 */
@Test
void clientWrappedBalanceReasonAlsoTerminalizesTask() throws Exception {
String producerMessage = LlmBalanceGuard.REASON_LLM_BALANCE_DUE + ";lastErr=" + QUOTA_403_BODY;
submitFailingWith(new IllegalStateException(producerMessage, new IllegalStateException(QUOTA_403_BODY)));
FileTaskEntity written = capturedTerminalWrite();
assertEquals(TaskStatuses.FileTask.FAILED, written.getStatus());
assertTrue(written.getErrorMessage().contains(LlmBalanceGuard.REASON_LLM_BALANCE_DUE),
"实际: " + written.getErrorMessage());
assertTrue(written.getErrorMessage().contains(QUOTA_403_BODY), "实际: " + written.getErrorMessage());
verify(llmClient, times(1)).inspectRows(any(), any(), any());
}
/**
* 密钥失效({@code TaskRetryEligibility} 的 KEY_MARKERS 一族)与欠费同属「不修外部条件、
* 重跑必然同结果」,也要落终态;这条钉住判据取的是 BALANCE 类而不是只认欠费字样。
*/
@Test
void invalidLlmKeyTerminalizesTaskToo() throws Exception {
submitFailingWith(new IllegalStateException("LLM http 401: invalid api key"));
assertEquals(TaskStatuses.FileTask.FAILED, capturedTerminalWrite().getStatus());
}
/**
* 提示语不许误导用户:终态文案里不能出现「请稍后重试」这类把欠费说成临时抖动的话,
* 必须写明充值/换密钥这个动作。文案取自真实落库的那一条,不是测试自己拼的。
*/
@Test
void terminalCopyPointsAtTheRealCauseAndAnActionNotAtATransientBlip() throws Exception {
submitFailingWith(new IllegalStateException(QUOTA_403_BODY));
String copy = capturedTerminalWrite().getErrorMessage();
assertFalse(copy.contains("稍后重试"), "欠费被写成抖动: " + copy);
assertFalse(copy.contains("无需修改"), "欠费被写成表格问题: " + copy);
assertTrue(copy.contains("充值"), "实际: " + copy);
assertTrue(copy.contains("密钥"), "实际: " + copy);
assertTrue(copy.contains("任务已终止"), "实际: " + copy);
}
// ===== (b) 其他失败原因一律继续:不许误杀成终态 =====
/** 连上了只是这一轮 5xx:连接层与上游都会自己恢复,任务照旧停放,剩下的批次照旧跑。 */
@Test
void gatewayFiveOhKeepsTaskRunningAndStillRunsEveryBatch() throws Exception {
FileTaskEntity task = submitFailingWith(new IllegalStateException("LLM http 502: Bad Gateway"));
verify(fileTaskMapper, never()).updateById(any(FileTaskEntity.class));
assertEquals(TaskStatuses.FileTask.RUNNING, task.getStatus());
assertNull(task.getFinishedAt());
verify(llmClient, times(2)).inspectRows(any(), any(), any());
}
/** 429 限流不是欠费({@code LlmBalanceGuardTest} 已钉过识别侧),这里钉任务侧同样不动。 */
@Test
void rateLimitedBatchesKeepTaskRunning() throws Exception {
FileTaskEntity task = submitFailingWith(new IllegalStateException("LLM http 429: Too Many Requests"));
verify(fileTaskMapper, never()).updateById(any(FileTaskEntity.class));
assertEquals(TaskStatuses.FileTask.RUNNING, task.getStatus());
assertNull(task.getFinishedAt());
verify(llmClient, times(2)).inspectRows(any(), any(), any());
}
/** 连接根本没建立(不可达一族):归 SERVICE_DOWN,属「等服务恢复」,不是判死的理由。 */
@Test
void connectFailureKeepsTaskRunningAndIsNotMistakenForArrears() throws Exception {
FileTaskEntity task = submitFailingWith(new IllegalStateException("Connection refused"));
verify(fileTaskMapper, never()).updateById(any(FileTaskEntity.class));
assertEquals(TaskStatuses.FileTask.RUNNING, task.getStatus());
verify(llmClient, times(2)).inspectRows(any(), any(), any());
}
/**
* 抓取缺口(交付侧的「有 N 行未完成检测」)原文由<b>真实生产者</b> {@code appendDeliveryGapMessage}
* 生成后灌进这条路径:它是可带缺口交付的部分失败,绝不能被当成欠费判死。
*/
@Test
@SuppressWarnings("unchecked")
void deliveryGapCopyIsNotMistakenForArrears() throws Exception {
Object deliverySupport = ReflectionTestUtils.invokeMethod(service, "deliverySupport");
String gapCopy = (String) ReflectionTestUtils.invokeMethod(deliverySupport, "appendDeliveryGapMessage",
null, new AppearancePatentRowOutcome.Facts(5, 3, 0, List.of("B0A0000001", "B0A0000002")));
assertTrue(gapCopy.contains("未完成检测"), "夹具应当是缺口文案,实际: " + gapCopy);
FileTaskEntity task = submitFailingWith(new IllegalStateException(gapCopy));
verify(fileTaskMapper, never()).updateById(any(FileTaskEntity.class));
assertEquals(TaskStatuses.FileTask.RUNNING, task.getStatus());
}
// ===== (c) 已是终态的任务不被改写(铁律 14) =====
@Test
void successfulTaskIsNeverRewrittenToFailedByArrears() throws Exception {
assertTerminalStatusUntouchedByArrears(TaskStatuses.FileTask.SUCCESS);
}
@Test
void cancelledTaskIsNeverRewrittenToFailedByArrears() throws Exception {
assertTerminalStatusUntouchedByArrears(TaskStatuses.FileTask.CANCELLED);
}
/** 已经终态(含上一跳刚被欠费判死):重入只许挡回去,不许第二次写库。 */
@Test
void alreadyFailedTaskIsNotWrittenAgain() throws Exception {
assertTerminalStatusUntouchedByArrears(TaskStatuses.FileTask.FAILED);
}
// ===== (d) 终态之后心跳的 alive 语义(worker 收手的依据) =====
/**
* 欠费文案灌进既有收尾 {@code finalizeTask} 时必须落 FAILED,<b>不能</b>被
* 「可带缺口交付」的抓取缺口判定救回 SUCCESS——这条是对 {@code isPartialDataGapError}
* 那段既有语义的实证,不是照抄它的注释。
*/
@Test
void arrearsCopyIsNotSalvagedAsAPartialDataGapByFinalizeTask() throws Exception {
submitFailingWith(new IllegalStateException(QUOTA_403_BODY));
String terminalCopy = capturedTerminalWrite().getErrorMessage();
when(fileResultMapper.selectList(any())).thenReturn(List.of());
AppearancePatentResultJobSupport support =
ReflectionTestUtils.invokeMethod(service, "resultJobSupport");
FileTaskEntity another = taskWithStatus(TaskStatuses.FileTask.RUNNING);
support.finalizeTask(another, terminalCopy, 0, true);
assertEquals(TaskStatuses.FileTask.FAILED, another.getStatus(),
"欠费文案被当成可带缺口交付的抓取缺口了: " + another.getErrorMessage());
assertTrue(another.getErrorMessage().contains(terminalCopy), "实际: " + another.getErrorMessage());
}
// ===== 辅助 =====
/** 用给定异常打爆 LLM 批次;返回宿主手里的那枚任务实体。 */
private FileTaskEntity submitFailingWith(Throwable failure) throws Exception {
FileTaskEntity task = taskWithStatus(TaskStatuses.FileTask.RUNNING);
when(taskCacheService.beginRowInspection(eq(TASK_ID), anyString())).thenReturn(true);
when(llmClient.inspectRows(any(), any(), any())).thenThrow(failure);
when(llmClient.markRowsFailed(any(), anyString())).thenReturn(rows(UNRESOLVED_ROWS));
ReflectionTestUtils.invokeMethod(service, "submitLlmBatches",
task, new FileResultEntity(), job(), List.of(chunk()));
return task;
}
private FileTaskEntity capturedTerminalWrite() {
ArgumentCaptor<FileTaskEntity> captor = ArgumentCaptor.forClass(FileTaskEntity.class);
verify(fileTaskMapper).updateById(captor.capture());
return captor.getValue();
}
private void assertTerminalStatusUntouchedByArrears(String dbStatus) throws Exception {
// 现网形状:作业手里这枚实体还是 RUNNING,而库里刚被别的链路写成终态(交付成功/用户取消)。
// 铁律 14/1:这种时刻欠费分支只许挡回去,连内存实体都不许改写。
when(fileTaskMapper.selectById(TASK_ID)).thenReturn(taskWithStatus(dbStatus));
FileTaskEntity inHand = submitFailingWith(new IllegalStateException(QUOTA_403_BODY));
verify(fileTaskMapper, never()).updateById(any(FileTaskEntity.class));
assertEquals(TaskStatuses.FileTask.RUNNING, inHand.getStatus(),
"库里已是 " + dbStatus + ",内存实体却被欠费分支改写成了 " + inHand.getStatus());
assertNull(inHand.getFinishedAt());
}
private List<AppearancePatentResultRowDto> rows(String json) throws Exception {
return List.of(new ObjectMapper().readValue(json, AppearancePatentResultRowDto[].class));
}
private FileTaskEntity taskWithStatus(String status) {
FileTaskEntity task = new FileTaskEntity();
task.setId(TASK_ID);
task.setModuleType(AppearancePatentTaskService.MODULE_TYPE);
task.setUserId(7L);
task.setStatus(status);
return task;
}
private TaskFileJobEntity job() {
TaskFileJobEntity job = new TaskFileJobEntity();
job.setId(JOB_ID);
job.setTaskId(TASK_ID);
job.setResultId(34819L);
return job;
}
private TaskChunkEntity chunk() {
TaskChunkEntity chunk = new TaskChunkEntity();
chunk.setId(11L);
chunk.setTaskId(TASK_ID);
chunk.setModuleType(AppearancePatentTaskService.MODULE_TYPE);
chunk.setScopeHash(SCOPE_HASH);
chunk.setChunkIndex(CHUNK_INDEX);
chunk.setPayloadJson(POINTER);
chunk.setPayloadHash("hash-old");
return chunk;
}
}
@@ -0,0 +1,108 @@
package com.nanri.aiimage.modules.task.service;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.nanri.aiimage.common.retry.LlmBalanceGuard;
import com.nanri.aiimage.config.AppearancePatentProperties;
import com.nanri.aiimage.modules.appearancepatent.service.AppearancePatentTaskCacheService;
import com.nanri.aiimage.modules.appearancepatent.service.AppearancePatentTaskHeartbeatSpi;
import com.nanri.aiimage.modules.task.mapper.FileTaskMapper;
import com.nanri.aiimage.modules.task.model.dto.TaskHeartbeatRequest;
import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
import com.nanri.aiimage.modules.task.model.vo.TaskHeartbeatVo;
import com.nanri.aiimage.modules.task.spi.BrandTaskHeartbeatSpi;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import java.util.List;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
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.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* 欠费终态之后心跳必须回 {@code alive=false}——这是 Python 采集端({@code maixiang ap_worker})
* 收手的<b>唯一</b>信号:任务还停在 RUNNING/WAIT_LLM 时它看不到终态,就会继续为剩下的行按次付费
* 买出口 IP,而那些行永远进不了 LLM(2026-10-27 现网 B46)。
*
* <p>本类不改 {@link TaskHeartbeatService},只按 {@code TaskHeartbeatServiceTest} 的夹具风格钉
* 「外观专利任务被欠费判成 FAILED 之后」这一格读数,并留一枚 RUNNING 对照,防止整条断言
* 因为桩没接上而变成恒 false 的假绿。
*/
class AppearancePatentArrearsHeartbeatAliveTest {
private static final Long TASK_ID = 32901L;
/** 上游 403 原文(外部世界的字符串)+ 本仓归因常量的引用,不手抄自家文案。 */
private static final String QUOTA_403_BODY = "{\"error\":{\"code\":\"insufficient_user_quota\","
+ "\"message\":\"预扣费额度失败, 用户[151246]剩余额度: ฿0.029168\"}}";
private static final String ARREARS_COPY =
LlmBalanceGuard.REASON_LLM_BALANCE_DUE + ";lastErr=" + QUOTA_403_BODY;
private final FileTaskMapper fileTaskMapper = mock(FileTaskMapper.class);
private final TaskProgressSnapshotService taskProgressSnapshotService = mock(TaskProgressSnapshotService.class);
private final BrandTaskHeartbeatSpi brandTaskHeartbeatSpi = mock(BrandTaskHeartbeatSpi.class);
private final TaskHeartbeatLivenessService livenessService = mock(TaskHeartbeatLivenessService.class);
@BeforeAll
static void initializeMybatisMetadata() {
TableInfoHelper.initTableInfo(
new MapperBuilderAssistant(new MybatisConfiguration(), ""),
FileTaskEntity.class);
}
private TaskHeartbeatService service() {
return new TaskHeartbeatService(fileTaskMapper, taskProgressSnapshotService, brandTaskHeartbeatSpi,
livenessService, List.of(new AppearancePatentTaskHeartbeatSpi(
mock(AppearancePatentTaskCacheService.class),
mock(TaskFileJobService.class),
new AppearancePatentProperties())));
}
@Test
@SuppressWarnings("unchecked")
void arrearsFailedTaskHeartbeatSaysNotAlive() {
FileTaskEntity task = apTask("FAILED");
task.setErrorMessage(ARREARS_COPY);
when(fileTaskMapper.selectOne(any(LambdaQueryWrapper.class))).thenReturn(task);
TaskHeartbeatVo result = service().heartbeat(TASK_ID, new TaskHeartbeatRequest());
assertFalse(result.isAlive(), "任务已终态还回 alive=true,采集端就会继续烧出口 IP");
assertEquals("FAILED", result.getStatus());
assertEquals("APPEARANCE_PATENT", result.getModuleType());
// 非在跑任务不许再刷 updated_at(刷了就等于把它重新写成"还活着")
verify(fileTaskMapper, never()).update(isNull(), any(LambdaUpdateWrapper.class));
}
/** 对照组:同一枚任务还是 RUNNING 时心跳照旧 alive=true,证明上一条的 false 是真判出来的。 */
@Test
@SuppressWarnings("unchecked")
void runningTaskHeartbeatStillSaysAlive() {
FileTaskEntity task = apTask("RUNNING");
when(fileTaskMapper.selectOne(any(LambdaQueryWrapper.class))).thenReturn(task);
when(fileTaskMapper.update(isNull(), any(LambdaUpdateWrapper.class))).thenReturn(1);
TaskHeartbeatVo result = service().heartbeat(TASK_ID, new TaskHeartbeatRequest());
assertTrue(result.isAlive());
assertEquals("RUNNING", result.getStatus());
}
private FileTaskEntity apTask(String status) {
FileTaskEntity task = new FileTaskEntity();
task.setId(TASK_ID);
task.setModuleType("APPEARANCE_PATENT");
task.setUserId(7L);
task.setStatus(status);
return task;
}
}