// SPDX-License-Identifier: GPL-3.0-or-later import XCTest import Darwin final class CMOCWorkspaceRecoveryTests: XCTestCase { private struct Fixture { let root: URL var project: URL { root.appendingPathComponent("Project") } var store: URL { root.appendingPathComponent("Recovery") } func recovery(session: UUID = UUID(), pid: Int32 = Int32.max) -> CMOCWorkspaceRecovery { CMOCWorkspaceRecovery(root: store, sessionID: session, processID: pid) } var projectFolder: URL { store.appendingPathComponent(CMOCProject.sha256(Data(project.resolvingSymlinksInPath().path.utf8))) } func remove() { try? FileManager.default.removeItem(at: root) } } private func fixture() throws -> Fixture { let fixture = Fixture(root: FileManager.default.temporaryDirectory.appendingPathComponent("CRecovery-" + UUID().uuidString)) try FileManager.default.createDirectory(at: fixture.project, withIntermediateDirectories: true) return fixture } private func draft(_ path: String = "main.c", text: String = "int changed;", saved: String = "int original;") -> CMOCWorkspaceRecovery.Draft { .init(path: path, text: text, savedText: saved, savedHash: CMOCProject.sha256(Data(saved.utf8))) } func testRecoveryRetainsDraftAndOriginalIdentityWithoutWritingProject() throws { let f = try fixture(); defer { f.remove() } let file = f.project.appendingPathComponent("main.c") try Data("int original;".utf8).write(to: file) let owner = f.recovery() try owner.save(projectDirectory: f.project, drafts: [draft(), draft("sub/header.h")]) XCTAssertEqual(try String(contentsOf: file, encoding: .utf8), "int original;") XCTAssertFalse(FileManager.default.fileExists(atPath: f.project.appendingPathComponent("sub/header.h").path)) let reopened = f.recovery() let record = try XCTUnwrap(reopened.records(projectDirectory: f.project).first) XCTAssertFalse(record.isFromRunningSession) XCTAssertEqual(record.drafts, [draft(), draft("sub/header.h")]) // A missing source does not make its unsaved recovery copy disappear. try FileManager.default.removeItem(at: file) XCTAssertEqual(try reopened.records(projectDirectory: f.project).first?.drafts[0].text, "int changed;") try reopened.save(projectDirectory: f.project, drafts: record.drafts) try reopened.discard(record) XCTAssertEqual(try reopened.records(projectDirectory: f.project).count, 1) XCTAssertFalse(FileManager.default.fileExists(atPath: file.path)) } func testConcurrentSessionsKeepSeparateCopiesAndRejectLiveDiscard() throws { let f = try fixture(); defer { f.remove() } let first = f.recovery(pid: getpid()), second = f.recovery() try first.save(projectDirectory: f.project, drafts: [draft(text: "first session")]) try second.save(projectDirectory: f.project, drafts: [draft(text: "second session")]) let scan = try second.scan(projectDirectory: f.project) XCTAssertEqual(scan.records.count, 2) let live = try XCTUnwrap(scan.records.first { $0.id == first.sessionID }) XCTAssertTrue(live.isFromRunningSession) XCTAssertThrowsError(try second.discard(live)) try second.save(projectDirectory: f.project, drafts: []) let left = try second.records(projectDirectory: f.project) XCTAssertEqual(left.count, 1); XCTAssertEqual(left[0].drafts[0].text, "first session") XCTAssertFalse(try first.records(projectDirectory: f.project)[0].isFromRunningSession) } func testInvalidDraftsKeepPreviousRecoveryCopy() throws { let f = try fixture(); defer { f.remove() } let store = f.recovery() try store.save(projectDirectory: f.project, drafts: [draft()]) for drafts in [[draft("../escape.c")], [draft("/absolute.c")], [draft("main.c"), draft("MAIN.C")], [draft(text: String(repeating: "x", count: CMOCProject.maximumSourceBytes + 1))], [CMOCWorkspaceRecovery.Draft(path: "main.c", text: "new", savedText: "old", savedHash: "wrong")], (0...CMOCWorkspaceRecovery.maximumDrafts).map { draft("file\($0).c") }] { XCTAssertThrowsError(try store.save(projectDirectory: f.project, drafts: drafts)) XCTAssertEqual(try store.records(projectDirectory: f.project)[0].drafts, [draft()]) } } func testDamagedRecordIsReportedWithoutHidingHealthySession() throws { let f = try fixture(); defer { f.remove() } let store = f.recovery() try store.save(projectDirectory: f.project, drafts: [draft()]) let broken = f.projectFolder.appendingPathComponent(UUID().uuidString + ".json") try Data("{truncated".utf8).write(to: broken) let scan = try store.scan(projectDirectory: f.project) XCTAssertEqual(scan.records.count, 1) XCTAssertEqual(scan.issues.count, 1) XCTAssertTrue(scan.issues[0].contains("damaged")) XCTAssertThrowsError(try store.records(projectDirectory: f.project)) XCTAssertTrue(FileManager.default.fileExists(atPath: broken.path)) } func testChangedRecordCannotBeDiscardedUsingAnOlderSelection() throws { let f = try fixture(); defer { f.remove() } let owner = f.recovery(), reader = f.recovery() try owner.save(projectDirectory: f.project, drafts: [draft(text: "first")]) let first = try XCTUnwrap(reader.records(projectDirectory: f.project).first) try owner.save(projectDirectory: f.project, drafts: [draft(text: "newer")]) XCTAssertThrowsError(try reader.discard(first)) XCTAssertEqual(try reader.records(projectDirectory: f.project)[0].drafts[0].text, "newer") let other = CMOCWorkspaceRecovery(root: f.root.appendingPathComponent("OtherRecovery")) XCTAssertThrowsError(try other.discard(first)) } func testRecoveryRefusesLinkedRootsFoldersAndRecords() throws { let f = try fixture(); defer { f.remove() } let external = f.root.appendingPathComponent("External") try FileManager.default.createDirectory(at: external, withIntermediateDirectories: true) let linkedRoot = f.root.appendingPathComponent("LinkedRecovery") try FileManager.default.createSymbolicLink(at: linkedRoot, withDestinationURL: external) XCTAssertThrowsError(try CMOCWorkspaceRecovery(root: linkedRoot).save(projectDirectory: f.project, drafts: [draft()])) let store = f.recovery() try store.save(projectDirectory: f.project, drafts: [draft()]) let record = try XCTUnwrap(store.records(projectDirectory: f.project).first) let recordURL = f.projectFolder.appendingPathComponent(record.id.uuidString + ".json") let canary = external.appendingPathComponent("canary") try Data("unchanged".utf8).write(to: canary) try FileManager.default.removeItem(at: recordURL) try FileManager.default.createSymbolicLink(at: recordURL, withDestinationURL: canary) XCTAssertEqual(try store.scan(projectDirectory: f.project).issues.count, 1) XCTAssertThrowsError(try store.save(projectDirectory: f.project, drafts: [])) XCTAssertThrowsError(try store.discard(record)) XCTAssertEqual(try String(contentsOf: canary, encoding: .utf8), "unchanged") try FileManager.default.removeItem(at: f.projectFolder) try FileManager.default.createSymbolicLink(at: f.projectFolder, withDestinationURL: external) XCTAssertThrowsError(try store.scan(projectDirectory: f.project)) XCTAssertThrowsError(try store.save(projectDirectory: f.project, drafts: [draft()])) XCTAssertEqual(try String(contentsOf: canary, encoding: .utf8), "unchanged") } @MainActor private func waitForRecovery(_ model: CMOCDevelopmentModel) async throws { for _ in 0..<500 where model.recoveryBusy { try await Task.sleep(nanoseconds: 10_000_000) } XCTAssertFalse(model.recoveryBusy) } @MainActor private func flush(_ model: CMOCDevelopmentModel) async { await withCheckedContinuation { continuation in model.flushDraftRecovery { continuation.resume() } } } @MainActor private func model(_ f: Fixture, defaults: UserDefaults) -> (MachineModel, CMOCDevelopmentModel) { let machine = MachineModel(diskStore: .init(url: f.root.appendingPathComponent("disks.json")), displayDefaults: defaults, inputStore: .init(url: f.root.appendingPathComponent("input.json"))) return (machine, CMOCDevelopmentModel(machine: machine, defaults: defaults, buildRoot: f.root.appendingPathComponent("Builds"), recoveryRoot: f.store)) } private func populateProject(_ f: Fixture) throws -> CMOCProject { try Data(CMOCProject.starterSource.utf8).write(to: f.project.appendingPathComponent("main.c")) try Data(CMOCProject.starterMakefile.utf8).write(to: f.project.appendingPathComponent("Makefile")) return try CMOCProject.open(at: f.project) } @MainActor func testModelRestoresConflictingAndMissingDraftsWithoutOverwritingSources() async throws { let f = try fixture(); defer { f.remove() } let suite = "CRecoveryModel." + UUID().uuidString, defaults: UserDefaults defaults = UserDefaults(suiteName: suite)! defer { defaults.removePersistentDomain(forName: suite) } let project = try populateProject(f) let original = try project.readText(relativePath: "main.c") let old = f.recovery() try old.save(projectDirectory: f.project, drafts: [draft(text: original + "\n/* recovered */", saved: original), draft("missing.h")]) try Data((original + "\n/* outside edit */").utf8).write(to: project.sourceURL) let (machine, model) = model(f, defaults: defaults) try model.adopt(project); try await waitForRecovery(model) let selected = try XCTUnwrap(model.recoveryRecords.first) model.restoreRecovery(selected); try await waitForRecovery(model); await flush(model) let main = try XCTUnwrap(model.documents.first { $0.id == "main.c" }) XCTAssertTrue(main.conflict); XCTAssertFalse(main.missing) XCTAssertTrue(main.text.contains("recovered")); XCTAssertEqual(main.savedText, original) let missing = try XCTUnwrap(model.documents.first { $0.id == "missing.h" }) XCTAssertTrue(missing.missing); XCTAssertTrue(missing.conflict) XCTAssertFalse(model.save(), "Recovery must not authorize overwriting externally changed source") XCTAssertEqual(try project.readText(relativePath: "main.c"), original + "\n/* outside edit */") XCTAssertFalse(FileManager.default.fileExists(atPath: f.project.appendingPathComponent("missing.h").path)) let durable = try f.recovery().records(projectDirectory: f.project) XCTAssertEqual(durable.count, 1) XCTAssertNotEqual(durable[0].id, old.sessionID, "The adopted copy must replace the prior session only after it is durable") XCTAssertEqual(durable[0].drafts.count, 2) XCTAssertTrue(durable[0].drafts.first { $0.path == "main.c" }!.text.contains("recovered")) await withCheckedContinuation { continuation in machine.shutdown { continuation.resume() } } } @MainActor func testModelKeepsPriorCopyWhenDurableAdoptionCannotBeWritten() async throws { let f = try fixture(); defer { f.remove() } let suite = "CRecoveryModel." + UUID().uuidString, defaults: UserDefaults defaults = UserDefaults(suiteName: suite)! defer { defaults.removePersistentDomain(forName: suite) } let project = try populateProject(f), old = f.recovery() let original = try project.readText(relativePath: "main.c") try old.save(projectDirectory: f.project, drafts: [draft(text: "recovered source", saved: original)]) let (machine, model) = model(f, defaults: defaults) try model.adopt(project); try await waitForRecovery(model) let selected = try XCTUnwrap(model.recoveryRecords.first) let kept = f.root.appendingPathComponent("RecoveryKept") try FileManager.default.moveItem(at: f.store, to: kept) try Data("not a directory".utf8).write(to: f.store) model.restoreRecovery(selected); try await waitForRecovery(model) XCTAssertEqual(model.source, "recovered source", "A failed recovery write must not erase the in-memory draft") XCTAssertTrue(model.message?.contains("real directory") == true) let priorFile = kept.appendingPathComponent(f.projectFolder.lastPathComponent).appendingPathComponent(old.sessionID.uuidString + ".json") XCTAssertTrue(FileManager.default.fileExists(atPath: priorFile.path), "Failed adoption must leave the old durable copy intact") XCTAssertEqual(try project.readText(relativePath: "main.c"), original) try FileManager.default.removeItem(at: f.store) try FileManager.default.moveItem(at: kept, to: f.store) await flush(model) await withCheckedContinuation { continuation in machine.shutdown { continuation.resume() } } } @MainActor func testMissingProjectStillOffersItsDraftsForExport() async throws { let f = try fixture(); defer { f.remove() } let suite = "CRecoveryModel." + UUID().uuidString, defaults: UserDefaults defaults = UserDefaults(suiteName: suite)! defer { defaults.removePersistentDomain(forName: suite) } let old = f.recovery() try old.save(projectDirectory: f.project, drafts: [draft()]) defaults.set(f.project.path, forKey: "CMOCWorkspace.directory") try FileManager.default.removeItem(at: f.project) let (machine, model) = model(f, defaults: defaults) model.restoreWorkspace(); try await waitForRecovery(model) XCTAssertNil(model.project) let record = try XCTUnwrap(model.recoveryRecords.first) XCTAssertEqual(record.drafts, [draft()], "Export has the full draft text even when the project cannot open") model.restoreRecovery(record) XCTAssertTrue(model.message?.contains("export") == true) XCTAssertEqual(try old.records(projectDirectory: f.project).count, 1) XCTAssertFalse(FileManager.default.fileExists(atPath: f.project.path)) await withCheckedContinuation { continuation in machine.shutdown { continuation.resume() } } } func testScanBoundsRetainedSessionsWithoutDeletingUnreviewedCopies() throws { let f = try fixture(); defer { f.remove() } for _ in 0...CMOCWorkspaceRecovery.maximumScanRecords { try f.recovery().save(projectDirectory: f.project, drafts: [draft()]) } let reader = f.recovery() let first = try reader.scan(projectDirectory: f.project) XCTAssertEqual(first.records.count, CMOCWorkspaceRecovery.maximumScanRecords) XCTAssertEqual(first.issues.count, 1) XCTAssertEqual(try FileManager.default.contentsOfDirectory(atPath: f.projectFolder.path).count, CMOCWorkspaceRecovery.maximumScanRecords + 1) try reader.discard(first.records[0]) let next = try reader.scan(projectDirectory: f.project) XCTAssertEqual(next.records.count, CMOCWorkspaceRecovery.maximumScanRecords) XCTAssertTrue(next.issues.isEmpty) XCTAssertFalse(Set(first.records.map(\.id)).isSuperset(of: Set(next.records.map(\.id))), "The remaining record becomes reviewable after explicit cleanup") } }