Repository Public
1import Foundation2import Testing3@testable import MCCCore45@Suite("Networking")6struct NetworkingTests {7 @Test("error envelope → APIError(code, message, details, correlation id)")8 func errorMapping() async throws {9 let server = StubServer()10 server.handle { r in11 switch r.path {12 case "/api/v1/nodes":13 return .json(400, Fixture.json(#"{"error":{"code":"validation_failed","message":"Bad limit","details":{"fields":{"limit":"must be 1-200"}},"correlation_id":"0199aaaa-0000-7000-8000-00000000cafe"}}"#),14 headers: ["X-Correlation-Id": "0199aaaa-0000-7000-8000-00000000cafe"])15 case "/api/v1/cluster/overview": return .error(501, code: "not_implemented")16 case "/api/v1/services": return .http(status: 502, headers: ["X-Correlation-Id": "proxy-1"], body: Data("<html>bad gateway</html>".utf8))17 case "/api/v1/models": return .http(status: 429, headers: ["Retry-After": "7", "Content-Type": "application/json"],18 body: Data(#"{"error":{"code":"rate_limited","message":"Too many requests.","correlation_id":"0199aaaa-0000-7000-8000-00000000beef"}}"#.utf8))19 default: return .http(status: 404)20 }21 }22 let api = makeAPI(server, getRetries: 1)23 do { _ = try await api.call { try await $0.listNodes().ok.body.json }; Issue.record("must throw") } catch {24 let e = APIError.from(error)25 #expect(e.status == 400)26 #expect(e.code == "validation_failed")27 #expect(e.message == "Bad limit")28 #expect(e.correlationID == "0199aaaa-0000-7000-8000-00000000cafe")29 #expect(e.invalidFields == ["limit"])30 }31 do { _ = try await api.call { try await $0.getClusterOverview().ok.body.json }; Issue.record("must throw") } catch {32 let e = APIError.from(error)33 #expect(e.isNotImplemented)34 #expect(e.correlationID != nil)35 if case .unavailable(.notImplemented, _) = Loadable<Int>.failure(e) {} else { Issue.record("501 must be an explicit unavailable state") }36 }37 // A non-envelope body (a proxy answered): nothing is invented, the header correlation id is kept.38 do { _ = try await api.call { try await $0.listServices().ok.body.json }; Issue.record("must throw") } catch {39 let e = APIError.from(error)40 #expect(e.status == 502)41 #expect(e.code == "http_502")42 #expect(e.correlationID == "proxy-1")43 }44 do { _ = try await api.call { try await $0.listInferenceServers().ok.body.json }; Issue.record("must throw") } catch {45 let e = APIError.from(error)46 #expect(e.code == "rate_limited")47 #expect(e.retryAfter == 7)48 }49 #expect(Loadable<Int>.failure(APIError(status: 503, code: "orchestrator_frozen", message: "")).unavailableReason == .serviceUnavailable(code: "orchestrator_frozen"))50 #expect(Loadable<Int>.failure(APIError(status: 403, code: "forbidden", message: "")).unavailableReason == .forbidden)51 #expect(Loadable<Int>.failure(APIError.network("down")).unavailableReason == .offline)52 if case .failed = Loadable<Int>.failure(APIError(status: 409, code: "conflict", message: "")) {} else { Issue.record("409 is a plain failure") }53 }5455 @Test("bearer injection; 20 concurrent 401s trigger exactly one refresh; every request is replayed with the new token")56 func singleFlightRefresh() async throws {57 let server = StubServer()58 let refreshes = Box(0)59 server.handle { r in60 switch (r.method, r.path) {61 case ("POST", "/api/v1/auth/refresh"):62 refreshes.update { $0 += 1 }63 guard r.json?["refresh_token"]?.stringValue == "refresh-1" else { return .error(401, code: "refresh_rejected") }64 Thread.sleep(forTimeInterval: 0.15) // keep the refresh in flight while the other 401s arrive65 return .json(200, Fixture.tokenPair(access: "access-2", refresh: "refresh-2"))66 case ("GET", "/api/v1/me"):67 return r.header("Authorization") == "Bearer access-2" ? .json(200, Fixture.me()) : .error(401, code: "session_expired")68 default: return .http(status: 404)69 }70 }71 let store = Fixture.signedInStore(for: server)72 let api = makeAPI(server, store: store)73 let handles = await withTaskGroup(of: String?.self) { group in74 for _ in 0..<20 { group.addTask { try? await api.call { try await $0.getMe().ok.body.json }.user.handle } }75 var out: [String?] = []76 for await h in group { out.append(h) }77 return out78 }79 #expect(handles.count == 20)80 #expect(handles.allSatisfy { $0 == "spb" })81 #expect(refreshes.value == 1)82 #expect(await api.tokens.refreshRequestCount == 1)83 // The rotated tokens are persisted.84 #expect(SessionStore(store: store, baseURL: server.origin).loadTokens()?.refreshToken == "refresh-2")85 // The refresh request itself carries no bearer and the public operations neither.86 #expect(server.requests("POST", "/api/v1/auth/refresh").allSatisfy { $0.header("Authorization") == nil })87 #expect(server.requests("GET", "/api/v1/me").filter { $0.header("Authorization") == "Bearer access-1" }.count == 20)88 #expect(server.requests("GET", "/api/v1/me").filter { $0.header("Authorization") == "Bearer access-2" }.count == 20)89 }9091 @Test("an access token about to expire is refreshed before the request (no 401 round trip)")92 func proactiveRefresh() async throws {93 let server = StubServer()94 server.handle { r in95 switch (r.method, r.path) {96 case ("POST", "/api/v1/auth/refresh"): return .json(200, Fixture.tokenPair(access: "access-2", refresh: "refresh-2"))97 case ("GET", "/api/v1/me"): return r.header("Authorization") == "Bearer access-2" ? .json(200, Fixture.me()) : .error(401, code: "session_expired")98 default: return .http(status: 404)99 }100 }101 let api = makeAPI(server, store: Fixture.signedInStore(for: server, expiresIn: 5))102 _ = try await api.call { try await $0.getMe().ok.body.json }103 #expect(server.requests("GET", "/api/v1/me").count == 1)104 #expect(server.requests("POST", "/api/v1/auth/refresh").count == 1)105 }106107 @Test("refresh_rejected wipes the session and reports the sign-out")108 func refreshRejected() async throws {109 let server = StubServer()110 server.handle { r in111 r.path == "/api/v1/auth/refresh" ? .error(401, code: "refresh_rejected", message: "Sign in again.") : .error(401, code: "unauthenticated")112 }113 let store = Fixture.signedInStore(for: server)114 let api = makeAPI(server, store: store)115 let ended = Task { () -> SessionEndReason? in116 for await r in await api.tokens.sessionEnds() { return r }117 return nil118 }119 try await Task.sleep(for: .milliseconds(50))120 do { _ = try await api.call { try await $0.getMe().ok.body.json }; Issue.record("must throw") } catch {121 let e = APIError.from(error)122 #expect(e.isSignedOut)123 #expect(e.correlationID != nil)124 }125 guard case .refreshRejected(let cause)? = await ended.value else { Issue.record("no end event"); return }126 #expect(cause.code == "refresh_rejected")127 #expect(store.accounts.isEmpty)128 #expect(await api.tokens.hasSession == false)129 // Signed out: later requests go out without credentials and are not refreshed again.130 _ = try? await api.call { try await $0.getMe().ok.body.json }131 #expect(server.requests("POST", "/api/v1/auth/refresh").count == 1)132 }133134 @Test("a failed refresh for a network reason keeps the session")135 func refreshNetworkFailureKeepsSession() async throws {136 let server = StubServer()137 server.handle { r in r.path == "/api/v1/auth/refresh" ? .failure(.notConnectedToInternet) : .error(401, code: "session_expired") }138 let store = Fixture.signedInStore(for: server)139 let api = makeAPI(server, store: store, getRetries: 1)140 do { _ = try await api.call { try await $0.getMe().ok.body.json }; Issue.record("must throw") } catch {141 #expect(APIError.from(error).isTransport)142 }143 #expect(await api.tokens.hasSession)144 #expect(!store.accounts.isEmpty)145 #expect(api.connectivity.isOffline)146 }147148 @Test("idempotent GETs are retried with backoff; mutations are never retried")149 func retryPolicy() async throws {150 let server = StubServer()151 let gets = Box(0)152 server.handle { r in153 if r.method == "GET" {154 let n = gets.update { $0 += 1; return $0 }155 return n < 3 ? .error(503, code: "unavailable") : .json(200, Fixture.nodeList([Fixture.node()]))156 }157 return .error(503, code: "unavailable")158 }159 let api = makeAPI(server, store: Fixture.signedInStore(for: server))160 let nodes = try await api.call { try await $0.listNodes().ok.body.json }161 #expect(nodes.items.first?.alias == "M4M64a")162 #expect(gets.value == 3)163164 do {165 _ = try await api.call { try await $0.acknowledgeAlert(path: .init(id: Fixture.nodeID), body: .json(.init())).ok.body.json }166 Issue.record("must throw")167 } catch {168 #expect(APIError.from(error).isServiceUnavailable)169 }170 #expect(server.requests.filter { $0.method == "POST" }.count == 1)171172 // Transport failure on a GET is retried too, then surfaces as a transport error.173 let down = StubServer()174 down.handle { _ in .failure(.cannotConnectToHost) }175 let api2 = makeAPI(down, store: Fixture.signedInStore(for: down))176 do { _ = try await api2.call { try await $0.listNodes().ok.body.json }; Issue.record("must throw") } catch {177 #expect(APIError.from(error).isTransport)178 }179 #expect(down.requests.count == 3)180 // A 501 is not retried: it is a stable "not available" answer.181 let notImpl = StubServer()182 notImpl.handle { _ in .error(501, code: "not_implemented") }183 let api3 = makeAPI(notImpl, store: Fixture.signedInStore(for: notImpl))184 _ = try? await api3.call { try await $0.listNodes().ok.body.json }185 #expect(notImpl.requests.count == 1)186 }187188 @Test("mutations are refused locally while offline; reads and identity calls still go out")189 func offlineGuard() async throws {190 let server = StubServer()191 server.handle { r in r.method == "GET" ? .json(200, Fixture.me()) : .http(status: 204) }192 let api = makeAPI(server, store: Fixture.signedInStore(for: server))193 api.connectivity.recordTransportFailure()194 #expect(api.connectivity.current.offlineSince != nil)195 do {196 _ = try await api.call { try await $0.acknowledgeAlert(path: .init(id: Fixture.nodeID), body: .json(.init())).ok.body.json }197 Issue.record("must be refused")198 } catch {199 #expect(APIError.from(error).code == APIError.codeOffline)200 }201 #expect(server.requests.isEmpty) // nothing was sent, nothing is queued202 _ = try await api.call { try await $0.logout().noContent } // identity stays possible203 _ = try await api.call { try await $0.getMe().ok.body.json } // a successful response flips back to online204 #expect(!api.connectivity.isOffline)205 #expect(api.connectivity.current.offlineSince == nil)206 }207208 @Test("request cancellation surfaces as a cancelled error, not as a failure")209 func cancellation() async throws {210 let server = StubServer()211 server.handle { _ in Thread.sleep(forTimeInterval: 0.5); return .json(200, Fixture.me()) }212 let api = makeAPI(server, store: Fixture.signedInStore(for: server))213 let task = Task { try await api.call { try await $0.getMe().ok.body.json } }214 try await Task.sleep(for: .milliseconds(50))215 task.cancel()216 do { _ = try await task.value; Issue.record("must throw") } catch {217 #expect(APIError.from(error).isCancelled)218 }219 #expect(!api.connectivity.isOffline)220 }221222 @Test("Idempotency-Key is stable per intent and renewed when the request changes or succeeds")223 func idempotency() async throws {224 var tracker = IdempotencyTracker()225 let k1 = tracker.key(forBody: #"{"type":"service.restart","target":"a"}"#)226 let k2 = tracker.key(forBody: #"{"type":"service.restart","target":"a"}"#) // retry of the same intent227 #expect(k1 == k2)228 let k3 = tracker.key(forBody: #"{"type":"service.restart","target":"b"}"#) // the form changed229 #expect(k3 != k1)230 #expect(tracker.key(forBody: #"{"type":"service.restart","target":"b"}"#) == k3)231 tracker.complete()232 #expect(tracker.key(forBody: #"{"type":"service.restart","target":"b"}"#) != k3)233 #expect(UUID(uuidString: k1) != nil)234235 // The key travels in the header of POST /actions, unchanged across a step-up retry.236 let server = StubServer()237 let calls = Box(0)238 server.handle { r in239 if r.path == "/api/v1/actions" {240 let n = calls.update { $0 += 1; return $0 }241 return n == 1 ? .error(503, code: "unavailable") : .error(422, code: "precheck_failed")242 }243 return .http(status: 404)244 }245 let api = makeAPI(server, store: Fixture.signedInStore(for: server))246 var form = IdempotencyTracker()247 for _ in 0..<2 {248 let key = form.key(forBody: "same")249 _ = try? await api.call {250 try await $0.createAction(headers: .init(idempotencyKey: key),251 body: .json(.init(_type: "inventory.refresh", target: .init(kind: .node, id: Fixture.nodeID)))).created.body.json252 }253 }254 let keys = server.requests("POST", "/api/v1/actions").compactMap { $0.header("Idempotency-Key") }255 #expect(keys.count == 2)256 #expect(Set(keys).count == 1)257 }258259 @Test("RFC 3339 dates with and without fractional seconds")260 func dates() throws {261 let t = FlexibleDateTranscoder()262 let a = try t.decode("2026-11-18T21:05:07Z")263 let b = try t.decode("2026-11-18T21:05:07.250Z")264 let c = try t.decode("2026-11-18T21:05:07.123456789Z")265 let d = try t.decode("2026-11-18T16:05:07.5-05:00")266 #expect(abs(b.timeIntervalSince(a) - 0.25) < 0.001)267 #expect(abs(c.timeIntervalSince(a) - 0.123456789) < 0.001)268 #expect(abs(d.timeIntervalSince(a) - 0.5) < 0.001)269 #expect(throws: (any Error).self) { try t.decode("yesterday") }270 #expect(try t.decode(try t.encode(b)) == b)271 // Decoding through the generated types.272 let user = try JSONDecoder.mcc.decode(API.User.self, from: Data(Fixture.user.utf8))273 #expect(user.handle == "spb")274 }275276 @Test("backoff grows exponentially, is capped and jittered")277 func backoff() {278 let b = Backoff(base: 0.5, cap: 30)279 #expect(b.delay(attempt: 1, random: 0) == 0.25)280 #expect(b.delay(attempt: 1, random: 1) == 0.5)281 #expect(b.delay(attempt: 4, random: 1) == 4)282 #expect(b.delay(attempt: 20, random: 1) == 30)283 #expect(b.delay(attempt: 20, random: 0) == 15)284 let samples = (0..<50).map { _ in b.delay(attempt: 3) }285 #expect(samples.allSatisfy { $0 >= 1 && $0 <= 2 })286 #expect(Set(samples).count > 10)287 }288}289290extension JSONDecoder {291 /// Decoder with the same date handling as the generated client.292 static var mcc: JSONDecoder {293 let d = JSONDecoder()294 d.dateDecodingStrategy = .custom { dec in295 let s = try dec.singleValueContainer().decode(String.self)296 return try FlexibleDateTranscoder().decode(s)297 }298 return d299 }300}301