Repository Public
1import Foundation2import Testing3import PDFKit4import SheetCore5import SheetEngine6import SheetIO7import SheetUI8import SheetAutomation9@testable import FeatureAutomation1011/// Redirects Application Support once for the test process.12@MainActor enum Env {13 static let support: URL = {14 let dir = FileManager.default.temporaryDirectory.appendingPathComponent("orix-feature-automation-tests-\(UUID().uuidString)", isDirectory: true)15 try? FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)16 WorkflowPaths.supportDirectory = dir17 ORIXEngine.bootstrap()18 return dir19 }()2021 static func tempDir() -> URL {22 _ = support23 let dir = FileManager.default.temporaryDirectory.appendingPathComponent("orix-fa-\(UUID().uuidString)", isDirectory: true)24 try! FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)25 return WorkflowPaths.canonical(dir)26 }2728 static func session() -> WorkbookSession {29 _ = support30 let wb = Workbook(sheetNames: ["Data", "Summary"])31 let s = WorkbookSession(workbook: wb, locale: Locale(identifier: "en_US"))32 s.perform("Seed") { e in33 let parser = InputParser(locale: Locale(identifier: "en_US_POSIX"))34 for (r, row) in [["category", "amount"], ["Housing", "1200"], ["Food", "450.25"], ["Transport", "89.9"], ["Food", "49.75"]].enumerated() {35 for (c, t) in row.enumerated() { try? e.setInput(sheet: 0, row: r, col: c, t, parser: parser) }36 }37 e.setFormula(sheet: 1, row: 0, col: 0, "=SUM(Data!B:B)")38 }39 s.engine.clearUndoHistory()40 return s41 }4243 static func model(_ session: WorkbookSession, base: URL) -> AutomationModel {44 let m = AutomationModel(session: session)45 m.baseDirectory = base46 return m47 }4849 static func value(_ s: WorkbookSession, _ sheet: String, _ a1: String) -> Value {50 guard let ws = s.workbook.sheet(named: sheet), let c = CellRef(a1: a1) else { return .error(.ref) }51 return ws.value(c.row, c.col)52 }53}5455@MainActor @Suite(.serialized) struct ModelTests {56 @Test func editingThroughTheModelSavesWhereTheWorkflowLives() throws {57 let session = Env.session()58 var changes = 059 session.onChange = { changes += 1 }60 let model = Env.model(session, base: Env.tempDir())61 #expect(model.selectedSource == .library || model.selectedSource == .template) // nothing in the workbook yet62 let wf = model.newWorkflow(in: .workbook)63 #expect(model.selectedSource == .workbook && model.isEditable && model.isTrusted) // created here by the user64 #expect(WorkflowStore.load(from: session.workbook).map(\.id) == [wf.id] && changes == 1)65 model.addStep(.setCell)66 model.addStep(.validate)67 model.addStep(.forEachFile)68 model.addStep(.exportFile, inside: [2])69 #expect(model.selectedPath == [2, 0])70 #expect(model.workflow?.flattened.map(\.item.step.kind) == [.setCell, .validate, .forEachFile, .exportFile])71 model.moveStep(at: [1], by: -1)72 #expect(model.selectedPath == [0] && model.workflow?.steps.first?.step.kind == .validate)73 model.duplicateStep(at: [0])74 model.removeStep(at: [1])75 #expect(model.selectedPath == nil && model.workflow?.steps.count == 3)76 let stored = try #require(WorkflowStore.load(from: session.workbook).first)77 #expect(stored == model.workflow)78 #expect(model.isTrusted) // the approval followed the edits79 #expect(changes > 5)8081 // templates are read-only; duplicating one gives an editable copy in the library82 model.select(WorkflowTemplates.csvReport.id, .template)83 model.addStep(.recalculate)84 model.edit { $0.name = "Hacked" }85 #expect(model.workflow == WorkflowTemplates.csvReport && !model.isEditable)86 model.duplicateSelected()87 #expect(model.selectedSource == .library && model.workflow?.name == "CSV report copy" && model.workflow?.id != WorkflowTemplates.csvReport.id)88 #expect(WorkflowStore.library().contains { $0.id == model.selectedID })89 model.deleteSelected()90 #expect(!WorkflowStore.library().contains { $0.name == "CSV report copy" })91 }9293 @Test func formsRoundTripEveryFieldThroughTheModel() throws {94 let session = Env.session()95 let model = Env.model(session, base: Env.tempDir())96 model.newWorkflow(in: .workbook)97 for kind in StepKind.allCases {98 model.selectedPath = nil99 model.addStep(kind)100 let path = try #require(model.selectedPath)101 for field in kind.fields {102 let new: FieldValue103 switch field.kind {104 case .bool: new = .bool(!(model.selectedItem?.step.settings[path: field.key]?.boolValue ?? false))105 case .number: new = .number(42)106 case .list: new = .list(["a", "b c"])107 case .choice(let options): new = .text(options.last ?? "")108 default: new = .text("v \(field.key)")109 }110 model.setField(field, to: new, at: path)111 #expect(model.selectedItem?.step.value(of: field) == new, "\(kind.rawValue).\(field.key)")112 }113 #expect(model.selectedItem?.step.kind == kind)114 }115 // what the forms wrote is what is stored in the workbook and what the engine decodes116 let stored = try #require(WorkflowStore.load(from: session.workbook).first)117 #expect(stored == model.workflow && stored.steps.count == StepKind.allCases.count)118 #expect(try Workflow.decode(try stored.jsonData()) == stored)119 // a text typed into a list or number field is converted120 model.selectedPath = [StepKind.allCases.firstIndex(of: .sort)!]121 let keys = StepKind.sort.fields.first { $0.key == "keys" }!122 model.setField(keys, to: .text("amount desc\ncategory"), at: model.selectedPath!)123 #expect(model.selectedItem?.step.value(of: keys) == .list(["amount desc", "category"]))124 }125126 @Test func validationBadgesFollowTheMode() {127 let session = Env.session()128 let model = Env.model(session, base: Env.tempDir())129 model.newWorkflow(in: .library)130 model.addStep(.recalculate)131 model.runsOnOpenWorkbook = false132 model.revalidate()133 #expect(model.errorCount == 1 && model.diagnostics(at: [0]).first?.message.contains("needs a workbook") == true)134 model.runsOnOpenWorkbook = true135 model.revalidate()136 #expect(model.errorCount == 0)137 model.addStep(.newWorkbook)138 #expect(model.diagnostics(at: [1]).contains { $0.message.contains("Run it standalone") })139 model.requestRun()140 #expect(model.prompt == nil && model.noticeIsError && model.tab == .editor && !model.isRunning)141 model.deleteSelected()142 }143144 @Test func runOnTheOpenWorkbookIsOneUndoStep() async throws {145 let dir = Env.tempDir()146 let session = Env.session()147 let model = Env.model(session, base: dir)148 model.newWorkflow(in: .workbook)149 model.edit { wf in150 wf.name = "Summarise"151 wf.steps = [152 WorkflowItem(.cleanRange(CleanRangeSettings(range: "Data!*", changeCase: .upper))),153 WorkflowItem(.createPivot(CreatePivotSettings(range: "Data!*", rows: ["category"], values: ["sum(amount)"], sheet: "Pivot"))),154 WorkflowItem(.setCell(SetCellSettings(sheet: "Summary", cell: "B1", input: "=A1*2"))),155 WorkflowItem(.createChart(CreateChartSettings(range: "Pivot!A1:B4", name: "Chart", sheet: "Pivot"))),156 WorkflowItem(.exportFile(ExportFileSettings(path: dir.appendingPathComponent("out.csv").path, sheet: "Pivot"))),157 ]158 }159 model.runsOnOpenWorkbook = true160 model.grantedForWriting.insert(dir)161 #expect(!session.engine.canUndo)162 await model.runSelected()163 let run = try #require(model.lastRun)164 #expect(run.status == .succeeded, "\(run.message)")165 #expect(model.phase == .finished && model.tab == .run && model.liveSteps.count == 5 && model.liveSteps.allSatisfy { $0.status == .succeeded })166 // the open workbook now holds the result…167 #expect(session.workbook.sheets.map(\.name) == ["Data", "Summary", "Pivot"])168 #expect(Env.value(session, "Data", "A2") == .text("HOUSING"))169 #expect(Env.value(session, "Pivot", "B2") == .number(500))170 #expect(Env.value(session, "Summary", "B1") == .number(2 * 1789.9))171 #expect(session.workbook.sheet(named: "Pivot")?.meta.objects.map(\.name) == ["Chart"])172 #expect(model.appliedSummary?.sheetsAdded == 1 && (model.appliedSummary?.cellsChanged ?? 0) >= 13)173 #expect(try String(contentsOf: dir.appendingPathComponent("out.csv"), encoding: .utf8).hasPrefix("category,Sum of amount\nFOOD,500\n"))174 // …as exactly one undo step175 #expect(session.engine.undoLabel == "Run Workflow “Summarise”")176 session.undo()177 #expect(session.workbook.sheets.map(\.name) == ["Data", "Summary"])178 #expect(Env.value(session, "Data", "A2") == .text("Housing") && Env.value(session, "Summary", "B1").isBlank)179 #expect(Env.value(session, "Summary", "A1") == .number(1789.9))180 #expect(!session.engine.canUndo)181 session.redo()182 #expect(Env.value(session, "Pivot", "B2") == .number(500) && Env.value(session, "Summary", "B1") == .number(2 * 1789.9))183 // the run is in the history184 #expect(model.history.first?.id == run.id && WorkflowHistory.recent(limit: 1).first?.id == run.id)185 }186187 @Test func aFailedRunLeavesTheOpenWorkbookUntouched() async throws {188 let dir = Env.tempDir()189 let session = Env.session()190 let model = Env.model(session, base: dir)191 model.newWorkflow(in: .workbook)192 model.edit { wf in193 wf.steps = [194 WorkflowItem(.setCell(SetCellSettings(sheet: "Data", cell: "B2", input: "=1/0"))),195 WorkflowItem(.exportFile(ExportFileSettings(path: dir.appendingPathComponent("early.xlsx").path))),196 WorkflowItem(.validate(ValidateSettings(noErrorValues: true))),197 ]198 }199 model.runsOnOpenWorkbook = true200 model.grantedForWriting.insert(dir)201 await model.runSelected()202 #expect(model.lastRun?.status == .failed)203 #expect(model.liveSteps.last?.status == .failed && model.liveSteps.last?.issues.contains("Data!B2 holds #DIV/0!") == true)204 #expect(Env.value(session, "Data", "B2") == .number(1200) && !session.engine.canUndo && model.appliedSummary == nil)205 #expect(try FileManager.default.contentsOfDirectory(atPath: dir.path).isEmpty)206 }207208 @Test func unapprovedWorkflowsAskBeforeRunningAndOnlyGetWhatWasListed() async throws {209 let dir = Env.tempDir(), secret = Env.tempDir()210 let session = Env.session()211 // a workflow that arrived inside the workbook212 let embedded = Workflow(name: "From a colleague", parameters: [WorkflowParameter(name: "note", defaultValue: "ok")], [213 .setCell(SetCellSettings(sheet: "Summary", cell: "C1", input: "{{note}}")),214 .exportFile(ExportFileSettings(path: dir.appendingPathComponent("shared.csv").path, sheet: "Data")),215 ])216 try WorkflowStore.save(embedded, to: session.workbook)217 let model = Env.model(session, base: dir)218 #expect(model.selectedSource == .workbook && model.workflow == embedded && !model.isTrusted)219 #expect(Env.value(session, "Summary", "C1").isBlank) // opening and listing ran nothing220221 model.runsOnOpenWorkbook = true222 model.requestRun()223 #expect(model.prompt == .parameters(problems: []))224 model.submitParameters(["note": "checked"])225 guard case .trust(let accesses)? = model.prompt else { Issue.record("expected the trust confirmation, got \(String(describing: model.prompt))"); return }226 #expect(accesses.map(\.path) == [dir.appendingPathComponent("shared.csv").path] && accesses[0].access == .write)227 #expect(!model.isRunning && Env.value(session, "Summary", "C1").isBlank)228 model.cancelPrompt()229 #expect(model.prompt == nil && model.lastRun == nil)230231 // "Run once" runs it without approving it232 let host = model.runHost(embedded, values: ["note": "checked"])233 #expect(host.isAuthorized(dir.appendingPathComponent("shared.csv"), for: .write))234 #expect(!host.isAuthorized(dir.appendingPathComponent("other.csv"), for: .write) && !host.isAuthorized(secret.appendingPathComponent("x"), for: .read))235 await model.runSelected(values: ["note": "checked"])236 #expect(model.lastRun?.status == .succeeded && Env.value(session, "Summary", "C1") == .text("checked"))237 #expect(!WorkflowTrust.isTrusted(embedded))238 // an edit does not smuggle in an approval239 model.edit { $0.name = "Renamed" }240 #expect(!model.isTrusted)241 // "Always trust" approves this exact text only242 model.requestRun()243 model.submitParameters(["note": "again"])244 #expect({ if case .trust? = model.prompt { true } else { false } }())245 WorkflowTrust.approve(model.workflow!)246 #expect(model.isTrusted)247 model.cancelPrompt()248 model.edit { $0.summary = "edited by me" }249 #expect(model.isTrusted) // edits of an approved workflow stay approved250 WorkflowTrust.revoke(model.workflow!)251 }252253 @Test func parameterProblemsKeepThePromptOpen() {254 let session = Env.session()255 let model = Env.model(session, base: Env.tempDir())256 model.select(WorkflowTemplates.csvReport.id, .template)257 #expect(!model.runsOnOpenWorkbook) // it creates its own workbook258 model.requestRun()259 #expect(model.prompt == .parameters(problems: []))260 #expect(model.draftValues(for: WorkflowTemplates.csvReport)["category"] == "category")261 model.submitParameters(["source": "/nowhere/missing.csv", "category": "category", "value": "amount"])262 guard case .parameters(let problems)? = model.prompt else { Issue.record("prompt closed"); return }263 #expect(problems.contains { $0.contains("file not found") } && !model.isRunning)264 model.cancelPrompt()265 }266267 @Test func standaloneTemplateRunFromTheModel() async throws {268 let dir = Env.tempDir()269 try Data("category,amount\nA,1\nB,2\nA,3\n".utf8).write(to: dir.appendingPathComponent("in.csv"))270 let session = Env.session()271 let model = Env.model(session, base: dir)272 model.select(WorkflowTemplates.csvReport.id, .template)273 await model.runSelected(values: ["source": dir.appendingPathComponent("in.csv").path])274 #expect(model.lastRun?.status == .succeeded, "\(model.lastRun?.message ?? "")")275 #expect(PDFDocument(url: dir.appendingPathComponent("in-report.pdf"))?.pageCount == 1)276 #expect(session.workbook.sheets.map(\.name) == ["Data", "Summary"] && !session.engine.canUndo && model.appliedSummary == nil) // standalone: the open workbook is not involved277 // the batch template is granted its dynamic output folder only278 let host = model.runHost(WorkflowTemplates.batchConvert, values: ["folder": dir.path])279 #expect(host.isAuthorized(dir.appendingPathComponent("xlsx/a.xlsx"), for: .write) && host.isAuthorized(dir.appendingPathComponent("a.csv"), for: .read))280 #expect(!host.isAuthorized(dir.appendingPathComponent("a.xlsx"), for: .write))281 }282283 @Test func schedulingNeedsALibraryWorkflowThatCanRunUnattended() {284 let session = Env.session()285 let model = Env.model(session, base: Env.tempDir())286 model.select(WorkflowTemplates.batchConvert.id, .template)287 #expect(model.scheduleWorkflowFile == nil && model.scheduleArguments() == nil)288 model.duplicateSelected()289 let id = model.selectedID!290 #expect(model.scheduleWorkflowFile?.lastPathComponent == "\(id.uuidString).orixflow")291 #expect(model.scheduleProblems.contains { $0.contains("needs a value") })292 let folder = Env.tempDir()293 model.parameterValues[id] = ["folder": folder.path]294 #expect(model.scheduleProblems.isEmpty)295 let args = model.scheduleArguments(tool: URL(fileURLWithPath: "/Apps/ORIX Sheet.app/Contents/MacOS/orix-sheet"))!296 #expect(args.prefix(3) == ["/Apps/ORIX Sheet.app/Contents/MacOS/orix-sheet", "run", model.scheduleWorkflowFile!.path])297 #expect(args.contains("folder=\(folder.path)") && !args.contains { $0.hasPrefix("outputFolder=") } && args.contains("--base-dir")) // defaults are resolved by the tool298 #expect(!model.scheduleIsInstalled)299 model.deleteSelected()300 }301}302