field_ios

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

TeraEditingReplacementTests.swift (9493B)


      1 import Combine
      2 import Foundation
      3 @testable import TeraApp
      4 import XCTest
      5 
      6 @MainActor
      7 final class TeraEditingReplacementTests: XCTestCase {
      8   func testCleanTypeChangeIsImmediateAndDirtyTypeChangePreservesExactAcknowledgment() async throws {
      9     let fixture = try await started()
     10     let backend = fixture.backend
     11     let client = fixture.client
     12     let store = fixture.store
     13     store.selectType(.createEvent)
     14     XCTAssertEqual(store.form.commandType, .createEvent)
     15     store.updateForm(\.eventStartDate, "2026-09-")
     16     store.updateForm(\.content, "  incomplete event  ")
     17     await store.save()
     18     let original = try XCTUnwrap(store.savedComposer)
     19     let pause = await backend.pause(.composer)
     20     store.updateForm(\.content, "  newer event  ")
     21     let editing = TeraComposerForm(editing: store.form)
     22     var observedNewAvailability: [Bool] = []
     23     let observation = store.objectWillChange.sink {
     24       observedNewAvailability.append(store.canCreateNewComposer)
     25     }
     26     defer { observation.cancel() }
     27     store.selectType(.createAsk)
     28     await pause.entered.wait()
     29     XCTAssertEqual(TeraComposerForm(editing: store.form), editing)
     30     store.selectType(.createFoodAvailability)
     31     await pause.resume.open()
     32     await TeraScopeFixtures.eventually { !store.protection.isWorking }
     33     XCTAssertEqual(store.form.commandType, .createAsk)
     34     XCTAssertEqual(store.form.content, "")
     35     XCTAssertEqual(observedNewAvailability.last, true,
     36                    "Add observers must see New enabled after the preservation worker settles")
     37     let saved = try await client.loadComposer(scope: original.scope, id: original.id)
     38     XCTAssertEqual(saved.form, editing)
     39     XCTAssertEqual(saved.revision, original.revision + 1)
     40     XCTAssertGreaterThan(saved.editSequence, original.editSequence)
     41     await store.save()
     42     XCTAssertNotEqual(store.savedComposer?.id, original.id)
     43     store.stop()
     44     _ = try await client.stop()
     45   }
     46 
     47   func testNewerEditingWhileNewSaveCompletesCancelsReplacementAndKeepsNewestForm() async throws {
     48     let fixture = try await started()
     49     let backend = fixture.backend
     50     let client = fixture.client
     51     let store = fixture.store
     52     let first = await backend.pause(.composer)
     53     store.updateForm(\.content, "first")
     54     store.newDraft(type: .createEvent)
     55     await first.entered.wait()
     56     let second = await backend.pause(.composer)
     57     store.updateForm(\.content, "newer while saving")
     58     await first.resume.open()
     59     await second.entered.wait()
     60     XCTAssertEqual(store.form.content, "newer while saving")
     61     XCTAssertEqual(store.form.commandType, .createUpdate)
     62     await second.resume.open()
     63     await TeraScopeFixtures.eventually { !store.isWorking }
     64     XCTAssertEqual(store.form.content, "newer while saving")
     65     XCTAssertEqual(store.savedComposer?.form.content, "newer while saving")
     66     XCTAssertFalse(store.protection.failed)
     67     store.stop()
     68     _ = try await client.stop()
     69   }
     70 
     71   func testSaveFailureKeepEditingAndDiscardPreserveLastDurableDraft() async throws {
     72     let fixture = try await started()
     73     let backend = fixture.backend
     74     let client = fixture.client
     75     let store = fixture.store
     76     store.updateForm(\.content, "durable")
     77     await store.save()
     78     let original = try XCTUnwrap(store.savedComposer)
     79     let failure = await backend.pause(.composer, fails: true)
     80     store.updateForm(\.content, "unsaved")
     81     store.newDraft()
     82     await failure.entered.wait()
     83     await failure.resume.open()
     84     await TeraScopeFixtures.eventually { store.protection.failed }
     85     XCTAssertEqual(store.form.content, "unsaved")
     86     store.protection.cancel()
     87     store.protection.discard()
     88     XCTAssertEqual(store.form.content, "unsaved")
     89     let again = await backend.pause(.composer, fails: true)
     90     store.newDraft(type: .createEvent)
     91     await again.entered.wait()
     92     await again.resume.open()
     93     await TeraScopeFixtures.eventually { store.protection.failed }
     94     store.protection.discard()
     95     await TeraScopeFixtures.eventually { !store.protection.isWorking }
     96     XCTAssertEqual(store.form.commandType, .createEvent)
     97     XCTAssertEqual(store.form.content, "")
     98     let saved = try await client.loadComposer(scope: original.scope, id: original.id)
     99     XCTAssertEqual(saved, original)
    100     store.stop()
    101     _ = try await client.stop()
    102   }
    103 
    104   func testSavedSelectionRetryPreservesBufferBeforeLoadingAndSignalsSheetDismissal() async throws {
    105     let fixture = try await started()
    106     let backend = fixture.backend
    107     let client = fixture.client
    108     let store = fixture.store
    109     store.updateForm(\.content, "buffer")
    110     await store.save()
    111     let original = try XCTUnwrap(store.savedComposer)
    112     let failure = await backend.pause(.composer, fails: true)
    113     store.updateForm(\.content, "latest buffer")
    114     let selection = Task { await store.reopenSaved(.legacy("draft")) }
    115     await failure.entered.wait()
    116     await failure.resume.open()
    117     let applied = await selection.value
    118     XCTAssertFalse(applied)
    119     XCTAssertEqual(store.form.content, "latest buffer")
    120     XCTAssertNil(store.protection.reopened)
    121     let counts = await backend.counts
    122     XCTAssertNil(counts[.draftStatus])
    123     store.protection.retry()
    124     await TeraScopeFixtures.eventually { !store.protection.isWorking }
    125     XCTAssertEqual(store.form.content, "old")
    126     XCTAssertNotNil(store.protection.reopened)
    127     let kept = try await client.loadComposer(scope: original.scope, id: original.id)
    128     XCTAssertEqual(kept.form.content, "latest buffer")
    129     await store.save()
    130     XCTAssertNotEqual(store.savedComposer?.id, original.id)
    131     store.stop()
    132     _ = try await client.stop()
    133   }
    134 
    135   func testScopeChangeCancelsPendingReplacementAndLateSaveCannotReplaceNewAccount() async throws {
    136     let fixture = try await started()
    137     let backend = fixture.backend
    138     let client = fixture.client
    139     let store = fixture.store
    140     let pause = await backend.pause(.composer)
    141     store.updateForm(\.content, "old account")
    142     store.newDraft(type: .createEvent)
    143     await pause.entered.wait()
    144     let snapshot = TeraScopeFixtures.snapshot(account: "b")
    145     await backend.configure(snapshot)
    146     store.configure(snapshot: snapshot)
    147     await store.start()
    148     store.updateForm(\.content, "current account")
    149     await pause.resume.open()
    150     await store.save()
    151     XCTAssertEqual(store.form.content, "current account")
    152     XCTAssertEqual(store.form.commandType, .createUpdate)
    153     XCTAssertEqual(store.savedComposer?.scope.authorPublicKey, String(repeating: "b", count: 64))
    154     XCTAssertFalse(store.protection.failed)
    155     store.stop()
    156     _ = try await client.stop()
    157   }
    158 
    159   func testLegacyRetryPreservesPriorComposerIdentityAndFailedSelectionHasNoEffects() async throws {
    160     let fixture = try await started()
    161     let backend = fixture.backend
    162     let client = fixture.client
    163     let store = fixture.store
    164     store.updateForm(\.content, "first buffer")
    165     await store.save()
    166     let original = try XCTUnwrap(store.savedComposer)
    167     store.updateForm(\.content, "last buffer")
    168     await store.retry(id: "draft")
    169     XCTAssertEqual(store.form.content, "old")
    170     await store.save()
    171     XCTAssertNotEqual(store.savedComposer?.id, original.id)
    172     let kept = try await client.loadComposer(scope: original.scope, id: original.id)
    173     XCTAssertEqual(kept.form.content, "last buffer")
    174     let failure = await backend.pause(.composer, fails: true)
    175     store.updateForm(\.content, "keep for cancellation")
    176     let cancellation = Task { await store.cancel(id: "draft") }
    177     await failure.entered.wait()
    178     await failure.resume.open()
    179     await cancellation.value
    180     XCTAssertEqual(store.form.content, "keep for cancellation")
    181     let counts = await backend.counts
    182     XCTAssertEqual(counts[.draftStatus], 1)
    183     XCTAssertTrue(store.protection.failed)
    184     store.stop()
    185     _ = try await client.stop()
    186   }
    187 
    188   private struct Fixture {
    189     let backend: TeraScopeBackend
    190     let client: TeraRuntimeClient
    191     let store: TeraAddStore
    192   }
    193 
    194   func testCancelledSavedSelectionCannotApplyItsLateLoadedForm() async throws {
    195     let fixture = try await started()
    196     let store = fixture.store
    197     store.updateForm(\.content, "keep current")
    198     await store.save()
    199     let original = try XCTUnwrap(store.savedComposer)
    200     var form = TeraComposerForm(commandType: .createAsk)
    201     form.content = "other saved editing"
    202     let other = try await fixture.client.saveComposer(request: TeraComposerSaveRequest(
    203       scope: original.scope, id: String(repeating: "7", count: 32), expectedRevision: nil, editSequence: 1, form: form
    204     ))
    205     let pause = await fixture.backend.pause(.composerLoad)
    206     let selection = Task { await store.reopenSaved(.composer(other.draft.id)) }
    207     await pause.entered.wait()
    208     selection.cancel()
    209     await TeraScopeFixtures.eventually { !store.protection.isWorking }
    210     await pause.resume.open()
    211     let applied = await selection.value
    212     XCTAssertFalse(applied)
    213     XCTAssertEqual(store.form.content, "keep current")
    214     XCTAssertEqual(store.savedComposer, original)
    215     XCTAssertNil(store.protection.reopened)
    216     XCTAssertFalse(store.protection.failed)
    217     store.stop()
    218     _ = try await fixture.client.stop()
    219   }
    220 
    221   private func started() async throws -> Fixture {
    222     let backend = try TeraScopeBackend()
    223     let client = try await TeraScopeFixtures.client(backend)
    224     let store = TeraAddStore(runtimeClient: client)
    225     store.configure(snapshot: TeraScopeFixtures.snapshot())
    226     await store.start()
    227     return Fixture(backend: backend, client: client, store: store)
    228   }
    229 }