field_ios

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

TeraSupportingFreshnessTests.swift (15266B)


      1 @testable import TeraApp
      2 import XCTest
      3 
      4 @MainActor
      5 final class TeraSupportingFreshnessTests: XCTestCase {
      6   func testSearchMandatoryFailureClearsOpenDetailAndRevokesMedia() async throws {
      7     let backend = try TeraScopeBackend()
      8     let client = try await TeraScopeFixtures.client(backend)
      9     let context = TeraLocalNetwork.defaultContext(snapshot: TeraScopeFixtures.snapshot())
     10     let stores = TeraProductStores(runtimeClient: client)
     11     stores.configure(snapshot: TeraScopeFixtures.snapshot())
     12     let store = stores.search
     13     let reference = TeraScopeFixtures.reference()
     14     let profile = profile(reference)
     15     let result = TeraSearchResult(type: .profile, id: profile.authorPublicKey, card: nil, profile: profile)
     16     await backend.setSearchResults([result])
     17     store.updateQuery("old farm")
     18     store.start()
     19     await TeraScopeFixtures.eventually { store.state == .loaded }
     20     XCTAssertNotNil(store.currentResult(id: result.id, type: .profile, context: context))
     21     let media = await backend.pause(.media)
     22     stores.media.load(media: reference, context: context)
     23     await media.entered.wait()
     24     let failure = await backend.pause(.search, fails: true)
     25     await backend.emit(.today, context: context)
     26     await failure.entered.wait()
     27     XCTAssertEqual(store.query, "old farm")
     28     XCTAssertTrue(store.results.isEmpty)
     29     XCTAssertNil(store.currentResult(id: result.id, type: .profile, context: context))
     30     XCTAssertEqual(stores.media.state(for: reference, context: context), .unavailable)
     31     await media.resume.open()
     32     await failure.resume.open()
     33     await TeraScopeFixtures.eventually {
     34       if case .failed = store.state {
     35         true
     36       } else {
     37         false
     38       }
     39     }
     40     XCTAssertTrue(store.results.isEmpty)
     41     XCTAssertNil(stores.media.image(for: reference, context: context))
     42     XCTAssertEqual(stores.media.cachedByteCount, 0)
     43     stores.stop()
     44     _ = try await client.stop()
     45   }
     46 
     47   func testSearchPausedOldResultCannotReturnAfterReplacementInvalidation() async throws {
     48     let backend = try TeraScopeBackend()
     49     let client = try await TeraScopeFixtures.client(backend)
     50     let context = TeraLocalNetwork.defaultContext(snapshot: TeraScopeFixtures.snapshot())
     51     let store = TeraSearchStore(runtimeClient: client)
     52     store.configure(context: context)
     53     store.updateQuery("scope")
     54     await backend.setSearchResults([result("old")])
     55     store.start()
     56     await TeraScopeFixtures.eventually { store.results.first?.id == "old" }
     57     let first = await backend.pause(.search)
     58     await backend.emit(.today, context: context)
     59     await first.entered.wait()
     60     let current = await backend.pause(.search)
     61     await backend.setSearchResults([result("current")])
     62     await backend.emit(.profile, context: context)
     63     XCTAssertTrue(store.results.isEmpty)
     64     await first.resume.open()
     65     await current.entered.wait()
     66     XCTAssertTrue(store.results.isEmpty, "The completed old read must remain fenced")
     67     await current.resume.open()
     68     await TeraScopeFixtures.eventually { store.results.first?.id == "current" }
     69     XCTAssertNil(store.currentResult(id: "old", type: .card, context: context))
     70     XCTAssertNotNil(store.currentResult(id: "current", type: .card, context: context))
     71     let calls = await backend.counts[.search]
     72     XCTAssertEqual(calls, 3, "Initial read and one bounded worker with one pending reconciliation")
     73     store.stop()
     74     _ = try await client.stop()
     75   }
     76 
     77   func testMeVoluntaryOfflineFailureKeepsCacheButMandatoryFailureClearsIt() async throws {
     78     let backend = try TeraScopeBackend()
     79     let client = try await TeraScopeFixtures.client(backend)
     80     let context = TeraLocalNetwork.defaultContext(snapshot: TeraScopeFixtures.snapshot())
     81     let store = TeraMeStore(runtimeClient: client)
     82     store.configure(context: context)
     83     await store.reload()
     84     XCTAssertNotNil(store.currentCard(id: "old", context: context))
     85     let voluntary = await backend.pause(.me, failure: .local(
     86       operation: "today", code: "today_storage_failed", safeMessage: "The local store is temporarily unavailable."
     87     ))
     88     let reload = Task { await store.reload() }
     89     await voluntary.entered.wait()
     90     await voluntary.resume.open()
     91     await reload.value
     92     XCTAssertNotNil(store.currentCard(id: "old", context: context))
     93     let mandatory = await backend.pause(.me, fails: true)
     94     store.invalidatePresentation()
     95     XCTAssertNil(store.snapshot)
     96     let reconcile = Task { await store.reload() }
     97     await mandatory.entered.wait()
     98     await mandatory.resume.open()
     99     await reconcile.value
    100     XCTAssertNil(store.snapshot)
    101     XCTAssertNil(store.currentCard(id: "old", context: context))
    102     store.stop()
    103     _ = try await client.stop()
    104   }
    105 
    106   func testMeObservationInvalidatesPausedReadAndGapReconcilesCurrentValues() async throws {
    107     let backend = try TeraScopeBackend()
    108     let client = try await TeraScopeFixtures.client(backend)
    109     let context = TeraLocalNetwork.defaultContext(snapshot: TeraScopeFixtures.snapshot())
    110     let store = TeraMeStore(runtimeClient: client)
    111     store.configure(context: context)
    112     await store.start()
    113     XCTAssertNotNil(store.snapshot, "Awaited startup includes the mandatory initial reconciliation")
    114     await TeraScopeFixtures.eventually { store.state == .loaded }
    115     let old = await backend.pause(.me)
    116     await backend.emit(.today, context: context)
    117     await old.entered.wait()
    118     let current = await backend.pause(.me)
    119     await backend.setMeCards([TeraScopeFixtures.card("current")])
    120     await backend.emit(.initial, delivery: .resnapshotRequired, context: context)
    121     XCTAssertNil(store.snapshot)
    122     await old.resume.open()
    123     await current.entered.wait()
    124     XCTAssertNil(store.snapshot)
    125     await current.resume.open()
    126     await TeraScopeFixtures.eventually { store.snapshot?.cards.first?.id == "current" }
    127     XCTAssertNil(store.currentCard(id: "old", context: context))
    128     store.stop()
    129     _ = try await client.stop()
    130   }
    131 
    132   func testFullContextChangeAndStopFenceSupportingReads() async throws {
    133     let backend = try TeraScopeBackend()
    134     let client = try await TeraScopeFixtures.client(backend)
    135     let first = TeraLocalNetwork.defaultContext(snapshot: TeraScopeFixtures.snapshot())
    136     let second = TeraLocalNetwork(
    137       schemaVersion: first.schemaVersion, id: first.id, label: first.label,
    138       relayURLs: first.relayURLs, locality: "Another locality",
    139       followedAuthors: first.followedAuthors, generation: first.generation
    140     )
    141     let search = TeraSearchStore(runtimeClient: client)
    142     let me = TeraMeStore(runtimeClient: client)
    143     search.configure(context: first)
    144     search.updateQuery("old")
    145     me.configure(context: first)
    146     let searchPause = await backend.pause(.search)
    147     let mePause = await backend.pause(.me)
    148     let searchTask = Task { await search.search() }
    149     let meTask = Task { await me.reload() }
    150     await searchPause.entered.wait()
    151     await mePause.entered.wait()
    152     search.configure(context: second)
    153     me.configure(context: second)
    154     await searchPause.resume.open()
    155     await mePause.resume.open()
    156     await searchTask.value
    157     await meTask.value
    158     XCTAssertTrue(search.results.isEmpty)
    159     XCTAssertNil(me.snapshot)
    160     search.updateQuery("new")
    161     await search.search()
    162     await me.reload()
    163     XCTAssertNil(search.currentResult(id: "new", type: .card, context: first))
    164     XCTAssertNotNil(search.currentResult(id: "new", type: .card, context: second))
    165     XCTAssertNil(me.currentCard(id: "old", context: first))
    166     XCTAssertNotNil(me.currentCard(id: "old", context: second))
    167     search.stop()
    168     me.stop()
    169     XCTAssertTrue(search.results.isEmpty)
    170     XCTAssertNil(me.snapshot)
    171     _ = try await client.stop()
    172   }
    173 
    174   func testMeMandatoryObserverFailureRemovesCurrentDetail() async throws {
    175     let backend = try TeraScopeBackend()
    176     let client = try await TeraScopeFixtures.client(backend)
    177     let context = TeraLocalNetwork.defaultContext(snapshot: TeraScopeFixtures.snapshot())
    178     let store = TeraMeStore(runtimeClient: client)
    179     store.configure(context: context)
    180     await store.start()
    181     await TeraScopeFixtures.eventually { store.state == .loaded }
    182     XCTAssertNotNil(store.currentCard(id: "old", context: context))
    183     let failed = await backend.pause(.me, fails: true)
    184     await backend.emit(.today, context: context)
    185     await failed.entered.wait()
    186     XCTAssertNil(store.currentCard(id: "old", context: context))
    187     await failed.resume.open()
    188     await TeraScopeFixtures.eventually {
    189       if case .failed = store.state {
    190         true
    191       } else {
    192         false
    193       }
    194     }
    195     XCTAssertNil(store.snapshot)
    196     store.stop()
    197     _ = try await client.stop()
    198   }
    199 
    200   func testOrdinaryMediaProgressPreservesCurrentSupportingContent() async throws {
    201     let backend = try TeraScopeBackend()
    202     let client = try await TeraScopeFixtures.client(backend)
    203     let context = TeraLocalNetwork.defaultContext(snapshot: TeraScopeFixtures.snapshot())
    204     let search = TeraSearchStore(runtimeClient: client)
    205     let me = TeraMeStore(runtimeClient: client)
    206     search.configure(context: context)
    207     search.updateQuery("scope")
    208     search.start()
    209     me.configure(context: context)
    210     await me.start()
    211     await TeraScopeFixtures.eventually { search.state == .loaded && me.state == .loaded }
    212     let results = search.results
    213     let snapshot = me.snapshot
    214     let before = await backend.counts
    215     for _ in 1 ... 8 {
    216       await backend.emit(.media, context: context)
    217       try await Task.sleep(for: .milliseconds(10))
    218     }
    219     let after = await backend.counts
    220     XCTAssertEqual(after[.search], before[.search])
    221     XCTAssertEqual(after[.me], before[.me])
    222     XCTAssertEqual(search.results, results)
    223     XCTAssertEqual(me.snapshot, snapshot)
    224     search.stop()
    225     me.stop()
    226     _ = try await client.stop()
    227   }
    228 
    229   private func result(_ id: String) -> TeraSearchResult {
    230     TeraSearchResult(type: .card, id: id, card: TeraScopeFixtures.card(id), profile: nil)
    231   }
    232 
    233   private func profile(_ reference: TeraMediaReference) -> TeraProfileSummary {
    234     TeraProfileSummary(
    235       authorPublicKey: String(repeating: "a", count: 64), name: "Farm", displayName: nil,
    236       about: nil, picture: reference, banner: nil, nip05: nil, website: nil, lightningAddress: nil
    237     )
    238   }
    239 }
    240 
    241 extension TeraSupportingFreshnessTests {
    242   func testMeTypedCurrentScopeRefusalClearsCacheWithoutNotification() async throws {
    243     let codes = [
    244       "today_invalid_request", "today_refresh_required", "today_projection_rebuilding",
    245       "today_cursor_invalid", "today_reader_unsupported", "today_runtime_unavailable", "today_state_failed",
    246       "storage_space_insufficient",
    247     ]
    248     for code in codes {
    249       let backend = try TeraScopeBackend()
    250       let client = try await TeraScopeFixtures.client(backend)
    251       let context = TeraLocalNetwork.defaultContext(snapshot: TeraScopeFixtures.snapshot())
    252       let stores = TeraProductStores(runtimeClient: client)
    253       stores.configure(snapshot: TeraScopeFixtures.snapshot())
    254       let store = stores.me
    255       let reference = TeraScopeFixtures.reference()
    256       await backend.setMeProfile(profile(reference))
    257       await store.reload()
    258       XCTAssertNotNil(store.currentCard(id: "old", context: context), code)
    259       XCTAssertNotNil(store.currentProfile(context: context), code)
    260       stores.media.load(media: reference, context: context)
    261       await TeraScopeFixtures.eventually { stores.media.image(for: reference, context: context) != nil }
    262       XCTAssertGreaterThan(stores.media.cachedByteCount, 0, code)
    263       let pause = await backend.pause(.me, failure: .local(
    264         operation: "today", code: code, safeMessage: "The current content could not be confirmed."
    265       ))
    266       let reload = Task { await store.reload() }
    267       await pause.entered.wait()
    268       await pause.resume.open()
    269       await reload.value
    270       XCTAssertNil(store.snapshot, code)
    271       XCTAssertNil(store.currentCard(id: "old", context: context), code)
    272       XCTAssertNil(store.currentProfile(context: context), code)
    273       XCTAssertEqual(stores.media.state(for: reference, context: context), .unavailable, code)
    274       XCTAssertNil(stores.media.image(for: reference, context: context), code)
    275       XCTAssertEqual(stores.media.cachedByteCount, 0, code)
    276       if case .failed = store.state {} else {
    277         XCTFail("Expected a typed read refusal for \(code)")
    278       }
    279       stores.stop()
    280       _ = try await client.stop()
    281     }
    282   }
    283 }
    284 
    285 extension TeraSupportingFreshnessTests {
    286   func testSearchQueryChangeAndStopPreserveMeSharedMediaUntilLastCurrentReferenceLeaves() async throws {
    287     let backend = try TeraScopeBackend()
    288     let client = try await TeraScopeFixtures.client(backend)
    289     let context = TeraLocalNetwork.defaultContext(snapshot: TeraScopeFixtures.snapshot())
    290     let stores = TeraProductStores(runtimeClient: client)
    291     stores.configure(snapshot: TeraScopeFixtures.snapshot())
    292     let reference = TeraScopeFixtures.reference()
    293     let shared = profile(reference)
    294     let result = TeraSearchResult(type: .profile, id: shared.authorPublicKey, card: nil, profile: shared)
    295     await backend.setMeProfile(shared)
    296     await stores.me.reload()
    297     await backend.setSearchResults([result])
    298     stores.search.updateQuery("farm")
    299     await stores.search.search()
    300     XCTAssertNotNil(stores.me.currentProfile(context: context))
    301     XCTAssertNotNil(stores.search.currentResult(id: result.id, type: .profile, context: context))
    302     stores.media.load(media: reference, context: context)
    303     await TeraScopeFixtures.eventually { stores.media.image(for: reference, context: context) != nil }
    304     let expected = try TeraScopeFixtures.artifact("a")
    305     XCTAssertEqual(stores.media.state(for: reference, context: context), .ready(expected))
    306     stores.search.updateQuery("different query")
    307     XCTAssertTrue(stores.search.results.isEmpty)
    308     XCTAssertNil(stores.search.currentResult(id: result.id, type: .profile, context: context))
    309     XCTAssertEqual(stores.me.currentProfile(context: context), shared)
    310     XCTAssertNotNil(stores.media.image(for: reference, context: context))
    311     XCTAssertEqual(stores.media.state(for: reference, context: context), .ready(expected))
    312     stores.media.load(media: reference, context: context)
    313     stores.media.retry(media: reference, context: context)
    314     await TeraScopeFixtures.eventually { stores.media.state(for: reference, context: context) == .ready(expected) }
    315     let calls = await backend.counts[.media]
    316     XCTAssertEqual(calls, 2, "Retry remains usable for the unchanged current Me picture")
    317     await stores.search.search()
    318     stores.search.stop()
    319     XCTAssertEqual(stores.me.currentProfile(context: context), shared)
    320     XCTAssertNotNil(stores.media.image(for: reference, context: context))
    321     stores.me.invalidatePresentation()
    322     XCTAssertNil(stores.me.currentProfile(context: context))
    323     XCTAssertNil(stores.media.image(for: reference, context: context))
    324     XCTAssertEqual(stores.media.cachedByteCount, 0)
    325     stores.media.load(media: reference, context: context)
    326     stores.media.retry(media: reference, context: context)
    327     let finalCalls = await backend.counts[.media]
    328     XCTAssertEqual(finalCalls, 2, "Last-reference invalidation must still deny load and retry")
    329     stores.stop()
    330     _ = try await client.stop()
    331   }
    332 }