feat(llm-arrears): 上游 LLM 欠费的提示落到任务界面并让货源链欠费即判死

现网两处叠加的洞:归因文案早在 2026-10-27 就写进了 biz_file_task.error_message,
但两支历史装配器只读结果行的错误、buildActiveItem 连任务级那条都不带,用户在列表
里只看到「失败」两字;货源链更是只有行级归因、任务停在 RUNNING,采集端读不到
心跳的 alive=false,就继续为永远进不了 LLM 的行按次付费买出口 IP。

- 新增 modules/task/service/TaskVisibleFailureNotice:界面出口的单一判据。认出本仓
  写下的欠费/密钥失效归因就换成 TASK_TERMINAL_GUIDANCE 那句中文动作,库里原文一字
  不改(英文响应体与上游账户号不进界面,对齐 RawExceptionMessageSinkGuardTest)。
  刻意不用 TaskRetryEligibility.BALANCE 当显示判据——那一类还涵盖 jikip 代理欠费,
  拿它换句子会把「出口没钱」说成「LLM 账户欠费」,正是 10-27 要避免的误导。
- 两支 HistoryAssembler 共用该出口:行级为空时兜底任务级归因,欠费压过行级副产品。
- 货源链补 terminalizeOnFatalLlmFailure(口径逐字对齐外观专利):判据取 BALANCE、
  非终态才写、可重入;并让 finalizeTask 不许用空/二次错误串盖掉整单结论。
- 用例:TaskVisibleFailureNoticeTest 11 例、SimilarAsinLlmArrearsTerminalTest 16 例
  (含 502/429/连接失败/心跳超时不许误杀、已终态不改写、收尾覆盖保护、接线源码钉子),
  两支装配器各补 4/3 例。后端整量 5,127 例/0 失败/19 skipped。
This commit is contained in:
2026-10-31 17:34:54 +08:00
parent 1c179e0f2e
commit a4e4456b50
10 changed files with 754 additions and 3 deletions
@@ -1,5 +1,6 @@
package com.nanri.aiimage.modules.appearancepatent.service.support;
import com.nanri.aiimage.common.retry.LlmBalanceGuard;
import com.nanri.aiimage.modules.appearancepatent.model.vo.AppearancePatentHistoryItemVo;
import com.nanri.aiimage.modules.task.model.entity.FileResultEntity;
import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
@@ -31,6 +32,10 @@ import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class AppearancePatentHistoryAssemblerTest {
/** 上游 403 响应体(现网形状,外部世界的字符串):钉它不许被摊到界面上。 */
private static final String QUOTA_403_BODY = "{\"error\":{\"code\":\"insufficient_user_quota\","
+ "\"message\":\"预扣费额度失败, 用户[151246]剩余额度: ฿0.029168\"}}";
@Mock private TaskProgressSnapshotService taskProgressSnapshotService;
private AppearancePatentHistoryAssembler assembler;
@@ -218,4 +223,64 @@ class AppearancePatentHistoryAssemblerTest {
assertEquals("FAILED", item.getTaskStatus());
assertEquals(12, item.getRowCount());
}
/**
* 2026-10-31 现网:任务被上游 LLM 欠费判死、{@code biz_file_task.error_message} 里写着
* 「充值或换密钥后重新发起」,列表那一行却只显「失败」——装配器只读结果行的错误,从不读任务级那条。
* 这里钉两件事:结果行一片空白时任务级归因兜底显示,且欠费在界面上是那句中文动作、
* 不是带上游账户号与响应体的原文({@code RawExceptionMessageSinkGuardTest} 同一条红线)。
*/
@Test
void arrearsVerdictReachesTheHistoryLineWithoutUpstreamDetails() {
FileResultEntity row = result(100L, 10L, "a.xlsx", null, 0);
FileTaskEntity task = taskWithArrearsVerdict(task(10L, "FAILED", LocalDateTime.of(2026, 8, 1, 9, 30)));
AppearancePatentHistoryItemVo item = assembler.toHistoryItem(row, task, null);
assertEquals(LlmBalanceGuard.TASK_TERMINAL_GUIDANCE, item.getError(), "实际: " + item.getError());
assertTrue(!item.getError().contains("151246") && !item.getError().contains("฿"),
"上游账户信息进界面: " + item.getError());
}
/** 欠费是整单的结论,压过结果行那句同一次欠费的副产品;换密钥充值这句话必须排在最前面被看见。 */
@Test
void arrearsOutranksTheRowLevelByproduct() {
FileResultEntity row = result(100L, 10L, "a.xlsx", null, 0);
row.setErrorMessage(LlmBalanceGuard.REASON_LLM_BALANCE_DUE + ";lastErr=" + QUOTA_403_BODY);
FileTaskEntity task = taskWithArrearsVerdict(task(10L, "FAILED", LocalDateTime.of(2026, 8, 1, 9, 30)));
AppearancePatentHistoryItemVo item = assembler.toHistoryItem(row, task, null);
assertEquals(LlmBalanceGuard.TASK_TERMINAL_GUIDANCE, item.getError(), "实际: " + item.getError());
}
/** 反向对照:任务级不是欠费时既有形状一字不变——行级优先,行级为空才用任务级兜底。 */
@Test
void ordinaryVerdictKeepsRowLevelFirstAndFillsOnlyBlanks() {
FileResultEntity row = result(100L, 10L, "a.xlsx", null, 0);
row.setErrorMessage("第 3 行抓取超时");
FileTaskEntity failed = task(10L, "FAILED", LocalDateTime.of(2026, 8, 1, 9, 30));
failed.setErrorMessage("结果文件装配失败");
assertEquals("第 3 行抓取超时", assembler.toHistoryItem(row, failed, null).getError());
assertEquals("结果文件装配失败", assembler.toHistoryItem(
result(101L, 10L, "b.xlsx", null, 0), failed, null).getError(), "行级为空时必须兜底");
}
/** 还没有结果行的在跑/续跑任务({@code buildActiveItem})同样要带任务级归因,否则只剩「失败」两字。 */
@Test
void activeItemCarriesTaskLevelVerdict() {
FileTaskEntity arrears = taskWithArrearsVerdict(task(77L, "FAILED", LocalDateTime.of(2026, 8, 3, 9, 0)));
assertEquals(LlmBalanceGuard.TASK_TERMINAL_GUIDANCE, assembler.buildActiveItem(arrears).getError());
assertNull(assembler.buildActiveItem(task(78L, "RUNNING", LocalDateTime.of(2026, 8, 3, 9, 0))).getError(),
"没有归因就不凭空造一行「错误:」");
}
/** 库里那条任务级原文的真实形状:生产者归因+上游响应体+本仓动作句(引用常量,不手抄文案)。 */
private static FileTaskEntity taskWithArrearsVerdict(FileTaskEntity task) {
task.setErrorMessage(LlmBalanceGuard.REASON_LLM_BALANCE_DUE + ";lastErr=" + QUOTA_403_BODY
+ ";" + LlmBalanceGuard.TASK_TERMINAL_GUIDANCE);
return task;
}
}
@@ -0,0 +1,322 @@
package com.nanri.aiimage.modules.similarasin.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.task.TaskStatuses;
import com.nanri.aiimage.config.InstanceMetadata;
import com.nanri.aiimage.config.SimilarAsinProperties;
import com.nanri.aiimage.config.StorageProperties;
import com.nanri.aiimage.modules.file.service.oss.OssStorageService;
import com.nanri.aiimage.modules.similarasin.mapper.SimilarAsinFilterConditionMapper;
import com.nanri.aiimage.modules.similarasin.service.support.SimilarAsinImageEmbedder;
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.TaskScopeStateEntity;
import com.nanri.aiimage.modules.task.service.TaskDistributedLockService;
import com.nanri.aiimage.modules.task.service.TaskFileJobService;
import com.nanri.aiimage.modules.task.service.TaskProgressSnapshotService;
import com.nanri.aiimage.modules.task.service.TaskVisibleFailureNotice;
import com.nanri.aiimage.modules.task.service.TransientPayloadStorageService;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.jupiter.api.BeforeAll;
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.transaction.PlatformTransactionManager;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;
import static org.junit.jupiter.api.Assertions.assertEquals;
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.Mockito.lenient;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* 货源查询(SIMILAR_ASIN)命中上游 LLM 欠费/密钥失效时,任务必须<b>立刻</b>落终态并把原因交到界面。
*
* <p>2026-10-31 现网两处叠加的洞:① {@code SimilarAsinLlmClient} 只把欠费写成<b>行级</b>归因就抛出,
* 没有任何链路写 {@code biz_file_task.error_message}——历史装配器又只读结果行的错误,于是用户在列表里
* 只看得到「失败」两个字;② 任务停在 RUNNING 时 {@code TaskHeartbeatService} 回的 {@code alive} 仍为
* true,{@code similar_worker.py:249} 就继续为永远进不了 LLM 的行<b>按次付费买出口 IP</b>。
* 口径与外观专利 2026-10-27 那条({@code AppearancePatentLlmArrearsTerminalTest})逐字对齐。
*
* <p>反向半边与正向一样重要:连接不可达 / 429 / 5xx / 心跳超时都必须照旧继续,判宽了就是
* 拿用户的整单给一次网络抖动陪葬。已终态的任务一律不动(铁律 14)。
*/
@ExtendWith(MockitoExtension.class)
class SimilarAsinLlmArrearsTerminalTest {
private static final Long TASK_ID = 33011L;
/** 上游 403 原文(外部世界的字符串,不是本仓文案)。 */
private static final String QUOTA_403_BODY = "{\"error\":{\"code\":\"insufficient_user_quota\","
+ "\"message\":\"预扣费额度失败, 用户[151246]剩余额度: ฿0.029168\"}}";
/** 客户端包过一层的现网形状:{@code SimilarAsinLlmClient} 抛的就是这一句。 */
private static final String PRODUCER_ARREARS_COPY =
LlmBalanceGuard.REASON_LLM_BALANCE_DUE + ";lastErr=" + QUOTA_403_BODY;
@Mock private OssStorageService ossStorageService;
@Mock private StorageProperties storageProperties;
@Mock private FileTaskMapper fileTaskMapper;
@Mock private FileResultMapper fileResultMapper;
@Mock private TaskScopeStateMapper taskScopeStateMapper;
@Mock private TaskChunkMapper taskChunkMapper;
@Mock private SimilarAsinFilterConditionMapper filterConditionMapper;
@Spy private ObjectMapper objectMapper = new ObjectMapper();
@Mock private SimilarAsinTaskCacheService taskCacheService;
@Mock private SimilarAsinProperties properties;
@Mock private TaskFileJobService taskFileJobService;
@Mock private TaskDistributedLockService taskDistributedLockService;
@Mock private TaskProgressSnapshotService taskProgressSnapshotService;
@Mock private TransientPayloadStorageService transientPayloadStorageService;
@Mock private PlatformTransactionManager transactionManager;
@Mock private DistributedJobLockService distributedJobLockService;
@Mock private InstanceMetadata instanceMetadata;
@Mock private SimilarAsinImageEmbedder imageEmbedder;
@Mock private SimilarAsinImagePrefetchService imagePrefetchService;
@InjectMocks private SimilarAsinTaskService 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);
}
// ===== (a) 欠费/密钥失效 → 任务落终态,文案带可执行动作 =====
@Test
void upstreamQuotaFailureTerminalizesTaskAndCarriesTheActionSentence() {
when(fileTaskMapper.selectById(TASK_ID)).thenReturn(taskWithStatus(TaskStatuses.FileTask.RUNNING));
service.terminalizeOnFatalLlmFailure(taskWithStatus(TaskStatuses.FileTask.RUNNING), PRODUCER_ARREARS_COPY);
FileTaskEntity written = capturedWrite();
assertEquals(TaskStatuses.FileTask.FAILED, written.getStatus(),
"欠费必须把任务落 FAILED,停在 RUNNING 就等于让采集端继续买出口");
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());
// 提示语不许把欠费说成抖动,也不许让人以为是自己的表格问题
assertTrue(written.getErrorMessage().contains("充值") && written.getErrorMessage().contains("任务已终止"),
"实际: " + written.getErrorMessage());
verify(taskCacheService).deleteTaskCache(TASK_ID);
}
@Test
void invalidLlmKeyTerminalizesTaskToo() {
when(fileTaskMapper.selectById(TASK_ID)).thenReturn(taskWithStatus(TaskStatuses.FileTask.RUNNING));
service.terminalizeOnFatalLlmFailure(taskWithStatus(TaskStatuses.FileTask.RUNNING),
"LLM http 401: invalid api key");
assertEquals(TaskStatuses.FileTask.FAILED, capturedWrite().getStatus());
}
/** 界面那一行拿到的必须是中文动作句,而不是库里那条带上游账户号与 ฿ 余额的原文。 */
@Test
void terminalCopyReachesTheListLineWithoutUpstreamAccountDetails() {
when(fileTaskMapper.selectById(TASK_ID)).thenReturn(taskWithStatus(TaskStatuses.FileTask.RUNNING));
service.terminalizeOnFatalLlmFailure(taskWithStatus(TaskStatuses.FileTask.RUNNING), PRODUCER_ARREARS_COPY);
String shown = TaskVisibleFailureNotice.forTask(capturedWrite());
assertEquals(LlmBalanceGuard.TASK_TERMINAL_GUIDANCE, shown, "实际: " + shown);
assertTrue(!shown.contains("151246") && !shown.contains("฿"), "上游账户信息进界面: " + shown);
}
// ===== (b) 其他失败一律继续:不许误杀成终态 =====
@Test
void gatewayFiveOhKeepsTaskRunning() {
assertKeepsTaskUntouched("LLM http 502: Bad Gateway");
}
@Test
void rateLimitedFailureKeepsTaskRunning() {
assertKeepsTaskUntouched("LLM http 429: Too Many Requests");
}
@Test
void connectFailureIsNotMistakenForArrears() {
assertKeepsTaskUntouched("LLM 服务不可达(连接未建立):Connection refused");
}
/** 心跳/回传超时判死那类原文进这条路径时也不许被当成欠费(它是另一条链路的结论)。 */
@Test
void staleHeartbeatCopyIsNotArrears() {
assertKeepsTaskUntouched("任务心跳超时,已自动失败");
}
/** 空错误串没有归因可言,判死只会把任务说成"不知道为什么失败"。 */
@Test
void blankFailureMessageTerminalizesNothing() {
assertKeepsTaskUntouched(" ");
assertKeepsTaskUntouched(null);
}
/** 缺任务主键(理论形状)不许写库。 */
@Test
void taskWithoutIdIsIgnored() {
service.terminalizeOnFatalLlmFailure(new FileTaskEntity(), PRODUCER_ARREARS_COPY);
verify(fileTaskMapper, never()).updateById(any(FileTaskEntity.class));
}
// ===== (c) 已是终态的任务不被改写(铁律 14) =====
@Test
void successfulTaskIsNeverRewrittenToFailedByArrears() {
assertTerminalStatusUntouched(TaskStatuses.FileTask.SUCCESS);
}
@Test
void cancelledTaskIsNeverRewrittenToFailedByArrears() {
assertTerminalStatusUntouched(TaskStatuses.FileTask.CANCELLED);
}
/** 上一跳刚被欠费判死:重入只许挡回去,连内存实体都不许改写(这方法是可重入的)。 */
@Test
void alreadyFailedTaskIsNotWrittenAgain() {
assertTerminalStatusUntouched(TaskStatuses.FileTask.FAILED);
}
// ===== (d) 后来的收尾不许把欠费结论盖掉 =====
/**
* 欠费判死之后,一次带<b>空</b>错误串的收尾(结果文件那半条链跑完了)会把 {@code error_message}
* 清零、把状态翻成 SUCCESS——用户重新回到"这单到底为什么没了"。这条钉住整单结论覆盖不掉。
*/
@Test
void blankFinalizeDoesNotWipeTheArrearsVerdict() {
FileTaskEntity task = terminalizedTask();
service.finalizeTask(task, null, null, false);
assertEquals(TaskStatuses.FileTask.FAILED, task.getStatus(), "欠费单被空收尾翻成了 " + task.getStatus());
assertTrue(task.getErrorMessage().contains(QUOTA_403_BODY), "实际: " + task.getErrorMessage());
}
/** 收尾带着另一条链的失败原因时同理:界面上要说得清是上游欠费,不是"装配失败"这种二次归因。 */
@Test
void assemblyFailureCopyDoesNotOverrideTheArrearsVerdict() {
FileTaskEntity task = terminalizedTask();
service.finalizeTask(task, "结果文件装配失败", null, false);
assertEquals(TaskStatuses.FileTask.FAILED, task.getStatus());
assertTrue(task.getErrorMessage().contains(QUOTA_403_BODY), "实际: " + task.getErrorMessage());
}
/** 反向对照:任务级不是欠费结论时,收尾照常按新错误串写(不许把这条保护扩成"什么都不许改")。 */
@Test
void ordinaryTaskErrorIsStillOverwrittenByFinalize() {
FileTaskEntity task = taskWithStatus(TaskStatuses.FileTask.RUNNING);
task.setErrorMessage("结果文件装配失败");
lenient().when(fileResultMapper.selectList(any())).thenReturn(List.of());
lenient().when(taskChunkMapper.selectCount(any())).thenReturn(0L);
service.finalizeTask(task, null, null, false);
assertEquals(TaskStatuses.FileTask.SUCCESS, task.getStatus(), "普通归因不该被这条保护锁住");
assertNull(task.getErrorMessage());
}
// ===== (e) 接线:流水线的欠费异常必须真的交给宿主处置 =====
/**
* 判死写在宿主里,触发点在流水线。这条源码钉子钉"识别到了必须交出去",且必须在行级归因
* 落库<b>之后</b>:{@code submitLlmBatch} 的 catch 里少了这一句,欠费就仍旧只是行级文案、
* 任务停在 RUNNING 让采集端继续买出口。
*/
@Test
void llmSubmitFailureHandsArrearsVerdictToTheHost() throws Exception {
String source = Files.readString(Path.of(
"src/main/java/com/nanri/aiimage/modules/similarasin/service/support/"
+ "SimilarAsinPipelineSupport.java"));
int rowsMerged = source.indexOf("markRowsFailed(batchRows, message)");
int handedToHost = source.indexOf("host.terminalizeOnFatalLlmFailure(task, message)");
assertEquals(1, occurrences(source, "host.terminalizeOnFatalLlmFailure(task, message)"),
"欠费处置的调用点必须恰好一处(在 submitLlmBatch 的 catch 里)");
assertTrue(rowsMerged >= 0 && handedToHost > rowsMerged,
"行级归因必须先落库、再把整单交给宿主处置(rowsMerged=" + rowsMerged + ", handedToHost=" + handedToHost + ")");
}
// ===== 辅助 =====
private void assertKeepsTaskUntouched(String failureMessage) {
service.terminalizeOnFatalLlmFailure(taskWithStatus(TaskStatuses.FileTask.RUNNING), failureMessage);
verify(fileTaskMapper, never()).updateById(any(FileTaskEntity.class));
verify(taskCacheService, never()).deleteTaskCache(any());
}
private void assertTerminalStatusUntouched(String dbStatus) {
when(fileTaskMapper.selectById(TASK_ID)).thenReturn(taskWithStatus(dbStatus));
FileTaskEntity inHand = taskWithStatus(TaskStatuses.FileTask.RUNNING);
service.terminalizeOnFatalLlmFailure(inHand, PRODUCER_ARREARS_COPY);
verify(fileTaskMapper, never()).updateById(any(FileTaskEntity.class));
assertEquals(TaskStatuses.FileTask.RUNNING, inHand.getStatus(),
"库里已是 " + dbStatus + ",内存实体却被欠费分支改写成了 " + inHand.getStatus());
assertNull(inHand.getFinishedAt());
}
/** 走一遍真实判死,拿到的就是库里那一行(不手工拼形状,免得测的是一份不存在的数据)。 */
private FileTaskEntity terminalizedTask() {
when(fileTaskMapper.selectById(TASK_ID)).thenReturn(taskWithStatus(TaskStatuses.FileTask.RUNNING));
FileTaskEntity task = taskWithStatus(TaskStatuses.FileTask.RUNNING);
service.terminalizeOnFatalLlmFailure(task, PRODUCER_ARREARS_COPY);
return task;
}
private FileTaskEntity capturedWrite() {
ArgumentCaptor<FileTaskEntity> captor = ArgumentCaptor.forClass(FileTaskEntity.class);
verify(fileTaskMapper).updateById(captor.capture());
return captor.getValue();
}
private static int occurrences(String text, String needle) {
int count = 0;
for (int at = text.indexOf(needle); at >= 0; at = text.indexOf(needle, at + needle.length())) {
count++;
}
return count;
}
private FileTaskEntity taskWithStatus(String status) {
FileTaskEntity task = new FileTaskEntity();
task.setId(TASK_ID);
task.setModuleType(SimilarAsinTaskService.MODULE_TYPE);
task.setUserId(7L);
task.setStatus(status);
return task;
}
}
@@ -2,6 +2,7 @@ package com.nanri.aiimage.modules.similarasin.service.support;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.retry.LlmBalanceGuard;
import com.nanri.aiimage.modules.similarasin.model.vo.SimilarAsinHistoryItemVo;
import com.nanri.aiimage.modules.similarasin.model.vo.SimilarAsinParsedRowVo;
import com.nanri.aiimage.modules.task.mapper.FileTaskMapper;
@@ -49,6 +50,10 @@ import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
@ExtendWith(MockitoExtension.class)
class SimilarAsinHistoryAssemblerTest {
/** 上游 403 响应体(现网形状,外部世界的字符串):钉它不许被摊到界面上。 */
private static final String QUOTA_403_BODY = "{\"error\":{\"code\":\"insufficient_user_quota\","
+ "\"message\":\"预扣费额度失败, 用户[151246]剩余额度: ฿0.029168\"}}";
@Mock private TaskScopeStateMapper taskScopeStateMapper;
@Mock private TaskChunkMapper taskChunkMapper;
@Mock private FileTaskMapper fileTaskMapper;
@@ -438,4 +443,58 @@ class SimilarAsinHistoryAssemblerTest {
"生产者会把原因 rewrap 成「<errorMessage>: <pointer>」,实际: " + failure.getMessage());
return failure;
}
// ===== 2026-10-31:任务级归因必须进得了列表(欠费单今天只剩「失败」两字) =====
/**
* 上游 LLM 欠费把整单判死之后:结果行一片空白时兜底显示任务级那句中文动作,
* 而行级带着同一次欠费的副产品时也让位给它——界面要先说清"充值或换密钥后重新发起"。
* 库里原文(上游账户号、响应体、฿ 余额)一个字都不许摊到界面上。
*/
@Test
void arrearsVerdictReachesTheListWithoutUpstreamDetails() {
FileTaskEntity arrears = task(10L, "FAILED", LocalDateTime.of(2026, 8, 1, 9, 30));
arrears.setErrorMessage(LlmBalanceGuard.REASON_LLM_BALANCE_DUE + ";lastErr=" + QUOTA_403_BODY
+ ";" + LlmBalanceGuard.TASK_TERMINAL_GUIDANCE);
Map<Long, FileTaskEntity> taskMap = new LinkedHashMap<>();
taskMap.put(10L, arrears);
FileResultEntity blankRow = result(100L, 10L, "a.xlsx", null, 0);
FileResultEntity byproductRow = result(101L, 10L, "b.xlsx", null, 0);
byproductRow.setErrorMessage(LlmBalanceGuard.REASON_LLM_BALANCE_DUE + ";lastErr=" + QUOTA_403_BODY);
Map<Long, String> errors = new LinkedHashMap<>();
assembler.buildHistoryItems(List.of(blankRow, byproductRow), taskMap, jobMap())
.forEach(item -> errors.put(item.getResultId(), item.getError()));
assertEquals(LlmBalanceGuard.TASK_TERMINAL_GUIDANCE, errors.get(100L), "行级为空时必须兜底");
assertEquals(LlmBalanceGuard.TASK_TERMINAL_GUIDANCE, errors.get(101L), "整单结论必须压过行级副产品");
assertTrue(errors.values().stream().noneMatch(text -> text.contains("151246") || text.contains("฿")),
"上游账户信息进界面: " + errors);
}
/** 反向对照:任务级不是欠费时既有形状一字不变(行级优先,行级为空才兜底,两头空就什么都不显)。 */
@Test
void ordinaryVerdictKeepsRowLevelFirst() {
FileTaskEntity failed = task(10L, "FAILED", LocalDateTime.of(2026, 8, 1, 9, 30));
failed.setErrorMessage("结果文件装配失败");
FileResultEntity row = result(100L, 10L, "a.xlsx", null, 0);
row.setErrorMessage("第 3 行抓取超时");
Map<Long, FileTaskEntity> taskMap = new LinkedHashMap<>();
taskMap.put(10L, failed);
List<SimilarAsinHistoryItemVo> items = assembler.buildHistoryItems(List.of(row), taskMap, jobMap());
assertEquals("第 3 行抓取超时", items.get(0).getError(), "行级为空才许被任务级顶掉");
}
/** 还没有结果行的在跑/续跑任务({@code buildActiveItem})同样带任务级归因;没归因时不凭空造一行。 */
@Test
void activeItemCarriesTaskLevelVerdict() {
FileTaskEntity arrears = task(77L, "FAILED", LocalDateTime.of(2026, 8, 3, 9, 0));
arrears.setErrorMessage(LlmBalanceGuard.REASON_LLM_BALANCE_DUE + ";lastErr=" + QUOTA_403_BODY
+ ";" + LlmBalanceGuard.TASK_TERMINAL_GUIDANCE);
assertEquals(LlmBalanceGuard.TASK_TERMINAL_GUIDANCE, assembler.buildActiveItem(arrears).getError());
assertNull(assembler.buildActiveItem(task(78L, "RUNNING", LocalDateTime.of(2026, 8, 3, 9, 0))).getError());
}
}
@@ -0,0 +1,149 @@
package com.nanri.aiimage.modules.task.service;
import com.nanri.aiimage.common.retry.LlmBalanceGuard;
import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* 任务级失败归因进用户界面那道出口的判据(2026-10-31)。
*
* <p>起因是现网那一单:上游 LLM 账户欠费,Java 侧已经把整单判死并把「充值或换密钥后重新发起」
* 写进了 {@code biz_file_task.error_message},但列表那一行只显「失败」——历史装配器只读结果行的
* 错误,从不读任务级那条。修的时候有两个方向都错:把库里原文(带上游响应体与上游账户号)直接摊到
* 界面({@code RawExceptionMessageSinkGuardTest} 就是把这种出口判红的),或者把原文重写掉
* (支持同学就没法对着上游日志核根因)。所以出口只做一件事:<b>换一句本仓已有的中文</b>,原文留着。
*
* <p>异常原文一律用外部世界的字符串或本仓常量的<b>引用</b>,不手抄自家文案。
*/
class TaskVisibleFailureNoticeTest {
/** 上游 403 响应体(现网形状):外部世界的字符串,抄它不算抄本仓字面量。 */
private static final String QUOTA_403_BODY = "{\"error\":{\"code\":\"insufficient_user_quota\","
+ "\"message\":\"预扣费额度失败, 用户[151246]剩余额度: ฿0.029168\"}}";
/** 生产者(LLM 客户端)包过一层的欠费归因,接上任务级收尾文案——现网库里的真实形状。 */
private static final String ARREARS_TERMINAL_COPY = LlmBalanceGuard.REASON_LLM_BALANCE_DUE
+ ";lastErr=" + QUOTA_403_BODY + ";" + LlmBalanceGuard.TASK_TERMINAL_GUIDANCE;
private static FileTaskEntity taskWith(String errorMessage) {
FileTaskEntity task = new FileTaskEntity();
task.setId(32901L);
task.setModuleType("APPEARANCE_PATENT");
task.setStatus("FAILED");
task.setErrorMessage(errorMessage);
return task;
}
// ===== 欠费/密钥失效:界面只给那句中文,原文与上游账户号不进界面 =====
@Test
void arrearsVerdictIsShownAsTheChineseActionSentenceWithoutUpstreamBody() {
String shown = TaskVisibleFailureNotice.forTask(taskWith(ARREARS_TERMINAL_COPY));
assertEquals(LlmBalanceGuard.TASK_TERMINAL_GUIDANCE, shown, "实际: " + shown);
assertFalse(shown.contains("insufficient_user_quota"), "上游响应体漏进界面: " + shown);
assertFalse(shown.contains("151246"), "上游账户号漏进界面: " + shown);
assertFalse(shown.contains("฿"), "上游余额数字漏进界面: " + shown);
assertTrue(shown.contains("充值") && shown.contains("密钥"), "实际: " + shown);
}
/** 密钥失效与欠费同族({@code TaskRetryEligibility} 的 KEY_MARKERS 归 BALANCE),同一句中文动作。 */
@Test
void invalidLlmKeySharesTheSameVisibleSentence() {
assertEquals(LlmBalanceGuard.TASK_TERMINAL_GUIDANCE,
TaskVisibleFailureNotice.forTask(taskWith("LLM http 401: invalid api key;"
+ LlmBalanceGuard.TASK_TERMINAL_GUIDANCE)));
}
/** 库里那条归因本身没被改写:出口只在"给人看"这一步换句子。 */
@Test
void storedCopySurvivesTheOutletUntouched() {
FileTaskEntity task = taskWith(ARREARS_TERMINAL_COPY);
TaskVisibleFailureNotice.forTask(task);
assertEquals(ARREARS_TERMINAL_COPY, task.getErrorMessage());
}
// ===== 其他任务级失败:原样透出,不改既有语义 =====
@Test
void ordinaryTaskFailureIsPassedThroughAsWritten() {
assertEquals("结果文件装配失败", TaskVisibleFailureNotice.forTask(taskWith("结果文件装配失败")));
}
@Test
void missingOrBlankTaskErrorYieldsNoVisibleLine() {
assertNull(TaskVisibleFailureNotice.forTask(taskWith(null)));
assertNull(TaskVisibleFailureNotice.forTask(taskWith(" ")));
assertNull(TaskVisibleFailureNotice.forTask(null));
}
// ===== 历史行:欠费压过行级,其余行级优先、任务级兜底 =====
/**
* 今天真正的盲区:任务被欠费判死、结果行一句错误都没有(或只有一行重复的欠费副产品),
* 界面就停在「失败」上。这条钉住"整单结论优先于行级文案"。
*/
@Test
void arrearsOutranksRowLevelCopy() {
String shown = TaskVisibleFailureNotice.forHistoryRow(taskWith(ARREARS_TERMINAL_COPY),
LlmBalanceGuard.REASON_LLM_BALANCE_DUE + ";lastErr=" + QUOTA_403_BODY);
assertEquals(LlmBalanceGuard.TASK_TERMINAL_GUIDANCE, shown, "实际: " + shown);
}
/** 反向对照:任务级不是欠费时,行级原文照旧优先——不许把既有的行级归因挤掉。 */
@Test
void rowLevelCopyStillWinsWhenTaskVerdictIsNotArrears() {
assertEquals("第 3 行抓取超时",
TaskVisibleFailureNotice.forHistoryRow(taskWith("结果文件装配失败"), "第 3 行抓取超时"));
}
/** 行级为空而任务级有结论:兜底显示任务级那句(这条就是"列表只剩失败两字"的补洞)。 */
@Test
void taskLevelVerdictFillsInWhenRowHasNothing() {
assertEquals("结果文件装配失败",
TaskVisibleFailureNotice.forHistoryRow(taskWith("结果文件装配失败"), null));
assertEquals("结果文件装配失败",
TaskVisibleFailureNotice.forHistoryRow(taskWith("结果文件装配失败"), " "));
}
/** 两头都空 ⇒ null,界面不凭空造一行「错误:」。 */
@Test
void nothingInventedWhenBothSidesAreEmpty() {
assertNull(TaskVisibleFailureNotice.forHistoryRow(taskWith(null), ""));
assertNull(TaskVisibleFailureNotice.forHistoryRow(null, null));
}
// ===== 收尾覆盖保护用的那只谓词 =====
@Test
void wholeTaskVerdictPredicateAcceptsOurOwnArrearsAttributionOnly() {
assertTrue(TaskVisibleFailureNotice.isWholeTaskVerdict(ARREARS_TERMINAL_COPY));
assertTrue(TaskVisibleFailureNotice.isWholeTaskVerdict(LlmBalanceGuard.REASON_LLM_BALANCE_DUE));
assertFalse(TaskVisibleFailureNotice.isWholeTaskVerdict("LLM http 502: Bad Gateway"),
"连接/抖动类不许被当成整单结论,否则一次网络抖动会永久锁死这单的归因");
assertFalse(TaskVisibleFailureNotice.isWholeTaskVerdict("任务心跳超时,已自动失败"));
assertFalse(TaskVisibleFailureNotice.isWholeTaskVerdict(null));
}
/**
* 代理欠费不许冒充 LLM 欠费:{@code TaskRetryEligibility.Category.BALANCE} 同时涵盖 jikip
* 代理余额与套餐过期("余额不足"/"套餐不存在"),界面按它换句子就会把"出口 IP 没钱了"说成
* "上游 LLM 账户欠费"——2026-10-27 用户点名要避免的那类误导,所以出口只认自己写下的归因。
*/
@Test
void proxyBalanceFailureIsShownAsWrittenNotRebrandedAsLlmArrears() {
String proxyCopy = "商标查询失败:reason=余额不足,全部代理 key 进入冷却";
assertEquals(proxyCopy, TaskVisibleFailureNotice.forTask(taskWith(proxyCopy)));
assertEquals(proxyCopy, TaskVisibleFailureNotice.forHistoryRow(taskWith(proxyCopy), null));
assertFalse(TaskVisibleFailureNotice.isWholeTaskVerdict(proxyCopy));
}
}