field_ios

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

TeraProductStartupTests.swift (7093B)


      1 @testable import TeraApp
      2 import XCTest
      3 
      4 @MainActor
      5 final class TeraProductStartupTests: XCTestCase {
      6   func testLocalAddIsEditableWhileTodayRefreshHasNotReturned() async throws {
      7     let fixture = try await StartupFixture()
      8     let refresh = await fixture.backend.pause(.refresh)
      9     fixture.stores.start()
     10     await refresh.entered.wait()
     11     await TeraScopeFixtures.eventually { fixture.stores.add.isProductReady }
     12     XCTAssertEqual(Set(fixture.stores.add.schemas.map(\.commandType)), Set(TeraAddCommandType.allCases))
     13     await TeraScopeFixtures.eventually { fixture.stores.add.drafts.first?.form?.content == "old" }
     14     XCTAssertEqual(fixture.stores.add.drafts.first?.form?.content, "old")
     15     XCTAssertEqual(fixture.stores.today.presentation.refresh, .refreshing)
     16     fixture.stores.add.updateForm(\.content, "Compose while refresh is held")
     17     XCTAssertTrue(fixture.stores.add.canSave)
     18     XCTAssertEqual(fixture.stores.add.form.content, "Compose while refresh is held")
     19     fixture.stores.suspend()
     20     await refresh.resume.open()
     21     try await fixture.close()
     22   }
     23 
     24   func testSuspendCancelsBothStartupReadsBeforeTheirBackendsReturn() async throws {
     25     let fixture = try await StartupFixture()
     26     let page = await fixture.backend.pause(.page)
     27     let drafts = await fixture.backend.pause(.drafts)
     28     let task = Task { await fixture.stores.resume() }
     29     await page.entered.wait()
     30     await drafts.entered.wait()
     31     let validated = fixture.stores.add.schemas
     32     XCTAssertEqual(validated.count, 5)
     33     fixture.stores.suspend()
     34     await task.value
     35     XCTAssertTrue(fixture.stores.today.cards.isEmpty)
     36     XCTAssertEqual(fixture.stores.add.schemas, validated)
     37     XCTAssertTrue(fixture.stores.add.drafts.isEmpty)
     38     XCTAssertTrue(fixture.stores.add.isProductReady)
     39     XCTAssertEqual(fixture.stores.today.observationState, .stopped)
     40     XCTAssertEqual(fixture.stores.add.observationState, .stopped)
     41     await page.resume.open()
     42     await drafts.resume.open()
     43     try await fixture.close()
     44     XCTAssertEqual(fixture.stores.add.schemas, validated)
     45     XCTAssertTrue(fixture.stores.add.drafts.isEmpty)
     46     XCTAssertTrue(fixture.stores.today.cards.isEmpty)
     47   }
     48 
     49   func testCanceledResumeStopsBothObserversAndCanStartAgain() async throws {
     50     let fixture = try await StartupFixture()
     51     let refresh = await fixture.backend.pause(.refresh)
     52     let drafts = await fixture.backend.pause(.drafts)
     53     let task = Task { await fixture.stores.resume() }
     54     await refresh.entered.wait()
     55     await drafts.entered.wait()
     56     task.cancel()
     57     await task.value
     58     XCTAssertEqual(fixture.stores.today.observationState, .stopped)
     59     XCTAssertEqual(fixture.stores.add.observationState, .stopped)
     60     XCTAssertTrue(fixture.stores.add.isProductReady, "Validated local editing remains available while optional reads are cancelled")
     61     await refresh.resume.open()
     62     await drafts.resume.open()
     63     await fixture.releaseObservers()
     64     await fixture.stores.resume()
     65     XCTAssertTrue(fixture.stores.add.isProductReady)
     66     XCTAssertEqual(fixture.stores.add.schemas.count, 5)
     67     try await fixture.close()
     68   }
     69 
     70   func testConcurrentStartsAndResumesKeepOneObserverPerStore() async throws {
     71     let fixture = try await StartupFixture()
     72     let refresh = await fixture.backend.pause(.refresh)
     73     let drafts = await fixture.backend.pause(.drafts)
     74     fixture.stores.start()
     75     fixture.stores.start()
     76     let first = Task { await fixture.stores.resume() }
     77     let second = Task { await fixture.stores.resume() }
     78     await refresh.entered.wait()
     79     await TeraScopeFixtures.eventually { fixture.stores.add.isProductReady }
     80     for observer in fixture.observers {
     81       await observer.entered.wait()
     82     }
     83     await drafts.entered.wait()
     84     let counts = await fixture.backend.counts
     85     XCTAssertEqual(counts[.subscribe], 2)
     86     XCTAssertEqual(counts[.refresh], 1)
     87     XCTAssertEqual(counts[.drafts], 1)
     88     await fixture.releaseObservers()
     89     await drafts.resume.open()
     90     await refresh.resume.open()
     91     await first.value
     92     await second.value
     93     let final = await fixture.backend.counts
     94     XCTAssertEqual(final[.subscribe], 2)
     95     XCTAssertEqual(final[.refresh], 1)
     96     try await fixture.close()
     97   }
     98 
     99   func testReconfigurationRejectsOldStartupAndKeepsTheReplacementOwned() async throws {
    100     for changed in [false, true] {
    101       try await assertReplacement(changed: changed)
    102     }
    103   }
    104 
    105   func testSuspendAndResumePreserveTheUnsentEditingForm() async throws {
    106     let fixture = try await StartupFixture()
    107     await fixture.releaseObservers()
    108     await fixture.stores.resume()
    109     fixture.stores.add.updateForm(\.content, "Unsent local editing")
    110     fixture.stores.suspend()
    111     await fixture.stores.resume()
    112     XCTAssertTrue(fixture.stores.add.isProductReady)
    113     XCTAssertEqual(fixture.stores.add.form.content, "Unsent local editing")
    114     try await fixture.close()
    115   }
    116 
    117   private func assertReplacement(changed: Bool) async throws {
    118     let fixture = try await StartupFixture()
    119     let oldRefresh = await fixture.backend.pause(.refresh)
    120     let oldDrafts = await fixture.backend.pause(.drafts)
    121     let old = Task { await fixture.stores.resume() }
    122     await oldRefresh.entered.wait()
    123     await oldDrafts.entered.wait()
    124     let snapshot = TeraScopeFixtures.snapshot(relay: changed ? "second" : "first")
    125     await fixture.backend.configure(snapshot)
    126     await fixture.backend.setDrafts([TeraScopeFixtures.draft("replacement", revision: 2)])
    127     fixture.stores.configure(snapshot: snapshot)
    128     let newRefresh = await fixture.backend.pause(.refresh)
    129     let current = Task { await fixture.stores.resume() }
    130     await newRefresh.entered.wait()
    131     await old.value
    132     await TeraScopeFixtures.eventually { fixture.stores.add.isProductReady }
    133     await TeraScopeFixtures.eventually { fixture.stores.add.drafts.first?.form?.content == "replacement" }
    134     XCTAssertEqual(fixture.stores.add.drafts.first?.form?.content, "replacement")
    135     XCTAssertEqual(fixture.stores.today.selectedContext?.relayURLs, snapshot.relay?.relays.map(\.url))
    136     fixture.stores.suspend()
    137     await current.value
    138     XCTAssertEqual(fixture.stores.today.observationState, .stopped)
    139     await oldRefresh.resume.open()
    140     await oldDrafts.resume.open()
    141     await newRefresh.resume.open()
    142     try await fixture.close()
    143     XCTAssertEqual(fixture.stores.add.drafts.first?.form?.content, "replacement")
    144   }
    145 }
    146 
    147 @MainActor
    148 private struct StartupFixture {
    149   let backend: TeraScopeBackend
    150   let client: TeraRuntimeClient
    151   let stores: TeraProductStores
    152   let observers: [ResourceTestPause]
    153 
    154   init() async throws {
    155     backend = try TeraScopeBackend()
    156     client = try await TeraScopeFixtures.client(backend)
    157     stores = TeraProductStores(runtimeClient: client)
    158     stores.configure(snapshot: TeraScopeFixtures.snapshot())
    159     observers = await [backend.pause(.subscribe), backend.pause(.subscribe)]
    160   }
    161 
    162   func releaseObservers() async {
    163     for observer in observers {
    164       await observer.resume.open()
    165     }
    166   }
    167 
    168   func close() async throws {
    169     stores.stop()
    170     await releaseObservers()
    171     _ = try await client.stop()
    172   }
    173 }