SPB Git

Repository Public

VQFakeServer.swift 16.9 KB 291 lines swift

1// Author: Simon-Pierre Boucher — contact@spboucher.ai2// File: Sources/VQuantKitTesting/VQFakeServer.swift3// Description: An in-memory VQuant server for tests: the object store, change feed and sync stream with the rev/seq4//              rules of CONTRACT §1, plus stubs for any other route and fault injection per device.5import Foundation6import VQuantKit78public final class VQFakeServer: @unchecked Sendable {9    public typealias Handler = @Sendable (VQRequest) -> (status: Int, body: VQJSON)1011    private let lock = NSLock()12    private var objects: [VQObjectKey: VQObjectEnvelope] = [:]13    private var archived: [VQObjectKey: [VQObjectEnvelope]] = [:]14    private var seq = 015    private var nowMs: Double = 1_795_000_000_00016    private var streams: [UUID: AsyncThrowingStream<Data, Error>.Continuation] = [:]17    private var stubs: [String: Handler] = [:]18    private var log: [(device: String, request: VQRequest)] = []19    /// Kinds accepted by the store.20    public var kinds: Set<VQObjectKind> = Set(VQObjectKind.known)2122    public init() {}2324    /// A transport that talks to this server as one device.25    public func transport(device: String) -> VQFakeTransport { VQFakeTransport(server: self, device: device) }2627    /// Answers a route outside the object store (`"GET /api/quant/jobs/j1"`).28    public func stub(_ method: VQHTTPMethod, _ path: String, _ handler: @escaping Handler) { lock.withLock { stubs["\(method.rawValue) \(path)"] = handler } }2930    // MARK: inspection and control3132    public var currentSeq: Int { lock.withLock { seq } }33    public func stored(_ kind: VQObjectKind, _ id: String) -> VQObjectEnvelope? { lock.withLock { objects[VQObjectKey(kind: kind, id: id)] } }34    public var requests: [(device: String, request: VQRequest)] { lock.withLock { log } }35    public func requestCount(_ method: VQHTTPMethod, pathPrefix: String) -> Int { lock.withLock { log.filter { $0.request.method == method && $0.request.path.hasPrefix(pathPrefix) }.count } }36    public var openStreams: Int { lock.withLock { streams.count } }3738    /// A write made by the server itself (agent tool, legacy route): `device` is "server".39    @discardableResult40    public func serverWrite(_ kind: VQObjectKind, _ id: String, data: VQJSON) -> VQObjectEnvelope {41        let rev = stored(kind, id).map { $0.deleted ? 0 : $0.rev } ?? 042        let r = handle(VQRequest(.put, "/api/v2/objects/\(kind.rawValue)/\(id)", body: ["data": data, "baseRev": .number(Double(rev))]), device: "server", serverOnlyAllowed: true)43        return VQObjectEnvelope(json: r.body["object"] ?? .null)44    }4546    /// Ends every open sync stream (a network drop or a server restart).47    public func dropStreams(error: Error? = nil) {48        let open = lock.withLock { let s = streams; streams = [:]; return s }49        for c in open.values { if let error { c.finish(throwing: error) } else { c.finish() } }50    }5152    public func sendHint(topic: String, id: String? = nil) {53        var payload: VQJSONObject = ["type": "hint", "topic": .string(topic)]54        if let id { payload["id"] = .string(id) }55        broadcast(event: "hint", payload: .object(payload))56    }57    public func sendHeartbeat() { lock.withLock { for c in streams.values { c.yield(Data(": ping\n\n".utf8)) } } }58    /// Writes arbitrary bytes on every open stream (malformed frames, unknown events).59    public func sendRaw(_ text: String) { lock.withLock { for c in streams.values { c.yield(Data(text.utf8)) } } }6061    private func broadcast(event: String, payload: VQJSON) {62        let frame = Data("event: \(event)\ndata: \(payload.text())\n\n".utf8)63        lock.withLock { for c in streams.values { c.yield(frame) } }64    }6566    // MARK: the routes6768    func openStream(device: String) -> AsyncThrowingStream<Data, Error> {69        let id = UUID()70        let (stream, continuation) = AsyncThrowingStream<Data, Error>.makeStream()71        // subscribed before `hello` is written: no change is lost in between72        let hello: VQJSON = lock.withLock {73            streams[id] = continuation74            log.append((device, VQRequest(.get, "/api/v2/sync/stream")))75            return ["type": "hello", "seq": .number(Double(seq))]76        }77        continuation.onTermination = { [weak self] _ in self?.lock.withLock { self?.streams[id] = nil } }78        continuation.yield(Data("event: hello\ndata: \(hello.text())\n\n".utf8))79        return stream80    }8182    func handle(_ request: VQRequest, device: String, serverOnlyAllowed: Bool = false) -> (status: Int, body: VQJSON) {83        var notice: VQJSON?84        let result: (Int, VQJSON) = lock.withLock {85            log.append((device, request))86            if let stub = stubs["\(request.method.rawValue) \(request.path)"] { let r = stub(request); return (r.status, r.body) }87            let parts = request.path.split(separator: "/").map { String($0).removingPercentEncoding ?? String($0) }88            func query(_ name: String) -> String? { request.query.first { $0.name == name }?.value }8990            if request.path == "/api/v2/sync/changes", request.method == .get {91                let since = Int(query("since") ?? "0") ?? 092                let limit = min(1000, max(1, Int(query("limit") ?? "500") ?? 500))93                var filter: Set<VQObjectKind>?94                if let k = query("kinds") {95                    let list = k.split(separator: ",").map { VQObjectKind(String($0)) }96                    if list.contains(where: { !kinds.contains($0) }) { return (400, ["error": "Unknown kind."]) }97                    filter = Set(list)98                }99                let all = objects.values.filter { $0.seq > since && (filter?.contains($0.kind) ?? true) }.sorted { $0.seq < $1.seq }100                let page = Array(all.prefix(limit))101                return (200, ["changes": .array(page.map(\.json)), "seq": .number(Double(seq)), "more": .bool(all.count > page.count)])102            }103104            guard parts.count >= 4, parts[0] == "api", parts[1] == "v2", parts[2] == "objects" else { return (404, ["error": "Not found."]) }105            let kind = VQObjectKind(parts[3])106            guard kinds.contains(kind) else { return (404, ["error": "Unknown kind."]) }107            if parts.count == 4 {108                guard request.method == .get else { return (404, ["error": "Not found."]) }109                let live = objects.values.filter { $0.kind == kind && !$0.deleted }.sorted { ($0.updatedAt, $0.id) > ($1.updatedAt, $1.id) }110                return (200, ["objects": .array(live.map(\.json))])111            }112            let id = parts[4]113            guard VQObjectID.isValid(id) else { return (400, ["error": "Invalid id."]) }114            let key = VQObjectKey(kind: kind, id: id)115            let existing = objects[key]116117            if parts.count >= 6, parts[5] == "versions", request.method == .get {118                guard let existing, !existing.deleted else { return (404, ["error": "Not found."]) }119                let old = (archived[key] ?? []).sorted { $0.rev > $1.rev }120                if parts.count == 7, let rev = Int(parts[6]) {121                    if rev == existing.rev { return (200, ["object": existing.json]) }122                    guard let v = old.first(where: { $0.rev == rev }) else { return (404, ["error": "Not found."]) }123                    return (200, ["object": v.json])124                }125                return (200, ["versions": .array(old.map { ["rev": .number(Double($0.rev)), "updatedAt": .number($0.updatedAt.timeIntervalSince1970 * 1000), "device": .string($0.device)] })])126            }127128            switch request.method {129            case .get:130                guard let existing, !existing.deleted else { return (404, ["error": "Not found."]) }131                return (200, ["object": existing.json])132            case .put:133                if kind.isServerOnly && !serverOnlyAllowed { return (403, ["error": "This kind is written by the server only."]) }134                guard let raw = request.body, let body = try? VQJSON.parse(raw), let data = body["data"], data.objectValue != nil, let baseRev = body["baseRev"]?.intValue, baseRev >= 0 else {135                    return (400, ["error": "Invalid body."])136                }137                if data.data().count > VQObjectStoreClient.maxDataBytes { return (413, ["error": "Too large."]) }138                if let issue = Self.validate(kind, data) { return (400, ["error": .string("\(issue) is required.")]) }139                nowMs += 1000140                let now = Date(timeIntervalSince1970: nowMs / 1000)141                var next: VQObjectEnvelope142                if baseRev == 0 {143                    if let existing, !existing.deleted { return (409, ["error": "conflict", "current": existing.json]) }144                    // a tombstone is written over with baseRev 0: the revision count continues, createdAt is new145                    next = VQObjectEnvelope(kind: kind, id: id, rev: (existing?.rev ?? 0) + 1, seq: 0, createdAt: now, updatedAt: now, deleted: false, device: device, data: data)146                } else {147                    guard let existing else { return (404, ["error": "Not found."]) }148                    guard !existing.deleted, existing.rev == baseRev else { return (409, ["error": "conflict", "current": existing.json]) }149                    if VQObjectKind.versioned.contains(kind) { archived[key] = Array(((archived[key] ?? []) + [existing]).suffix(30)) }150                    next = existing151                    next.rev += 1; next.updatedAt = now; next.device = device; next.data = data152                }153                seq += 1154                next.seq = seq155                objects[key] = next156                notice = ["type": "change", "kind": .string(kind.rawValue), "id": .string(id), "rev": .number(Double(next.rev)), "seq": .number(Double(seq)), "deleted": false, "device": .string(device)]157                return (200, ["object": next.json])158            case .delete:159                guard let baseRev = query("baseRev").flatMap(Int.init) else { return (400, ["error": "baseRev is required."]) }160                guard let existing else { return (404, ["error": "Not found."]) }161                guard !existing.deleted, existing.rev == baseRev else { return (409, ["error": "conflict", "current": existing.json]) }162                nowMs += 1000163                seq += 1164                var tomb = existing165                tomb.rev += 1; tomb.seq = seq; tomb.updatedAt = Date(timeIntervalSince1970: nowMs / 1000); tomb.deleted = true; tomb.device = device; tomb.data = .object([:])166                objects[key] = tomb167                archived[key] = nil                 // a deletion erases the content and the archived versions168                notice = ["type": "change", "kind": .string(kind.rawValue), "id": .string(id), "rev": .number(Double(tomb.rev)), "seq": .number(Double(seq)), "deleted": true, "device": .string(device)]169                return (200, ["object": tomb.json])170            default:171                return (404, ["error": "Not found."])172            }173        }174        if let notice { broadcast(event: "change", payload: notice) }175        return result176    }177178    /// The required fields of each kind (the real server's zod schemas, reduced to "is the field there").179    private static func validate(_ kind: VQObjectKind, _ data: VQJSON) -> String? {180        switch kind {181        case .watchlist: return VQWatchlist(json: data).validationIssues().first182        case .portfolio: return VQPortfolio(json: data).validationIssues().first183        case .workspace: return VQWorkspace(json: data).validationIssues().first184        case .chart: return VQChart(json: data).validationIssues().first185        case .project: return VQProject(json: data).validationIssues().first186        case .note: return VQNote(json: data).validationIssues().first187        default: return nil188        }189    }190}191192/// One device's connection to a `VQFakeServer`, with switchable faults.193public final class VQFakeTransport: VQTransport, @unchecked Sendable {194    public enum Fault: Sendable {195        /// The request never reaches the server.196        case network197        /// The server applies the request, but the answer is lost (a crash or a drop between write and acknowledgement).198        case lostResponse199        /// The server answers this status without doing anything.200        case status(Int, retryAfter: TimeInterval? = nil, locked: Bool = false)201    }202    public let server: VQFakeServer203    public let device: String204    private let lock = NSLock()205    private var isOffline = false206    private var faults: [Fault] = []207    private var streamFaults: [Fault] = []208209    init(server: VQFakeServer, device: String) { self.server = server; self.device = device }210211    /// While true every request fails like a device without network.212    public var offline: Bool {213        get { lock.withLock { isOffline } }214        set { lock.withLock { isOffline = newValue } }215    }216    /// Faults applied to the next `send` calls, one each, in order.217    public func failNext(_ faults: Fault...) { lock.withLock { self.faults += faults } }218    /// Faults applied to the next attempts to open the stream.219    public func failNextStream(_ faults: Fault...) { lock.withLock { self.streamFaults += faults } }220221    private static let url = URL(string: "https://vquant.test")!222    private static func http(_ status: Int, headers: [String: String] = [:]) -> HTTPURLResponse {223        HTTPURLResponse(url: url, statusCode: status, httpVersion: "HTTP/1.1", headerFields: headers)!224    }225    private static func faultResponse(_ status: Int, _ retryAfter: TimeInterval?, _ locked: Bool) -> VQResponse {226        var headers: [String: String] = [:]227        if let retryAfter { headers["Retry-After"] = String(Int(retryAfter)) }228        if locked { headers["x-vq-locked"] = "1" }229        return VQResponse(data: Data(#"{"error":"fault"}"#.utf8), http: http(status, headers: headers))230    }231232    public func send(_ request: VQRequest) async throws -> VQResponse {233        let (off, fault): (Bool, Fault?) = lock.withLock { (isOffline, isOffline || faults.isEmpty ? nil : faults.removeFirst()) }234        if off { throw URLError(.notConnectedToInternet) }235        switch fault {236        case .network?: throw URLError(.networkConnectionLost)237        case .lostResponse?:238            _ = server.handle(request, device: device)239            throw URLError(.networkConnectionLost)240        case .status(let s, let retry, let locked)?: return Self.faultResponse(s, retry, locked)241        case nil: break242        }243        let r = server.handle(request, device: device)244        return VQResponse(data: r.body.data(), http: Self.http(r.status))245    }246247    public func stream(_ request: VQRequest) async throws -> VQByteStream {248        let (off, fault): (Bool, Fault?) = lock.withLock { (isOffline, isOffline || streamFaults.isEmpty ? nil : streamFaults.removeFirst()) }249        if off { throw URLError(.notConnectedToInternet) }250        switch fault {251        case .network?, .lostResponse?: throw URLError(.networkConnectionLost)252        case .status(let s, let retry, let locked)?:253            let r = Self.faultResponse(s, retry, locked)254            return VQByteStream(http: r.http, chunks: AsyncThrowingStream { $0.yield(r.data); $0.finish() })255        case nil: break256        }257        guard request.path == "/api/v2/sync/stream" else {258            return VQByteStream(http: Self.http(404), chunks: AsyncThrowingStream { $0.yield(Data(#"{"error":"Not found."}"#.utf8)); $0.finish() })259        }260        return VQByteStream(http: Self.http(200, headers: ["Content-Type": "text/event-stream"]), chunks: server.openStream(device: device))261    }262}263264/// A transport that answers from a list of canned responses, in order, and records what was asked.265public final class VQScriptedTransport: VQTransport, @unchecked Sendable {266    public struct Reply: Sendable {267        public var status: Int268        public var body: Data269        public var headers: [String: String]270        public init(status: Int = 200, body: Data, headers: [String: String] = [:]) { self.status = status; self.body = body; self.headers = headers }271        public init(status: Int = 200, json: VQJSON, headers: [String: String] = [:]) { self.init(status: status, body: json.data(), headers: headers) }272    }273    private let lock = NSLock()274    private var replies: [Reply]275    private var asked: [VQRequest] = []276    public init(_ replies: [Reply] = []) { self.replies = replies }277    public func enqueue(_ reply: Reply) { lock.withLock { replies.append(reply) } }278    public var requests: [VQRequest] { lock.withLock { asked } }279280    public func send(_ request: VQRequest) async throws -> VQResponse {281        let reply: Reply? = lock.withLock { asked.append(request); return replies.isEmpty ? nil : replies.removeFirst() }282        guard let reply else { throw URLError(.notConnectedToInternet) }283        return VQResponse(data: reply.body, http: HTTPURLResponse(url: URL(string: "https://vquant.test\(request.path)")!, statusCode: reply.status, httpVersion: "HTTP/1.1", headerFields: reply.headers)!)284    }285286    public func stream(_ request: VQRequest) async throws -> VQByteStream {287        let r = try await send(request)288        return VQByteStream(http: r.http, chunks: AsyncThrowingStream { $0.yield(r.data); $0.finish() })289    }290}291
Files main
Menu

Theme