@stephen-netu/design-system 0.1.0 → 0.2.0

package/src/n0-node-graph/validate.test.ts

@@ -1,722 +0,0 @@
-// N0 Node Graph — Validation Tests
-// Uses Vitest — deterministic test data only
-
-import { describe, it, expect } from 'vitest';
-import { validateGraph } from './validate';
-import type { GraphSchema, NodeDefinition, NodeInstance, EdgeDefinition } from './types';
-
-// Deterministic test data factories — no Math.random() or Date.now()
-
-function createMinimalNodeDefinition(): NodeDefinition {
-  return {
-    kind: 'test:task',
-    label: 'Task Node',
-    description: 'A test task node',
-    ports: [
-      {
-        id: 'input',
-        label: 'Input',
-        type: 'app:test:task' as const,
-        direction: 'input' as const,
-        required: false,
-        maxConnections: 1,
-      },
-      {
-        id: 'output',
-        label: 'Output',
-        type: 'app:test:task' as const,
-        direction: 'output' as const,
-        required: false,
-        maxConnections: Infinity,
-      },
-    ],
-    metadata: {},
-  };
-}
-
-function createMinimalNodeInstance(id: string, kind: string = 'test:task'): NodeInstance {
-  return {
-    id,
-    kind,
-    position: { x: 0, y: 0 },
-    size: { width: 100, height: 50 },
-    data: {},
-    collapsed: false,
-  };
-}
-
-function createMinimalEdge(
-  id: string,
-  sourceNodeId: string,
-  sourcePortId: string,
-  targetNodeId: string,
-  targetPortId: string
-): EdgeDefinition {
-  return {
-    id,
-    sourceNodeId,
-    sourcePortId,
-    targetNodeId,
-    targetPortId,
-    metadata: {},
-  };
-}
-
-function createValidGraph(): GraphSchema {
-  const nodeDef = createMinimalNodeDefinition();
-  return {
-    id: 'graph-001',
-    name: 'Valid Test Graph',
-    version: '1.0.0',
-    nodeDefinitions: [nodeDef],
-    nodes: [
-      createMinimalNodeInstance('node-1'),
-      createMinimalNodeInstance('node-2'),
-    ],
-    edges: [
-      createMinimalEdge('edge-1', 'node-1', 'output', 'node-2', 'input'),
-    ],
-  };
-}
-
-// === Valid Graph Tests ===
-
-describe('validateGraph — valid graphs', () => {
-  it('passes for a valid minimal graph', () => {
-    const graph = createValidGraph();
-    const result = validateGraph(graph);
-    expect(result.valid).toBe(true);
-    expect(result.errors).toHaveLength(0);
-  });
-
-  it('passes for an empty graph', () => {
-    const graph: GraphSchema = {
-      id: 'empty-graph',
-      name: 'Empty Graph',
-      version: '1.0.0',
-      nodeDefinitions: [createMinimalNodeDefinition()],
-      nodes: [],
-      edges: [],
-    };
-    const result = validateGraph(graph);
-    expect(result.valid).toBe(true);
-    expect(result.errors).toHaveLength(0);
-  });
-
-  it('passes for a single node with no edges', () => {
-    const graph: GraphSchema = {
-      id: 'single-node-graph',
-      name: 'Single Node Graph',
-      version: '1.0.0',
-      nodeDefinitions: [createMinimalNodeDefinition()],
-      nodes: [createMinimalNodeInstance('node-1')],
-      edges: [],
-    };
-    const result = validateGraph(graph);
-    expect(result.valid).toBe(true);
-    expect(result.errors).toHaveLength(0);
-  });
-
-  it('passes for disconnected subgraphs (multiple node groups without edges)', () => {
-    const graph: GraphSchema = {
-      id: 'disconnected-graph',
-      name: 'Disconnected Graph',
-      version: '1.0.0',
-      nodeDefinitions: [createMinimalNodeDefinition()],
-      nodes: [
-        createMinimalNodeInstance('node-1'),
-        createMinimalNodeInstance('node-2'),
-        createMinimalNodeInstance('node-3'),
-        createMinimalNodeInstance('node-4'),
-      ],
-      // Only connect node-1 to node-2, leaving 3 and 4 disconnected
-      edges: [
-        createMinimalEdge('edge-1', 'node-1', 'output', 'node-2', 'input'),
-      ],
-    };
-    const result = validateGraph(graph);
-    expect(result.valid).toBe(true);
-    expect(result.errors).toHaveLength(0);
-  });
-});
-
-// === Rule 1: Node kind references ===
-
-describe('validateGraph — Rule 1: Node kind must reference registered definition', () => {
-  it('fails when node kind is not registered', () => {
-    const graph: GraphSchema = {
-      id: 'invalid-kind-graph',
-      name: 'Invalid Kind Graph',
-      version: '1.0.0',
-      nodeDefinitions: [createMinimalNodeDefinition()],
-      nodes: [
-        {
-          id: 'node-1',
-          kind: 'nonexistent:kind',
-          position: { x: 0, y: 0 },
-          size: { width: 100, height: 50 },
-          data: {},
-          collapsed: false,
-        },
-      ],
-      edges: [],
-    };
-    const result = validateGraph(graph);
-    expect(result.valid).toBe(false);
-    expect(result.errors).toContainEqual(
-      expect.objectContaining({
-        code: 'INVALID_NODE_KIND',
-        message: expect.stringContaining('nonexistent:kind'),
-        nodeId: 'node-1',
-      })
-    );
-  });
-});
-
-// === Rule 2: Edge connections ===
-
-describe('validateGraph — Rule 2: Edges must connect existing nodes and port', () => {
-  it('fails when edge references non-existent source node', () => {
-    const graph: GraphSchema = {
-      id: 'invalid-source-node',
-      name: 'Invalid Source Node',
-      version: '1.0.0',
-      nodeDefinitions: [createMinimalNodeDefinition()],
-      nodes: [createMinimalNodeInstance('node-1')],
-      edges: [
-        createMinimalEdge('edge-1', 'nonexistent-node', 'output', 'node-1', 'input'),
-      ],
-    };
-    const result = validateGraph(graph);
-    expect(result.valid).toBe(false);
-    expect(result.errors).toContainEqual(
-      expect.objectContaining({
-        code: 'INVALID_SOURCE_NODE',
-      })
-    );
-  });
-
-  it('fails when edge references non-existent target node', () => {
-    const graph: GraphSchema = {
-      id: 'invalid-target-node',
-      name: 'Invalid Target Node',
-      version: '1.0.0',
-      nodeDefinitions: [createMinimalNodeDefinition()],
-      nodes: [createMinimalNodeInstance('node-1')],
-      edges: [
-        createMinimalEdge('edge-1', 'node-1', 'output', 'nonexistent-node', 'input'),
-      ],
-    };
-    const result = validateGraph(graph);
-    expect(result.valid).toBe(false);
-    expect(result.errors).toContainEqual(
-      expect.objectContaining({
-        code: 'INVALID_TARGET_NODE',
-      })
-    );
-  });
-
-  it('fails when edge references non-existent source port', () => {
-    const graph: GraphSchema = {
-      id: 'invalid-source-port',
-      name: 'Invalid Source Port',
-      version: '1.0.0',
-      nodeDefinitions: [createMinimalNodeDefinition()],
-      nodes: [
-        createMinimalNodeInstance('node-1'),
-        createMinimalNodeInstance('node-2'),
-      ],
-      edges: [
-        createMinimalEdge('edge-1', 'node-1', 'nonexistent-port', 'node-2', 'input'),
-      ],
-    };
-    const result = validateGraph(graph);
-    expect(result.valid).toBe(false);
-    expect(result.errors).toContainEqual(
-      expect.objectContaining({
-        code: 'INVALID_SOURCE_PORT',
-      })
-    );
-  });
-
-  it('fails when edge references non-existent target port', () => {
-    const graph: GraphSchema = {
-      id: 'invalid-target-port',
-      name: 'Invalid Target Port',
-      version: '1.0.0',
-      nodeDefinitions: [createMinimalNodeDefinition()],
-      nodes: [
-        createMinimalNodeInstance('node-1'),
-        createMinimalNodeInstance('node-2'),
-      ],
-      edges: [
-        createMinimalEdge('edge-1', 'node-1', 'output', 'node-2', 'nonexistent-port'),
-      ],
-    };
-    const result = validateGraph(graph);
-    expect(result.valid).toBe(false);
-    expect(result.errors).toContainEqual(
-      expect.objectContaining({
-        code: 'INVALID_TARGET_PORT',
-      })
-    );
-  });
-});
-
-// === Rule 3: Port direction ===
-
-describe('validateGraph — Rule 3: Port direction (output → input only)', () => {
-  it('fails when edge goes from input to output', () => {
-    const nodeDef: NodeDefinition = {
-      kind: 'test:task',
-      label: 'Task Node',
-      description: 'A test task node',
-      ports: [
-        {
-          id: 'input',
-          label: 'Input',
-          type: 'app:test:task' as const,
-          direction: 'input' as const,
-          required: false,
-          maxConnections: 1,
-        },
-        {
-          id: 'output',
-          label: 'Output',
-          type: 'app:test:task' as const,
-          direction: 'output' as const,
-          required: false,
-          maxConnections: Infinity,
-        },
-      ],
-      metadata: {},
-    };
-    
-    const graph: GraphSchema = {
-      id: 'wrong-direction',
-      name: 'Wrong Direction',
-      version: '1.0.0',
-      nodeDefinitions: [nodeDef],
-      nodes: [
-        createMinimalNodeInstance('node-1'),
-        createMinimalNodeInstance('node-2'),
-      ],
-      edges: [
-        // Trying to connect input to output — wrong direction
-        createMinimalEdge('edge-1', 'node-1', 'input', 'node-2', 'output'),
-      ],
-    };
-    const result = validateGraph(graph);
-    expect(result.valid).toBe(false);
-    expect(result.errors).toContainEqual(
-      expect.objectContaining({
-        code: 'INVALID_PORT_DIRECTION',
-      })
-    );
-  });
-
-  it('fails when edge goes from output to output', () => {
-    const nodeDef: NodeDefinition = {
-      kind: 'test:task',
-      label: 'Task Node',
-      description: 'A test task node',
-      ports: [
-        {
-          id: 'input',
-          label: 'Input',
-          type: 'app:test:task' as const,
-          direction: 'input' as const,
-          required: false,
-          maxConnections: 1,
-        },
-        {
-          id: 'output',
-          label: 'Output',
-          type: 'app:test:task' as const,
-          direction: 'output' as const,
-          required: false,
-          maxConnections: Infinity,
-        },
-      ],
-      metadata: {},
-    };
-    
-    const graph: GraphSchema = {
-      id: 'wrong-direction-2',
-      name: 'Wrong Direction 2',
-      version: '1.0.0',
-      nodeDefinitions: [nodeDef],
-      nodes: [
-        createMinimalNodeInstance('node-1'),
-        createMinimalNodeInstance('node-2'),
-      ],
-      edges: [
-        // Both are output ports — wrong direction
-        createMinimalEdge('edge-1', 'node-1', 'output', 'node-2', 'output'),
-      ],
-    };
-    const result = validateGraph(graph);
-    expect(result.valid).toBe(false);
-    expect(result.errors).toContainEqual(
-      expect.objectContaining({
-        code: 'INVALID_PORT_DIRECTION',
-      })
-    );
-  });
-});
-
-// === Rule 4: Type compatibility ===
-
-describe('validateGraph — Rule 4: Port type compatibility (exact match)', () => {
-  it('fails when source and target port types do not match', () => {
-    const nodeDef1: NodeDefinition = {
-      kind: 'test:task',
-      label: 'Task Node',
-      description: 'A test task node',
-      ports: [
-        {
-          id: 'output',
-          label: 'Output',
-          type: 'app:test:task' as const,
-          direction: 'output' as const,
-          required: false,
-          maxConnections: Infinity,
-        },
-      ],
-      metadata: {},
-    };
-    
-    const nodeDef2: NodeDefinition = {
-      kind: 'test:signal',
-      label: 'Signal Node',
-      description: 'A test signal node',
-      ports: [
-        {
-          id: 'input',
-          label: 'Input',
-          type: 'app:test:signal' as const,
-          direction: 'input' as const,
-          required: false,
-          maxConnections: 1,
-        },
-      ],
-      metadata: {},
-    };
-    
-    const graph: GraphSchema = {
-      id: 'type-mismatch',
-      name: 'Type Mismatch',
-      version: '1.0.0',
-      nodeDefinitions: [nodeDef1, nodeDef2],
-      nodes: [
-        { ...createMinimalNodeInstance('node-1', 'test:task'), ports: undefined } as NodeInstance,
-        { ...createMinimalNodeInstance('node-2', 'test:signal'), ports: undefined } as NodeInstance,
-      ],
-      edges: [
-        createMinimalEdge('edge-1', 'node-1', 'output', 'node-2', 'input'),
-      ],
-    };
-    const result = validateGraph(graph);
-    expect(result.valid).toBe(false);
-    expect(result.errors).toContainEqual(
-      expect.objectContaining({
-        code: 'TYPE_MISMATCH',
-        message: expect.stringMatching(/app:test:(task|signal)/),
-      })
-    );
-  });
-});
-
-// === Rule 5: Connection limits ===
-
-describe('validateGraph — Rule 5: Connection limits (maxConnections)', () => {
-  it('fails when input port maxConnections is exceeded', () => {
-    const nodeDef: NodeDefinition = {
-      kind: 'test:task',
-      label: 'Task Node',
-      description: 'A test task node',
-      ports: [
-        {
-          id: 'input',
-          label: 'Input',
-          type: 'app:test:task' as const,
-          direction: 'input' as const,
-          required: false,
-          maxConnections: 1, // Only allows 1 connection
-        },
-        {
-          id: 'output',
-          label: 'Output',
-          type: 'app:test:task' as const,
-          direction: 'output' as const,
-          required: false,
-          maxConnections: Infinity,
-        },
-      ],
-      metadata: {},
-    };
-    
-    const graph: GraphSchema = {
-      id: 'max-connections',
-      name: 'Max Connections',
-      version: '1.0.0',
-      nodeDefinitions: [nodeDef],
-      nodes: [
-        createMinimalNodeInstance('node-1'), // Source
-        createMinimalNodeInstance('node-2'), // Target 1
-        createMinimalNodeInstance('node-3'), // Target 2 - exceeds limit
-      ],
-      edges: [
-        createMinimalEdge('edge-1', 'node-1', 'output', 'node-2', 'input'),
-        createMinimalEdge('edge-2', 'node-1', 'output', 'node-2', 'input'), // 2 connections to same port - exceeds maxConnections=1
-      ],
-    };
-    const result = validateGraph(graph);
-    expect(result.valid).toBe(false);
-    expect(result.errors).toContainEqual(
-      expect.objectContaining({
-        code: 'MAX_CONNECTIONS_EXCEEDED',
-        message: expect.stringMatching(/(1 connections|maximum allowed is 1)/),
-      })
-    );
-  });
-});
-
-// === Rule 6: Required ports ===
-
-describe('validateGraph — Rule 6: Required ports must have connections', () => {
-  it('fails when required input port has no connections', () => {
-    const nodeDef: NodeDefinition = {
-      kind: 'test:task',
-      label: 'Task Node',
-      description: 'A test task node',
-      ports: [
-        {
-          id: 'input',
-          label: 'Input',
-          type: 'app:test:task' as const,
-          direction: 'input' as const,
-          required: true, // Required!
-          maxConnections: 1,
-        },
-        {
-          id: 'output',
-          label: 'Output',
-          type: 'app:test:task' as const,
-          direction: 'output' as const,
-          required: false,
-          maxConnections: Infinity,
-        },
-      ],
-      metadata: {},
-    };
-    
-    const graph: GraphSchema = {
-      id: 'required-port',
-      name: 'Required Port',
-      version: '1.0.0',
-      nodeDefinitions: [nodeDef],
-      nodes: [createMinimalNodeInstance('node-1')],
-      edges: [], // No connections to the required input port
-    };
-    const result = validateGraph(graph);
-    expect(result.valid).toBe(false);
-    expect(result.errors.some(e => 
-      e.code === 'REQUIRED_PORT_UNCONNECTED' && 
-      e.nodeId === 'node-1' &&
-      e.portId === 'input'
-    )).toBe(true);
-  });
-
-  it('passes when required input port has at least one connection', () => {
-    const nodeDefRequired: NodeDefinition = {
-      kind: 'test:task',
-      label: 'Task Node',
-      description: 'A test task node',
-      ports: [
-        {
-          id: 'input',
-          label: 'Input',
-          type: 'app:test:task' as const,
-          direction: 'input' as const,
-          required: true,
-          maxConnections: 1,
-        },
-        {
-          id: 'output',
-          label: 'Output',
-          type: 'app:test:task' as const,
-          direction: 'output' as const,
-          required: false,
-          maxConnections: Infinity,
-        },
-      ],
-      metadata: {},
-    };
-
-    const nodeDefOptional: NodeDefinition = {
-      kind: 'test:task-optional',
-      label: 'Task Node Optional',
-      description: 'A test task node with optional input',
-      ports: [
-        {
-          id: 'input',
-          label: 'Input',
-          type: 'app:test:task' as const,
-          direction: 'input' as const,
-          required: false,
-          maxConnections: 1,
-        },
-        {
-          id: 'output',
-          label: 'Output',
-          type: 'app:test:task' as const,
-          direction: 'output' as const,
-          required: false,
-          maxConnections: Infinity,
-        },
-      ],
-      metadata: {},
-    };
-    
-    const graph: GraphSchema = {
-      id: 'required-port-ok',
-      name: 'Required Port OK',
-      version: '1.0.0',
-      nodeDefinitions: [nodeDefRequired, nodeDefOptional],
-      nodes: [
-        createMinimalNodeInstance('node-1', 'test:task-optional'),
-        createMinimalNodeInstance('node-2', 'test:task'),
-      ],
-      edges: [
-        createMinimalEdge('edge-1', 'node-1', 'output', 'node-2', 'input'),
-      ],
-    };
-    const result = validateGraph(graph);
-    expect(result.valid).toBe(true);
-    expect(result.errors).toHaveLength(0);
-  });
-});
-
-// === Rule 7: No self-loops ===
-
-describe('validateGraph — Rule 7: No self-loops', () => {
-  it('fails when edge connects node to itself', () => {
-    const graph: GraphSchema = {
-      id: 'self-loop',
-      name: 'Self Loop',
-      version: '1.0.0',
-      nodeDefinitions: [createMinimalNodeDefinition()],
-      nodes: [createMinimalNodeInstance('node-1')],
-      edges: [
-        // Self-loop: source and target are the same node
-        createMinimalEdge('edge-1', 'node-1', 'output', 'node-1', 'input'),
-      ],
-    };
-    const result = validateGraph(graph);
-    expect(result.valid).toBe(false);
-    expect(result.errors).toContainEqual(
-      expect.objectContaining({
-        code: 'SELF_LOOP',
-        message: expect.stringContaining('self-loop'),
-        edgeId: 'edge-1',
-      })
-    );
-  });
-});
-
-// === Rule 8: No duplicate edges ===
-
-describe('validateGraph — Rule 8: No duplicate edges', () => {
-  it('fails when duplicate edge exists (same source and target ports)', () => {
-    const graph: GraphSchema = {
-      id: 'duplicate-edge',
-      name: 'Duplicate Edge',
-      version: '1.0.0',
-      nodeDefinitions: [createMinimalNodeDefinition()],
-      nodes: [
-        createMinimalNodeInstance('node-1'),
-        createMinimalNodeInstance('node-2'),
-      ],
-      edges: [
-        createMinimalEdge('edge-1', 'node-1', 'output', 'node-2', 'input'),
-        // Duplicate: same source and target ports
-        createMinimalEdge('edge-2', 'node-1', 'output', 'node-2', 'input'),
-      ],
-    };
-    const result = validateGraph(graph);
-    expect(result.valid).toBe(false);
-    expect(result.errors).toContainEqual(
-      expect.objectContaining({
-        code: 'DUPLICATE_EDGE',
-        message: expect.stringContaining('duplicate'),
-      })
-    );
-  });
-
-  it('passes when edges connect different ports on same nodes', () => {
-    const graph: GraphSchema = {
-      id: 'different-ports',
-      name: 'Different Ports',
-      version: '1.0.0',
-      nodeDefinitions: [
-        {
-          kind: 'test:multi',
-          label: 'Multi Port Node',
-          description: 'Node with multiple ports',
-          ports: [
-            { id: 'input1', label: 'Input 1', type: 'app:test:task' as const, direction: 'input' as const, required: false, maxConnections: 1 },
-            { id: 'input2', label: 'Input 2', type: 'app:test:task' as const, direction: 'input' as const, required: false, maxConnections: 1 },
-            { id: 'output1', label: 'Output 1', type: 'app:test:task' as const, direction: 'output' as const, required: false, maxConnections: Infinity },
-            { id: 'output2', label: 'Output 2', type: 'app:test:task' as const, direction: 'output' as const, required: false, maxConnections: Infinity },
-          ],
-          metadata: {},
-        },
-      ],
-      nodes: [
-        createMinimalNodeInstance('node-1', 'test:multi'),
-        createMinimalNodeInstance('node-2', 'test:multi'),
-      ],
-      edges: [
-        createMinimalEdge('edge-1', 'node-1', 'output1', 'node-2', 'input1'),
-        createMinimalEdge('edge-2', 'node-1', 'output2', 'node-2', 'input2'), // Different ports, not duplicate
-      ],
-    };
-    const result = validateGraph(graph);
-    expect(result.valid).toBe(true);
-  });
-});
-
-// === Multiple validation errors ===
-
-describe('validateGraph — multiple errors', () => {
-  it('collects all errors from all rules', () => {
-    const graph: GraphSchema = {
-      id: 'multiple-errors',
-      name: 'Multiple Errors',
-      version: '1.0.0',
-      nodeDefinitions: [createMinimalNodeDefinition()],
-      nodes: [
-        {
-          id: 'node-1',
-          kind: 'nonexistent:kind', // Rule 1 error
-          position: { x: 0, y: 0 },
-          size: { width: 100, height: 50 },
-          data: {},
-          collapsed: false,
-        },
-        createMinimalNodeInstance('node-2'),
-      ],
-      edges: [
-        createMinimalEdge('edge-1', 'node-1', 'output', 'node-2', 'input'),
-        createMinimalEdge('edge-2', 'node-1', 'output', 'node-1', 'input'), // Rule 7: self-loop
-      ],
-    };
-    const result = validateGraph(graph);
-    expect(result.valid).toBe(false);
-    expect(result.errors.length).toBeGreaterThanOrEqual(2);
-    expect(result.errors.map(e => e.code).sort()).toEqual(
-      expect.arrayContaining(['INVALID_NODE_KIND', 'SELF_LOOP'].sort())
-    );
-  });
-});