SPB Git

Repository Public

ModelTests.swift 16.7 KB 302 lines swift

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
Files main
Menu

Theme