@lancewu602/mihomo-dash 0.0.0-stage → 0.6.1

package/server/tests/groups.test.js

@@ -0,0 +1,558 @@
+/**
+ * 策略组增删（server/src/http/groups.js）集成测试。
+ * 用桩 HTTP 服务替代内核（只响应 PUT /configs），验证：文本改写保留注释、
+ * 引用检查（rules / sub-rules / 其它组）、内核重载失败时报错。运行：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]
+  - name: 自动选择
+    type: url-test
+    use: [airport]
+    url: https://www.gstatic.com/generate_204
+    interval: 300
+    tolerance: 50
+  # 组注释
+  - name: 备用组
+    type: select
+    use: [airport]
+
+rules:
+  # 规则注释
+  - GEOSITE,gfw,自动选择
+  - 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;
+/** 桩内核收到的请求数（用于断言「纯写盘」的操作不触发内核请求） */
+let kernelCalls = 0;
+/** @type {typeof import('../src/http/groups.js')} */ let groups;
+
+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 resetConfig = (text = BASE_CONFIG) => writeConfig(text);
+
+before(async () => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mihomo-dash-groups-'));
+  cfgDir = path.join(tmpDir, 'mihomo');
+  cliDir = path.join(tmpDir, 'cli');
+  fs.mkdirSync(path.join(cfgDir, 'providers'), { recursive: true });
+
+  server = http.createServer((_req, res) => {
+    kernelCalls++;
+    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;
+  groups = await import('../src/http/groups.js');
+});
+
+after(() => {
+  server?.close();
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+
+beforeEach(() => {
+  kernelDown = false;
+  kernelCalls = 0;
+  resetConfig();
+});
+
+test('新增策略组：写入 select 组（use + proxies）并保留注释与其余段落', async () => {
+  const beforeDoc = parseConfig();
+  const r = await groups.addGroup({
+    name: '备用选择',
+    type: 'select',
+    use: ['airport'],
+    proxies: ['自动选择', '日本 中继-1(1.5x)'],
+  });
+
+  assert.equal(r.name, '备用选择');
+
+  const text = readConfig();
+  assert.match(text, /# Document: https:\/\/wiki\.metacubex\.one/);
+  assert.match(text, /# 组注释/);
+  assert.match(text, /# 规则注释/);
+  assert.match(text, /- name: 备用选择/);
+
+  const doc = parseConfig();
+  assert.deepEqual(doc['proxy-groups'].slice(0, 3), beforeDoc['proxy-groups']);
+  assert.deepEqual(doc['proxy-groups'][3], {
+    name: '备用选择',
+    type: 'select',
+    proxies: ['自动选择', '日本 中继-1(1.5x)'],
+    use: ['airport'],
+  });
+  assert.deepEqual(doc.rules, beforeDoc.rules);
+  assert.deepEqual(doc['proxy-providers'], beforeDoc['proxy-providers']);
+});
+
+test('新增策略组：url-test 默认 url/interval/tolerance，显式传值可覆盖', async () => {
+  await groups.addGroup({ name: '自动选择2', type: 'url-test', use: ['airport'] });
+  await groups.addGroup({
+    name: '自动选择3',
+    type: 'url-test',
+    use: ['airport'],
+    url: 'https://example.com/204',
+    interval: 120,
+    tolerance: 30,
+  });
+
+  const list = parseConfig()['proxy-groups'];
+  assert.deepEqual(
+    list.find((g) => g.name === '自动选择2'),
+    {
+      name: '自动选择2',
+      type: 'url-test',
+      use: ['airport'],
+      url: 'https://www.gstatic.com/generate_204',
+      interval: 300,
+      tolerance: 50,
+    },
+  );
+  assert.deepEqual(
+    list.find((g) => g.name === '自动选择3'),
+    {
+      name: '自动选择3',
+      type: 'url-test',
+      use: ['airport'],
+      url: 'https://example.com/204',
+      interval: 120,
+      tolerance: 30,
+    },
+  );
+});
+
+test('新增策略组：参数非法时拒绝且不改动配置', async () => {
+  const cases = [
+    [{ name: '节点选择', type: 'select', use: ['airport'] }, /已存在/],
+    [{ name: 'DIRECT', type: 'select', use: ['airport'] }, /保留名称/],
+    [{ name: 'x', type: 'fallback', use: ['airport'] }, /仅支持 select/],
+    [{ name: 'x', type: 'select' }, /至少选择一个/],
+    [{ name: 'x', type: 'select', proxies: [] }, /至少选择一个/],
+    [{ name: 'x', type: 'url-test', use: ['airport'], url: 'ftp://a' }, /http\(s\)/],
+    [{ name: 'x', type: 'select', proxies: ['x'] }, /不能引用自己/],
+    [{ name: '', type: 'select', use: ['airport'] }, /不能为空/],
+    [{ name: 'a:b', type: 'select', use: ['airport'] }, /不能包含/],
+  ];
+  for (const [input, re] of cases) {
+    await assert.rejects(() => groups.addGroup(input), re);
+    assert.equal(readConfig(), withKernel(BASE_CONFIG), `配置被意外改动: ${JSON.stringify(input)}`);
+  }
+});
+
+test('新增策略组：无 proxy-groups 段时自动创建；空流式写法可追加', async () => {
+  resetConfig('mixed-port: 7891\nrules:\n  - MATCH,DIRECT\n');
+  await groups.addGroup({ name: '新组', type: 'select', use: ['airport'] });
+  assert.deepEqual(parseConfig()['proxy-groups'], [
+    { name: '新组', type: 'select', use: ['airport'] },
+  ]);
+  assert.equal(parseConfig()['mixed-port'], 7891);
+
+  resetConfig('proxy-groups: []\nrules:\n  - MATCH,DIRECT\n');
+  await groups.addGroup({ name: '新组', type: 'select', use: ['airport'] });
+  const doc = parseConfig();
+  assert.deepEqual(doc['proxy-groups'], [{ name: '新组', type: 'select', use: ['airport'] }]);
+  assert.match(readConfig(), /proxy-groups:\n {2}- name: 新组/);
+});
+
+test('删除策略组：被规则引用时拒绝，并列出引用位置', async () => {
+  await assert.rejects(
+    () => groups.removeGroup('自动选择'),
+    (e) => {
+      assert.match(e.message, /仍被引用/);
+      assert.match(e.message, /rules: GEOSITE,gfw,自动选择/);
+      assert.match(e.message, /策略组「节点选择」的 proxies/);
+      assert.deepEqual(e.refs, ['策略组「节点选择」的 proxies', 'rules: GEOSITE,gfw,自动选择']);
+      return true;
+    },
+  );
+  assert.equal(readConfig(), withKernel(BASE_CONFIG));
+});
+
+test('删除策略组：被 sub-rules 引用时拒绝', async () => {
+  resetConfig(`${BASE_CONFIG}\nsub-rules:\n  广告:\n    - DOMAIN-SUFFIX,ads.com,备用组\n`);
+  await assert.rejects(
+    () => groups.removeGroup('备用组'),
+    (e) => {
+      assert.match(e.message, /sub-rules「广告」/);
+      assert.deepEqual(e.refs, ['sub-rules「广告」: DOMAIN-SUFFIX,ads.com,备用组']);
+      return true;
+    },
+  );
+});
+
+test('删除策略组：无引用时移除条目，保留注释与其它组', async () => {
+  const beforeDoc = parseConfig();
+  const r = await groups.removeGroup('备用组');
+  assert.equal(r.name, '备用组');
+
+  const text = readConfig();
+  assert.match(text, /# 组注释/);
+  assert.match(text, /# 规则注释/);
+  assert.doesNotMatch(text, /备用组/);
+
+  const doc = parseConfig();
+  assert.deepEqual(doc['proxy-groups'], beforeDoc['proxy-groups'].slice(0, 2));
+  assert.deepEqual(doc.rules, beforeDoc.rules);
+  // 删除后相邻条目之间不应留下空行
+  assert.doesNotMatch(text, /tolerance: 50\n\s*\n/);
+  assert.match(text, /- name: 自动选择\n(.*\n)*?\s+interval: 300\n\s+tolerance: 50\n/);
+});
+
+test('删除策略组：最后一个组时连同段落一起移除；未知名称报错', async () => {
+  resetConfig(
+    'proxy-groups:\n  - name: 唯一组\n    type: select\n    use: [airport]\nrules:\n  - MATCH,DIRECT\n',
+  );
+  await groups.removeGroup('唯一组');
+  const doc = parseConfig();
+  assert.equal(doc['proxy-groups'], undefined);
+  assert.deepEqual(doc.rules, ['MATCH,DIRECT']);
+  assert.match(readConfig(), /rules:\n {2}- MATCH,DIRECT/);
+
+  await assert.rejects(() => groups.removeGroup('不存在'), /未找到策略组/);
+});
+
+test('删除策略组：新增后即可删除（回归：删除范围的边界）', async () => {
+  await groups.addGroup({ name: '临时组', type: 'select', proxies: ['自动选择'] });
+  await groups.removeGroup('临时组');
+  const doc = parseConfig();
+  assert.equal(
+    doc['proxy-groups'].some((g) => g.name === '临时组'),
+    false,
+  );
+  assert.equal(doc['proxy-groups'].length, 3);
+  assert.match(readConfig(), /# 组注释/);
+});
+
+test('内核热重载失败时报错，config.yaml 停在新内容（新增与删除都一样）', async () => {
+  kernelDown = true;
+  await assert.rejects(
+    () => groups.addGroup({ name: '新组', type: 'select', use: ['airport'] }),
+    /热重载失败/,
+  );
+  assert.match(readConfig(), /name: 新组/);
+
+  await assert.rejects(() => groups.removeGroup('备用组'), /热重载失败/);
+  assert.doesNotMatch(readConfig(), /name: 备用组/);
+  kernelDown = false;
+});
+
+test('读取策略组：返回 config.yaml 中的原始条目（含 use / proxies）', () => {
+  assert.deepEqual(groups.getGroup('节点选择'), {
+    name: '节点选择',
+    type: 'select',
+    proxies: ['自动选择'],
+    use: ['airport'],
+  });
+  assert.throws(() => groups.getGroup('不存在'), /未找到策略组/);
+});
+
+test('读取策略组列表：原样返回全部条目（含 interval / tolerance）', () => {
+  const list = groups.listGroups();
+  assert.deepEqual(list, yaml.load(BASE_CONFIG)['proxy-groups']);
+  const auto = list.find((g) => g.name === '自动选择');
+  assert.equal(auto.interval, 300);
+  assert.equal(auto.tolerance, 50);
+});
+
+test('读取策略组列表：无 proxy-groups 段时返回空数组', () => {
+  resetConfig('mixed-port: 7891\n');
+  assert.deepEqual(groups.listGroups(), []);
+});
+
+test('编辑策略组：就地替换条目、保留注释与其它组', async () => {
+  const beforeDoc = parseConfig();
+  const r = await groups.updateGroup('节点选择', {
+    type: 'url-test',
+    use: ['airport'],
+    url: 'https://example.com/204',
+    interval: 120,
+    tolerance: 20,
+  });
+  assert.equal(r.name, '节点选择');
+
+  const text = readConfig();
+  assert.match(text, /# Document: https:\/\/wiki\.metacubex\.one/);
+  assert.match(text, /# 组注释/);
+  assert.match(text, /# 规则注释/);
+  assert.doesNotMatch(text, /- name: 节点选择\n {4}type: select/);
+
+  const doc = parseConfig();
+  assert.deepEqual(doc['proxy-groups'][0], {
+    name: '节点选择',
+    type: 'url-test',
+    use: ['airport'],
+    url: 'https://example.com/204',
+    interval: 120,
+    tolerance: 20,
+  });
+  assert.deepEqual(doc['proxy-groups'].slice(1), beforeDoc['proxy-groups'].slice(1));
+  assert.deepEqual(doc.rules, beforeDoc.rules);
+  assert.match(text, /# 组注释\n {2}- name: 备用组/);
+});
+
+test('编辑 / 删除策略组：不吞掉条目后的注释（回归）', async () => {
+  // 自动选择 后面紧跟 `# 组注释` + 备用组；替换时注释必须保留
+  await groups.updateGroup('自动选择', { type: 'select', use: ['airport'] });
+  let text = readConfig();
+  assert.match(text, /# 组注释\n {2}- name: 备用组/);
+  assert.doesNotMatch(text, /- name: 自动选择\n {4}type: url-test/);
+
+  // 删除 自动选择 时同样保留注释
+  await groups.removeGroup('备用组');
+  text = readConfig();
+  assert.match(text, /# 组注释/);
+  assert.doesNotMatch(text, /备用组/);
+});
+
+test('编辑策略组：select 组不带测速字段；参数非法时拒绝且不改动配置', async () => {
+  await groups.updateGroup('自动选择', { type: 'select', proxies: ['备用组'] });
+  const entry = parseConfig()['proxy-groups'].find((g) => g.name === '自动选择');
+  assert.deepEqual(entry, { name: '自动选择', type: 'select', proxies: ['备用组'] });
+
+  const cases = [
+    [{ type: 'fallback', use: ['airport'] }, /仅支持 select/],
+    [{ type: 'select' }, /至少选择一个/],
+    [{ type: 'select', proxies: ['自动选择'] }, /不能引用自己/],
+    [{ type: 'url-test', use: ['airport'], url: 'ftp://x' }, /http\(s\)/],
+  ];
+  for (const [input, re] of cases) {
+    await assert.rejects(() => groups.updateGroup('自动选择', input), re);
+    assert.deepEqual(
+      parseConfig()['proxy-groups'].find((g) => g.name === '自动选择'),
+      { name: '自动选择', type: 'select', proxies: ['备用组'] },
+      `配置被意外改动: ${JSON.stringify(input)}`,
+    );
+  }
+
+  // 不改名：用另一个名字编辑应报「未找到」
+  await assert.rejects(() => groups.updateGroup('改了名', { type: 'select', use: ['airport'] }));
+});
+
+test('编辑策略组：内核热重载失败时报错，config.yaml 停在新内容', async () => {
+  kernelDown = true;
+  await assert.rejects(
+    () => groups.updateGroup('自动选择', { type: 'select', proxies: ['备用组'] }),
+    /热重载失败/,
+  );
+  kernelDown = false;
+  assert.notEqual(readConfig(), BASE_CONFIG);
+});
+
+test('落盘当前节点：写入 default-selected（保留注释、其他段落不变、不请求内核）', async () => {
+  const beforeDoc = parseConfig();
+  const r = await groups.setDefaultSelected({ 节点选择: '日本 中继-1(1.5x)' });
+
+  assert.deepEqual(r.applied, ['节点选择']);
+  assert.deepEqual(r.cleared, []);
+  assert.equal(
+    kernelCalls,
+    0,
+    '写 default-selected 不应触发内核请求（运行时已由 PUT /proxies 生效）',
+  );
+
+  const text = readConfig();
+  assert.match(text, /# Document: https:\/\/wiki\.metacubex\.one/);
+  assert.match(text, /# 组注释/);
+  assert.match(text, /# 规则注释/);
+  // 节点名含空格与括号：写入时加双引号，且落在该组块内（缩进 4）
+  assert.match(
+    text,
+    /\n {2}- name: 节点选择\n(?:.*\n)*? {4}default-selected: "日本 中继-1\(1\.5x\)"\n/,
+  );
+
+  const doc = parseConfig();
+  assert.equal(doc['proxy-groups'][0]['default-selected'], '日本 中继-1(1.5x)');
+  assert.deepEqual(doc['proxy-groups'].slice(1), beforeDoc['proxy-groups'].slice(1));
+  assert.deepEqual(doc.rules, beforeDoc.rules);
+  assert.deepEqual(doc['proxy-providers'], beforeDoc['proxy-providers']);
+});
+
+test('落盘当前节点：覆盖已有值 + 多组一次写入只写盘一次', async () => {
+  await groups.setDefaultSelected({ 节点选择: '香港 01' });
+  assert.equal(parseConfig()['proxy-groups'][0]['default-selected'], '香港 01');
+
+  const r = await groups.setDefaultSelected({ 节点选择: '台湾 02', 备用组: '自动选择' });
+  assert.deepEqual(r.applied.sort(), ['备用组', '节点选择'].sort());
+
+  const list = parseConfig()['proxy-groups'];
+  assert.equal(list.find((g) => g.name === '节点选择')['default-selected'], '台湾 02');
+  assert.equal(list.find((g) => g.name === '备用组')['default-selected'], '自动选择');
+  // 覆盖时不应出现重复键
+  assert.equal((readConfig().match(/default-selected:/g) || []).length, 2);
+});
+
+test('落盘当前节点：传 null 删除该项；无变化时不写盘', async () => {
+  await groups.setDefaultSelected({ 节点选择: '香港 01' });
+  const r = await groups.setDefaultSelected({ 节点选择: null });
+  assert.deepEqual(r.cleared, ['节点选择']);
+  assert.equal(parseConfig()['proxy-groups'][0]['default-selected'], undefined);
+  assert.doesNotMatch(readConfig(), /default-selected/);
+
+  // 与当前配置一致 → 不写盘
+  const beforeText = readConfig();
+  const same = await groups.setDefaultSelected({ 节点选择: null });
+  assert.deepEqual(same, { applied: [], cleared: [] });
+  assert.equal(readConfig(), beforeText);
+});
+
+test('落盘当前节点：非 select 组 / 未知组 / 空输入一律拒绝且配置不动', async () => {
+  const beforeText = readConfig();
+  await assert.rejects(() => groups.setDefaultSelected({ 自动选择: '香港 01' }), /只有 select 组/);
+  await assert.rejects(() => groups.setDefaultSelected({ 不存在的组: '香港 01' }), /未找到策略组/);
+  await assert.rejects(() => groups.setDefaultSelected({}), /未指定/);
+  await assert.rejects(() => groups.setDefaultSelected({ 节点选择: '   ' }), /不能为空/);
+  assert.equal(readConfig(), beforeText);
+  assert.equal(kernelCalls, 0);
+});
+
+test('缩进 0 的列表写法：新增 / 编辑 / 删除 / 落盘当前节点都保留原缩进', async () => {
+  // YAML 允许序列与键同缩进：`proxy-groups:` 换行直接接 `- name: ...`
+  resetConfig(`mixed-port: 7890
+proxy-groups:
+- name: 手动
+  type: select
+  proxies: [DIRECT]
+rules:
+- MATCH,手动
+`);
+
+  await groups.addGroup({ name: '自动', type: 'url-test', proxies: ['DIRECT'] });
+  let text = readConfig();
+  assert.match(text, /^- name: 自动$/m, '新增条目要跟着用缩进 0');
+  assert.doesNotMatch(text, /^ {2}- name: 自动$/m);
+
+  await groups.updateGroup('手动', { type: 'select', proxies: ['DIRECT', '自动'] });
+  await groups.setDefaultSelected({ 手动: '自动' });
+  text = readConfig();
+  assert.match(
+    text,
+    /^- name: 手动\n {2}type: select\n {2}proxies: \[DIRECT, 自动\]\n {2}default-selected: "自动"$/m,
+    '替换条目与 default-selected 都要用 0 + 2 的缩进',
+  );
+
+  await groups.updateGroup('手动', { type: 'select', proxies: ['DIRECT'] }); // 先解除引用
+  await groups.removeGroup('自动');
+  assert.doesNotMatch(readConfig(), /name: 自动/);
+  assert.deepEqual(
+    parseConfig()['proxy-groups'].map((g) => g.name),
+    ['手动'],
+  );
+});
+
+test('编辑策略组：面板没建模的字段（icon / disable-udp / hidden / lazy / expected-status）原样保留', async () => {
+  resetConfig(`mixed-port: 7890
+proxy-groups:
+  - name: 手动
+    type: select
+    proxies: [DIRECT]
+    icon: https://example.com/i.png
+    disable-udp: true
+    hidden: true
+  - name: 自动
+    type: url-test
+    use: [airport]
+    lazy: true
+    expected-status: 204
+rules:
+  - MATCH,手动
+`);
+
+  await groups.updateGroup('手动', { type: 'select', proxies: ['DIRECT'] });
+  await groups.updateGroup('自动', {
+    type: 'url-test',
+    use: ['airport'],
+    interval: 120,
+    tolerance: 30,
+  });
+
+  const list = parseConfig()['proxy-groups'];
+  const manual = list.find((g) => g.name === '手动');
+  assert.equal(manual.icon, 'https://example.com/i.png');
+  assert.equal(manual['disable-udp'], true);
+  assert.equal(manual.hidden, true);
+
+  const auto = list.find((g) => g.name === '自动');
+  assert.equal(auto.lazy, true);
+  assert.equal(auto['expected-status'], 204);
+  assert.equal(auto.interval, 120, '面板管理的字段照旧按表单写');
+  assert.equal(auto.tolerance, 30);
+});
+
+test('编辑策略组：fallback / load-balance 这类没有表单的类型给出明确提示且不改配置', async () => {
+  resetConfig(`mixed-port: 7890
+proxy-groups:
+  - name: 故障转移
+    type: fallback
+    proxies: [DIRECT]
+rules:
+  - MATCH,故障转移
+`);
+
+  const beforeText = readConfig();
+  await assert.rejects(
+    () => groups.updateGroup('故障转移', { type: 'select', proxies: ['DIRECT'] }),
+    /只提供手动选择 \/ 自动选择的编辑表单/,
+  );
+  assert.equal(readConfig(), beforeText);
+  assert.equal(kernelCalls, 0);
+});
+
+test('内核没在跑（连不上）：写盘照旧成功，返回 reloaded:false + warning 而不是报错', async () => {
+  // 指向一个没人监听的端口：fetch 直接失败（没有 HTTP 状态码），与「内核回了 500」不是一回事
+  fs.writeFileSync(
+    configPath(),
+    `mixed-port: 7890
+external-controller: 127.0.0.1:1
+proxy-groups:
+  - name: 手动
+    type: select
+    proxies: [DIRECT]
+rules:
+  - MATCH,手动
+`,
+  );
+
+  const r = await groups.addGroup({ name: '新组', type: 'select', proxies: ['DIRECT'] });
+  assert.equal(r.ok, true);
+  assert.equal(r.reloaded, false);
+  assert.match(r.warning, /内核没在运行/);
+  assert.match(readConfig(), /- name: 新组/);
+});