@lancewu602/mihomo-dash 0.0.0-stage → 0.6.1

package/server/tests/kernel.test.js

@@ -0,0 +1,250 @@
+/**
+ * 内核安装 / 升级 / 卸载（server/src/shared/kernel-*.js 与 CLI 入口）测试。
+ *
+ * 不碰真实内核、不碰网络：安装包是测试自己用 gzip 包出来的「假 mihomo」——一个 `-v` 会打印
+ * `Mihomo Meta <版本> ...` 的可执行脚本。这样能把「解包 → sha256 校验 → 试跑 → 备份替换 → 台账
+ * → 卸载」整条链路走通。面板不下载二进制（2026-11 起），所以这里没有桩 HTTP 服务。
+ * 运行：npm test
+ */
+// 单测要快：把内核起停的等待间隔调到 20ms（默认 300 / 200，生产行为不变）
+process.env.MIHOMO_DASH_READY_INTERVAL_MS ??= '20';
+process.env.MIHOMO_DASH_STOP_INTERVAL_MS ??= '20';
+
+import assert from 'node:assert/strict';
+import { after, before, test } from 'node:test';
+import { spawnSync } from 'node:child_process';
+import { randomBytes } from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { gzipSync } from 'node:zlib';
+
+const BIN = path.resolve(import.meta.dirname, '../../bin/mihomo-dash.js');
+/**
+ * 假内核：只有 `-v` 会输出一行版本，其余什么都不做（shell 脚本够用，Windows 上会跳过相关断言）。
+ * 中间塞几行随机十六进制注释：面板会拒「小于 1 KB」的安装包（像被截断的文件），
+ * 而这么短的脚本 gzip 完只有几十字节，靠随机内容把包撑过那条线。
+ */
+const fakeMihomo = (version) =>
+  `#!/bin/sh\n${Array.from({ length: 8 }, () => `# ${randomBytes(128).toString('hex')}`).join('\n')}\n` +
+  `if [ "$1" = "-v" ]; then echo "Mihomo Meta ${version} lin fake"; fi\n`;
+
+/** @type {string} */ let tmpDir;
+/** @type {string} */ let cliDir;
+/** @type {string} */ let cfgDir;
+/** @type {string} */ let workDir;
+/** @type {Record<string, any>} */ let mods = {};
+const posix = process.platform !== 'win32';
+
+before(async () => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mihomo-dash-kernel-'));
+  cliDir = path.join(tmpDir, 'cli');
+  cfgDir = path.join(tmpDir, 'mihomo');
+  workDir = path.join(tmpDir, 'work');
+  for (const d of [cliDir, cfgDir, workDir]) fs.mkdirSync(d, { recursive: true });
+  fs.writeFileSync(
+    path.join(cfgDir, 'config.yaml'),
+    'mixed-port: 17890\nexternal-controller: 127.0.0.1:18980\n',
+  );
+
+  // 这几个模块在加载时就读 CLI_DIR，必须先设好环境变量再 import
+  process.env.MIHOMO_DASH_DIR = cliDir;
+  process.env.MIHOMO_DIR = cfgDir;
+  mods = {
+    binary: await import('../src/kernel/binary.js'),
+    archive: await import('../src/kernel/archive.js'),
+    install: await import('../src/kernel/install.js'),
+  };
+});
+
+after(() => {
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+
+/** 造一个真·gzip 安装包（内容是一个假内核），返回文件路径 */
+function writePkg(name, version) {
+  const file = path.join(workDir, name);
+  fs.writeFileSync(file, gzipSync(Buffer.from(fakeMihomo(version))));
+  return file;
+}
+
+test('assetTarget：按平台/架构给出去 release 页面该拿哪个资产（纯字符串，不联网）', () => {
+  const { assetTarget, archiveExt } = mods.archive;
+  const at = (platform, arch) => assetTarget(platform, arch);
+  assert.equal(at('darwin', 'arm64'), 'darwin-arm64');
+  assert.equal(at('darwin', 'x64'), 'darwin-amd64-compatible');
+  assert.equal(at('linux', 'x64'), 'linux-amd64');
+  assert.equal(at('linux', 'arm64'), 'linux-arm64');
+  assert.equal(at('linux', 'arm'), 'linux-armv7');
+  assert.equal(at('win32', 'x64'), 'windows-amd64');
+  assert.equal(at('win32', 'arm64'), 'windows-arm64');
+  // 没有官方构建的平台/架构 → null（页面退回通用文案）
+  assert.equal(at('linux', 'mips'), null);
+  assert.equal(at('freebsd', 'x64'), null);
+  // 扩展名：只有 Windows 是 zip
+  assert.equal(archiveExt('darwin'), 'gz');
+  assert.equal(archiveExt('linux'), 'gz');
+  assert.equal(archiveExt('win32'), 'zip');
+});
+
+test('assertBinaryArchive：发行版安装包 / 其它格式一律拒，二进制压缩包才放行', () => {
+  const { assertBinaryArchive } = mods.archive;
+  for (const name of [
+    'mihomo-linux-amd64-v1.19.32.gz',
+    'mihomo-darwin-arm64-v1.19.32.gz',
+    'mihomo-windows-amd64-v1.19.32.zip',
+  ]) {
+    assert.equal(assertBinaryArchive(name), name);
+  }
+  for (const name of [
+    'mihomo-linux-amd64-v1.19.32.deb',
+    'mihomo-linux-amd64-v1.19.32.rpm',
+    'mihomo-linux-amd64-v1.19.32.pkg.tar.zst',
+    'mihomo-linux-arm64-v1.19.32.apk',
+    'mihomo-darwin-arm64-v1.19.32',
+  ]) {
+    assert.throws(() => assertBinaryArchive(name), /只支持二进制压缩包/);
+  }
+});
+
+test('bareVersion：去掉 v 前缀', () => {
+  const { bareVersion } = mods.binary;
+  assert.equal(bareVersion('v1.19.32'), '1.19.32');
+  assert.equal(bareVersion('1.19.32'), '1.19.32');
+  assert.equal(bareVersion(''), '');
+});
+
+test('安装：解包 → 试跑 → 落盘 + 台账；再装一版会留备份', async (t) => {
+  if (!posix) return t.skip('假内核是 shell 脚本，Windows 上跑不了');
+  const { performInstall, readLedger, currentInstall } = mods.install;
+  const { readKernelVersion } = mods.binary;
+  const target = path.join(workDir, 'bin', 'mihomo');
+
+  const first = await performInstall({
+    localFile: writePkg('pkg-1.19.32.gz', '1.19.32'),
+    ext: 'gz',
+    asset: 'mihomo-fake-v1.19.32.gz',
+    target,
+  });
+  assert.equal(first.version, '1.19.32');
+  assert.equal(first.sha256.length, 64);
+  assert.equal(first.source, 'upload');
+  assert.ok(fs.existsSync(target));
+  assert.equal(fs.statSync(target).mode & 0o111, 0o111, '得是可执行的');
+  assert.equal(await readKernelVersion(target), '1.19.32');
+  assert.equal(currentInstall(target).version, '1.19.32');
+  assert.equal(currentInstall(target).asset, 'mihomo-fake-v1.19.32.gz');
+
+  const second = await performInstall({
+    localFile: writePkg('pkg-1.19.33.gz', '1.19.33'),
+    ext: 'gz',
+    asset: 'mihomo-fake-v1.19.33.gz',
+    target,
+  });
+  assert.equal(second.version, '1.19.33');
+  assert.ok(second.backup.endsWith('mihomo.bak-1.19.32'), `备份名：${second.backup}`);
+  assert.ok(fs.existsSync(second.backup));
+  assert.equal(readLedger().installed.length, 2);
+});
+
+test('sha256 对不上就报错，且现有文件与临时文件都不受影响', async (t) => {
+  if (!posix) return t.skip('假内核是 shell 脚本，Windows 上跑不了');
+  const { performInstall } = mods.install;
+  const { readKernelVersion } = mods.binary;
+  const dir = path.join(workDir, 'bin-sha');
+  const target = path.join(dir, 'mihomo');
+
+  await performInstall({
+    localFile: writePkg('sha-1.19.32.gz', '1.19.32'),
+    ext: 'gz',
+    asset: 'mihomo-fake-v1.19.32.gz',
+    target,
+  });
+  await assert.rejects(
+    () =>
+      performInstall({
+        localFile: writePkg('sha-1.19.33.gz', '1.19.33'),
+        ext: 'gz',
+        asset: 'mihomo-fake-v1.19.33.gz',
+        target,
+        sha256: 'deadbeef',
+      }),
+    /sha256 不匹配/,
+  );
+  assert.equal(await readKernelVersion(target), '1.19.32');
+  assert.deepEqual(
+    fs.readdirSync(dir).filter((f) => f.startsWith('.')),
+    [],
+    '解包/暂存的临时文件要清干净',
+  );
+});
+
+test('安装包里不是 mihomo（`-v` 没输出）：拒绝替换，落点保持原样', async (t) => {
+  if (!posix) return t.skip('假内核是 shell 脚本，Windows 上跑不了');
+  const { performInstall } = mods.install;
+  const target = path.join(workDir, 'bin-junk', 'mihomo');
+  const junk = path.join(workDir, 'junk.gz');
+  fs.writeFileSync(junk, gzipSync(Buffer.from('#!/bin/sh\necho 我不是 mihomo\n')));
+
+  await assert.rejects(
+    () => performInstall({ localFile: junk, ext: 'gz', asset: 'junk.gz', target }),
+    /跑不起来/,
+  );
+  assert.equal(fs.existsSync(target), false);
+  assert.equal(mods.install.currentInstall(target), null);
+});
+
+test('卸载：只删面板装的文件，别人的东西留着', async (t) => {
+  if (!posix) return t.skip('假内核是 shell 脚本，Windows 上跑不了');
+  const { performInstall, removeInstalled, readLedger } = mods.install;
+  const dir = path.join(workDir, 'bin-uninstall');
+  const target = path.join(dir, 'mihomo');
+
+  for (const version of ['1.19.32', '1.19.33']) {
+    await performInstall({
+      localFile: writePkg(`uninstall-${version}.gz`, version),
+      ext: 'gz',
+      asset: `mihomo-fake-v${version}.gz`,
+      target,
+    });
+  }
+  const keep = path.join(dir, '别人的文件');
+  fs.writeFileSync(keep, 'keep');
+
+  const removed = removeInstalled(target);
+  assert.ok(removed.includes(target));
+  assert.ok(removed.some((f) => f.includes('.bak-1.19.32')));
+  assert.ok(!fs.existsSync(target));
+  assert.ok(fs.existsSync(keep), '同目录下别的文件不能删');
+  assert.equal(readLedger().installed.length, 0);
+});
+
+test('CLI：kernel 子命令已下线（指向面板），proxy 只是普通未知命令，顶层 --version 仍是查包版本', (t) => {
+  if (!posix) return t.skip('假内核是 shell 脚本，Windows 上跑不了');
+  const env = { ...process.env, MIHOMO_DASH_DIR: cliDir, MIHOMO_DIR: cfgDir };
+  const gone = spawnSync(process.execPath, [BIN, 'kernel', 'info'], { encoding: 'utf8', env });
+  assert.equal(gone.status, 2);
+  assert.match(gone.stderr, /内核的装 \/ 升 \/ 卸改到面板的「内核」页，进程启停改到侧栏底部/);
+
+  // proxy 已删除，但不再特殊提示：与其它拼错的子命令一样报「未知命令」
+  const proxyGone = spawnSync(process.execPath, [BIN, 'proxy', 'status'], {
+    encoding: 'utf8',
+    env,
+  });
+  assert.equal(proxyGone.status, 2);
+  assert.match(proxyGone.stderr, /未知命令: proxy/);
+  assert.doesNotMatch(proxyGone.stderr, /子命令已移除/);
+
+  // 帮助里不再提 kernel / proxy 子命令，而是指到面板
+  const help = spawnSync(process.execPath, [BIN, '--help'], { encoding: 'utf8', env });
+  assert.equal(help.status, 0);
+  assert.doesNotMatch(help.stdout, /mihomo-dash kernel/);
+  assert.doesNotMatch(help.stdout, /proxy <子命令>/);
+  assert.match(help.stdout, /面板的「内核」页/);
+  assert.match(help.stdout, /系统代理开关也不在 CLI/);
+
+  // 顶层 --version 仍然是「查包版本」
+  const pkg = spawnSync(process.execPath, [BIN, '--version'], { encoding: 'utf8', env });
+  assert.equal(pkg.status, 0);
+  assert.match(pkg.stdout, /^mihomo-dash \d+\.\d+\.\d+/);
+});

package/server/tests/log-file.test.js

@@ -0,0 +1,110 @@
+/**
+ * 日志尾部读取 / 轮转（server/src/shared/log-file.js）与原子写（server/src/shared/atomic-file.js）测试。
+ *
+ * 两件事都跟「长期跑的面板不把事件循环按住 / 不把用户配置写坏」有关：
+ * 日志按块从文件末尾读（而不是 readFileSync 整份），配置走 tmp → rename（而不是直接覆盖）。
+ * 运行：npm test
+ */
+import assert from 'node:assert/strict';
+import { after, before, test } from 'node:test';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { readTailLines, rotateLogFile } from '../src/shared/log-file.js';
+import { writeFileAtomic } from '../src/shared/atomic-file.js';
+
+/** @type {string} */ let dir;
+before(() => {
+  dir = fs.mkdtempSync(path.join(os.tmpdir(), 'mihomo-dash-logfile-'));
+});
+after(() => fs.rmSync(dir, { recursive: true, force: true }));
+
+const write = (name, text) => {
+  const p = path.join(dir, name);
+  fs.writeFileSync(p, text);
+  return p;
+};
+
+test('尾读：文件比要的行数少 → 全给；结尾有换行也不能多出空行', () => {
+  const f = write('small.log', 'a\nb\nc\n');
+  assert.deepEqual(readTailLines(f, { lines: 10 }), {
+    lines: ['a', 'b', 'c'],
+    missing: false,
+    truncated: false,
+  });
+});
+
+test('尾读：按行切，不因为缺结尾换行就吞掉最后一行', () => {
+  const f = write('no-nl.log', 'x1\nx2\nx3');
+  assert.deepEqual(readTailLines(f, { lines: 2 }).lines, ['x2', 'x3']);
+});
+
+test('尾读：大文件只读尾部，结果与「整份读再切」一致（含多字节字符跨块边界）', () => {
+  const all = Array.from({ length: 200000 }, (_, i) => `${i} 中文行 abcdefghijklmnopqrstuvwxyz`);
+  const f = write('big.log', `${all.join('\n')}\n`);
+  const got = readTailLines(f, { lines: 400 });
+  assert.equal(got.lines.length, 400);
+  assert.deepEqual(got.lines, all.slice(-400));
+  assert.equal(got.truncated, true, '没读到文件头就该标成 truncated');
+
+  // 行数要求超过 maxBytes 允许的范围：最多给 maxBytes 里的完整行，不能越界读
+  const capped = readTailLines(f, { lines: 100000, maxBytes: 64 * 1024 });
+  assert.ok(capped.lines.length > 0 && capped.lines.length < 100000);
+  assert.deepEqual(capped.lines, all.slice(-capped.lines.length));
+});
+
+test('尾读：文件不存在 → missing；空文件 → 空数组', () => {
+  assert.deepEqual(readTailLines(path.join(dir, 'nope.log')), {
+    lines: [],
+    missing: true,
+    truncated: false,
+  });
+  assert.deepEqual(readTailLines(write('empty.log', ''), { lines: 5 }), {
+    lines: [],
+    missing: false,
+    truncated: false,
+  });
+});
+
+test('轮转：超过上限改名成 <file>.1（覆盖旧的那份）；没超过 / 不存在都不动', () => {
+  const f = write('rotate.log', 'x'.repeat(2 * 1024 * 1024));
+  assert.equal(rotateLogFile(f, 1024 * 1024), `${f}.1`);
+  assert.equal(fs.existsSync(f), false, '原文件已被移走');
+  assert.equal(fs.statSync(`${f}.1`).size, 2 * 1024 * 1024);
+
+  // 再来一次：旧的 .1 被覆盖，不会堆成 .2 / .3
+  write('rotate.log', 'y'.repeat(2 * 1024 * 1024));
+  assert.equal(rotateLogFile(f, 1024 * 1024), `${f}.1`);
+  assert.deepEqual(
+    fs.readdirSync(dir).filter((n) => n.startsWith('rotate.log')),
+    ['rotate.log.1'],
+  );
+
+  write('keep.log', 'small');
+  assert.equal(rotateLogFile(path.join(dir, 'keep.log'), 1024 * 1024), null);
+  assert.equal(fs.readFileSync(path.join(dir, 'keep.log'), 'utf8'), 'small');
+  assert.equal(rotateLogFile(path.join(dir, 'missing.log')), null);
+});
+
+test('原子写：内容整份替换、权限沿用原文件、不留临时文件', () => {
+  const f = path.join(dir, 'config.yaml');
+  writeFileAtomic(f, 'a: 1\n');
+  fs.chmodSync(f, 0o600);
+  writeFileAtomic(f, 'a: 2\nb: 3\n');
+  assert.equal(fs.readFileSync(f, 'utf8'), 'a: 2\nb: 3\n');
+  assert.equal(fs.statSync(f).mode & 0o777, 0o600, '原文件权限要保留');
+  assert.deepEqual(
+    fs.readdirSync(dir).filter((n) => n.startsWith('.')),
+    [],
+    '临时文件不能留在目录里',
+  );
+});
+
+test('原子写：写不进去时抛错，且不留下临时文件', () => {
+  const target = path.join(dir, 'no-such-dir', 'config.yaml');
+  assert.throws(() => writeFileAtomic(target, 'a: 1\n'), /ENOENT/);
+  assert.deepEqual(
+    fs.readdirSync(dir).filter((n) => n.startsWith('.')),
+    [],
+  );
+});

package/server/tests/providers.test.js

@@ -0,0 +1,259 @@
+/**
+ * 订阅增删（server/src/http/providers.js）集成测试。
+ * 用桩 HTTP 服务替代内核（只响应 PUT /configs），验证：文本改写保留注释、
+ * 内核重载失败时报错、删除订阅时清理本地缓存文件。运行：npm test
+ */
+import assert from 'node:assert/strict';
+import { after, before, beforeEach, test } from 'node:test';
+import fs from 'node:fs';
+import http from 'node:http';
+import os from 'node:os';
+import path from 'node:path';
+import yaml from 'js-yaml';
+
+const BASE_CONFIG = `# Document: https://wiki.metacubex.one/config/
+mixed-port: 7890
+mode: rule
+
+proxy-providers:
+  airport:
+    type: http
+    url: "https://example.com/link/aaa"
+    interval: 3600
+    path: ./providers/airport.yaml
+
+proxy-groups:
+  - name: 节点选择
+    type: select
+    proxies: [自动选择]
+    use: [airport]
+  # 组注释
+
+rules:
+  - MATCH,节点选择
+`;
+
+/** @type {string} */ let tmpDir;
+/** @type {string} */ let cfgDir;
+/** @type {string} */ let cliDir;
+/** @type {import('node:http').Server} */ let server;
+/** @type {boolean} */ let kernelDown = false;
+/** @type {typeof import('../src/http/providers.js')} */ let providers;
+
+const configPath = () => path.join(cfgDir, 'config.yaml');
+const readConfig = () => fs.readFileSync(configPath(), 'utf8');
+/** 代码只认 config.yaml 的 external-controller（环境变量覆盖已去掉），桩内核地址必须写进配置 */
+let stubPort = 0;
+const withKernel = (text) =>
+  `${text}${text.endsWith('\n') ? '' : '\n'}external-controller: 127.0.0.1:${stubPort}\n`;
+const writeConfig = (text) => fs.writeFileSync(configPath(), withKernel(text));
+const parseConfig = () => yaml.load(readConfig());
+const cacheFile = (name) => path.join(cfgDir, 'providers', `${name}.yaml`);
+
+before(async () => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mihomo-dash-'));
+  cfgDir = path.join(tmpDir, 'mihomo');
+  cliDir = path.join(tmpDir, 'cli');
+  fs.mkdirSync(path.join(cfgDir, 'providers'), { recursive: true });
+
+  server = http.createServer((_req, res) => {
+    res.writeHead(kernelDown ? 500 : 200, { 'content-type': 'application/json' });
+    res.end(kernelDown ? JSON.stringify({ message: 'mock reload failure' }) : '{}');
+  });
+  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+
+  // 必须在 import 之前注入环境变量：paths.js / kernel.js 在模块加载时读取
+  process.env.MIHOMO_DIR = cfgDir;
+  process.env.MIHOMO_DASH_DIR = cliDir;
+  stubPort = server.address().port;
+  providers = await import('../src/http/providers.js');
+});
+
+after(() => {
+  server?.close();
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+
+beforeEach(() => {
+  kernelDown = false;
+  writeConfig(BASE_CONFIG);
+  for (const f of fs.readdirSync(path.join(cfgDir, 'providers'))) {
+    fs.rmSync(path.join(cfgDir, 'providers', f), { force: true });
+  }
+  fs.writeFileSync(cacheFile('airport'), 'proxies: []\n');
+});
+
+test('新增订阅：写入条目、保留注释与其余段落', async () => {
+  const r = await providers.addProvider({
+    name: 'airport2',
+    url: 'https://example.com/link/bbb',
+  });
+
+  assert.equal(r.name, 'airport2');
+  assert.equal(r.path, 'providers/airport2.yaml');
+
+  const text = readConfig();
+  assert.match(text, /# Document: https:\/\/wiki\.metacubex\.one/);
+  assert.match(text, /# 组注释/);
+
+  const doc = parseConfig();
+  assert.deepEqual(
+    doc['proxy-providers'].airport,
+    yaml.load(BASE_CONFIG)['proxy-providers'].airport,
+  );
+  assert.deepEqual(doc['proxy-providers'].airport2, {
+    type: 'http',
+    url: 'https://example.com/link/bbb',
+    interval: 3600,
+    path: './providers/airport2.yaml',
+    'health-check': {
+      enable: true,
+      interval: 300,
+      url: 'https://www.gstatic.com/generate_204',
+    },
+  });
+  assert.deepEqual(doc['proxy-groups'], yaml.load(BASE_CONFIG)['proxy-groups']);
+  assert.deepEqual(doc.rules, yaml.load(BASE_CONFIG).rules);
+});
+
+test('新增订阅：无 proxy-providers 段时自动创建', async () => {
+  writeConfig(`mixed-port: 7891\nproxy-groups:\n  - name: 直连\n`);
+  await providers.addProvider({ name: 'sub', url: 'https://example.com/link/ccc', interval: 1800 });
+
+  const doc = parseConfig();
+  assert.equal(doc['proxy-providers'].sub.interval, 1800);
+  assert.equal(doc['mixed-port'], 7891);
+});
+
+test('新增订阅：重名 / 非法链接 / 缓存文件已存在时拒绝', async () => {
+  await assert.rejects(
+    () => providers.addProvider({ name: 'airport', url: 'https://a.com/x' }),
+    /已存在/,
+  );
+  await assert.rejects(
+    () => providers.addProvider({ name: 'x', url: 'ftp://a.com/x' }),
+    /http\(s\)/,
+  );
+  await assert.rejects(
+    () => providers.addProvider({ name: '', url: 'https://a.com/x' }),
+    /不能为空/,
+  );
+  await assert.rejects(
+    () => providers.addProvider({ name: 'a:b', url: 'https://a.com/x' }),
+    /不能包含/,
+  );
+
+  fs.writeFileSync(cacheFile('ghost'), 'proxies: []\n');
+  await assert.rejects(
+    () => providers.addProvider({ name: 'ghost', url: 'https://a.com/x' }),
+    /已存在/,
+  );
+});
+
+test('新增订阅：内核热重载失败时报错，config.yaml 停在新内容', async () => {
+  kernelDown = true;
+  await assert.rejects(
+    () => providers.addProvider({ name: 'broken', url: 'https://example.com/link/ddd' }),
+    /热重载失败/,
+  );
+  kernelDown = false;
+  assert.match(readConfig(), /broken/); // 写盘已完成，失败只发生在内核重载这一步
+});
+
+test('新增订阅：带「拉取用代理」时写入 proxy 字段（键序在 path 之后）', async () => {
+  await providers.addProvider({
+    name: 'proxied',
+    url: 'https://example.com/link/fff',
+    proxy: '自动选择',
+  });
+
+  const doc = parseConfig();
+  assert.equal(doc['proxy-providers'].proxied.proxy, '自动选择');
+  // 键序：path 紧跟 proxy，便于肉眼对照
+  const lines = readConfig().split('\n');
+  const pathAt = lines.findIndex((l) => l.trim().startsWith('path: ./providers/proxied.yaml'));
+  assert.match(lines[pathAt + 1], /^\s+proxy: 自动选择$/);
+
+  // 不填 proxy 时那个键压根不写（内核按直连拉取）
+  await providers.addProvider({ name: 'direct', url: 'https://example.com/link/ggg' });
+  assert.equal('proxy' in parseConfig()['proxy-providers'].direct, false);
+});
+
+test('改拉取用代理：插入 / 替换 / 删除都只动那一行，保留注释', async () => {
+  const set = providers.setProviderProxy;
+
+  await set('airport', '自动选择');
+  let doc = parseConfig();
+  assert.equal(doc['proxy-providers'].airport.proxy, '自动选择');
+  assert.equal(doc['proxy-providers'].airport.url, 'https://example.com/link/aaa');
+  assert.match(readConfig(), /# 组注释/);
+
+  // 再改一次：原地替换，不堆出第二行 proxy
+  await set('airport', 'DIRECT');
+  assert.equal(parseConfig()['proxy-providers'].airport.proxy, 'DIRECT');
+  assert.equal(readConfig().match(/^\s+proxy:/gm).length, 1);
+
+  // 空串 = 删掉该键，回退直连；条目其余字段不变
+  const r = await set('airport', '');
+  assert.equal(r.proxy, '');
+  doc = parseConfig();
+  assert.deepEqual(
+    doc['proxy-providers'].airport,
+    yaml.load(BASE_CONFIG)['proxy-providers'].airport,
+  );
+  assert.equal(readConfig().includes('proxy:'), false);
+});
+
+test('改拉取用代理：值没变就不写盘、不热重载', async () => {
+  const r = await providers.setProviderProxy('airport', '');
+  assert.equal(r.unchanged, true);
+  assert.equal(r.reloaded, false);
+});
+
+test('改拉取用代理：未知订阅 / 含冒号的名称报错', async () => {
+  await assert.rejects(() => providers.setProviderProxy('nope', '自动选择'), /未找到订阅/);
+  await assert.rejects(() => providers.setProviderProxy('airport', 'a:b'), /不能包含/);
+});
+
+test('删除订阅：移除条目与缓存文件、保留其他段落与注释', async () => {
+  const r = await providers.removeProvider('airport');
+
+  assert.equal(r.cache.removed, true);
+  assert.equal(r.cache.path, 'providers/airport.yaml');
+  assert.equal(fs.existsSync(cacheFile('airport')), false);
+
+  const doc = parseConfig();
+  assert.equal(doc['proxy-providers'], undefined); // 最后一个订阅被删，段头一并移除
+  assert.equal(readConfig().includes('proxy-providers'), false);
+  assert.match(readConfig(), /# 组注释/);
+  assert.deepEqual(doc['proxy-groups'], yaml.load(BASE_CONFIG)['proxy-groups']);
+});
+
+test('删除订阅：多订阅时仅删目标条目', async () => {
+  await providers.addProvider({ name: 'airport2', url: 'https://example.com/link/eee' });
+  fs.writeFileSync(cacheFile('airport2'), 'proxies: []\n');
+
+  await providers.removeProvider('airport2');
+
+  const doc = parseConfig();
+  assert.deepEqual(Object.keys(doc['proxy-providers']), ['airport']);
+  assert.match(readConfig(), /^proxy-providers:$/m);
+  assert.equal(fs.existsSync(cacheFile('airport2')), false);
+});
+
+test('删除订阅：keepCache 时保留缓存文件；未知名称报错', async () => {
+  await providers.removeProvider('airport', { deleteCache: false });
+  assert.equal(fs.existsSync(cacheFile('airport')), true);
+  await assert.rejects(() => providers.removeProvider('nope'), /未找到订阅/);
+});
+
+test('读取订阅列表：原样返回 config.yaml 中的 proxy-providers 条目', () => {
+  const list = providers.listProviders();
+  assert.deepEqual(list, yaml.load(BASE_CONFIG)['proxy-providers']);
+  assert.equal(list.airport.interval, 3600);
+});
+
+test('读取订阅列表：无 proxy-providers 段时返回空映射', () => {
+  writeConfig('mixed-port: 7891\n');
+  assert.deepEqual(providers.listProviders(), {});
+});