SPB Git

Repository Public

NetworkingTests.swift 15.8 KB 301 lines swift

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
Files main
Menu

Theme