Skip to content

Play your own Switch games on iPhone/iPad — one-click macOS app, no terminal. | 把 Switch 游戏装进 iPhone:图形界面一键构建,不用命令行。Bring your own game.

26.6 KB
Raw Blame
import XCTest
@testable import NXModel
@testable import NXCore

/// `BuildStore` without SwiftUI: the other stores are fakes behind the narrow protocols (`RepoLocation`, `DependencyInstalling`,
/// `EngineSyncing`, `InstallTarget`), the panels and the alert are closures that record, the defaults are a suite of their own and
/// the files are in a temporary folder. No process starts and nothing is built: these tests drive the inputs, the script's events,
/// the failure, "Build anyway" and the conditions that stop a build before it starts.
@MainActor final class BuildStoreTests: XCTestCase {
    private final class FakeRepo: RepoLocation {
        var path = "/repo"
        var isRepo = true
        var isGit = true
    }

    private final class FakeDeps: DependencyInstalling {
        var pythonPath = "/usr/bin/python3"
        var dotnetPath = "/usr/bin/true"
        var checked = true
        var allPresent = true
        var deps: [Dep] = []
        var installed: [String] = []
        var busy: Set<String> = []
        func isInstalling(_ id: String) -> Bool { busy.contains(id) }
        func install(_ dep: Dep) -> Task<Void, Never> { installed.append(dep.id); return Task {} }
    }

    private final class FakeEngine: EngineSyncing {
        var syncs = 0
        func syncEngine(then: ((Bool) -> Void)?) -> Task<Void, Never> { syncs += 1; then?(true); return Task {} }
    }

    private final class FakeDevices: InstallTarget {
        var installDevice = ""
        var signingTeam = ""
        var exportIPA = false
        var exportOneGame = false
        var driveFolder = ""
        var devices: [AppleDevice] = []
        var xcrun = "/usr/bin/true"
        var readTeams: @Sendable () -> [SigningTeam] = { [] }
        func deviceName(_ udid: String) -> String { devices.first { $0.id == udid }?.name ?? "iPhone" }
        nonisolated func askCopy(_ plan: ShellCopyPlan) -> ShellCopyDecision { .skip }
        nonisolated func setWaiting(_ on: Bool) {}
        nonisolated var waitCancelled: Bool { false }
        func copyEnded() {}
    }

    private var suite: String!
    private var defaults: UserDefaults!
    private var temporary: URL!
    private let repo = FakeRepo()
    private let deps = FakeDeps()
    private let engine = FakeEngine()
    private let devices = FakeDevices()
    private let localizer = Localizer(.en)

    override func setUpWithError() throws {
        suite = "nxmodel-build-tests-" + UUID().uuidString
        defaults = UserDefaults(suiteName: suite)
        temporary = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
        try FileManager.default.createDirectory(at: temporary, withIntermediateDirectories: true)
    }

    override func tearDownWithError() throws {
        defaults.removePersistentDomain(forName: suite)
        try? FileManager.default.removeItem(at: temporary)
    }

    private func makeStore(targetChanged: @escaping () -> Void = {}) -> BuildStore {
        BuildStore(localizer: localizer, runner: FakeProcessRunner(), repo: repo, deps: deps, engine: engine, devices: devices,
                   defaults: defaults, targetChanged: targetChanged)
    }

    private func file(_ name: String) throws -> String {
        let url = temporary.appendingPathComponent(name)
        try Data([0]).write(to: url)
        return url.path
    }

    // MARK: The conditions to start

    func testABuildMayStartOnlyWithARepositoryTheBaseGameTheKeysAndTheToolsAndNoRunningBuild() throws {
        let store = makeStore()
        XCTAssertFalse(store.canBuild, "no files yet")
        store.updateSlot("base") { $0.paths = [try! file("Game [0100000000001000].nsp")] }
        store.updateSlot("keys") { $0.paths = [try! file("prod.keys")] }
        XCTAssertTrue(store.canBuild)
        repo.isRepo = false
        XCTAssertFalse(store.canBuild, "the repository is not usable")
        repo.isRepo = true; deps.allPresent = false
        XCTAssertFalse(store.canBuild, "a tool is missing")
        deps.allPresent = true; store.running = true
        XCTAssertFalse(store.canBuild, "a build runs")
    }

    /// #416: the export choice is not an install, so the stop for a missing device and team does not apply to it.
    func testTheExportChoiceNeedsNoDeviceAndNoTeam() {
        let store = makeStore()
        store.target = "ios"
        devices.exportIPA = true
        XCTAssertTrue(store.exportsShell)
        XCTAssertFalse(store.installsDirectly)
        store.startBuild()
        XCTAssertNotEqual(store.doneNote, store.t("shell.needsDevice"))
        store.target = BuildTarget.mac
        XCTAssertFalse(store.exportsShell, "a Mac app is never an IPA")
    }

    func testAnIPhoneBuildWithoutADeviceStopsBeforeTheLongSteps() {
        let store = makeStore()
        store.target = "ios"
        store.startBuild()
        XCTAssertFalse(store.running)
        XCTAssertEqual(store.doneNote, store.t("shell.needsDevice"))
        XCTAssertFalse(store.installsDirectly)
        devices.installDevice = "UDID"; devices.signingTeam = "TEAM"
        XCTAssertTrue(store.installsDirectly)
        store.target = "mac-app"
        XCTAssertFalse(store.installsDirectly, "a Mac app is not installed on a device")
    }

    func testABuildWithoutARepositoryEndsWithTheMessageAndRunsNothing() {
        let store = makeStore()
        store.target = "mac-app"
        repo.isRepo = false; repo.path = ""
        store.startBuild()
        XCTAssertFalse(store.running)
        XCTAssertEqual(store.doneNote, store.t("msg.repoInvalidEmpty"))
        XCTAssertTrue(store.log.text.contains("✗"), "the log says it too")
    }

    // MARK: The inputs

    func testTheTargetTheOutputFolderAndTheCompatibilitySwitchAreSavedAndTheTargetTellsTheApp() {
        var changes = 0
        let store = makeStore { changes += 1 }
        store.target = "mac-app"; store.outDir = "/out"; store.bcOnCPU = true
        XCTAssertEqual(defaults.string(forKey: BuildStore.targetKey), "mac-app")
        XCTAssertEqual(defaults.string(forKey: BuildStore.outputKey), "/out")
        XCTAssertTrue(defaults.bool(forKey: BuildStore.bcOnCPUKey))
        XCTAssertEqual(changes, 1)
        store.target = "mac-app"
        XCTAssertEqual(changes, 1, "the same target is no change")
        XCTAssertEqual(makeStore().outDir, "/out", "a new store starts from what was saved")
    }

    // MARK: The experimental builder (#749)

    func testTheExperimentalBuilderIsOffByDefaultAndItsSettingIsSaved() {
        let store = makeStore()
        XCTAssertFalse(store.experimentalBuilder)
        XCTAssertNil(store.experimentalBuilderProblem(), "off: nothing to say")
        store.experimentalBuilder = true; store.experimentalBuilderPath = "/opt/nxbuild"
        XCTAssertTrue(defaults.bool(forKey: BuildStore.experimentalBuilderKey))
        XCTAssertEqual(defaults.string(forKey: BuildStore.experimentalBuilderPathKey), "/opt/nxbuild")
        let again = makeStore()
        XCTAssertTrue(again.experimentalBuilder)
        XCTAssertEqual(again.experimentalBuilderPath, "/opt/nxbuild")
    }

    func testTheExperimentalBuilderStopsWithoutANewEnoughNxbAndNeverRunsTheScript() throws {
        let runner = FakeProcessRunner()
        let store = BuildStore(localizer: localizer, runner: runner, repo: repo, deps: deps, engine: engine, devices: devices, defaults: defaults, targetChanged: {})
        store.bundledBuilder = nil
        XCTAssertNil(store.experimentalBuilderProblem(), "off: nothing to say")
        store.experimentalBuilder = true
        store.experimentalBuilderPath = temporary.path + "/gone/nxb"
        XCTAssertNil(store.experimentalBuilderBinary)
        XCTAssertEqual(store.experimentalBuilderProblem(), store.t("msg.builderMissingError"), "no nxb is an error, not a build by the script")
        let nxb = try file("nxb")
        try FileManager.default.setAttributes([.posixPermissions: 0o755], ofItemAtPath: nxb)
        store.experimentalBuilderPath = temporary.path   // the folder that holds it
        XCTAssertEqual(store.experimentalBuilderBinary, nxb)
        runner.answer = { _ in ProcessResult(status: 0, out: "nxb 0.4.0\n") }
        XCTAssertEqual(store.experimentalBuilderProblem(), String(format: store.t("nxb.tooOld"), "nxb 0.4.0", ExperimentalBuilder.minimumVersion))
        runner.answer = { _ in ProcessResult(status: 0, out: "nxb 0.6.2\n") }
        XCTAssertNil(store.experimentalBuilderProblem(), "a game or a step nxb does not take ends with its own exit code 4")
        XCTAssertTrue(runner.commands.contains("nxb version"))
        store.experimentalBuilder = false
        XCTAssertNil(store.experimentalBuilderProblem())
    }

    func testAFailedNxbBuildSaysItsExitCodeAndItsLastErrorLine() {
        let store = makeStore()
        store.append("{\"ev\": \"say\", \"msg\": \"[RED] no key master_key_0f in prod.keys\", \"severity\": \"error\"}\n")
        XCTAssertEqual(store.experimentalFailureNote(status: 6), String(format: store.t("nxb.exit.6"), 6) + " no key master_key_0f in prod.keys")
        XCTAssertTrue(store.experimentalFailureNote(status: 4).contains("exit code 4"))
    }

    func testTakingFilesFillsTheRowAndNamesTheFirstFileThatDoesNotFit() {
        let store = makeStore()
        store.take(picked: ["/g/Game [0100000000001000].nsp"], kind: .base)
        XCTAssertEqual(store.basePath, "/g/Game [0100000000001000].nsp")
        XCTAssertEqual(store.gameDir, "/g")
        store.take(picked: ["/g/Other [0100000000002800].nsp", "/g/Game update [0100000000001800].nsp"], kind: .update)
        XCTAssertEqual(store.updatePath, "/g/Game update [0100000000001800].nsp", "the file that fits is taken")
        XCTAssertFalse(store.slot("update").problem.isEmpty, "the other one is named on the row")
        store.clear("update")
        XCTAssertEqual(store.updatePath, "")
        XCTAssertEqual(store.slot("update").problem, "")
    }

    func testThePickerIsTheAppsAndGetsTheRowsWordsAndFileTypes() {
        let store = makeStore()
        var asked: [FilePick] = []
        store.choosePaths = { asked.append($0); return ["/g/Game dlc [0100000000001001].nsp"] }
        store.pickFiles(kind: .dlc)
        XCTAssertEqual(asked.count, 1)
        XCTAssertTrue(asked[0].allowsMultiple)
        XCTAssertEqual(asked[0].fileTypes, GameInputs.allowedFileTypes(for: .dlc))
        XCTAssertEqual(asked[0].message, store.t("data.dlcPanelMessage"))
        store.choosePaths = { _ in [] }
        store.pickFiles(kind: .update)
        XCTAssertEqual(store.updatePath, "", "a cancelled panel changes nothing")
    }

    // MARK: The script's events

    func testLastShaderFileHintFollowsTheReportedBatch() {
        let store = makeStore()
        func progress(_ done: Int, _ total: Int, name: String = "shader split", step: String = "splitting",
                      unit: String = "files", estimated: Bool = false) {
            store.handleEvent("progress", ["k": 2, "name": name, "step": step, "unit": unit,
                                           "done": done, "total": total, "est": estimated, "frac": 0.99])
        }

        progress(304_227, 304_243)
        XCTAssertTrue(store.stages[0].isScanningLastShaderFiles)
        XCTAssertEqual(store.stages[0].percent, 99)
        XCTAssertEqual(store.stages[0].detail, BuildProgress.progressDetail(["step": "splitting", "unit": "files",
                                                                             "done": 304_227, "total": 304_243]))
        progress(48_145, 48_146)
        XCTAssertTrue(store.stages[0].isScanningLastShaderFiles)
        store.handleEvent("step", ["k": 2, "name": "shader split", "step": "checking the outputs"])
        XCTAssertFalse(store.stages[0].isScanningLastShaderFiles)
        for done in [0, 48_129, 48_146] {
            progress(done, 48_146)
            XCTAssertFalse(store.stages[0].isScanningLastShaderFiles)
        }
        progress(48_130, 48_146, name: "extract")
        XCTAssertFalse(store.stages[0].isScanningLastShaderFiles)
        progress(48_130, 48_146, step: "checking the inputs")
        XCTAssertFalse(store.stages[0].isScanningLastShaderFiles)
        progress(48_130, 48_146, unit: "B")
        XCTAssertFalse(store.stages[0].isScanningLastShaderFiles)
        progress(48_130, 48_146, estimated: true)
        XCTAssertFalse(store.stages[0].isScanningLastShaderFiles)
        progress(48_130, 48_146)
        store.handleEvent("stage_end", ["k": 2, "name": "shader split", "ok": false])
        XCTAssertFalse(store.stages[0].isScanningLastShaderFiles)
    }

    func testTheScriptsJSONEventsBecomeStagesAndLogLines() {
        let store = makeStore()
        store.ingest("{\"ev\":\"stage\",\"k\":1,\"n\":3,\"name\":\"extract\",\"step\":\"keys\"}\n")
        XCTAssertEqual(store.stages.map(\.id), [1])
        XCTAssertEqual(store.stages[0].state, .running)
        XCTAssertEqual(store.stages[0].detail, "keys")
        store.ingest("{\"ev\":\"progress\",\"k\":1,\"frac\":0.5,\"done\":5,\"total\":10}\n{\"ev\":\"stage_end\",\"k\":1,\"name\":\"extract\",\"ok\":true,\"elapsed\":3,\"summary\":\"10 files\"}\n")
        XCTAssertEqual(store.stages[0].state, .done)
        XCTAssertEqual(store.stages[0].detail, "10 files")
        XCTAssertEqual(store.stages[0].percent, 100)
        XCTAssertTrue(store.log.text.contains("[1/3] extract · keys …"))
        XCTAssertTrue(store.log.text.contains("✓ extract (\(BuildProgress.duration(3))): 10 files"))
    }

    func testAChunkThatEndsInTheMiddleOfALineWaitsForTheRest() {
        let store = makeStore()
        store.ingest("{\"ev\":\"stage\",\"k\":2,\"n\":3,\"na")
        XCTAssertTrue(store.stages.isEmpty)
        store.ingest("me\":\"pack\"}\nplain line from a tool\n")
        XCTAssertEqual(store.stages.map(\.id), [2])
        XCTAssertTrue(store.log.text.contains("plain line from a tool\n"), "what is not an event is log text")
    }

    func testTheStaleShadersNoticeShowsOncePerBuildForEachReason() {
        for (reason, text) in [("chain", "msg.shadersStale.chain"), ("inputs", "msg.shadersStale.inputs")] {
            let store = makeStore()
            var notices: [[String]] = []
            store.showNotice = { notices.append([$0, $1]) }
            let event = "{\"ev\":\"shaders_stale\",\"reason\":\"\(reason)\",\"old\":\"b-4e0dd2535996\",\"new\":\"b-b7cd656abd7c\",\"count\":65}\n"
            store.ingest(event)
            store.ingest(event)   // the next shader step of the same build
            XCTAssertEqual(notices, [[store.t("msg.shadersStale.title"), store.t(text)]], reason)
        }
    }

    func testTheNoteLineAndAnUnknownReasonShowNoNotice() {
        let store = makeStore()
        var notices: [String] = []
        store.showNotice = { title, _ in notices.append(title) }
        store.ingest("{\"ev\":\"say\",\"msg\":\"[NOTE] cached shader libraries cannot be reused (a -> b): the translation chain changed\"}\n")
        XCTAssertEqual(notices, [], "the event shows the notice, the note that follows it is a log line")
        store.ingest("{\"ev\":\"shaders_stale\",\"reason\":\"newer\",\"old\":\"a\",\"new\":\"b\",\"count\":1}\n")
        XCTAssertEqual(notices, [], "no text explains a reason a newer script adds")
    }

    // MARK: The failure

    func testAFailedBuildsLogIsClassifiedAndAnUnknownStopLeavesTheNote() {
        let store = makeStore()
        store.logTail = "[RED] the iOS SDK is not installed\n"
        store.noteFailure()
        XCTAssertEqual(store.failure?.kind, .iosSDK)
        XCTAssertEqual(store.doneNote, store.t(BuildFailureKind.iosSDK.whatKey))
        store.doneNote = "Build failed: something else"
        store.logTail = "nothing the table knows"
        store.noteFailure()
        XCTAssertNil(store.failure)
        XCTAssertEqual(store.doneNote, "Build failed: something else")
    }

    func testBuildAnywayAsksFirstAndArmsTheFlagForOneBuildOnly() {
        let store = makeStore()
        store.target = "mac-app"
        repo.isRepo = false   // the build that follows ends at once, which is all this test needs
        store.failure = BuildFailure(kind: .iosSDK, gameName: nil)
        store.requestBuildAnyway()
        XCTAssertNil(store.confirmingOverride, "this stop has no override")
        store.failure = BuildFailure(kind: .otherMetal, gameName: nil)
        store.running = true
        store.requestBuildAnyway()
        XCTAssertNil(store.confirmingOverride, "not while a build runs")
        store.running = false
        store.requestBuildAnyway()
        XCTAssertEqual(store.confirmingOverride, .otherMetal)
        XCTAssertNil(store.armedOverride, "nothing is armed before the confirmation")
        store.cancelBuildAnyway()
        XCTAssertNil(store.confirmingOverride)
        store.requestBuildAnyway()
        store.confirmBuildAnyway()
        XCTAssertNil(store.confirmingOverride)
        XCTAssertNil(store.armedOverride, "the build took the flag: the next one asks again")
        XCTAssertNil(store.takeOverrideFlag())
        store.armedOverride = .damagedNSP
        XCTAssertEqual(store.takeOverrideFlag(), "--allow-damaged")
        XCTAssertNil(store.takeOverrideFlag())
    }

    func testTheFixButtonsRunTheDependencyRowsOwnInstall() {
        let store = makeStore()
        deps.deps = [Dep(id: "dotnet", name: "dep.dotnet", hint: "", present: false, installCmd: ["/usr/bin/true"]),
                     Dep(id: "python", name: "dep.python", hint: "", present: false, installCmd: ["/usr/bin/true"])]
        store.fixBuildFailure(.translator)
        store.fixBuildFailure(.zbic)
        store.fixBuildFailure(.iosSDK)
        XCTAssertEqual(deps.installed, ["dotnet", "python", "xcode"])
        XCTAssertFalse(store.fixBusy(.translator))
        deps.busy = ["dotnet"]
        XCTAssertTrue(store.fixBusy(.translator))
        XCTAssertFalse(store.fixBusy(.zbic))
        XCTAssertFalse(store.fixBusy(.keys), "a fix that is no install is never busy")
    }

    func testTheKeysFixUsesTheKeysPickerAndTheCloudFixTheFolderPanel() {
        let store = makeStore()
        var keysAsked = 0
        store.chooseKeys = { keysAsked += 1 }
        store.fixBuildFailure(.keys)
        XCTAssertEqual(keysAsked, 1)
        store.failure = BuildFailure(kind: .cloudFolder, gameName: nil, detail: "/iCloud/x")
        store.doneNote = "stopped"
        store.chooseFolder = { nil }
        store.fixBuildFailure(.cloudFolder)
        XCTAssertEqual(store.failure?.kind, .cloudFolder, "a cancelled panel keeps the stop")
        store.chooseFolder = { "/Users/x/Games" }
        store.fixBuildFailure(.cloudFolder)
        XCTAssertEqual(store.outDir, "/Users/x/Games")
        XCTAssertNil(store.failure, "the next build looks at the new folder")
        XCTAssertEqual(store.doneNote, "")
    }

    func testTheFailureFolderOpensInTheFinderForAFullDisk() throws {
        let store = makeStore()
        let built = temporary.appendingPathComponent("0100_build")
        try FileManager.default.createDirectory(at: built, withIntermediateDirectories: true)
        store.gameDir = temporary.path
        store.failure = BuildFailure(kind: .diskFull, gameName: nil, detail: "40")
        var shown: [URL] = []
        store.revealFolder = { shown.append($0) }
        store.showFailureFolder()
        XCTAssertEqual(shown.map(\.path), [built.path])
    }

    // MARK: The install on a device

    func testReinstallAndResignSayWhyTheyCannotRunInsteadOfStartingATool() {
        let store = makeStore()
        store.reinstallOnDevice()
        XCTAssertFalse(store.running, "nothing was installed: nothing to reinstall")
        store.installedOn = "UDID"; store.installedAppPath = temporary.path + "/gone/DmIOS.app"
        store.reinstallOnDevice()
        XCTAssertFalse(store.running)
        XCTAssertEqual(store.doneNote, String(format: store.t("dev.reinstallMissing"), store.shortPath(store.installedAppPath)))
        store.resignOnDevice(app: store.installedAppPath, device: "UDID")
        XCTAssertEqual(store.doneNote, store.t("dev.resignNoTeam"))
        devices.signingTeam = "TEAM"
        store.resignOnDevice(app: store.installedAppPath, device: "UDID")
        XCTAssertEqual(store.doneNote, store.t("dev.resignOlder"))
        XCTAssertFalse(store.running)
    }

    func testTheSavePanelIsTheAppsAndACancelWritesNothing() {
        let store = makeStore()
        var asked: [(String, String)] = []
        store.chooseSaveLocation = { asked.append(($0, $1)); return nil }
        store.saveIPAPanel()
        XCTAssertEqual(asked.count, 1)
        XCTAssertEqual(asked.first?.0, store.t("dev.saveIPATitle"))
        XCTAssertEqual(asked.first?.1, "DmIOS.ipa")
        XCTAssertFalse(store.running)
    }

    func testTheRetryOfTheGameDataNeedsAnInstallThatLeftOneToRetry() {
        let store = makeStore()
        store.retryShellData()
        XCTAssertFalse(store.running, "no install ran: nothing to retry")
    }

    func testWhatTheStoreWritesItselfIsInTheLanguageOfTheLocalizer() {
        let store = makeStore()
        localizer.lang = Lang("de")
        XCTAssertEqual(store.lang, Lang("de"))
        XCTAssertEqual(store.t("shell.needsDevice"), L10n.string("shell.needsDevice", Lang("de")))
    }

    func testAStoppedBuildWithNothingRunningDoesNothing() {
        let store = makeStore()
        store.stop()
        XCTAssertFalse(store.stopping)
    }

    // MARK: Move cache folder (#427)

    /// A store whose home is the temporary folder, so the default cache place is never the real Application Support.
    private func moveStore() throws -> (BuildStore, cache: String) {
        let store = makeStore()
        store.home = temporary.path + "/home"
        let cache = store.home + "/Library/Application Support/NX2Apple/shell"
        try FileManager.default.createDirectory(atPath: cache + "/frameworks/DmGame0100AAAA.framework", withIntermediateDirectories: true)
        try Data("shader".utf8).write(to: URL(fileURLWithPath: cache + "/frameworks/DmGame0100AAAA.framework/game.manifest.json"))
        let json: [String: Any] = ["bundleID": "org.nxnative.shell.TEAM", "team": "TEAM", "games": [["titleID": "0100AAAA", "name": "A", "framework": cache + "/frameworks/DmGame0100AAAA.framework"]]]
        try JSONSerialization.data(withJSONObject: json).write(to: URL(fileURLWithPath: cache + "/shell.json"))
        XCTAssertEqual(store.shellCachePath, cache)
        XCTAssertTrue(store.shellCacheIsDefault)
        return (store, cache)
    }

    /// The build guard: no move starts while a build, an install or an export runs, and nothing on disk changes.
    func testTheCacheDoesNotMoveWhileABuildRuns() throws {
        let (store, cache) = try moveStore()
        let picked = temporary.path + "/Drive"
        try FileManager.default.createDirectory(atPath: picked, withIntermediateDirectories: true)
        store.prepareShellMove(into: picked)
        guard case .confirm(let plan) = store.shellMove else { return XCTFail("the confirmation shows") }
        XCTAssertEqual(plan.destination, picked + "/NX2Apple-shell")
        store.running = true
        XCTAssertNil(store.confirmShellMove(), "refused while a build runs")
        XCTAssertEqual(store.shellMove, .confirm(plan), "the confirmation stays, with its note")
        XCTAssertTrue(FileManager.default.fileExists(atPath: cache + "/shell.json"))
        XCTAssertFalse(FileManager.default.fileExists(atPath: plan.destination))
        XCTAssertNil(defaults.string(forKey: "shellRoot"), "the saved place is unchanged")
    }

    /// While the cache moves the build store's `running` flag is set, so no build can start, and the saved place, shell.json and the
    /// way back follow the move.
    func testAMoveSavesTheNewPlaceAndTheWayBackClearsThePick() async throws {
        let (store, cache) = try moveStore()
        let picked = temporary.path + "/Drive"
        try FileManager.default.createDirectory(atPath: picked, withIntermediateDirectories: true)
        store.prepareShellMove(into: picked)
        let task = try XCTUnwrap(store.confirmShellMove())
        XCTAssertTrue(store.running, "builds, installs and exports are off while the cache moves")
        XCTAssertFalse(store.canBuild)
        await task.value
        let moved = picked + "/NX2Apple-shell"
        XCTAssertEqual(store.shellMove, .moved(moved))
        XCTAssertFalse(store.running)
        XCTAssertEqual(defaults.string(forKey: "shellRoot"), moved)
        XCTAssertTrue(defaults.bool(forKey: ShellRootMove.pickedKey))
        XCTAssertEqual(store.shellCachePath, moved)
        XCTAssertEqual(store.shellRoot, moved, "the launch migration leaves a picked folder where it is")
        XCTAssertFalse(store.shellCacheIsDefault)
        XCTAssertFalse(FileManager.default.fileExists(atPath: cache))
        XCTAssertEqual(ShellLibrary.load(root: moved).games.first?.framework, moved + "/frameworks/DmGame0100AAAA.framework")

        store.dismissShellMove()
        store.prepareShellMoveToDefault()
        await store.confirmShellMove()?.value
        XCTAssertEqual(store.shellMove, .moved(cache))
        XCTAssertEqual(defaults.string(forKey: "shellRoot"), cache)
        XCTAssertFalse(defaults.bool(forKey: ShellRootMove.pickedKey))
        XCTAssertTrue(store.shellCacheIsDefault)
        XCTAssertEqual(try FileManager.default.contentsOfDirectory(atPath: picked), [], "the picked folder stays, empty as it was")
    }

    /// A move that fails on the disk says why and where the cache stays, keeps the old folder and the saved place.
    func testAFailedMoveKeepsTheCacheAndTheSavedPlace() async throws {
        let (store, cache) = try moveStore()
        let picked = temporary.path + "/Locked"
        try FileManager.default.createDirectory(atPath: picked, withIntermediateDirectories: true)
        try FileManager.default.setAttributes([.posixPermissions: 0o555], ofItemAtPath: picked)   // nothing can be made inside it
        defer { try? FileManager.default.setAttributes([.posixPermissions: 0o755], ofItemAtPath: picked) }
        store.prepareShellMove(into: picked)
        await store.confirmShellMove()?.value
        guard case .failed(let why, let stays) = store.shellMove else { return XCTFail("expected a failure, got \(store.shellMove)") }
        XCTAssertFalse(why.isEmpty)
        XCTAssertFalse(why.hasSuffix("."), "the text goes on after the reason, so the system's full stop is dropped")
        XCTAssertEqual(stays, cache)
        XCTAssertFalse(store.running)
        XCTAssertTrue(FileManager.default.fileExists(atPath: cache + "/frameworks/DmGame0100AAAA.framework/game.manifest.json"))
        XCTAssertNil(defaults.string(forKey: "shellRoot"))
        XCTAssertFalse(defaults.bool(forKey: ShellRootMove.pickedKey))
    }

    func testAMoveThatCannotStartKeepsTheSavedPlace() throws {
        let (store, cache) = try moveStore()
        store.prepareShellMove(into: cache + "/frameworks")
        guard case .confirm(let plan) = store.shellMove else { return XCTFail("the confirmation shows") }
        XCTAssertEqual(plan.problem, .insideCache)
        XCTAssertNil(store.confirmShellMove())
        XCTAssertFalse(store.running)
        XCTAssertNil(defaults.string(forKey: "shellRoot"))
    }
}