911 lines
26 KiB
TypeScript
911 lines
26 KiB
TypeScript
import { describe, it, expect } from "vitest";
|
|
import { DirectedGraph } from "graphology";
|
|
import { WorkflowReactiveRoot } from "../../src/reactive/workflow.js";
|
|
import type {
|
|
CallEventMapValue,
|
|
FailurePolicy,
|
|
} from "../../src/reactive/workflow.js";
|
|
|
|
function makeSimpleGraph(): DirectedGraph {
|
|
const graph = new DirectedGraph();
|
|
graph.addNode("a", { name: "a" });
|
|
graph.addNode("b", { name: "b" });
|
|
graph.addNode("c", { name: "c" });
|
|
graph.addEdgeWithKey("a->b", "a", "b", { edgeType: "sequential" });
|
|
graph.addEdgeWithKey("b->c", "b", "c", { edgeType: "sequential" });
|
|
return graph;
|
|
}
|
|
|
|
function makeDiamondGraph(): DirectedGraph {
|
|
const graph = new DirectedGraph();
|
|
graph.addNode("top", { name: "top" });
|
|
graph.addNode("left", { name: "left" });
|
|
graph.addNode("right", { name: "right" });
|
|
graph.addNode("bottom", { name: "bottom" });
|
|
graph.addEdgeWithKey("top->left", "top", "left", { edgeType: "sequential" });
|
|
graph.addEdgeWithKey("top->right", "top", "right", { edgeType: "sequential" });
|
|
graph.addEdgeWithKey("left->bottom", "left", "bottom", {
|
|
edgeType: "sequential",
|
|
});
|
|
graph.addEdgeWithKey("right->bottom", "right", "bottom", {
|
|
edgeType: "sequential",
|
|
});
|
|
return graph;
|
|
}
|
|
|
|
function makeForkJoinGraph(): DirectedGraph {
|
|
const graph = new DirectedGraph();
|
|
graph.addNode("source", { name: "source" });
|
|
graph.addNode("fail-node", { name: "fail-node" });
|
|
graph.addNode("run-node", { name: "run-node" });
|
|
graph.addNode("sink", { name: "sink" });
|
|
graph.addEdgeWithKey("source->fail-node", "source", "fail-node", { edgeType: "sequential" });
|
|
graph.addEdgeWithKey("source->run-node", "source", "run-node", { edgeType: "sequential" });
|
|
graph.addEdgeWithKey("fail-node->sink", "fail-node", "sink", { edgeType: "sequential" });
|
|
graph.addEdgeWithKey("run-node->sink", "run-node", "sink", { edgeType: "sequential" });
|
|
return graph;
|
|
}
|
|
|
|
describe("WorkflowReactiveRoot", () => {
|
|
describe("constructor and initializeSignals", () => {
|
|
it("initializes all nodes with idle status", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
expect(root.statusMap.get("a")!.value).toBe("idle");
|
|
expect(root.statusMap.get("b")!.value).toBe("idle");
|
|
expect(root.statusMap.get("c")!.value).toBe("idle");
|
|
|
|
root.dispose();
|
|
});
|
|
|
|
it("creates precondition computeds for all nodes", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
expect(root.preconditions.has("a")).toBe(true);
|
|
expect(root.preconditions.has("b")).toBe(true);
|
|
expect(root.preconditions.has("c")).toBe(true);
|
|
|
|
root.dispose();
|
|
});
|
|
|
|
it("root node has met preconditions (no predecessors)", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
expect(root.preconditions.get("a")!.value).toBe(true);
|
|
|
|
root.dispose();
|
|
});
|
|
|
|
it("downstream nodes have unmet preconditions initially", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
expect(root.preconditions.get("b")!.value).toBe(false);
|
|
expect(root.preconditions.get("c")!.value).toBe(false);
|
|
|
|
root.dispose();
|
|
});
|
|
|
|
it("creates blockedByFailure computeds for all nodes", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
expect(root.blockedByFailure.has("a")).toBe(true);
|
|
expect(root.blockedByFailure.has("b")).toBe(true);
|
|
expect(root.blockedByFailure.has("c")).toBe(true);
|
|
|
|
root.dispose();
|
|
});
|
|
|
|
it("no nodes are blocked by failure initially", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
expect(root.blockedByFailure.get("a")!.value).toBe(false);
|
|
expect(root.blockedByFailure.get("b")!.value).toBe(false);
|
|
expect(root.blockedByFailure.get("c")!.value).toBe(false);
|
|
|
|
root.dispose();
|
|
});
|
|
|
|
it("creates resultMap entries for all nodes", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
expect(root.resultMap.has("a")).toBe(true);
|
|
expect(root.resultMap.has("b")).toBe(true);
|
|
expect(root.resultMap.has("c")).toBe(true);
|
|
|
|
root.dispose();
|
|
});
|
|
|
|
it("defaults failurePolicy to continue-running", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
const policy = (root as unknown as { _failurePolicy: string })._failurePolicy;
|
|
|
|
expect(policy).toBe("continue-running");
|
|
|
|
root.dispose();
|
|
});
|
|
|
|
it("accepts custom failurePolicy", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph, {
|
|
failurePolicy: "abort-dependents",
|
|
});
|
|
const policy = (root as unknown as { _failurePolicy: string })._failurePolicy;
|
|
|
|
expect(policy).toBe("abort-dependents");
|
|
|
|
root.dispose();
|
|
});
|
|
|
|
it("initializes nodeKeyToRequestId as empty map", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
expect(root.nodeKeyToRequestId.size).toBe(0);
|
|
|
|
root.dispose();
|
|
});
|
|
});
|
|
|
|
describe("append and status updates", () => {
|
|
it("updates status to running on call.requested", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
root.nodeKeyToRequestId.set("a", "req-1");
|
|
root.append({
|
|
type: "call.requested",
|
|
requestId: "req-1",
|
|
operationId: "a",
|
|
input: null,
|
|
timestamp: "2026-01-01T00:00:00Z",
|
|
});
|
|
|
|
expect(root.statusMap.get("a")!.value).toBe("running");
|
|
|
|
root.dispose();
|
|
});
|
|
|
|
it("updates status to completed on call.responded", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
root.nodeKeyToRequestId.set("a", "req-1");
|
|
root.append({
|
|
type: "call.requested",
|
|
requestId: "req-1",
|
|
operationId: "a",
|
|
input: null,
|
|
timestamp: "2026-01-01T00:00:00Z",
|
|
});
|
|
root.append({
|
|
type: "call.responded",
|
|
requestId: "req-1",
|
|
output: { result: 42 },
|
|
timestamp: "2026-01-01T00:00:01Z",
|
|
});
|
|
|
|
expect(root.statusMap.get("a")!.value).toBe("completed");
|
|
|
|
root.dispose();
|
|
});
|
|
|
|
it("updates status to failed on call.error", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
root.nodeKeyToRequestId.set("a", "req-1");
|
|
root.append({
|
|
type: "call.requested",
|
|
requestId: "req-1",
|
|
operationId: "a",
|
|
input: null,
|
|
timestamp: "2026-01-01T00:00:00Z",
|
|
});
|
|
root.append({
|
|
type: "call.error",
|
|
requestId: "req-1",
|
|
error: { code: "ERR", message: "something failed" },
|
|
timestamp: "2026-01-01T00:00:01Z",
|
|
});
|
|
|
|
expect(root.statusMap.get("a")!.value).toBe("failed");
|
|
|
|
root.dispose();
|
|
});
|
|
|
|
it("updates status to aborted on call.aborted", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
root.nodeKeyToRequestId.set("a", "req-1");
|
|
root.append({
|
|
type: "call.requested",
|
|
requestId: "req-1",
|
|
operationId: "a",
|
|
input: null,
|
|
timestamp: "2026-01-01T00:00:00Z",
|
|
});
|
|
root.append({
|
|
type: "call.aborted",
|
|
requestId: "req-1",
|
|
timestamp: "2026-01-01T00:00:01Z",
|
|
});
|
|
|
|
expect(root.statusMap.get("a")!.value).toBe("aborted");
|
|
|
|
root.dispose();
|
|
});
|
|
|
|
it("ignores events for unknown requestIds", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
root.append({
|
|
type: "call.requested",
|
|
requestId: "unknown-req",
|
|
operationId: "x",
|
|
input: null,
|
|
timestamp: "2026-01-01T00:00:00Z",
|
|
});
|
|
|
|
expect(root.statusMap.get("a")!.value).toBe("idle");
|
|
|
|
root.dispose();
|
|
});
|
|
|
|
it("is idempotent - appending same event twice produces same state", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
root.nodeKeyToRequestId.set("a", "req-1");
|
|
|
|
const respondedEvent: CallEventMapValue = {
|
|
type: "call.responded",
|
|
requestId: "req-1",
|
|
output: { result: 42 },
|
|
timestamp: "2026-01-01T00:00:01Z",
|
|
};
|
|
|
|
root.append({
|
|
type: "call.requested",
|
|
requestId: "req-1",
|
|
operationId: "a",
|
|
input: null,
|
|
timestamp: "2026-01-01T00:00:00Z",
|
|
});
|
|
root.append(respondedEvent);
|
|
root.append(respondedEvent);
|
|
|
|
expect(root.statusMap.get("a")!.value).toBe("completed");
|
|
|
|
root.dispose();
|
|
});
|
|
});
|
|
|
|
describe("getStatus", () => {
|
|
it("returns idle for nodes with no events", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
expect(root.getStatus("a")).toBe("idle");
|
|
|
|
root.dispose();
|
|
});
|
|
|
|
it("returns event-derived status when requestId is mapped", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
root.nodeKeyToRequestId.set("a", "req-1");
|
|
root.append({
|
|
type: "call.requested",
|
|
requestId: "req-1",
|
|
operationId: "a",
|
|
input: null,
|
|
timestamp: "2026-01-01T00:00:00Z",
|
|
});
|
|
|
|
expect(root.getStatus("a")).toBe("running");
|
|
|
|
root.dispose();
|
|
});
|
|
|
|
it("falls back to signal value when no requestId is mapped", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
root.statusMap.get("a")!.value = "waiting";
|
|
|
|
expect(root.getStatus("a")).toBe("waiting");
|
|
|
|
root.dispose();
|
|
});
|
|
|
|
it("returns idle for unknown node", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
expect(root.getStatus("nonexistent")).toBe("idle");
|
|
|
|
root.dispose();
|
|
});
|
|
});
|
|
|
|
describe("getResult", () => {
|
|
it("returns undefined when no requestId is mapped", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
expect(root.getResult("a")).toBeUndefined();
|
|
|
|
root.dispose();
|
|
});
|
|
|
|
it("returns completed result from call.responded event", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
root.nodeKeyToRequestId.set("a", "req-1");
|
|
root.append({
|
|
type: "call.requested",
|
|
requestId: "req-1",
|
|
operationId: "a",
|
|
input: null,
|
|
timestamp: "2026-01-01T00:00:00Z",
|
|
});
|
|
root.append({
|
|
type: "call.responded",
|
|
requestId: "req-1",
|
|
output: { value: 99 },
|
|
timestamp: "2026-01-01T00:00:01Z",
|
|
});
|
|
|
|
const result = root.getResult("a");
|
|
expect(result).toBeDefined();
|
|
expect(result!.status).toBe("completed");
|
|
expect(result!.output).toEqual({ value: 99 });
|
|
|
|
root.dispose();
|
|
});
|
|
|
|
it("returns failed result from call.error event", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
root.nodeKeyToRequestId.set("a", "req-1");
|
|
root.append({
|
|
type: "call.requested",
|
|
requestId: "req-1",
|
|
operationId: "a",
|
|
input: null,
|
|
timestamp: "2026-01-01T00:00:00Z",
|
|
});
|
|
root.append({
|
|
type: "call.error",
|
|
requestId: "req-1",
|
|
error: { code: "TIMEOUT", message: "timed out" },
|
|
timestamp: "2026-01-01T00:00:01Z",
|
|
});
|
|
|
|
const result = root.getResult("a");
|
|
expect(result).toBeDefined();
|
|
expect(result!.status).toBe("failed");
|
|
expect(result!.output).toBeUndefined();
|
|
expect(result!.error).toEqual({ code: "TIMEOUT", message: "timed out" });
|
|
|
|
root.dispose();
|
|
});
|
|
|
|
it("returns aborted result from call.aborted event", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
root.nodeKeyToRequestId.set("a", "req-1");
|
|
root.append({
|
|
type: "call.requested",
|
|
requestId: "req-1",
|
|
operationId: "a",
|
|
input: null,
|
|
timestamp: "2026-01-01T00:00:00Z",
|
|
});
|
|
root.append({
|
|
type: "call.aborted",
|
|
requestId: "req-1",
|
|
timestamp: "2026-01-01T00:00:01Z",
|
|
});
|
|
|
|
const result = root.getResult("a");
|
|
expect(result).toBeDefined();
|
|
expect(result!.status).toBe("aborted");
|
|
expect(result!.output).toBeUndefined();
|
|
|
|
root.dispose();
|
|
});
|
|
|
|
it("returns undefined when only call.requested has been received", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
root.nodeKeyToRequestId.set("a", "req-1");
|
|
root.append({
|
|
type: "call.requested",
|
|
requestId: "req-1",
|
|
operationId: "a",
|
|
input: null,
|
|
timestamp: "2026-01-01T00:00:00Z",
|
|
});
|
|
|
|
expect(root.getResult("a")).toBeUndefined();
|
|
|
|
root.dispose();
|
|
});
|
|
|
|
it("uses most recent terminal event for retries", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
root.nodeKeyToRequestId.set("a", "req-2");
|
|
root.append({
|
|
type: "call.requested",
|
|
requestId: "req-1",
|
|
operationId: "a",
|
|
input: null,
|
|
timestamp: "2026-01-01T00:00:00Z",
|
|
});
|
|
root.append({
|
|
type: "call.error",
|
|
requestId: "req-1",
|
|
error: { code: "ERR", message: "first attempt failed" },
|
|
timestamp: "2026-01-01T00:00:01Z",
|
|
});
|
|
root.append({
|
|
type: "call.requested",
|
|
requestId: "req-2",
|
|
operationId: "a",
|
|
input: null,
|
|
timestamp: "2026-01-01T00:00:02Z",
|
|
});
|
|
root.append({
|
|
type: "call.responded",
|
|
requestId: "req-2",
|
|
output: { ok: true },
|
|
timestamp: "2026-01-01T00:00:03Z",
|
|
});
|
|
|
|
const result = root.getResult("a");
|
|
expect(result).toBeDefined();
|
|
expect(result!.status).toBe("completed");
|
|
expect(result!.output).toEqual({ ok: true });
|
|
|
|
root.dispose();
|
|
});
|
|
});
|
|
|
|
describe("getEvents", () => {
|
|
it("returns empty array for unmapped node", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
expect(root.getEvents("a")).toEqual([]);
|
|
|
|
root.dispose();
|
|
});
|
|
|
|
it("returns events for a mapped node", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
root.nodeKeyToRequestId.set("a", "req-1");
|
|
root.append({
|
|
type: "call.requested",
|
|
requestId: "req-1",
|
|
operationId: "a",
|
|
input: null,
|
|
timestamp: "2026-01-01T00:00:00Z",
|
|
});
|
|
root.append({
|
|
type: "call.responded",
|
|
requestId: "req-1",
|
|
output: 42,
|
|
timestamp: "2026-01-01T00:00:01Z",
|
|
});
|
|
|
|
const events = root.getEvents("a");
|
|
expect(events).toHaveLength(2);
|
|
expect(events[0]!.type).toBe("call.requested");
|
|
expect(events[1]!.type).toBe("call.responded");
|
|
|
|
root.dispose();
|
|
});
|
|
});
|
|
|
|
describe("abort cascade", () => {
|
|
it("failed node causes downstream dependents to abort (continue-running default)", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
root.statusMap.get("a")!.value = "failed";
|
|
|
|
expect(root.statusMap.get("b")!.value).toBe("aborted");
|
|
expect(root.statusMap.get("c")!.value).toBe("aborted");
|
|
|
|
root.dispose();
|
|
});
|
|
|
|
it("aborted node causes downstream dependents to abort", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
root.statusMap.get("a")!.value = "aborted";
|
|
|
|
expect(root.statusMap.get("b")!.value).toBe("aborted");
|
|
expect(root.statusMap.get("c")!.value).toBe("aborted");
|
|
|
|
root.dispose();
|
|
});
|
|
|
|
it("sibling branches are independent - failure on one side does not abort the other", () => {
|
|
const graph = makeDiamondGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
root.statusMap.get("top")!.value = "completed";
|
|
root.statusMap.get("left")!.value = "running";
|
|
root.statusMap.get("right")!.value = "failed";
|
|
|
|
expect(root.statusMap.get("left")!.value).toBe("running");
|
|
expect(root.statusMap.get("bottom")!.value).toBe("aborted");
|
|
|
|
root.dispose();
|
|
});
|
|
|
|
it("failed node does not abort already completed nodes", () => {
|
|
const graph = makeDiamondGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
root.statusMap.get("top")!.value = "completed";
|
|
root.statusMap.get("left")!.value = "completed";
|
|
root.statusMap.get("right")!.value = "failed";
|
|
|
|
expect(root.statusMap.get("left")!.value).toBe("completed");
|
|
|
|
root.dispose();
|
|
});
|
|
});
|
|
|
|
describe("failurePolicy: abort-dependents", () => {
|
|
it("abort-dependents policy aborts idle dependents of a failed node", () => {
|
|
const graph = makeForkJoinGraph();
|
|
const root = new WorkflowReactiveRoot(graph, {
|
|
failurePolicy: "abort-dependents",
|
|
});
|
|
|
|
root.statusMap.get("source")!.value = "completed";
|
|
root.statusMap.get("fail-node")!.value = "running";
|
|
root.statusMap.get("run-node")!.value = "running";
|
|
root.statusMap.get("fail-node")!.value = "failed";
|
|
|
|
expect(root.statusMap.get("sink")!.value).toBe("aborted");
|
|
|
|
root.dispose();
|
|
});
|
|
});
|
|
|
|
describe("abortAll", () => {
|
|
it("sets all non-terminal nodes to aborted", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
root.statusMap.get("a")!.value = "completed";
|
|
|
|
root.abortAll();
|
|
|
|
expect(root.statusMap.get("a")!.value).toBe("completed");
|
|
expect(root.statusMap.get("b")!.value).toBe("aborted");
|
|
expect(root.statusMap.get("c")!.value).toBe("aborted");
|
|
|
|
root.dispose();
|
|
});
|
|
|
|
it("does not change already failed nodes", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
root.statusMap.get("a")!.value = "failed";
|
|
|
|
root.abortAll();
|
|
|
|
expect(root.statusMap.get("a")!.value).toBe("failed");
|
|
|
|
root.dispose();
|
|
});
|
|
});
|
|
|
|
describe("abortNode", () => {
|
|
it("aborts a specific non-terminal node", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
root.abortNode("b");
|
|
|
|
expect(root.statusMap.get("b")!.value).toBe("aborted");
|
|
|
|
root.dispose();
|
|
});
|
|
|
|
it("does not abort already completed nodes", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
root.statusMap.get("a")!.value = "completed";
|
|
|
|
root.abortNode("a");
|
|
|
|
expect(root.statusMap.get("a")!.value).toBe("completed");
|
|
|
|
root.dispose();
|
|
});
|
|
|
|
it("does not throw for unknown node", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
expect(() => root.abortNode("nonexistent")).not.toThrow();
|
|
|
|
root.dispose();
|
|
});
|
|
});
|
|
|
|
describe("isComplete", () => {
|
|
it("returns false when any node is non-terminal", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
expect(root.isComplete()).toBe(false);
|
|
|
|
root.dispose();
|
|
});
|
|
|
|
it("returns true when all nodes are in terminal state", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
root.statusMap.get("a")!.value = "completed";
|
|
root.statusMap.get("b")!.value = "skipped";
|
|
root.statusMap.get("c")!.value = "failed";
|
|
|
|
expect(root.isComplete()).toBe(true);
|
|
|
|
root.dispose();
|
|
});
|
|
});
|
|
|
|
describe("getAggregateStatus", () => {
|
|
it("returns correct counts", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
root.statusMap.get("a")!.value = "completed";
|
|
root.statusMap.get("b")!.value = "running";
|
|
root.statusMap.get("c")!.value = "idle";
|
|
|
|
const agg = root.getAggregateStatus();
|
|
expect(agg.completed).toBe(1);
|
|
expect(agg.running).toBe(1);
|
|
expect(agg.idle).toBe(1);
|
|
expect(agg.total).toBe(3);
|
|
expect(agg.failed).toBe(0);
|
|
expect(agg.aborted).toBe(0);
|
|
expect(agg.skipped).toBe(0);
|
|
expect(agg.waiting).toBe(0);
|
|
expect(agg.ready).toBe(0);
|
|
|
|
root.dispose();
|
|
});
|
|
});
|
|
|
|
describe("dispose", () => {
|
|
it("clears all maps", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
root.dispose();
|
|
|
|
expect(root.statusMap.size).toBe(0);
|
|
expect(root.preconditions.size).toBe(0);
|
|
expect(root.blockedByFailure.size).toBe(0);
|
|
expect(root.resultMap.size).toBe(0);
|
|
expect(root.nodeKeyToRequestId.size).toBe(0);
|
|
});
|
|
|
|
it("effects no longer fire after dispose", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
const bStatusValue = root.statusMap.get("b")!.value;
|
|
root.dispose();
|
|
|
|
expect(bStatusValue).toBeDefined();
|
|
});
|
|
});
|
|
|
|
describe("precondition reactivity", () => {
|
|
it("preconditions update when predecessor completes", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
expect(root.preconditions.get("b")!.value).toBe(false);
|
|
|
|
root.statusMap.get("a")!.value = "completed";
|
|
|
|
expect(root.preconditions.get("b")!.value).toBe(true);
|
|
|
|
root.dispose();
|
|
});
|
|
|
|
it("skipped predecessor satisfies preconditions", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
root.statusMap.get("a")!.value = "skipped";
|
|
|
|
expect(root.preconditions.get("b")!.value).toBe(true);
|
|
|
|
root.dispose();
|
|
});
|
|
|
|
it("failed predecessor does not satisfy preconditions", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
root.statusMap.get("a")!.value = "failed";
|
|
|
|
expect(root.preconditions.get("b")!.value).toBe(false);
|
|
|
|
root.dispose();
|
|
});
|
|
|
|
it("diamond graph: bottom requires both predecessors complete", () => {
|
|
const graph = makeDiamondGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
root.statusMap.get("top")!.value = "completed";
|
|
root.statusMap.get("left")!.value = "completed";
|
|
root.statusMap.get("right")!.value = "completed";
|
|
|
|
expect(root.preconditions.get("bottom")!.value).toBe(true);
|
|
|
|
root.dispose();
|
|
});
|
|
|
|
it("diamond graph: bottom blocked when one predecessor fails", () => {
|
|
const graph = makeDiamondGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
root.statusMap.get("top")!.value = "completed";
|
|
root.statusMap.get("left")!.value = "completed";
|
|
root.statusMap.get("right")!.value = "failed";
|
|
|
|
expect(root.preconditions.get("bottom")!.value).toBe(false);
|
|
|
|
root.dispose();
|
|
});
|
|
});
|
|
|
|
describe("blockedByFailure reactivity", () => {
|
|
it("detects failed predecessor", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
root.statusMap.get("a")!.value = "failed";
|
|
|
|
expect(root.blockedByFailure.get("b")!.value).toBe(true);
|
|
expect(root.blockedByFailure.get("c")!.value).toBe(true);
|
|
|
|
root.dispose();
|
|
});
|
|
|
|
it("detects aborted predecessor", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
root.statusMap.get("a")!.value = "aborted";
|
|
|
|
expect(root.blockedByFailure.get("b")!.value).toBe(true);
|
|
|
|
root.dispose();
|
|
});
|
|
|
|
it("completed predecessor does not block by failure", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
root.statusMap.get("a")!.value = "completed";
|
|
|
|
expect(root.blockedByFailure.get("b")!.value).toBe(false);
|
|
|
|
root.dispose();
|
|
});
|
|
});
|
|
|
|
describe("full workflow execution flow", () => {
|
|
it("simulates a simple linear workflow: a -> b -> c", () => {
|
|
const graph = makeSimpleGraph();
|
|
const root = new WorkflowReactiveRoot(graph);
|
|
|
|
root.nodeKeyToRequestId.set("a", "req-a");
|
|
root.nodeKeyToRequestId.set("b", "req-b");
|
|
root.nodeKeyToRequestId.set("c", "req-c");
|
|
|
|
expect(root.getStatus("a")).toBe("idle");
|
|
expect(root.getStatus("b")).toBe("idle");
|
|
expect(root.getStatus("c")).toBe("idle");
|
|
|
|
root.append({
|
|
type: "call.requested",
|
|
requestId: "req-a",
|
|
operationId: "a",
|
|
input: null,
|
|
timestamp: "t1",
|
|
});
|
|
expect(root.getStatus("a")).toBe("running");
|
|
|
|
root.append({
|
|
type: "call.responded",
|
|
requestId: "req-a",
|
|
output: "result-a",
|
|
timestamp: "t2",
|
|
});
|
|
expect(root.getStatus("a")).toBe("completed");
|
|
expect(root.preconditions.get("b")!.value).toBe(true);
|
|
|
|
root.append({
|
|
type: "call.requested",
|
|
requestId: "req-b",
|
|
operationId: "b",
|
|
input: null,
|
|
timestamp: "t3",
|
|
});
|
|
expect(root.getStatus("b")).toBe("running");
|
|
|
|
root.append({
|
|
type: "call.responded",
|
|
requestId: "req-b",
|
|
output: "result-b",
|
|
timestamp: "t4",
|
|
});
|
|
expect(root.getStatus("b")).toBe("completed");
|
|
expect(root.preconditions.get("c")!.value).toBe(true);
|
|
|
|
root.append({
|
|
type: "call.requested",
|
|
requestId: "req-c",
|
|
operationId: "c",
|
|
input: null,
|
|
timestamp: "t5",
|
|
});
|
|
root.append({
|
|
type: "call.responded",
|
|
requestId: "req-c",
|
|
output: "result-c",
|
|
timestamp: "t6",
|
|
});
|
|
expect(root.getStatus("c")).toBe("completed");
|
|
expect(root.isComplete()).toBe(true);
|
|
|
|
expect(root.getResult("a")!.output).toBe("result-a");
|
|
expect(root.getResult("b")!.output).toBe("result-b");
|
|
expect(root.getResult("c")!.output).toBe("result-c");
|
|
|
|
root.dispose();
|
|
});
|
|
});
|
|
});
|