SPB Git

Repository Public License

GraphTests.swift 41.1 KB 541 lines swift

1// ORIX OS Automation2// File: Packages/ORIXWorkflowEngine/Tests/ORIXWorkflowEngineTests/GraphTests.swift3// Description: Unit and property tests of the graph projection, auto-layout, visual edit operations and document diff.4//5// Author: Simon-Pierre Boucher6// Contact: contact@spboucher.ai7import Foundation8import Testing9import ORIXCore10@testable import ORIXWorkflowEngine1112private func tool(_ id: String, needs: [String] = [], _ tool: String = "filesystem.list", with args: [String: JSONValue] = [:]) -> WorkflowStep {13    WorkflowStep(id: id, needs: needs, kind: .tool(ToolStep(tool: tool, arguments: args)))14}1516private func document(_ steps: [WorkflowStep], triggers: [WorkflowTrigger] = [], onError: [WorkflowStep] = []) -> WorkflowDocument {17    WorkflowDocument(metadata: WorkflowMetadata(id: "g", name: "Graph"), spec: WorkflowSpec(triggers: triggers, steps: steps, onError: onError))18}1920/// A document touching every graph feature.21private func sampleDocument() -> WorkflowDocument {22    var list = tool("list")23    list.onError = "cleanup"24    list.name = "List files"25    let cond = WorkflowStep(id: "check", needs: ["list"], kind: .condition(ConditionStep(condition: "${{ len(steps.list.output.entries) > 0 }}", then: ["each"], otherwise: ["nothing"])))26    let each = WorkflowStep(id: "each", kind: .foreach(ForeachStep(items: "${{ steps.list.output.entries }}", steps: [27        tool("read", needs: [], "filesystem.read"), WorkflowStep(id: "shape", needs: ["read"], kind: .transform(TransformStep(expression: "upper(steps.read.output.text)"))),28    ], collect: "shape")))29    let nothing = WorkflowStep(id: "nothing", kind: .notify(NotifyStep(message: "Nothing to do")))30    let sw = WorkflowStep(id: "route", needs: ["each"], kind: .switch(SwitchStep(on: "params.mode", cases: [SwitchCase(value: "fast", steps: ["par"])], defaultSteps: ["loop"])))31    let par = WorkflowStep(id: "par", kind: .parallel(ParallelStep(branches: [32        ParallelBranch(name: "left", steps: [tool("l1"), tool("l2", needs: ["l1"])]), ParallelBranch(name: "right", steps: [tool("r1")]),33    ])))34    let loop = WorkflowStep(id: "loop", kind: .loop(LoopStep(condition: "vars.n < 3", maxIterations: 5, steps: [WorkflowStep(id: "inc", kind: .set(SetStep(values: ["n": "${{ vars.n + 1 }}"])))])))35    let cleanup = WorkflowStep(id: "cleanup", kind: .fail(FailStep(message: "listing failed")))36    let agent = WorkflowStep(id: "think", needs: ["route"], kind: .agent(AgentStep(agent: .profile("analyst"), objective: "x")))37    let out = WorkflowStep(id: "out", needs: ["think"], kind: .output(OutputStep(values: ["n": 1])))38    return document([list, cond, each, nothing, sw, par, loop, cleanup, agent, out],39                    triggers: [.manual, .schedule(cron: "0 9 * * MON", timezone: "America/Toronto")],40                    onError: [WorkflowStep(id: "alert", kind: .notify(NotifyStep(message: "failed")))])41}4243@Suite("Graph projection (unit)") struct GraphProjectionTests {44    @Test func nodesCategoriesPortsAndMembership() {45        let g = WorkflowGraph(document: sampleDocument())46        #expect(g.nodes.map(\.id) == ["trigger:0", "trigger:1", "list", "check", "each", "nothing", "route", "par", "loop", "cleanup", "think", "out",47                                      "read", "shape", "l1", "l2", "r1", "inc", "alert"])48        func cat(_ id: String) -> WorkflowGraph.Category? { g.node(id)?.category }49        #expect(cat("trigger:0") == .trigger && cat("list") == .tool && cat("check") == .logic && cat("each") == .logic)50        #expect(cat("par") == .parallelism && cat("inc") == .data && cat("cleanup") == .error && cat("think") == .agent)51        #expect(cat("out") == .output && cat("nothing") == .output && cat("alert") == .error && cat("shape") == .logic)52        #expect(g.node("list")?.title == "List files" && g.node("list")?.subtitle == "filesystem.list" && g.node("check")?.title == "check")53        #expect(g.node("trigger:1")?.subtitle == "0 9 * * MON (America/Toronto)" && g.node("think")?.subtitle == "analyst")54        #expect(g.node("list")?.outputs.map(\.id) == ["out", "error"] && g.node("list")?.inputs.map(\.id) == ["in"])55        #expect(g.node("check")?.outputs.map(\.id) == ["out", "then", "else"])56        #expect(g.node("route")?.outputs.map(\.id) == ["out", "case:0", "default"] && g.node("route")?.outputs[1].label == "fast")57        #expect(g.node("each")?.outputs.map(\.id) == ["out", "body"] && g.node("trigger:0")?.inputs.isEmpty == true)58        #expect(g.node("read")?.parentID == "each" && g.node("read")?.branch == nil)59        #expect(g.node("l2")?.parentID == "par" && g.node("l2")?.branch == "left" && g.node("r1")?.branch == "right")60        #expect(g.node("par")?.isContainer == true && g.node("list")?.isContainer == false && g.node("alert")?.parentID == nil)61        #expect(g.children(of: "par").map(\.id) == ["l1", "l2", "r1"])62    }6364    @Test func everyEdgeKind() {65        let g = WorkflowGraph(document: sampleDocument())66        func has(_ from: String, _ port: String, _ to: String, _ kind: WorkflowGraph.EdgeKind, _ label: String = "") -> Bool {67            g.edges.contains { $0.from == from && $0.fromPort == port && $0.to == to && $0.toPort == "in" && $0.kind == kind && $0.label == label }68        }69        #expect(has("list", "out", "check", .dependency) && has("read", "out", "shape", .dependency) && has("l1", "out", "l2", .dependency))70        #expect(has("check", "then", "each", .branch, "then") && has("check", "else", "nothing", .branch, "else"))71        #expect(has("route", "case:0", "par", .branch, "fast") && has("route", "default", "loop", .branch, "default"))72        #expect(has("list", "error", "cleanup", .error, "on error"))73        // Triggers reach only root steps that start on their own: not gated, not handlers, no needs.74        let triggered = g.edges.filter { $0.kind == .trigger && $0.from == "trigger:0" }.map(\.to)75        #expect(triggered == ["list"])76        #expect(g.edges.filter { $0.kind == .trigger }.count == 2)77        #expect(Set(g.edges.map(\.id)).count == g.edges.count)78    }7980    @Test func danglingReferencesProduceNoEdge() {81        let g = WorkflowGraph(document: document([tool("a", needs: ["ghost"])]))82        #expect(g.edges.isEmpty && g.nodes.count == 1)83    }84}8586@Suite("Graph auto-layout (unit)") struct GraphLayoutTests {87    private func overlaps(_ a: WorkflowGraph.Node, _ b: WorkflowGraph.Node) -> Bool {88        a.x < b.x + b.width && b.x < a.x + a.width && a.y < b.y + b.height && b.y < a.y + a.height89    }9091    @Test func layoutIsDeterministicLayeredAndFreeOfOverlaps() {92        let doc = sampleDocument()93        #expect(WorkflowGraph.autoLayout(doc) == WorkflowGraph.autoLayout(doc))94        let g = WorkflowGraph(document: doc)95        #expect(g == WorkflowGraph(document: doc))96        let groups = Dictionary(grouping: g.nodes, by: { ($0.parentID ?? "") })97        for (_, nodes) in groups {98            for i in nodes.indices { for j in nodes.indices where i < j {99                #expect(!overlaps(nodes[i], nodes[j]), "\(nodes[i].id) overlaps \(nodes[j].id)")100            } }101        }102        // Layers follow dependency, branch and error edges.103        for e in g.edges where e.kind != .trigger { #expect(g.node(e.from)!.x < g.node(e.to)!.x, "\(e.id) does not go left to right") }104        #expect(g.node("trigger:0")!.x < 0 && g.node("list")!.x == 0 && g.node("list")!.y == 0)105        // Containers enclose their children (child positions are relative to the container).106        for n in g.nodes { if let p = n.parentID, let c = g.node(p) {107            #expect(n.x >= 0 && n.y >= 0 && n.x + n.width <= c.width && n.y + n.height <= c.height, "\(n.id) leaves \(p)")108        } }109        #expect(g.node("alert")!.y > g.node("out")!.y)110    }111112    @Test func storedLayoutOverridesAutoPositionsAndResizesContainers() throws {113        var doc = sampleDocument()114        let auto = WorkflowGraph(document: doc)115        doc = try WorkflowEdit.moveNode("list", x: 500, y: 600, in: doc)116        doc = try WorkflowEdit.moveNode("read", x: 900, y: 30, in: doc)117        doc = try WorkflowEdit.moveNode("trigger:1", x: -10, y: -20, in: doc)118        let g = WorkflowGraph(document: doc)119        #expect(g.node("list")!.x == 500 && g.node("list")!.y == 600)120        #expect(g.node("trigger:1")!.x == -10 && g.node("trigger:1")!.y == -20)121        #expect(g.node("check")!.x == auto.node("check")!.x)122        #expect(g.node("each")!.width >= 900 + WorkflowGraph.leafSize.width && g.node("each")!.width > auto.node("each")!.width)123        let applied = doc.applyingAutoLayout()124        #expect(applied.spec.layout.count == doc.allSteps.count && applied.spec.layout["list"] == WorkflowNodePosition(x: 0, y: 0))125        #expect(WorkflowValidator.validate(applied, tools: [], agents: [], workflows: []).allSatisfy { $0.code != "stale-layout" })126    }127128    @Test func cyclicDocumentsStillLayOut() {129        let g = WorkflowGraph(document: document([tool("a", needs: ["b"]), tool("b", needs: ["a"])]))130        #expect(g.nodes.count == 2)131    }132}133134@Suite("Graph edits (unit)") struct GraphEditTests {135    private func threw(_ expected: WorkflowEditError, _ body: () throws -> WorkflowDocument) -> Bool {136        do { _ = try body(); return false } catch let e as WorkflowEditError { return e == expected } catch { return false }137    }138    private func throwsEdit(_ body: () throws -> WorkflowDocument) -> WorkflowEditError? {139        do { _ = try body(); return nil } catch let e as WorkflowEditError { return e } catch { return nil }140    }141142    @Test func addStepToRootContainerAndBranch() throws {143        var doc = sampleDocument()144        doc = try WorkflowEdit.addStep(tool("new"), to: doc)145        #expect(doc.spec.steps.last?.id == "new")146        doc = try WorkflowEdit.addStep(tool("first"), to: doc, at: 0)147        #expect(doc.spec.steps.first?.id == "first")148        doc = try WorkflowEdit.addStep(tool("inEach"), to: doc, inContainer: "each", at: 1)149        #expect(doc.location(of: "inEach")?.containerID == "each" && doc.location(of: "inEach")?.index == 1)150        doc = try WorkflowEdit.addStep(tool("inLoop"), to: doc, inContainer: "loop")151        doc = try WorkflowEdit.addStep(tool("inRight"), to: doc, inContainer: "par", branch: "right")152        doc = try WorkflowEdit.addStep(tool("inNew"), to: doc, inContainer: "par", branch: "extra")153        #expect(doc.location(of: "inRight")?.branch == "right" && doc.location(of: "inNew")?.branch == "extra" && doc.location(of: "inLoop")?.containerID == "loop")154        #expect(threw(.duplicateID("list")) { try WorkflowEdit.addStep(tool("list"), to: doc) })155        #expect(threw(.duplicateID("l1")) { try WorkflowEdit.addStep(WorkflowStep(id: "c", kind: .loop(LoopStep(condition: "true", maxIterations: 1, steps: [tool("l1")]))), to: doc) })156        #expect(threw(.invalidID("9 bad")) { try WorkflowEdit.addStep(tool("9 bad"), to: doc) })157        #expect(threw(.unknownStep("ghost")) { try WorkflowEdit.addStep(tool("x"), to: doc, inContainer: "ghost") })158        if case .invalid? = throwsEdit({ try WorkflowEdit.addStep(tool("x"), to: doc, inContainer: "list") }) {} else { Issue.record("a tool step cannot contain steps") }159        if case .invalid? = throwsEdit({ try WorkflowEdit.addStep(tool("x"), to: doc, inContainer: "par") }) {} else { Issue.record("parallel needs a branch") }160        if case .invalid? = throwsEdit({ try WorkflowEdit.addStep(tool("x", needs: ["ghost"]), to: doc) }) {} else { Issue.record("unknown need must be refused") }161    }162163    @Test func removeStepDropsReferencesNestedLayoutAndIsRefusedWhenUnknown() throws {164        var doc = sampleDocument()165        doc.spec.layout = ["each": .init(x: 1, y: 2), "read": .init(x: 3, y: 4), "list": .init(x: 5, y: 6)]166        doc.spec.steps.append(WorkflowStep(id: "v", needs: ["each", "list"], kind: .verify(VerifyStep(assertions: [.stepSucceeded("each"), .stepSucceeded("list")]))))167        let out = try WorkflowEdit.removeStep("each", from: doc)168        #expect(out.step(id: "each") == nil && out.step(id: "read") == nil && out.step(id: "shape") == nil)169        #expect(out.step(id: "route")?.needs == [] && out.step(id: "v")?.needs == ["list"])170        #expect(out.step(id: "check")?.kind == .condition(ConditionStep(condition: "${{ len(steps.list.output.entries) > 0 }}", then: [], otherwise: ["nothing"])))171        #expect(out.step(id: "v")?.kind == .verify(VerifyStep(assertions: [.stepSucceeded("list")])))172        #expect(out.spec.layout == ["list": .init(x: 5, y: 6)])173        let noHandler = try WorkflowEdit.removeStep("cleanup", from: doc)174        #expect(noHandler.step(id: "list")?.onError == nil)175        let noCollect = try WorkflowEdit.removeStep("shape", from: doc)176        if case .foreach(let f)? = noCollect.step(id: "each")?.kind { #expect(f.collect == nil && f.steps.map(\.id) == ["read"]) } else { Issue.record("each lost") }177        #expect(threw(.unknownStep("ghost")) { try WorkflowEdit.removeStep("ghost", from: doc) })178    }179180    @Test func renameRewritesStructuralReferencesAndExpressions() throws {181        var doc = sampleDocument()182        doc.spec.layout["list"] = .init(x: 7, y: 8)183        doc.spec.steps.append(WorkflowStep(id: "v", needs: ["list"], when: "steps.list.status == 'succeeded' && steps[\"list\"] != null",184                                           kind: .verify(VerifyStep(assertions: [.stepSucceeded("list"), .truthy("steps.list.output"), .equals("${{ steps.list.output.n }} of list", "list")]))))185        let out = try WorkflowEdit.renameStep("list", to: "listing-1", in: doc)186        #expect(out.step(id: "list") == nil && out.step(id: "listing-1")?.name == "List files")187        #expect(out.step(id: "check")?.needs == ["listing-1"])188        #expect(out.step(id: "check")?.kind == .condition(ConditionStep(condition: "${{ len(steps.listing-1.output.entries) > 0 }}", then: ["each"], otherwise: ["nothing"])))189        if case .foreach(let f)? = out.step(id: "each")?.kind { #expect(f.items == "${{ steps.listing-1.output.entries }}") } else { Issue.record("each lost") }190        let v = out.step(id: "v")191        // Dotted and bracket references are rewritten; plain text is left alone.192        #expect(v?.when == "steps.listing-1.status == 'succeeded' && steps[\"listing-1\"] != null" && v?.needs == ["listing-1"])193        #expect(v?.kind == .verify(VerifyStep(assertions: [.stepSucceeded("listing-1"), .truthy("steps.listing-1.output"), .equals("${{ steps.listing-1.output.n }} of list", "list")])))194        #expect(out.spec.layout == ["listing-1": .init(x: 7, y: 8)])195        let handler = try WorkflowEdit.renameStep("cleanup", to: "recover", in: doc)196        #expect(handler.step(id: "list")?.onError == "recover")197        let collected = try WorkflowEdit.renameStep("shape", to: "shaped", in: doc)198        if case .foreach(let f)? = collected.step(id: "each")?.kind { #expect(f.collect == "shaped") } else { Issue.record("each lost") }199        #expect(try WorkflowEdit.renameStep("list", to: "list", in: doc) == doc)200        #expect(threw(.unknownStep("ghost")) { try WorkflowEdit.renameStep("ghost", to: "x", in: doc) })201        #expect(threw(.duplicateID("read")) { try WorkflowEdit.renameStep("list", to: "read", in: doc) })202        #expect(threw(.invalidID("no good")) { try WorkflowEdit.renameStep("list", to: "no good", in: doc) })203        #expect(try WorkflowCodec.parse(WorkflowCodec.emit(out)) == out)204    }205206    @Test func connectAndDisconnect() throws {207        let doc = document([tool("a"), tool("b", needs: ["a"]), tool("c"), WorkflowStep(id: "p", kind: .parallel(ParallelStep(branches: [ParallelBranch(name: "x", steps: [tool("in1"), tool("in2")])])))])208        let out = try WorkflowEdit.connect(from: "b", to: "c", in: doc)209        #expect(out.step(id: "c")?.needs == ["b"])210        #expect(try WorkflowEdit.connect(from: "b", to: "c", in: out) == out)211        #expect(try WorkflowEdit.connect(from: "in1", to: "in2", in: doc).step(id: "in2")?.needs == ["in1"])212        if case .wouldCreateCycle? = throwsEdit({ try WorkflowEdit.connect(from: "c", to: "a", in: out) }) {} else { Issue.record("cycle a→b→c→a must be refused") }213        if case .wouldCreateCycle? = throwsEdit({ try WorkflowEdit.connect(from: "a", to: "a", in: doc) }) {} else { Issue.record("self need must be refused") }214        #expect(threw(.differentScopes("a", "in1")) { try WorkflowEdit.connect(from: "a", to: "in1", in: doc) })215        #expect(threw(.unknownStep("ghost")) { try WorkflowEdit.connect(from: "ghost", to: "a", in: doc) })216        #expect(threw(.unknownStep("ghost")) { try WorkflowEdit.connect(from: "a", to: "ghost", in: doc) })217        #expect(try WorkflowEdit.disconnect(from: "b", to: "c", in: out) == doc)218        #expect(try WorkflowEdit.disconnect(from: "c", to: "a", in: doc) == doc)219        #expect(threw(.unknownStep("ghost")) { try WorkflowEdit.disconnect(from: "ghost", to: "a", in: doc) })220    }221222    @Test func moveNode() throws {223        let doc = sampleDocument()224        #expect(try WorkflowEdit.moveNode("read", x: 10.5, y: -3, in: doc).spec.layout == ["read": .init(x: 10.5, y: -3)])225        #expect(threw(.unknownStep("ghost")) { try WorkflowEdit.moveNode("ghost", x: 0, y: 0, in: doc) })226        #expect(threw(.unknownStep("trigger:7")) { try WorkflowEdit.moveNode("trigger:7", x: 0, y: 0, in: doc) })227        if case .invalid? = throwsEdit({ try WorkflowEdit.moveNode("read", x: .nan, y: 0, in: doc) }) {} else { Issue.record("NaN position must be refused") }228    }229230    @Test func setFieldAndUpdateStep() throws {231        var doc = sampleDocument()232        doc = try WorkflowEdit.setField("list", .name("Listing"), in: doc)233        doc = try WorkflowEdit.setField("list", .when("params.enabled"), in: doc)234        doc = try WorkflowEdit.setField("list", .timeoutSeconds(12), in: doc)235        doc = try WorkflowEdit.setField("list", .continueOnError(true), in: doc)236        doc = try WorkflowEdit.setField("list", .retry(WorkflowRetryPolicy(maxAttempts: 3)), in: doc)237        doc = try WorkflowEdit.setField("list", .toolArgument("path", "~/x"), in: doc)238        doc = try WorkflowEdit.setField("list", .toolArgument("recursive", true), in: doc)239        doc = try WorkflowEdit.setField("list", .toolArgument("recursive", nil), in: doc)240        doc = try WorkflowEdit.setField("list", .onError(nil), in: doc)241        let s = doc.step(id: "list")!242        #expect(s.name == "Listing" && s.when == "params.enabled" && s.timeoutSeconds == 12 && s.continueOnError && s.retry?.maxAttempts == 3 && s.onError == nil)243        #expect(s.kind == .tool(ToolStep(tool: "filesystem.list", arguments: ["path": "~/x"])))244        doc = try WorkflowEdit.setField("list", .onError("cleanup"), in: doc)245        #expect(doc.step(id: "list")?.onError == "cleanup")246        #expect(threw(.unknownStep("ghost")) { try WorkflowEdit.setField("list", .onError("ghost"), in: doc) })247        #expect(threw(.differentScopes("list", "read")) { try WorkflowEdit.setField("list", .onError("read"), in: doc) })248        #expect(threw(.unknownStep("ghost")) { try WorkflowEdit.setField("ghost", .name("x"), in: doc) })249        if case .invalid? = throwsEdit({ try WorkflowEdit.setField("check", .toolArgument("a", 1), in: doc) }) {} else { Issue.record("toolArgument on a condition must be refused") }250        if case .invalid? = throwsEdit({ try WorkflowEdit.setField("list", .onError("list"), in: doc) }) {} else { Issue.record("self handler must be refused") }251        // Replacing a container's kind drops its nested steps and their layout.252        doc.spec.layout["read"] = .init(x: 1, y: 1)253        let flat = try WorkflowEdit.setField("each", .kind(.delay(DelayStep(seconds: 1))), in: doc)254        #expect(flat.step(id: "read") == nil && flat.spec.layout["read"] == nil && flat.step(id: "each")?.kind.name == "delay")255        let updated = try WorkflowEdit.updateStep("out", in: doc) { $0.needs = ["list"]; $0.name = "Result" }256        #expect(updated.step(id: "out")?.needs == ["list"] && updated.step(id: "out")?.name == "Result")257        if case .invalid? = throwsEdit({ try WorkflowEdit.updateStep("out", in: doc) { $0.id = "renamed" } }) {} else { Issue.record("updateStep must not rename") }258        if case .wouldCreateCycle? = throwsEdit({ try WorkflowEdit.updateStep("list", in: doc) { $0.needs = ["check"] } }) {} else { Issue.record("cycle must be refused") }259    }260261    @Test func duplicateStepGivesFreshIdsAndRemapsNestedReferences() throws {262        var doc = sampleDocument()263        doc.spec.layout = ["each": .init(x: 100, y: 200), "read": .init(x: 5, y: 6)]264        let out = try WorkflowEdit.duplicateStep("each", in: doc)265        #expect(out.spec.steps.map(\.id) == ["list", "check", "each", "each-copy", "nothing", "route", "par", "loop", "cleanup", "think", "out"])266        guard case .foreach(let f)? = out.step(id: "each-copy")?.kind else { Issue.record("copy is not a foreach"); return }267        #expect(f.steps.map(\.id) == ["read-copy", "shape-copy"] && f.collect == "shape-copy" && f.steps[1].needs == ["read-copy"])268        #expect(f.steps[1].kind == .transform(TransformStep(expression: "upper(steps.read-copy.output.text)")))269        #expect(f.items == "${{ steps.list.output.entries }}")270        #expect(out.spec.layout["each-copy"] == .init(x: 140, y: 240) && out.spec.layout["read-copy"] == .init(x: 5, y: 6))271        #expect(out.step(id: "each") == doc.step(id: "each"))272        let twice = try WorkflowEdit.duplicateStep("each", in: out)273        #expect(twice.step(id: "each-copy2") != nil && twice.step(id: "read-copy2") != nil)274        let named = try WorkflowEdit.duplicateStep("check", in: doc, newID: "check2")275        #expect(named.step(id: "check2")?.needs == ["list"] && named.location(of: "check2")?.index == 2)276        #expect(threw(.duplicateID("list")) { try WorkflowEdit.duplicateStep("check", in: doc, newID: "list") })277        #expect(threw(.invalidID("-x")) { try WorkflowEdit.duplicateStep("check", in: doc, newID: "-x") })278        #expect(threw(.unknownStep("ghost")) { try WorkflowEdit.duplicateStep("ghost", in: doc) })279    }280281    @Test func groupIntoParallelBuildsBranchesFromConnectedComponentsAndRewires() throws {282        var doc = document([tool("a"), tool("b", needs: ["a"]), tool("c", needs: ["b"]), tool("d", needs: ["a"]), tool("e", needs: ["c", "d"]), tool("f")])283        doc.spec.layout = ["b": .init(x: 10, y: 20), "c": .init(x: 30, y: 40)]284        let out = try WorkflowEdit.groupIntoParallel(["b", "c", "d"], containerID: "fan", in: doc)285        #expect(out.spec.steps.map(\.id) == ["a", "fan", "e", "f"])286        let fan = out.step(id: "fan")!287        #expect(fan.needs == ["a"])288        guard case .parallel(let p) = fan.kind else { Issue.record("not parallel"); return }289        #expect(p.branches.map(\.name) == ["b", "d"] && p.branches[0].steps.map(\.id) == ["b", "c"] && p.branches[1].steps.map(\.id) == ["d"])290        #expect(p.branches[0].steps[0].needs == [] && p.branches[0].steps[1].needs == ["b"] && p.branches[1].steps[0].needs == [])291        #expect(out.step(id: "e")?.needs == ["fan"])292        #expect(out.spec.layout == ["fan": .init(x: 10, y: 20)])293        #expect(WorkflowValidator.structuralErrors(out).isEmpty)294        #expect(threw(.unknownStep("ghost")) { try WorkflowEdit.groupIntoParallel(["b", "ghost"], containerID: "g", in: doc) })295        #expect(threw(.duplicateID("a")) { try WorkflowEdit.groupIntoParallel(["b"], containerID: "a", in: doc) })296        #expect(threw(.differentScopes("a", "b")) { try WorkflowEdit.groupIntoParallel(["a", "b"], containerID: "g", in: out) })297        if case .invalid? = throwsEdit({ try WorkflowEdit.groupIntoParallel([], containerID: "g", in: doc) }) {} else { Issue.record("empty selection must be refused") }298        if case .invalid? = throwsEdit({ try WorkflowEdit.groupIntoParallel(["b", "b"], containerID: "g", in: doc) }) {} else { Issue.record("repeated selection must be refused") }299        // a → c (outside) → … : grouping b and its indirect dependent e around the outside step c would loop through the container.300        if case .wouldCreateCycle? = throwsEdit({ try WorkflowEdit.groupIntoParallel(["b", "e"], containerID: "g", in: doc) }) {} else { Issue.record("cycle through the container must be refused") }301        // Branch and error routes cannot cross the container boundary.302        if case .invalid? = throwsEdit({ try WorkflowEdit.groupIntoParallel(["each"], containerID: "g", in: sampleDocument()) }) {} else { Issue.record("gated member must be refused") }303        if case .invalid? = throwsEdit({ try WorkflowEdit.groupIntoParallel(["list"], containerID: "g", in: sampleDocument()) }) {} else { Issue.record("member with outside handler must be refused") }304        let together = try WorkflowEdit.groupIntoParallel(["check", "each", "nothing"], containerID: "g", in: sampleDocument())305        if case .parallel(let q)? = together.step(id: "g")?.kind { #expect(q.branches.count == 1 && q.branches[0].steps.count == 3) } else { Issue.record("not parallel") }306        #expect(together.step(id: "g")?.needs == ["list"] && together.step(id: "route")?.needs == ["g"])307    }308309    @Test func wrapInForeachKeepsInternalNeeds() throws {310        let doc = document([tool("a"), tool("b", needs: ["a"]), tool("c", needs: ["b"]), tool("d", needs: ["c", "a"])])311        let out = try WorkflowEdit.wrapInForeach(["b", "c"], containerID: "each", items: "${{ steps.a.output.entries }}", itemName: "entry", in: doc)312        #expect(out.spec.steps.map(\.id) == ["a", "each", "d"] && out.step(id: "d")?.needs == ["each", "a"])313        guard case .foreach(let f)? = out.step(id: "each")?.kind else { Issue.record("not foreach"); return }314        #expect(f.items == "${{ steps.a.output.entries }}" && f.itemName == "entry" && f.concurrency == 1 && f.collect == nil)315        #expect(f.steps.map(\.id) == ["b", "c"] && f.steps[0].needs == [] && f.steps[1].needs == ["b"])316        #expect(out.step(id: "each")?.needs == ["a"])317        if case .invalid? = throwsEdit({ try WorkflowEdit.wrapInForeach(["b"], containerID: "x", items: "[]", itemName: "steps", in: doc) }) {} else { Issue.record("reserved loop variable must be refused") }318        #expect(threw(.invalidID("bad id")) { try WorkflowEdit.wrapInForeach(["b"], containerID: "bad id", items: "[]", in: doc) })319    }320321    @Test func reorderWithinItsList() throws {322        let doc = sampleDocument()323        #expect(try WorkflowEdit.reorder("out", to: 0, in: doc).spec.steps.first?.id == "out")324        #expect(try WorkflowEdit.reorder("list", to: 99, in: doc).spec.steps.last?.id == "list")325        #expect(try WorkflowEdit.reorder("l2", to: 0, in: doc).location(of: "l2")?.index == 0)326        #expect(try WorkflowEdit.reorder("list", to: 0, in: doc) == doc)327        #expect(threw(.unknownStep("ghost")) { try WorkflowEdit.reorder("ghost", to: 0, in: doc) })328    }329330    @Test func editsOfAStructurallyInvalidDocumentAreRefused() {331        let broken = document([tool("a", needs: ["ghost"])])332        if case .invalid? = throwsEdit({ try WorkflowEdit.addStep(tool("b"), to: broken) }) {} else { Issue.record("an invalid document cannot be edited into a valid one silently") }333    }334}335336// MARK: - Property test337338/// Generates structurally valid documents: unique valid ids, `needs` only to earlier steps of the same list.339private struct ValidDocumentGenerator {340    var rng: SeededRNG341    var counter = 0342    init(seed: UInt64) { rng = SeededRNG(seed: seed) }343344    mutating func int(_ r: ClosedRange<Int>) -> Int { Int.random(in: r, using: &rng) }345    mutating func bool(_ p: Double = 0.5) -> Bool { Double.random(in: 0..<1, using: &rng) < p }346    mutating func pick<T>(_ a: [T]) -> T { a[int(0...(a.count - 1))] }347    mutating func id() -> String { counter += 1; return pick(["s", "step-", "fetch_", "n"]) + "\(counter)" }348349    mutating func leaf(_ id: String, earlier: [String]) -> WorkflowStepKind {350        let ref = earlier.isEmpty ? "params.x" : "steps.\(pick(earlier)).output"351        switch int(0...6) {352        case 0: return .tool(ToolStep(tool: pick(["filesystem.list", "shell.run"]), arguments: ["path": .string("${{ \(ref) }}/x"), "n": .int(int(0...9))]))353        case 1: return .set(SetStep(values: ["v": .string("${{ \(ref) }}")]))354        case 2: return .transform(TransformStep(expression: "len(\(ref)) > 0"))355        case 3: return .delay(DelayStep(seconds: .int(int(0...3))))356        case 4: return .verify(VerifyStep(assertions: earlier.isEmpty ? [.truthy(true)] : [.stepSucceeded(pick(earlier)), .truthy(.string(ref))]))357        case 5: return .notify(NotifyStep(message: "value ${{ \(ref) }}"))358        default: return .agent(AgentStep(agent: .profile("analyst"), objective: "Use ${{ \(ref) }}"))359        }360    }361362    mutating func steps(depth: Int, count: Int) -> [WorkflowStep] {363        var out: [WorkflowStep] = []364        for _ in 0..<count {365            let sid = id()366            let earlier = out.map(\.id)367            let needs = earlier.filter { _ in bool(0.3) }368            let kind: WorkflowStepKind369            if depth < 2, bool(0.25) {370                switch int(0...2) {371                case 0: kind = .foreach(ForeachStep(items: "params.items", itemName: "entry", concurrency: int(1...3), steps: steps(depth: depth + 1, count: int(0...3))))372                case 1: kind = .parallel(ParallelStep(branches: (0..<int(1...3)).map { ParallelBranch(name: "b\($0)", steps: steps(depth: depth + 1, count: int(0...2))) }))373                default: kind = .loop(LoopStep(condition: "vars.n < 3", maxIterations: int(1...9), steps: steps(depth: depth + 1, count: int(1...2))))374                }375            } else { kind = leaf(sid, earlier: earlier) }376            out.append(WorkflowStep(id: sid, name: bool(0.3) ? "Step \(sid)" : nil, needs: needs, when: bool(0.2) ? "params.enabled" : nil, kind: kind))377        }378        // A condition gating two later-defined free steps, and an error handler.379        if out.count >= 2, bool(0.5) {380            let a = WorkflowStep(id: id(), kind: .delay(DelayStep(seconds: 1))), b = WorkflowStep(id: id(), kind: .fail(FailStep(message: "no")))381            out.append(WorkflowStep(id: id(), needs: [out[0].id], kind: .condition(ConditionStep(condition: "params.enabled", then: [a.id], otherwise: [b.id]))))382            out += [a, b]383        }384        if !out.isEmpty, bool(0.4) {385            let h = WorkflowStep(id: id(), kind: .notify(NotifyStep(message: "failed")))386            out[int(0...(out.count - 1))].onError = h.id387            out.append(h)388        }389        return out390    }391392    mutating func document() -> WorkflowDocument {393        var spec = WorkflowSpec(triggers: bool() ? [.manual] : [.manual, .login],394                                parameters: [WorkflowParameter(name: "x"), WorkflowParameter(name: "items", type: .array), WorkflowParameter(name: "enabled", type: .boolean)],395                                variables: ["n": 0], steps: steps(depth: 0, count: int(2...7)))396        if bool(0.3) { spec.onError = [WorkflowStep(id: id(), kind: .notify(NotifyStep(message: "workflow failed")))] }397        return WorkflowDocument(metadata: WorkflowMetadata(id: "prop", name: "Property"), spec: spec)398    }399400    /// One random edit; throws `WorkflowEditError` when the edit is refused.401    mutating func edit(_ doc: WorkflowDocument) throws -> WorkflowDocument {402        let all = doc.allSteps403        guard !all.isEmpty else { return try WorkflowEdit.addStep(WorkflowStep(id: id(), kind: .delay(DelayStep(seconds: 1))), to: doc) }404        let a = pick(all), b = pick(all)405        let peers = all.filter { $0.scopeID == a.scopeID }.map(\.step.id)406        switch int(0...13) {407        case 0: return try WorkflowEdit.addStep(WorkflowStep(id: id(), needs: bool() ? [] : [pick(doc.spec.steps.map(\.id) + ["ghost"])], kind: leaf("x", earlier: [])), to: doc, at: bool() ? int(0...3) : nil)408        case 1:409            let containers = all.filter(\.step.isContainer)410            guard !containers.isEmpty else { return doc }411            return try WorkflowEdit.addStep(WorkflowStep(id: id(), kind: leaf("x", earlier: [])), to: doc, inContainer: pick(containers).step.id, branch: pick(["b0", "b1", "fresh"]))412        case 2: return try WorkflowEdit.removeStep(a.step.id, from: doc)413        case 3: return try WorkflowEdit.renameStep(a.step.id, to: bool(0.9) ? id() : b.step.id, in: doc)414        case 4: return try WorkflowEdit.connect(from: a.step.id, to: bool(0.8) ? pick(peers) : b.step.id, in: doc)415        case 5: return try WorkflowEdit.disconnect(from: a.step.needs.first ?? b.step.id, to: a.step.id, in: doc)416        case 6: return try WorkflowEdit.moveNode(bool(0.9) ? a.step.id : "trigger:\(int(0...2))", x: Double(int(-500...500)), y: Double(int(-500...500)) / 4, in: doc)417        case 7:418            let field: StepField = pick([.name(bool() ? "Renamed" : nil), .when(bool() ? "vars.n == 0" : nil), .timeoutSeconds(bool() ? 2.5 : nil), .continueOnError(bool()),419                                         .onError(bool() ? pick(peers) : nil), .retry(bool() ? WorkflowRetryPolicy(maxAttempts: 2, backoffSeconds: 0.5) : nil),420                                         .toolArgument("path", bool() ? "~/p" : nil), .kind(.delay(DelayStep(seconds: 2)))])421            return try WorkflowEdit.setField(a.step.id, field, in: doc)422        case 8: return try WorkflowEdit.duplicateStep(a.step.id, in: doc)423        case 9: return try WorkflowEdit.groupIntoParallel(Array(Set([a.step.id, pick(peers), pick(peers)])).sorted(), containerID: id(), in: doc)424        case 10: return try WorkflowEdit.wrapInForeach(Array(Set([a.step.id, pick(peers)])).sorted(), containerID: id(), items: "params.items", in: doc)425        case 11: return try WorkflowEdit.reorder(a.step.id, to: int(0...8), in: doc)426        case 12: return try WorkflowEdit.updateStep(a.step.id, in: doc) { $0.needs = Array(peers.prefix(2)) }427        default: return try WorkflowEdit.groupIntoParallel([a.step.id, b.step.id], containerID: id(), in: doc)428        }429    }430}431432@Suite("Graph edits (property)") struct GraphEditPropertyTests {433    @Test func randomEditSequencesStayValidAndRoundTripThroughTheCodeView() throws {434        var generator = ValidDocumentGenerator(seed: 20261121)435        var applied = 0, refused = 0436        var kinds: Set<String> = []437        for round in 0..<60 {438            var doc = generator.document()439            #expect(WorkflowValidator.structuralErrors(doc).isEmpty, "generator produced an invalid document in round \(round)")440            for stepIndex in 0..<40 {441                let before = doc442                do { doc = try generator.edit(doc) }443                catch is WorkflowEditError { refused += 1; #expect(doc == before); continue }444                applied += 1445                let errors = WorkflowValidator.structuralErrors(doc)446                if !errors.isEmpty { Issue.record("round \(round) edit \(stepIndex): structurally invalid result: \(errors[0])\n\(WorkflowCodec.emit(doc))"); return }447                for format in WorkflowFormat.allCases {448                    let text = WorkflowCodec.emit(doc, format: format)449                    guard let back = try? WorkflowCodec.parse(text, format: format), back == doc else {450                        Issue.record("round \(round) edit \(stepIndex): \(format) round trip lost information\n\(text)"); return451                    }452                }453                for change in WorkflowDiff.diff(before, doc) { kinds.insert(String(describing: change).prefix { $0 != "(" }.description) }454                #expect(WorkflowDiff.diff(before, doc).isEmpty == (before == doc))455                _ = WorkflowGraph(document: doc)456            }457        }458        #expect(applied > 600, "only \(applied) edits were applied (\(refused) refused)")459        #expect(refused > 50, "the property test should also exercise refused edits (\(refused))")460        #expect(kinds.isSuperset(of: ["stepAdded", "stepRemoved", "stepModified", "stepMoved", "layoutChanged"]), "diff kinds seen: \(kinds.sorted())")461    }462}463464// MARK: - Diff465466@Suite("Workflow diff (unit)") struct WorkflowDiffTests {467    @Test func equalDocumentsHaveNoChange() {468        #expect(WorkflowDiff.diff(sampleDocument(), sampleDocument()).isEmpty)469    }470471    @Test func everyDocumentLevelChangeKind() {472        let old = sampleDocument()473        var new = old474        new.metadata.name = "Renamed"; new.metadata.tags = ["x"]475        new.spec.triggers.removeLast()476        new.spec.parameters = [WorkflowParameter(name: "mode"), WorkflowParameter(name: "added")]477        new.spec.permissions.filesystem.write = ["~/Reports"]478        new.spec.permissions.notifications = true479        new.spec.budget.maxToolCalls = 5480        new.spec.variables = ["n": 1]481        new.spec.onError = []482        new.spec.layout["list"] = .init(x: 1, y: 1)483        var older = old484        older.spec.parameters = [WorkflowParameter(name: "mode", type: .integer), WorkflowParameter(name: "gone")]485        older.spec.permissions.network = ["example.com"]486        let changes = WorkflowDiff.diff(older, new)487        #expect(changes == [488            .metadataChanged(fields: ["name", "tags"]), .triggersChanged,489            .parametersChanged(added: ["added"], removed: ["gone"], modified: ["mode"]),490            .permissionsChanged(added: ["filesystem.write: ~/Reports", "notifications"], removed: ["network: example.com"]),491            .budgetChanged, .variablesChanged, .onErrorChanged, .layoutChanged,492        ])493        #expect(changes.filter(\.isSecurityRelevant) == [.permissionsChanged(added: ["filesystem.write: ~/Reports", "notifications"], removed: ["network: example.com"])])494        #expect(changes[3].summary == "Permissions changed (security-relevant): added filesystem.write: ~/Reports, notifications; removed network: example.com")495        #expect(changes.allSatisfy { !$0.summary.isEmpty })496        #expect(WorkflowDiff.permissionEntries(WorkflowPermissions(processes: ["git"], scripts: ["bash"], apps: .init(control: ["com.apple.Safari"]), browser: ["a.com"],497                                                                 secrets: ["k"], clipboard: .init(read: true, write: true), screen: ["display"]))498                == ["processes: git", "scripts: bash", "apps.control: com.apple.Safari", "browser: a.com", "secrets: k", "clipboard.read", "clipboard.write", "screen: display"])499    }500501    @Test func stepChangesAreReportedByFieldWithoutBlamingContainers() throws {502        let old = sampleDocument()503        var new = try WorkflowEdit.setField("read", .toolArgument("path", "~/x"), in: old)504        new = try WorkflowEdit.updateStep("read", in: new) { s in505            s.name = "Read"; s.when = "true"; s.retry = WorkflowRetryPolicy(maxAttempts: 2); s.timeoutSeconds = 3; s.continueOnError = true506            if case .tool(var t) = s.kind { t.tool = "documents.pdfText"; s.kind = .tool(t) }507        }508        #expect(WorkflowDiff.diff(old, new) == [.stepModified(id: "read", fields: ["name", "when", "tool", "with", "retry", "timeoutSeconds", "continueOnError"])])509        let kind = try WorkflowEdit.setField("nothing", .kind(.fail(FailStep(message: "x"))), in: old)510        #expect(WorkflowDiff.diff(old, kind) == [.stepModified(id: "nothing", fields: ["kind"])])511        let each = try WorkflowEdit.updateStep("each", in: old) { s in512            if case .foreach(var f) = s.kind { f.concurrency = 4; f.itemName = "e"; s.kind = .foreach(f) }513        }514        #expect(WorkflowDiff.diff(old, each) == [.stepModified(id: "each", fields: ["as", "concurrency"])])515        let cond = try WorkflowEdit.updateStep("check", in: old) { s in s.kind = .condition(ConditionStep(condition: "false", then: [], otherwise: ["nothing", "each"])) }516        #expect(WorkflowDiff.diff(old, cond) == [.stepModified(id: "check", fields: ["if", "then", "else"])])517    }518519    @Test func diffAfterEachEditOperation() throws {520        let old = sampleDocument()521        #expect(WorkflowDiff.diff(old, try WorkflowEdit.addStep(tool("new"), to: old)) == [.stepAdded(id: "new")])522        #expect(WorkflowDiff.diff(old, try WorkflowEdit.removeStep("each", from: old))523                == [.stepRemoved(id: "each"), .stepRemoved(id: "read"), .stepRemoved(id: "shape"), .stepModified(id: "check", fields: ["then"]), .stepModified(id: "route", fields: ["needs"])])524        #expect(WorkflowDiff.diff(old, try WorkflowEdit.renameStep("think", to: "reason", in: old))525                == [.stepRemoved(id: "think"), .stepAdded(id: "reason"), .stepModified(id: "out", fields: ["needs"])])526        #expect(WorkflowDiff.diff(old, try WorkflowEdit.connect(from: "list", to: "out", in: old)) == [.stepModified(id: "out", fields: ["needs"])])527        #expect(WorkflowDiff.diff(old, try WorkflowEdit.disconnect(from: "think", to: "out", in: old)) == [.stepModified(id: "out", fields: ["needs"])])528        #expect(WorkflowDiff.diff(old, try WorkflowEdit.moveNode("list", x: 1, y: 2, in: old)) == [.layoutChanged])529        #expect(WorkflowDiff.diff(old, try WorkflowEdit.setField("list", .name("L"), in: old)) == [.stepModified(id: "list", fields: ["name"])])530        #expect(WorkflowDiff.diff(old, try WorkflowEdit.duplicateStep("par", in: old))531                == [.stepAdded(id: "par-copy"), .stepAdded(id: "l1-copy"), .stepAdded(id: "l2-copy"), .stepAdded(id: "r1-copy")])532        #expect(WorkflowDiff.diff(old, try WorkflowEdit.reorder("out", to: 0, in: old)) == [.stepMoved(id: "out")])533        #expect(WorkflowDiff.diff(old, try WorkflowEdit.groupIntoParallel(["think", "out"], containerID: "tail", in: old))534                == [.stepAdded(id: "tail"), .stepModified(id: "think", fields: ["needs"]), .stepMoved(id: "think"), .stepMoved(id: "out")])535        #expect(WorkflowDiff.diff(old, try WorkflowEdit.wrapInForeach(["out"], containerID: "wrap", items: "[1]", in: old))536                == [.stepAdded(id: "wrap"), .stepModified(id: "out", fields: ["needs"]), .stepMoved(id: "out")])537        let nested = WorkflowDiff.diff(old, try WorkflowEdit.reorder("l2", to: 0, in: old))538        #expect(nested == [.stepMoved(id: "l2")] || nested == [.stepMoved(id: "l1")])539    }540}541
Files main
Menu

Theme