Files
streamline/control-server/test/readable_retry_backoff.test.ts
2026-11-16 17:26:44 -08:00

88 lines
3.9 KiB
TypeScript

// MUST be first: sets DATABASE_URL before db_client is evaluated.
import "./setup_env";
import { test, expect, describe } from "bun:test";
import { retryDelayMs, isRetryExhausted, retryDecision } from "../src/readable_retry";
/**
* 这组挡的是一个**不报错**的失控:重试扫描原本只有「成功会清掉 error」这一条终止
* 条件,而它只对「终究会停」的失败成立。一个稳定复发的失败永远满足循环条件,于是
* 以固定 5 分钟的节奏无限重跑,每次都是节点上一次几分钟的 claude。
*
* 生产实测(2026-08-20→22):三个目标各失败 108 / 106 / 27 次,两天里约 240 次整机
* 调用全压在同一台 Mac 上,并且长期占满两个报告槽 + 一个译文槽。更糟的是它自我强化 ——
* 进程堆积让 claude 起得更慢,慢过 wrapper 的 120s 等待就判失败,失败又排下一次重试。
*
* 两个方向的判错代价不对称,所以都要钉住:
* - 退让不足 → 又一次风暴,而且照样不报错;
* - 退让过度 → 节点只是眨了一下眼,报告却要等上几小时,而这正是本扫描存在的理由。
*/
describe("readable-retry: 退避与放弃", () => {
const COOLDOWN = 10 * 60 * 1000;
test("第一次失败按原节奏重试 —— 眨一下眼的场景不能被拖慢", () => {
expect(retryDelayMs(0)).toBe(COOLDOWN);
expect(retryDelayMs(1)).toBe(COOLDOWN);
});
test("连续失败逐次翻倍", () => {
expect(retryDelayMs(2)).toBe(COOLDOWN * 2);
expect(retryDelayMs(3)).toBe(COOLDOWN * 4);
expect(retryDelayMs(4)).toBe(COOLDOWN * 8);
});
test("翻倍有上限 —— 不能退到「今天之内不会再看一眼」", () => {
expect(retryDelayMs(50)).toBe(2 * 60 * 60 * 1000);
});
test("连续失败到阈值就彻底停手", () => {
expect(isRetryExhausted(4)).toBe(false);
expect(isRetryExhausted(5)).toBe(true);
// 风暴里那三个目标,分别到了 108 / 106 / 27。
expect(isRetryExhausted(108)).toBe(true);
});
describe("retryDecision", () => {
const now = 1_000_000_000_000;
test("从没失败过 + 冷却已过 = 该跑", () => {
const d = retryDecision(undefined, now - COOLDOWN - 1, now);
expect(d.due).toBe(true);
expect(d.reason).toBe("due");
expect(d.failures).toBe(0);
});
test("冷却没过 = 等着,并说清还要等多久", () => {
const d = retryDecision({ failures: 1, lastFailureAt: now - 60_000 }, now - 60_000, now);
expect(d.due).toBe(false);
expect(d.reason).toBe("cooling");
expect(d.waitMs).toBe(COOLDOWN - 60_000);
});
test("失败越多,同样的时间点就越不该跑", () => {
const failedAt = now - COOLDOWN * 3;
// 失败 2 次:退避 20 分钟,30 分钟前失败的 → 到点了。
expect(retryDecision({ failures: 2, lastFailureAt: failedAt }, failedAt, now).due).toBe(true);
// 失败 4 次:退避 80 分钟,同一个时间点 → 还得等。
const d4 = retryDecision({ failures: 4, lastFailureAt: failedAt }, failedAt, now);
expect(d4.due).toBe(false);
expect(d4.reason).toBe("cooling");
});
test("到达阈值后不管冷却多久都不再跑 —— 这是风暴的止血点", () => {
// 失败很久以前,冷却早就过了;旧逻辑在这里会毫不犹豫地再跑一次。
const d = retryDecision({ failures: 9, lastFailureAt: now - 24 * 3600 * 1000 }, now - 24 * 3600 * 1000, now);
expect(d.due).toBe(false);
expect(d.reason).toBe("exhausted");
expect(d.failures).toBe(9);
});
test("generatedAt 缺失时退回用 streak 自己的时间戳,而不是当成「从没跑过」", () => {
// 当成 0 会让 now - 0 远大于任何退避 → 立刻重跑,退避形同虚设。
const d = retryDecision({ failures: 3, lastFailureAt: now - 1000 }, null, now);
expect(d.due).toBe(false);
expect(d.reason).toBe("cooling");
});
});
});