field_ios

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

TeraScopeBackend.swift (11514B)


      1 import Foundation
      2 @testable import TeraApp
      3 
      4 actor TeraScopeBackend: TeraRuntimeBackend {
      5   let visibilityStorage = VisibilityTestStorage()
      6   let restoreStorage = RestoreTestStorage()
      7   let recoveryScheduleStorage = NativeRecoveryScheduleTestStorage()
      8   var nativeRepairValues: [String: TeraNativeRecoveryStatus] = [:]
      9   enum Call: Hashable { case snapshot, schemas, drafts, save, composer, composerLoad, composerList, legacyPage, draftStatus, probe, page, reconcile, refresh, search, me, subscribe, media, invalidate, cacheCleanup }
     10   struct Pending {
     11     let pause: ResourceTestPause
     12     let failure: TeraRuntimeFailure?
     13   }
     14 
     15   private(set) var value = TeraScopeFixtures.snapshot()
     16   private let composerStorage = ComposerTestStorage()
     17   private var composerPages: [String: TeraComposerPage] = [:]
     18   private var legacyPages: [String: TeraLegacyDraftPage] = [:]
     19   private(set) var recoveryLimits: [UInt16] = []
     20   private var pending: [Call: [Pending]] = [:]
     21   private(set) var counts: [Call: Int] = [:]
     22   private var receivers: [@Sendable (TeraRuntimeChange) async -> Void] = []
     23   private(set) var tokens: [ResourceTestToken] = []
     24   private(set) var lastMeContext: TeraLocalNetwork?
     25   private var drafts: [TeraDraftStatus] = [TeraScopeFixtures.draft("old")]
     26   private var media: TeraVerifiedMediaArtifact
     27   private var pages: [String: TeraTodayPage] = [:]
     28   private var meCards = [TeraScopeFixtures.card("old")]
     29   private var meProfile: TeraProfileSummary?
     30   private var searchResults: [TeraSearchResult]?
     31   private var cacheCleanupResult = TeraMediaCacheCleanup(invalidatedEntries: 2, retainedCandidates: 1, remainingEntries: 3)
     32   private var revision: UInt64 = 0
     33   private var syncReceipt: TeraTodaySyncReceipt?
     34   var recoveryCompletion: (@Sendable (TeraRecoveryUploadReceipt, TeraPreparedMediaHandle) async throws -> TeraRecoveryCompletionReceipt)?
     35   private var legacyCompletionFailure: TeraRuntimeFailure?
     36 
     37   func failLegacyCompletion(with error: TeraRuntimeFailure) {
     38     legacyCompletionFailure = error
     39   }
     40 
     41   func completeAddMediaBackground(input _: TeraNativeUploadCompletion) throws -> TeraDraftStatus {
     42     throw legacyCompletionFailure ?? TeraComposerAcknowledgment.unconfirmed
     43   }
     44 
     45   func setRecoveryCompletion(_ value: @escaping @Sendable (TeraRecoveryUploadReceipt, TeraPreparedMediaHandle) async throws -> TeraRecoveryCompletionReceipt) {
     46     recoveryCompletion = value
     47   }
     48 
     49   func recoveryParent(key: String) -> TeraRecoveryEntry? {
     50     drafts.first(where: { $0.id == key }).map { .init(key: $0.id, revision: $0.revision, owner: .legacy) }
     51   }
     52 
     53   func recoverNativeUpload(_ receipt: TeraRecoveryUploadReceipt, media: TeraPreparedMediaHandle) async throws -> TeraRecoveryCompletionReceipt {
     54     guard let recoveryCompletion else { throw TeraComposerAcknowledgment.unconfirmed }
     55     return try await recoveryCompletion(receipt, media)
     56   }
     57 
     58   private var reconciliationCards: [TeraTodayCard]?
     59   private var reconciliationGeneration: UInt64 = 1
     60   private(set) var reconciliationRequests: [TeraTodayReconcileRequest] = []
     61   private(set) var pageRequests: [TeraTodayPageRequest] = []
     62 
     63   init() throws {
     64     media = try TeraScopeFixtures.artifact("a")
     65   }
     66 
     67   func pause(_ call: Call, fails: Bool = false, failure: TeraRuntimeFailure? = nil) -> ResourceTestPause {
     68     let pause = ResourceTestPause()
     69     pending[call, default: []].append(Pending(pause: pause, failure: failure ?? (fails ? TeraScopeFixtures.failure() : nil)))
     70     return pause
     71   }
     72 
     73   func configure(_ value: TeraRuntimeSnapshot) {
     74     self.value = value
     75   }
     76 
     77   func setSyncReceipt(_ receipt: TeraTodaySyncReceipt) {
     78     syncReceipt = receipt
     79   }
     80 
     81   func setDrafts(_ values: [TeraDraftStatus]) {
     82     drafts = values
     83   }
     84 
     85   func setMedia(_ value: TeraVerifiedMediaArtifact) {
     86     media = value
     87   }
     88 
     89   func setPage(_ value: TeraTodayPage, cursor: String = "first") {
     90     pages[cursor] = value
     91   }
     92 
     93   func setMeProfile(_ value: TeraProfileSummary) {
     94     meProfile = value
     95   }
     96 
     97   func setMeCards(_ values: [TeraTodayCard]) {
     98     meCards = values
     99   }
    100 
    101   func setSearchResults(_ values: [TeraSearchResult]) {
    102     searchResults = values
    103   }
    104 
    105   func setReconciliation(_ cards: [TeraTodayCard], generation: UInt64) {
    106     reconciliationCards = cards
    107     reconciliationGeneration = generation
    108   }
    109 
    110   func reconcileToday(request: TeraTodayReconcileRequest) async throws -> TeraTodayPage {
    111     reconciliationRequests.append(request)
    112     let saved = pages.isEmpty ? [TeraScopeFixtures.card(request.context.relayURLs.first ?? "none")] : pages.values.flatMap(\.items)
    113     let values = reconciliationCards ?? saved
    114     var seen = Set<String>()
    115     let items = values.filter { request.cardIDs.contains($0.id) && seen.insert($0.id).inserted }
    116     let generation = reconciliationGeneration
    117     try await wait(.reconcile)
    118     if let expected = request.expectedGeneration, expected != generation {
    119       throw TeraRuntimeFailure.local(operation: "test", code: "today_cursor_invalid", safeMessage: "Changed")
    120     }
    121     return TeraTodayPage(asOfUnixSeconds: request.asOfUnixSeconds, items: items, nextCursor: nil, projectionGeneration: generation, calendar: request.calendar)
    122   }
    123 
    124   private func wait(_ call: Call) async throws {
    125     counts[call, default: 0] += 1
    126     guard var queue = pending[call], !queue.isEmpty else { return }
    127     let next = queue.removeFirst()
    128     pending[call] = queue
    129     await next.pause.wait()
    130     if let failure = next.failure {
    131       throw failure
    132     }
    133   }
    134 
    135   func snapshot() async throws -> TeraRuntimeSnapshot {
    136     let snapshot = value
    137     try await wait(.snapshot)
    138     return snapshot
    139   }
    140 
    141   func addSchemas() async throws -> [TeraAddSchema] {
    142     let schemas = TeraAddSchemaFixtures.schemas()
    143     try await wait(.schemas)
    144     return schemas
    145   }
    146 
    147   func draftHeads(limit _: UInt16) async throws -> [TeraDraftStatus] {
    148     let result = drafts
    149     try await wait(.drafts)
    150     return result
    151   }
    152 
    153   func saveAddIntent(
    154     input: TeraAddRuntimeInput, existingDraftID _: String?, expectedRevision: UInt64?
    155   ) async throws -> TeraDraftStatus {
    156     let result = TeraScopeFixtures.draft(input.form.content, revision: (expectedRevision ?? 0) + 1)
    157     try await wait(.save)
    158     drafts = [result]
    159     return result
    160   }
    161 
    162   func reserveComposerID() async -> String {
    163     await composerStorage.reserve()
    164   }
    165 
    166   func saveComposer(request: TeraComposerSaveRequest) async throws -> TeraComposerSaveReceipt {
    167     try await wait(.composer)
    168     return try await composerStorage.save(request)
    169   }
    170 
    171   func loadComposer(scope: TeraComposerScope, id: String) async throws -> TeraComposerDraft {
    172     let saved = try await composerStorage.load(scope, id: id)
    173     try await wait(.composerLoad)
    174     return saved
    175   }
    176 
    177   func setComposerPage(_ page: TeraComposerPage, cursor: String = "first") {
    178     composerPages[cursor] = page
    179   }
    180 
    181   func setLegacyPage(_ page: TeraLegacyDraftPage, cursor: String = "first") {
    182     legacyPages[cursor] = page
    183   }
    184 
    185   func listComposers(scope: TeraComposerScope, limit: UInt16, cursor: String?) async throws -> TeraComposerPage {
    186     recoveryLimits.append(limit)
    187     let result = composerPages[cursor ?? "first"] ?? TeraComposerPage(scope: scope, entries: [], nextCursor: nil)
    188     try await wait(.composerList)
    189     return result
    190   }
    191 
    192   func legacyDraftPage(limit: UInt16, cursor: String?) async throws -> TeraLegacyDraftPage {
    193     recoveryLimits.append(limit)
    194     let result = legacyPages[cursor ?? "first"] ?? TeraLegacyDraftPage(authorPublicKey: value.identity.publicKeyHex, entries: [], nextCursor: nil)
    195     try await wait(.legacyPage)
    196     return result
    197   }
    198 
    199   func draftStatus(id: String) async throws -> TeraDraftStatus {
    200     guard let result = drafts.first(where: { $0.id == id }) else { throw TeraScopeFixtures.failure() }
    201     try await wait(.draftStatus)
    202     return result
    203   }
    204 
    205   func probeBlossom() async throws -> TeraBlossomEvidence {
    206     let fingerprint = value.blossomConfiguration?.configFingerprint ?? ""
    207     try await wait(.probe)
    208     return TeraBlossomEvidence(
    209       schemaVersion: 2, origin: "http://127.0.0.1:3000", configFingerprint: fingerprint,
    210       state: "reachable", lastSuccessfulState: "probe", transportSecurity: "loopback_plaintext",
    211       observedAtUnixMilliseconds: 1, httpStatus: 200, errorCode: nil, serverErrorCode: nil,
    212       errorPhase: nil, retryable: false, possibleOrphan: false, attempts: 1
    213     )
    214   }
    215 
    216   func todayPage(request: TeraTodayPageRequest) async throws -> TeraTodayPage {
    217     pageRequests.append(request)
    218     let result = pages[request.cursor ?? "first"] ?? TeraTodayPage(asOfUnixSeconds: 1, items: [TeraScopeFixtures.card(request.context.relayURLs.first ?? "none")], nextCursor: nil, calendar: TeraScopeFixtures.viewerCalendar(asOf: 1))
    219     try await wait(.page)
    220     return result
    221   }
    222 
    223   private(set) var lastBackfillCursor: String?
    224 
    225   func refreshToday(
    226     context _: TeraLocalNetwork, nowUnixSeconds _: UInt64, update: TeraTodayProjectionUpdate,
    227     backfillCursor: String?
    228   ) async throws -> TeraTodaySyncReceipt {
    229     lastBackfillCursor = backfillCursor
    230     let result = syncReceipt ?? TeraTodaySyncFixtures.receipt(update: update)
    231     try await wait(.refresh)
    232     return result
    233   }
    234 
    235   func search(
    236     context _: TeraLocalNetwork, query: String, limit _: UInt16, asOfUnixSeconds _: UInt64
    237   ) async throws -> [TeraSearchResult] {
    238     let result = searchResults ?? [TeraSearchResult(type: .card, id: query, card: TeraScopeFixtures.card(query), profile: nil)]
    239     try await wait(.search)
    240     return result
    241   }
    242 
    243   func me(context: TeraLocalNetwork, asOfUnixSeconds _: UInt64) async throws -> TeraMeSnapshot {
    244     lastMeContext = context
    245     let result = TeraMeSnapshot(publicKey: value.identity.publicKeyHex, profile: meProfile, cards: meCards)
    246     try await wait(.me)
    247     return result
    248   }
    249 
    250   func retrieveMedia(context _: TeraLocalNetwork, reference _: TeraMediaReference) async throws -> TeraVerifiedMediaArtifact {
    251     let result = media
    252     try await wait(.media)
    253     return result
    254   }
    255 
    256   func cleanupMediaCache(context _: TeraLocalNetwork) async throws -> TeraMediaCacheCleanup {
    257     try await wait(.cacheCleanup)
    258     return cacheCleanupResult
    259   }
    260 
    261   func invalidateMediaArtifact(context _: TeraLocalNetwork, artifactID _: String) async throws -> Bool {
    262     try await wait(.invalidate)
    263     return true
    264   }
    265 
    266   func subscribe(
    267     bufferCapacity _: Int, receive: @escaping @Sendable (TeraRuntimeChange) async -> Void
    268   ) async throws -> any TeraRuntimeSubscriptionToken {
    269     let token = ResourceTestToken()
    270     receivers.append(receive)
    271     tokens.append(token)
    272     try await wait(.subscribe)
    273     return token
    274   }
    275 
    276   func emit(
    277     _ kind: TeraRuntimeChangeKind,
    278     delivery: TeraRuntimeChangeDelivery = .change,
    279     context: TeraLocalNetwork? = nil,
    280     exhausted: Bool = false
    281   ) async {
    282     revision += 1
    283     let emittedRevision = revision
    284     for receive in receivers {
    285       await receive(TeraRuntimeChange(
    286         schemaVersion: 3,
    287         scope: TeraRuntimeChangeScope(publicKey: String(repeating: "a", count: 64), sourceGeneration: String(repeating: "a", count: 64), context: context),
    288         epoch: String(repeating: "1", count: 32),
    289         revision: TeraProjectionRevision(rawValue: exhausted ? nil : emittedRevision),
    290         delivery: delivery, kind: kind, entityID: nil
    291       ))
    292     }
    293   }
    294 
    295   func shutdown() -> TeraRuntimeShutdownReceipt {
    296     TeraRuntimeShutdownReceipt(state: "closed", alreadyClosed: false)
    297   }
    298 }
    299 
    300 extension TeraScopeBackend {
    301   func setCacheCleanupResult(_ value: TeraMediaCacheCleanup) {
    302     cacheCleanupResult = value
    303   }
    304 }