field_ios

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

TeraScopedObservationTests.swift (2304B)

      1 @testable import TeraApp
      2 import XCTest
      3 
      4 @MainActor
      5 final class TeraScopedObservationTests: XCTestCase {
      6   func testCancelledLateSubscriptionCannotClearOrUpdateReplacementObserver() async throws {
      7     let backend = try TeraScopeBackend()
      8     let client = try await TeraScopeFixtures.client(backend)
      9     let store = TeraTodayStore(runtimeClient: client, clock: .fixed(unixSeconds: 1))
     10     store.configure(snapshot: TeraScopeFixtures.snapshot())
     11     let first = await backend.pause(.subscribe)
     12     await store.start()
     13     await first.entered.wait()
     14     store.stop()
     15     let second = await backend.pause(.subscribe)
     16     await store.start()
     17     await second.entered.wait()
     18     await first.resume.open()
     19     let tokens = await backend.tokens
     20     await tokens[0].cancelled.wait()
     21     XCTAssertEqual(store.observationState, .subscribing(attempt: 1))
     22     await second.resume.open()
     23     await TeraScopeFixtures.eventually { store.observationState == .active }
     24     let attempts = await backend.counts[.subscribe]
     25     await store.start()
     26     let after = await backend.counts[.subscribe]
     27     XCTAssertEqual(attempts, after)
     28     store.stop()
     29     _ = try await client.stop()
     30   }
     31 
     32   func testFailedObservationDelayClearsItsOwnerSoStartResubscribes() async throws {
     33     let backend = try TeraScopeBackend()
     34     let client = try await TeraScopeFixtures.client(backend)
     35     let observation = TeraStoreObservation()
     36     var state = TeraRuntimeObservationState.inactive
     37     let pause = await backend.pause(.subscribe, fails: true)
     38     observation.start(
     39       client: client, buffer: (capacity: 8, delay: { _ in throw CancellationError() }),
     40       state: { state = $0 }, accepts: { _ in true }, refresh: { _ in }
     41     )
     42     await pause.entered.wait()
     43     await pause.resume.open()
     44     await TeraScopeFixtures.eventually { !observation.isActive }
     45     guard case .retrying = state else { return XCTFail("The failed retry remains visible") }
     46     observation.start(
     47       client: client, buffer: (capacity: 8, delay: { _ in throw CancellationError() }),
     48       state: { state = $0 }, accepts: { _ in true }, refresh: { _ in }
     49     )
     50     await TeraScopeFixtures.eventually { state == .active }
     51     let count = await backend.counts[.subscribe]
     52     XCTAssertEqual(count, 2)
     53     observation.stop()
     54     _ = try await client.stop()
     55   }
     56 }