droboticflow/tests/frontend/workflow-canvas.test.mjs
2026-08-24 03:36:25 +08:00

195 lines
5.6 KiB
JavaScript

import test from "node:test";
import assert from "node:assert/strict";
import {
allowedCanvasChanges,
canConnectToInput,
findInputConnectionConflicts,
removeSelectedCanvasElements,
validateSingleConnectedWorkflowGraph,
} from "../../src/lib/workflow-canvas.js";
test("input handle only accepts a single incoming edge", () => {
const edges = [
{
id: "edge-a",
source: "source-a",
sourceHandle: "out-1",
target: "node-b",
targetHandle: "in-1",
},
];
assert.equal(
canConnectToInput(edges, {
source: "source-c",
sourceHandle: "out-1",
target: "node-b",
targetHandle: "in-1",
}),
false,
);
assert.equal(
canConnectToInput(edges, {
source: "source-c",
sourceHandle: "out-1",
target: "node-b",
targetHandle: "in-2",
}),
true,
);
});
test("findInputConnectionConflicts groups duplicate incoming edges by target handle", () => {
const conflicts = findInputConnectionConflicts([
{
id: "edge-a",
source: "source-a",
target: "upload-node",
targetHandle: "result",
},
{
id: "edge-b",
source: "source-b",
target: "upload-node",
targetHandle: "result",
},
{
id: "edge-c",
source: "source-c",
target: "upload-node",
targetHandle: "other",
},
]);
assert.deepEqual(conflicts, [
{
target: "upload-node",
targetHandle: "result",
edgeIds: ["edge-a", "edge-b"],
},
]);
});
test("findInputConnectionConflicts treats empty handles as the same default input", () => {
const conflicts = findInputConnectionConflicts([
{
id: "edge-a",
source: "source-a",
target: "upload-node",
},
{
id: "edge-b",
source: "source-b",
target: "upload-node",
targetHandle: " ",
},
]);
assert.equal(conflicts.length, 1);
assert.equal(conflicts[0].targetHandle, "");
});
test("validateSingleConnectedWorkflowGraph rejects isolated nodes", () => {
const result = validateSingleConnectedWorkflowGraph(
[{ id: "source" }, { id: "train" }, { id: "orphan" }],
[{ id: "edge-1", source: "source", target: "train" }],
);
assert.equal(result.valid, false);
assert.equal(result.code, "workflow_graph_isolated_node");
assert.match(result.issue, /orphan/);
});
test("validateSingleConnectedWorkflowGraph rejects disconnected chains", () => {
const result = validateSingleConnectedWorkflowGraph(
[{ id: "a" }, { id: "b" }, { id: "c" }, { id: "d" }],
[
{ id: "edge-1", source: "a", target: "b" },
{ id: "edge-2", source: "c", target: "d" },
],
);
assert.equal(result.valid, false);
assert.equal(result.code, "workflow_graph_disconnected");
});
test("validateSingleConnectedWorkflowGraph accepts a connected branching workflow", () => {
const result = validateSingleConnectedWorkflowGraph(
[{ id: "source" }, { id: "train-a" }, { id: "train-b" }, { id: "merge" }],
[
{ id: "edge-1", source: "source", target: "train-a" },
{ id: "edge-2", source: "source", target: "train-b" },
{ id: "edge-3", source: "train-a", target: "merge" },
{ id: "edge-4", source: "train-b", target: "merge" },
],
);
assert.equal(result.valid, true);
});
test("validateSingleConnectedWorkflowGraph rejects directed cycles", () => {
const result = validateSingleConnectedWorkflowGraph(
[{ id: "annotate" }, { id: "review" }, { id: "deliver" }],
[
{ id: "a-r", source: "annotate", target: "review" },
{ id: "r-a", source: "review", target: "annotate" },
{ id: "r-d", source: "review", target: "deliver" },
],
);
assert.equal(result.valid, false);
assert.equal(result.code, "workflow_graph_cycle");
assert.match(result.issue, /Human Item/);
});
test("read-only replay keeps selection and temporary positions but discards structural mutations", () => {
const changes = [
{ type: "select", id: "node-a", selected: true },
{ type: "position", id: "node-a", position: { x: 20, y: 30 } },
{ type: "remove", id: "edge-a" },
{ type: "add", item: { id: "node-b" } },
{ type: "replace", id: "node-a", item: { id: "node-a" } },
{ type: "reset", items: [] },
];
assert.deepEqual(allowedCanvasChanges(changes, false), [changes[0]]);
assert.deepEqual(allowedCanvasChanges(changes, false, true), [changes[0], changes[1]]);
assert.equal(allowedCanvasChanges(changes, true), changes);
assert.deepEqual(allowedCanvasChanges(null, false), []);
});
test("removing selected nodes also removes incident edges", () => {
const result = removeSelectedCanvasElements(
[
{ id: "node-a", selected: true },
{ id: "node-b", selected: false },
],
[
{ id: "edge-a", source: "node-a", target: "node-b", selected: false },
{ id: "edge-b", source: "node-b", target: "node-a", selected: false },
],
);
assert.deepEqual(result.removedNodeIds, ["node-a"]);
assert.deepEqual(result.nodes, [{ id: "node-b", selected: false }]);
assert.deepEqual(result.edges, []);
});
test("removing selected edges leaves nodes intact", () => {
const result = removeSelectedCanvasElements(
[
{ id: "node-a", selected: false },
{ id: "node-b", selected: false },
],
[
{ id: "edge-a", source: "node-a", target: "node-b", selected: true },
{ id: "edge-b", source: "node-b", target: "node-a", selected: false },
],
);
assert.deepEqual(result.removedEdgeIds, ["edge-a"]);
assert.equal(result.nodes.length, 2);
assert.deepEqual(result.edges, [{ id: "edge-b", source: "node-b", target: "node-a", selected: false }]);
});