Repository Public License
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