tt-help-cli-ycl 1.4.169 → 1.4.171

package/scripts/test-daemon-failover.mjs

@@ -1,301 +0,0 @@
-/**
- * daemon _handleFailover 单测（2026-08-25，时间锚点方案，无需 Clash 运行）
- *
- * 验证：
- *   - 探针不健康 → 立即切换（无视冷却）
- *   - 探针健康（含壳页）→ 距上次切换 < 冷却期仅检查不切换
- *   - 探针健康 → 距上次切换 >= 冷却期 → 按业务级封禁轮换一次
- *   - 强切（force=true）→ 探针健康且冷却期内仍强制轮换
- *   - 切换后（含手动/巡检/failover）更新 _lastSwitchAt 锚点，冷却期内不再切
- *   - 候选集为空 → 触发 delay 初测且不切换
- *
- * 运行: node --test scripts/test-daemon-failover.mjs
- *      （若当前 Node 版本 module mock 仍需 flag: --experimental-test-module-mocks）
- */
-import { test, mock, before } from "node:test";
-import assert from "node:assert/strict";
-
-// ── 可配置假依赖状态 ──
-const state = {
-  health: {
-    healthy: true,
-    httpCode: 200,
-    timeTotal: 1.2,
-    sizeDownload: 100000,
-    numRedirects: 0,
-    title: "TikTok - Make Your Day",
-    error: null,
-  },
-  nodes: ["🇭🇰 香港01", "🇲🇾 马来02"],
-  currentNode: "🇭🇰 香港01",
-  switches: [],
-  closes: 0, // closeAllConnections（全断）调用次数
-  idleCloses: 0, // closeIdleConnections（优雅断连）调用次数
-  failIdleClose: false, // 模拟优雅断连失败
-  // 订阅切换感知（巡检开头候选集存在性校验）相关
-  proxyMap: { "🇭🇰 香港01": {}, "🇲🇾 马来02": {} }, // 当前 /proxies 中的代理名
-  pruneResult: { kept: 2, removed: 0, allGone: false },
-  pruneCalls: 0,
-  probeCalls: 0,
-  failProxies: false,
-};
-
-function resetState() {
-  state.health = {
-    healthy: true,
-    httpCode: 200,
-    timeTotal: 1.2,
-    sizeDownload: 100000,
-    numRedirects: 0,
-    title: "TikTok - Make Your Day",
-    error: null,
-  };
-  state.nodes = ["🇭🇰 香港01", "🇲🇾 马来02"];
-  state.currentNode = "🇭🇰 香港01";
-  state.switches = [];
-  state.closes = 0;
-  state.idleCloses = 0;
-  state.failIdleClose = false;
-  state.proxyMap = { "🇭🇰 香港01": {}, "🇲🇾 马来02": {} };
-  state.pruneResult = { kept: 2, removed: 0, allGone: false };
-  state.pruneCalls = 0;
-  state.probeCalls = 0;
-  state.failProxies = false;
-}
-
-// ── 注册模块 mock（必须在 import daemon.js 之前） ──
-before(async () => {
-  mock.module("../src/clash/checker.js", {
-    namedExports: {
-      normalizeCountries: (v) => (Array.isArray(v) ? [...v] : v ? [v] : []),
-      CONFIG: {
-        groupName: "GLOBAL",
-        testUrl: "https://www.tiktok.com/explore",
-        proxyUrl: "http://127.0.0.1:7897",
-        nodeCountryFilter: null,
-      },
-      checkNodeHealth: () => ({ ...state.health }),
-      loadHealthyList: () => ({ nodes: [...state.nodes] }),
-      switchToNode: async (n) => {
-        state.switches.push(n);
-        state.currentNode = n;
-        // 模拟真实世界：故障属于原节点，切换后的新节点健康（候选内容验证通过）
-        state.health = { ...state.health, healthy: true, error: null };
-        return true;
-      },
-      applyDiscovered: () => {},
-      checkClashAlive: () => true,
-      pruneHealthyListByCurrentProxies: () => {
-        state.pruneCalls += 1;
-        return { ...state.pruneResult };
-      },
-      runDelayProbe: async () => {
-        state.probeCalls += 1;
-        return {
-          nodes: [...state.nodes],
-          total: state.nodes.length,
-        };
-      },
-      saveHealthyList: () => {},
-    },
-  });
-  mock.module("../src/clash/api.js", {
-    namedExports: {
-      configure: () => {},
-      getProxies: async () => {
-        if (state.failProxies) throw new Error("mock /proxies 不可达");
-        return { proxies: { ...state.proxyMap } };
-      },
-      getCurrentNode: async () => state.currentNode,
-      closeAllConnections: async () => {
-        state.closes += 1;
-      },
-      closeIdleConnections: async () => {
-        if (state.failIdleClose) throw new Error("mock 优雅断连失败");
-        state.idleCloses += 1;
-        return { closed: 3, active: 2 };
-      },
-    },
-  });
-  mock.module("../src/clash/ipc.js", {
-    namedExports: {
-      writeHealth: () => {},
-      listCommandChannels: () => [],
-      readCommand: () => null,
-      clearCommand: () => {},
-    },
-  });
-  mock.module("../src/clash/discover.js", {
-    namedExports: {
-      discoverAll: async () => [],
-      invalidateDiscoverCache: () => {},
-    },
-  });
-  ({ ClashDaemon } = await import("../src/clash/daemon.js"));
-});
-
-let ClashDaemon = null;
-
-function makeCtx(opts = {}) {
-  const d = new ClashDaemon({
-    failoverCooldownMs: 600000,
-    failoverEscapeAfter: 3,
-    ...opts,
-  });
-  const c = { proxyPort: 7897 };
-  return { d, c };
-}
-
-test("F1 探针健康：冷却期外首次 failover 即轮换，并更新锚点", async () => {
-  resetState();
-  const { d, c } = makeCtx();
-  c._lastSwitchAt = Date.now() - 600_001; // 距上次切换 > 10min 冷却
-  await d._handleFailover({ reason: "F1" }, c);
-  assert.deepEqual(state.switches, ["🇲🇾 马来02"], "冷却期外应轮换切换");
-  assert.equal(state.idleCloses, 1, "切换后应优雅断连（空闲回收）");
-  assert.ok(
-    c._lastSwitchAt && c._lastSwitchAt > Date.now() - 5000,
-    "切换后应更新锚点",
-  );
-});
-
-test("F2 探针不健康：立即切换（无视冷却）", async () => {
-  resetState();
-  const { d, c } = makeCtx();
-  c._lastSwitchAt = Date.now(); // 刚切过，但探针不健康时不看锚点
-  state.health = { ...state.health, healthy: false, error: "timeout" };
-  await d._handleFailover({ reason: "F2" }, c);
-  assert.deepEqual(state.switches, ["🇲🇾 马来02"], "不健康应立即切换");
-});
-
-test("F3 壳页视为链路正常：冷却期内仅检查不切换", async () => {
-  resetState();
-  const { d, c } = makeCtx();
-  c._lastSwitchAt = Date.now(); // 冷却期内
-  // 壳页签名：200 + 无跳转 + 无 error + 无 title
-  state.health = {
-    healthy: false,
-    httpCode: 200,
-    timeTotal: 1.0,
-    sizeDownload: 43000,
-    numRedirects: 0,
-    title: "",
-    error: null,
-  };
-  await d._handleFailover({ reason: "F3" }, c);
-  assert.equal(state.switches.length, 0, "冷却期内壳页不应触发切换");
-});
-
-test("F4 冷却期约束：切换后冷却期内不连续切换，过期后再切", async () => {
-  resetState();
-  const { d, c } = makeCtx();
-  // 首次 failover（无锚点）→ 按冷却期外处理 → 轮换
-  await d._handleFailover({ reason: "F4-1" }, c);
-  assert.equal(state.switches.length, 1, "首次应轮换切换");
-  // 锚点刚更新，冷却期内再次 failover（探针健康）→ 不切
-  await d._handleFailover({ reason: "F4-2" }, c);
-  assert.equal(state.switches.length, 1, "冷却期内不应再切换");
-  // 冷却期过后 → 再次轮换
-  c._lastSwitchAt = Date.now() - 600_001;
-  await d._handleFailover({ reason: "F4-3" }, c);
-  assert.equal(state.switches.length, 2, "冷却期过后应再切换");
-});
-
-test("F5 手动切换同样更新锚点：切换后冷却期内 failover 不再切", async () => {
-  resetState();
-  const { d, c } = makeCtx();
-  // 手动切换（用户主动切，立即执行）
-  await d._handleSwitchNode({ node: "🇲🇾 马来02", proxyPort: 7897 }, c);
-  assert.equal(state.switches.length, 1, "手动切换应立即执行");
-  assert.ok(
-    c._lastSwitchAt && c._lastSwitchAt > Date.now() - 5000,
-    "手动切换应更新锚点",
-  );
-  // 手动切换后冷却期内，探针健康的 failover 不再切
-  await d._handleFailover({ reason: "F5-2" }, c);
-  assert.equal(
-    state.switches.length,
-    1,
-    "手动切换后冷却期内 failover 不应再切",
-  );
-});
-
-// F6 已移除：failoverEscapeAfter 计数方案已弃用（2026-08-25 改为时间锚点），
-// 不再存在"连报 N 次"阈值；字段保留仅为兼容外部传参，不影响行为。
-
-test("F7 候选集为空：触发 delay 初测且不切换", async () => {
-  resetState();
-  const { d, c } = makeCtx();
-  state.health = { ...state.health, healthy: false, error: "timeout" };
-  state.nodes = [];
-  await d._handleFailover({ reason: "F7" }, c);
-  assert.equal(state.switches.length, 0, "无候选不应切换");
-  assert.ok(c._lastProbeAt, "应触发过 delay 初测");
-});
-
-test("F8 优雅断连失败：回退全断，切换仍生效", async () => {
-  resetState();
-  const { d, c } = makeCtx();
-  c._lastSwitchAt = Date.now() - 600_001; // 冷却期外
-  state.failIdleClose = true; // 优雅断连抛错
-  await d._handleFailover({ reason: "F8" }, c);
-  assert.deepEqual(state.switches, ["🇲🇾 马来02"], "切换仍应执行");
-  assert.equal(state.idleCloses, 0, "优雅断连失败未计数");
-  assert.equal(state.closes, 1, "失败后应回退全断");
-});
-
-test("F9 disconnectMode=full：直接全断", async () => {
-  resetState();
-  const { d, c } = makeCtx({ disconnectMode: "full" });
-  c._lastSwitchAt = Date.now() - 600_001;
-  await d._handleFailover({ reason: "F9" }, c);
-  assert.deepEqual(state.switches, ["🇲🇾 马来02"], "切换应执行");
-  assert.equal(state.idleCloses, 0, "full 模式不走优雅断连");
-  assert.equal(state.closes, 1, "full 模式直接全断");
-});
-
-test("F10 强切（force）：冷却期内探针健康仍强制轮换", async () => {
-  resetState();
-  const { d, c } = makeCtx();
-  c._lastSwitchAt = Date.now(); // 刚切过，处于 10min 冷却期内
-  await d._handleFailover({ reason: "F10", force: true }, c);
-  assert.deepEqual(state.switches, ["🇲🇾 马来02"], "force 应无视冷却直接轮换");
-  assert.ok(
-    c._lastSwitchAt && c._lastSwitchAt > Date.now() - 5000,
-    "强切后应更新锚点（给新节点观察期）",
-  );
-});
-
-// ── 订阅切换感知：巡检开头候选集存在性校验（2026-08-29） ──
-
-test("S1 候选集全部失效：当前节点健康也立即触发 delay 初测", async () => {
-  resetState();
-  const { d, c } = makeCtx();
-  state.health = { ...state.health, healthy: true }; // 当前节点健康
-  state.pruneResult = { kept: 0, removed: 2, allGone: true };
-  await d._healthCheckController(c);
-  assert.equal(state.pruneCalls, 1, "巡检应执行候选集校验");
-  // 初测经串行锁排队执行，等队列清空后断言
-  await d._withLock(() => {});
-  assert.equal(state.probeCalls, 1, "全失效应立即触发 delay 初测");
-});
-
-test("S2 候选集部分失效：剔除后不触发初测，巡检正常", async () => {
-  resetState();
-  const { d, c } = makeCtx();
-  state.pruneResult = { kept: 1, removed: 1, allGone: false };
-  await d._healthCheckController(c);
-  await d._withLock(() => {});
-  assert.equal(state.pruneCalls, 1, "应执行候选集校验");
-  assert.equal(state.probeCalls, 0, "部分失效不应触发初测");
-});
-
-test("S3 /proxies 拉取失败：静默跳过校验，不阻断巡检", async () => {
-  resetState();
-  const { d, c } = makeCtx();
-  state.failProxies = true;
-  await d._healthCheckController(c);
-  await d._withLock(() => {});
-  assert.equal(state.pruneCalls, 0, "API 失败不应执行校验");
-  assert.equal(state.probeCalls, 0, "API 失败不应触发初测");
-});

package/scripts/test-daemon-switch-history.mjs

@@ -1,141 +0,0 @@
-/**
- * daemon 切换历史排序单测（无需 Clash 运行）
- * 验证 _sortCandidates / _markSwitch 的纯时间轮换（后进后出）行为
- */
-import { ClashDaemon } from "../src/clash/daemon.js";
-
-let pass = 0;
-let fail = 0;
-function ok(cond, name, detail = "") {
-  if (cond) {
-    pass++;
-    console.log(`  ✓ ${name}`);
-  } else {
-    fail++;
-    console.error(`  ✗ ${name} ${detail}`);
-  }
-}
-
-const d = new ClashDaemon({});
-const nodes = ["A", "B", "C", "D"];
-const T0 = Date.now();
-
-// T1 无历史 → 原序
-{
-  const c = { proxyPort: 1 };
-  ok(
-    JSON.stringify(d._sortCandidates(nodes, c)) === JSON.stringify(nodes),
-    "T1 无历史保持原序",
-  );
-}
-
-// T2 切过沉底，未切过保持原序
-{
-  const c = { proxyPort: 2 };
-  c._switchHistory = new Map([["B", T0 - 10_000]]);
-  const r = d._sortCandidates(nodes, c);
-  ok(r.join() === "A,C,D,B", "T2 切过沉底，未切过保持原序", r.join());
-}
-
-// T3 切过按切换时间升序，未切过最前
-{
-  const c = { proxyPort: 3 };
-  c._switchHistory = new Map([
-    ["C", T0 - 2_000],
-    ["A", T0 - 1_000],
-  ]);
-  const r = d._sortCandidates(nodes, c);
-  ok(r.join() === "B,D,C,A", "T3 切过按切换时间升序，未切过最前", r.join());
-}
-
-// T4 全部切过 → 完全按切换时间轮换
-{
-  const c = { proxyPort: 4 };
-  c._switchHistory = new Map([
-    ["A", T0 - 4_000],
-    ["B", T0 - 1_000],
-    ["C", T0 - 3_000],
-    ["D", T0 - 2_000],
-  ]);
-  const r = d._sortCandidates(nodes, c);
-  ok(r.join() === "A,C,D,B", "T4 全切过按切换时间轮换", r.join());
-}
-
-// T5 无时间窗口：无论多久前切过都按时间排队（不恢复 delay 原序）
-{
-  const c = { proxyPort: 5 };
-  c._switchHistory = new Map([["C", T0 - 3_600_000]]); // 1 小时前切过
-  const r = d._sortCandidates(nodes, c);
-  ok(r.join() === "A,B,D,C", "T5 无窗口：1 小时前切过仍沉底", r.join());
-}
-
-// T6 排序不改原数组
-{
-  ok(nodes.join() === "A,B,C,D", "T6 原数组未被修改");
-}
-
-// T7 _markSwitch 惰性初始化 + 更新
-{
-  const c = { proxyPort: 6 };
-  d._markSwitch(c, "A");
-  ok(
-    c._switchHistory instanceof Map && c._switchHistory.has("A"),
-    "T7 _markSwitch 惰性初始化并记录",
-  );
-  const t1 = c._switchHistory.get("A");
-  d._markSwitch(c, "A");
-  ok(c._switchHistory.get("A") >= t1, "T8 _markSwitch 重复记录更新时间戳");
-}
-
-// T9 时间戳相同时稳定排序（V8 sort 稳定，保持原相对序）
-{
-  const c = { proxyPort: 7 };
-  c._switchHistory = new Map([
-    ["A", T0 - 100],
-    ["B", T0 - 100],
-  ]);
-  const r = d._sortCandidates(nodes, c);
-  ok(r.join() === "C,D,A,B", "T9 相同时间戳保持原相对序（稳定排序）", r.join());
-}
-
-// T10 壳页判定：200 + 无跳转 + 无 error + 无 title → 壳页
-ok(
-  d._isShellPage({ error: null, httpCode: 200, numRedirects: 0, title: "" }) ===
-    true,
-  "T10 壳页判定：200+无title → true",
-);
-// T11 健康页（有 title）→ 非壳页
-ok(
-  d._isShellPage({
-    error: null,
-    httpCode: 200,
-    numRedirects: 0,
-    title: "TikTok - Make Your Day",
-  }) === false,
-  "T11 健康页有 title → false",
-);
-// T12 连接错误 → 非壳页
-ok(
-  d._isShellPage({
-    error: "timeout",
-    httpCode: 0,
-    numRedirects: 0,
-    title: "",
-  }) === false,
-  "T12 连接错误 → false",
-);
-// T13 跳转 → 非壳页
-ok(
-  d._isShellPage({ error: null, httpCode: 200, numRedirects: 1, title: "" }) ===
-    false,
-  "T13 跳转 → false",
-);
-// T14 非 200 → 非壳页
-ok(
-  d._isShellPage({ error: null, httpCode: 403, numRedirects: 0, title: "" }) ===
-    false,
-  "T14 非 200 → false",
-);
-
-console.log(`\n结果: ${pass} 通过 / ${fail} 失败`);
-process.exit(fail ? 1 : 0);