elsabro 7.3.0 → 7.3.2

package/flow-engine/tests/executors-complex.test.js

@@ -180,6 +180,265 @@ describe('executeParallel', () => {
     );
     assert.equal(result3.next, 'interrupt_manual_fix');
   });
+
+  it('handles errorPolicy quorum with threshold - quorum met', async () => {
+    const callbacks = {
+      onParallel: async ({ branches }) => {
+        // 3 out of 4 branches succeed (75% success rate)
+        return [
+          { id: 'a', result: 'success' },
+          { id: 'b', result: 'success' },
+          { id: 'c', result: 'success' },
+          { id: 'd', error: 'failed', skipped: false }
+        ];
+      }
+    };
+
+    const ctx = makeContext();
+    const result = await executeParallel(
+      {
+        id: 'parallel_task',
+        type: 'parallel',
+        branches: [{ id: 'a' }, { id: 'b' }, { id: 'c' }, { id: 'd' }],
+        errorPolicy: 'quorum',
+        quorumThreshold: 0.5, // 50% threshold
+        next: 'success_node',
+        onError: 'error_node'
+      },
+      ctx,
+      callbacks
+    );
+
+    assert.equal(result.next, 'success_node');
+    assert.equal(result.outputs.quorumMet, true);
+    assert.equal(result.outputs.successCount, 3);
+    assert.equal(result.outputs.totalCount, 4);
+    assert.equal(result.outputs.failureCount, 1);
+    assert.equal(result.outputs.successRate, 0.75);
+    assert.equal(result.outputs.quorumType, 'threshold');
+  });
+
+  it('handles errorPolicy quorum with threshold - quorum failed', async () => {
+    const callbacks = {
+      onParallel: async ({ branches }) => {
+        // Only 1 out of 4 branches succeed (25% success rate)
+        return [
+          { id: 'a', result: 'success' },
+          { id: 'b', error: 'failed' },
+          { id: 'c', error: 'failed' },
+          { id: 'd', error: 'failed' }
+        ];
+      }
+    };
+
+    const ctx = makeContext();
+    const result = await executeParallel(
+      {
+        id: 'parallel_task',
+        type: 'parallel',
+        branches: [{ id: 'a' }, { id: 'b' }, { id: 'c' }, { id: 'd' }],
+        errorPolicy: 'quorum',
+        quorumThreshold: 0.5, // 50% threshold
+        next: 'success_node',
+        onError: 'error_node'
+      },
+      ctx,
+      callbacks
+    );
+
+    assert.equal(result.next, 'error_node');
+    assert.equal(result.outputs.quorumMet, false);
+    assert.equal(result.outputs.successCount, 1);
+    assert.equal(result.outputs.totalCount, 4);
+    assert.equal(result.outputs.failureCount, 3);
+    assert.equal(result.outputs.successRate, 0.25);
+    assert.equal(result.outputs.quorumType, 'threshold');
+  });
+
+  it('handles errorPolicy quorum with minSuccess - quorum met', async () => {
+    const callbacks = {
+      onParallel: async ({ branches }) => {
+        // 2 out of 3 branches succeed
+        return [
+          { id: 'a', result: 'success' },
+          { id: 'b', result: 'success' },
+          { id: 'c', error: 'failed' }
+        ];
+      }
+    };
+
+    const ctx = makeContext();
+    const result = await executeParallel(
+      {
+        id: 'parallel_task',
+        type: 'parallel',
+        branches: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
+        errorPolicy: 'quorum',
+        quorumMinSuccess: 2, // At least 2 must succeed
+        next: 'success_node',
+        onError: 'error_node'
+      },
+      ctx,
+      callbacks
+    );
+
+    assert.equal(result.next, 'success_node');
+    assert.equal(result.outputs.quorumMet, true);
+    assert.equal(result.outputs.successCount, 2);
+    assert.equal(result.outputs.quorumType, 'minSuccess');
+  });
+
+  it('handles errorPolicy quorum with minSuccess - quorum failed', async () => {
+    const callbacks = {
+      onParallel: async ({ branches }) => {
+        // Only 1 out of 3 branches succeed
+        return [
+          { id: 'a', result: 'success' },
+          { id: 'b', error: 'failed' },
+          { id: 'c', error: 'failed' }
+        ];
+      }
+    };
+
+    const ctx = makeContext();
+    const result = await executeParallel(
+      {
+        id: 'parallel_task',
+        type: 'parallel',
+        branches: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
+        errorPolicy: 'quorum',
+        quorumMinSuccess: 2, // At least 2 must succeed
+        next: 'success_node',
+        onError: 'error_node'
+      },
+      ctx,
+      callbacks
+    );
+
+    assert.equal(result.next, 'error_node');
+    assert.equal(result.outputs.quorumMet, false);
+    assert.equal(result.outputs.successCount, 1);
+    assert.equal(result.outputs.quorumType, 'minSuccess');
+  });
+
+  it('handles errorPolicy quorum with default (all must succeed)', async () => {
+    const callbacks = {
+      onParallel: async ({ branches }) => {
+        // All branches succeed
+        return branches.map(b => ({ id: b.id, result: 'success' }));
+      }
+    };
+
+    const ctx = makeContext();
+    const result = await executeParallel(
+      {
+        id: 'parallel_task',
+        type: 'parallel',
+        branches: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
+        errorPolicy: 'quorum', // No threshold or minSuccess specified
+        next: 'success_node',
+        onError: 'error_node'
+      },
+      ctx,
+      callbacks
+    );
+
+    assert.equal(result.next, 'success_node');
+    assert.equal(result.outputs.quorumMet, true);
+    assert.equal(result.outputs.quorumType, 'all');
+  });
+
+  it('handles errorPolicy quorum default - one failure fails quorum', async () => {
+    const callbacks = {
+      onParallel: async ({ branches }) => {
+        // One branch fails
+        return [
+          { id: 'a', result: 'success' },
+          { id: 'b', result: 'success' },
+          { id: 'c', error: 'failed' }
+        ];
+      }
+    };
+
+    const ctx = makeContext();
+    const result = await executeParallel(
+      {
+        id: 'parallel_task',
+        type: 'parallel',
+        branches: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
+        errorPolicy: 'quorum', // Default: all must succeed
+        next: 'success_node',
+        onError: 'error_node'
+      },
+      ctx,
+      callbacks
+    );
+
+    assert.equal(result.next, 'error_node');
+    assert.equal(result.outputs.quorumMet, false);
+    assert.equal(result.outputs.successCount, 2);
+    assert.equal(result.outputs.totalCount, 3);
+  });
+
+  it('handles errorPolicy quorum - skipped branches count as failures', async () => {
+    const callbacks = {
+      onParallel: async ({ branches }) => {
+        return [
+          { id: 'a', result: 'success' },
+          { id: 'b', skipped: true },
+          { id: 'c', result: 'success' }
+        ];
+      }
+    };
+
+    const ctx = makeContext();
+    const result = await executeParallel(
+      {
+        id: 'parallel_task',
+        type: 'parallel',
+        branches: [{ id: 'a' }, { id: 'b' }, { id: 'c' }],
+        errorPolicy: 'quorum',
+        quorumThreshold: 0.7, // Need 70% success
+        next: 'success_node',
+        onError: 'error_node'
+      },
+      ctx,
+      callbacks
+    );
+
+    // 2/3 = 66.7% < 70%, quorum fails
+    assert.equal(result.next, 'error_node');
+    assert.equal(result.outputs.quorumMet, false);
+    assert.equal(result.outputs.successCount, 2);
+    assert.equal(result.outputs.successRate, 2 / 3);
+  });
+
+  it('handles errorPolicy quorum - falls back to next if no onError defined', async () => {
+    const callbacks = {
+      onParallel: async ({ branches }) => {
+        return branches.map(() => ({ error: 'all failed' }));
+      }
+    };
+
+    const ctx = makeContext();
+    const result = await executeParallel(
+      {
+        id: 'parallel_task',
+        type: 'parallel',
+        branches: [{ id: 'a' }, { id: 'b' }],
+        errorPolicy: 'quorum',
+        quorumThreshold: 0.5,
+        next: 'next_node'
+        // No onError defined
+      },
+      ctx,
+      callbacks
+    );
+
+    // Should fall back to 'next' when no onError defined
+    assert.equal(result.next, 'next_node');
+    assert.equal(result.outputs.quorumMet, false);
+  });
 });
 
 describe('executeInterrupt', () => {

package/flow-engine/tests/graph.test.js

@@ -150,6 +150,181 @@ describe('getNextNodes', () => {
   });
 });
 
+describe('flow validation enhancements', () => {
+  it('detects orphaned nodes in simple case', () => {
+    const graph = buildGraph({
+      nodes: [
+        { id: 'start', type: 'entry', next: 'end' },
+        { id: 'end', type: 'exit', status: 'success', outputs: {} },
+        { id: 'orphan', type: 'sequence', next: 'end' }
+      ]
+    });
+    const result = validateGraph(graph);
+    assert.equal(result.valid, false);
+    assert.ok(result.errors.some(e => e.includes('orphan') && e.includes('unreachable')));
+  });
+
+  it('detects orphaned nodes in complex branching', () => {
+    const graph = buildGraph({
+      nodes: [
+        { id: 'start', type: 'entry', next: 'cond' },
+        { id: 'cond', type: 'condition', true: 'end', false: 'end' },
+        { id: 'end', type: 'exit', status: 'success', outputs: {} },
+        { id: 'isolated_branch', type: 'sequence', next: 'isolated_end' },
+        { id: 'isolated_end', type: 'exit', status: 'error', outputs: {} }
+      ]
+    });
+    const result = validateGraph(graph);
+    assert.equal(result.valid, false);
+    assert.ok(result.errors.some(e => e.includes('isolated_branch') && e.includes('unreachable')));
+    assert.ok(result.errors.some(e => e.includes('isolated_end') && e.includes('unreachable')));
+  });
+
+  it('validates onMaxIterations handler references', () => {
+    const graph = buildGraph({
+      nodes: [
+        { id: 'start', type: 'entry', next: 'loop' },
+        { id: 'loop', type: 'sequence', next: 'loop', onMaxIterations: 'missing_exit' },
+        { id: 'end', type: 'exit', status: 'success', outputs: {} }
+      ]
+    });
+    const result = validateGraph(graph);
+    assert.equal(result.valid, false);
+    assert.ok(result.errors.some(e => e.includes('missing_exit')));
+  });
+
+  it('validates onError handler references', () => {
+    const graph = buildGraph({
+      nodes: [
+        { id: 'start', type: 'entry', next: 'task' },
+        { id: 'task', type: 'sequence', next: 'end', onError: 'non_existent_handler' },
+        { id: 'end', type: 'exit', status: 'success', outputs: {} }
+      ]
+    });
+    const result = validateGraph(graph);
+    assert.equal(result.valid, false);
+    assert.ok(result.errors.some(e => e.includes('non_existent_handler')));
+  });
+
+  it('validates all router routes', () => {
+    const graph = buildGraph({
+      nodes: [
+        { id: 'start', type: 'entry', next: 'router' },
+        { id: 'router', type: 'router', routes: { path_a: 'valid', path_b: 'invalid_node', default: 'also_invalid' } },
+        { id: 'valid', type: 'exit', status: 'success', outputs: {} }
+      ]
+    });
+    const result = validateGraph(graph);
+    assert.equal(result.valid, false);
+    assert.ok(result.errors.some(e => e.includes('invalid_node')));
+    assert.ok(result.errors.some(e => e.includes('also_invalid')));
+  });
+
+  it('detects multiple validation errors at once', () => {
+    const graph = buildGraph({
+      nodes: [
+        { id: 'start', type: 'entry', next: 'missing_next' },
+        { id: 'orphan', type: 'sequence', next: 'another_orphan' },
+        { id: 'another_orphan', type: 'exit', status: 'success', outputs: {} }
+      ]
+    });
+    const result = validateGraph(graph);
+    assert.equal(result.valid, false);
+    // Should have dangling reference error (missing_next)
+    assert.ok(result.errors.some(e => e.includes('missing_next')));
+    // Should have orphaned node errors
+    assert.ok(result.errors.some(e => e.includes('orphan')));
+  });
+
+  it('passes validation for graph with all error handlers', () => {
+    const graph = buildGraph({
+      nodes: [
+        { id: 'start', type: 'entry', next: 'task' },
+        { id: 'task', type: 'sequence', next: 'end', onError: 'error_handler', onMaxIterations: 'max_handler' },
+        { id: 'error_handler', type: 'exit', status: 'error', outputs: {} },
+        { id: 'max_handler', type: 'exit', status: 'max_iterations', outputs: {} },
+        { id: 'end', type: 'exit', status: 'success', outputs: {} }
+      ]
+    });
+    const result = validateGraph(graph);
+    assert.equal(result.valid, true);
+    assert.equal(result.errors.length, 0);
+  });
+
+  it('passes validation for complex branching with no orphans', () => {
+    const graph = buildGraph({
+      nodes: [
+        { id: 'start', type: 'entry', next: 'cond' },
+        { id: 'cond', type: 'condition', true: 'router', false: 'fallback' },
+        { id: 'router', type: 'router', routes: { a: 'end', b: 'fallback' }, default: 'fallback' },
+        { id: 'fallback', type: 'sequence', next: 'end' },
+        { id: 'end', type: 'exit', status: 'success', outputs: {} }
+      ]
+    });
+    const result = validateGraph(graph);
+    assert.equal(result.valid, true);
+    assert.equal(result.errors.length, 0);
+  });
+
+  it('detects orphaned node in circular subgraph', () => {
+    const graph = buildGraph({
+      nodes: [
+        { id: 'start', type: 'entry', next: 'end' },
+        { id: 'end', type: 'exit', status: 'success', outputs: {} },
+        { id: 'circular_a', type: 'sequence', next: 'circular_b' },
+        { id: 'circular_b', type: 'sequence', next: 'circular_a' }
+      ]
+    });
+    const result = validateGraph(graph);
+    assert.equal(result.valid, false);
+    assert.ok(result.errors.some(e => e.includes('circular_a') && e.includes('unreachable')));
+    assert.ok(result.errors.some(e => e.includes('circular_b') && e.includes('unreachable')));
+  });
+
+  it('validates condition node with both branches pointing to same target', () => {
+    const graph = buildGraph({
+      nodes: [
+        { id: 'start', type: 'entry', next: 'cond' },
+        { id: 'cond', type: 'condition', true: 'end', false: 'end' },
+        { id: 'end', type: 'exit', status: 'success', outputs: {} }
+      ]
+    });
+    const result = validateGraph(graph);
+    assert.equal(result.valid, true);
+    assert.equal(result.errors.length, 0);
+  });
+
+  it('validates router with duplicate route targets', () => {
+    const graph = buildGraph({
+      nodes: [
+        { id: 'start', type: 'entry', next: 'router' },
+        { id: 'router', type: 'router', routes: { a: 'end', b: 'end', c: 'end' }, default: 'end' },
+        { id: 'end', type: 'exit', status: 'success', outputs: {} }
+      ]
+    });
+    const result = validateGraph(graph);
+    assert.equal(result.valid, true);
+    assert.equal(result.errors.length, 0);
+  });
+
+  it('provides clear error messages for all error types', () => {
+    const graph = buildGraph({
+      nodes: [
+        { id: 'start', type: 'entry', next: 'task' },
+        { id: 'task', type: 'sequence', next: 'missing', onError: 'no_such_handler' },
+        { id: 'orphan', type: 'exit', status: 'error', outputs: {} }
+      ]
+    });
+    const result = validateGraph(graph);
+    assert.equal(result.valid, false);
+    // Check error message format includes node IDs and issue type
+    result.errors.forEach(err => {
+      assert.ok(typeof err === 'string');
+      assert.ok(err.length > 0);
+    });
+  });
+});
+
 describe('real flow loading', () => {
   it('loads the full development-flow.json', () => {
     const flow = require('../../flows/development-flow.json');
@@ -158,4 +333,22 @@ describe('real flow loading', () => {
     assert.equal(graph.entryNode, 'start');
     assert.equal(graph.meta.version, '5.3.0');
   });
+
+  it('validates the full development-flow.json and detects known issues', () => {
+    const flow = require('../../flows/development-flow.json');
+    const graph = buildGraph(flow);
+    const result = validateGraph(graph);
+    // Development flow has known orphaned nodes (P0.3 - teams mode deprecated nodes)
+    // Expected orphaned nodes: teams_spawn, interrupt_teams_failed, design_ui, interrupt_design_complete
+    if (!result.valid) {
+      const orphanedNodes = result.errors.filter(e => e.includes('unreachable'));
+      assert.ok(orphanedNodes.length > 0, 'Should detect orphaned nodes');
+      // Verify these are the known teams mode orphaned nodes
+      const hasTeamsNodes = orphanedNodes.some(e =>
+        e.includes('teams_spawn') || e.includes('interrupt_teams') ||
+        e.includes('design_ui') || e.includes('interrupt_design')
+      );
+      assert.ok(hasTeamsNodes, 'Orphaned nodes should include known teams mode nodes');
+    }
+  });
 });