SPB Git

Repository Public

StoreTests.swift 14.8 KB 279 lines swift

1import Foundation2import Testing3@testable import MCCCore45@Suite("Store and offline cache")6@MainActor7struct StoreTests {8    static func tempDir() -> URL { FileManager.default.temporaryDirectory.appendingPathComponent("mcc-cache-\(UUID().uuidString)") }910    @Test("offline cache round-trip with timestamps; schema and key are checked; removeAll wipes")11    func cacheRoundTrip() async throws {12        let dir = Self.tempDir()13        defer { try? FileManager.default.removeItem(at: dir) }14        let cache = OfflineCache(directory: dir)15        let nodes = try JSONDecoder.mcc.decode([API.Node].self, from: Data("[\(Fixture.node())]".utf8))16        let at = Date(timeIntervalSince1970: 1_800_000_000.5)17        await cache.store(nodes, key: "nodes", receivedAt: at)18        // A new instance (next launch) reads it back, flagged as cached, with the original reception time.19        let again = OfflineCache(directory: dir)20        let snap = try #require(await again.load([API.Node].self, key: "nodes"))21        #expect(snap.value == nodes)22        #expect(snap.fromCache)23        #expect(abs(snap.receivedAt.timeIntervalSince(at)) < 0.002)24        #expect(await again.keys() == ["nodes"])25        // Wrong type or unknown key → nothing, never a crash.26        #expect(await again.load(API.ClusterOverview.self, key: "nodes") == nil)27        #expect(await again.load([API.Node].self, key: "absent") == nil)28        // A file written under another key name is not served for this key.29        let files = try FileManager.default.contentsOfDirectory(at: dir.appendingPathComponent("v\(OfflineCache.schemaVersion)"), includingPropertiesForKeys: nil)30        try FileManager.default.copyItem(at: files[0], to: files[0].deletingLastPathComponent().appendingPathComponent("other.json"))31        #expect(await again.load([API.Node].self, key: "other") == nil)32        await again.removeAll()33        #expect(await again.load([API.Node].self, key: "nodes") == nil)34        #expect(await again.keys().isEmpty)35    }3637    @Test("Resource: explicit states for loaded / 501 / 503 / 403 / failure, with the correlation id")38    func resourceStates() async throws {39        let server = StubServer()40        let mode = Box("ok")41        server.handle { _ in42            switch mode.value {43            case "ok": return .json(200, Fixture.nodeList([Fixture.node()]))44            case "501": return .error(501, code: "not_implemented", correlation: "0199aaaa-0000-7000-8000-000000000501")45            case "503": return .error(503, code: "unavailable")46            case "403": return .error(403, code: "forbidden")47            default: return .error(409, code: "conflict")48            }49        }50        let api = makeAPI(server, store: Fixture.signedInStore(for: server), getRetries: 1)51        let resource = Resource<[API.Node]> { try await api.call { try await $0.listNodes().ok.body.json.items } }52        if case .idle = resource.state {} else { Issue.record("starts idle") }53        #expect(resource.value == nil)54        mode.value = "501"55        await resource.load()56        guard case .unavailable(.notImplemented, let e) = resource.state else { Issue.record("501 → unavailable"); return }57        #expect(e?.correlationID == "0199aaaa-0000-7000-8000-000000000501")58        #expect(resource.value == nil)                         // nothing is invented59        mode.value = "503"; await resource.load()60        #expect(resource.state.unavailableReason == .serviceUnavailable(code: "unavailable"))61        mode.value = "403"; await resource.load()62        #expect(resource.state.unavailableReason == .forbidden)63        mode.value = "409"; await resource.load()64        if case .failed(let e) = resource.state { #expect(e.code == "conflict") } else { Issue.record("409 → failed") }65        mode.value = "ok"; await resource.load()66        guard case .loaded(let v, let at) = resource.state else { Issue.record("loaded"); return }67        #expect(v.count == 1 && abs(at.timeIntervalSinceNow) < 5)68        #expect(!resource.isShowingStaleData)69        // A later failure keeps the last good value visible and marks it stale.70        mode.value = "503"; await resource.load()71        #expect(resource.value?.first?.alias == "M4M64a")72        #expect(resource.isShowingStaleData)73        #expect(resource.receivedAt == at)74    }7576    @Test("Resource: cancelLoad stops the request in flight and restores the previous state (not an error)")77    func cancelLoad() async throws {78        let slow = Resource<Int> {79            try await Task.sleep(for: .seconds(30))80            return 181        }82        // Nothing loaded yet: a cancelled first load goes back to idle.83        let first = Task { await slow.load() }84        while !slow.isLoading { await Task.yield() }85        #expect(slow.state.isLoading || slow.isLoading)86        slow.cancelLoad()87        await first.value88        #expect(!slow.isLoading)89        if case .idle = slow.state {} else { Issue.record("expected idle, got \(slow.state)") }90        #expect(slow.value == nil)9192        // A value is on screen: a cancelled refresh keeps it, still marked as loaded.93        let gate = GateCounter()94        let r = Resource<Int> {95            if await gate.next() > 1 { try await Task.sleep(for: .seconds(30)) }96            return 797        }98        await r.load()99        #expect(r.value == 7)100        let refresh = Task { await r.load() }101        while !r.isLoading { await Task.yield() }102        r.cancelLoad()103        await refresh.value104        #expect(r.value == 7)105        if case .loaded(let v, _) = r.state { #expect(v == 7) } else { Issue.record("expected loaded, got \(r.state)") }106        #expect(!r.isShowingStaleData)107        // Cancelling with nothing in flight is a no-op.108        r.cancelLoad()109        #expect(r.value == 7)110    }111112    @Test("Resource: concurrent loads share one request; event patches and coalesced reloads")113    func resourceCoalescing() async throws {114        let server = StubServer()115        server.handle { _ in Thread.sleep(forTimeInterval: 0.1); return .json(200, Fixture.nodeList([Fixture.node()])) }116        let api = makeAPI(server, store: Fixture.signedInStore(for: server))117        let resource = Resource<[API.Node]> { try await api.call { try await $0.listNodes().ok.body.json.items } }118        resource.scheduleReload(after: 0)                      // inactive: ignored119        try await Task.sleep(for: .milliseconds(50))120        #expect(server.requests.isEmpty)121        async let a: Void = resource.load()122        async let b: Void = resource.load()123        async let c: Void = resource.load()124        _ = await (a, b, c)125        #expect(server.requests.count == 1)126        resource.update { $0[0].freshness = .offline }127        #expect(resource.value?.first?.freshness == .offline)128        for _ in 0..<10 { resource.scheduleReload(after: 0.05) }   // a burst of events129        #expect(await eventuallyMain { server.requests.count == 2 })130        try await Task.sleep(for: .milliseconds(250))131        #expect(server.requests.count == 2)132        #expect(resource.value?.first?.freshness == .fresh)133        await resource.loadIfNeeded(maxAge: 60)134        #expect(server.requests.count == 2)135    }136137    private func session(_ server: StubServer, cache: URL?, signedIn: Bool = true) -> AppSession {138        let store = signedIn ? Fixture.signedInStore(for: server) : InMemorySecureStore()139        let config = CoreConfiguration(origin: server.origin, secureStore: store, passkeys: SoftwareAuthenticator(origin: "http://localhost"),140                                       cacheDirectory: cache) { DeviceInfo(kind: .macos, label: "t", model: "t", osVersion: "t", appVersion: "t") }141        return AppSession(configuration: config, protocolClasses: server.protocolClasses)142    }143144    @Test("offline: the last loaded data is shown read-only with its timestamp; mutations are disabled; recovery reloads")145    func offlineReadOnly() async throws {146        let dir = Self.tempDir()147        defer { try? FileManager.default.removeItem(at: dir) }148        let server = StubServer()149        let down = Box(false)150        server.handle { r in151            if down.value { return .failure(.cannotConnectToHost) }152            switch r.path {153            case "/api/v1/me": return .json(200, Fixture.me(permissions: ["nodes.read", "alerts.ack"]))154            case "/api/v1/nodes": return .json(200, Fixture.nodeList([Fixture.node()]))155            case "/api/v1/events": return .stream(chunks: [(0, Data("event: hello\ndata: {}\n\n".utf8))])156            default: return .error(501, code: "not_implemented")157            }158        }159        // First launch, online.160        let first = session(server, cache: dir)161        await first.start()162        #expect(first.phase == .signedIn)163        #expect(first.can("alerts.ack") && !first.can("users.manage"))164        await first.nodes.list.load()165        let loadedAt = try #require(first.nodes.list.receivedAt)166        #expect(first.canMutate)167        await first.stream.stop()168169        // Second launch with the server unreachable: the session is restored from the Keychain, the data from disk.170        down.value = true171        let second = session(server, cache: dir)172        await second.start()173        #expect(second.phase == .signedIn)                     // not signed out just because the network is down174        #expect(second.me?.user.handle == "spb")               // cached /me175        await second.nodes.list.load()176        #expect(second.nodes.list.value?.first?.alias == "M4M64a")177        #expect(second.nodes.list.snapshot?.fromCache == true)178        #expect(second.nodes.list.isShowingStaleData)179        #expect(abs(try #require(second.nodes.list.receivedAt).timeIntervalSince(loadedAt)) < 0.01)   // "data from hh:mm"180        #expect(second.nodes.list.state.unavailableReason == .offline)181        #expect(await eventuallyMain { second.isOffline })182        #expect(second.offlineSince != nil)183        #expect(!second.canMutate)184        do { _ = try await second.alerts.acknowledge(id: Fixture.nodeID, comment: nil); Issue.record("must be refused offline") }185        catch { #expect(APIError.from(error).code == APIError.codeOffline) }186        #expect(server.requests.filter { $0.method != "GET" }.isEmpty)   // nothing was queued or sent187188        // The server comes back: the stream reconnects, the client is online again and reloads what is on screen.189        down.value = false190        #expect(await eventuallyMain(timeout: 8) { !second.isOffline })191        #expect(await eventuallyMain(timeout: 5) { second.nodes.list.snapshot?.fromCache == false })192        #expect(second.canMutate)193        #expect(!second.nodes.list.isShowingStaleData)194        await second.stream.stop()195    }196197    @Test("events patch the read models; resync reloads; a rejected session wipes memory and disk")198    func eventsAndSignOut() async throws {199        let dir = Self.tempDir()200        defer { try? FileManager.default.removeItem(at: dir) }201        let server = StubServer()202        let nodeCalls = Box(0)203        let revoked = Box(false)204        server.handle { r in205            if revoked.value { return r.path == "/api/v1/auth/refresh" ? .error(401, code: "refresh_rejected") : .error(401, code: "unauthenticated") }206            switch r.path {207            case "/api/v1/me": return .json(200, Fixture.me())208            case "/api/v1/nodes": nodeCalls.update { $0 += 1 }; return .json(200, Fixture.nodeList([Fixture.node()]))209            case "/api/v1/events":210                return .stream(chunks: [(0.05, sse(id: 1, event: "node.state", data: EventStreamTests.nodeState("M4M64a", freshness: "stale"))),211                                        (0.3, sse(id: 2, event: "resync", data: "{}"))])212            default: return .error(501, code: "not_implemented")213            }214        }215        let s = session(server, cache: dir)216        let seen = Box<[String]>([])217        s.addEventHandler { e in seen.update { $0.append(e.event.topic) } }218        await s.nodes.list.load()219        await s.start()220        #expect(await eventuallyMain { s.nodes.list.value?.first?.freshness == .stale })     // patched in place by node.state221        #expect(s.nodes.list.value?.first?.headline?.cpuUsagePct == 12.5)222        #expect(await eventuallyMain { seen.value == ["node.state", "resync"] })223        #expect(await eventuallyMain { nodeCalls.value >= 2 })                                 // resync → reload224        #expect(s.generation >= 1)225        #expect(s.lastEventAt != nil)226        #expect(await eventuallyMain { s.streamState.isConnected })227228        // The server revokes the session: next request → refresh rejected → signed out, everything wiped.229        revoked.value = true230        await s.nodes.list.load()231        #expect(await eventuallyMain { s.phase == .signedOut })232        #expect(s.sessionEndError?.code == "refresh_rejected")233        #expect(s.nodes.list.value == nil && s.me == nil)234        #expect(await eventuallyMain { await s.cache!.keys().isEmpty })235        #expect(await eventuallyMain { await s.stream.currentState == .idle })236    }237238    @Test("no session at launch → signed out, nothing requested")239    func signedOutStart() async throws {240        let server = StubServer()241        let s = session(server, cache: nil, signedIn: false)242        await s.start()243        #expect(s.phase == .signedOut)244        #expect(!s.canMutate)245        #expect(server.requests.isEmpty)246    }247248    @Test("action output: REST catch-up and live events merge without duplicates")249    func actionOutput() async throws {250        let server = StubServer()251        server.handle { r in252            guard r.path.hasSuffix("/output") else { return .http(status: 404) }253            if r.query["after"] == "0" || r.query["after"] == nil {254                return .json(200, Fixture.json(#"{"items":[{"id":1,"ts":"2026-11-18T21:00:00Z","kind":"output","stream":"stdout","data":"a\n"},{"id":2,"ts":"2026-11-18T21:00:01Z","kind":"output","stream":"stdout","data":"b\n"}],"next_after":2,"complete":false}"#))255            }256            return .json(200, Fixture.json(#"{"items":[],"next_after":2,"complete":false}"#))257        }258        let s = session(server, cache: nil)259        let buffer = s.actions.output(for: Fixture.nodeID)260        await s.actions.refreshOutput(for: Fixture.nodeID)261        #expect(buffer.text == "a\nb\n")262        let event = { (id: Int64, data: String) in263            try! JSONDecoder.mcc.decode(API.ActionOutputEvent.self, from: Data(#"{"action_id":"\#(Fixture.nodeID)","event_id":\#(id),"ts":"2026-11-18T21:00:02Z","stream":"stderr","data":"\#(data)"}"#.utf8))264        }265        s.handle(EventEnvelope(id: 10, event: .actionOutput(event(2, "dup"))))     // already fetched266        s.handle(EventEnvelope(id: 11, event: .actionOutput(event(3, "c"))))267        s.handle(EventEnvelope(id: 12, event: .actionOutput(event(3, "c"))))       // replay268        #expect(buffer.events.map(\.id) == [1, 2, 3])269        #expect(buffer.text == "a\nb\nc")270        #expect(buffer.events.last?.stream == .stderr)271        #expect(!buffer.complete)272    }273}274275private actor GateCounter {276    private var n = 0277    func next() -> Int { n += 1; return n }278}279
Files main
Menu

Theme