Initial release

Tests/KnotchyCoreTests/Support/SetupFakes.swift

@@ -0,0 +1,117 @@
+import Foundation
+import Synchronization
+@testable import KnotchyCore
+
+final class FakeHost: HostChecking {
+    private let value = Mutex(HostFacts(unsupported: nil, osVersion: "macOS 27.0", bytesFree: 212_000_000_000))
+
+    var current: HostFacts {
+        get { value.withLock { $0 } }
+        set { value.withLock { $0 = newValue } }
+    }
+
+    func facts() async -> HostFacts { current }
+}
+
+@MainActor
+final class FakeInstallerSession: InstallerSession {
+    var hasQuit: Bool
+
+    nonisolated init(hasQuit: Bool = true) {
+        self.hasQuit = hasQuit
+    }
+}
+
+final class FakeInstaller: RuntimeInstalling {
+    enum Opening: Sendable {
+        case opened
+        case changed
+        case failed(String)
+    }
+
+    private struct State {
+        var downloadError: DownloadError?
+        var opening: Opening = .opened
+        var calls: [String] = []
+    }
+
+    private let state = Mutex(State())
+    /// What `.opened` hands out; it has already quit unless a test says otherwise.
+    let session = FakeInstallerSession()
+
+    var calls: [String] { state.withLock { $0.calls } }
+    func failDownload(with error: DownloadError) { state.withLock { $0.downloadError = error } }
+    func open(with opening: Opening) { state.withLock { $0.opening = opening } }
+
+    func download(_ release: ContainerRuntime.Release,
+                  progress: @escaping @Sendable (Int64) -> Void) async throws -> DownloadedPackage {
+        let error = state.withLock { s -> DownloadError? in
+            s.calls.append("download")
+            return s.downloadError
+        }
+        if let error { throw error }
+        return DownloadedPackage(directory: URL(fileURLWithPath: "/fake/knotchy-runtime"), name: release.url.lastPathComponent)
+    }
+
+    @MainActor
+    func openInInstaller(_ package: DownloadedPackage, release: ContainerRuntime.Release) async -> InstallerOpening {
+        let opening = state.withLock { s -> Opening in
+            s.calls.append("open")
+            return s.opening
+        }
+        switch opening {
+        case .opened: return .opened(session)
+        case .changed: return .changed
+        case .failed(let message): return .failed(message)
+        }
+    }
+
+    func discard(_ package: DownloadedPackage) {
+        state.withLock { $0.calls.append("discard") }
+    }
+}
+
+@MainActor
+final class FakeSetupDriver: SetupDriving {
+    var state: SessionState = .idle
+    var setupLog: String?
+    var setupOutput: [String] = []
+    /// Used in order; the last one repeats.
+    var runtimeStatuses: [RuntimeStatus] = [.current("1.4.1")]
+    /// Used in order; then `.ready`.
+    var checkResults: [SetupRunOutcome?] = []
+    var runResults: [SetupRunOutcome?] = []
+    var holdResult: Result<Void, RuntimeHoldRefusal> = .success(())
+    var finishResult: SetupRunOutcome = .ready
+    private(set) var calls: [String] = []
+
+    func runtimeStatus() async -> RuntimeStatus {
+        calls.append("runtimeStatus")
+        return runtimeStatuses.count > 1 ? runtimeStatuses.removeFirst() : runtimeStatuses[0]
+    }
+
+    func checkSetup() async -> SetupRunOutcome? {
+        calls.append("checkSetup")
+        return checkResults.isEmpty ? .ready : checkResults.removeFirst()
+    }
+
+    func runSetup(_ issue: SetupIssue, continuing: Bool) async -> SetupRunOutcome? {
+        calls.append("runSetup(\(issue), continuing: \(continuing))")
+        return runResults.isEmpty ? .ready : runResults.removeFirst()
+    }
+
+    func beginRuntimeInstall(replacing found: String?) async -> Result<Void, RuntimeHoldRefusal> {
+        calls.append("begin(\(found ?? "nil"))")
+        return holdResult
+    }
+
+    func finishRuntimeInstall(_ result: RuntimeInstallResult) async -> SetupRunOutcome {
+        calls.append("finish(\(result))")
+        return finishResult
+    }
+
+    func waitWhileSettingUp() async {
+        calls.append("wait")
+        state = .idle
+    }
+}