Skip to content

Fastest and only macOS Dictation app with on-device STT and custom trained AI enhancement model. Windows, iOS testflight! Android, Linux waitlist open! A local Wispr Flow alternative. Follow https://x.com/fluidvoiceapp for more

13.6 KB
Raw Blame
import AppKit

/// Runs the production coordinator and SystemPasteboardManager on a private pasteboard.
/// Only command posting and optional I/O failures are injected; no keys are sent.
/// Assertions cover backup failure recovery and preservation of newer user copies.
@main
@MainActor
enum ClipboardBackupReproductionTests {
    static func main() async {
        var failures = 0
        var cases = 0
        self.testOversizedFileFallback()
        for keepBackup in [false, true] {
            for scenario in Scenario.allCases {
                cases += 1
                let board = NSPasteboard(name: .init("fluidvoice.backup-reproduction.\(UUID().uuidString)"))
                defer { board.releaseGlobally() }
                let manager = InjectedPasteboard(board: board, scenario: scenario)
                precondition(manager.base.writeIntentionalText("old clipboard"))
                let poster = InjectedCommandPoster(succeeds: scenario != .commandFailure && scenario != .externalCopyDuringFailedPost)
                if scenario == .externalCopyDuringFailedPost {
                    poster.onPost = { precondition(manager.base.writeIntentionalText("new user copy")) }
                }
                let coordinator = PasteDeliveryCoordinator(
                    pasteboard: manager,
                    commandPoster: poster,
                    settlementDelayNanoseconds: .max
                )
                let result = await coordinator.deliver("dictated text", preserveTranscriptOnClipboard: keepBackup)
                if scenario == .newerUserCopy {
                    precondition(manager.base.writeIntentionalText("new user copy"))
                }
                coordinator.runPendingSettlementForTesting()

                let expectedResult: TextDeliveryResult = switch scenario {
                case .snapshotFailure: .recoverableFailure(.clipboardSnapshotFailed)
                case .writeFailure, .earlyWriteFailure, .externalCopyDuringFailedWrite: .recoverableFailure(.clipboardWriteFailed)
                case .commandFailure, .externalCopyDuringFailedPost: .recoverableFailure(.pasteCommandFailed)
                case .success, .newerUserCopy: .commandPosted
                }
                let hasNewerCopy = scenario == .newerUserCopy || scenario == .externalCopyDuringFailedPost || scenario == .externalCopyDuringFailedWrite
                let expectedText = hasNewerCopy
                    ? "new user copy" : (keepBackup ? "dictated text" : "old clipboard")
                let expectedPosts = [.snapshotFailure, .writeFailure, .earlyWriteFailure, .externalCopyDuringFailedWrite].contains(scenario) ? 0 : 1
                let actualText = board.string(forType: .string)
                let isTemporary = board.types?.contains(.init("org.nspasteboard.TransientType")) == true
                // Restored old content is deliberately marked transient to avoid duplicate
                // clipboard-manager entries. An enabled transcript backup must be permanent.
                let permanentBackup = !keepBackup || !isTemporary
                let passed = result == expectedResult && actualText == expectedText
                    && poster.postCount == expectedPosts && permanentBackup
                    && manager.intentionalWrites == (keepBackup && !hasNewerCopy ? 1 : 0)
                if !passed { failures += 1 }
                print("\(passed ? "PASS" : "FAIL"): backup=\(keepBackup) scenario=\(scenario.rawValue) result=\(result) clipboard=\(actualText ?? "nil") posts=\(poster.postCount)")
            }
        }
        let preparation = await self.testPreparation()
        cases += preparation.cases
        failures += preparation.failures
        let ordering = await self.testOrdering()
        cases += ordering.cases
        failures += ordering.failures
        print("\(cases - failures)/\(cases) passed; \(failures) backup contract failures. No system clipboard or real paste commands used.")
        exit(failures == 0 ? 0 : 1)
    }

    static func testOversizedFileFallback() {
        for existingText in [nil, "original label"] as [String?] {
            for oversized in [false, true] {
                let board = NSPasteboard(name: .init("fluidvoice.filename-fallback.\(UUID().uuidString)"))
                defer { board.releaseGlobally() }
                let fileURL = URL(fileURLWithPath: "/tmp/Report with spaces.pdf")
                let payloadType = NSPasteboard.PasteboardType("com.fluidvoice.tests.payload")
                let item = NSPasteboardItem()
                precondition(item.setString(fileURL.absoluteString, forType: .fileURL))
                precondition(item.setData(Data(count: oversized ? SystemPasteboardManager.maximumRepresentationBytes + 1 : 16), forType: payloadType))
                if let existingText { precondition(item.setString(existingText, forType: .string)) }
                precondition(board.writeObjects([item]))
                let manager = SystemPasteboardManager(pasteboard: board)
                guard let snapshot = manager.captureSnapshot() else { fatalError("Snapshot missing") }
                precondition(manager.writeTemporaryText("dictated", sessionID: "filename-test"))
                precondition(manager.restore(snapshot))
                precondition(board.string(forType: .fileURL).flatMap(URL.init(string:)) == fileURL)
                precondition(board.string(forType: .string) == (existingText ?? (oversized ? fileURL.lastPathComponent : nil)))
                precondition((board.data(forType: payloadType) == nil) == oversized)
                if oversized { precondition(snapshot.items.first?.portableImage == nil) }
            }
        }
        print("PASS: 4 filename fallback cases; file URLs, existing text and small payloads preserved")
    }

    static func testPreparation() async -> (cases: Int, failures: Int) {
        var failures = 0
        var cases = 0
        for backup in [false, true] {
            for returnToStart in [false, true] {
                for focusedPID: Int32? in [200, nil] {
                    cases += 1
                    let board = NSPasteboard(name: .init("fluidvoice.preparation.\(UUID().uuidString)"))
                    defer { board.releaseGlobally() }
                    let manager = InjectedPasteboard(board: board, scenario: .success)
                    precondition(manager.base.writeIntentionalText("old clipboard"))
                    let originalChangeCount = manager.changeCount
                    let poster = InjectedCommandPoster(succeeds: true)
                    let coordinator = PasteDeliveryCoordinator(pasteboard: manager, commandPoster: poster)
                    let target = DictationTargetPolicy.resolve(
                        returnToStartingField: returnToStart,
                        focusedPID: focusedPID,
                        ownPID: 999,
                        originalPID: 100,
                        originalFieldIsFocused: false
                    )
                    let ready = await coordinator.prepareForDelivery("dictated text", preserveTranscriptOnClipboard: backup) {
                        // Deterministically fail whenever restoration is requested.
                        !target.shouldRestoreOriginalFocus
                    }
                    let expectedCopy = backup && target.shouldRestoreOriginalFocus
                    let passed = ready == !target.shouldRestoreOriginalFocus
                        && board.string(forType: .string) == (expectedCopy ? "dictated text" : "old clipboard")
                        && manager.intentionalWrites == (expectedCopy ? 1 : 0)
                        && poster.postCount == 0
                        && (expectedCopy || manager.changeCount == originalChangeCount)
                    if !passed { failures += 1 }
                    print("\(passed ? "PASS" : "FAIL"): preparation backup=\(backup) returnToStart=\(returnToStart) externalFocus=\(focusedPID != nil)")
                }
            }
        }
        return (cases, failures)
    }

    static func testOrdering() async -> (cases: Int, failures: Int) {
        var failures = 0
        var cases = 0
        for backup in [false, true] {
            for externalCopy in [false, true] {
                cases += 1
                let board = NSPasteboard(name: .init("fluidvoice.queued-backup.\(UUID().uuidString)"))
                defer { board.releaseGlobally() }
                let manager = InjectedPasteboard(board: board, scenario: .success)
                precondition(manager.base.writeIntentionalText("old clipboard"))
                let poster = InjectedCommandPoster(succeeds: true)
                let coordinator = PasteDeliveryCoordinator(pasteboard: manager, commandPoster: poster, settlementDelayNanoseconds: .max)
                _ = await coordinator.deliver("first", preserveTranscriptOnClipboard: false)
                var started = false
                let pending = Task { @MainActor in
                    started = true
                    return await coordinator.copyBackup("second", enabled: backup)
                }
                for _ in 0..<100 where !started {
                    await Task.yield()
                }
                let protectedFirst = board.string(forType: .string) == "first"
                if externalCopy { precondition(manager.base.writeIntentionalText("new user copy")) }
                coordinator.runPendingSettlementForTesting()
                let copied = await pending.value
                let expected = externalCopy ? "new user copy" : (backup ? "second" : "old clipboard")
                let passed = protectedFirst && board.string(forType: .string) == expected
                    && copied == (backup && !externalCopy) && poster.postCount == 1
                    && manager.intentionalWrites == (backup && !externalCopy ? 1 : 0)
                if !passed { failures += 1 }
                print("\(passed ? "PASS" : "FAIL"): queued backup=\(backup) newerUserCopy=\(externalCopy)")
            }
        }
        // A newer dictation or user copy while focus restoration waits must win.
        for newerOutput in ["user copy", "paste", "copy only"] {
            cases += 1
            let board = NSPasteboard(name: .init("fluidvoice.stale-backup.\(UUID().uuidString)"))
            defer { board.releaseGlobally() }
            let manager = InjectedPasteboard(board: board, scenario: .success)
            precondition(manager.base.writeIntentionalText("old clipboard"))
            let coordinator = PasteDeliveryCoordinator(pasteboard: manager, commandPoster: InjectedCommandPoster(succeeds: true), settlementDelayNanoseconds: .max)
            let ready = await coordinator.prepareForDelivery("stale text", preserveTranscriptOnClipboard: true) {
                if newerOutput == "paste" {
                    _ = await coordinator.deliver("newer text", preserveTranscriptOnClipboard: true)
                    coordinator.runPendingSettlementForTesting()
                } else if newerOutput == "copy only" {
                    _ = await coordinator.copyBackup("newer text", enabled: true)
                } else {
                    precondition(manager.base.writeIntentionalText("newer text"))
                }
                return false
            }
            let passed = !ready && board.string(forType: .string) == "newer text"
            if !passed { failures += 1 }
            print("\(passed ? "PASS" : "FAIL"): stale preparation newerOutput=\(newerOutput)")
        }
        return (cases, failures)
    }
}

private enum Scenario: String, CaseIterable {
    case success, snapshotFailure, writeFailure, earlyWriteFailure, commandFailure, newerUserCopy
    case externalCopyDuringFailedWrite, externalCopyDuringFailedPost
}

@MainActor
private final class InjectedCommandPoster: PasteCommandPosting {
    let succeeds: Bool
    private(set) var postCount = 0
    var onPost: (() -> Void)?

    init(succeeds: Bool) { self.succeeds = succeeds }

    func postGlobalPasteCommand() async -> Bool {
        self.postCount += 1
        self.onPost?()
        return self.succeeds
    }
}

@MainActor
private final class InjectedPasteboard: PasteboardManaging {
    let base: SystemPasteboardManager
    let scenario: Scenario
    var changeCount: Int { self.base.changeCount }
    private(set) var intentionalWrites = 0

    init(board: NSPasteboard, scenario: Scenario) {
        self.base = SystemPasteboardManager(pasteboard: board)
        self.scenario = scenario
    }

    func captureSnapshot() -> PasteboardSnapshot? {
        self.scenario == .snapshotFailure ? nil : self.base.captureSnapshot()
    }

    func writeTemporaryText(_ text: String, sessionID: String) -> Bool {
        if self.scenario == .earlyWriteFailure { return false }
        let written = self.base.writeTemporaryText(text, sessionID: sessionID)
        if self.scenario == .externalCopyDuringFailedWrite {
            precondition(self.base.writeIntentionalText("new user copy"))
            return false
        }
        // Exercise cleanup after a write that touched the clipboard but reports failure.
        return self.scenario == .writeFailure ? false : written
    }

    func writeIntentionalText(_ text: String) -> Bool {
        self.intentionalWrites += 1
        return self.base.writeIntentionalText(text)
    }

    func isOwned(sessionID: String, expectedText: String) -> Bool {
        self.base.isOwned(sessionID: sessionID, expectedText: expectedText)
    }

    func restore(_ snapshot: PasteboardSnapshot) -> Bool { self.base.restore(snapshot) }
    func restoreTemporarySnapshot(_ snapshot: PasteboardSnapshot, sessionID: String, expectedText: String) -> Bool {
        self.base.restoreTemporarySnapshot(snapshot, sessionID: sessionID, expectedText: expectedText)
    }
}