Files
ShadowsocksX-NG/ShadowsocksX-NG2/Tests/CustomRuleEditingWorkflowTests.swift
T
Qiu Yuzhou 17672ff655 feat(rules): add custom rule editor (#79)
Add versioned sheet-local drafts, normalized previews, custom identity validation,
and explicit saves through the existing rule-document transaction. Preserve UUIDs,
builtin memberships, disabled identities, and deployment recovery outcomes.

Include approved Chinese and English editor copy. Verify public Workflow commands,
the production Controller adapter with hostless tests, and compiled bilingual
resources. Visual acceptance remains manual.
2026-10-03 00:47:06 +08:00

358 lines
16 KiB
Swift

import XCTest
@testable import ShadowsocksX_NG2
@MainActor
final class CustomRuleEditingWorkflowTests: XCTestCase {
func testIPPreviewNormalizesWithoutSavingAndSavePublishesNewRow() async throws {
let workflow = RulesWorkflow(
loadDocument: { CustomRuleDocument(rules: []) },
commitDocument: { RuleDocumentCommit(outcome: .saved, document: $0) },
loadBuiltin: { rulesFixture($0) })
await workflow.refresh()
let version = workflow.snapshot.version
var draft = try XCTUnwrap(workflow.makeCustomRuleDraft())
draft.kind = .ipAddress
draft.content = " 2001:DB8::1 "
draft.action = .direct
let preview = await workflow.previewCustomRule(draft)
XCTAssertNil(preview.failure)
XCTAssertEqual(preview.rule?.match, .ipv6CIDR("2001:db8::1/128"))
XCTAssertEqual(preview.displayContent, "2001:db8::1")
XCTAssertEqual(workflow.snapshot.version, version)
XCTAssertFalse(workflow.snapshot.rows.contains { $0.customIDs.contains(draft.id) })
let outcome = await workflow.saveCustomRule(draft)
XCTAssertEqual(outcome, .committed(.saved))
let row = try XCTUnwrap(workflow.snapshot.rows.first { $0.customIDs.contains(draft.id) })
XCTAssertEqual(row.identity?.match, .ipv6CIDR("2001:db8::1/128"))
XCTAssertEqual(row.sources, [.custom])
XCTAssertNotEqual(workflow.snapshot.version, version)
}
func testEditingDisabledMergedRuleMovesOnlyCustomMembershipAndKeepsUUID() async throws {
let original = CustomRule(
action: .proxy, match: .domainSuffix("old.example"),
source: RuleSourceIdentity(kind: .custom, upstreamVersion: "imported", label: "User import"))
let source = RuleSourceIdentity(kind: .gfwlist, upstreamVersion: "fixture", label: "GFWList")
let builtin = ProxyRule(action: .proxy, match: original.match, source: source)
var saved = CustomRuleDocument(rules: [original], disabledIdentities: [original.identity])
let workflow = RulesWorkflow(
loadDocument: { saved },
commitDocument: {
saved = $0
return RuleDocumentCommit(outcome: .saved, document: saved)
},
loadBuiltin: { rulesFixture($0, rules: $0 == .gfwlist ? [builtin] : []) })
await workflow.refresh()
var draft = try XCTUnwrap(workflow.makeCustomRuleDraft(editing: original.id))
let unchanged = await workflow.previewCustomRule(draft)
XCTAssertNil(unchanged.failure, "Editing excludes its own UUID")
draft.content = "new.example"
draft.action = .direct
let preview = await workflow.previewCustomRule(draft)
XCTAssertTrue(preview.inheritsDisablement)
XCTAssertEqual(preview.row?.isEnabled, false)
let result = await workflow.saveCustomRule(draft)
XCTAssertEqual(result, .committed(.saved))
XCTAssertEqual(saved.rules.count, 1)
XCTAssertEqual(saved.rules.first?.id, original.id)
XCTAssertEqual(saved.rules.first?.source, original.source)
XCTAssertEqual(
saved.disabledIdentities,
[original.identity, RuleIdentity(action: .direct, match: .domainSuffix("new.example"))])
let oldRow = try XCTUnwrap(workflow.snapshot.rows.first { $0.identity == original.identity })
XCTAssertEqual(oldRow.sources, [.gfwlist])
XCTAssertTrue(oldRow.customIDs.isEmpty)
XCTAssertFalse(oldRow.isEnabled)
let newRow = try XCTUnwrap(workflow.snapshot.rows.first { $0.customIDs.contains(original.id) })
XCTAssertEqual(newRow.sources, [.custom])
XCTAssertFalse(newRow.isEnabled)
}
func testCIDRRequiresAddressAndPrefixAndShowsMaskedNetwork() async throws {
let workflow = RulesWorkflow(
loadDocument: { CustomRuleDocument(rules: []) },
commitDocument: { RuleDocumentCommit(outcome: .saved, document: $0) },
loadBuiltin: { rulesFixture($0) })
await workflow.refresh()
var draft = try XCTUnwrap(workflow.makeCustomRuleDraft())
draft.kind = .cidr
draft.action = .direct
for invalid in ["/8.8.8.8", "8.8.8.8/", "8.8.8.8", "8.8.8.8/33", "2001:db8::1/129"] {
draft.content = invalid
let preview = await workflow.previewCustomRule(draft)
XCTAssertEqual(preview.failure, .invalidInput(.cidr), invalid)
}
for (input, expected) in [
("8.8.8.9/24", "8.8.8.0/24"), ("2001:db8:1::123/48", "2001:db8:1::/48"),
] {
draft.content = input
let preview = await workflow.previewCustomRule(draft)
XCTAssertNil(preview.failure)
XCTAssertEqual(preview.displayContent, expected)
}
}
func testDuplicateAndFixedLocalConflictAreRejectedWithoutCommit() async throws {
let existing = CustomRule(action: .direct, match: .ipv4CIDR("8.8.8.8/32"))
var commits = 0
let workflow = RulesWorkflow(
loadDocument: { CustomRuleDocument(rules: [existing]) },
commitDocument: {
commits += 1
return RuleDocumentCommit(outcome: .saved, document: $0)
},
loadBuiltin: { rulesFixture($0) })
await workflow.refresh()
var draft = try XCTUnwrap(workflow.makeCustomRuleDraft())
draft.kind = .ipAddress
draft.content = "8.8.8.8"
draft.action = .direct
let duplicate = await workflow.previewCustomRule(draft)
XCTAssertEqual(duplicate.failure, .duplicate)
let duplicateSave = await workflow.saveCustomRule(draft)
XCTAssertEqual(duplicateSave, .unavailable(.duplicate))
draft.kind = .cidr
draft.content = "8.8.8.8/32"
let cidr = await workflow.previewCustomRule(draft)
XCTAssertEqual(cidr.failure, .duplicate, "IP and full CIDR have one identity")
draft.action = .proxy
draft.kind = .ipAddress
for input in ["192.168.1.1", "::ffff:192.168.1.1", "::1"] {
draft.content = input
let conflict = await workflow.previewCustomRule(draft)
XCTAssertEqual(conflict.failure, .fixedLocalConflict, input)
let save = await workflow.saveCustomRule(draft)
XCTAssertEqual(save, .unavailable(.fixedLocalConflict))
}
XCTAssertEqual(commits, 0)
}
func testEquivalentBuiltinAndDisabledOrphanCanBeAddedWithoutEnabling() async throws {
let source = RuleSourceIdentity(kind: .gfwlist, upstreamVersion: "fixture", label: "GFWList")
let builtin = ProxyRule(action: .proxy, match: .domainSuffix("merge.example"), source: source)
let orphan = RuleIdentity(action: .proxy, match: .domainExact("orphan.example"))
let workflow = RulesWorkflow(
loadDocument: {
CustomRuleDocument(rules: [], disabledIdentities: [builtin.identity, orphan])
},
commitDocument: { RuleDocumentCommit(outcome: .saved, document: $0) },
loadBuiltin: { rulesFixture($0, rules: $0 == .gfwlist ? [builtin] : []) })
await workflow.refresh()
var draft = try XCTUnwrap(workflow.makeCustomRuleDraft())
draft.content = ".MERGE.Example"
let preview = await workflow.previewCustomRule(draft)
XCTAssertNil(preview.failure)
XCTAssertEqual(preview.displayContent, "merge.example")
XCTAssertEqual(preview.row?.sources, [.custom, .gfwlist])
XCTAssertEqual(preview.row?.isEnabled, false)
let result = await workflow.saveCustomRule(draft)
XCTAssertEqual(result, .committed(.saved))
let row = try XCTUnwrap(workflow.snapshot.rows.first { $0.customIDs.contains(draft.id) })
XCTAssertEqual(row.sources, [.custom, .gfwlist])
XCTAssertFalse(row.isEnabled)
var next = try XCTUnwrap(workflow.makeCustomRuleDraft())
next.kind = .domainExact
next.content = "orphan.example"
let orphanPreview = await workflow.previewCustomRule(next)
XCTAssertEqual(orphanPreview.row?.isEnabled, false)
let orphanSave = await workflow.saveCustomRule(next)
XCTAssertEqual(orphanSave, .committed(.saved))
XCTAssertFalse(
try XCTUnwrap(workflow.snapshot.rows.first { $0.customIDs.contains(next.id) }).isEnabled)
}
func testDomainBoundaryAndNationalSuffixUseExistingNormalization() async throws {
let workflow = RulesWorkflow(
loadDocument: { CustomRuleDocument(rules: []) },
commitDocument: { RuleDocumentCommit(outcome: .saved, document: $0) },
loadBuiltin: { rulesFixture($0) })
await workflow.refresh()
var draft = try XCTUnwrap(workflow.makeCustomRuleDraft())
draft.action = .direct
for kind in [CustomRuleDraft.Kind.domainExact, .domainSuffix] {
draft.kind = kind
for input in [
"", "例子.cn", "*.example.com", "https://example.com", "example.com/path", "^example$",
] {
draft.content = input
let preview = await workflow.previewCustomRule(draft)
XCTAssertEqual(preview.failure, .invalidInput(kind), input)
}
draft.content = " XN--FIQS8S.Example "
let valid = await workflow.previewCustomRule(draft)
XCTAssertNil(valid.failure)
XCTAssertEqual(valid.displayContent, "xn--fiqs8s.example")
}
draft.kind = .domainSuffix
draft.content = "CN"
let national = await workflow.previewCustomRule(draft)
XCTAssertNil(national.failure)
XCTAssertEqual(national.rule?.match, .domainSuffix("cn"))
draft.kind = .ipAddress
for input in ["8.8.8.8/32", "[2001:db8::1]", "8.8.8.8:80", "example.com"] {
draft.content = input
let invalid = await workflow.previewCustomRule(draft)
XCTAssertEqual(invalid.failure, .invalidInput(.ipAddress))
}
}
func testPreviewExplainsAbsorptionShadowingAndPartialOverlapButAllowsSave() async throws {
let broad = CustomRule(action: .direct, match: .domainSuffix("coverage.example"))
let proxy = CustomRule(action: .proxy, match: .domainExact("a.coverage.example"))
let workflow = RulesWorkflow(
loadDocument: { CustomRuleDocument(rules: [broad, proxy]) },
commitDocument: { RuleDocumentCommit(outcome: .saved, document: $0) },
loadBuiltin: { rulesFixture($0) })
await workflow.refresh()
var draft = try XCTUnwrap(workflow.makeCustomRuleDraft())
draft.kind = .domainExact
draft.content = "a.coverage.example"
draft.action = .direct
let preview = await workflow.previewCustomRule(draft)
XCTAssertNil(preview.failure)
XCTAssertTrue(
preview.row?.relationships.contains {
$0.kind == .absorption && $0.extent == .full && $0.covering == [broad.identity]
} == true)
XCTAssertTrue(
preview.row?.relationships.contains {
$0.kind == .shadowing && $0.extent == .full && $0.covering == [proxy.identity]
} == true)
let saved = await workflow.saveCustomRule(draft)
XCTAssertEqual(saved, .committed(.saved))
XCTAssertEqual(
workflow.snapshot.rows.first { $0.customIDs.contains(draft.id) }?.relationships,
preview.row?.relationships)
var edited = try XCTUnwrap(workflow.makeCustomRuleDraft(editing: broad.id))
edited.content = "coverage.example"
let partial = await workflow.previewCustomRule(edited)
XCTAssertTrue(
partial.row?.relationships.contains { $0.kind == .shadowing && $0.extent == .partial } == true
)
}
func testStaleDraftCannotOverwriteAnotherSavedChangeAndDiscardingDraftDoesNothing() async throws {
let rule = CustomRule(action: .direct, match: .domainExact("kept.example"))
var commits = 0
let workflow = RulesWorkflow(
loadDocument: { CustomRuleDocument(rules: [rule]) },
commitDocument: {
commits += 1
return RuleDocumentCommit(outcome: .saved, document: $0)
},
loadBuiltin: { rulesFixture($0) })
await workflow.refresh()
var discarded = try XCTUnwrap(workflow.makeCustomRuleDraft(editing: rule.id))
discarded.content = "discarded.example"
_ = await workflow.previewCustomRule(discarded)
XCTAssertEqual(commits, 0)
XCTAssertEqual(
workflow.snapshot.rows.first { $0.customIDs.contains(rule.id) }?.identity, rule.identity)
var stale = try XCTUnwrap(workflow.makeCustomRuleDraft())
stale.content = "new.example"
await workflow.setEnabled(false, identities: [rule.identity])
let result = await workflow.saveCustomRule(stale)
XCTAssertEqual(result, .unavailable(.staleDraft))
XCTAssertEqual(commits, 1)
XCTAssertFalse(workflow.snapshot.rows.contains { $0.customIDs.contains(stale.id) })
}
}
extension CustomRuleEditingWorkflowTests {
func testPendingSaveBlocksRepeatsAndFailureKeepsSnapshotAvailableForRetry() async throws {
let original = CustomRuleDocument(rules: [])
let started = expectation(description: "save awaiting adapter")
var continuation: CheckedContinuation<Void, Never>?
var commits = 0
let workflow = RulesWorkflow(
loadDocument: { original },
commitDocument: { _ in
commits += 1
await withCheckedContinuation {
continuation = $0
started.fulfill()
}
return RuleDocumentCommit(outcome: .persistenceFailed, document: original)
},
loadBuiltin: { rulesFixture($0) })
await workflow.refresh()
let version = workflow.snapshot.version
var draft = try XCTUnwrap(workflow.makeCustomRuleDraft())
draft.content = "pending.example"
let pending = Task { await workflow.saveCustomRule(draft) }
await fulfillment(of: [started], timeout: 3)
XCTAssertTrue(workflow.snapshot.isCommitting)
XCTAssertEqual(workflow.snapshot.operationStatus, .updating)
let repeated = await workflow.saveCustomRule(draft)
XCTAssertEqual(repeated, .unavailable(.busy))
XCTAssertNil(workflow.makeCustomRuleDraft())
continuation?.resume()
let result = await pending.value
XCTAssertEqual(result, .committed(.persistenceFailed))
XCTAssertEqual(commits, 1)
XCTAssertEqual(workflow.snapshot.version, version)
XCTAssertEqual(workflow.snapshot.commitOutcome, .persistenceFailed)
XCTAssertFalse(workflow.snapshot.rows.contains { $0.customIDs.contains(draft.id) })
let retry = await workflow.previewCustomRule(draft)
XCTAssertNil(retry.failure)
}
func testIncompleteCollectionAndFailedRecoveryCannotSilentlyUseOldFacts() async throws {
let rule = CustomRule(action: .direct, match: .domainSuffix("old.example"))
let original = CustomRuleDocument(rules: [rule])
let outcome = CustomRuleUpdateOutcome.recoveryFailed(
detail: "fixture recovery error", rulesRestored: false)
let workflow = RulesWorkflow(
loadDocument: { original },
commitDocument: { RuleDocumentCommit(outcome: outcome, document: $0) },
loadBuiltin: { rulesFixture($0) })
XCTAssertNil(workflow.makeCustomRuleDraft())
await workflow.refresh()
var draft = try XCTUnwrap(workflow.makeCustomRuleDraft(editing: rule.id))
draft.content = "new.example"
let result = await workflow.saveCustomRule(draft)
XCTAssertEqual(result, .committed(outcome))
XCTAssertEqual(workflow.snapshot.commitOutcome, outcome)
XCTAssertEqual(
workflow.snapshot.rows.first { $0.customIDs.contains(rule.id) }?.content, "new.example")
let stale = await workflow.previewCustomRule(draft)
XCTAssertEqual(stale.failure, .staleDraft)
let incomplete = RulesWorkflow(
loadDocument: { throw CustomRuleStoreError.corrupt(detail: "fixture error") },
commitDocument: { RuleDocumentCommit(outcome: .saved, document: $0) },
loadBuiltin: { rulesFixture($0) })
await incomplete.refresh()
XCTAssertNil(incomplete.makeCustomRuleDraft())
let refused = await incomplete.saveCustomRule(draft)
XCTAssertEqual(refused, .unavailable(.incompleteCollection))
}
}
extension CustomRuleEditingWorkflowTests {
func testDisabledEditCannotInheritDisablementOntoImmutableFixedIdentity() async throws {
let original = CustomRule(action: .direct, match: .domainExact("disabled.example"))
var commits = 0
let workflow = RulesWorkflow(
loadDocument: {
CustomRuleDocument(rules: [original], disabledIdentities: [original.identity])
},
commitDocument: {
commits += 1
return RuleDocumentCommit(outcome: .saved, document: $0)
},
loadBuiltin: { rulesFixture($0) })
await workflow.refresh()
var draft = try XCTUnwrap(workflow.makeCustomRuleDraft(editing: original.id))
draft.kind = .cidr
draft.content = "127.0.0.0/8"
let preview = await workflow.previewCustomRule(draft)
XCTAssertEqual(preview.failure, .fixedPolicyDisablement)
XCTAssertNil(preview.document)
let result = await workflow.saveCustomRule(draft)
guard case .unavailable = result else { return XCTFail("Must reject fixed-policy disablement") }
XCTAssertEqual(commits, 0)
XCTAssertFalse(workflow.snapshot.rows.filter(\.isFixed).contains { !$0.isEnabled })
}
}