field_ios

In-the-field app for Radroots on iOS
git clone https://radroots.dev/git/field_ios.git
Log | Files | Refs | README | LICENSE

TeraLifecycleTests.swift (8234B)


      1 import Foundation
      2 import RadrootsKit
      3 @testable import TeraApp
      4 import XCTest
      5 
      6 final class TeraLifecycleTests: XCTestCase {
      7   func testDiagnosticsRejectPreEpochAndSignedOverflowTimestamps() async throws {
      8     let buffer = TeraDiagnosticsBuffer()
      9     let preEpoch = try RadrootsTelemetryEvent(
     10       name: "ios.lifecycle.invalid_clock",
     11       occurredAt: Date(timeIntervalSince1970: -1)
     12     )
     13     await buffer.record(preEpoch)
     14 
     15     let overflow = Date(timeIntervalSince1970: TimeInterval(Int64.max) / 1000 + 1)
     16     XCTAssertThrowsError(try TeraClock.signedUnixMilliseconds(from: overflow)) { error in
     17       XCTAssertEqual(error as? TeraClockError, .overflow)
     18     }
     19     XCTAssertThrowsError(
     20       try RadrootsTelemetryEvent(name: "ios.lifecycle.invalid_clock", occurredAt: overflow)
     21     ) { error in
     22       XCTAssertEqual(error as? RadrootsTelemetryError, .invalidRequest)
     23     }
     24 
     25     let rejected = await buffer.records()
     26     XCTAssertTrue(rejected.isEmpty)
     27 
     28     for timestamp in [TimeInterval(0), TimeInterval(1.25)] {
     29       let event = try RadrootsTelemetryEvent(
     30         name: "ios.lifecycle.active",
     31         occurredAt: Date(timeIntervalSince1970: timestamp)
     32       )
     33       await buffer.record(event)
     34     }
     35 
     36     let records = await buffer.records()
     37     XCTAssertEqual(records.map(\.occurredAtUnixMilliseconds), [0, 1250])
     38   }
     39 
     40   func testBackgroundEventsCompleteExactlyOnceBeforeAndAfterAttachment() async {
     41     let router = TeraBackgroundEventRouter()
     42     let first = CompletionProbe()
     43 
     44     await router.handle(
     45       identifier: "org.radroots.tests.background.transfer",
     46       completion: TeraCompletionOnce { first.increment() }
     47     )
     48     XCTAssertEqual(first.value(), 0)
     49 
     50     await router.attach(identifier: "org.radroots.tests.background.transfer") { _, completion in
     51       completion()
     52       completion()
     53     }
     54     XCTAssertEqual(first.value(), 1)
     55 
     56     let mismatched = CompletionProbe()
     57     await router.handle(
     58       identifier: "org.radroots.tests.background.other",
     59       completion: TeraCompletionOnce { mismatched.increment() }
     60     )
     61     XCTAssertEqual(mismatched.value(), 1)
     62   }
     63 
     64   func testBackgroundEventQueueIsBoundedAndShutdownCompletesPendingEvents() async {
     65     let router = TeraBackgroundEventRouter()
     66     let probes = (0 ..< 12).map { _ in CompletionProbe() }
     67 
     68     for probe in probes {
     69       await router.handle(
     70         identifier: "org.radroots.tests.background.transfer",
     71         completion: TeraCompletionOnce { probe.increment() }
     72       )
     73     }
     74 
     75     XCTAssertEqual(probes.filter { $0.value() == 1 }.count, 4)
     76     await router.detachAndCompletePending()
     77     XCTAssertTrue(probes.allSatisfy { $0.value() == 1 })
     78   }
     79 
     80   func testLifecycleBridgeRunsRegisteredShutdownOnlyOnce() async {
     81     let bridge = TeraLifecycleBridge()
     82     let shutdowns = CompletionProbe()
     83     await bridge.register { shutdowns.increment(); return true }
     84 
     85     await bridge.requestShutdown()
     86     await bridge.requestShutdown()
     87 
     88     XCTAssertEqual(shutdowns.value(), 1)
     89   }
     90 
     91   func testProtectedDataMonitorReflectsTransitions() {
     92     let monitor = TeraProtectedDataMonitor(available: false)
     93     XCTAssertFalse(monitor.isAvailable())
     94 
     95     monitor.update(available: true)
     96 
     97     XCTAssertTrue(monitor.isAvailable())
     98   }
     99 
    100   func testDiagnosticsAreBoundedAndExcludeSensitiveRuntimeValues() async throws {
    101     let roots = try makeRoots()
    102     defer { try? FileManager.default.removeItem(at: roots.dataRoot.deletingLastPathComponent()) }
    103     let coordinator = TeraLifecycleCoordinator.testing(roots: roots, capacity: 16)
    104     let secret = "nsec1diagnosticcanary"
    105     let privateKey = String(repeating: "ab", count: 32)
    106     let privatePath = "/Users/private/radroots/private.json"
    107 
    108     for index in 0 ..< 40 {
    109       await coordinator.record(
    110         "ios.lifecycle.test_event",
    111         fields: [
    112           "attempt": "\(index)",
    113           "content": secret,
    114           "private_key": privateKey,
    115           "source": privatePath,
    116         ]
    117       )
    118     }
    119     let export = try await coordinator.prepareDiagnostics(
    120       snapshot: makeSnapshot(privateKey: privateKey),
    121       appVersion: "0.1.0-alpha",
    122       appBuild: "1",
    123       phase: "running"
    124     )
    125     let data = try Data(contentsOf: export.fileURL)
    126     let text = try XCTUnwrap(String(data: data, encoding: .utf8))
    127     let object = try XCTUnwrap(JSONSerialization.jsonObject(with: data) as? [String: Any])
    128     let records = try XCTUnwrap(object["records"] as? [[String: Any]])
    129 
    130     XCTAssertEqual(object["schema"] as? String, "radroots.ios.diagnostics.v1")
    131     XCTAssertEqual(records.count, 16)
    132     XCTAssertLessThanOrEqual(data.count, 256 * 1024)
    133     XCTAssertTrue(text.contains("ios.diagnostics.redacted"))
    134     XCTAssertTrue(records.allSatisfy { ($0["fields"] as? [String: String])?.isEmpty == true })
    135     XCTAssertFalse(text.contains(secret))
    136     XCTAssertFalse(text.contains(privateKey))
    137     XCTAssertFalse(text.contains(privatePath))
    138     XCTAssertFalse(text.contains("password@example.test"))
    139 
    140     await coordinator.releaseDiagnostics(export)
    141     XCTAssertFalse(FileManager.default.fileExists(atPath: export.fileURL.path))
    142   }
    143 
    144   func testActualExportExcludesUntrustedMetadataAndOrdinaryPrivateContent() async throws {
    145     let roots = try makeRoots()
    146     defer { try? FileManager.default.removeItem(at: roots.dataRoot.deletingLastPathComponent()) }
    147     let coordinator = TeraLifecycleCoordinator.testing(roots: roots)
    148     let canary = "plain post at 49.123456,-123.987654 Bearer CANARY /Users/private/file"
    149     await coordinator.record("private_event", fields: ["value": canary, "phase": canary])
    150     let export = try await coordinator.prepareDiagnostics(
    151       snapshot: makeSnapshot(privateKey: String(repeating: "ab", count: 32), metadata: canary),
    152       appVersion: canary, appBuild: canary, phase: canary
    153     )
    154     let data = try Data(contentsOf: export.fileURL)
    155     let text = try XCTUnwrap(String(data: data, encoding: .utf8))
    156     XCTAssertFalse(text.contains(canary))
    157     let document = try XCTUnwrap(JSONSerialization.jsonObject(with: data) as? [String: Any])
    158     for key in ["appVersion", "appBuild", "runtimeCrate", "runtimeVersion", "runtimePhase", "relayProfile", "relayState"] {
    159       XCTAssertEqual(document[key] as? String, "unavailable", key)
    160     }
    161     XCTAssertLessThanOrEqual(data.count, 256 * 1024)
    162     await coordinator.releaseDiagnostics(export)
    163     XCTAssertFalse(FileManager.default.fileExists(atPath: export.fileURL.path))
    164   }
    165 
    166   private func makeRoots() throws -> RadrootsAppleFileRoots {
    167     let base = FileManager.default.temporaryDirectory
    168       .appendingPathComponent(
    169         "radroots-ios-lifecycle-tests-\(UUID().uuidString)", isDirectory: true
    170       )
    171     return try RadrootsAppleFileRoots(
    172       appIdentifier: "org.radroots.tests",
    173       dataRoot: base.appendingPathComponent("data", isDirectory: true),
    174       cacheRoot: base.appendingPathComponent("cache", isDirectory: true),
    175       temporaryRoot: base.appendingPathComponent("temporary", isDirectory: true)
    176     )
    177   }
    178 
    179   private func makeSnapshot(privateKey: String, metadata: String? = nil) -> TeraRuntimeSnapshot {
    180     TeraRuntimeSnapshot(
    181       identity: TeraRuntimeIdentity(
    182         publicKeyHex: privateKey,
    183         hostSignerConfigured: true
    184       ),
    185       relay: TeraRelayStatus(
    186         profile: metadata ?? "simulator",
    187         state: metadata ?? "configured",
    188         readAvailability: "available",
    189         writeAvailability: "available",
    190         relays: [
    191           TeraRelayEndpointStatus(
    192             url: "wss://user:password@example.test",
    193             access: .readWrite,
    194             readState: "available",
    195             writeState: "available",
    196             readLastAttemptUnixMilliseconds: nil,
    197             writeLastAttemptUnixMilliseconds: nil,
    198             readNextAttemptUnixMilliseconds: nil,
    199             writeNextAttemptUnixMilliseconds: nil
    200           ),
    201         ]
    202       ),
    203       blossomConfiguration: nil,
    204       blossomEvidence: nil,
    205       crateName: metadata ?? "tera_ffi",
    206       crateVersion: metadata ?? "0.1.0-alpha",
    207       isClosed: false
    208     )
    209   }
    210 }
    211 
    212 private final class CompletionProbe: @unchecked Sendable {
    213   private let lock = NSLock()
    214   private var count = 0
    215 
    216   func increment() {
    217     lock.withLock { count += 1 }
    218   }
    219 
    220   func value() -> Int {
    221     lock.withLock { count }
    222   }
    223 }