Repository Public
1// ORIX DJ2// File: Packages/ORIXDJCore/Tests/ORIXDJEngineTests/SessionTests.swift3// Description: Tests of the session layer: demo tracks and analysis cache, loading, cue persistence, recording and4// export integrity, Auto DJ, projects, the control surface and the Anthropic client against a stub server.5//6// Author: Simon-Pierre Boucher7// Contact: contact@spboucher.ai8import AVFoundation9import Foundation10import ORIXAnalysis11import ORIXDSP12@testable import ORIXDJEngine13import ORIXLibrary14import ORIXMIDI15import ORIXScript16import Testing1718func tempRoot() -> URL {19 let url = FileManager.default.temporaryDirectory.appendingPathComponent("orixdj-test-\(UUID().uuidString)", isDirectory: true)20 try? FileManager.default.createDirectory(at: url, withIntermediateDirectories: true)21 return url22}2324func makeSession() throws -> DJSession {25 var c = EngineConfiguration(); c.sampleRate = 48000; c.bufferFrames = 25626 return try DJSession(root: tempRoot(), configuration: c)27}2829func loadSync(_ session: DJSession, _ id: Int64, deck: Int) async -> Result<LoadedTrack, SessionError> {30 await withCheckedContinuation { c in session.load(trackID: id, deck: deck) { c.resume(returning: $0) } }31}3233@Suite(.serialized) struct SessionTests {34 @Test func demoTracksAnalysisCacheAndLoading() async throws {35 let session = try makeSession()36 let tracks = try session.installDemoTracks(seconds: 40)37 #expect(tracks.count == 6)38 let first = tracks[0]39 guard case let .success(info) = await loadSync(session, first.id, deck: 0) else { Issue.record("load failed"); return }40 #expect(abs((info.grid?.bpm ?? 0) - 124) < 0.1)41 #expect(info.waveform?.count ?? 0 > 1000)42 #expect(info.key != nil)43 let stored = try #require(try session.library.track(id: first.id))44 #expect(stored.analysisVersion == AnalysisResult.currentVersion)45 #expect(session.storedAnalysis(for: stored) != nil)46 // The deck is cued on the first beat and plays real audio.47 #expect(abs(session.engine.deckStatus(0).position - (info.grid?.firstBeatSeconds ?? 0)) < 1e-6)48 session.engine.play(deck: 0)49 let out = session.host.renderOffline(frames: 48000)50 #expect(rms(out[0][4800...]) > 0.02)51 // History: one play recorded.52 #expect(try session.library.history(sessionID: nil, limit: 10).count == 1)53 // Loading over a playing deck is refused.54 if case .failure(.deckBusy) = await loadSync(session, tracks[1].id, deck: 0) {} else { Issue.record("a playing deck must refuse a load") }55 // Cues survive a reload.56 session.engine.pause(deck: 0)57 session.engine.seek(deck: 0, seconds: 8); _ = session.host.renderOffline(frames: 512)58 session.engine.setHotcue(deck: 0, index: 2)59 session.persistCues(deck: 0)60 _ = await loadSync(session, first.id, deck: 1)61 #expect(session.engine.deckStatus(1).hotcues[2] != nil)62 // Missing media is reported, not crashed on.63 try FileManager.default.removeItem(at: tracks[5].url)64 if case .failure(.missingMedia) = await loadSync(session, tracks[5].id, deck: 2) {} else { Issue.record("missing media not detected") }65 }6667 @Test func recordingIsBitAccurateAndExportsValidate() async throws {68 let session = try makeSession()69 let e = session.engine70 e.set(.mixer("master.limiter"), .bool(false)); e.set(.mixer("curve"), .string("linear"))71 _ = e.renderOffline(frames: 4096)72 let src = SignalSynth.pinkNoise(seconds: 4, sampleRate: 48000, amplitude: 0.3)73 let buffer = TrackBuffer(left: src, right: src, sampleRate: 48000)74 #expect(e.load(deck: 0, buffer: buffer, info: LoadedTrack(title: "noise", duration: 4, sampleRate: 48000)))75 #expect(e.renderState.recording == false)76 try session.recorder.start(directory: session.directories.recordings, name: "Take 1")77 #expect(throws: RecorderError.alreadyRecording) { try session.recorder.start(directory: session.directories.recordings, name: "Take 2") }78 _ = e.renderOffline(frames: 256)79 #expect(e.renderState.recording)80 e.play(deck: 0)81 let live = e.renderOffline(frames: 96000)[0]82 // Let the writer thread drain, as it would during a real take.83 try await Task.sleep(nanoseconds: 200_000_000)84 let take = try #require(session.recorder.stop())85 #expect(!e.renderState.recording || e.renderOffline(frames: 256).isEmpty == false)86 #expect(session.recorder.currentStatus.overruns == 0)87 let file = try AVAudioFile(forReading: take)88 #expect(Int(file.length) >= 96000)89 let read = AVAudioPCMBuffer(pcmFormat: file.processingFormat, frameCapacity: AVAudioFrameCount(file.length))!90 try file.read(into: read)91 // The take is the master output, sample for sample (256 frames of silence were recorded before play).92 var maxError: Float = 093 for i in 0 ..< 90000 { maxError = max(maxError, abs(read.floatChannelData![0][i + 256] - live[i])) }94 #expect(maxError == 0, "recording differs from the output by \(maxError)")95 #expect(Recorder.recoverableTakes(in: session.directories.recordings).map(\.lastPathComponent) == [take.lastPathComponent])9697 // Exports: every format reopens with the expected length; lossless PCM keeps the samples within its bit depth.98 for format in AudioFileFormat.allCases {99 var options = ExportOptions(); options.format = format; options.range = 0.5 ... 1.5; options.fadeIn = 0.1; options.fadeOut = 0.1100 let url = session.directories.recordings.appendingPathComponent("export-\(format.rawValue)").appendingPathExtension(format.fileExtension)101 let report = try AudioExporter.export(source: take, to: url, options: options)102 #expect(report.validated, "\(format) did not validate")103 #expect(report.frames == 48000)104 #expect(report.clippedSamples == 0)105 #expect(report.fileSize > 1000)106 let check = try AVAudioFile(forReading: url)107 let buf = AVAudioPCMBuffer(pcmFormat: check.processingFormat, frameCapacity: 48000)!108 try check.read(into: buf, frameCount: 48000)109 // Fades: silent at both ends.110 #expect(abs(buf.floatChannelData![0][0]) < 0.001, "\(format): fade-in")111 if format.isLossless {112 let offset = 24000113 var err: Float = 0114 for i in 10000 ..< 30000 { err = max(err, abs(buf.floatChannelData![0][i] - live[offset + i - 256])) }115 #expect(err < (format == .wav16 || format == .aiff16 ? 1.0 / 16384 : 1.0 / 4_000_000), "\(format): error \(err)")116 }117 }118 // Normalising to -1 dBFS lands on -1 dBFS.119 var n = ExportOptions(); n.normalizePeakDB = -1120 let norm = try AudioExporter.export(source: take, to: session.directories.recordings.appendingPathComponent("norm.wav"), options: n)121 #expect(abs(norm.peakDB - -1) < 0.01)122 #expect(norm.clippedSamples == 0)123 // Gain that clips is reported.124 var hot = ExportOptions(); hot.gainDB = 30125 #expect(try AudioExporter.export(source: take, to: session.directories.recordings.appendingPathComponent("hot.wav"), options: hot).clippedSamples > 0)126 #expect(throws: RecorderError.empty) { var bad = ExportOptions(); bad.range = 900 ... 901; _ = try AudioExporter.export(source: take, to: session.directories.recordings.appendingPathComponent("bad.wav"), options: bad) }127 }128129 @Test func autoDJMixesTheQueueWithARealTransitionScript() async throws {130 let session = try makeSession()131 let tracks = try session.installDemoTracks(seconds: 50)132 // Wait for background analysis so the planner has tempo and key.133 var unanalysed = TrackQuery(); unanalysed.scope = .unanalysed134 for _ in 0 ..< 600 {135 let pending = (try? session.library.tracks(query: unanalysed).count) ?? 0136 if session.analysisProgress == nil, pending == 0 { break }137 try await Task.sleep(nanoseconds: 50_000_000)138 }139 var settings = AutoDJSettings(); settings.bars = 4; settings.style = .bassSwap140 session.autoDJConfiguration = settings141 session.startAutoDJ(trackIDs: Array(tracks.prefix(3).map(\.id)))142 var rendered = 0143 var peakDuring: Float = 0144 while session.autoDJStatus.transitions < 2, rendered < 48000 * 150 {145 let out = session.host.renderOffline(frames: 4800)146 peakDuring = max(peakDuring, peak(out[0][...]))147 rendered += 4800148 session.autoDJTick()149 if session.loadProgress.isEmpty == false { try await Task.sleep(nanoseconds: 20_000_000) }150 }151 let status = session.autoDJStatus152 #expect(status.transitions == 2, "transitions: \(status.transitions), state \(status.state)")153 #expect(status.lastScript.contains("automation \"Auto DJ"))154 #expect(ScriptCompiler.compile(status.lastScript).succeeded)155 #expect(peakDuring > 0.05)156 // After two transitions the third track is playing on deck A again and nothing else is.157 #expect(session.engine.deckStatus(0).playing != session.engine.deckStatus(1).playing)158 #expect(session.host.stats.runtimeErrors == 0)159 session.stopAutoDJ()160 #expect(!session.autoDJStatus.enabled)161 }162163 @Test func plannerIsDeterministicAndPrefersCompatibleNeighbours() {164 let s = AutoDJSettings()165 #expect(AutoDJPlanner.keyDistance("8A", "8A") == 0)166 #expect(AutoDJPlanner.keyDistance("8A", "9A") == 1)167 #expect(AutoDJPlanner.keyDistance("8A", "8B") == 1)168 #expect(AutoDJPlanner.keyDistance("12A", "1A") == 1)169 #expect(AutoDJPlanner.keyDistance("8A", "2A") == 6)170 #expect(AutoDJPlanner.keyDistance("8A", nil) == nil)171 #expect(abs(AutoDJPlanner.tempoChange(from: 124, to: 62)!) < 1e-9)172 let tracks = [AutoDJCandidate(id: 1, bpm: 124, camelot: "8A"), AutoDJCandidate(id: 2, bpm: 140, camelot: "3B"), AutoDJCandidate(id: 3, bpm: 126, camelot: "9A"), AutoDJCandidate(id: 4, bpm: 125, camelot: "8A")]173 #expect(AutoDJPlanner.order(tracks, settings: s).map(\.id) == [1, 4, 3, 2])174 #expect(AutoDJPlanner.order(tracks, settings: s) == AutoDJPlanner.order(tracks, settings: s))175 var off = s; off.smartOrder = false176 #expect(AutoDJPlanner.order(tracks, settings: off).map(\.id) == [1, 2, 3, 4])177 for style in AutoDJStyle.allCases {178 for bars in [1, 4, 8, 16] {179 var x = s; x.style = style; x.bars = bars180 let r = ScriptCompiler.compile(AutoDJPlanner.transitionScript(from: "B", to: "A", settings: x))181 #expect(r.errors.isEmpty && r.warnings.isEmpty, "\(style) \(bars): \(r.diagnostics)")182 let sim = Simulator.run(r.program!, config: { var c = SimulationConfig(); c.decks[0].playing = false; c.decks[1].playing = true; return c }())!183 #expect(sim.error == nil)184 #expect(sim.actions.contains { $0.text.hasPrefix("deck.A.play") })185 #expect(sim.actions.contains { $0.text.hasPrefix("deck.B.pause") })186 }187 }188 }189190 @Test func projectsRoundTripAndReportMissingMedia() async throws {191 let session = try makeSession()192 let tracks = try session.installDemoTracks(seconds: 30)193 _ = await loadSync(session, tracks[0].id, deck: 0)194 _ = await loadSync(session, tracks[1].id, deck: 1)195 let e = session.engine196 e.set(.deck(0, "volume"), .gain(-9)); e.set(.deck(0, "eq.low"), .gain(-12)); e.set(.deck(1, "keylock"), .bool(true)); e.set(.deck(1, "rate"), .number(1.03))197 e.set(.mixer("crossfader"), .number(0.25)); e.set(.mixer("curve"), .string("cut"))198 let slot = e.insertEffect(.echo, rack: 0); e.setEffectParameter(rack: 0, slot: slot, index: 1, value: 0.7); e.setEffectEnabled(rack: 0, slot: slot, true)199 _ = e.insertEffect(.reverb, rack: nil)200 e.seek(deck: 0, seconds: 12); _ = e.renderOffline(frames: 512); e.setHotcue(deck: 0, index: 0)201 let savedHotcue = e.deckStatus(0).hotcues[0]202 _ = try session.library.createScript(name: "Mine", source: PresetLibrary.all[0].source)203 var doc = ProjectStore.capture(session, name: "Friday set", notes: "warm-up", scriptNames: ["Mine"])204 doc.midiProfile = MIDIMappingProfile(name: "Pads", mappings: [MIDIMapping(control: .note(channel: 0, note: 36), target: "deck.A.play", mode: .trigger)])205 let url = session.directories.root.appendingPathComponent("Friday.orixdjproject")206 try ProjectStore.save(doc, to: url)207 try ProjectStore.save(doc, to: url) // overwriting an existing package works208 #expect(FileManager.default.fileExists(atPath: url.appendingPathComponent("Scripts/Mine.orixdj").path))209 let loaded = try ProjectStore.load(url)210 #expect(loaded.name == "Friday set")211 #expect(loaded.decks[0].values["volume"] == -9)212 #expect(loaded.racks[0].slots.first?.kind == .echo)213 #expect(loaded.midiProfile?.mappings.count == 1)214215 // Restore into a fresh session; one referenced file is gone.216 let other = try makeSession()217 try FileManager.default.removeItem(at: tracks[1].url)218 let report: ProjectRestoreReport = await withCheckedContinuation { c in ProjectStore.apply(loaded, to: other) { c.resume(returning: $0) } }219 #expect(report.loadedDecks == [0])220 #expect(report.missingMedia == [tracks[1].path])221 #expect(report.scriptsRestored == 1)222 _ = other.engine.renderOffline(frames: 512)223 #expect(other.engine.value(of: .deck(0, "volume")) == .gain(-9))224 #expect(other.engine.value(of: .mixer("curve")) == .string("cut"))225 #expect(other.engine.rackStatus(0).first?.enabled == true)226 #expect(abs(Double(other.engine.rackStatus(0).first?.values[1] ?? 0) - 0.7) < 1e-6)227 #expect(savedHotcue != nil && other.engine.deckStatus(0).hotcues[0] == savedHotcue)228 #expect(abs(other.engine.deckStatus(0).position - 12) < 1e-6)229 #expect(try other.library.script(named: "Mine") != nil)230231 // Corrupt and newer projects fail with a clear error and change nothing.232 try Data("{ not json".utf8).write(to: url.appendingPathComponent("project.json"))233 #expect(throws: ProjectError.self) { try ProjectStore.load(url) }234 try Data("{\"formatVersion\": 99}".utf8).write(to: url.appendingPathComponent("project.json"))235 #expect(throws: ProjectError.newerFormat(99)) { try ProjectStore.load(url) }236 #expect(throws: ProjectError.self) { try ProjectStore.load(session.directories.root.appendingPathComponent("nope.orixdjproject")) }237 }238239 @Test func controlSurfaceAndScaling() throws {240 let session = try makeSession()241 let s = session.surface, e = session.engine242 // Scaling round-trips for every writable numeric parameter.243 for def in ScriptSchema.deckParams + ScriptSchema.mixerParams where def.writable && [.gain, .frequency, .number].contains(def.type) {244 for x in [0.0, 0.25, 0.5, 0.75, 1.0] {245 let v = ParamScale.value(def, normalized: x)246 #expect(abs(ParamScale.normalized(def, v) - x) < 1e-6, "\(def.key) at \(x)")247 }248 }249 #expect(ParamScale.value(ScriptSchema.deckParam("volume")!, normalized: 0) == .gain(-60))250 #expect(ParamScale.value(ScriptSchema.deckParam("volume")!, normalized: 1) == .gain(0))251 #expect(ParamScale.value(ScriptSchema.deckParam("eq.low")!, normalized: 0.5) == .gain(0))252 #expect(ParamScale.beatLabel(0.25) == "1/4" && ParamScale.beatLabel(0.75) == "3/4" && ParamScale.beatLabel(2) == "2")253 // Every catalogued target resolves and is unique.254 #expect(Set(ControlTargets.all.map(\.id)).count == ControlTargets.all.count)255 for t in ControlTargets.all where t.kind == .value { #expect(s.normalizedValue(of: t.id) != nil, "\(t.id) has no value") }256 for t in ControlTargets.all where t.kind == .toggle { #expect(ControlTargets.address(t.id) != nil, "\(t.id) has no address") }257 // MIDI events drive the engine.258 s.apply(.value(target: "mixer.crossfader", normalized: 0.2))259 #expect(e.value(of: .mixer("crossfader")) == .number(0.2))260 s.apply(.value(target: "deck.B.tempo", normalized: 1))261 #expect(abs((e.value(of: .deck(1, "rate"))?.numberValue ?? 0) - 1.08) < 1e-9)262 s.apply(.toggle(target: "deck.A.keylock")); #expect(e.value(of: .deck(0, "keylock")) == .bool(true))263 s.apply(.toggle(target: "fx.reverb.enabled")); #expect(e.rackStatus(nil).first?.enabled == true)264 s.apply(.momentary(target: "deck.A.cueMonitor", pressed: true)); #expect(e.value(of: .deck(0, "cue")) == .bool(true))265 s.apply(.momentary(target: "deck.A.cueMonitor", pressed: false)); #expect(e.value(of: .deck(0, "cue")) == .bool(false))266 let src = SignalSynth.clickTrack(bpm: 120, seconds: 20, sampleRate: 48000)267 #expect(e.load(deck: 0, buffer: TrackBuffer(left: src, right: src, sampleRate: 48000), info: LoadedTrack(title: "c", duration: 20, sampleRate: 48000, grid: BeatGrid(bpm: 120, firstBeatSeconds: 0))))268 s.apply(.trigger(target: "deck.A.play")); #expect(e.deckStatus(0).playing)269 _ = e.renderOffline(frames: 48000)270 s.apply(.trigger(target: "deck.A.hotcue.1")); #expect(e.deckStatus(0).hotcues[0] != nil)271 s.apply(.trigger(target: "deck.A.loop.4")); #expect(e.deckStatus(0).loop?.active == true)272 s.apply(.trigger(target: "deck.A.loopExit")); #expect(e.deckStatus(0).loop?.active == false)273 s.apply(.trigger(target: "automation.panic")); #expect(e.rackStatus(nil).first?.enabled == false)274 // A profile through the pure mapping engine reaches the same place.275 var engine = MIDIMappingEngine(profile: MIDIMappingProfile(name: "t", mappings: [MIDIMapping(control: .cc(channel: 0, controller: 7), target: "mixer.master.volume", mode: .absolute)]))276 for ev in engine.process(.controlChange(channel: 0, controller: 7, value: 127), deviceUniqueID: 1, currentValue: { _ in nil }) { s.apply(ev) }277 #expect(e.value(of: .mixer("master.volume")) == .gain(6))278 try session.saveMIDIProfile(MIDIMappingProfile(name: "Stored", mappings: []))279 #expect(session.midiProfiles().map(\.name) == ["Stored"])280 }281}282283// MARK: - Anthropic client against a stub server284285final class StubProtocol: URLProtocol, @unchecked Sendable {286 struct Reply { var status: Int; var headers: [String: String]; var body: Data }287 nonisolated(unsafe) static var handler: (@Sendable (URLRequest, Data) -> Reply)?288 nonisolated(unsafe) static var requests: [(URLRequest, Data)] = []289 static let lock = NSLock()290291 override class func canInit(with request: URLRequest) -> Bool { true }292 override class func canonicalRequest(for request: URLRequest) -> URLRequest { request }293 override func startLoading() {294 var body = request.httpBody ?? Data()295 if let stream = request.httpBodyStream {296 stream.open(); var buffer = [UInt8](repeating: 0, count: 65536)297 while stream.hasBytesAvailable { let n = stream.read(&buffer, maxLength: buffer.count); if n <= 0 { break }; body.append(buffer, count: n) }298 stream.close()299 }300 Self.lock.lock(); Self.requests.append((request, body)); let handler = Self.handler; Self.lock.unlock()301 let reply = handler?(request, body) ?? Reply(status: 500, headers: [:], body: Data())302 client?.urlProtocol(self, didReceive: HTTPURLResponse(url: request.url!, statusCode: reply.status, httpVersion: "HTTP/1.1", headerFields: reply.headers)!, cacheStoragePolicy: .notAllowed)303 client?.urlProtocol(self, didLoad: reply.body)304 client?.urlProtocolDidFinishLoading(self)305 }306 override func stopLoading() {}307308 static func client() -> AnthropicClient {309 let c = URLSessionConfiguration.ephemeral310 c.protocolClasses = [StubProtocol.self]311 lock.lock(); requests = []; lock.unlock()312 return AnthropicClient(session: URLSession(configuration: c))313 }314315 static func sse(_ text: [String], stop: String = "end_turn", model: String = "claude-opus-5-5", details: String = "") -> Data {316 var s = "event: message_start\ndata: {\"type\":\"message_start\",\"message\":{\"id\":\"msg_1\",\"model\":\"\(model)\",\"usage\":{\"input_tokens\":2100,\"cache_read_input_tokens\":1900}}}\n\n"317 s += "event: content_block_start\ndata: {\"type\":\"content_block_start\",\"index\":0,\"content_block\":{\"type\":\"thinking\",\"thinking\":\"\"}}\n\n"318 s += "event: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"thinking_delta\",\"thinking\":\"hidden\"}}\n\n"319 for t in text {320 let json = String(decoding: try! JSONSerialization.data(withJSONObject: ["type": "content_block_delta", "index": 1, "delta": ["type": "text_delta", "text": t]]), as: UTF8.self)321 s += "event: content_block_delta\ndata: \(json)\n\n"322 }323 s += "event: message_delta\ndata: {\"type\":\"message_delta\",\"delta\":{\"stop_reason\":\"\(stop)\"\(details)},\"usage\":{\"output_tokens\":55}}\n\n"324 s += "event: message_stop\ndata: {\"type\":\"message_stop\"}\n\n"325 return Data(s.utf8)326 }327}328329final class TextBox: @unchecked Sendable {330 private let lock = NSLock(); private var parts: [String] = []331 func add(_ s: String) { lock.lock(); parts.append(s); lock.unlock() }332 var all: [String] { lock.lock(); defer { lock.unlock() }; return parts }333}334335@Suite(.serialized) struct AnthropicTests {336 let key = "sk-ant-test-0000000000000000000000000000000000000000-abcd"337338 @Test func streamsTextAndSendsTheDocumentedRequest() async throws {339 let client = StubProtocol.client()340 StubProtocol.handler = { _, _ in .init(status: 200, headers: ["content-type": "text/event-stream", "request-id": "req_42"], body: StubProtocol.sse(["Here is ", "the script."])) }341 let box = TextBox()342 var settings = AnthropicSettings(); settings.effort = "high"343 let request = ScriptAssistant.request(task: .generate, prompt: "Fade A out over 8 bars", context: AssistantContext())344 let result = try await client.send(request, settings: settings, apiKey: key) { box.add($0) }345 #expect(result.text == "Here is the script.")346 #expect(box.all == ["Here is ", "the script."])347 #expect(result.stopReason == "end_turn" && result.outputTokens == 55 && result.cacheReadTokens == 1900 && result.requestID == "req_42")348 let (sent, body) = StubProtocol.requests[0]349 #expect(sent.url?.absoluteString == "https://api.anthropic.com/v1/messages")350 #expect(sent.value(forHTTPHeaderField: "x-api-key") == key)351 #expect(sent.value(forHTTPHeaderField: "anthropic-version") == "2026-10-21")352 #expect(sent.value(forHTTPHeaderField: "anthropic-beta") == "server-side-fallback-2026-07-01")353 let json = try #require(try JSONSerialization.jsonObject(with: body) as? [String: Any])354 #expect(json["model"] as? String == "claude-opus-5-5")355 #expect(json["stream"] as? Bool == true)356 #expect(json["fallbacks"] as? String == "default")357 #expect((json["output_config"] as? [String: Any])?["effort"] as? String == "high")358 // Parameters current models reject are never sent.359 for forbidden in ["temperature", "top_p", "top_k", "thinking", "budget_tokens"] { #expect(json[forbidden] == nil) }360 let system = try #require((json["system"] as? [[String: Any]])?.first)361 #expect((system["cache_control"] as? [String: Any])?["type"] as? String == "ephemeral")362 #expect((system["text"] as? String)?.contains("deck.X.filter.highpass") == true)363 // The key appears in the header only.364 #expect(!String(decoding: body, as: UTF8.self).contains("sk-ant"))365 }366367 @Test func errorsAreTypedAndRetriesAreBounded() async throws {368 let client = StubProtocol.client()369 let request = AnthropicRequest(system: "s", messages: [.init(role: "user", content: "hi")])370 func expect(_ status: Int, _ body: String = "{\"type\":\"error\",\"error\":{\"type\":\"x\",\"message\":\"nope\"}}", headers: [String: String] = [:], _ match: (AnthropicError) -> Bool) async {371 StubProtocol.handler = { _, _ in .init(status: status, headers: headers, body: Data(body.utf8)) }372 do { _ = try await client.send(request, settings: { var s = AnthropicSettings(); s.maxRequestsPerHour = 1000; return s }(), apiKey: key); Issue.record("no error for \(status)") }373 catch let e as AnthropicError { #expect(match(e), "\(status) gave \(e)") } catch { Issue.record("\(error)") }374 }375 await expect(401) { $0 == .unauthorized }376 await expect(402) { $0 == .billing }377 await expect(403) { $0 == .forbidden("nope") }378 await expect(404) { $0 == .modelNotFound("claude-opus-5-5") }379 await expect(429, headers: ["retry-after": "7"]) { $0 == .rateLimited(retryAfter: 7) }380 await expect(400) { $0 == .badRequest("nope") }381 let before = StubProtocol.requests.count382 await expect(529) { $0 == .overloaded }383 #expect(StubProtocol.requests.count - before == 3) // one try, two retries384 // Stop reasons are checked before the text is trusted.385 StubProtocol.handler = { _, _ in .init(status: 200, headers: [:], body: StubProtocol.sse([], stop: "refusal", details: ",\"stop_details\":{\"type\":\"refusal\",\"category\":\"cyber\"}")) }386 await #expect(throws: AnthropicError.refusal(category: "cyber")) { _ = try await client.send(request, settings: { var s = AnthropicSettings(); s.maxRequestsPerHour = 1000; return s }(), apiKey: key) }387 StubProtocol.handler = { _, _ in .init(status: 200, headers: [:], body: StubProtocol.sse(["cut"], stop: "max_tokens")) }388 await #expect(throws: AnthropicError.truncated) { _ = try await client.send(request, settings: { var s = AnthropicSettings(); s.maxRequestsPerHour = 1000; return s }(), apiKey: key) }389 // A deployment that rejects the fallback parameter gets one retry without it.390 StubProtocol.handler = { r, _ in391 r.value(forHTTPHeaderField: "anthropic-beta") != nil392 ? .init(status: 400, headers: [:], body: Data("{\"type\":\"error\",\"error\":{\"type\":\"invalid_request_error\",\"message\":\"Unexpected value(s) for the `anthropic-beta` header.\"}}".utf8))393 : .init(status: 200, headers: [:], body: StubProtocol.sse(["ok"]))394 }395 #expect(try await client.send(request, settings: { var s = AnthropicSettings(); s.maxRequestsPerHour = 1000; return s }(), apiKey: key).text == "ok")396 // Missing key and request budget never reach the network.397 let count = StubProtocol.requests.count398 await #expect(throws: AnthropicError.noKey) { _ = try await client.send(request, settings: AnthropicSettings(), apiKey: "") }399 var tight = AnthropicSettings(); tight.maxRequestsPerHour = 0400 await #expect(throws: AnthropicError.requestLimit(0)) { _ = try await client.send(request, settings: tight, apiKey: key) }401 #expect(StubProtocol.requests.count == count)402 }403404 @Test func modelListIsPaginated() async throws {405 let client = StubProtocol.client()406 StubProtocol.handler = { r, _ in407 let second = r.url?.query?.contains("after_id=m2") == true408 let body = second ? "{\"data\":[{\"id\":\"claude-haiku-5-5\",\"display_name\":\"Claude Haiku 5.5\"}],\"has_more\":false}"409 : "{\"data\":[{\"id\":\"claude-opus-5-5\",\"display_name\":\"Claude Opus 5.5\",\"max_input_tokens\":1000000,\"max_tokens\":128000},{\"id\":\"m2\"}],\"has_more\":true,\"last_id\":\"m2\"}"410 return .init(status: 200, headers: [:], body: Data(body.utf8))411 }412 let models = try await client.models(apiKey: key)413 #expect(models.map(\.id) == ["claude-opus-5-5", "m2", "claude-haiku-5-5"])414 #expect(models[0].maxOutputTokens == 128000 && models[1].displayName == "m2")415 StubProtocol.handler = { _, _ in .init(status: 401, headers: [:], body: Data()) }416 await #expect(throws: AnthropicError.unauthorized) { _ = try await client.models(apiKey: key) }417 }418419 @Test func keychainStoresAndMasksTheKey() {420 let service = "ai.spboucher.orix.dj.tests.\(UUID().uuidString)"421 #expect(APIKeyStore.load(service: service) == nil)422 #expect(APIKeyStore.save(" \(key)\n", service: service))423 #expect(APIKeyStore.load(service: service) == key)424 #expect(APIKeyStore.save("sk-ant-other-1111111111", service: service))425 #expect(APIKeyStore.load(service: service) == "sk-ant-other-1111111111")426 #expect(APIKeyStore.delete(service: service))427 #expect(APIKeyStore.load(service: service) == nil)428 #expect(APIKeyStore.masked(key) == "sk-ant-…abcd")429 #expect(!APIKeyStore.masked(key).contains("0000"))430 }431432 @Test func proposalsAreValidatedLocally() {433 let good = "Sure.\n\n```orixdj\nautomation \"Fade\" quantize bar {\n fx.echo.enable()\n over 8 bars { deck.A.volume -> -60dB }\n deck.A.pause()\n}\n```\n\nIt fades deck A."434 let p = ScriptAssistant.evaluate(answer: good, task: .generate)435 #expect(p.isValid)436 #expect(p.requirements?.deckLetters == ["A"])437 #expect(p.requirements?.lengthBeats == 32)438 #expect(p.explanation == "Sure.\n\n\n\nIt fades deck A." || !p.explanation.contains("automation"))439 #expect(p.risks.contains { $0.contains("stops deck A") })440 #expect(p.risks.contains { $0.contains("fx.echo") && $0.contains("switched on") })441 // Invented syntax is caught by the compiler, not run.442 let bad = ScriptAssistant.evaluate(answer: "```orixdj\nautomation \"X\" {\n deck.A.scratch(4beats)\n system(\"rm -rf\")\n}\n```", task: .generate)443 #expect(!bad.isValid)444 #expect(bad.compile?.errors.count == 2)445 #expect(bad.simulation == nil)446 // A script that fails at run time is caught by the simulator.447 let runtime = ScriptAssistant.evaluate(answer: "```\nautomation \"X\" {\n deck.D.play()\n}\n```", task: .generate)448 #expect(runtime.compile?.succeeded == true && !runtime.isValid)449 #expect(ScriptAssistant.evaluate(answer: "No script here.", task: .explain).script == nil)450 // MIDI proposals: unknown targets are dropped and reported.451 let midi = ScriptAssistant.evaluate(answer: "```json\n{\"name\":\"Pads\",\"mappings\":[{\"control\":{\"kind\":\"note\",\"channel\":0,\"number\":36},\"target\":\"deck.A.play\",\"mode\":\"trigger\"},{\"control\":{\"kind\":\"cc\",\"channel\":0,\"number\":1},\"target\":\"deck.A.launchMissiles\",\"mode\":\"absolute\"}]}\n```", task: .midi)452 #expect(midi.midiProfile?.mappings.map(\.target) == ["deck.A.play"])453 #expect(midi.midiIssues.contains { $0.contains("launchMissiles") })454 // Context preview: titles are shared only when asked for.455 var c = AssistantContext()456 c.decks = [.init(letter: "A", loaded: true, playing: true, bpm: 124, key: "8A", title: "Secret Dubplate")]457 #expect(!c.rendered().contains("Secret Dubplate"))458 c.includeTitles = true; #expect(c.rendered().contains("Secret Dubplate"))459 c.includeDecks = false; #expect(!c.rendered().contains("124"))460 let d = ScriptAssistant.diff(old: "a\nb\nc", new: "a\nB\nc\nd")461 #expect(d.map(\.kind) == [.same, .removed, .added, .same, .added])462 }463}464