test(desktop): add mocks for dependency injection testing

Create mock implementations of DI protocols for isolated unit testing.

- Add MockCommandExecutor with stubbing and verification helpers
- Add MockFileSystem with in-memory storage and test data builders

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: grokify

apps/desktop/Tests/PlexusOneDesktopTests/Mocks/MockCommandExecutor.swift

@@ -0,0 +1,141 @@
+import Foundation
+@testable import PlexusOneDesktop
+
+/// Mock implementation of CommandExecuting for testing
+final class MockCommandExecutor: CommandExecuting, @unchecked Sendable {
+    /// Recorded calls for verification
+    private(set) var executedCommands: [(path: String, arguments: [String])] = []
+
+    /// Stub responses keyed by command path or pattern
+    private var stubbedResults: [String: CommandResult] = [:]
+
+    /// Default result when no stub matches
+    var defaultResult: CommandResult = CommandResult(
+        exitCode: 0,
+        stdout: "",
+        stderr: ""
+    )
+
+    /// Error to throw (if set, takes precedence over results)
+    var errorToThrow: Error?
+
+    // MARK: - Stubbing
+
+    /// Stub a result for a specific command path
+    func stub(path: String, result: CommandResult) {
+        stubbedResults[path] = result
+    }
+
+    /// Stub a result for tmux commands (convenience method)
+    func stubTmux(arguments: [String], result: CommandResult) {
+        // Store by the first tmux argument as key
+        let key = arguments.first ?? "tmux"
+        stubbedResults["tmux:\(key)"] = result
+    }
+
+    /// Stub tmux list-sessions output
+    func stubListSessions(_ output: String, exitCode: Int32 = 0) {
+        stubbedResults["tmux:list-sessions"] = CommandResult(
+            exitCode: exitCode,
+            stdout: output,
+            stderr: ""
+        )
+    }
+
+    /// Stub tmux list-sessions with no server running
+    func stubNoServerRunning() {
+        stubbedResults["tmux:list-sessions"] = CommandResult(
+            exitCode: 1,
+            stdout: "",
+            stderr: "no server running on /tmp/tmux-501/default"
+        )
+    }
+
+    /// Stub tmux command success
+    func stubTmuxSuccess(arguments: [String], stdout: String = "") {
+        let key = arguments.first ?? "tmux"
+        stubbedResults["tmux:\(key)"] = CommandResult(
+            exitCode: 0,
+            stdout: stdout,
+            stderr: ""
+        )
+    }
+
+    /// Stub tmux command failure
+    func stubTmuxFailure(arguments: [String], stderr: String) {
+        let key = arguments.first ?? "tmux"
+        stubbedResults["tmux:\(key)"] = CommandResult(
+            exitCode: 1,
+            stdout: "",
+            stderr: stderr
+        )
+    }
+
+    /// Stub `which tmux` command
+    func stubWhichTmux(available: Bool) {
+        stubbedResults["/usr/bin/which"] = CommandResult(
+            exitCode: available ? 0 : 1,
+            stdout: available ? "/opt/homebrew/bin/tmux\n" : "",
+            stderr: ""
+        )
+    }
+
+    // MARK: - CommandExecuting
+
+    func execute(_ path: String, arguments: [String]) async throws -> CommandResult {
+        // Record the call
+        executedCommands.append((path: path, arguments: arguments))
+
+        // Throw error if configured
+        if let error = errorToThrow {
+            throw error
+        }
+
+        // Check for exact path match
+        if let result = stubbedResults[path] {
+            return result
+        }
+
+        // Check for tmux-prefixed match (when tmux is in path or arguments)
+        if path.contains("tmux") || arguments.first == "tmux" {
+            let tmuxArg = path.contains("tmux") ? arguments.first : arguments.dropFirst().first
+            if let arg = tmuxArg, let result = stubbedResults["tmux:\(arg)"] {
+                return result
+            }
+        }
+
+        return defaultResult
+    }
+
+    // MARK: - Verification
+
+    /// Reset all recorded calls and stubs
+    func reset() {
+        executedCommands = []
+        stubbedResults = [:]
+        errorToThrow = nil
+    }
+
+    /// Check if a command was executed
+    func wasExecuted(path: String) -> Bool {
+        executedCommands.contains { $0.path == path }
+    }
+
+    /// Check if a command was executed with specific arguments
+    func wasExecuted(path: String, arguments: [String]) -> Bool {
+        executedCommands.contains { $0.path == path && $0.arguments == arguments }
+    }
+
+    /// Get number of times a command path was executed
+    func executionCount(path: String) -> Int {
+        executedCommands.filter { $0.path == path }.count
+    }
+
+    /// Get number of times tmux was called with a specific subcommand
+    func tmuxExecutionCount(subcommand: String) -> Int {
+        executedCommands.filter { cmd in
+            (cmd.path.contains("tmux") && cmd.arguments.first == subcommand) ||
+            (cmd.arguments.first == "tmux" && cmd.arguments.dropFirst().first == subcommand)
+        }.count
+    }
+}

apps/desktop/Tests/PlexusOneDesktopTests/Mocks/MockFileSystem.swift

@@ -0,0 +1,152 @@
+import Foundation
+@testable import PlexusOneDesktop
+
+/// In-memory mock implementation of FileSystemAccessing for testing
+final class MockFileSystem: FileSystemAccessing {
+    /// In-memory file storage
+    private var files: [String: Data] = [:]
+
+    /// Track which directories have been "created"
+    private var directories: Set<String> = []
+
+    /// Track removed files/directories
+    private(set) var removedItems: [URL] = []
+
+    /// Track created directories
+    private(set) var createdDirectories: [URL] = []
+
+    /// Error to throw on next operation (if set)
+    var errorToThrow: Error?
+
+    /// Mock home directory
+    var mockHomeDirectory: URL = URL(fileURLWithPath: "/tmp/mock-home")
+
+    // MARK: - FileSystemAccessing
+
+    var homeDirectoryForCurrentUser: URL {
+        mockHomeDirectory
+    }
+
+    func fileExists(atPath path: String) -> Bool {
+        files[path] != nil || directories.contains(path)
+    }
+
+    func contents(at url: URL) throws -> Data {
+        if let error = errorToThrow {
+            throw error
+        }
+        guard let data = files[url.path] else {
+            throw NSError(domain: NSCocoaErrorDomain, code: NSFileReadNoSuchFileError)
+        }
+        return data
+    }
+
+    func write(_ data: Data, to url: URL, options: Data.WritingOptions) throws {
+        if let error = errorToThrow {
+            throw error
+        }
+        files[url.path] = data
+    }
+
+    func createDirectory(at url: URL, withIntermediateDirectories: Bool) throws {
+        if let error = errorToThrow {
+            throw error
+        }
+        directories.insert(url.path)
+        createdDirectories.append(url)
+    }
+
+    func removeItem(at url: URL) throws {
+        if let error = errorToThrow {
+            throw error
+        }
+        files.removeValue(forKey: url.path)
+        directories.remove(url.path)
+        removedItems.append(url)
+    }
+
+    // MARK: - Test Helpers
+
+    /// Set file content for a given path
+    func setFile(at path: String, content: Data) {
+        files[path] = content
+    }
+
+    /// Set file content with a string
+    func setFile(at path: String, content: String) {
+        files[path] = content.data(using: .utf8)
+    }
+
+    /// Set file content at a URL
+    func setFile(at url: URL, content: Data) {
+        files[url.path] = content
+    }
+
+    /// Get file content at a path
+    func getFile(at path: String) -> Data? {
+        files[path]
+    }
+
+    /// Get file content at a URL
+    func getFile(at url: URL) -> Data? {
+        files[url.path]
+    }
+
+    /// Reset all state
+    func reset() {
+        files = [:]
+        directories = []
+        removedItems = []
+        createdDirectories = []
+        errorToThrow = nil
+    }
+
+    /// Check if directory was created
+    func wasDirectoryCreated(at url: URL) -> Bool {
+        createdDirectories.contains(url)
+    }
+
+    /// Check if item was removed
+    func wasRemoved(at url: URL) -> Bool {
+        removedItems.contains(url)
+    }
+}
+
+// MARK: - Test Data Builders
+
+extension MockFileSystem {
+    /// Create valid v2 multi-window state JSON
+    static func makeV2StateJSON(configs: [WindowConfig] = []) -> Data {
+        let state = MultiWindowState(windows: configs)
+        let encoder = JSONEncoder()
+        encoder.dateEncodingStrategy = .iso8601
+        encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
+        return (try? encoder.encode(state)) ?? Data()
+    }
+
+    /// Create valid v1 legacy state JSON
+    static func makeV1StateJSON(
+        gridColumns: Int = 2,
+        gridRows: Int = 1,
+        paneAttachments: [String: String] = [:]
+    ) -> Data {
+        let json = """
+        {
+            "gridColumns": \(gridColumns),
+            "gridRows": \(gridRows),
+            "paneAttachments": \(paneAttachmentsJSON(paneAttachments)),
+            "savedAt": "2024-01-01T00:00:00Z",
+            "version": 1
+        }
+        """
+        return json.data(using: .utf8) ?? Data()
+    }
+
+    private static func paneAttachmentsJSON(_ attachments: [String: String]) -> String {
+        if attachments.isEmpty {
+            return "{}"
+        }
+        let pairs = attachments.map { "\"\($0.key)\": \"\($0.value)\"" }
+        return "{\(pairs.joined(separator: ", "))}"
+    }
+}