Files
ShadowsocksX-NG/ShadowsocksX-NG2/Tests/Support/SettingsWorkflowTestSupport.swift
T
Qiu Yuzhou 20a62117f2 refactor(tests): 按功能领域重组 Tests/ 目录
Tests/ 根层原有 138 个平铺测试文件,无法从目录读出测试覆盖的功能领域。

按功能领域重组为 17 个目录(Catalog/Workflow 与 Rules/Custom 两处嵌套,分别
对应 App/Application/CatalogWorkflow 与 Domain/Rules/Custom):Architecture /
Support / Agent / Activation / Catalog / Subscription / Rules / ProxyRuntime /
ProxyControl / Runtime / Settings / SystemProxy / Plugin / Diagnostics /
Credentials / Workspace / Servers;Smoke/ 保持独立 target 不动。138 个移动中
132 个是 100% 相似度的纯重命名,其余 6 个在重命名之上带路径反推改写(见下)。

本次不是纯搬移:测试代码比生产代码多一层位置耦合,有 7 处用固定层数的
deletingLastPathComponent() 从 #filePath 反推仓库路径(都假定文件就在 Tests/
根层)。这 7 处改走新增的 Tests/Support/TestSourceTree.swift——从调用点沿父
目录上溯找到含 project.yml 的目录,因此不再依赖父目录层数,以后移动测试文件
也不会静默指错。

配套改动:

- 新增 Tests 布局守卫 TestsLayoutTests,断言 Tests/ 根层无平铺 .swift。比
  Domain 那条弱一档——根层的 Info.plist(info.path 生成物)与
  Fixtures/RuleSnapshots 下的 JSON(folder resource)都必须保留,不能用
  「树下只有 .swift」覆盖。
- project.yml:Smoke target 按文件引用的 Tests/AppArtifact.swift 改指
  Tests/Support/;两处注释里写死的 Tests/SkeletonTests.swift 随移动更新。
  excludes 的裸名 "Smoke" / "Fixtures" 仍匹配 Tests/ 直属子目录,无需改动。
- README 的 Tests 条目展开为目录说明,并修掉 Domain 条目里写死的
  Tests/SkeletonTests.swift。
- 顺带删去 DomainLayoutTests 文档注释里「整理前 62 个文件」这类易漂移的数字。

验证:xcodegen generate 后单测 target 为 139 个源文件(全部非 Smoke 文件,0 个
Smoke 文件混入)且仍以 Fixtures/RuleSnapshots 为资源,Smoke target 为 8 个
Smoke 文件加 AppArtifact;依赖路径反推的 6 个测试类全绿(路径指错即失败);
task format 未改写任何被移动文件;task lint 与整理前同为 21 条内容型 warning;
build 0 error;task test 1025 用例全通过(整理前 1024,+1 为新守卫);
TestsLayoutTests 经变异验证(根层投放探针即失败);packaging-gate ALL CHECKS
PASSED。
2026-10-05 20:37:35 +08:00

223 lines
6.7 KiB
Swift

import Foundation
import XCTest
@testable import ShadowsocksX_NG2
/// 轮询等待异步投影落定(设置工作流测试共享)。
@MainActor
func waitUntil(
_ condition: @autoclosure () -> Bool,
timeout: TimeInterval = 2,
file: StaticString = #filePath,
line: UInt = #line
) async {
let deadline = Date().addingTimeInterval(timeout)
while !condition() && Date() < deadline {
try? await Task.sleep(nanoseconds: 10_000_000)
}
XCTAssertTrue(condition(), file: file, line: line)
}
/// 设置工作流测试的写入缝替身(issue #44):记录提交调用,可注入失败;
/// 不触碰真实偏好文件、钥匙串或运行时。
@MainActor
final class FakeSettingsCommitter: SettingsCommitting {
var committedSettings: ProxySettings = ProxySettings()
var runtimeListenFacts: RuntimeListenFacts?
var runtimeListenerProcessID: Int32?
var updateError: Error?
var updateGate: AsyncGate?
private(set) var updateCalls: [ProxySettings] = []
var isProxyRunning: Bool {
get { runtimeListenFacts != nil }
set {
runtimeListenFacts = newValue ? RuntimeListenFacts(listen: committedSettings.listen) : nil
}
}
func updateSettings(_ proposed: ProxySettings) async throws {
if let updateError { throw updateError }
if let updateGate { await updateGate.wait() }
updateCalls.append(proposed)
committedSettings = proposed
}
func updateListenerMode(_ mode: ListenerMode) async throws {
var proposed = committedSettings
proposed.listen.listenerMode = mode
try await updateSettings(proposed)
}
}
/// 可重复使用的异步门闩,用于证明 workflow 在提交等待期间拒绝第二次命令。
final class AsyncGate: @unchecked Sendable {
private let lock = NSLock()
private var released = false
private var waiters: [CheckedContinuation<Void, Never>] = []
func wait() async {
await withCheckedContinuation { continuation in
lock.lock()
if released {
lock.unlock()
continuation.resume()
} else {
waiters.append(continuation)
lock.unlock()
}
}
}
func release() {
lock.lock()
released = true
let waiters = self.waiters
self.waiters.removeAll()
lock.unlock()
waiters.forEach { $0.resume() }
}
}
/// 占用探测替身:按端口预设占用/不可判定,记录全部探测请求。
final class FakeOccupancyProbe: PortOccupancyProbing, @unchecked Sendable {
private let lock = NSLock()
private let occupiedPorts: Set<Int>
private let unknownPorts: Set<Int>
private let occupierName: String
private let occupierIPv4ProcessIDs: Set<Int32>
private let occupierIPv6ProcessIDs: Set<Int32>
private let explicitOccupiedFamilies: Set<PortOccupancyAddressFamily>?
private let unverifiedFamilyDetail: String?
private var requestedPorts: [Int] = []
private var requestedRequests: [PortOccupancyProbeRequest] = []
private var answerOverride: PortOccupancy?
init(
occupiedPorts: Set<Int> = [], unknownPorts: Set<Int> = [], occupierName: String = "other-app",
occupierProcessIDs: Set<Int32> = [], occupierIPv6ProcessIDs: Set<Int32> = [],
occupiedFamilies: Set<PortOccupancyAddressFamily>? = nil,
unverifiedFamilyDetail: String? = nil
) {
self.occupiedPorts = occupiedPorts
self.unknownPorts = unknownPorts
self.occupierName = occupierName
occupierIPv4ProcessIDs = occupierProcessIDs
self.occupierIPv6ProcessIDs = occupierIPv6ProcessIDs
explicitOccupiedFamilies = occupiedFamilies
self.unverifiedFamilyDetail = unverifiedFamilyDetail
}
var requested: [Int] {
lock.lock()
defer { lock.unlock() }
return requestedPorts
}
var callCount: Int {
lock.lock()
defer { lock.unlock() }
return requestedPorts.count
}
var requests: [PortOccupancyProbeRequest] {
lock.lock()
defer { lock.unlock() }
return requestedRequests
}
/// 覆盖全部端口的应答(占用代际测试用)。
func setAnswer(_ answer: PortOccupancy?) {
lock.lock()
defer { lock.unlock() }
answerOverride = answer
}
func occupancy(for request: PortOccupancyProbeRequest) -> PortOccupancy {
lock.lock()
defer { lock.unlock() }
requestedPorts.append(request.port)
requestedRequests.append(request)
if let answerOverride { return answerOverride }
if unknownPorts.contains(request.port) {
return .unknown(detail: "无法判定")
}
return occupiedPorts.contains(request.port)
? .occupied(
PortOccupancyFacts(
occupier: occupierName, ipv4ProcessIDs: occupierIPv4ProcessIDs,
ipv6ProcessIDs: occupierIPv6ProcessIDs,
occupiedFamilies: explicitOccupiedFamilies
?? occupiedFamilies(for: request.listen.listenerMode),
verifiedFamilies: Set(PortOccupancyAddressFamily.allCases),
unverifiedFamilyDetail: unverifiedFamilyDetail)) : .free
}
private func occupiedFamilies(for mode: ListenerMode) -> Set<PortOccupancyAddressFamily> {
switch mode {
case .localhost, .allIPv4Interfaces:
[.ipv4]
case .allIPv4AndIPv6Interfaces:
[.ipv4, .ipv6]
case .allIPv6Interfaces:
[.ipv6]
}
}
}
/// 分阶段占用探测替身(占用代际测试用):门闩阶段的调用先记下自己的应答再
/// 被扣住,`passThrough` 之后的调用立即返回新应答。用于把「旧一轮」结果钉在
/// 新一轮之后落盘,验证过期结果不得覆盖。
final class GatedOccupancyProbe: PortOccupancyProbing, @unchecked Sendable {
private let lock = NSLock()
private let gate = DispatchGroup()
private var isGated = true
private var enteredCount = 0
private var gatedAnswer: PortOccupancy
private var passThroughAnswer: PortOccupancy
init(gatedAnswer: PortOccupancy, passThroughAnswer: PortOccupancy) {
self.gatedAnswer = gatedAnswer
self.passThroughAnswer = passThroughAnswer
gate.enter()
}
/// 已进入探测的调用数(按端口标识序,socks 先于 http)。
var entered: Int {
lock.lock()
defer { lock.unlock() }
return enteredCount
}
/// 之后的调用立即返回 `answer`;已进入且被扣住的调用仍持有各自应答。
func passThrough(_ answer: PortOccupancy) {
lock.lock()
defer { lock.unlock() }
isGated = false
passThroughAnswer = answer
}
/// 放行全部被扣住的调用(广播门闩)。
func releaseGatedCalls() {
lock.lock()
let wasGated = isGated
isGated = false
lock.unlock()
if wasGated {
gate.leave()
}
}
func occupancy(for request: PortOccupancyProbeRequest) -> PortOccupancy {
lock.lock()
enteredCount += 1
let gated = isGated
let answer = gated ? gatedAnswer : passThroughAnswer
lock.unlock()
if gated {
gate.wait()
}
return answer
}
}