field_ios

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

TeraHistoricalOwnerFixture.swift (6580B)


      1 import CryptoKit
      2 import Foundation
      3 import RadrootsKit
      4 @testable import TeraApp
      5 import TeraKitBindings
      6 import XCTest
      7 
      8 @MainActor
      9 struct TeraHistoricalOwnerFixture {
     10   let root: URL
     11   let host: [String: Any]
     12   let rust: [String: Any]
     13   let native: [String: Any]
     14 
     15   init() throws {
     16     let source = try XCTUnwrap(Bundle(for: TeraHistoricalOwnerTests.self).url(forResource: "legacy_upgrade_v1", withExtension: nil))
     17     let manifest = try Self.object(source.appendingPathComponent("manifest.json"))
     18     XCTAssertEqual(manifest["state"] as? String, "HISTORICAL_WRITER_ADMITTED_CURRENT_READERS_PENDING")
     19     root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString, isDirectory: true)
     20     try FileManager.default.createDirectory(at: root, withIntermediateDirectories: false)
     21     for (relative, hash) in try XCTUnwrap(manifest["files"] as? [String: String]) {
     22       let components = relative.split(separator: "/", omittingEmptySubsequences: false)
     23       guard !relative.hasPrefix("/"), !components.isEmpty,
     24         components.allSatisfy({ !$0.isEmpty && $0 != "." && $0 != ".." })
     25       else {
     26         throw CocoaError(.fileReadInvalidFileName)
     27       }
     28       var input = source
     29       for component in components {
     30         input.appendPathComponent(String(component))
     31         guard try input.resourceValues(forKeys: [.isSymbolicLinkKey]).isSymbolicLink == false else {
     32           throw CocoaError(.fileReadInvalidFileName)
     33         }
     34       }
     35       let output = root.appendingPathComponent(relative)
     36       let bytes = try Data(contentsOf: input)
     37       XCTAssertEqual(Self.hash(bytes), hash)
     38       try FileManager.default.createDirectory(at: output.deletingLastPathComponent(), withIntermediateDirectories: true)
     39       try bytes.write(to: output, options: [.atomic])
     40     }
     41     for name in ["data", "cache", "tmp", "logs"] {
     42       try FileManager.default.createDirectory(at: root.appendingPathComponent(name), withIntermediateDirectories: true)
     43     }
     44     host = try Self.object(root.appendingPathComponent("host-metadata.json"))
     45     rust = try Self.object(root.appendingPathComponent("rust-metadata.json"))
     46     native = try Self.object(root.appendingPathComponent("native-metadata.json"))
     47   }
     48 
     49   func text(_ object: [String: Any], _ key: String) throws -> String {
     50     try XCTUnwrap(object[key] as? String)
     51   }
     52 
     53   func number(_ object: [String: Any], _ key: String) throws -> UInt64 {
     54     try XCTUnwrap(object[key] as? NSNumber).uint64Value
     55   }
     56 
     57   var publicKey: String {
     58     get throws { try text(rust, "public_key") }
     59   }
     60 
     61   var generation: String {
     62     get throws { try text(host, "source_generation") }
     63   }
     64 
     65   func roots() throws -> RadrootsAppleFileRoots {
     66     let base = try RadrootsAppleFileRoots(appIdentifier: "dev.local.radroots",
     67                                           dataRoot: root.appendingPathComponent("data"), cacheRoot: root.appendingPathComponent("cache"),
     68                                           temporaryRoot: root.appendingPathComponent("tmp"), logsRoot: root.appendingPathComponent("logs"))
     69     return try TeraDurableMediaRoots.selectingStaging(in: base)
     70   }
     71 
     72   func blob() throws -> RadrootsStagedBlobReference {
     73     let hash = try text(host, "media_sha256")
     74     let count = try XCTUnwrap(Int(exactly: number(host, "media_bytes")))
     75     return try RadrootsStagedBlobReference(blobID: hash, sizeBytes: count, mediaType: "image/png", filenameHint: hash + ".png")
     76   }
     77 
     78   func bootstrap() throws -> TeraConfigurationBootstrap {
     79     try TeraConfigurationBootstrap(runtimeMode: "production", relayURLs: ["wss://relay-one.example", "wss://relay-two.example"],
     80                                    blossomOrigins: ["https://blossom.example"], keychainServicePrefix: text(host, "keychain_service_prefix"),
     81                                    bundleIdentifier: text(host, "bundle_identifier"),
     82                                    appMetadata: TeraRuntimeAppMetadata(bundleIdentifier: text(host, "bundle_identifier"), version: "1.0.0-alpha", buildNumber: "1", buildSHA: nil))
     83   }
     84 
     85   func runtime() async throws -> TeraRuntime {
     86     try await TeraRuntime.open(applicationSupportDirectory: roots().dataRoot.path, publicKeyHex: publicKey,
     87                                sourceGenerationHex: generation, sourceGenerationCreatedAtUnixMs: number(host, "generation_created_at_unix_ms"), protectedData: .available)
     88   }
     89 
     90   func assertStatuses(_ runtime: TeraRuntime) async throws {
     91     let statuses = try XCTUnwrap(rust["drafts"] as? [[String: Any]])
     92     XCTAssertEqual(statuses.count, 106)
     93     for expected in statuses {
     94       let actual = try await runtime.phase1DraftStatus(draftId: text(expected, "draft_id"))
     95       XCTAssertEqual(actual.authorPublicKey, try publicKey)
     96       XCTAssertEqual(actual.revision, try number(expected, "revision"))
     97       XCTAssertEqual(actual.cardId, try text(expected, "card_id"))
     98       XCTAssertEqual(actual.operationId, expected["operation_id"] as? String)
     99       XCTAssertEqual(actual.createdAtUnixMs, try number(expected, "created_at_unix_ms"))
    100       XCTAssertEqual(actual.updatedAtUnixMs, try number(expected, "updated_at_unix_ms"))
    101       XCTAssertEqual(actual.state, try XCTUnwrap(Self.states[text(expected, "state")]))
    102       if let settled = expected["settlement"] as? [String: Any] {
    103         let actual = try XCTUnwrap(actual.settlement)
    104         XCTAssertEqual(UInt64(actual.signed), try number(settled, "signed"))
    105         XCTAssertEqual(UInt64(actual.admitted), try number(settled, "admitted"))
    106         XCTAssertEqual(UInt64(actual.pending), try number(settled, "pending"))
    107         XCTAssertEqual(UInt64(actual.deliveryPlans), try number(settled, "delivery_plans"))
    108         XCTAssertEqual(UInt64(actual.deliverySatisfied), try number(settled, "delivery_satisfied"))
    109       } else {
    110         XCTAssertNil(actual.settlement)
    111       }
    112     }
    113   }
    114 
    115   private static let states: [String: FfiOutboxState] = [
    116     "Draft": .draft, "MediaPreparing": .mediaPreparing, "MediaUploading": .mediaUploading,
    117     "ReadyToSign": .readyToSign, "Signing": .signing, "Signed": .signed, "Queued": .queued,
    118     "Delivering": .delivering, "PartiallyDelivered": .partiallyDelivered, "Retryable": .retryable,
    119     "Terminal": .terminal, "Cancelled": .cancelled, "Complete": .complete,
    120   ]
    121 
    122   static func object(_ path: URL) throws -> [String: Any] {
    123     try XCTUnwrap(JSONSerialization.jsonObject(with: Data(contentsOf: path)) as? [String: Any])
    124   }
    125 
    126   static func hash(_ bytes: Data) -> String {
    127     SHA256.hash(data: bytes).map { String(format: "%02x", $0) }.joined()
    128   }
    129 
    130   func remove() {
    131     try? FileManager.default.removeItem(at: root)
    132   }
    133 }