field_ios

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

TeraSupportingStoreTests.swift (9908B)


      1 @testable import TeraApp
      2 import XCTest
      3 
      4 final class TeraSupportingStoreTests: XCTestCase {
      5     @MainActor
      6     func testSearchRejectsOversizedRawAndExpandedQueriesWithoutTruncationOrDispatch() async throws {
      7         for query in [
      8           String(repeating: "x", count: 257),
      9           String(repeating: "é", count: 128) + "a",
     10           String(repeating: " ", count: 1_048_576) + "carrots",
     11           String(repeating: "x", count: 1_048_576),
     12           "   ", "\ncarrots", "carrots\0", String(repeating: "İ", count: 86),
     13         ] {
     14             let backend = SupportingBackend()
     15             let client = try await Self.startedClient(backend)
     16             let store = TeraSearchStore(runtimeClient: client)
     17             store.configure(context: Self.context(id: "farm"))
     18             store.updateQuery(query)
     19             XCTAssertEqual(store.query, query)
     20             await store.search()
     21             XCTAssertEqual(store.state, .idle)
     22             XCTAssertTrue(store.results.isEmpty)
     23             let request = await backend.lastSearchRequest()
     24             XCTAssertNil(request)
     25             _ = try await client.stop()
     26         }
     27     }
     28 
     29     @MainActor
     30     func testSearchAcceptsExactRawAndNormalizedByteBoundaries() async throws {
     31         for query in [
     32           String(repeating: "x", count: 256), String(repeating: "é", count: 128),
     33           String(repeating: "İ", count: 85) + "a",
     34         ] {
     35             let backend = SupportingBackend()
     36             let client = try await Self.startedClient(backend)
     37             let store = TeraSearchStore(runtimeClient: client)
     38             store.configure(context: Self.context(id: "farm"))
     39             store.updateQuery(query)
     40             await store.search()
     41             let request = await backend.lastSearchRequest()
     42             XCTAssertEqual(request?.query, query)
     43             XCTAssertEqual(store.state, .loaded)
     44             _ = try await client.stop()
     45         }
     46     }
     47 
     48     @MainActor
     49     func testSearchUsesCurrentContextDeduplicatesAndClearsEmptyQueries() async throws {
     50         let backend = SupportingBackend()
     51         let client = try await Self.startedClient(backend)
     52         let store = TeraSearchStore(
     53           runtimeClient: client,
     54           clock: .fixed(unixSeconds: 1_800_000_000)
     55         )
     56         store.configure(context: Self.context(id: "farm"))
     57         store.updateQuery(" carrots ")
     58 
     59         await store.search()
     60 
     61         XCTAssertEqual(store.state, .loaded)
     62         XCTAssertEqual(store.results.map(\.id), ["card", "profile"])
     63         let request = await backend.lastSearchRequest()
     64         XCTAssertEqual(request?.contextID, "farm")
     65         XCTAssertEqual(request?.query, "carrots")
     66         store.updateQuery("   ")
     67         XCTAssertEqual(store.state, .idle)
     68         XCTAssertTrue(store.results.isEmpty)
     69         _ = try await client.stop()
     70     }
     71 
     72     @MainActor
     73     func testSearchContextChangeFencesLateResults() async throws {
     74         let backend = SupportingBackend(searchDelayNanoseconds: 40_000_000)
     75         let client = try await Self.startedClient(backend)
     76         let store = TeraSearchStore(
     77           runtimeClient: client,
     78           clock: .fixed(unixSeconds: 1_800_000_000)
     79         )
     80         store.configure(context: Self.context(id: "first"))
     81         store.updateQuery("carrots")
     82 
     83         let search = Task { await store.search() }
     84         try await Task.sleep(nanoseconds: 2_000_000)
     85         store.configure(context: Self.context(id: "second"))
     86         await search.value
     87 
     88         XCTAssertTrue(store.results.isEmpty)
     89         XCTAssertEqual(store.state, .idle)
     90         _ = try await client.stop()
     91     }
     92 
     93     @MainActor
     94     func testMePreservesAdoptedProfileFieldsAndCurrentCards() async throws {
     95         let backend = SupportingBackend()
     96         let client = try await Self.startedClient(backend)
     97         let store = TeraMeStore(
     98           runtimeClient: client,
     99           clock: .fixed(unixSeconds: 1_800_000_000)
    100         )
    101         store.configure(context: Self.context(id: "farm"))
    102 
    103         await store.start()
    104 
    105         let snapshot = try XCTUnwrap(store.snapshot)
    106         XCTAssertEqual(snapshot.profile?.displayName, "Moss Farm")
    107         XCTAssertEqual(snapshot.profile?.about, "Local roots")
    108         XCTAssertEqual(snapshot.profile?.nip05, "moss@example.com")
    109         XCTAssertEqual(snapshot.profile?.website, "https://moss.example")
    110         XCTAssertEqual(snapshot.profile?.lightningAddress, "moss@example.com")
    111         XCTAssertEqual(snapshot.cards.map(\.id), ["card"])
    112         store.stop()
    113         _ = try await client.stop()
    114     }
    115 
    116     func testVisualIdentityIsStableAndKeyBound() {
    117         let first = TeraStableVisualIdentity(publicKeyHex: String(repeating: "a", count: 64))
    118         let repeated = TeraStableVisualIdentity(publicKeyHex: String(repeating: "a", count: 64))
    119         let second = TeraStableVisualIdentity(publicKeyHex: String(repeating: "b", count: 64))
    120 
    121         XCTAssertEqual(first, repeated)
    122         XCTAssertNotEqual(first.digestHex, second.digestHex)
    123         XCTAssertTrue((0 ..< 12).contains(first.paletteIndex))
    124     }
    125 
    126     @MainActor
    127     func testSettingsRoundTripUsesTypedRuntimeAndReportsReconfigurationEffects() async throws {
    128         let backend = SupportingBackend()
    129         let client = try await Self.startedClient(backend)
    130         let store = TeraSettingsStore(runtimeClient: client)
    131 
    132         await store.load(profile: nil)
    133         XCTAssertEqual(store.settings?.identity.identities.count, 1)
    134         store.networkEnvironment = .physicalDevice
    135         store.relays = [
    136           TeraRelayPreference(url: "wss://radroots.org/", access: .readWrite),
    137           TeraRelayPreference(url: "wss://read.example/", access: .readOnly),
    138         ]
    139         store.blossomPrimaryOrigin = "https://blossom.radroots.org"
    140         store.allowCellularUploads = false
    141         store.mediaCacheMegabytes = 512
    142         store.mediaCacheArtifacts = 2000
    143 
    144         let restartRequired = await store.saveSettings()
    145 
    146         XCTAssertTrue(restartRequired)
    147         XCTAssertEqual(store.settings?.revision, 2)
    148         XCTAssertEqual(store.settings?.relays.map(\.access), [.readWrite, .readOnly])
    149         XCTAssertEqual(store.settings?.mediaCacheBytes, 512 * 1_048_576)
    150         XCTAssertEqual(store.settings?.mediaCacheArtifacts, 2000)
    151         XCTAssertEqual(store.message, "Settings saved; required changes: runtime restart, outbox requeue, media cache refresh.")
    152         XCTAssertNil(store.failureCode)
    153         _ = try await client.stop()
    154     }
    155 
    156     @MainActor
    157     func testInvalidSettingsFailClosedWithoutReplacingLastAcceptedState() async throws {
    158         let backend = SupportingBackend()
    159         let client = try await Self.startedClient(backend)
    160         let store = TeraSettingsStore(runtimeClient: client)
    161         await store.load(profile: nil)
    162         store.relays = [TeraRelayPreference(url: "https://not-a-relay.example", access: .readWrite)]
    163 
    164         let restartRequired = await store.saveSettings()
    165 
    166         XCTAssertFalse(restartRequired)
    167         XCTAssertEqual(store.failureCode, "invalid_relay_endpoint")
    168         XCTAssertEqual(store.settings?.revision, 1)
    169         let revision = await backend.settingsRevision()
    170         XCTAssertEqual(revision, 1)
    171         _ = try await client.stop()
    172     }
    173 
    174     @MainActor
    175     func testProfileEditingUsesDurableTypedStatus() async throws {
    176         let backend = SupportingBackend()
    177         let client = try await Self.startedClient(backend)
    178         let store = TeraSettingsStore(runtimeClient: client)
    179         store.profileName = "moss"
    180         store.profileDisplayName = "Moss Farm"
    181         store.profileAbout = "Local roots"
    182         store.profileNip05 = "moss@example.com"
    183 
    184         await store.saveProfile()
    185         XCTAssertEqual(store.profileStatus?.state, .queued)
    186         await store.advanceProfile()
    187         XCTAssertEqual(store.profileStatus?.state, .complete)
    188         XCTAssertEqual(store.profileStatus?.settlement?.deliverySatisfied, 1)
    189         _ = try await client.stop()
    190     }
    191 
    192     static func startedClient(_ backend: SupportingBackend) async throws -> TeraRuntimeClient {
    193         let client = TeraRuntimeClient { _ in
    194             await TeraRuntimeBackendStart(backend: backend, snapshot: backend.snapshotValue())
    195         }
    196         _ = try await client.start(configuration: configuration())
    197         return client
    198     }
    199 
    200     private static func configuration() -> TeraRuntimeLaunchConfiguration {
    201         TeraRuntimeLaunchConfiguration(
    202           applicationSupportDirectory: "/tmp/radroots-supporting-tests",
    203           publicKeyHex: String(repeating: "a", count: 64),
    204           sourceGenerationHex: String(repeating: "c", count: 64),
    205           sourceGenerationCreatedAtUnixMilliseconds: 1,
    206           protectedData: .available,
    207           networkProfile: .simulator,
    208           writableRelays: ["ws://127.0.0.1:7447"],
    209           blossom: TeraBlossomEndpointConfiguration(
    210             hostKind: .simulator,
    211             endpointAuthority: .loopbackDevelopment,
    212             primaryOrigin: "http://127.0.0.1:3000",
    213             fallbackOrigins: []
    214           ),
    215           app: TeraRuntimeAppMetadata(
    216             bundleIdentifier: "org.radroots.supporting-tests",
    217             version: "0.1.0-alpha",
    218             buildNumber: "1",
    219             buildSHA: nil
    220           ),
    221           signerGeneration: "supporting-tests",
    222           signer: SupportingSigner(),
    223           adoptBootstrapSettings: false
    224         )
    225     }
    226 
    227     private static func context(id: String) -> TeraLocalNetwork {
    228         TeraLocalNetwork(
    229           schemaVersion: 1,
    230           id: id,
    231           label: "Farm",
    232           relayURLs: ["ws://127.0.0.1:7447"],
    233           locality: "Metchosin",
    234           followedAuthors: [],
    235           generation: 1
    236         )
    237     }
    238 }
    239 
    240 private struct SupportingSigner: TeraRuntimeSigner {
    241     func availability() -> TeraRuntimeSignerAvailability {
    242         .ready
    243     }
    244 
    245     func sign(_: TeraRuntimeSigningRequest) -> TeraRuntimeSigningOutcome {
    246         .failed
    247     }
    248 }