im0o
955fa340af
之前只扫顶层 rules。附加规则（sub-rules）里的 RULE-SET 引用漏过的话， 删除会被内核重载拒掉——保护链路能回滚，但用户看到的是解析错误原文 而不是「谁在引用它」。
334 lines
12 KiB
TypeScript
334 lines
12 KiB
TypeScript
import { describe, expect, it } from 'bun:test'
|
||
import {
|
||
buildRule,
|
||
findRuleIssues,
|
||
firstMatchIndex,
|
||
inferRuleFormat,
|
||
insertBeforeMatch,
|
||
isStructuredEditable,
|
||
missingLanRules,
|
||
moveRule,
|
||
parseIniRulesets,
|
||
parseRule,
|
||
planIniImport,
|
||
ruleProviderPath,
|
||
ruleProviderPathConflict,
|
||
ruleSetReferences,
|
||
setRuleProviders,
|
||
setRules,
|
||
subRuleSetReferences,
|
||
} from './rules.ts'
|
||
import type { ConfigObject } from '../vendor/config-editor/index.ts'
|
||
|
||
describe('规则字符串的拆分与拼装', () => {
|
||
it('常见的三段规则', () => {
|
||
expect(parseRule('DOMAIN-SUFFIX,youtube.com,PROXY')).toEqual({
|
||
type: 'DOMAIN-SUFFIX',
|
||
payload: 'youtube.com',
|
||
target: 'PROXY',
|
||
extras: [],
|
||
})
|
||
})
|
||
|
||
it('MATCH 没有载荷', () => {
|
||
expect(parseRule('MATCH,PROXY')).toEqual({
|
||
type: 'MATCH',
|
||
payload: null,
|
||
target: 'PROXY',
|
||
extras: [],
|
||
})
|
||
})
|
||
|
||
it('选项尾部原样保留', () => {
|
||
const parsed = parseRule('IP-CIDR,127.0.0.0/8,DIRECT,no-resolve')
|
||
expect(parsed.extras).toEqual(['no-resolve'])
|
||
// 改目标不能丢掉选项
|
||
expect(buildRule({ ...parsed, target: 'REJECT' })).toBe('IP-CIDR,127.0.0.0/8,REJECT,no-resolve')
|
||
})
|
||
|
||
it('拆开再拼回原样', () => {
|
||
for (const rule of [
|
||
'DOMAIN-SUFFIX,youtube.com,PROXY',
|
||
'MATCH,PROXY',
|
||
'IP-CIDR,127.0.0.0/8,DIRECT,no-resolve',
|
||
'RULE-SET,ads,REJECT',
|
||
'AND,((DOMAIN-SUFFIX,a.com),(DST-PORT,443)),PROXY',
|
||
]) {
|
||
expect(buildRule(parseRule(rule))).toBe(rule)
|
||
}
|
||
})
|
||
|
||
it('逻辑规则的载荷里有逗号也不被拆开', () => {
|
||
const parsed = parseRule('AND,((DOMAIN-SUFFIX,a.com),(DST-PORT,443)),PROXY')
|
||
expect(parsed.payload).toBe('((DOMAIN-SUFFIX,a.com),(DST-PORT,443))')
|
||
expect(parsed.target).toBe('PROXY')
|
||
})
|
||
|
||
it('正则类规则的顶层逗号不拆坏：最后一段是目标，其余全归载荷', () => {
|
||
// 内核对 DOMAIN-REGEX 这几类按「载荷可含逗号、不许带选项」读（rules/common/base.go:47-79）
|
||
expect(parseRule('DOMAIN-REGEX,^(a|b),c$,PROXY')).toEqual({
|
||
type: 'DOMAIN-REGEX',
|
||
payload: '^(a|b),c$',
|
||
target: 'PROXY',
|
||
extras: [],
|
||
})
|
||
})
|
||
|
||
it('结构化编辑只给常见形状，逻辑规则、子规则和正则类按原文编辑', () => {
|
||
expect(isStructuredEditable('DOMAIN-SUFFIX,youtube.com,PROXY')).toBe(true)
|
||
expect(isStructuredEditable('MATCH,PROXY')).toBe(true)
|
||
expect(isStructuredEditable('AND,((DOMAIN-SUFFIX,a.com),(DST-PORT,443)),PROXY')).toBe(false)
|
||
expect(isStructuredEditable('SUB-RULE,(DOMAIN-SUFFIX,a.com),sub1')).toBe(false)
|
||
expect(isStructuredEditable('DOMAIN-REGEX,^ads?,b$,REJECT')).toBe(false)
|
||
expect(isStructuredEditable('孤零零一段')).toBe(false)
|
||
})
|
||
})
|
||
|
||
describe('规则表的顺序', () => {
|
||
const rules = ['DOMAIN-SUFFIX,a.com,DIRECT', 'MATCH,PROXY', 'DOMAIN-SUFFIX,b.com,REJECT']
|
||
|
||
it('第一条 MATCH 之后的规则不可达', () => {
|
||
expect(firstMatchIndex(rules)).toBe(1)
|
||
expect(firstMatchIndex(['DOMAIN-SUFFIX,a.com,DIRECT'])).toBe(-1)
|
||
})
|
||
|
||
it('新规则插在第一条 MATCH 之前', () => {
|
||
expect(insertBeforeMatch(rules, ['GEOIP,CN,DIRECT'])).toEqual([
|
||
'DOMAIN-SUFFIX,a.com,DIRECT',
|
||
'GEOIP,CN,DIRECT',
|
||
'MATCH,PROXY',
|
||
'DOMAIN-SUFFIX,b.com,REJECT',
|
||
])
|
||
})
|
||
|
||
it('没有 MATCH 时加在末尾', () => {
|
||
expect(insertBeforeMatch(['GEOIP,CN,DIRECT'], ['MATCH,PROXY'])).toEqual([
|
||
'GEOIP,CN,DIRECT',
|
||
'MATCH,PROXY',
|
||
])
|
||
})
|
||
|
||
it('上移下移只交换相邻两条，其余不动', () => {
|
||
expect(moveRule(rules, 0, 1)).toEqual([
|
||
'MATCH,PROXY',
|
||
'DOMAIN-SUFFIX,a.com,DIRECT',
|
||
'DOMAIN-SUFFIX,b.com,REJECT',
|
||
])
|
||
expect(moveRule(rules, 0, -1)).toBe(rules)
|
||
expect(moveRule(rules, 2, 1)).toBe(rules)
|
||
})
|
||
})
|
||
|
||
describe('断引用', () => {
|
||
it('目标出站不存在和规则组不存在都标出来', () => {
|
||
const rules = [
|
||
'DOMAIN-SUFFIX,a.com,NOPE',
|
||
'RULE-SET,ads,REJECT',
|
||
'RULE-SET,gone,DIRECT',
|
||
'SUB-RULE,(DOMAIN-SUFFIX,a.com),sub1',
|
||
'MATCH,PROXY',
|
||
]
|
||
const issues = findRuleIssues(rules, new Set(['PROXY', 'REJECT', 'DIRECT']), new Set(['ads']))
|
||
expect(issues).toEqual([
|
||
{ index: 0, kind: 'target', name: 'NOPE' },
|
||
{ index: 2, kind: 'rule-set', name: 'gone' },
|
||
])
|
||
})
|
||
})
|
||
|
||
describe('内网直连预设', () => {
|
||
it('空表全缺', () => {
|
||
expect(missingLanRules([])).toHaveLength(8)
|
||
})
|
||
|
||
it('已管住的网段不重复加，哪怕写法不完全一样', () => {
|
||
const existing = ['IP-CIDR,192.168.0.0/16,DIRECT', 'MATCH,PROXY']
|
||
const missing = missingLanRules(existing)
|
||
expect(missing).toHaveLength(7)
|
||
expect(missing.some((r) => r.includes('192.168.0.0/16'))).toBe(false)
|
||
})
|
||
})
|
||
|
||
describe('删除规则组前找引用', () => {
|
||
it('列出 rules 里引用它的规则下标', () => {
|
||
const rules = ['RULE-SET,ads,REJECT', 'DOMAIN-SUFFIX,a.com,DIRECT', 'RULE-SET,ads,PROXY']
|
||
expect(ruleSetReferences(rules, 'ads')).toEqual([0, 2])
|
||
expect(ruleSetReferences(rules, 'other')).toEqual([])
|
||
})
|
||
})
|
||
|
||
describe('配置形状', () => {
|
||
it('rules 空了删掉整个键', () => {
|
||
const data: ConfigObject = { rules: ['MATCH,PROXY'] }
|
||
setRules(data, ['A,B,C'])
|
||
expect(data.rules).toEqual(['A,B,C'])
|
||
setRules(data, [])
|
||
expect('rules' in data).toBe(false)
|
||
})
|
||
|
||
it('rule-providers 空了删掉整个键', () => {
|
||
const data: ConfigObject = {}
|
||
setRuleProviders(data, { ads: { type: 'http' } })
|
||
expect(Object.keys(data['rule-providers'] as ConfigObject)).toEqual(['ads'])
|
||
setRuleProviders(data, {})
|
||
expect('rule-providers' in data).toBe(false)
|
||
})
|
||
})
|
||
|
||
describe('ini 的 ruleset= 行解析', () => {
|
||
const ini = `
|
||
[custom]
|
||
; 注释行不算
|
||
;ruleset=🎯 全球直连,[]GEOIP,LAN
|
||
ruleset=🎯 全球直连,https://example.com/LocalAreaNetwork.list
|
||
ruleset=🛑 全球拦截,https://example.com/BanAD.list?token=1
|
||
ruleset=🎯 全球直连,https://example.com/GoogleCN.list
|
||
ruleset=🍎 苹果服务,Apple.list
|
||
ruleset=🎯 全球直连,[]GEOIP,CN
|
||
ruleset=🐟 漏网之鱼,[]FINAL
|
||
custom_proxy_group=🚀 节点选择\`select\`[]AUTO
|
||
`
|
||
|
||
it('URL、本地路径、内联 GEOIP 和 FINAL 都认出来', () => {
|
||
expect(parseIniRulesets(ini)).toEqual([
|
||
{ target: '🎯 全球直连', kind: 'url', source: 'https://example.com/LocalAreaNetwork.list' },
|
||
{ target: '🛑 全球拦截', kind: 'url', source: 'https://example.com/BanAD.list?token=1' },
|
||
{ target: '🎯 全球直连', kind: 'url', source: 'https://example.com/GoogleCN.list' },
|
||
{ target: '🍎 苹果服务', kind: 'file', source: 'Apple.list' },
|
||
{ target: '🎯 全球直连', kind: 'geoip', source: 'CN' },
|
||
{ target: '🐟 漏网之鱼', kind: 'final', source: '' },
|
||
])
|
||
})
|
||
|
||
it('custom_proxy_group 和残缺行不产生条目', () => {
|
||
expect(parseIniRulesets('ruleset=\nruleset=只有目标,\ncustom_proxy_group=x`select`y')).toEqual([])
|
||
})
|
||
|
||
it('GEOIP 类别后的附加参数不并进类别名，生成规则时放在目标之后', () => {
|
||
const entries = parseIniRulesets('ruleset=🎯 全球直连,[]GEOIP,CN,no-resolve')
|
||
expect(entries).toEqual([
|
||
{ target: '🎯 全球直连', kind: 'geoip', source: 'CN', flags: ['no-resolve'] },
|
||
])
|
||
const plan = planIniImport(entries, { '🎯 全球直连': 'DIRECT' }, new Set())
|
||
expect(plan.rules).toEqual(['GEOIP,CN,DIRECT,no-resolve'])
|
||
})
|
||
})
|
||
|
||
describe('ini 导入计划', () => {
|
||
const entries = parseIniRulesets(`
|
||
ruleset=🎯 全球直连,https://example.com/LocalAreaNetwork.list
|
||
ruleset=🎯 全球直连,https://example.com/GoogleCN.list
|
||
ruleset=🎯 全球直连,[]GEOIP,CN
|
||
ruleset=🐟 漏网之鱼,[]FINAL
|
||
`)
|
||
|
||
it('每行一个规则组加一条规则骨架，FINAL 落在表末尾', () => {
|
||
const plan = planIniImport(
|
||
entries,
|
||
{ '🎯 全球直连': 'DIRECT', '🐟 漏网之鱼': 'PROXY' },
|
||
new Set(),
|
||
)
|
||
expect(Object.keys(plan.providers)).toEqual(['LocalAreaNetwork', 'GoogleCN'])
|
||
expect(plan.providers.LocalAreaNetwork).toEqual({
|
||
type: 'http',
|
||
behavior: 'classical',
|
||
url: 'https://example.com/LocalAreaNetwork.list',
|
||
path: './providers/rules/LocalAreaNetwork.txt',
|
||
format: 'text',
|
||
interval: 86400,
|
||
})
|
||
expect(plan.rules).toEqual([
|
||
'RULE-SET,LocalAreaNetwork,DIRECT',
|
||
'RULE-SET,GoogleCN,DIRECT',
|
||
'GEOIP,CN,DIRECT',
|
||
])
|
||
expect(plan.finals).toEqual(['MATCH,PROXY'])
|
||
})
|
||
|
||
it('同一个来源出现多次只声明一个规则组', () => {
|
||
const plan = planIniImport(
|
||
[
|
||
{ target: '甲', kind: 'url', source: 'https://example.com/a.list' },
|
||
{ target: '乙', kind: 'url', source: 'https://example.com/a.list' },
|
||
],
|
||
{ 甲: 'DIRECT', 乙: 'REJECT' },
|
||
new Set(),
|
||
)
|
||
expect(Object.keys(plan.providers)).toEqual(['a'])
|
||
expect(plan.rules).toEqual(['RULE-SET,a,DIRECT', 'RULE-SET,a,REJECT'])
|
||
})
|
||
|
||
it('和已有规则组撞名时加序号', () => {
|
||
const plan = planIniImport(
|
||
[{ target: '甲', kind: 'url', source: 'https://example.com/ads.list' }],
|
||
{ 甲: 'REJECT' },
|
||
new Set(['ads']),
|
||
)
|
||
expect(Object.keys(plan.providers)).toEqual(['ads-2'])
|
||
expect(plan.rules).toEqual(['RULE-SET,ads-2,REJECT'])
|
||
})
|
||
|
||
it('本地路径生成 file 类型，path 就是来源本身', () => {
|
||
const plan = planIniImport(
|
||
[{ target: '甲', kind: 'file', source: 'D:\\lists\\ads.list' }],
|
||
{ 甲: 'REJECT' },
|
||
new Set(),
|
||
)
|
||
expect(plan.providers['ads']).toEqual({
|
||
type: 'file',
|
||
behavior: 'classical',
|
||
path: 'D:\\lists\\ads.list',
|
||
format: 'text',
|
||
})
|
||
})
|
||
|
||
it('没映射目标组的行跳过', () => {
|
||
const plan = planIniImport(entries, { '🎯 全球直连': 'DIRECT' }, new Set())
|
||
expect(plan.finals).toEqual([])
|
||
expect(plan.rules).toHaveLength(3)
|
||
})
|
||
})
|
||
|
||
describe('清单格式与缓存路径', () => {
|
||
it('格式按扩展名推断，拿不准回 yaml', () => {
|
||
expect(inferRuleFormat('https://example.com/a.list?token=1')).toBe('text')
|
||
expect(inferRuleFormat('https://example.com/a.txt')).toBe('text')
|
||
expect(inferRuleFormat('https://example.com/a.mrs')).toBe('mrs')
|
||
expect(inferRuleFormat('https://example.com/a.yaml')).toBe('yaml')
|
||
expect(inferRuleFormat('https://example.com/no-extension')).toBe('yaml')
|
||
})
|
||
|
||
it('缓存路径的扩展名跟着格式走', () => {
|
||
expect(ruleProviderPath('ads', 'text')).toBe('./providers/rules/ads.txt')
|
||
expect(ruleProviderPath('ads', 'mrs')).toBe('./providers/rules/ads.mrs')
|
||
expect(ruleProviderPath('ads', 'yaml')).toBe('./providers/rules/ads.yaml')
|
||
expect(ruleProviderPath('🛑 广告', 'yaml')).toBe('./providers/rules/广告.yaml')
|
||
})
|
||
|
||
it('名字只差符号时清单路径撞车，能认出来；自己不算', () => {
|
||
const data = {
|
||
'rule-providers': {
|
||
'🛑 广告': { behavior: 'domain', path: './providers/rules/广告.yaml' },
|
||
},
|
||
}
|
||
const path = ruleProviderPath('广告', 'yaml')
|
||
expect(ruleProviderPathConflict(data, '广告', path)).toBe('🛑 广告')
|
||
expect(ruleProviderPathConflict(data, '🛑 广告', path)).toBeNull()
|
||
expect(ruleProviderPathConflict(data, 'x', ruleProviderPath('x', 'yaml'))).toBeNull()
|
||
})
|
||
})
|
||
|
||
describe('附加规则里的规则组引用', () => {
|
||
it('sub-rules 各表里的 RULE-SET 引用都认出来，别的表不误报', () => {
|
||
const data = {
|
||
'sub-rules': {
|
||
'patchbay:t1 附加': ['RULE-SET,ads,REJECT', 'MATCH,patchbay:t1'],
|
||
mine: ['RULE-SET,other,DIRECT'],
|
||
},
|
||
}
|
||
expect(subRuleSetReferences(data, 'ads')).toEqual(['RULE-SET,ads,REJECT'])
|
||
expect(subRuleSetReferences(data, 'ghost')).toEqual([])
|
||
expect(subRuleSetReferences({}, 'ads')).toEqual([])
|
||
})
|
||
})
|