fix(brand-check): 补测耗尽通知按失败类别说话,代理套餐问题不再算成上游的锅

16890 改烧任务归属用户自己的代理提取链接后,失败主因从上游不可用变成用户侧套餐:
现网 12 分钟内 18 条「全部 N 把代理 key 处于冷却」、4 条「余额不足」。而耗尽通知仍一律写
「上游商标库持续不可用,建议稍后重新提交采集任务重跑这些 ASIN」——既把账算到别人头上,
又把人推向"重跑必然还是同样失败"的那条路。

- 新增 BrandCheckFailureNotice:原始原因 → Kind(未配置/套餐耗尽/冷却/出口被拒/技术性/上游),
  每类给一句"发生了什么 + 该做什么",代理侧全部指向「密钥设置」的「代理设置」。
- 拒付判定排在冷却之前:key 因余额不足被拒后整批写冷却,只报冷却等于让用户白等。
- pushRecheckOutcome 多收一个 Kind,耗尽分支改用它给的句子;last_error 照库存原文供后台取证。
- 30 支用例(分类器 9 / 通知 7 / 调度 10,含冷却原话透传到通知那支),判据串取自现网读到的原文。
This commit is contained in:
2026-10-20 23:05:29 +08:00
parent b9fb25c270
commit 74384fa6ac
6 changed files with 269 additions and 18 deletions
@@ -0,0 +1,91 @@
package com.nanri.aiimage.modules.brand.support;
import com.nanri.aiimage.modules.brand.client.BrandCheckClient;
import java.util.regex.Pattern;
/**
* 把 16890 品牌检测回来的原始原因归成"用户看得懂的那一类",并给出该做的动作。
*
* <p>存在的理由只有一句:2026-10-20 品牌检测改成烧**任务归属用户自己的**代理提取链接后,
* 失败主因从「上游商标库不可用」变成了用户侧套餐问题(现网 12 分钟内 18 条冷却、4 条余额不足),
* 而补测耗尽通知还写着「上游商标库持续不可用」——既冤枉了上游,也让用户照着提示去重跑,
* 重跑当然还是失败。原始原因照旧进 {@code biz_collectdata_brand_recheck.last_error}
* 供后台取证,这里只管对用户说话的那一句。
*/
public final class BrandCheckFailureNotice {
public enum Kind {
/** 没配代理提取链接:不是查不到,是根本没得查,动作最明确。 */
PROXY_NOT_CONFIGURED,
/** 套餐余额不足/过期/未开通:不充值或换链接,重跑多少次都一样。 */
PROXY_PACKAGE_EXHAUSTED,
/** 所有 key 都在拒付冷却窗口里:短时现象,补测轮会自动再来。 */
PROXY_COOLDOWN,
/** 代理出口 IP 被商标库拒绝。 */
PROXY_EGRESS_REJECTED,
/** 提取没返回可用 IP、请求失败、解密失败等本地/链路技术性失败。 */
TECHNICAL,
/** 上游商标库本身不可用,或上游没给原因(含连接层失败)。 */
UPSTREAM
}
/** 供应商拒付类话术(与 16890 侧判拒付用的关键字同一套)。 */
private static final Pattern PACKAGE_EXHAUSTED = Pattern.compile("余额不足|欠费|套餐不存在|套餐已过期|套餐过期|未开通");
private static final Pattern COOLDOWN = Pattern.compile("处于冷却|冷却窗口|冷却");
private static final Pattern EGRESS_REJECTED = Pattern.compile("拒绝代理出口|出口 IP|换 IP 重试");
private static final Pattern TECHNICAL = Pattern.compile(
"查询或解密失败|代理请求失败|未返回可用 IP|提取失败|解密");
private BrandCheckFailureNotice() {
}
/**
* 原始原因 → 类别。空串按「上游」算:Java 自己在连接层失败时拿不到上游的 reason,
* 那种情况下能观测到的事实也只有"没回来"。
*
* <p>拒付判定在冷却之前:一把 key 因余额不足被拒后,随后的整批都写成"处于冷却",
* 但那句是冷却、根因是套餐,两个都命中时取更靠根因的那一类。
*/
public static Kind classify(String rawReason) {
String reason = rawReason == null ? "" : rawReason.trim();
if (reason.isEmpty()) {
return Kind.UPSTREAM;
}
if (BrandCheckClient.NO_PROXY_REASON.equals(reason)) {
return Kind.PROXY_NOT_CONFIGURED;
}
if (PACKAGE_EXHAUSTED.matcher(reason).find()) {
return Kind.PROXY_PACKAGE_EXHAUSTED;
}
if (COOLDOWN.matcher(reason).find()) {
return Kind.PROXY_COOLDOWN;
}
if (EGRESS_REJECTED.matcher(reason).find()) {
return Kind.PROXY_EGRESS_REJECTED;
}
if (TECHNICAL.matcher(reason).find()) {
return Kind.TECHNICAL;
}
return Kind.UPSTREAM;
}
/** 用户可读的那一句:先说发生了什么,再说该做什么。 */
public static String userMessage(Kind kind) {
if (kind == null) {
return "商标库本次未返回结果,系统会在后续补测轮自动重试。";
}
return switch (kind) {
case PROXY_NOT_CONFIGURED -> "这个账号还没配代理提取链接,品牌检测无法发起查询:"
+ "请在「密钥设置」的「代理设置」里补上后重跑这些行。";
case PROXY_PACKAGE_EXHAUSTED -> "你的代理提取套餐余额不足或已过期,"
+ "请在「密钥设置」的「代理设置」里充值或更换提取链接,否则重跑也会同样失败。";
case PROXY_COOLDOWN -> "你的代理提取链接连续被供应商拒绝,短时间内已不再尝试;"
+ "系统会在后续补测轮自动重试,若反复出现请检查「密钥设置」的「代理设置」里的套餐余量。";
case PROXY_EGRESS_REJECTED -> "代理出口 IP 被商标库拒绝,系统会自动换出口并在后续补测轮重试;"
+ "持续如此时请更换「密钥设置」的「代理设置」里的提取链接。";
case TECHNICAL -> "品牌检测本次没取回结果(代理提取或结果解析未成功),系统会在后续补测轮自动重试。";
case UPSTREAM -> "上游商标库暂时不可用,系统会在后续补测轮自动重试。";
};
}
}
@@ -3,6 +3,7 @@ package com.nanri.aiimage.modules.collectdata.service;
import com.nanri.aiimage.common.service.DistributedJobLockService;
import com.nanri.aiimage.config.CollectDataBrandRecheckProperties;
import com.nanri.aiimage.modules.brand.client.BrandCheckClient;
import com.nanri.aiimage.modules.brand.support.BrandCheckFailureNotice;
import com.nanri.aiimage.modules.collectdata.model.entity.CollectDataBrandRecheckEntity;
import com.nanri.aiimage.modules.collectdata.service.CollectDataBrandRecheckInjector.RecheckVerdict;
import com.nanri.aiimage.modules.collectdata.util.CollectDataBrandBatchFilter;
@@ -220,7 +221,8 @@ public class CollectDataBrandRecheckScheduler {
}
notificationDispatchService.pushRecheckOutcome(task.getUserId(), task.getId(), MODULE_TYPE,
task.getTaskNo(), outcome.acceptedRows(), outcome.rejectedRows(),
stillFailedEntries.size(), exhaustedThisRound);
stillFailedEntries.size(), exhaustedThisRound,
BrandCheckFailureNotice.classify(checkReason));
log.info("[brand-recheck] 任务组完成 taskId={} 品牌={} 净={} 败={} 仍失败={} 收口={} 新增结果行={} 判定无效行={}",
task.getId(), brands.size(), cleanEntries.size(), rejectedEntries.size(),
stillFailedEntries.size(), exhaustedThisRound, outcome.acceptedRows(), outcome.rejectedRows());
@@ -5,6 +5,7 @@ import com.nanri.aiimage.common.module.TaskModuleRegistry;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.common.mapper.AdminUserMapper;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.modules.brand.support.BrandCheckFailureNotice;
import com.nanri.aiimage.modules.permission.support.UserDataScopeSupport;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
@@ -143,7 +144,8 @@ public class NotificationDispatchService {
* 同任务同自然日一条(dedupe_key 带日期):补测按轮推进,同一轮内多品牌合并成一条。
*/
public void pushRecheckOutcome(Long userId, Long taskId, String moduleType, String taskNo,
int injectedRows, int rejectedRows, int pendingRows, int exhaustedRows) {
int injectedRows, int rejectedRows, int pendingRows, int exhaustedRows,
BrandCheckFailureNotice.Kind failureKind) {
if (userId == null || userId <= 0 || taskId == null) {
return;
}
@@ -164,8 +166,11 @@ public class NotificationDispatchService {
+ "。结果文件已更新,可在「历史任务」重新下载。";
} else {
title = label + "任务品牌补测未能完成";
// 这句过去一律写成「上游商标库持续不可用」并建议重跑——2026-10-20 起品牌检测烧的是
// 用户自己的代理提取链接,主因变成套餐/冷却,那句既冤枉上游又把用户推向"重跑还是失败"。
// 原始原因照旧留在补测条目 last_error 里给后台取证。
content = "任务 " + displayTaskNo + ":品牌检测连续多轮自动补测仍未成功,共 " + exhaustedRows
+ " 行未能补出结论(上游商标库持续不可用)。建议稍后重新提交采集任务重跑这些 ASIN。";
+ " 行未能补出结论。" + BrandCheckFailureNotice.userMessage(failureKind);
}
String level = fixed && pendingRows <= 0
? NotificationService.LEVEL_INFO : NotificationService.LEVEL_WARNING;
@@ -0,0 +1,99 @@
package com.nanri.aiimage.modules.brand.support;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
/**
* 品牌检测失败原因的分类与用户文案:判据全部取自 2026-10-20 现网真出现过的句子
* ({@code biz_collectdata_brand_recheck.last_error} 与 Java brand-check warn 日志),
* 不是设想出来的样例。
*
* <p>这条链要守住的只有一件事:**代理侧的原因不许说成上游的锅**。改之前补测耗尽通知一律写
* 「上游商标库持续不可用,建议稍后重跑」,而现网 12 分钟内 18 条是"key 处于冷却"、4 条是
* 「余额不足」——都是用户自己的套餐,重跑必然还是失败。
*/
class BrandCheckFailureNoticeTest {
@Test
void 空原因按上游算_连接层失败拿不到上游原话() {
assertThat(BrandCheckFailureNotice.classify(null)).isEqualTo(BrandCheckFailureNotice.Kind.UPSTREAM);
assertThat(BrandCheckFailureNotice.classify(" ")).isEqualTo(BrandCheckFailureNotice.Kind.UPSTREAM);
assertThat(BrandCheckFailureNotice.classify("socket timeout")).isEqualTo(BrandCheckFailureNotice.Kind.UPSTREAM);
}
@Test
void 未配置代理是独立一类() {
assertThat(BrandCheckFailureNotice.classify("用户未配置代理"))
.isEqualTo(BrandCheckFailureNotice.Kind.PROXY_NOT_CONFIGURED);
}
@Test
void 供应商拒付类话术归到套餐() {
assertThat(BrandCheckFailureNotice.classify("余额不足"))
.isEqualTo(BrandCheckFailureNotice.Kind.PROXY_PACKAGE_EXHAUSTED);
assertThat(BrandCheckFailureNotice.classify("代理提取失败(套餐已过期)"))
.isEqualTo(BrandCheckFailureNotice.Kind.PROXY_PACKAGE_EXHAUSTED);
assertThat(BrandCheckFailureNotice.classify("代理提取失败(套餐不存在)"))
.isEqualTo(BrandCheckFailureNotice.Kind.PROXY_PACKAGE_EXHAUSTED);
assertThat(BrandCheckFailureNotice.classify("账户欠费"))
.isEqualTo(BrandCheckFailureNotice.Kind.PROXY_PACKAGE_EXHAUSTED);
}
@Test
void 冷却窗口归到冷却() {
assertThat(BrandCheckFailureNotice.classify("全部 1 把代理 key 处于冷却,最早还要等 299 秒"))
.isEqualTo(BrandCheckFailureNotice.Kind.PROXY_COOLDOWN);
}
@Test
void 冷却里带着拒付根因时取根因那一类() {
// 一把 key 因余额不足被拒后,整批都写成"处于冷却":只报冷却会把用户引向"等一等",
// 而真动作是充值/换链接。
assertThat(BrandCheckFailureNotice.classify("全部 2 把代理 key 处于冷却(余额不足),最早还要等 299 秒"))
.isEqualTo(BrandCheckFailureNotice.Kind.PROXY_PACKAGE_EXHAUSTED);
}
@Test
void 出口被上游拒单独一类因为它要换的是链接不是套餐() {
assertThat(BrandCheckFailureNotice.classify("上游拒绝代理出口 IP,换 IP 重试仍未放行"))
.isEqualTo(BrandCheckFailureNotice.Kind.PROXY_EGRESS_REJECTED);
}
@Test
void 技术性失败_提取没结果_请求失败_解密失败() {
assertThat(BrandCheckFailureNotice.classify("代理提取未返回可用 IP"))
.isEqualTo(BrandCheckFailureNotice.Kind.TECHNICAL);
assertThat(BrandCheckFailureNotice.classify("代理请求失败: connection reset"))
.isEqualTo(BrandCheckFailureNotice.Kind.TECHNICAL);
assertThat(BrandCheckFailureNotice.classify(
"查询或解密失败: 未找到 node 命令,请确保已安装 Node.js 并添加到 PATH"))
.isEqualTo(BrandCheckFailureNotice.Kind.TECHNICAL);
}
@Test
void 每一类都给得出可执行动作() {
for (BrandCheckFailureNotice.Kind kind : BrandCheckFailureNotice.Kind.values()) {
String message = BrandCheckFailureNotice.userMessage(kind);
assertThat(message).as("类别 %s 必须有话术", kind).isNotBlank();
if (kind.name().startsWith("PROXY_")) {
assertThat(message).as("代理侧的类别必须把用户带到「代理设置」门口:%s", message)
.contains("代理设置");
// 禁的是"把账算到别人头上"这两句:不许说成上游的锅,也不许说成库坏了让用户白等。
// 「代理出口 IP 被商标库拒绝」里出现"商标库"是事实陈述(拒绝的就是那个库),
// 动作仍然指向换提取链接,所以不在禁列——旧文案的毛病是说库「持续不可用」。
assertThat(message).as("代理侧的原因不许说成上游的锅:%s", message)
.doesNotContain("上游")
.doesNotContain("不可用");
} else {
assertThat(message).as("非代理类别应当给出自动补测的兜底:%s", message)
.contains("自动重试");
}
}
}
@Test
void 类别缺失时退回上游那句而不是空话() {
assertThat(BrandCheckFailureNotice.userMessage(null)).contains("自动重试");
}
}
@@ -3,6 +3,7 @@ package com.nanri.aiimage.modules.collectdata.service;
import com.nanri.aiimage.common.service.DistributedJobLockService;
import com.nanri.aiimage.config.CollectDataBrandRecheckProperties;
import com.nanri.aiimage.modules.brand.client.BrandCheckClient;
import com.nanri.aiimage.modules.brand.support.BrandCheckFailureNotice;
import com.nanri.aiimage.modules.collectdata.model.entity.CollectDataBrandRecheckEntity;
import com.nanri.aiimage.modules.collectdata.service.CollectDataBrandRecheckInjector.GroupOutcome;
import com.nanri.aiimage.modules.notification.service.NotificationDispatchService;
@@ -119,7 +120,7 @@ class CollectDataBrandRecheckSchedulerTest {
verify(recheckService).postponeWithoutAttempt(List.of(e1), 30);
verify(brandCheckClient, never()).checkAll(anyList(), anyString(), any());
verify(notificationDispatchService, never()).pushRecheckOutcome(
any(), any(), anyString(), anyString(), anyInt(), anyInt(), anyInt(), anyInt());
any(), any(), anyString(), anyString(), anyInt(), anyInt(), anyInt(), anyInt(), any());
}
@Test
@@ -167,7 +168,28 @@ class CollectDataBrandRecheckSchedulerTest {
verify(recheckService, never()).markAttempted(any(), anyString());
verify(taskFileJobService).enqueueAssembleResult(100L, "COLLECT_DATA", 9L, "task:100");
verify(notificationDispatchService).pushRecheckOutcome(
961L, 100L, "COLLECT_DATA", "COLLECT_DATA-100", 3, 1, 0, 0);
961L, 100L, "COLLECT_DATA", "COLLECT_DATA-100", 3, 1, 0, 0,
BrandCheckFailureNotice.Kind.UPSTREAM);
}
@Test
void runRoundPassesProxyCooldownKindThroughToNotification() {
// 上游回来的原因就是"全部 key 处于冷却"时,通知必须拿到冷却这一类,
// 而不是继续按"上游商标库不可用"对用户说话。
CollectDataBrandRecheckEntity e1 = entry(1, 100L, "zara");
when(recheckService.listDue(any(), anyInt())).thenReturn(List.of(e1));
when(fileTaskMapper.selectById(100L)).thenReturn(task(100L, "SUCCESS"));
when(taskDistributedLockService.acquire("COLLECT_DATA", 100L, 2000L)).thenReturn(taskLock);
when(brandCheckClient.checkAll(anyList(), eq("Terms"), any())).thenReturn(
new BrandCheckClient.BrandCheckBatchResult(List.of(), List.of(), List.of("zara"),
"全部 1 把代理 key 处于冷却,最早还要等 299 秒"));
scheduler.runRound();
verify(recheckService).markAttempted(e1, "全部 1 把代理 key 处于冷却,最早还要等 299 秒");
verify(notificationDispatchService).pushRecheckOutcome(
961L, 100L, "COLLECT_DATA", "COLLECT_DATA-100", 0, 0, 1, 0,
BrandCheckFailureNotice.Kind.PROXY_COOLDOWN);
}
@Test
@@ -185,7 +207,8 @@ class CollectDataBrandRecheckSchedulerTest {
verify(injector, never()).apply(any(), any());
verify(taskFileJobService, never()).enqueueAssembleResult(anyLong(), anyString(), anyLong(), anyString());
verify(notificationDispatchService).pushRecheckOutcome(
961L, 100L, "COLLECT_DATA", "COLLECT_DATA-100", 0, 0, 1, 0);
961L, 100L, "COLLECT_DATA", "COLLECT_DATA-100", 0, 0, 1, 0,
BrandCheckFailureNotice.Kind.UPSTREAM);
}
@Test
@@ -220,7 +243,7 @@ class CollectDataBrandRecheckSchedulerTest {
verify(taskFileJobService, never()).enqueueAssembleResult(anyLong(), anyString(), anyLong(), anyString());
// 注入失败:无修复、无收口,不打扰用户
verify(notificationDispatchService, never()).pushRecheckOutcome(
any(), any(), anyString(), anyString(), anyInt(), anyInt(), anyInt(), anyInt());
any(), any(), anyString(), anyString(), anyInt(), anyInt(), anyInt(), anyInt(), any());
}
@Test
@@ -2,6 +2,7 @@ package com.nanri.aiimage.modules.notification.service;
import com.nanri.aiimage.common.mapper.AdminUserMapper;
import com.nanri.aiimage.common.security.AdminAuthSupport;
import com.nanri.aiimage.modules.brand.support.BrandCheckFailureNotice;
import com.nanri.aiimage.modules.permission.support.UserDataScopeSupport;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@@ -11,6 +12,7 @@ import org.mockito.junit.jupiter.MockitoExtension;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.argThat;
import static org.mockito.ArgumentMatchers.contains;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.ArgumentMatchers.startsWith;
@@ -19,7 +21,7 @@ import static org.mockito.Mockito.verify;
/**
* 品牌补测结果通知:补出结论才推、同任务同日一条(dedupe_key 带日期)、
* 全部收口未修复时改推「未能完成」指引。只推用户不推管理员(正向收敛不放大铃铛)。
* 全部收口未修复时改推「未能完成」并按**失败类别**给指引。只推用户不推管理员(正向收敛不放大铃铛)。
*/
@ExtendWith(MockitoExtension.class)
class NotificationDispatchServiceRecheckTest {
@@ -38,7 +40,8 @@ class NotificationDispatchServiceRecheckTest {
@Test
void pushRecheckOutcomeNotifiesUserWithInfoLevelWhenAllResolved() {
service.pushRecheckOutcome(961L, 29842L, "COLLECT_DATA", "COLLECT_DATA-29842", 3, 1, 0, 0);
service.pushRecheckOutcome(961L, 29842L, "COLLECT_DATA", "COLLECT_DATA-29842", 3, 1, 0, 0,
BrandCheckFailureNotice.Kind.UPSTREAM);
verify(notificationService).pushOrRefresh(eq(961L), eq("user"), eq("task_partial"),
eq("info"), contains("补测完成"), contains("新增结果 3 行"), startsWith("collect_recheck:29842:"));
@@ -46,7 +49,8 @@ class NotificationDispatchServiceRecheckTest {
@Test
void pushRecheckOutcomeUsesWarningWhileRowsStillPending() {
service.pushRecheckOutcome(961L, 29842L, "COLLECT_DATA", "COLLECT_DATA-29842", 3, 0, 5, 0);
service.pushRecheckOutcome(961L, 29842L, "COLLECT_DATA", "COLLECT_DATA-29842", 3, 0, 5, 0,
BrandCheckFailureNotice.Kind.UPSTREAM);
verify(notificationService).pushOrRefresh(eq(961L), eq("user"), eq("task_partial"),
eq("warning"), contains("补测完成"), contains("仍有 5 行"), anyString());
@@ -55,26 +59,53 @@ class NotificationDispatchServiceRecheckTest {
@Test
void pushRecheckOutcomeStaysSilentOnPureProgressRounds() {
// 本轮没有品牌出结论、也没有条目收口:纯排队推进,不打扰
service.pushRecheckOutcome(961L, 29842L, "COLLECT_DATA", "COLLECT_DATA-29842", 0, 0, 3, 0);
service.pushRecheckOutcome(961L, 29842L, "COLLECT_DATA", "COLLECT_DATA-29842", 0, 0, 0, 0);
service.pushRecheckOutcome(961L, 29842L, "COLLECT_DATA", "COLLECT_DATA-29842", 0, 0, 3, 0,
BrandCheckFailureNotice.Kind.UPSTREAM);
service.pushRecheckOutcome(961L, 29842L, "COLLECT_DATA", "COLLECT_DATA-29842", 0, 0, 0, 0,
BrandCheckFailureNotice.Kind.UPSTREAM);
verify(notificationService, never()).pushOrRefresh(
any(), anyString(), anyString(), anyString(), anyString(), anyString(), anyString());
}
@Test
void pushRecheckOutcomeAdvisesManualRerunWhenAllExhausted() {
service.pushRecheckOutcome(961L, 29842L, "COLLECT_DATA", "COLLECT_DATA-29842", 0, 0, 0, 4);
void pushRecheckOutcomeTellsUserToFixProxyPackageWhenExhaustedByRejection() {
// 2026-10-20 现网主因:用户自己的代理套餐被拒付后冷却。旧文案一律怪「上游商标库」
// 并建议重跑,而重跑必然还是失败——这句得跟着类别走。
service.pushRecheckOutcome(961L, 29842L, "COLLECT_DATA", "COLLECT_DATA-29842", 0, 0, 0, 4,
BrandCheckFailureNotice.Kind.PROXY_PACKAGE_EXHAUSTED);
verify(notificationService).pushOrRefresh(eq(961L), eq("user"), eq("task_partial"),
eq("warning"), contains("未能完成"), contains("共 4 行"), startsWith("collect_recheck:29842:"));
eq("warning"), contains("未能完成"),
argThat(content -> content.contains("共 4 行") && content.contains("代理设置")),
startsWith("collect_recheck:29842:"));
}
@Test
void pushRecheckOutcomeBlamesUpstreamOnlyWhenReasonIsUpstream() {
service.pushRecheckOutcome(961L, 29842L, "COLLECT_DATA", "COLLECT_DATA-29842", 0, 0, 0, 4,
BrandCheckFailureNotice.Kind.UPSTREAM);
verify(notificationService).pushOrRefresh(eq(961L), eq("user"), eq("task_partial"),
eq("warning"), contains("未能完成"), contains("上游商标库"), startsWith("collect_recheck:29842:"));
}
@Test
void pushRecheckOutcomeFallsBackToUpstreamWordingWhenKindMissing() {
service.pushRecheckOutcome(961L, 29842L, "COLLECT_DATA", "COLLECT_DATA-29842", 0, 0, 0, 2, null);
verify(notificationService).pushOrRefresh(eq(961L), eq("user"), eq("task_partial"),
eq("warning"), contains("未能完成"), contains("自动重试"), anyString());
}
@Test
void pushRecheckOutcomeSkipsInvalidUser() {
service.pushRecheckOutcome(null, 29842L, "COLLECT_DATA", "COLLECT_DATA-29842", 3, 1, 0, 0);
service.pushRecheckOutcome(0L, 29842L, "COLLECT_DATA", "COLLECT_DATA-29842", 3, 1, 0, 0);
service.pushRecheckOutcome(961L, null, "COLLECT_DATA", "COLLECT_DATA-29842", 3, 1, 0, 0);
service.pushRecheckOutcome(null, 29842L, "COLLECT_DATA", "COLLECT_DATA-29842", 3, 1, 0, 0,
BrandCheckFailureNotice.Kind.UPSTREAM);
service.pushRecheckOutcome(0L, 29842L, "COLLECT_DATA", "COLLECT_DATA-29842", 3, 1, 0, 0,
BrandCheckFailureNotice.Kind.UPSTREAM);
service.pushRecheckOutcome(961L, null, "COLLECT_DATA", "COLLECT_DATA-29842", 3, 1, 0, 0,
BrandCheckFailureNotice.Kind.UPSTREAM);
verify(notificationService, never()).pushOrRefresh(
any(), anyString(), anyString(), anyString(), anyString(), anyString(), anyString());