@divmain/jdm-asm 0.2.0

package/tests/unit/compiler/graph-scalability.test.ts

@@ -0,0 +1,510 @@
+/**
+ * Unit tests for graph module scalability and complex topologies
+ */
+
+import { describe, it, expect } from 'vitest';
+import { buildGraph, validateGraph, getEvaluationOrder } from '../../../src/compiler/graph';
+import type { JDMDecision, JDMNode, JDMEdge } from '../../../src/compiler/parser';
+import { NodeType } from '../../../src/compiler/parser';
+
+function createTestGraph(
+  nodes: Array<{ id: string }>,
+  edges: Array<{ id: string; sourceId: string; targetId: string }>,
+  options?: { hasInput?: boolean; hasOutput?: boolean },
+): JDMDecision {
+  const jdmNodes: JDMNode[] = [];
+
+  // Add input node first if needed
+  if (options?.hasInput !== false) {
+    jdmNodes.unshift({
+      id: 'input',
+      type: NodeType.INPUT,
+      name: 'Input',
+      position: { x: 0, y: 0 },
+    });
+  }
+
+  // Add user-provided nodes as decision nodes
+  for (const n of nodes) {
+    jdmNodes.push({
+      id: n.id,
+      type: NodeType.DECISION,
+      name: n.id,
+      position: { x: 0, y: 0 },
+    });
+  }
+
+  // Add output node last if needed
+  if (options?.hasOutput !== false) {
+    jdmNodes.push({
+      id: 'output',
+      type: NodeType.OUTPUT,
+      name: 'Output',
+      position: { x: 0, y: 0 },
+    });
+  }
+
+  const jdmEdges: JDMEdge[] = edges.map((e) => ({
+    id: e.id,
+    type: 'edge',
+    sourceId: e.sourceId,
+    targetId: e.targetId,
+  }));
+
+  return {
+    nodes: jdmNodes,
+    edges: jdmEdges,
+  };
+}
+
+describe('Graph Module - Scaling Tests', () => {
+  describe('Large Graph Support (5+ decision nodes)', () => {
+    it('should handle linear chain of 10 decision nodes', () => {
+      const nodes: Array<{ id: string }> = [
+        { id: 'node1' },
+        { id: 'node2' },
+        { id: 'node3' },
+        { id: 'node4' },
+        { id: 'node5' },
+        { id: 'node6' },
+        { id: 'node7' },
+        { id: 'node8' },
+        { id: 'node9' },
+        { id: 'node10' },
+      ];
+
+      const edges: Array<{ id: string; sourceId: string; targetId: string }> = [
+        { id: 'e1', sourceId: 'input', targetId: 'node1' },
+        { id: 'e2', sourceId: 'node1', targetId: 'node2' },
+        { id: 'e3', sourceId: 'node2', targetId: 'node3' },
+        { id: 'e4', sourceId: 'node3', targetId: 'node4' },
+        { id: 'e5', sourceId: 'node4', targetId: 'node5' },
+        { id: 'e6', sourceId: 'node5', targetId: 'node6' },
+        { id: 'e7', sourceId: 'node6', targetId: 'node7' },
+        { id: 'e8', sourceId: 'node7', targetId: 'node8' },
+        { id: 'e9', sourceId: 'node8', targetId: 'node9' },
+        { id: 'e10', sourceId: 'node9', targetId: 'node10' },
+        { id: 'e11', sourceId: 'node10', targetId: 'output' },
+      ];
+
+      const jdm = createTestGraph(nodes, edges);
+      const graph = buildGraph(jdm);
+
+      validateGraph(graph);
+
+      const order = getEvaluationOrder(graph);
+      expect(order.length).toBeGreaterThan(nodes.length);
+
+      // Verify linear ordering
+      expect(order.indexOf('input')).toBeLessThan(order.indexOf('node1'));
+      expect(order.indexOf('node1')).toBeLessThan(order.indexOf('node2'));
+      expect(order.indexOf('node9')).toBeLessThan(order.indexOf('node10'));
+      expect(order.indexOf('node10')).toBeLessThan(order.indexOf('output'));
+    });
+
+    it('should handle complex DAG with 20+ nodes', () => {
+      const nodeCount = 20;
+      const nodes: Array<{ id: string }> = [];
+      for (let i = 0; i < nodeCount; i++) {
+        nodes.push({ id: `node${i}` });
+      }
+
+      const edges: Array<{ id: string; sourceId: string; targetId: string }> = [
+        { id: 'e-in', sourceId: 'input', targetId: 'node0' },
+      ];
+
+      // Create a mesh-like structure where each node connects to the next few nodes
+      for (let i = 0; i < nodeCount; i++) {
+        const connections = Math.min(3, nodeCount - i - 1);
+        for (let j = 1; j <= connections; j++) {
+          edges.push({
+            id: `e-${i}-${i + j}`,
+            sourceId: `node${i}`,
+            targetId: `node${i + j}`,
+          });
+        }
+      }
+
+      edges.push({ id: 'e-out', sourceId: `node${nodeCount - 1}`, targetId: 'output' });
+
+      const jdm = createTestGraph(nodes, edges);
+      const graph = buildGraph(jdm);
+
+      // Should validate without errors (no cycles, proper structure)
+      validateGraph(graph);
+
+      const order = getEvaluationOrder(graph);
+      expect(order.length).toBeGreaterThan(nodeCount);
+
+      // Topological ordering is respected
+      expect(order.indexOf('input')).toBeLessThan(order.indexOf('node0'));
+      expect(order.indexOf(`node${nodeCount - 1}`)).toBeLessThan(order.indexOf('output'));
+    });
+
+    it('should handle tree-like structure with 15 nodes', () => {
+      const nodes: Array<{ id: string }> = [
+        { id: 'root' },
+        // Level 1
+        { id: 'branch1' },
+        { id: 'branch2' },
+        { id: 'branch3' },
+        // Level 2
+        { id: 'leaf1-1' },
+        { id: 'leaf1-2' },
+        { id: 'leaf2-1' },
+        { id: 'leaf2-2' },
+        { id: 'leaf3-1' },
+        // Level 3
+        { id: 'subleaf1-1-1' },
+        { id: 'subleaf1-1-2' },
+        { id: 'subleaf2-1-1' },
+        { id: 'subleaf2-1-2' },
+        { id: 'subleaf3-1-1' },
+      ];
+
+      const edges: Array<{ id: string; sourceId: string; targetId: string }> = [
+        // Input to root
+        { id: 'e-in', sourceId: 'input', targetId: 'root' },
+        // Root to branches
+        { id: 'e-r-1', sourceId: 'root', targetId: 'branch1' },
+        { id: 'e-r-2', sourceId: 'root', targetId: 'branch2' },
+        { id: 'e-r-3', sourceId: 'root', targetId: 'branch3' },
+        // Branch 1 to leaves
+        { id: 'e-b1-l1', sourceId: 'branch1', targetId: 'leaf1-1' },
+        { id: 'e-b1-l2', sourceId: 'branch1', targetId: 'leaf1-2' },
+        // Branch 2 to leaves
+        { id: 'e-b2-l1', sourceId: 'branch2', targetId: 'leaf2-1' },
+        { id: 'e-b2-l2', sourceId: 'branch2', targetId: 'leaf2-2' },
+        // Branch 3 to leaf
+        { id: 'e-b3-l1', sourceId: 'branch3', targetId: 'leaf3-1' },
+        // Leaves to subleaves
+        { id: 'e-l1-1-s1', sourceId: 'leaf1-1', targetId: 'subleaf1-1-1' },
+        { id: 'e-l1-1-s2', sourceId: 'leaf1-1', targetId: 'subleaf1-1-2' },
+        { id: 'e-l2-1-s1', sourceId: 'leaf2-1', targetId: 'subleaf2-1-1' },
+        { id: 'e-l2-1-s2', sourceId: 'leaf2-1', targetId: 'subleaf2-1-2' },
+        { id: 'e-l3-1-s1', sourceId: 'leaf3-1', targetId: 'subleaf3-1-1' },
+        // Subleaves to output
+        { id: 'e-out1', sourceId: 'subleaf1-1-1', targetId: 'output' },
+        { id: 'e-out2', sourceId: 'subleaf2-1-1', targetId: 'output' },
+        { id: 'e-out3', sourceId: 'subleaf3-1-1', targetId: 'output' },
+      ];
+
+      const jdm = createTestGraph(nodes, edges);
+      const graph = buildGraph(jdm);
+
+      validateGraph(graph);
+
+      const order = getEvaluationOrder(graph);
+
+      // Verify tree ordering is respected
+      expect(order.indexOf('input')).toBeLessThan(order.indexOf('root'));
+      expect(order.indexOf('root')).toBeLessThan(order.indexOf('branch1'));
+      expect(order.indexOf('root')).toBeLessThan(order.indexOf('branch2'));
+      expect(order.indexOf('branch1')).toBeLessThan(order.indexOf('leaf1-1'));
+      expect(order.indexOf('leaf1-1')).toBeLessThan(order.indexOf('subleaf1-1-1'));
+      expect(order.indexOf('subleaf1-1-1')).toBeLessThan(order.indexOf('output'));
+    });
+  });
+
+  describe('Various Graph Topologies', () => {
+    it('should correctly topologically sort diamond pattern (4 decision nodes)', () => {
+      const nodes: Array<{ id: string }> = [
+        { id: 'node-a' },
+        { id: 'node-b' },
+        { id: 'node-c' },
+        { id: 'node-shared' },
+      ];
+
+      const edges: Array<{ id: string; sourceId: string; targetId: string }> = [
+        { id: 'e-1', sourceId: 'input', targetId: 'node-a' },
+        { id: 'e-2', sourceId: 'node-a', targetId: 'node-b' },
+        { id: 'e-3', sourceId: 'node-a', targetId: 'node-c' },
+        { id: 'e-4', sourceId: 'node-b', targetId: 'node-shared' },
+        { id: 'e-5', sourceId: 'node-c', targetId: 'node-shared' },
+        { id: 'e-6', sourceId: 'node-shared', targetId: 'output' },
+      ];
+
+      const jdm = createTestGraph(nodes, edges);
+      const graph = buildGraph(jdm);
+
+      const order = getEvaluationOrder(graph);
+
+      // Diamond ordering: a comes before both b and c, both come before shared
+      expect(order.indexOf('node-a')).toBeLessThan(order.indexOf('node-b'));
+      expect(order.indexOf('node-a')).toBeLessThan(order.indexOf('node-c'));
+      expect(order.indexOf('node-b')).toBeLessThan(order.indexOf('node-shared'));
+      expect(order.indexOf('node-c')).toBeLessThan(order.indexOf('node-shared'));
+      expect(order.indexOf('node-shared')).toBeLessThan(order.indexOf('output'));
+    });
+
+    it('should correctly handle star pattern (fan-out then fan-in)', () => {
+      const nodes: Array<{ id: string }> = [
+        { id: 'start' },
+        { id: 'worker1' },
+        { id: 'worker2' },
+        { id: 'worker3' },
+        { id: 'worker4' },
+        { id: 'worker5' },
+        { id: 'end' },
+      ];
+
+      const edges: Array<{ id: string; sourceId: string; targetId: string }> = [
+        { id: 'e-in', sourceId: 'input', targetId: 'start' },
+        { id: 'e-1', sourceId: 'start', targetId: 'worker1' },
+        { id: 'e-2', sourceId: 'start', targetId: 'worker2' },
+        { id: 'e-3', sourceId: 'start', targetId: 'worker3' },
+        { id: 'e-4', sourceId: 'start', targetId: 'worker4' },
+        { id: 'e-5', sourceId: 'start', targetId: 'worker5' },
+        { id: 'e-6', sourceId: 'worker1', targetId: 'end' },
+        { id: 'e-7', sourceId: 'worker2', targetId: 'end' },
+        { id: 'e-8', sourceId: 'worker3', targetId: 'end' },
+        { id: 'e-9', sourceId: 'worker4', targetId: 'end' },
+        { id: 'e-10', sourceId: 'worker5', targetId: 'end' },
+        { id: 'e-out', sourceId: 'end', targetId: 'output' },
+      ];
+
+      const jdm = createTestGraph(nodes, edges);
+      const graph = buildGraph(jdm);
+
+      validateGraph(graph);
+
+      const order = getEvaluationOrder(graph);
+
+      // All workers come after start, and end comes after all workers
+      expect(order.indexOf('start')).toBeLessThan(order.indexOf('worker1'));
+      expect(order.indexOf('start')).toBeLessThan(order.indexOf('worker2'));
+      expect(order.indexOf('start')).toBeLessThan(order.indexOf('worker3'));
+      expect(order.indexOf('start')).toBeLessThan(order.indexOf('worker4'));
+      expect(order.indexOf('start')).toBeLessThan(order.indexOf('worker5'));
+
+      expect(order.indexOf('worker1')).toBeLessThan(order.indexOf('end'));
+      expect(order.indexOf('worker2')).toBeLessThan(order.indexOf('end'));
+      expect(order.indexOf('worker3')).toBeLessThan(order.indexOf('end'));
+      expect(order.indexOf('worker4')).toBeLessThan(order.indexOf('end'));
+      expect(order.indexOf('worker5')).toBeLessThan(order.indexOf('end'));
+    });
+
+    it('should handle multiple diamond patterns merged together', () => {
+      const nodes: Array<{ id: string }> = [
+        { id: 'stage1' },
+        // First diamond
+        { id: 'd1-a' },
+        { id: 'd1-b' },
+        { id: 'd1-shared' },
+        // Second diamond
+        { id: 'd2-a' },
+        { id: 'd2-b' },
+        { id: 'd2-shared' },
+        // Final stage
+        { id: 'stage2' },
+      ];
+
+      const edges: Array<{ id: string; sourceId: string; targetId: string }> = [
+        // Input to stage1
+        { id: 'e-in1', sourceId: 'input', targetId: 'stage1' },
+
+        // First diamond
+        { id: 'e-d1-a', sourceId: 'stage1', targetId: 'd1-a' },
+        { id: 'e-d1-b', sourceId: 'stage1', targetId: 'd1-b' },
+        { id: 'e-d1-in', sourceId: 'd1-a', targetId: 'd1-shared' },
+        { id: 'e-d1-in2', sourceId: 'd1-b', targetId: 'd1-shared' },
+
+        // Second diamond (feeds from first)
+        { id: 'e-d2-a', sourceId: 'd1-shared', targetId: 'd2-a' },
+        { id: 'e-d2-b', sourceId: 'd1-shared', targetId: 'd2-b' },
+        { id: 'e-d2-in', sourceId: 'd2-a', targetId: 'd2-shared' },
+        { id: 'e-d2-in2', sourceId: 'd2-b', targetId: 'd2-shared' },
+
+        // To final stage
+        { id: 'e-stage2', sourceId: 'd2-shared', targetId: 'stage2' },
+        { id: 'e-out', sourceId: 'stage2', targetId: 'output' },
+      ];
+
+      const jdm = createTestGraph(nodes, edges);
+      const graph = buildGraph(jdm);
+
+      validateGraph(graph);
+
+      const order = getEvaluationOrder(graph);
+
+      // Verify ordering through both diamonds
+      expect(order.indexOf('stage1')).toBeLessThan(order.indexOf('d1-a'));
+      expect(order.indexOf('d1-b')).toBeLessThan(order.indexOf('d1-shared'));
+      expect(order.indexOf('d1-shared')).toBeLessThan(order.indexOf('d2-a'));
+      expect(order.indexOf('d2-shared')).toBeLessThan(order.indexOf('stage2'));
+    });
+  });
+
+  describe('Error Messages at Scale', () => {
+    it('should provide clear cycle detection message for large graph', () => {
+      // Create a cycle in a larger graph
+      const nodes: Array<{ id: string }> = [
+        { id: 'n1' },
+        { id: 'n2' },
+        { id: 'n3' },
+        { id: 'n4' },
+        { id: 'n5' },
+      ];
+
+      const edges: Array<{ id: string; sourceId: string; targetId: string }> = [
+        { id: 'e1', sourceId: 'input', targetId: 'n1' },
+        { id: 'e2', sourceId: 'n1', targetId: 'n2' },
+        { id: 'e3', sourceId: 'n2', targetId: 'n3' },
+        { id: 'e4', sourceId: 'n3', targetId: 'n4' },
+        { id: 'e5', sourceId: 'n4', targetId: 'n5' },
+        // Add a cycle back to n2
+        { id: 'e6', sourceId: 'n5', targetId: 'n2' },
+        { id: 'e7', sourceId: 'n5', targetId: 'output' },
+      ];
+
+      const jdm = createTestGraph(nodes, edges);
+      const graph = buildGraph(jdm);
+
+      // Should throw with clear cycle message
+      expect(() => validateGraph(graph)).toThrow('Circular dependency detected');
+
+      try {
+        validateGraph(graph);
+      } catch (error) {
+        const message = (error as Error).message;
+        // Should include the cycle path
+        expect(message).toContain('Circular dependency detected');
+      }
+    });
+
+    it('should allow multiple output nodes', () => {
+      const jdm: JDMDecision = {
+        nodes: [
+          { id: 'input', type: NodeType.INPUT, name: 'Input', position: { x: 0, y: 0 } },
+          { id: 'n1', type: NodeType.DECISION, name: 'n1', position: { x: 0, y: 0 } },
+          { id: 'n2', type: NodeType.DECISION, name: 'n2', position: { x: 0, y: 0 } },
+          { id: 'n3', type: NodeType.DECISION, name: 'n3', position: { x: 0, y: 0 } },
+          { id: 'output1', type: NodeType.OUTPUT, name: 'Output1', position: { x: 0, y: 0 } },
+          { id: 'output2', type: NodeType.OUTPUT, name: 'Output2', position: { x: 0, y: 0 } },
+        ],
+        edges: [
+          { id: 'e1', type: 'edge', sourceId: 'input', targetId: 'n1' },
+          { id: 'e2', type: 'edge', sourceId: 'n1', targetId: 'output1' },
+          { id: 'e3', type: 'edge', sourceId: 'n1', targetId: 'output2' },
+        ],
+      };
+
+      const graph = buildGraph(jdm);
+
+      // Should not throw - multiple outputs are allowed (only single input is enforced)
+      validateGraph(graph);
+    });
+
+    it('should error on multiple input nodes', () => {
+      const jdm: JDMDecision = {
+        nodes: [
+          { id: 'input1', type: NodeType.INPUT, name: 'Input1', position: { x: 0, y: 0 } },
+          { id: 'input2', type: NodeType.INPUT, name: 'Input2', position: { x: 0, y: 0 } },
+          { id: 'n1', type: NodeType.DECISION, name: 'n1', position: { x: 0, y: 0 } },
+          { id: 'output', type: NodeType.OUTPUT, name: 'Output', position: { x: 0, y: 0 } },
+        ],
+        edges: [
+          { id: 'e1', type: 'edge', sourceId: 'input1', targetId: 'n1' },
+          { id: 'e2', type: 'edge', sourceId: 'input2', targetId: 'n1' },
+          { id: 'e3', type: 'edge', sourceId: 'n1', targetId: 'output' },
+        ],
+      };
+
+      const graph = buildGraph(jdm);
+
+      // Should throw on multiple input nodes
+      expect(() => validateGraph(graph)).toThrow('Expected exactly 1 input node');
+      try {
+        validateGraph(graph);
+      } catch (error) {
+        const message = (error as Error).message;
+        expect(message).toContain('Expected exactly 1 input node');
+        expect(message).toContain('found 2');
+      }
+    });
+  });
+
+  describe('Performance Considerations', () => {
+    it('should build 50-node graph', () => {
+      const nodeCount = 50;
+      const nodes: Array<{ id: string }> = [];
+      for (let i = 0; i < nodeCount; i++) {
+        nodes.push({ id: `node${i}` });
+      }
+
+      const edges: Array<{ id: string; sourceId: string; targetId: string }> = [
+        { id: 'e-in', sourceId: 'input', targetId: 'node0' },
+      ];
+
+      // Create a chain with some branching
+      for (let i = 0; i < nodeCount - 1; i++) {
+        edges.push({
+          id: `e-${i}-${i + 1}`,
+          sourceId: `node${i}`,
+          targetId: `node${i + 1}`,
+        });
+
+        // Add some cross-links for complexity
+        if (i > 0 && i % 5 === 0) {
+          edges.push({
+            id: `e-cross-${i}`,
+            sourceId: `node${i - 2}`,
+            targetId: `node${i + 1}`,
+          });
+        }
+      }
+
+      edges.push({ id: 'e-out', sourceId: `node${nodeCount - 1}`, targetId: 'output' });
+
+      const jdm = createTestGraph(nodes, edges);
+
+      const graph = buildGraph(jdm);
+      validateGraph(graph);
+
+      // Verify the graph was built correctly
+      const order = getEvaluationOrder(graph);
+      expect(order.length).toBeGreaterThan(nodeCount);
+      expect(order).toContain('input');
+      expect(order).toContain('output');
+      expect(order).toContain('node0');
+      expect(order).toContain(`node${nodeCount - 1}`);
+    });
+
+    it('should handle dense graph (many edges between many nodes)', () => {
+      const nodeCount = 30;
+      const nodes: Array<{ id: string }> = [];
+      for (let i = 0; i < nodeCount; i++) {
+        nodes.push({ id: `node${i}` });
+      }
+
+      const edges: Array<{ id: string; sourceId: string; targetId: string }> = [
+        { id: 'e-in', sourceId: 'input', targetId: 'node0' },
+      ];
+
+      // Create a complete graph where each node connects to all higher-numbered nodes
+      let edgeId = 1;
+      for (let i = 0; i < nodeCount; i++) {
+        for (let j = i + 1; j < Math.min(i + 5, nodeCount); j++) {
+          edges.push({
+            id: `e-${edgeId++}`,
+            sourceId: `node${i}`,
+            targetId: `node${j}`,
+          });
+        }
+      }
+
+      edges.push({ id: `e-${edgeId}`, sourceId: `node${nodeCount - 1}`, targetId: 'output' });
+
+      const jdm = createTestGraph(nodes, edges);
+
+      const graph = buildGraph(jdm);
+      validateGraph(graph);
+      const order = getEvaluationOrder(graph);
+
+      // All nodes should be in the order
+      for (const node of nodes) {
+        expect(order).toContain(node.id);
+      }
+    });
+  });
+});