Files
ShadowsocksX-NG/ShadowsocksX-NG2/Tests/ServerFormLoadingTests.swift
T

234 lines
9.8 KiB
Swift

import Foundation
import Testing
@testable import ShadowsocksX_NG2
@MainActor
struct ServerFormLoadingTests {
@Test
func missingReferencedPasswordFailsLoadingInsteadOfBecomingEmpty() throws {
let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
defer { try? FileManager.default.removeItem(at: directory) }
let store = CatalogFileStore(fileURL: directory.appendingPathComponent("catalog.json"))
var catalog = ConfigurationCatalog()
let id = try catalog.addServer(
ServerFields(
address: "203.0.113.1", port: 8388, encryptionMethod: "aes-256-gcm",
passwordRef: .fresh(), remark: "服务器"))
try store.save(CatalogDocument(catalog: catalog))
let workflow = makeCatalogWorkflow(
coordinator: CatalogCommitCoordinator(fileStore: store, runtime: FakeCatalogRuntime()),
credentials: InMemoryCredentialStore())
#expect(throws: (any Error).self) { _ = try workflow.serverEditForm(for: id) }
}
@Test
func appearingAgainAndUpdatingPresentationDoNotReloadManualDraft() {
let fields = ServerFormFields()
let id = NodeID(rawValue: "manual")
var reads = 0
let load = { (_: NodeID) -> ServerEditForm? in
reads += 1
return Self.form()
}
fields.showServer(id, load: load)
fields.remark = "未保存名称"
fields.showServer(id, load: load)
fields.updatePresentation(ServerFormPresentation(isEditable: true, plugin: Self.form().plugin))
#expect(reads == 1)
#expect(fields.remark == "未保存名称")
#expect(fields.hasChanges)
fields.reloadServer(load: load)
#expect(reads == 2)
#expect(fields.remark == "服务器")
#expect(!fields.hasChanges)
}
@Test
func resetFailurePreservesManualDraftButBlocksSavingUntilReloadSucceeds() {
let fields = ServerFormFields()
fields.showServer(NodeID(rawValue: "manual")) { _ in Self.form() }
fields.password = "edited password"
fields.reloadServer { _ in throw ServerFormLoadError.credentialsUnavailable }
#expect(fields.password == "edited password")
#expect(fields.hasLoadedServer)
#expect(!fields.canSaveServer)
#expect(fields.loadFailure == .credentialsUnavailable)
fields.reloadServer { _ in Self.form(password: "latest") }
#expect(fields.password == "latest")
#expect(fields.canSaveServer)
#expect(fields.loadFailure == nil)
#expect(!fields.hasChanges)
}
@Test
func failedSelectionNeverShowsPreviousServerAndLateSaveDoesNotResetNewDraft() {
let fields = ServerFormFields()
let first = NodeID(rawValue: "first")
let second = NodeID(rawValue: "second")
fields.showServer(first) { _ in Self.form() }
fields.showServer(second) { _ in throw ServerFormLoadError.credentialsUnavailable }
#expect(fields.password.isEmpty)
#expect(fields.address.isEmpty)
#expect(!fields.hasLoadedServer)
#expect(!fields.canSaveServer)
fields.reloadServer { _ in Self.form(password: "second password") }
fields.password = "unsaved second password"
fields.didSaveServer(first) { _ in
Issue.record("保存其他服务器不应装载当前草稿")
return Self.form()
}
#expect(fields.password == "unsaved second password")
fields.didSaveServer(second) { _ in Self.form(password: "saved second password") }
#expect(fields.password == "saved second password")
#expect(!fields.hasChanges)
}
@Test
func onlyAffectedReadOnlyServerReloadsAndFailedReloadClearsOldFields() {
let fields = ServerFormFields()
let id = NodeID(rawValue: "subscription")
fields.showServer(id) { _ in Self.form(isEditable: false) }
fields.subscriptionDidRefresh(affectedServers: [NodeID(rawValue: "other")]) { _ in
Issue.record("其他订阅不应触发装载")
return nil
}
#expect(fields.password == "pw")
fields.subscriptionDidRefresh(affectedServers: [id]) { _ in
throw ServerFormLoadError.credentialsUnavailable
}
#expect(fields.password.isEmpty)
#expect(fields.portText.isEmpty)
#expect(fields.pluginOptions.composedString == "")
#expect(!fields.hasLoadedServer)
#expect(fields.loadFailure == .credentialsUnavailable)
fields.updatePresentation(
ServerFormPresentation(isEditable: false, plugin: Self.form().plugin))
fields.subscriptionDidRefresh(affectedServers: [id]) { _ in
Self.form(isEditable: false, password: "new password")
}
#expect(fields.password == "new password")
#expect(fields.loadFailure == nil)
fields.showServer(NodeID(rawValue: "manual")) { _ in Self.form() }
fields.password = "manual draft"
fields.subscriptionDidRefresh(affectedServers: [fields.serverID!]) { _ in
Issue.record("手动草稿不应自动装载")
return nil
}
#expect(fields.password == "manual draft")
}
@Test
func presentationReadsNoSecretsAndReferencedManagedOptionsMustLoad() async throws {
let credentials = FormCredentialStore()
try await Self.withWorkflow(credentials: credentials) { workflow in
let program = ManagedPluginCatalog.plugins[0].program
let id = try await workflow.createServer(
ServerEditDraft(
address: "203.0.113.1", port: 8388, encryptionMethod: "aes-256-gcm",
password: "pw", remark: "服务器", plugin: .managed(program: program),
pluginOptions: "mode=websocket"), into: nil)
credentials.reads = 0
credentials.failReads = true
let presentation = try #require(workflow.serverFormPresentation(for: id))
#expect(presentation.isEditable)
#expect(presentation.plugin.optionsPresent)
#expect(presentation.plugin.options.isEmpty)
#expect(credentials.reads == 0)
#expect(throws: ServerFormLoadError.credentialsUnavailable) {
_ = try workflow.serverEditForm(for: id)
}
credentials.failReads = false
let form = try #require(try workflow.serverEditForm(for: id))
#expect(form.password == "pw")
#expect(form.plugin.options == "mode=websocket")
let optionsRef = try #require(
credentials.storage.storageSnapshot.first(where: { $0.value == "mode=websocket" })?.key)
try credentials.delete(CredentialReference(rawValue: optionsRef))
#expect(throws: ServerFormLoadError.credentialsUnavailable) {
_ = try workflow.serverEditForm(for: id)
}
}
}
@Test
func successfulRefreshReloadsSecretChangesDespiteEqualTreeAndFailureDoesNotReload() async throws {
let fetcher = FakeSubscriptionFetcher(behavior: .success(SubscriptionDocs.flat(serverCount: 1)))
let credentials = InMemoryCredentialStore()
try await Self.withWorkflow(credentials: credentials, fetcher: fetcher) { workflow in
let summary = try await workflow.createSubscription(urlString: "https://example.com/sub.json")
let server = try #require(workflow.tree.node(withID: summary.groupID)?.childNodes.first)
let fields = ServerFormFields()
fields.showServer(server.id, load: workflow.serverEditForm)
let oldTree = workflow.tree
var reloads = 0
let observation = workflow.subscriptionServerRefreshes.sink { affected in
fields.updatePresentation(workflow.serverFormPresentation(for: server.id))
fields.subscriptionDidRefresh(affectedServers: affected) { id in
reloads += 1
return try workflow.serverEditForm(for: id)
}
}
defer { observation.cancel() }
let original = try #require(
String(data: SubscriptionDocs.flat(serverCount: 1), encoding: .utf8))
let changed = original.replacingOccurrences(
of: "\"password\": \"pw\"", with: "\"password\": \"new password\"")
fetcher.setBehavior(.success(Data(changed.utf8)))
await workflow.refreshSubscription(summary.id)
#expect(workflow.tree == oldTree)
#expect(fields.password == "new password")
#expect(reloads == 1)
fetcher.setBehavior(.failure(.transport(detail: "fixture failure")))
await workflow.refreshSubscription(summary.id)
#expect(reloads == 1)
#expect(fields.password == "new password")
fetcher.setBehavior(.success(Data(changed.utf8)))
_ = try await workflow.createSubscription(urlString: "https://other.example/sub.json")
#expect(reloads == 1)
}
}
private static func withWorkflow(
credentials: CredentialStoring,
fetcher: SubscriptionFetching = FakeSubscriptionFetcher(behavior: .success(Data())),
_ body: (CatalogWorkflow) async throws -> Void
) async throws {
let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
defer { try? FileManager.default.removeItem(at: directory) }
let workflow = makeCatalogWorkflow(
coordinator: CatalogCommitCoordinator(
fileStore: CatalogFileStore(fileURL: directory.appendingPathComponent("catalog.json")),
runtime: FakeCatalogRuntime()),
credentials: credentials, subscriptionFetcher: fetcher)
try await body(workflow)
}
private static func form(isEditable: Bool = true, password: String = "pw") -> ServerEditForm {
ServerEditForm(
address: "203.0.113.1", port: 8388, encryptionMethod: "aes-256-gcm",
password: password, remark: "服务器",
plugin: PluginSectionState(
selection: .none, managed: ManagedPluginCatalog.plugins, provided: false,
optionsPresent: false, options: ""), isEditable: isEditable)
}
}
private final class FormCredentialStore: CredentialStoring {
let storage = InMemoryCredentialStore()
var reads = 0
var failReads = false
func secret(for reference: CredentialReference) throws -> String? {
reads += 1
if failReads { throw CredentialStoreError.secretNotUTF8 }
return try storage.secret(for: reference)
}
func save(_ secret: String, for reference: CredentialReference) throws {
try storage.save(secret, for: reference)
}
func delete(_ reference: CredentialReference) throws { try storage.delete(reference) }
}