Repository Public
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