@hasna/recordings 0.2.10 → 0.2.13

package/src/native/Recordings/RecordingsTests/MenuBarPresentationTests.swift

@@ -0,0 +1,98 @@
+import Foundation
+import Testing
+@testable import RecordingsLib
+
+/// The menu bar's state contract: its presentation must agree with the engine's own start
+/// gate in every state, so the surface can never offer a Start it would reject.
+struct MenuBarPresentationTests {
+    @Test("idle presents the mic and an enabled Start")
+    func idle() {
+        let presentation = MenuBarPresentation(
+            isRecording: false,
+            canStartRecording: true,
+            statusMessage: "Ready"
+        )
+        #expect(presentation.iconName == "mic.fill")
+        #expect(presentation.accessibilityLabel == "Recordings")
+        #expect(presentation.statusText == "Ready")
+        #expect(presentation.primaryActionEnabled)
+    }
+
+    @Test("recording presents the waveform and an enabled Stop affordance")
+    func recording() {
+        let presentation = MenuBarPresentation(
+            isRecording: true,
+            canStartRecording: false,
+            statusMessage: "Recording — release to stop"
+        )
+        #expect(presentation.iconName == "waveform")
+        #expect(presentation.accessibilityLabel == "Recordings, recording")
+        #expect(presentation.statusText == "Recording")
+        #expect(presentation.primaryActionEnabled, "Stop must stay available while recording")
+    }
+
+    @Test("every non-startable processing state presents busy and disables Start")
+    func busyStatesAreTruthful() {
+        for status in ["Transcribing...", "Deciding...", "Answering...", "Rewriting...", "Pasting..."] {
+            let presentation = MenuBarPresentation(
+                isRecording: false,
+                canStartRecording: false,
+                statusMessage: status
+            )
+            #expect(presentation.iconName == "ellipsis.circle", "expected busy icon for \(status)")
+            #expect(!presentation.primaryActionEnabled, "Start must be disabled during \(status)")
+            let trimmed = status.trimmingCharacters(in: .punctuationCharacters)
+            #expect(presentation.statusText == trimmed)
+            #expect(presentation.accessibilityLabel == "Recordings, \(trimmed.lowercased())")
+        }
+    }
+
+    @Test("presentation follows canStartRecording exactly, not isTranscribing alone")
+    func presentationTracksTheStartGate() {
+        // A pending intent decision keeps canStartRecording false even though
+        // isTranscribing is false — the old menu bar showed idle here and then rejected
+        // the click. The contract requires busy.
+        let deciding = MenuBarPresentation(
+            isRecording: false,
+            canStartRecording: false,
+            statusMessage: "Deciding..."
+        )
+        #expect(!deciding.primaryActionEnabled)
+        #expect(deciding.statusText == "Deciding")
+    }
+}
+
+/// Reduce Transparency surface contract: chrome must resolve to an opaque surface — never
+/// a translucent material — whenever the user has reduced transparency.
+struct ChromeSurfaceTests {
+    @Test("Reduce Transparency resolves to the opaque surface; otherwise Liquid Glass")
+    func reducedTransparencyIsOpaque() {
+        #expect(ChromeSurface.forReducedTransparency(true) == .opaque)
+        #expect(ChromeSurface.forReducedTransparency(false) == .liquidGlass)
+    }
+}
+
+/// Voice-shortcut matching contract: exact utterance only.
+struct VoiceShortcutMatchingTests {
+    @Test("a shortcut fires for the exact utterance, ignoring case, punctuation, and spacing")
+    func exactUtteranceMatches() {
+        #expect(VoiceShortcuts.matches(trigger: "add disclaimer", transcript: "add disclaimer"))
+        #expect(VoiceShortcuts.matches(trigger: "add disclaimer", transcript: "Add disclaimer."))
+        #expect(VoiceShortcuts.matches(trigger: "add disclaimer", transcript: "  ADD   DISCLAIMER!  "))
+        #expect(VoiceShortcuts.matches(trigger: "Add Disclaimer", transcript: "add disclaimer"))
+    }
+
+    @Test("ordinary sentences containing the trigger cannot hijack routing")
+    func embeddedTriggerDoesNotMatch() {
+        #expect(!VoiceShortcuts.matches(trigger: "add disclaimer", transcript: "what does add disclaimer mean?"))
+        #expect(!VoiceShortcuts.matches(trigger: "add disclaimer", transcript: "please add disclaimer to the doc"))
+        #expect(!VoiceShortcuts.matches(trigger: "add disclaimer", transcript: "add disclaimers"))
+        #expect(!VoiceShortcuts.matches(trigger: "sig", transcript: "the signature looks wrong"))
+    }
+
+    @Test("empty or whitespace triggers never match")
+    func emptyTriggerNeverMatches() {
+        #expect(!VoiceShortcuts.matches(trigger: "", transcript: ""))
+        #expect(!VoiceShortcuts.matches(trigger: "   ", transcript: "anything"))
+    }
+}

package/src/native/Recordings/RecordingsTests/NativeAppDiagnosticsTests.swift

@@ -14,6 +14,26 @@ struct NativeAppDiagnosticsTests {
         #expect(text.contains("diagnostic-test"))
     }
 
+    @Test("Native app log redacts credentials before persistence")
+    func logRedactsCredentials() throws {
+        let home = try makeHome()
+        let keyFragment = "sk-" + "synthetic-log-fragment-123456"
+        let bearerFragment = "synthetic-log-bearer-123456"
+        let tokenFragment = "synthetic-log-token-123456"
+
+        NativeAppLog.write(
+            "request failed key=\(keyFragment) Authorization: Bearer \(bearerFragment) endpoint?api_key=\(tokenFragment)",
+            homePath: home
+        )
+
+        let path = "\(home)/.hasna/recordings/Recordings.log"
+        let text = try String(contentsOfFile: path, encoding: .utf8)
+        #expect(!text.contains(keyFragment))
+        #expect(!text.contains(bearerFragment))
+        #expect(!text.contains(tokenFragment))
+        #expect(text.contains("[REDACTED]"))
+    }
+
     private func makeHome() throws -> String {
         let url = FileManager.default.temporaryDirectory
             .appendingPathComponent("recordings-diagnostics-tests-\(UUID().uuidString)")

package/src/native/Recordings/RecordingsTests/NativePCMRecorderTests.swift

@@ -1,4 +1,4 @@
-import AVFoundation
+@preconcurrency import AVFoundation
 import Testing
 @testable import RecordingsLib
 
@@ -30,4 +30,373 @@ struct NativePCMRecorderTests {
         #expect(data.count == 8)
         #expect(data.withUnsafeBytes { $0.load(as: Int16.self) } == 1)
     }
+
+    @Test("stop waits for an admitted callback, rejects later callbacks, then emits converter tail")
+    func stopDrainsAdmittedCallbackAndConverterTail() throws {
+        let inputFormat = try #require(AVAudioFormat(
+            standardFormatWithSampleRate: 48_000,
+            channels: 1
+        ))
+        let outputFormat = try #require(NativePCMRecorder.realtimeOutputFormat())
+        let converter = try #require(AVAudioConverter(from: inputFormat, to: outputFormat))
+        converter.primeMethod = .normal
+        let buffer = try #require(AVAudioPCMBuffer(pcmFormat: inputFormat, frameCapacity: 480))
+        buffer.frameLength = 480
+        let samples = try #require(buffer.floatChannelData?[0])
+        for index in 0..<Int(buffer.frameLength) {
+            samples[index] = Float(index % 32) / 32
+        }
+        let bufferBox = NativeRecorderAudioBufferBox(buffer)
+
+        let probe = NativeRecorderLifecycleProbe()
+        let tail = Data([0x54, 0x41, 0x49, 0x4c])
+        let recorder = NativePCMRecorder(
+            testingInputFormat: inputFormat,
+            outputFormat: outputFormat,
+            converter: converter,
+            stopCapture: { probe.captureStopped.signal() },
+            onCallbackAdmitted: { probe.callbackAdmitted() },
+            finalizeConverter: { _, _ in
+                probe.finalizerRan()
+                return [tail]
+            },
+            onPCM: { probe.emit($0) }
+        )
+
+        DispatchQueue.global(qos: .userInitiated).async {
+            recorder.processInputBufferForTesting(bufferBox.value)
+            probe.callbackReturned.signal()
+        }
+        #expect(probe.firstCallbackEntered.wait(timeout: .now() + 1) == .success)
+
+        DispatchQueue.global(qos: .userInitiated).async {
+            recorder.stop()
+            probe.stopReturned.signal()
+        }
+        #expect(probe.captureStopped.wait(timeout: .now() + 1) == .success)
+
+        recorder.processInputBufferForTesting(bufferBox.value)
+        #expect(probe.admissionCount == 1)
+        #expect(probe.finalizationCount == 0)
+
+        probe.releaseFirstCallback.signal()
+        #expect(probe.callbackReturned.wait(timeout: .now() + 1) == .success)
+        #expect(probe.stopReturned.wait(timeout: .now() + 1) == .success)
+        #expect(probe.finalizationCount == 1)
+        #expect(probe.emissions.last == tail)
+    }
+
+    @Test("stop executes AVAudioConverter end-of-stream finalization")
+    func stopFinalizesActualConverter() throws {
+        let inputFormat = try #require(AVAudioFormat(
+            standardFormatWithSampleRate: 44_100,
+            channels: 1
+        ))
+        let outputFormat = try #require(NativePCMRecorder.realtimeOutputFormat())
+        let converter = try #require(AVAudioConverter(from: inputFormat, to: outputFormat))
+        converter.primeMethod = .normal
+        let buffer = try #require(AVAudioPCMBuffer(pcmFormat: inputFormat, frameCapacity: 441))
+        buffer.frameLength = 441
+        let samples = try #require(buffer.floatChannelData?[0])
+        for index in 0..<Int(buffer.frameLength) {
+            samples[index] = Float(index % 16) / 16
+        }
+
+        let probe = NativeRecorderLifecycleProbe()
+        let recorder = NativePCMRecorder(
+            testingInputFormat: inputFormat,
+            outputFormat: outputFormat,
+            converter: converter,
+            stopCapture: {},
+            onCallbackAdmitted: {},
+            finalizeConverter: { converter, format in
+                probe.finalizerRan()
+                return NativePCMRecorder.finalizeConverterTail(converter, outputFormat: format)
+            },
+            onPCM: { probe.emit($0) }
+        )
+
+        recorder.processInputBufferForTesting(buffer)
+        let bytesBeforeStop = probe.emittedByteCount
+        recorder.stop()
+
+        #expect(probe.finalizationCount == 1)
+        #expect(probe.emittedByteCount > bytesBeforeStop)
+    }
+
+    @Test("start reports busy while recorder is running or another public start is failing")
+    func concurrentStartNeverReportsFalseSuccess() throws {
+        let inputFormat = try #require(AVAudioFormat(
+            standardFormatWithSampleRate: 48_000,
+            channels: 1
+        ))
+        let outputFormat = try #require(NativePCMRecorder.realtimeOutputFormat())
+        let converter = try #require(AVAudioConverter(from: inputFormat, to: outputFormat))
+        let runningRecorder = NativePCMRecorder(
+            testingInputFormat: inputFormat,
+            outputFormat: outputFormat,
+            converter: converter,
+            stopCapture: {},
+            onCallbackAdmitted: {},
+            finalizeConverter: { _, _ in [] },
+            onPCM: { _ in }
+        )
+
+        expectBusyStart(runningRecorder)
+        runningRecorder.stop()
+
+        let probe = NativeRecorderLifecycleProbe()
+        let startingRecorder = NativePCMRecorder(
+            testingInputFormat: inputFormat,
+            outputFormat: outputFormat,
+            converter: converter,
+            stopCapture: {},
+            startCapture: {
+                probe.startCaptureEntered.signal()
+                probe.releaseStartCapture.wait()
+                throw NativeRecorderTestError.syntheticStartFailure
+            },
+            onCallbackAdmitted: {},
+            finalizeConverter: { _, _ in [] },
+            startsRunning: false,
+            onPCM: { _ in }
+        )
+
+        DispatchQueue.global(qos: .userInitiated).async {
+            do {
+                try startingRecorder.start()
+                probe.recordStartResult("success")
+            } catch NativePCMRecorderError.failedToStart(_) {
+                probe.recordStartResult("failed")
+            } catch {
+                probe.recordStartResult("wrong-error")
+            }
+            probe.startReturned.signal()
+        }
+        #expect(probe.startCaptureEntered.wait(timeout: .now() + 1) == .success)
+
+        expectBusyStart(startingRecorder)
+        probe.releaseStartCapture.signal()
+        #expect(probe.startReturned.wait(timeout: .now() + 1) == .success)
+        #expect(probe.startResult == "failed")
+        #expect(startingRecorder.isIdleForTesting)
+    }
+
+    @Test("start reports busy while stop owns the recorder")
+    func startRacingStopReportsBusy() throws {
+        let inputFormat = try #require(AVAudioFormat(
+            standardFormatWithSampleRate: 48_000,
+            channels: 1
+        ))
+        let outputFormat = try #require(NativePCMRecorder.realtimeOutputFormat())
+        let converter = try #require(AVAudioConverter(from: inputFormat, to: outputFormat))
+        let probe = NativeRecorderLifecycleProbe()
+        let recorder = NativePCMRecorder(
+            testingInputFormat: inputFormat,
+            outputFormat: outputFormat,
+            converter: converter,
+            stopCapture: {
+                probe.captureStopped.signal()
+                probe.releaseCaptureStop.wait()
+            },
+            onCallbackAdmitted: {},
+            finalizeConverter: { _, _ in [] },
+            onPCM: { _ in }
+        )
+
+        DispatchQueue.global(qos: .userInitiated).async {
+            recorder.stop()
+            probe.stopReturned.signal()
+        }
+        #expect(probe.captureStopped.wait(timeout: .now() + 1) == .success)
+
+        expectBusyStart(recorder)
+        probe.releaseCaptureStop.signal()
+        #expect(probe.stopReturned.wait(timeout: .now() + 1) == .success)
+        #expect(recorder.isIdleForTesting)
+    }
+
+    @Test("stop called from a normal PCM delivery finishes without waiting on itself")
+    func reentrantStopFromPCMDelivery() throws {
+        let inputFormat = try #require(AVAudioFormat(
+            standardFormatWithSampleRate: 48_000,
+            channels: 1
+        ))
+        let outputFormat = try #require(NativePCMRecorder.realtimeOutputFormat())
+        let converter = try #require(AVAudioConverter(from: inputFormat, to: outputFormat))
+        let recorderBox = NativeRecorderReferenceBox()
+        let probe = NativeRecorderLifecycleProbe()
+        let recorder = NativePCMRecorder(
+            testingInputFormat: inputFormat,
+            outputFormat: outputFormat,
+            converter: converter,
+            stopCapture: { probe.captureStopped.signal() },
+            onCallbackAdmitted: {},
+            finalizeConverter: { _, _ in
+                probe.finalizerRan()
+                return []
+            },
+            onPCM: { _ in
+                guard probe.claimFirstReentrantStop() else { return }
+                recorderBox.recorder?.stop()
+                probe.reentrantStopReturned.signal()
+            }
+        )
+        recorderBox.recorder = recorder
+
+        DispatchQueue.global(qos: .userInitiated).async {
+            recorder.deliverPCMForTesting(Data([0x50, 0x43, 0x4d]))
+            probe.callbackReturned.signal()
+        }
+
+        #expect(probe.reentrantStopReturned.wait(timeout: .now() + 1) == .success)
+        #expect(probe.callbackReturned.wait(timeout: .now() + 1) == .success)
+        recorder.stop()
+        #expect(probe.finalizationCount == 1)
+        #expect(recorder.isIdleForTesting)
+    }
+
+    @Test("stop called from converter tail delivery returns without deadlock")
+    func reentrantStopFromTailDelivery() throws {
+        let inputFormat = try #require(AVAudioFormat(
+            standardFormatWithSampleRate: 48_000,
+            channels: 1
+        ))
+        let outputFormat = try #require(NativePCMRecorder.realtimeOutputFormat())
+        let converter = try #require(AVAudioConverter(from: inputFormat, to: outputFormat))
+        let recorderBox = NativeRecorderReferenceBox()
+        let probe = NativeRecorderLifecycleProbe()
+        let recorder = NativePCMRecorder(
+            testingInputFormat: inputFormat,
+            outputFormat: outputFormat,
+            converter: converter,
+            stopCapture: {},
+            onCallbackAdmitted: {},
+            finalizeConverter: { _, _ in [Data([0x54])] },
+            onPCM: { _ in
+                recorderBox.recorder?.stop()
+                probe.reentrantStopReturned.signal()
+            }
+        )
+        recorderBox.recorder = recorder
+
+        recorder.stop()
+
+        #expect(probe.reentrantStopReturned.wait(timeout: .now() + 1) == .success)
+        #expect(recorder.isIdleForTesting)
+    }
+
+    private func expectBusyStart(_ recorder: NativePCMRecorder) {
+        do {
+            try recorder.start()
+            Issue.record("start unexpectedly reported success for a non-idle recorder")
+        } catch NativePCMRecorderError.alreadyActive {
+            // Expected: a competing caller must never observe false success.
+        } catch {
+            Issue.record("start returned the wrong error: \(error)")
+        }
+    }
+}
+
+private final class NativeRecorderAudioBufferBox: @unchecked Sendable {
+    let value: AVAudioPCMBuffer
+
+    init(_ value: AVAudioPCMBuffer) {
+        self.value = value
+    }
+}
+
+private final class NativeRecorderReferenceBox: @unchecked Sendable {
+    var recorder: NativePCMRecorder?
+}
+
+private enum NativeRecorderTestError: Error {
+    case syntheticStartFailure
+}
+
+private final class NativeRecorderLifecycleProbe: @unchecked Sendable {
+    let firstCallbackEntered = DispatchSemaphore(value: 0)
+    let releaseFirstCallback = DispatchSemaphore(value: 0)
+    let callbackReturned = DispatchSemaphore(value: 0)
+    let captureStopped = DispatchSemaphore(value: 0)
+    let stopReturned = DispatchSemaphore(value: 0)
+    let releaseCaptureStop = DispatchSemaphore(value: 0)
+    let reentrantStopReturned = DispatchSemaphore(value: 0)
+    let startCaptureEntered = DispatchSemaphore(value: 0)
+    let releaseStartCapture = DispatchSemaphore(value: 0)
+    let startReturned = DispatchSemaphore(value: 0)
+
+    private let lock = NSLock()
+    private var admissions = 0
+    private var finalizations = 0
+    private var emitted: [Data] = []
+    private var didClaimReentrantStop = false
+    private var storedStartResult: String?
+
+    var admissionCount: Int {
+        lock.lock()
+        defer { lock.unlock() }
+        return admissions
+    }
+
+    var finalizationCount: Int {
+        lock.lock()
+        defer { lock.unlock() }
+        return finalizations
+    }
+
+    var emissions: [Data] {
+        lock.lock()
+        defer { lock.unlock() }
+        return emitted
+    }
+
+    var emittedByteCount: Int {
+        lock.lock()
+        defer { lock.unlock() }
+        return emitted.reduce(0) { $0 + $1.count }
+    }
+
+    var startResult: String? {
+        lock.lock()
+        defer { lock.unlock() }
+        return storedStartResult
+    }
+
+    func callbackAdmitted() {
+        lock.lock()
+        admissions += 1
+        let shouldBlock = admissions == 1
+        lock.unlock()
+        if shouldBlock {
+            firstCallbackEntered.signal()
+            releaseFirstCallback.wait()
+        }
+    }
+
+    func finalizerRan() {
+        lock.lock()
+        finalizations += 1
+        lock.unlock()
+    }
+
+    func emit(_ data: Data) {
+        lock.lock()
+        emitted.append(data)
+        lock.unlock()
+    }
+
+    func claimFirstReentrantStop() -> Bool {
+        lock.lock()
+        defer { lock.unlock() }
+        guard !didClaimReentrantStop else { return false }
+        didClaimReentrantStop = true
+        return true
+    }
+
+    func recordStartResult(_ result: String) {
+        lock.lock()
+        storedStartResult = result
+        lock.unlock()
+    }
 }