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