@yh-ui/flow 0.1.21

package/dist/__tests__/bpmn.test.mjs

@@ -0,0 +1,106 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  clearCustomTypes,
+  getCustomNode,
+  getAllCustomNodes,
+  hasCustomNode
+} from "../utils/custom-types.mjs";
+import { registerBpmnNodes, BPMN_NODE_TYPES } from "../components/nodes/bpmn/index.mjs";
+describe("flow/components/nodes/bpmn", () => {
+  beforeEach(() => {
+    clearCustomTypes();
+  });
+  describe("BPMN Node Types", () => {
+    it("should have correct BPMN node type constants", () => {
+      expect(BPMN_NODE_TYPES.StartEvent).toBe("bpmn-start");
+      expect(BPMN_NODE_TYPES.EndEvent).toBe("bpmn-end");
+      expect(BPMN_NODE_TYPES.Task).toBe("bpmn-task");
+      expect(BPMN_NODE_TYPES.ServiceTask).toBe("bpmn-service-task");
+      expect(BPMN_NODE_TYPES.UserTask).toBe("bpmn-user-task");
+      expect(BPMN_NODE_TYPES.ExclusiveGateway).toBe("bpmn-exclusive-gateway");
+      expect(BPMN_NODE_TYPES.ParallelGateway).toBe("bpmn-parallel-gateway");
+      expect(BPMN_NODE_TYPES.InclusiveGateway).toBe("bpmn-inclusive-gateway");
+    });
+    it("should have 8 BPMN node types", () => {
+      const types = Object.values(BPMN_NODE_TYPES);
+      expect(types).toHaveLength(8);
+    });
+  });
+  describe("BPMN Node Registration", () => {
+    it("should register all BPMN node types", () => {
+      registerBpmnNodes();
+      const allNodes = getAllCustomNodes();
+      expect(allNodes).toHaveLength(8);
+    });
+    it("should register start event node", () => {
+      registerBpmnNodes();
+      const node = getCustomNode(BPMN_NODE_TYPES.StartEvent);
+      expect(node).toBeDefined();
+      expect(node?.type).toBe(BPMN_NODE_TYPES.StartEvent);
+      expect(node?.component).toBeDefined();
+    });
+    it("should register end event node", () => {
+      registerBpmnNodes();
+      const node = getCustomNode(BPMN_NODE_TYPES.EndEvent);
+      expect(node).toBeDefined();
+      expect(node?.type).toBe(BPMN_NODE_TYPES.EndEvent);
+      expect(node?.component).toBeDefined();
+    });
+    it("should register task node", () => {
+      registerBpmnNodes();
+      const node = getCustomNode(BPMN_NODE_TYPES.Task);
+      expect(node).toBeDefined();
+      expect(node?.type).toBe(BPMN_NODE_TYPES.Task);
+    });
+    it("should register service task node", () => {
+      registerBpmnNodes();
+      const node = getCustomNode(BPMN_NODE_TYPES.ServiceTask);
+      expect(node).toBeDefined();
+      expect(node?.type).toBe(BPMN_NODE_TYPES.ServiceTask);
+    });
+    it("should register user task node", () => {
+      registerBpmnNodes();
+      const node = getCustomNode(BPMN_NODE_TYPES.UserTask);
+      expect(node).toBeDefined();
+      expect(node?.type).toBe(BPMN_NODE_TYPES.UserTask);
+    });
+    it("should register exclusive gateway node", () => {
+      registerBpmnNodes();
+      const node = getCustomNode(BPMN_NODE_TYPES.ExclusiveGateway);
+      expect(node).toBeDefined();
+      expect(node?.type).toBe(BPMN_NODE_TYPES.ExclusiveGateway);
+    });
+    it("should register parallel gateway node", () => {
+      registerBpmnNodes();
+      const node = getCustomNode(BPMN_NODE_TYPES.ParallelGateway);
+      expect(node).toBeDefined();
+      expect(node?.type).toBe(BPMN_NODE_TYPES.ParallelGateway);
+    });
+    it("should register inclusive gateway node", () => {
+      registerBpmnNodes();
+      const node = getCustomNode(BPMN_NODE_TYPES.InclusiveGateway);
+      expect(node).toBeDefined();
+      expect(node?.type).toBe(BPMN_NODE_TYPES.InclusiveGateway);
+    });
+    it("should check if BPMN nodes are registered", () => {
+      expect(hasCustomNode(BPMN_NODE_TYPES.StartEvent)).toBe(false);
+      expect(hasCustomNode(BPMN_NODE_TYPES.EndEvent)).toBe(false);
+      registerBpmnNodes();
+      expect(hasCustomNode(BPMN_NODE_TYPES.StartEvent)).toBe(true);
+      expect(hasCustomNode(BPMN_NODE_TYPES.EndEvent)).toBe(true);
+      expect(hasCustomNode(BPMN_NODE_TYPES.Task)).toBe(true);
+      expect(hasCustomNode(BPMN_NODE_TYPES.ServiceTask)).toBe(true);
+      expect(hasCustomNode(BPMN_NODE_TYPES.UserTask)).toBe(true);
+      expect(hasCustomNode(BPMN_NODE_TYPES.ExclusiveGateway)).toBe(true);
+      expect(hasCustomNode(BPMN_NODE_TYPES.ParallelGateway)).toBe(true);
+      expect(hasCustomNode(BPMN_NODE_TYPES.InclusiveGateway)).toBe(true);
+    });
+    it("should not duplicate nodes on re-registration", () => {
+      registerBpmnNodes();
+      const firstCount = getAllCustomNodes().length;
+      registerBpmnNodes();
+      const secondCount = getAllCustomNodes().length;
+      expect(firstCount).toBe(secondCount);
+    });
+  });
+});

package/dist/__tests__/custom-types.test.cjs

@@ -0,0 +1,300 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _customTypes = require("../utils/custom-types.cjs");
+var _vue = require("vue");
+(0, _vitest.describe)("flow/utils/custom-types", () => {
+  const MockComponent = (0, _vue.defineComponent)({
+    name: "MockComponent",
+    render() {
+      return (0, _vue.h)("div");
+    }
+  });
+  (0, _vitest.beforeEach)(() => {
+    (0, _customTypes.clearCustomTypes)();
+  });
+  (0, _vitest.describe)("Custom Node Templates", () => {
+    (0, _vitest.it)("should register and retrieve custom node template", () => {
+      const template = {
+        type: "custom-node",
+        component: MockComponent,
+        defaultData: {
+          label: "Test Node"
+        },
+        defaultWidth: 200,
+        defaultHeight: 100
+      };
+      (0, _customTypes.registerCustomNodeTemplate)(template);
+      (0, _vitest.expect)((0, _customTypes.hasCustomNodeTemplate)("custom-node")).toBe(true);
+      const retrieved = (0, _customTypes.getCustomNodeTemplate)("custom-node");
+      (0, _vitest.expect)(retrieved?.type).toBe("custom-node");
+      (0, _vitest.expect)(retrieved?.defaultWidth).toBe(200);
+    });
+    (0, _vitest.it)("should get all registered templates", () => {
+      (0, _customTypes.registerCustomNodeTemplate)({
+        type: "template-1",
+        component: MockComponent
+      });
+      (0, _customTypes.registerCustomNodeTemplate)({
+        type: "template-2",
+        component: MockComponent
+      });
+      const all = (0, _customTypes.getAllCustomNodeTemplates)();
+      (0, _vitest.expect)(all.length).toBe(2);
+    });
+    (0, _vitest.it)("should create node from template", () => {
+      (0, _customTypes.registerCustomNodeTemplate)({
+        type: "template-node",
+        component: MockComponent,
+        defaultData: {
+          label: "Default"
+        },
+        defaultWidth: 180,
+        defaultHeight: 60
+      });
+      const node = (0, _customTypes.createNodeFromTemplate)("template-node", "node-1", {
+        x: 100,
+        y: 200
+      });
+      (0, _vitest.expect)(node).not.toBeNull();
+      (0, _vitest.expect)(node?.id).toBe("node-1");
+      (0, _vitest.expect)(node?.type).toBe("template-node");
+      (0, _vitest.expect)(node?.position).toEqual({
+        x: 100,
+        y: 200
+      });
+      (0, _vitest.expect)(node?.width).toBe(180);
+      (0, _vitest.expect)(node?.height).toBe(60);
+      (0, _vitest.expect)(node?.data.label).toBe("Default");
+    });
+    (0, _vitest.it)("should create node with overrides", () => {
+      (0, _customTypes.registerCustomNodeTemplate)({
+        type: "template-node",
+        component: MockComponent,
+        defaultData: {
+          label: "Default"
+        },
+        defaultWidth: 180,
+        defaultHeight: 60
+      });
+      const node = (0, _customTypes.createNodeFromTemplate)("template-node", "node-1", {
+        x: 100,
+        y: 200
+      }, {
+        data: {
+          label: "Custom Label"
+        },
+        width: 250
+      });
+      (0, _vitest.expect)(node?.data.label).toBe("Custom Label");
+      (0, _vitest.expect)(node?.width).toBe(250);
+    });
+    (0, _vitest.it)("should return null for non-existent template", () => {
+      const node = (0, _customTypes.createNodeFromTemplate)("non-existent", "node-1", {
+        x: 0,
+        y: 0
+      });
+      (0, _vitest.expect)(node).toBeNull();
+    });
+  });
+  (0, _vitest.describe)("Custom Edges", () => {
+    (0, _vitest.it)("should register and retrieve custom edge", () => {
+      const edge = {
+        type: "custom-edge",
+        component: MockComponent,
+        label: "Custom Edge Label"
+      };
+      (0, _customTypes.registerCustomEdge)(edge);
+      (0, _vitest.expect)((0, _customTypes.hasCustomEdge)("custom-edge")).toBe(true);
+      const retrieved = (0, _customTypes.getCustomEdge)("custom-edge");
+      (0, _vitest.expect)(retrieved?.type).toBe("custom-edge");
+      (0, _vitest.expect)(retrieved?.label).toBe("Custom Edge Label");
+    });
+    (0, _vitest.it)("should get all registered edges", () => {
+      (0, _customTypes.registerCustomEdge)({
+        type: "edge-1",
+        component: MockComponent
+      });
+      (0, _customTypes.registerCustomEdge)({
+        type: "edge-2",
+        component: MockComponent
+      });
+      const all = (0, _customTypes.getAllCustomEdges)();
+      (0, _vitest.expect)(all.length).toBe(2);
+    });
+  });
+  (0, _vitest.describe)("Edge Templates", () => {
+    (0, _vitest.it)("should register and retrieve edge template", () => {
+      const template = {
+        type: "animated-edge",
+        animated: true,
+        style: {
+          stroke: "#3b82f6",
+          strokeWidth: 2
+        },
+        label: "Animated"
+      };
+      (0, _customTypes.registerEdgeTemplate)(template);
+      const retrieved = (0, _customTypes.getEdgeTemplate)("animated-edge");
+      (0, _vitest.expect)(retrieved?.type).toBe("animated-edge");
+      (0, _vitest.expect)(retrieved?.animated).toBe(true);
+    });
+    (0, _vitest.it)("should get all edge templates", () => {
+      (0, _customTypes.registerEdgeTemplate)({
+        type: "edge-1",
+        animated: false
+      });
+      (0, _customTypes.registerEdgeTemplate)({
+        type: "edge-2",
+        animated: true
+      });
+      const all = (0, _customTypes.getAllEdgeTemplates)();
+      (0, _vitest.expect)(all.length).toBe(2);
+    });
+  });
+  (0, _vitest.describe)("Nested Node Helpers", () => {
+    const nodes = [{
+      id: "parent-1",
+      type: "group",
+      position: {
+        x: 0,
+        y: 0
+      },
+      data: {},
+      width: 500,
+      height: 300
+    }, {
+      id: "child-1",
+      type: "default",
+      position: {
+        x: 50,
+        y: 50
+      },
+      data: {},
+      parentId: "parent-1"
+    }, {
+      id: "child-2",
+      type: "default",
+      position: {
+        x: 150,
+        y: 50
+      },
+      data: {},
+      parentId: "parent-1"
+    }, {
+      id: "standalone",
+      type: "default",
+      position: {
+        x: 300,
+        y: 300
+      },
+      data: {}
+    }];
+    (0, _vitest.it)("should detect nested node", () => {
+      const child = nodes.find(n => n.id === "child-1");
+      const standalone = nodes.find(n => n.id === "standalone");
+      (0, _vitest.expect)((0, _customTypes.isNestedNode)(child)).toBe(true);
+      (0, _vitest.expect)((0, _customTypes.isNestedNode)(standalone)).toBe(false);
+    });
+    (0, _vitest.it)("should get node children", () => {
+      const parent = nodes.find(n => n.id === "parent-1");
+      const children = (0, _customTypes.getNodeChildren)(parent, nodes);
+      (0, _vitest.expect)(children.length).toBe(2);
+      (0, _vitest.expect)(children.map(c => c.id).sort()).toEqual(["child-1", "child-2"]);
+    });
+    (0, _vitest.it)("should get node parent", () => {
+      const child = nodes.find(n => n.id === "child-1");
+      const standalone = nodes.find(n => n.id === "standalone");
+      const parent = (0, _customTypes.getNodeParent)(child, nodes);
+      (0, _vitest.expect)(parent?.id).toBe("parent-1");
+      const standaloneParent = (0, _customTypes.getNodeParent)(standalone, nodes);
+      (0, _vitest.expect)(standaloneParent).toBeUndefined();
+    });
+  });
+  (0, _vitest.describe)("Export/Import", () => {
+    const testNodes = [{
+      id: "1",
+      type: "input",
+      position: {
+        x: 0,
+        y: 0
+      },
+      data: {
+        label: "Start"
+      }
+    }, {
+      id: "2",
+      type: "default",
+      position: {
+        x: 100,
+        y: 100
+      },
+      data: {
+        label: "Process"
+      }
+    }];
+    const testEdges = [{
+      id: "e1",
+      source: "1",
+      target: "2",
+      type: "bezier"
+    }];
+    (0, _vitest.it)("should export flow data as JSON", () => {
+      const json = (0, _customTypes.exportFlowData)(testNodes, testEdges, {
+        x: 0,
+        y: 0,
+        zoom: 1
+      });
+      (0, _vitest.expect)(json).toContain('"nodes"');
+      (0, _vitest.expect)(json).toContain('"edges"');
+      (0, _vitest.expect)(json).toContain('"viewport"');
+      (0, _vitest.expect)(json).toContain('"version"');
+    });
+    (0, _vitest.it)("should import flow data from JSON", () => {
+      const json = JSON.stringify({
+        nodes: testNodes,
+        edges: testEdges,
+        viewport: {
+          x: 0,
+          y: 0,
+          zoom: 1
+        }
+      });
+      const data = (0, _customTypes.importFlowData)(json);
+      (0, _vitest.expect)(data).not.toBeNull();
+      (0, _vitest.expect)(data?.nodes.length).toBe(2);
+      (0, _vitest.expect)(data?.edges.length).toBe(1);
+    });
+    (0, _vitest.it)("should return null for invalid JSON", () => {
+      const data = (0, _customTypes.importFlowData)("invalid json");
+      (0, _vitest.expect)(data).toBeNull();
+    });
+    (0, _vitest.it)("should return null for empty nodes array", () => {
+      const json = JSON.stringify({
+        edges: []
+      });
+      const data = (0, _customTypes.importFlowData)(json);
+      (0, _vitest.expect)(data).toBeNull();
+    });
+  });
+  (0, _vitest.describe)("clearCustomTypes", () => {
+    (0, _vitest.it)("should clear all registered types", () => {
+      (0, _customTypes.registerCustomNodeTemplate)({
+        type: "test-node",
+        component: MockComponent
+      });
+      (0, _customTypes.registerCustomEdge)({
+        type: "test-edge",
+        component: MockComponent
+      });
+      (0, _customTypes.registerEdgeTemplate)({
+        type: "test-edge-template",
+        animated: true
+      });
+      (0, _customTypes.clearCustomTypes)();
+      (0, _vitest.expect)((0, _customTypes.hasCustomNodeTemplate)("test-node")).toBe(false);
+      (0, _vitest.expect)((0, _customTypes.hasCustomEdge)("test-edge")).toBe(false);
+      (0, _vitest.expect)((0, _customTypes.getEdgeTemplate)("test-edge-template")).toBeUndefined();
+    });
+  });
+});

package/dist/__tests__/custom-types.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/custom-types.test.mjs

@@ -0,0 +1,248 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  registerCustomNodeTemplate,
+  getCustomNodeTemplate,
+  getAllCustomNodeTemplates,
+  hasCustomNodeTemplate,
+  createNodeFromTemplate,
+  isNestedNode,
+  getNodeChildren,
+  getNodeParent,
+  registerCustomEdge,
+  getCustomEdge,
+  getAllCustomEdges,
+  hasCustomEdge,
+  registerEdgeTemplate,
+  getEdgeTemplate,
+  getAllEdgeTemplates,
+  exportFlowData,
+  importFlowData,
+  clearCustomTypes
+} from "../utils/custom-types.mjs";
+import { defineComponent, h } from "vue";
+describe("flow/utils/custom-types", () => {
+  const MockComponent = defineComponent({
+    name: "MockComponent",
+    render() {
+      return h("div");
+    }
+  });
+  beforeEach(() => {
+    clearCustomTypes();
+  });
+  describe("Custom Node Templates", () => {
+    it("should register and retrieve custom node template", () => {
+      const template = {
+        type: "custom-node",
+        component: MockComponent,
+        defaultData: { label: "Test Node" },
+        defaultWidth: 200,
+        defaultHeight: 100
+      };
+      registerCustomNodeTemplate(template);
+      expect(hasCustomNodeTemplate("custom-node")).toBe(true);
+      const retrieved = getCustomNodeTemplate("custom-node");
+      expect(retrieved?.type).toBe("custom-node");
+      expect(retrieved?.defaultWidth).toBe(200);
+    });
+    it("should get all registered templates", () => {
+      registerCustomNodeTemplate({
+        type: "template-1",
+        component: MockComponent
+      });
+      registerCustomNodeTemplate({
+        type: "template-2",
+        component: MockComponent
+      });
+      const all = getAllCustomNodeTemplates();
+      expect(all.length).toBe(2);
+    });
+    it("should create node from template", () => {
+      registerCustomNodeTemplate({
+        type: "template-node",
+        component: MockComponent,
+        defaultData: { label: "Default" },
+        defaultWidth: 180,
+        defaultHeight: 60
+      });
+      const node = createNodeFromTemplate("template-node", "node-1", { x: 100, y: 200 });
+      expect(node).not.toBeNull();
+      expect(node?.id).toBe("node-1");
+      expect(node?.type).toBe("template-node");
+      expect(node?.position).toEqual({ x: 100, y: 200 });
+      expect(node?.width).toBe(180);
+      expect(node?.height).toBe(60);
+      expect(node?.data.label).toBe("Default");
+    });
+    it("should create node with overrides", () => {
+      registerCustomNodeTemplate({
+        type: "template-node",
+        component: MockComponent,
+        defaultData: { label: "Default" },
+        defaultWidth: 180,
+        defaultHeight: 60
+      });
+      const node = createNodeFromTemplate(
+        "template-node",
+        "node-1",
+        { x: 100, y: 200 },
+        {
+          data: { label: "Custom Label" },
+          width: 250
+        }
+      );
+      expect(node?.data.label).toBe("Custom Label");
+      expect(node?.width).toBe(250);
+    });
+    it("should return null for non-existent template", () => {
+      const node = createNodeFromTemplate("non-existent", "node-1", { x: 0, y: 0 });
+      expect(node).toBeNull();
+    });
+  });
+  describe("Custom Edges", () => {
+    it("should register and retrieve custom edge", () => {
+      const edge = {
+        type: "custom-edge",
+        component: MockComponent,
+        label: "Custom Edge Label"
+      };
+      registerCustomEdge(edge);
+      expect(hasCustomEdge("custom-edge")).toBe(true);
+      const retrieved = getCustomEdge("custom-edge");
+      expect(retrieved?.type).toBe("custom-edge");
+      expect(retrieved?.label).toBe("Custom Edge Label");
+    });
+    it("should get all registered edges", () => {
+      registerCustomEdge({ type: "edge-1", component: MockComponent });
+      registerCustomEdge({ type: "edge-2", component: MockComponent });
+      const all = getAllCustomEdges();
+      expect(all.length).toBe(2);
+    });
+  });
+  describe("Edge Templates", () => {
+    it("should register and retrieve edge template", () => {
+      const template = {
+        type: "animated-edge",
+        animated: true,
+        style: { stroke: "#3b82f6", strokeWidth: 2 },
+        label: "Animated"
+      };
+      registerEdgeTemplate(template);
+      const retrieved = getEdgeTemplate("animated-edge");
+      expect(retrieved?.type).toBe("animated-edge");
+      expect(retrieved?.animated).toBe(true);
+    });
+    it("should get all edge templates", () => {
+      registerEdgeTemplate({ type: "edge-1", animated: false });
+      registerEdgeTemplate({ type: "edge-2", animated: true });
+      const all = getAllEdgeTemplates();
+      expect(all.length).toBe(2);
+    });
+  });
+  describe("Nested Node Helpers", () => {
+    const nodes = [
+      {
+        id: "parent-1",
+        type: "group",
+        position: { x: 0, y: 0 },
+        data: {},
+        width: 500,
+        height: 300
+      },
+      {
+        id: "child-1",
+        type: "default",
+        position: { x: 50, y: 50 },
+        data: {},
+        parentId: "parent-1"
+      },
+      {
+        id: "child-2",
+        type: "default",
+        position: { x: 150, y: 50 },
+        data: {},
+        parentId: "parent-1"
+      },
+      {
+        id: "standalone",
+        type: "default",
+        position: { x: 300, y: 300 },
+        data: {}
+      }
+    ];
+    it("should detect nested node", () => {
+      const child = nodes.find((n) => n.id === "child-1");
+      const standalone = nodes.find((n) => n.id === "standalone");
+      expect(isNestedNode(child)).toBe(true);
+      expect(isNestedNode(standalone)).toBe(false);
+    });
+    it("should get node children", () => {
+      const parent = nodes.find((n) => n.id === "parent-1");
+      const children = getNodeChildren(parent, nodes);
+      expect(children.length).toBe(2);
+      expect(children.map((c) => c.id).sort()).toEqual(["child-1", "child-2"]);
+    });
+    it("should get node parent", () => {
+      const child = nodes.find((n) => n.id === "child-1");
+      const standalone = nodes.find((n) => n.id === "standalone");
+      const parent = getNodeParent(child, nodes);
+      expect(parent?.id).toBe("parent-1");
+      const standaloneParent = getNodeParent(standalone, nodes);
+      expect(standaloneParent).toBeUndefined();
+    });
+  });
+  describe("Export/Import", () => {
+    const testNodes = [
+      { id: "1", type: "input", position: { x: 0, y: 0 }, data: { label: "Start" } },
+      { id: "2", type: "default", position: { x: 100, y: 100 }, data: { label: "Process" } }
+    ];
+    const testEdges = [{ id: "e1", source: "1", target: "2", type: "bezier" }];
+    it("should export flow data as JSON", () => {
+      const json = exportFlowData(testNodes, testEdges, { x: 0, y: 0, zoom: 1 });
+      expect(json).toContain('"nodes"');
+      expect(json).toContain('"edges"');
+      expect(json).toContain('"viewport"');
+      expect(json).toContain('"version"');
+    });
+    it("should import flow data from JSON", () => {
+      const json = JSON.stringify({
+        nodes: testNodes,
+        edges: testEdges,
+        viewport: { x: 0, y: 0, zoom: 1 }
+      });
+      const data = importFlowData(json);
+      expect(data).not.toBeNull();
+      expect(data?.nodes.length).toBe(2);
+      expect(data?.edges.length).toBe(1);
+    });
+    it("should return null for invalid JSON", () => {
+      const data = importFlowData("invalid json");
+      expect(data).toBeNull();
+    });
+    it("should return null for empty nodes array", () => {
+      const json = JSON.stringify({ edges: [] });
+      const data = importFlowData(json);
+      expect(data).toBeNull();
+    });
+  });
+  describe("clearCustomTypes", () => {
+    it("should clear all registered types", () => {
+      registerCustomNodeTemplate({
+        type: "test-node",
+        component: MockComponent
+      });
+      registerCustomEdge({
+        type: "test-edge",
+        component: MockComponent
+      });
+      registerEdgeTemplate({
+        type: "test-edge-template",
+        animated: true
+      });
+      clearCustomTypes();
+      expect(hasCustomNodeTemplate("test-node")).toBe(false);
+      expect(hasCustomEdge("test-edge")).toBe(false);
+      expect(getEdgeTemplate("test-edge-template")).toBeUndefined();
+    });
+  });
+});