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
@@ -8,6 +8,7 @@ import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
import com.nanri.aiimage.modules.task.model.entity.TaskFileJobEntity;
import com.nanri.aiimage.modules.task.model.entity.TaskProgressSnapshotEntity;
import com.nanri.aiimage.modules.task.service.TaskProgressSnapshotService;
import com.nanri.aiimage.modules.task.service.TaskVisibleFailureNotice;
import java.time.LocalDateTime;
import java.util.function.Function;
@@ -15,7 +16,9 @@ import java.util.function.Function;
/**
* 任务 97:AppearancePatentHistoryAssembler 历史查询组装器。
* 历史列表 VO 拼装(toHistoryItem + 排序辅助 historyPriority/historyActivityTime +
* 文件进度链)从 AppearancePatentTaskService 原样搬移;只读不落库;输出与现状逐字段一致。
* 文件进度链)从 AppearancePatentTaskService 原样搬移;只读不落库;输出与现状逐字段一致
* (2026-10-31 唯一例外:{@code error} 改走 {@link TaskVisibleFailureNotice},行级为空时补上任务级归因,
* 欠费单在列表里不再只剩一个「失败」)。
* 进度百分比计算(calculateDisplayProgressPercent/extractSnapshotDisplayPercent)仍在
* 服务侧(与 saveFileBuildProgress 实时路径共享),以函数注入。
*/
@@ -54,7 +57,7 @@ public class AppearancePatentHistoryAssembler {
vo.setTaskStatus(task == null ? null : task.getStatus());
vo.setSuccess(row.getResultFileUrl() != null && !row.getResultFileUrl().isBlank()
|| row.getSuccess() != null && row.getSuccess() == 1);
vo.setError(row.getErrorMessage());
vo.setError(TaskVisibleFailureNotice.forHistoryRow(task, row.getErrorMessage()));
vo.setRowCount(row.getRowCount());
vo.setCreatedAt(fmt(row.getCreatedAt()));
// 任务开始时间复用 biz_file_task.created_at;缺 task 时回退到 result.createdAt 兜底
@@ -69,6 +72,7 @@ public class AppearancePatentHistoryAssembler {
vo.setTaskId(task.getId());
vo.setTaskStatus(task.getStatus());
vo.setSuccess(false);
vo.setError(TaskVisibleFailureNotice.forTask(task));
vo.setCreatedAt(fmt(task.getCreatedAt()));
vo.setStartedAt(fmt(task.getCreatedAt()));
vo.setFinishedAt(fmt(task.getFinishedAt()));
@@ -8,6 +8,7 @@ import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.common.retry.LlmBalanceGuard;
import com.nanri.aiimage.common.task.TaskStatuses;
import com.nanri.aiimage.common.task.LockSkipWitness;
import com.nanri.aiimage.common.service.DistributedJobLockService;
@@ -70,6 +71,8 @@ import com.nanri.aiimage.modules.task.service.TaskFileJobService;
import com.nanri.aiimage.modules.task.service.TaskDistributedLockService;
import com.nanri.aiimage.modules.task.service.TaskHeartbeatPositionService;
import com.nanri.aiimage.modules.task.service.TaskProgressSnapshotService;
import com.nanri.aiimage.modules.task.service.TaskRetryEligibility;
import com.nanri.aiimage.modules.task.service.TaskVisibleFailureNotice;
import com.nanri.aiimage.modules.task.service.TransientPayloadStorageService;
import com.nanri.aiimage.modules.usersecret.service.UserApiSecretService;
import lombok.RequiredArgsConstructor;
@@ -1342,6 +1345,12 @@ public class SimilarAsinTaskService implements SimilarAsinPipelineHost {
throw new IllegalStateException("Synchronous result assembly is not allowed in a database transaction");
}
}
// 欠费/密钥失效是整单的结论,后来的收尾(哪怕带空错误串)不许把它盖掉或翻成成功:
// 盖掉的后果是界面重新变成「只见失败、不见原因」,采集端也以为这单还能跑。
if (TaskVisibleFailureNotice.isWholeTaskVerdict(task.getErrorMessage())
&& !TaskVisibleFailureNotice.isWholeTaskVerdict(finalError)) {
finalError = task.getErrorMessage();
}
boolean failed = finalError != null && !finalError.isBlank();
boolean waitingForAssemble = !failed && assembleWorkbook && !shouldAssembleSynchronously();
task.setStatus(waitingForAssemble ? STATUS_RUNNING : (failed ? STATUS_FAILED : STATUS_SUCCESS));
@@ -1575,6 +1584,50 @@ public class SimilarAsinTaskService implements SimilarAsinPipelineHost {
return task.getId();
}
/**
* 上游 LLM 账户欠费/密钥失效 → 任务<b>立即</b>落终态 FAILED(2026-10-31,口径与外观专利 2026-10-27 那条一致)。
*
* <p>为什么必须由 Java 侧落终态:{@code maixiang similar_worker} 只看 {@code /task/heartbeat} 的
* {@code alive}({@code similar_worker.py:249}),任务还停在 RUNNING 它就看不到判决,会继续为
* 永远进不了 LLM 的行<b>按次付费买出口 IP</b>。任务一终态,{@code TaskHeartbeatService} 才对该任务
* 回 {@code alive=false},worker 下一跳收手。
*
* <p>判据只取 {@link TaskRetryEligibility.Category#BALANCE}(欠费与 LLM 密钥失效同族,复用既有唯一
* 判据、不抄第二份字面量表):连接不可达(SERVICE_DOWN)、429 限流、5xx 抖动、抓取缺口都属
* "外部会自己恢复或补传能救",判宽了就是拿用户的整单给一次网络抖动陪葬。写之前重读库里现状态,
* 已终态的一律不动(铁律 14),本方法因此可重入。
*/
@Override
public void terminalizeOnFatalLlmFailure(FileTaskEntity task, String failureMessage) {
if (task == null || task.getId() == null) {
return;
}
if (TaskRetryEligibility.forceMajeureCategory(failureMessage) != TaskRetryEligibility.Category.BALANCE) {
return;
}
FileTaskEntity current = fileTaskMapper.selectById(task.getId());
String currentStatus = current != null ? current.getStatus() : task.getStatus();
if (TaskStatuses.FileTask.TERMINAL.contains(currentStatus)) {
log.info("[similar-asin] 任务已是终态,欠费归因不改写状态 taskId={} status={}", task.getId(), currentStatus);
return;
}
String raw = failureMessage == null ? "" : failureMessage.trim();
task.setStatus(STATUS_FAILED);
task.setSuccessFileCount(0);
task.setFailedFileCount(1);
// 生产者原文一个字都不在这里重写(支持同学要对着上游响应体查根因);界面上那句中文由
// TaskVisibleFailureNotice 在出口处给,英文原文与上游账户号不进界面。
task.setErrorMessage(raw.isEmpty()
? LlmBalanceGuard.TASK_TERMINAL_GUIDANCE
: raw + ";" + LlmBalanceGuard.TASK_TERMINAL_GUIDANCE);
task.setUpdatedAt(LocalDateTime.now());
task.setFinishedAt(LocalDateTime.now());
fileTaskMapper.updateById(task);
taskCacheService.deleteTaskCache(task.getId());
log.warn("[similar-asin] LLM 上游欠费/密钥失效,任务落终态 FAILED 以停止为空转的行继续买出口 IP"
+ " taskId={} err={}", task.getId(), task.getErrorMessage());
}
@Override
public void finalizeExhaustedResultFileJob(TaskFileJobEntity job, String message) {
handleResultFileJobFailure(job, message);
@@ -22,6 +22,7 @@ import com.nanri.aiimage.modules.task.model.entity.TaskFileJobEntity;
import com.nanri.aiimage.modules.task.model.entity.TaskProgressSnapshotEntity;
import com.nanri.aiimage.modules.task.model.entity.TaskScopeStateEntity;
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 lombok.extern.slf4j.Slf4j;
@@ -121,6 +122,7 @@ public class SimilarAsinHistoryAssembler {
vo.setTaskId(task.getId());
vo.setTaskStatus(task.getStatus());
vo.setSuccess(false);
vo.setError(TaskVisibleFailureNotice.forTask(task));
vo.setCreatedAt(fmt(task.getCreatedAt()));
vo.setStartedAt(fmt(task.getCreatedAt()));
vo.setFinishedAt(fmt(task.getFinishedAt()));
@@ -137,7 +139,7 @@ public class SimilarAsinHistoryAssembler {
vo.setTaskStatus(resolveDisplayTaskStatus(task, row));
attachFileJobState(vo, row, job, task);
vo.setSuccess(row.getSuccess() != null && row.getSuccess() == 1);
vo.setError(row.getErrorMessage());
vo.setError(TaskVisibleFailureNotice.forHistoryRow(task, row.getErrorMessage()));
vo.setRowCount(row.getRowCount());
vo.setCreatedAt(fmt(row.getCreatedAt()));
// 任务开始时间复用 biz_file_task.created_at;缺 task 时回退到 result.createdAt 兜底
@@ -29,4 +29,12 @@ public interface SimilarAsinPipelineHost {
/** 结果文件任务重试耗尽后的失败处理(宿主侧带事务边界)。 */
void finalizeExhaustedResultFileJob(TaskFileJobEntity job, String message);
/**
* 上游 LLM 账户欠费/密钥失效的<b>任务级处置</b>出口:识别归流水线,落终态归宿主
* ({@code fileTaskMapper}/任务缓存清理都在宿主手里,判宽了也不该由 support 决定)。
* 口径与外观专利 2026-10-27 那条一致——任务不落终态,心跳就不回 {@code alive=false},
* Linux 采集端({@code similar_worker})会继续为永远进不了 LLM 的行按次付费买出口 IP。
*/
void terminalizeOnFatalLlmFailure(FileTaskEntity task, String failureMessage);
}
@@ -1308,6 +1308,9 @@ public class SimilarAsinPipelineSupport {
null,
markRowsFailed(batchRows, message),
allRowsByBaseId);
// 行级归因先落库,再把整单交出去:欠费/密钥失效这一类后面每一批都拿不到结论,
// 而采集端只看心跳的 alive——任务不落终态,它就会继续为这些行按次付费买出口 IP。
host.terminalizeOnFatalLlmFailure(task, message);
return false;
}
if (llmRows == null || llmRows.isEmpty()) {
@@ -0,0 +1,86 @@
package com.nanri.aiimage.modules.task.service;
import com.nanri.aiimage.common.retry.LlmBalanceGuard;
import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
/**
* 任务级失败归因交给用户界面前的那道出口。
*
* <p>{@code biz_file_task.error_message} 存的是给支持同学查根因的原文,带着上游响应体
* ({@code lastErr=LLM http 403: {"error":{"code":"insufficient_user_quota"…}}),把这一串直接摊到
* 界面上既读不懂、也漏出上游账户号——全仓尺子
* {@code RawExceptionMessageSinkGuardTest} 就是为此而存在。欠费/密钥失效恰好有现成的中文句子
* ({@link LlmBalanceGuard#TASK_TERMINAL_GUIDANCE}),所以出口认出<b>本仓自己写下的那条归因</b>就换成它,
* 库里原文一个字都不动。认别人写的"余额不足"不换——那句可能是 jikip 代理欠费,换成 LLM 的话就是说谎。
*
* <p>外观专利与货源两支历史装配器都走这里:优先级逻辑抄两份,改一处就静默失效。
*/
public final class TaskVisibleFailureNotice {
private TaskVisibleFailureNotice() {
}
/** 任务级归因的界面读法;任务没写过错误就返回 null(界面这一行不出现「错误:」)。 */
public static String forTask(FileTaskEntity task) {
return forStoredMessage(task == null ? null : task.getErrorMessage());
}
/**
* 历史行(一个结果文件一行)的界面读法。
*
* <p>欠费/密钥失效是<b>整单</b>的结论,压过行级文案——行级那句往往只是同一次欠费的副产品,
* 让用户先看到"充值或换密钥后重新发起"才是可执行的。其余情形维持既有形状:行级优先,
* 行级为空才用任务级兜底(兜不住时界面就只剩一个「失败」,2026-10-31 现网即卡在这里)。
*/
public static String forHistoryRow(FileTaskEntity task, String rowError) {
String stored = task == null ? null : task.getErrorMessage();
if (isFatalArrears(stored)) {
return forStoredMessage(stored);
}
String row = trimToNull(rowError);
return row != null ? row : forStoredMessage(stored);
}
private static String forStoredMessage(String stored) {
String raw = trimToNull(stored);
if (raw == null) {
return null;
}
return isFatalArrears(raw) ? LlmBalanceGuard.TASK_TERMINAL_GUIDANCE : raw;
}
/**
* 这条库里原文是不是<b>整单</b>的不可抗力结论(上游账户欠费 / LLM 密钥失效)。
*
* <p>收尾路径拿它决定「新文案能不能覆盖旧结论」:欠费判死的单后来被一次带空错误串的收尾
* 盖掉,界面上就又回到「只见失败、不见原因」,采集端也会以为这单还能跑。
*/
public static boolean isWholeTaskVerdict(String storedMessage) {
return isFatalArrears(storedMessage);
}
/**
* 这条库里原文是不是<b>本仓自己写下</b>的 LLM 欠费/密钥失效归因(生产者句 {@code REASON_LLM_BALANCE_DUE}
* 或终态句 {@code TASK_TERMINAL_GUIDANCE} 命中其一)。
*
* <p>刻意<b>不</b>用 {@link TaskRetryEligibility.Category#BALANCE} 当这里的判据:那一类还涵盖
* jikip <b>代理 IP</b>欠费与套餐过期("余额不足"/"套餐不存在"),拿它换句子会把"代理出口没钱了"
* 说成"上游 LLM 账户欠费"——正是 2026-10-27 用户点名要避免的那种误导。判死侧(是否落终态)仍用
* 那一类,因为两条链的调用点只会收到自己那类错误。
*/
private static boolean isFatalArrears(String errorMessage) {
if (errorMessage == null || errorMessage.isBlank()) {
return false;
}
return errorMessage.contains(LlmBalanceGuard.REASON_LLM_BALANCE_DUE)
|| errorMessage.contains(LlmBalanceGuard.TASK_TERMINAL_GUIDANCE);
}
private static String trimToNull(String value) {
if (value == null) {
return null;
}
String trimmed = value.trim();
return trimmed.isEmpty() ? null : trimmed;
}
}
@@ -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));
}
}