refactor(tests): dedupe ios gateway and deeplink fixtures

apps/ios/Tests/DeepLinkParserTests.swift

@@ -10,6 +10,28 @@ private func setupCode(from payload: String) -> String {
         .replacingOccurrences(of: "=", with: "")
 }
 
+private func agentAction(
+    message: String,
+    sessionKey: String? = nil,
+    thinking: String? = nil,
+    deliver: Bool = false,
+    to: String? = nil,
+    channel: String? = nil,
+    timeoutSeconds: Int? = nil,
+    key: String? = nil) -> DeepLinkRoute
+{
+    .agent(
+        .init(
+            message: message,
+            sessionKey: sessionKey,
+            thinking: thinking,
+            deliver: deliver,
+            to: to,
+            channel: channel,
+            timeoutSeconds: timeoutSeconds,
+            key: key))
+}
+
 @Suite struct DeepLinkParserTests {
     @Test func parseRejectsUnknownHost() {
         let url = URL(string: "openclaw://nope?message=hi")!
@@ -18,15 +40,7 @@ private func setupCode(from payload: String) -> String {
 
     @Test func parseHostIsCaseInsensitive() {
         let url = URL(string: "openclaw://AGENT?message=Hello")!
-        #expect(DeepLinkParser.parse(url) == .agent(.init(
-            message: "Hello",
-            sessionKey: nil,
-            thinking: nil,
-            deliver: false,
-            to: nil,
-            channel: nil,
-            timeoutSeconds: nil,
-            key: nil)))
+        #expect(DeepLinkParser.parse(url) == agentAction(message: "Hello"))
     }
 
     @Test func parseRejectsNonOpenClawScheme() {
@@ -42,47 +56,29 @@ private func setupCode(from payload: String) -> String {
     @Test func parseAgentLinkParsesCommonFields() {
         let url =
             URL(string: "openclaw://agent?message=Hello&deliver=1&sessionKey=node-test&thinking=low&timeoutSeconds=30")!
-        #expect(
-            DeepLinkParser.parse(url) == .agent(
-                .init(
-                    message: "Hello",
-                    sessionKey: "node-test",
-                    thinking: "low",
-                    deliver: true,
-                    to: nil,
-                    channel: nil,
-                    timeoutSeconds: 30,
-                    key: nil)))
+        #expect(DeepLinkParser.parse(url) == agentAction(
+            message: "Hello",
+            sessionKey: "node-test",
+            thinking: "low",
+            deliver: true,
+            timeoutSeconds: 30))
     }
 
     @Test func parseAgentLinkParsesTargetRoutingFields() {
         let url =
             URL(
                 string: "openclaw://agent?message=Hello%20World&deliver=1&to=%2B15551234567&channel=whatsapp&key=secret")!
-        #expect(
-            DeepLinkParser.parse(url) == .agent(
-                .init(
-                    message: "Hello World",
-                    sessionKey: nil,
-                    thinking: nil,
-                    deliver: true,
-                    to: "+15551234567",
-                    channel: "whatsapp",
-                    timeoutSeconds: nil,
-                    key: "secret")))
+        #expect(DeepLinkParser.parse(url) == agentAction(
+            message: "Hello World",
+            deliver: true,
+            to: "+15551234567",
+            channel: "whatsapp",
+            key: "secret"))
     }
 
     @Test func parseRejectsNegativeTimeoutSeconds() {
         let url = URL(string: "openclaw://agent?message=Hello&timeoutSeconds=-1")!
-        #expect(DeepLinkParser.parse(url) == .agent(.init(
-            message: "Hello",
-            sessionKey: nil,
-            thinking: nil,
-            deliver: false,
-            to: nil,
-            channel: nil,
-            timeoutSeconds: nil,
-            key: nil)))
+        #expect(DeepLinkParser.parse(url) == agentAction(message: "Hello"))
     }
 
     @Test func parseGatewayLinkParsesCommonFields() {

apps/ios/Tests/GatewayConnectionSecurityTests.swift

@@ -5,6 +5,32 @@ import Testing
 @testable import OpenClaw
 
 @Suite(.serialized) struct GatewayConnectionSecurityTests {
+    private func makeController() -> GatewayConnectionController {
+        GatewayConnectionController(appModel: NodeAppModel(), startDiscovery: false)
+    }
+
+    private func makeDiscoveredGateway(
+        stableID: String,
+        lanHost: String?,
+        tailnetDns: String?,
+        gatewayPort: Int?,
+        fingerprint: String?) -> GatewayDiscoveryModel.DiscoveredGateway
+    {
+        let endpoint: NWEndpoint = .service(name: "Test", type: "_openclaw-gw._tcp", domain: "local.", interface: nil)
+        return GatewayDiscoveryModel.DiscoveredGateway(
+            name: "Test",
+            endpoint: endpoint,
+            stableID: stableID,
+            debugID: "debug",
+            lanHost: lanHost,
+            tailnetDns: tailnetDns,
+            gatewayPort: gatewayPort,
+            canvasPort: nil,
+            tlsEnabled: true,
+            tlsFingerprintSha256: fingerprint,
+            cliPath: nil)
+    }
+
     private func clearTLSFingerprint(stableID: String) {
         let suite = UserDefaults(suiteName: "ai.openclaw.shared") ?? .standard
         suite.removeObject(forKey: "gateway.tls.\(stableID)")
@@ -17,22 +43,13 @@ import Testing
 
         GatewayTLSStore.saveFingerprint("11", stableID: stableID)
 
-        let endpoint: NWEndpoint = .service(name: "Test", type: "_openclaw-gw._tcp", domain: "local.", interface: nil)
-        let gateway = GatewayDiscoveryModel.DiscoveredGateway(
-            name: "Test",
-            endpoint: endpoint,
+        let gateway = makeDiscoveredGateway(
             stableID: stableID,
-            debugID: "debug",
             lanHost: "evil.example.com",
             tailnetDns: "evil.example.com",
             gatewayPort: 12345,
-            canvasPort: nil,
-            tlsEnabled: true,
-            tlsFingerprintSha256: "22",
-            cliPath: nil)
-
-        let appModel = NodeAppModel()
-        let controller = GatewayConnectionController(appModel: appModel, startDiscovery: false)
+            fingerprint: "22")
+        let controller = makeController()
 
         let params = controller._test_resolveDiscoveredTLSParams(gateway: gateway, allowTOFU: true)
         #expect(params?.expectedFingerprint == "11")
@@ -44,22 +61,13 @@ import Testing
         defer { clearTLSFingerprint(stableID: stableID) }
         clearTLSFingerprint(stableID: stableID)
 
-        let endpoint: NWEndpoint = .service(name: "Test", type: "_openclaw-gw._tcp", domain: "local.", interface: nil)
-        let gateway = GatewayDiscoveryModel.DiscoveredGateway(
-            name: "Test",
-            endpoint: endpoint,
+        let gateway = makeDiscoveredGateway(
             stableID: stableID,
-            debugID: "debug",
             lanHost: nil,
             tailnetDns: nil,
             gatewayPort: nil,
-            canvasPort: nil,
-            tlsEnabled: true,
-            tlsFingerprintSha256: "22",
-            cliPath: nil)
-
-        let appModel = NodeAppModel()
-        let controller = GatewayConnectionController(appModel: appModel, startDiscovery: false)
+            fingerprint: "22")
+        let controller = makeController()
 
         let params = controller._test_resolveDiscoveredTLSParams(gateway: gateway, allowTOFU: true)
         #expect(params?.expectedFingerprint == nil)
@@ -82,22 +90,13 @@ import Testing
         defaults.removeObject(forKey: "gateway.preferredStableID")
         defaults.set(stableID, forKey: "gateway.lastDiscoveredStableID")
 
-        let endpoint: NWEndpoint = .service(name: "Test", type: "_openclaw-gw._tcp", domain: "local.", interface: nil)
-        let gateway = GatewayDiscoveryModel.DiscoveredGateway(
-            name: "Test",
-            endpoint: endpoint,
+        let gateway = makeDiscoveredGateway(
             stableID: stableID,
-            debugID: "debug",
             lanHost: "test.local",
             tailnetDns: nil,
             gatewayPort: 18789,
-            canvasPort: nil,
-            tlsEnabled: true,
-            tlsFingerprintSha256: nil,
-            cliPath: nil)
-
-        let appModel = NodeAppModel()
-        let controller = GatewayConnectionController(appModel: appModel, startDiscovery: false)
+            fingerprint: nil)
+        let controller = makeController()
         controller._test_setGateways([gateway])
         controller._test_triggerAutoConnect()
 
@@ -105,8 +104,7 @@ import Testing
     }
 
     @Test @MainActor func manualConnectionsForceTLSForNonLoopbackHosts() async {
-        let appModel = NodeAppModel()
-        let controller = GatewayConnectionController(appModel: appModel, startDiscovery: false)
+        let controller = makeController()
 
         #expect(controller._test_resolveManualUseTLS(host: "gateway.example.com", useTLS: false) == true)
         #expect(controller._test_resolveManualUseTLS(host: "openclaw.local", useTLS: false) == true)
@@ -121,8 +119,7 @@ import Testing
     }
 
     @Test @MainActor func manualDefaultPortUses443OnlyForTailnetTLSHosts() async {
-        let appModel = NodeAppModel()
-        let controller = GatewayConnectionController(appModel: appModel, startDiscovery: false)
+        let controller = makeController()
 
         #expect(controller._test_resolveManualPort(host: "gateway.example.com", port: 0, useTLS: true) == 18789)
         #expect(controller._test_resolveManualPort(host: "device.sample.ts.net", port: 0, useTLS: true) == 443)

apps/ios/Tests/GatewaySettingsStoreTests.swift

@@ -14,6 +14,19 @@ private let instanceIdEntry = KeychainEntry(service: nodeService, account: "inst
 private let preferredGatewayEntry = KeychainEntry(service: gatewayService, account: "preferredStableID")
 private let lastGatewayEntry = KeychainEntry(service: gatewayService, account: "lastDiscoveredStableID")
 private let talkAcmeProviderEntry = KeychainEntry(service: talkService, account: "provider.apiKey.acme")
+private let bootstrapDefaultsKeys = [
+    "node.instanceId",
+    "gateway.preferredStableID",
+    "gateway.lastDiscoveredStableID",
+]
+private let bootstrapKeychainEntries = [instanceIdEntry, preferredGatewayEntry, lastGatewayEntry]
+private let lastGatewayDefaultsKeys = [
+    "gateway.last.kind",
+    "gateway.last.host",
+    "gateway.last.port",
+    "gateway.last.tls",
+    "gateway.last.stableID",
+]
 
 private func snapshotDefaults(_ keys: [String]) -> [String: Any?] {
     let defaults = UserDefaults.standard
@@ -61,142 +74,112 @@ private func restoreKeychain(_ snapshot: [KeychainEntry: String?]) {
     applyKeychain(snapshot)
 }
 
+private func withBootstrapSnapshots(_ body: () -> Void) {
+    let defaultsSnapshot = snapshotDefaults(bootstrapDefaultsKeys)
+    let keychainSnapshot = snapshotKeychain(bootstrapKeychainEntries)
+    defer {
+        restoreDefaults(defaultsSnapshot)
+        restoreKeychain(keychainSnapshot)
+    }
+    body()
+}
+
+private func withLastGatewayDefaultsSnapshot(_ body: () -> Void) {
+    let snapshot = snapshotDefaults(lastGatewayDefaultsKeys)
+    defer { restoreDefaults(snapshot) }
+    body()
+}
+
 @Suite(.serialized) struct GatewaySettingsStoreTests {
     @Test func bootstrapCopiesDefaultsToKeychainWhenMissing() {
-        let defaultsKeys = [
-            "node.instanceId",
-            "gateway.preferredStableID",
-            "gateway.lastDiscoveredStableID",
-        ]
-        let entries = [instanceIdEntry, preferredGatewayEntry, lastGatewayEntry]
-        let defaultsSnapshot = snapshotDefaults(defaultsKeys)
-        let keychainSnapshot = snapshotKeychain(entries)
-        defer {
-            restoreDefaults(defaultsSnapshot)
-            restoreKeychain(keychainSnapshot)
+        withBootstrapSnapshots {
+            applyDefaults([
+                "node.instanceId": "node-test",
+                "gateway.preferredStableID": "preferred-test",
+                "gateway.lastDiscoveredStableID": "last-test",
+            ])
+            applyKeychain([
+                instanceIdEntry: nil,
+                preferredGatewayEntry: nil,
+                lastGatewayEntry: nil,
+            ])
+
+            GatewaySettingsStore.bootstrapPersistence()
+
+            #expect(KeychainStore.loadString(service: nodeService, account: "instanceId") == "node-test")
+            #expect(KeychainStore.loadString(service: gatewayService, account: "preferredStableID") == "preferred-test")
+            #expect(KeychainStore.loadString(service: gatewayService, account: "lastDiscoveredStableID") == "last-test")
         }
-
-        applyDefaults([
-            "node.instanceId": "node-test",
-            "gateway.preferredStableID": "preferred-test",
-            "gateway.lastDiscoveredStableID": "last-test",
-        ])
-        applyKeychain([
-            instanceIdEntry: nil,
-            preferredGatewayEntry: nil,
-            lastGatewayEntry: nil,
-        ])
-
-        GatewaySettingsStore.bootstrapPersistence()
-
-        #expect(KeychainStore.loadString(service: nodeService, account: "instanceId") == "node-test")
-        #expect(KeychainStore.loadString(service: gatewayService, account: "preferredStableID") == "preferred-test")
-        #expect(KeychainStore.loadString(service: gatewayService, account: "lastDiscoveredStableID") == "last-test")
     }
 
     @Test func bootstrapCopiesKeychainToDefaultsWhenMissing() {
-        let defaultsKeys = [
-            "node.instanceId",
-            "gateway.preferredStableID",
-            "gateway.lastDiscoveredStableID",
-        ]
-        let entries = [instanceIdEntry, preferredGatewayEntry, lastGatewayEntry]
-        let defaultsSnapshot = snapshotDefaults(defaultsKeys)
-        let keychainSnapshot = snapshotKeychain(entries)
-        defer {
-            restoreDefaults(defaultsSnapshot)
-            restoreKeychain(keychainSnapshot)
+        withBootstrapSnapshots {
+            applyDefaults([
+                "node.instanceId": nil,
+                "gateway.preferredStableID": nil,
+                "gateway.lastDiscoveredStableID": nil,
+            ])
+            applyKeychain([
+                instanceIdEntry: "node-from-keychain",
+                preferredGatewayEntry: "preferred-from-keychain",
+                lastGatewayEntry: "last-from-keychain",
+            ])
+
+            GatewaySettingsStore.bootstrapPersistence()
+
+            let defaults = UserDefaults.standard
+            #expect(defaults.string(forKey: "node.instanceId") == "node-from-keychain")
+            #expect(defaults.string(forKey: "gateway.preferredStableID") == "preferred-from-keychain")
+            #expect(defaults.string(forKey: "gateway.lastDiscoveredStableID") == "last-from-keychain")
         }
-
-        applyDefaults([
-            "node.instanceId": nil,
-            "gateway.preferredStableID": nil,
-            "gateway.lastDiscoveredStableID": nil,
-        ])
-        applyKeychain([
-            instanceIdEntry: "node-from-keychain",
-            preferredGatewayEntry: "preferred-from-keychain",
-            lastGatewayEntry: "last-from-keychain",
-        ])
-
-        GatewaySettingsStore.bootstrapPersistence()
-
-        let defaults = UserDefaults.standard
-        #expect(defaults.string(forKey: "node.instanceId") == "node-from-keychain")
-        #expect(defaults.string(forKey: "gateway.preferredStableID") == "preferred-from-keychain")
-        #expect(defaults.string(forKey: "gateway.lastDiscoveredStableID") == "last-from-keychain")
     }
 
     @Test func lastGateway_manualRoundTrip() {
-        let keys = [
-            "gateway.last.kind",
-            "gateway.last.host",
-            "gateway.last.port",
-            "gateway.last.tls",
-            "gateway.last.stableID",
-        ]
-        let snapshot = snapshotDefaults(keys)
-        defer { restoreDefaults(snapshot) }
+        withLastGatewayDefaultsSnapshot {
+            GatewaySettingsStore.saveLastGatewayConnectionManual(
+                host: "example.com",
+                port: 443,
+                useTLS: true,
+                stableID: "manual|example.com|443")
 
-        GatewaySettingsStore.saveLastGatewayConnectionManual(
-            host: "example.com",
-            port: 443,
-            useTLS: true,
-            stableID: "manual|example.com|443")
-
-        let loaded = GatewaySettingsStore.loadLastGatewayConnection()
-        #expect(loaded == .manual(host: "example.com", port: 443, useTLS: true, stableID: "manual|example.com|443"))
+            let loaded = GatewaySettingsStore.loadLastGatewayConnection()
+            #expect(loaded == .manual(host: "example.com", port: 443, useTLS: true, stableID: "manual|example.com|443"))
+        }
     }
 
     @Test func lastGateway_discoveredDoesNotPersistResolvedHostPort() {
-        let keys = [
-            "gateway.last.kind",
-            "gateway.last.host",
-            "gateway.last.port",
-            "gateway.last.tls",
-            "gateway.last.stableID",
-        ]
-        let snapshot = snapshotDefaults(keys)
-        defer { restoreDefaults(snapshot) }
+        withLastGatewayDefaultsSnapshot {
+            // Simulate a prior manual record that included host/port.
+            applyDefaults([
+                "gateway.last.host": "10.0.0.99",
+                "gateway.last.port": 18789,
+                "gateway.last.tls": true,
+                "gateway.last.stableID": "manual|10.0.0.99|18789",
+                "gateway.last.kind": "manual",
+            ])
 
-        // Simulate a prior manual record that included host/port.
-        applyDefaults([
-            "gateway.last.host": "10.0.0.99",
-            "gateway.last.port": 18789,
-            "gateway.last.tls": true,
-            "gateway.last.stableID": "manual|10.0.0.99|18789",
-            "gateway.last.kind": "manual",
-        ])
+            GatewaySettingsStore.saveLastGatewayConnectionDiscovered(stableID: "gw|abc", useTLS: true)
 
-        GatewaySettingsStore.saveLastGatewayConnectionDiscovered(stableID: "gw|abc", useTLS: true)
-
-        let defaults = UserDefaults.standard
-        #expect(defaults.object(forKey: "gateway.last.host") == nil)
-        #expect(defaults.object(forKey: "gateway.last.port") == nil)
-        #expect(GatewaySettingsStore.loadLastGatewayConnection() == .discovered(stableID: "gw|abc", useTLS: true))
+            let defaults = UserDefaults.standard
+            #expect(defaults.object(forKey: "gateway.last.host") == nil)
+            #expect(defaults.object(forKey: "gateway.last.port") == nil)
+            #expect(GatewaySettingsStore.loadLastGatewayConnection() == .discovered(stableID: "gw|abc", useTLS: true))
+        }
     }
 
     @Test func lastGateway_backCompat_manualLoadsWhenKindMissing() {
-        let keys = [
-            "gateway.last.kind",
-            "gateway.last.host",
-            "gateway.last.port",
-            "gateway.last.tls",
-            "gateway.last.stableID",
-        ]
-        let snapshot = snapshotDefaults(keys)
-        defer { restoreDefaults(snapshot) }
+        withLastGatewayDefaultsSnapshot {
+            applyDefaults([
+                "gateway.last.kind": nil,
+                "gateway.last.host": "example.org",
+                "gateway.last.port": 18789,
+                "gateway.last.tls": false,
+                "gateway.last.stableID": "manual|example.org|18789",
+            ])
 
-        applyDefaults([
-            "gateway.last.kind": nil,
-            "gateway.last.host": "example.org",
-            "gateway.last.port": 18789,
-            "gateway.last.tls": false,
-            "gateway.last.stableID": "manual|example.org|18789",
-        ])
-
-        let loaded = GatewaySettingsStore.loadLastGatewayConnection()
-        #expect(loaded == .manual(host: "example.org", port: 18789, useTLS: false, stableID: "manual|example.org|18789"))
+            let loaded = GatewaySettingsStore.loadLastGatewayConnection()
+            #expect(loaded == .manual(host: "example.org", port: 18789, useTLS: false, stableID: "manual|example.org|18789"))
+        }
     }
 
     @Test func talkProviderApiKey_genericRoundTrip() {

apps/ios/Tests/VoiceWakeManagerExtractCommandTests.swift

@@ -3,6 +3,19 @@ import SwabbleKit
 import Testing
 @testable import OpenClaw
 
+private let openclawTranscript = "hey openclaw do thing"
+
+private func openclawSegments(postTriggerStart: TimeInterval) -> [WakeWordSegment] {
+    makeSegments(
+        transcript: openclawTranscript,
+        words: [
+            ("hey", 0.0, 0.1),
+            ("openclaw", 0.2, 0.1),
+            ("do", postTriggerStart, 0.1),
+            ("thing", postTriggerStart + 0.2, 0.1),
+        ])
+}
+
 @Suite struct VoiceWakeManagerExtractCommandTests {
     @Test func extractCommandReturnsNilWhenNoTriggerFound() {
         let transcript = "hello world"
@@ -13,17 +26,9 @@ import Testing
     }
 
     @Test func extractCommandTrimsTokensAndResult() {
-        let transcript = "hey openclaw do thing"
-        let segments = makeSegments(
-            transcript: transcript,
-            words: [
-                ("hey", 0.0, 0.1),
-                ("openclaw", 0.2, 0.1),
-                ("do", 0.9, 0.1),
-                ("thing", 1.1, 0.1),
-            ])
+        let segments = openclawSegments(postTriggerStart: 0.9)
         let cmd = VoiceWakeManager.extractCommand(
-            from: transcript,
+            from: openclawTranscript,
             segments: segments,
             triggers: ["  openclaw  "],
             minPostTriggerGap: 0.3)
@@ -31,17 +36,9 @@ import Testing
     }
 
     @Test func extractCommandReturnsNilWhenGapTooShort() {
-        let transcript = "hey openclaw do thing"
-        let segments = makeSegments(
-            transcript: transcript,
-            words: [
-                ("hey", 0.0, 0.1),
-                ("openclaw", 0.2, 0.1),
-                ("do", 0.35, 0.1),
-                ("thing", 0.5, 0.1),
-            ])
+        let segments = openclawSegments(postTriggerStart: 0.35)
         let cmd = VoiceWakeManager.extractCommand(
-            from: transcript,
+            from: openclawTranscript,
             segments: segments,
             triggers: ["openclaw"],
             minPostTriggerGap: 0.3)
@@ -57,17 +54,9 @@ import Testing
     }
 
     @Test func extractCommandIgnoresEmptyTriggers() {
-        let transcript = "hey openclaw do thing"
-        let segments = makeSegments(
-            transcript: transcript,
-            words: [
-                ("hey", 0.0, 0.1),
-                ("openclaw", 0.2, 0.1),
-                ("do", 0.9, 0.1),
-                ("thing", 1.1, 0.1),
-            ])
+        let segments = openclawSegments(postTriggerStart: 0.9)
         let cmd = VoiceWakeManager.extractCommand(
-            from: transcript,
+            from: openclawTranscript,
             segments: segments,
             triggers: ["", "   ", "openclaw"],
             minPostTriggerGap: 0.3)