SPB Git

Repository Public

SessionTests.swift 31.0 KB 464 lines swift

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

Theme