field_ios

TeraLifecycleTests.swift (7526B)

---

 import Foundation
 import RadrootsKit
 @testable import TeraApp
 import XCTest
 
 final class TeraLifecycleTests: XCTestCase {
   func testDiagnosticsRejectPreEpochAndSignedOverflowTimestamps() async throws {
     let buffer = TeraDiagnosticsBuffer()
     for timestamp in [
       TimeInterval(-1),
       TimeInterval(Int64.max) / 1000 + 1,
     ] {
       try await buffer.record(
         RadrootsTelemetryEvent(
           name: "ios.lifecycle.invalid_clock",
           occurredAt: Date(timeIntervalSince1970: timestamp)
         )
       )
     }
 
     let records = await buffer.records()
     XCTAssertTrue(records.isEmpty)
   }
 
   func testBackgroundEventsCompleteExactlyOnceBeforeAndAfterAttachment() async {
     let router = TeraBackgroundEventRouter()
     let first = CompletionProbe()
 
     await router.handle(
       identifier: "org.radroots.tests.background.transfer",
       completion: TeraCompletionOnce { first.increment() }
     )
     XCTAssertEqual(first.value(), 0)
 
     await router.attach(identifier: "org.radroots.tests.background.transfer") { _, completion in
       completion()
       completion()
     }
     XCTAssertEqual(first.value(), 1)
 
     let mismatched = CompletionProbe()
     await router.handle(
       identifier: "org.radroots.tests.background.other",
       completion: TeraCompletionOnce { mismatched.increment() }
     )
     XCTAssertEqual(mismatched.value(), 1)
   }
 
   func testBackgroundEventQueueIsBoundedAndShutdownCompletesPendingEvents() async {
     let router = TeraBackgroundEventRouter()
     let probes = (0 ..< 12).map { _ in CompletionProbe() }
 
     for probe in probes {
       await router.handle(
         identifier: "org.radroots.tests.background.transfer",
         completion: TeraCompletionOnce { probe.increment() }
       )
     }
 
     XCTAssertEqual(probes.filter { $0.value() == 1 }.count, 4)
     await router.detachAndCompletePending()
     XCTAssertTrue(probes.allSatisfy { $0.value() == 1 })
   }
 
   func testLifecycleBridgeRunsRegisteredShutdownOnlyOnce() async {
     let bridge = TeraLifecycleBridge()
     let shutdowns = CompletionProbe()
     await bridge.register { shutdowns.increment(); return true }
 
     await bridge.requestShutdown()
     await bridge.requestShutdown()
 
     XCTAssertEqual(shutdowns.value(), 1)
   }
 
   func testProtectedDataMonitorReflectsTransitions() {
     let monitor = TeraProtectedDataMonitor(available: false)
     XCTAssertFalse(monitor.isAvailable())
 
     monitor.update(available: true)
 
     XCTAssertTrue(monitor.isAvailable())
   }
 
   func testDiagnosticsAreBoundedAndExcludeSensitiveRuntimeValues() async throws {
     let roots = try makeRoots()
     defer { try? FileManager.default.removeItem(at: roots.dataRoot.deletingLastPathComponent()) }
     let coordinator = TeraLifecycleCoordinator.testing(roots: roots, capacity: 16)
     let secret = "nsec1diagnosticcanary"
     let privateKey = String(repeating: "ab", count: 32)
     let privatePath = "/Users/private/radroots/private.json"
 
     for index in 0 ..< 40 {
       await coordinator.record(
         "ios.lifecycle.test_event",
         fields: [
           "attempt": "\(index)",
           "content": secret,
           "private_key": privateKey,
           "source": privatePath,
         ]
       )
     }
     let export = try await coordinator.prepareDiagnostics(
       snapshot: makeSnapshot(privateKey: privateKey),
       appVersion: "0.1.0-alpha",
       appBuild: "1",
       phase: "running"
     )
     let data = try Data(contentsOf: export.fileURL)
     let text = try XCTUnwrap(String(data: data, encoding: .utf8))
     let object = try XCTUnwrap(JSONSerialization.jsonObject(with: data) as? [String: Any])
     let records = try XCTUnwrap(object["records"] as? [[String: Any]])
 
     XCTAssertEqual(object["schema"] as? String, "radroots.ios.diagnostics.v1")
     XCTAssertEqual(records.count, 16)
     XCTAssertLessThanOrEqual(data.count, 256 * 1024)
     XCTAssertTrue(text.contains("ios.diagnostics.redacted"))
     XCTAssertTrue(records.allSatisfy { ($0["fields"] as? [String: String])?.isEmpty == true })
     XCTAssertFalse(text.contains(secret))
     XCTAssertFalse(text.contains(privateKey))
     XCTAssertFalse(text.contains(privatePath))
     XCTAssertFalse(text.contains("password@example.test"))
 
     await coordinator.releaseDiagnostics(export)
     XCTAssertFalse(FileManager.default.fileExists(atPath: export.fileURL.path))
   }
 
   func testActualExportExcludesUntrustedMetadataAndOrdinaryPrivateContent() async throws {
     let roots = try makeRoots()
     defer { try? FileManager.default.removeItem(at: roots.dataRoot.deletingLastPathComponent()) }
     let coordinator = TeraLifecycleCoordinator.testing(roots: roots)
     let canary = "plain post at 49.123456,-123.987654 Bearer CANARY /Users/private/file"
     await coordinator.record("private_event", fields: ["value": canary, "phase": canary])
     let export = try await coordinator.prepareDiagnostics(
       snapshot: makeSnapshot(privateKey: String(repeating: "ab", count: 32), metadata: canary),
       appVersion: canary, appBuild: canary, phase: canary
     )
     let data = try Data(contentsOf: export.fileURL)
     let text = try XCTUnwrap(String(data: data, encoding: .utf8))
     XCTAssertFalse(text.contains(canary))
     let document = try XCTUnwrap(JSONSerialization.jsonObject(with: data) as? [String: Any])
     for key in ["appVersion", "appBuild", "runtimeCrate", "runtimeVersion", "runtimePhase", "relayProfile", "relayState"] {
       XCTAssertEqual(document[key] as? String, "unavailable", key)
     }
     XCTAssertLessThanOrEqual(data.count, 256 * 1024)
     await coordinator.releaseDiagnostics(export)
     XCTAssertFalse(FileManager.default.fileExists(atPath: export.fileURL.path))
   }
 
   private func makeRoots() throws -> RadrootsAppleFileRoots {
     let base = FileManager.default.temporaryDirectory
       .appendingPathComponent(
         "radroots-ios-lifecycle-tests-\(UUID().uuidString)", isDirectory: true
       )
     return try RadrootsAppleFileRoots(
       appIdentifier: "org.radroots.tests",
       dataRoot: base.appendingPathComponent("data", isDirectory: true),
       cacheRoot: base.appendingPathComponent("cache", isDirectory: true),
       temporaryRoot: base.appendingPathComponent("temporary", isDirectory: true)
     )
   }
 
   private func makeSnapshot(privateKey: String, metadata: String? = nil) -> TeraRuntimeSnapshot {
     TeraRuntimeSnapshot(
       identity: TeraRuntimeIdentity(
         publicKeyHex: privateKey,
         hostSignerConfigured: true
       ),
       relay: TeraRelayStatus(
         profile: metadata ?? "simulator",
         state: metadata ?? "configured",
         readAvailability: "available",
         writeAvailability: "available",
         relays: [
           TeraRelayEndpointStatus(
             url: "wss://user:password@example.test",
             access: .readWrite,
             readState: "available",
             writeState: "available",
             readLastAttemptUnixMilliseconds: nil,
             writeLastAttemptUnixMilliseconds: nil,
             readNextAttemptUnixMilliseconds: nil,
             writeNextAttemptUnixMilliseconds: nil
           ),
         ]
       ),
       blossomConfiguration: nil,
       blossomEvidence: nil,
       crateName: metadata ?? "tera_ffi",
       crateVersion: metadata ?? "0.1.0-alpha",
       isClosed: false
     )
   }
 }
 
 private final class CompletionProbe: @unchecked Sendable {
   private let lock = NSLock()
   private var count = 0
 
   func increment() {
     lock.withLock { count += 1 }
   }
 
   func value() -> Int {
     lock.withLock { count }
   }
 }