SPB Git

Repository Public License

StudioModelTests.swift 24.7 KB 440 lines swift

1// ORIX OS Automation2// File: Packages/ORIXFeatureWorkflow/Tests/ORIXFeatureWorkflowTests/StudioModelTests.swift3// Description: Integration tests of the studio view model against real services in a temporary folder: edits with undo/redo, inspector validation, saving, versions, palette insertion for every tool, and real dry and debug runs.4//5// Author: Simon-Pierre Boucher6// Contact: contact@spboucher.ai7import Foundation8import ORIXAppUI9import Testing10@testable import ORIXFeatureWorkflow1112@MainActor13func makeStudio(open id: String? = "system-health-report", seed: Bool = true) async throws -> WorkflowStudioModel {14    let app = try await PreviewEnvironment.make(seed: seed)15    let vm = WorkflowStudioModel(app: app)16    app.selectedWorkflowID = id17    await vm.reload(selected: id)18    return vm19}2021@MainActor22func waitUntil(_ seconds: Double = 30, _ condition: @MainActor () -> Bool) async -> Bool {23    let deadline = Date().addingTimeInterval(seconds)24    while Date() < deadline {25        if condition() { return true }26        try? await Task.sleep(nanoseconds: 50_000_000)27    }28    return condition()29}3031@Suite("Integration · studio edits (real services, temp folder)") @MainActor struct StudioEditTests {32    @Test func opensTheSelectedWorkflowAndFollowsTheAppSelectionBothWays() async throws {33        let vm = try await makeStudio()34        #expect(vm.workflowID == "system-health-report")35        #expect(vm.rows.count == 3 && vm.document != nil && !vm.isDirty)36        #expect(vm.graph.nodes.contains { $0.id == "write" && $0.category == .tool })37        #expect(vm.errors.isEmpty)38        await vm.open("folder-backup-and-verify")39        #expect(vm.app.selectedWorkflowID == "folder-backup-and-verify")40        vm.app.selectedWorkflowID = "smart-downloads-organizer"41        await vm.reload(selected: vm.app.selectedWorkflowID)42        #expect(vm.workflowID == "smart-downloads-organizer")43        vm.search = "health"44        #expect(vm.filteredRows.map(\.id) == ["system-health-report"])45    }4647    @Test func everyCanvasEditIsUndoableAndRedoable() async throws {48        let vm = try await makeStudio()49        let original = try #require(vm.document)50        let tool = try #require(vm.manifestByID["filesystem.list"])5152        // Add after the selected step: wired with `needs`, required arguments stubbed.53        vm.selection = ["write"]54        let added = try #require(vm.add(.tool(tool)))55        var step = try #require(vm.document?.step(id: added))56        #expect(step.needs == ["write"])57        if case .tool(let t) = step.kind { #expect(t.tool == "filesystem.list" && t.arguments["path"] != nil) } else { Issue.record("not a tool step") }58        #expect(vm.selection == [added] && vm.isDirty && vm.canUndo)5960        // Connect, then disconnect by deleting the edge.61        vm.connect(from: "paths", port: "out", to: added)62        #expect(vm.document?.step(id: added)?.needs == ["write", "paths"])63        let edge = try #require(vm.graph.edges.first { $0.from == "paths" && $0.to == added })64        vm.selectedEdgeID = edge.id65        vm.removeSelection()66        #expect(vm.document?.step(id: added)?.needs == ["write"])6768        // A cycle is refused and reported; the document does not change.69        let before = vm.document70        vm.connect(from: added, port: "out", to: "write")71        #expect(vm.document == before && vm.editMessage != nil)7273        // Rename rewrites references.74        #expect(vm.rename("freeFraction", to: "share") == nil)75        let renamed = try #require(vm.document)76        #expect(renamed.step(id: "freeFraction") == nil && renamed.step(id: "write")?.needs.contains("share") == true)77        #expect(WorkflowCodec.emit(renamed).contains("steps.share.output") && !WorkflowCodec.emit(renamed).contains("steps.freeFraction"))78        #expect(vm.rename("share", to: "write") != nil)      // duplicate id refused inline7980        // Duplicate, move with snapping, group, wrap, auto-layout, delete.81        vm.selection = [added]82        vm.duplicateSelection()83        let copy = try #require(vm.selection.first)84        #expect(copy != added && vm.document?.step(id: copy) != nil)85        vm.commitMove([copy], by: CGSize(width: 33, height: 47))86        let position = try #require(vm.document?.spec.layout[copy])87        #expect(position.x.truncatingRemainder(dividingBy: 20) == 0 && position.y.truncatingRemainder(dividingBy: 20) == 0)88        #expect(vm.geometry.frames[copy]?.origin == CGPoint(x: position.x, y: position.y))89        vm.selection = [added, copy]90        vm.groupSelectionIntoParallel()91        let group = try #require(vm.selection.first)92        if case .parallel(let p) = vm.document?.step(id: group)?.kind { #expect(p.branches.flatMap(\.steps).map(\.id).sorted() == [added, copy].sorted()) } else { Issue.record("not grouped") }93        vm.selection = [group]94        vm.wrapSelectionInForeach()95        let loop = try #require(vm.selection.first)96        #expect(vm.document?.location(of: group)?.containerID == loop)97        vm.autoLayout()98        #expect(vm.document?.spec.layout.isEmpty == false)99        vm.selection = [loop]100        vm.removeSelection()101        #expect(vm.document?.step(id: loop) == nil && vm.document?.step(id: added) == nil)102        step = try #require(vm.document?.step(id: "write"))103104        // Undo everything, then redo everything.105        let final = vm.document106        var undos = 0107        while vm.canUndo { vm.undo(); undos += 1 }108        #expect(undos == 10)109        #expect(vm.document == original && !vm.isDirty)110        while vm.canRedo { vm.redo() }111        #expect(vm.document == final)112        // Every state along the way is a valid, round-trippable document.113        #expect(try WorkflowCodec.parse(WorkflowCodec.emit(#require(final))) == final)114    }115116    @Test func branchAndErrorPortsCreateAndRemoveRoutes() async throws {117        let vm = try await makeStudio()118        vm.selection = []119        let note = try #require(vm.add(.template(.notify)))120        vm.connect(from: "lowDisk", port: "else", to: note)121        if case .condition(let c) = vm.document?.step(id: "lowDisk")?.kind { #expect(c.otherwise == [note]) } else { Issue.record("no condition") }122        let branch = try #require(vm.graph.edges.first { $0.kind == .branch && $0.to == note })123        #expect(branch.label == "else")124        vm.deleteEdge(branch)125        if case .condition(let c) = vm.document?.step(id: "lowDisk")?.kind { #expect(c.otherwise.isEmpty) }126        vm.connect(from: "check", port: "error", to: note)127        #expect(vm.document?.step(id: "check")?.onError == note)128        #expect(vm.graph.node(note)?.category == .error)129        let route = try #require(vm.graph.edges.first { $0.kind == .error })130        vm.deleteEdge(route)131        #expect(vm.document?.step(id: "check")?.onError == nil)132        // Trigger links are derived and cannot be removed.133        let trigger = try #require(vm.graph.edges.first { $0.kind == .trigger })134        let before = vm.document135        vm.deleteEdge(trigger)136        #expect(vm.document == before && vm.editMessage != nil)137    }138139    @Test func selectionAndKeyboardNavigationModel() async throws {140        let vm = try await makeStudio()141        vm.selectAll()142        #expect(vm.selection.count == vm.graph.nodes.count)143        vm.clearSelection()144        #expect(vm.selection.isEmpty && vm.inspectedStep == nil)145        vm.select("write", extend: false)146        vm.select("check", extend: true)147        #expect(vm.selection == ["write", "check"] && vm.inspectedStep == nil)148        vm.select("check", extend: true)149        #expect(vm.selection == ["write"] && vm.inspectedStep?.step.id == "write")150        vm.moveSelection(.right)151        #expect(vm.selection == ["check"])152        vm.moveSelection(.left)153        #expect(vm.selection == ["write"])154        let frame = try #require(vm.geometry.frames["collect"])155        vm.select(in: frame.insetBy(dx: -4, dy: -4), extend: false)156        #expect(vm.selection.isSuperset(of: ["collect", "info", "disk"]))157        vm.selection = ["trigger:1"]158        vm.removeSelection()159        #expect(vm.document?.spec.triggers == [.manual])160        vm.undo()161        #expect(vm.document?.spec.triggers.count == 2)162    }163164    @Test func inspectorEditsAreValidatedAndRefusedInline() async throws {165        let vm = try await makeStudio()166        let manifest = try #require(vm.manifestByID["filesystem.write"])167        let fields = ArgumentForm.fields(of: manifest.inputSchema)168        let overwrite = try #require(fields.first { $0.name == "overwrite" })169        let path = try #require(fields.first { $0.name == "path" })170        let start = vm.document171172        // Argument form ↔ document round trip.173        #expect(vm.setArgument("write", field: path, text: "~/ORIX Samples/x.md") == nil)174        #expect(vm.setArgument("write", field: overwrite, text: "false") == nil)175        guard case .tool(let t) = vm.document?.step(id: "write")?.kind else { Issue.record("no tool"); return }176        #expect(t.arguments["path"] == .string("~/ORIX Samples/x.md") && t.arguments["overwrite"] == .bool(false))177        #expect(ArgumentForm.text(for: t.arguments["overwrite"]) == "false")178        #expect(vm.setArgument("write", field: overwrite, text: "${{ params.minFreeFraction > 0 }}") == nil)179        #expect(vm.setArgument("write", field: overwrite, text: "") == nil)       // optional argument removed180        if case .tool(let t2) = vm.document?.step(id: "write")?.kind { #expect(t2.arguments["overwrite"] == nil) }181182        // Refused: wrong type, unknown names in expressions, required argument cleared, non-upstream step.183        let valid = vm.document184        #expect(vm.setArgument("write", field: overwrite, text: "perhaps") != nil)185        #expect(vm.setArgument("write", field: path, text: "${{ params.missing }}") != nil)186        #expect(vm.setArgument("write", field: path, text: "${{ steps.result.output }}") != nil)187        #expect(vm.setField("write", .when("${{ nonsense( }}")) != nil)188        #expect(vm.setField("write", .onError("info")) != nil)                     // another list189        #expect(vm.update("write") { $0.needs.append("ghost") } != nil)190        #expect(vm.document == valid)191192        // Accepted flow fields.193        #expect(vm.setField("write", .when("${{ params.minFreeFraction > 0 }}")) == nil)194        #expect(vm.setField("write", .retry(WorkflowRetryPolicy(maxAttempts: 3, backoffSeconds: 1))) == nil)195        #expect(vm.setField("write", .timeoutSeconds(20)) == nil)196        #expect(vm.setField("write", .continueOnError(true)) == nil)197        let edited = try #require(vm.document?.step(id: "write"))198        #expect(edited.when != nil && edited.retry?.maxAttempts == 3 && edited.timeoutSeconds == 20 && edited.continueOnError)199200        // Changing the tool keeps compatible arguments and stubs the required ones.201        #expect(vm.setTool("write", to: "filesystem.mkdir") == nil)202        if case .tool(let t3) = vm.document?.step(id: "write")?.kind { #expect(t3.tool == "filesystem.mkdir" && t3.arguments["path"] == .string("~/ORIX Samples/x.md") && t3.arguments["content"] == nil) }203        #expect(vm.setTool("write", to: "no.such.tool") != nil)204205        // Workflow settings.206        #expect(vm.updateDocument { $0.metadata.name = "Health" } == nil)207        #expect(vm.updateDocument { $0.spec.budget.maxToolCalls = 0 } != nil)208        #expect(vm.updateDocument { $0.spec.triggers.append(.schedule(cron: "61 * * * *", timezone: nil)) } != nil)209        #expect(vm.updateDocument { $0.spec.parameters.removeAll { $0.name == "outputFolder" } } != nil)   // still used210        #expect(vm.updateDocument { $0.spec.permissions.network.append("api.example.com") } == nil)211        #expect(vm.document?.metadata.name == "Health")212        while vm.canUndo { vm.undo() }213        #expect(vm.document == start)214    }215216    @Test func paletteInsertionIsValidForEveryToolKindAndAgent() async throws {217        let vm = try await makeStudio()218        #expect(vm.manifests.count > 20)219        await vm.createBlank()220        let blank = try #require(vm.document)221        var failures: [String] = []222        let items = vm.manifests.map(PaletteItem.tool) + StepTemplate.allCases.map(PaletteItem.template) + vm.agents.map(PaletteItem.agent)223        for item in items {224            vm.selection = []225            guard let id = vm.add(item), let doc = vm.document else { failures.append("\(item.id): refused (\(vm.editMessage ?? "?"))"); continue }226            let result = await vm.services.workflows.diagnose(WorkflowCodec.emit(doc))227            let errors = result.diagnostics.filter { $0.severity == .error }228            if !errors.isEmpty { failures.append("\(item.id): " + errors.map(\.message).joined(separator: "; ")) }229            if result.document != doc { failures.append("\(item.id): does not round-trip") }230            if doc.step(id: id) == nil { failures.append("\(item.id): step missing") }231            vm.undo()232            #expect(vm.document == blank)233        }234        #expect(failures.isEmpty, "\(failures.joined(separator: "\n"))")235        if failures.isEmpty { print("PALETTE inserted \(items.count) entries (\(vm.manifests.count) tools, \(StepTemplate.allCases.count) step kinds, \(vm.agents.count) agents) without validation errors") }236        // Inside a selected container.237        let each = try #require(vm.add(.template(.foreach)))238        vm.selection = [each]239        let inner = try #require(vm.add(.template(.delay)))240        #expect(vm.document?.location(of: inner)?.containerID == each)241    }242}243244@Suite("Integration · studio saving and versions (real services, temp folder)") @MainActor struct StudioSaveTests {245    @Test func firstVisualSaveShowsWhatTheRewriteDropsThenSavesAndReloadsEqual() async throws {246        let vm = try await makeStudio()247        #expect(!vm.lossNotes.isEmpty)                       // the template has comments248        #expect(vm.lossNotes.contains { $0.contains("comment") })249        #expect(vm.setField("write", .timeoutSeconds(45)) == nil)250        #expect(vm.canSave)251        #expect(await vm.save() == false)252        #expect(vm.showLossConfirmation && vm.loadedVersion == 1 && vm.isDirty)253        vm.showLossConfirmation = false254        #expect(await vm.save(confirmedLoss: true))255        #expect(!vm.isDirty && vm.loadedVersion == 2 && vm.lossNotes.isEmpty)256        let edited = try #require(vm.document)257258        // The stored text is exactly the canonical emission, so the code view sees the same model.259        let stored = try await vm.services.workflows.source(workflowID: "system-health-report")260        #expect(stored == WorkflowCodec.emit(edited, format: .yaml))261        #expect(WorkflowCodec.roundTripLoss(source: stored).isEmpty)262263        // A fresh model reads back an equal document; later saves need no confirmation.264        let second = WorkflowStudioModel(app: vm.app)265        await second.reload(selected: "system-health-report")266        #expect(second.document == edited && second.document?.step(id: "write")?.timeoutSeconds == 45)267        #expect(second.setField("write", .timeoutSeconds(50)) == nil)268        #expect(await second.save())269        #expect(second.loadedVersion == 3)270271        // The first model notices the newer version: it reloads when clean.272        await vm.reload(selected: "system-health-report")273        #expect(vm.loadedVersion == 3 && vm.document?.step(id: "write")?.timeoutSeconds == 50)274        // …and warns instead of overwriting when it has unsaved edits.275        #expect(vm.setField("write", .timeoutSeconds(60)) == nil)276        _ = try await vm.services.workflows.save(source: stored, note: "Saved from the code view")277        await vm.reload(selected: "system-health-report")278        #expect(vm.newerVersionAvailable && vm.document?.step(id: "write")?.timeoutSeconds == 60)279        await vm.revert()280        #expect(!vm.newerVersionAvailable && vm.loadedVersion == 4 && vm.document?.step(id: "write")?.timeoutSeconds == 45)281    }282283    @Test func saveIsDisabledWhileThereAreErrors() async throws {284        let vm = try await makeStudio()285        // Removing a step that expressions still read is allowed on the canvas and reported by the validator.286        vm.selection = ["freeFraction"]287        vm.removeSelection()288        await vm.refreshDiagnostics()289        #expect(!vm.errors.isEmpty && vm.errors.contains { $0.stepID != nil })290        #expect(!vm.canSave)291        #expect(await vm.save(confirmedLoss: true) == false)292        #expect(vm.loadedVersion == 1)293        vm.undo()294        await vm.refreshDiagnostics()295        #expect(vm.errors.isEmpty)296    }297298    @Test func newDuplicateTemplateAndDelete() async throws {299        let vm = try await makeStudio()300        await vm.createBlank()301        #expect(vm.workflowID == "new-workflow" && vm.rows.count == 4)302        let blank = try #require(vm.document)303        #expect(blank.spec.triggers == [.manual] && blank.spec.steps.count == 1 && vm.errors.isEmpty && !vm.isDirty)304        await vm.createBlank()305        #expect(vm.workflowID == "new-workflow-2")306        let row = try #require(vm.rows.first { $0.id == "new-workflow" })307        await vm.duplicate(row)308        #expect(vm.workflowID == "new-workflow-copy" && vm.document?.spec.steps == blank.spec.steps)309        let template = try #require(BuiltInWorkflows.all().first { $0.slug == "batch-image-conversion" } ?? BuiltInWorkflows.all().last)310        #expect(await vm.installTemplate(template))311        #expect(vm.document?.metadata.name == template.title)312        let count = vm.rows.count313        await vm.delete(try #require(vm.currentRow))314        #expect(vm.rows.count == count - 1 && vm.workflowID != nil && vm.workflowID == vm.app.selectedWorkflowID)315        #expect(BuiltInWorkflows.all().count >= 10)316    }317318    @Test func unsavedEditsSurviveSwitchingWorkflows() async throws {319        let vm = try await makeStudio()320        #expect(vm.setField("write", .timeoutSeconds(12)) == nil)321        await vm.open("folder-backup-and-verify")322        #expect(vm.hasDraft("system-health-report") && !vm.isDirty)323        await vm.open("system-health-report")324        #expect(vm.isDirty && vm.document?.step(id: "write")?.timeoutSeconds == 12 && vm.canUndo)325    }326327    @Test func versionHistoryDiffsFlagPermissionChangesAndRestoreSavesANewVersion() async throws {328        let vm = try await makeStudio()329        let first = try #require(vm.document)330        #expect(vm.updateDocument { $0.spec.permissions.network.append("api.example.com") } == nil)331        #expect(vm.setField("write", .timeoutSeconds(30)) == nil)332        #expect(await vm.save(confirmedLoss: true))333        let versions = await vm.versions()334        #expect(versions.map(\.version) == [2, 1])335        #expect(versions[0].note.contains("Workflow Studio"))336        let changes = try vm.changes(since: versions[1]).get()337        #expect(changes.contains { $0.isSecurityRelevant && $0.summary.contains("api.example.com") })338        #expect(changes.contains { if case .stepModified(let id, _) = $0 { return id == "write" }; return false })339        #expect(try vm.changes(since: versions[0]).get().isEmpty)340        #expect(await vm.restore(versions[1]))341        #expect(vm.loadedVersion == 3 && vm.document == first)342        #expect(await vm.versions().first?.note == "Restored from version 1")343    }344345    @Test func generateWithoutAModelReportsItAndSavesNothing() async throws {346        let vm = try await makeStudio(open: nil, seed: false)347        #expect(vm.rows.isEmpty && vm.document == nil)348        do {349            _ = try await vm.services.workflows.generate(objective: "List my downloads")350            Issue.record("generation should need a model")351        } catch {352            guard case RunError.noModel = error else { Issue.record("unexpected error \(error)"); return }353        }354        #expect(await vm.services.workflows.list().isEmpty)355    }356}357358@Suite("Integration · studio runs (real engine, temp folder)") @MainActor struct StudioRunTests {359    @Test func dryRunGoesThroughPermissionReviewAndShowsSimulatedSteps() async throws {360        let vm = try await makeStudio()361        let folder = NSHomeDirectory() + "/ORIX Samples/system-health-report/Reports"362        let existedBefore = FileManager.default.fileExists(atPath: folder)363        let filesBefore = (try? FileManager.default.contentsOfDirectory(atPath: folder)) ?? []364        let review = try await vm.services.workflows.permissionReview(workflowID: "system-health-report")365        #expect(!review.accepted && !review.proposed.isEmpty)366        await vm.requestRun(.dryRun)367        #expect(vm.runRequest == .dryRun && vm.activeRunID == nil)     // not accepted yet: the sheet is shown368        vm.runRequest = nil369        let runID = try #require(await vm.start(.dryRun, parameters: [:], accept: true))370        #expect(try await vm.services.workflows.permissionReview(workflowID: "system-health-report").accepted)371        #expect(await waitUntil { vm.runRecord?.status.isTerminal == true && !vm.runIsLive && vm.runReceipt != nil })372        #expect(vm.activeRunID == runID && vm.runIsDry && vm.showDrawer)373        // What was simulated is reported, from the live outcome or (when the run ended before it could be followed) the receipt.374        let simulated = vm.runOutcome?.simulations ?? vm.runReceipt?.limitations ?? []375        #expect(simulated.contains { $0.contains("prepare") && $0.contains("simulated") })376        #expect(vm.stepInfo["prepare"]?.status == .simulated)377        #expect(vm.stepInfo["info"]?.status == .simulated && vm.stepInfo["collect"] != nil)378        #expect(vm.stepInfo["paths"]?.status == .succeeded && vm.stepInfo["paths"]?.output != nil)379        #expect(vm.stepInfo["paths"]?.durationSeconds != nil)380        #expect(vm.runRecord?.status.isTerminal == true && vm.runReceipt != nil)381        // The dry run wrote nothing.382        #expect(FileManager.default.fileExists(atPath: folder) == existedBefore)383        #expect(((try? FileManager.default.contentsOfDirectory(atPath: folder)) ?? []) == filesBefore)384        // Already accepted: the next request starts directly.385        await vm.requestRun(.dryRun)386        #expect(vm.runRequest == nil && vm.activeRunID != runID)387        #expect(await waitUntil { vm.runRecord?.status.isTerminal == true && !vm.runIsLive })388389        // A fresh model shows the last run's data from the store.390        let later = WorkflowStudioModel(app: vm.app)391        await later.reload(selected: "system-health-report")392        #expect(later.activeRunID == vm.activeRunID && later.runHandle == nil)393        #expect(later.stepInfo["prepare"]?.status == .simulated && later.stepInfo["paths"]?.status == .succeeded)394    }395396    @Test func debugRunPausesStepsOverEditsVariablesAndStopsAtBreakpoints() async throws {397        let vm = try await makeStudio()398        var doc = Palette.blankDocument(existingIDs: [])399        doc.metadata.id = "debug-me"400        doc.spec.steps = [401            WorkflowStep(id: "one", kind: .set(SetStep(values: ["n": 1]))),402            WorkflowStep(id: "two", needs: ["one"], kind: .transform(TransformStep(expression: "${{ vars.n + 1 }}", into: "m"))),403            WorkflowStep(id: "three", needs: ["two"], kind: .output(OutputStep(values: ["m": "${{ vars.m }}"]))),404        ]405        #expect(await vm.install(doc))406        vm.toggleBreakpoint("three")407        #expect(vm.breakpoints == ["three"])408        await vm.requestRun(.debug)                 // no declared permission → nothing to accept, but the sheet still asks once409        if vm.runRequest != nil { vm.runRequest = nil; _ = await vm.start(.debug, parameters: [:], accept: false) }410        #expect(await waitUntil { vm.runIsPaused })411        #expect(vm.stepInfo["one"] == nil || vm.stepInfo["one"]?.status != .succeeded)412        vm.stepOver()413        #expect(await waitUntil { vm.stepInfo["one"]?.status == .succeeded && vm.runVariables["n"] == .int(1) })414        #expect(vm.runIsPaused && vm.runIsLive)415        #expect(await vm.setVariable("n", text: "41") == nil)416        #expect(vm.runVariables["n"] == .int(41))417        vm.resumeRun()                              // runs "two", then holds at the breakpoint on "three"418        #expect(await waitUntil { vm.stepInfo["two"]?.status == .succeeded && vm.runState?.pausedAt == ["three"] })419        #expect(vm.stepInfo["two"]?.output == .int(42))420        vm.toggleBreakpoint("three")421        vm.resumeRun()422        #expect(await waitUntil { vm.runOutcome != nil })423        #expect(vm.runOutcome?.status == .succeeded && vm.runOutcome?.outputs["m"] == .int(42))424        #expect(vm.stepInfo["three"]?.status == .succeeded && !vm.runIsLive)425    }426427    @Test func stopCancelsARunningWorkflow() async throws {428        let vm = try await makeStudio()429        var doc = Palette.blankDocument(existingIDs: [])430        doc.metadata.id = "slow"431        doc.spec.steps = [WorkflowStep(id: "wait", kind: .delay(DelayStep(seconds: 30)))]432        #expect(await vm.install(doc))433        _ = try #require(await vm.start(.run, parameters: [:], accept: false))434        #expect(await waitUntil { vm.stepInfo["wait"]?.status == .running })435        vm.stopRun()436        #expect(await waitUntil { vm.runOutcome != nil })437        #expect(vm.runOutcome?.status == .canceled && !vm.runIsLive)438    }439}440
Files main
Menu

Theme