elsabro 5.2.0 → 6.0.1

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

@@ -0,0 +1,272 @@
+'use strict';
+
+const { describe, it } = require('node:test');
+const assert = require('node:assert/strict');
+const {
+  resolveTemplate,
+  resolveExpression,
+  resolvePath,
+  _functions,
+  _filters
+} = require('../src/template');
+
+// Shared test context
+const ctx = {
+  inputs: { task: 'add auth', profile: 'default', complexity: 'high' },
+  nodes: {
+    skill_discovery: {
+      outputs: { discoveryResult: 'skills found', skillRecommendations: ['context7'] }
+    },
+    quality_gate: {
+      outputs: {
+        tests: { exitCode: 0 },
+        typescript: { exitCode: 0 },
+        lint: { exitCode: 1 }
+      }
+    },
+    parallel_review: {
+      outputs: {
+        branches: {
+          code_reviewer: { issues: [] },
+          silent_failure_hunter: { issues: [{ severity: 'critical', msg: 'found bug' }] }
+        }
+      }
+    }
+  },
+  steps: {
+    discovery: {
+      output: {
+        recommended: { skills: ['context7', 'stitch'] }
+      }
+    }
+  },
+  state: {
+    patterns: 'TDD first',
+    reviewIteration: 2,
+    decisions: [{ node: 'a', choice: 'approve' }],
+    errors: [{ node: 'b', error: 'timeout' }]
+  }
+};
+
+describe('resolvePath', () => {
+  it('resolves a simple path', () => {
+    assert.equal(resolvePath(ctx, 'inputs.task'), 'add auth');
+  });
+
+  it('resolves a deep path', () => {
+    assert.deepEqual(
+      resolvePath(ctx, 'steps.discovery.output.recommended.skills'),
+      ['context7', 'stitch']
+    );
+  });
+
+  it('returns undefined for missing path', () => {
+    assert.equal(resolvePath(ctx, 'inputs.nonexistent'), undefined);
+  });
+
+  it('returns undefined for path through non-object', () => {
+    assert.equal(resolvePath(ctx, 'inputs.task.deep.path'), undefined);
+  });
+});
+
+describe('resolveExpression — simple interpolation', () => {
+  it('resolves a path reference', () => {
+    assert.equal(resolveExpression('inputs.task', ctx), 'add auth');
+  });
+
+  it('resolves a deep node output', () => {
+    assert.equal(
+      resolveExpression('nodes.skill_discovery.outputs.discoveryResult', ctx),
+      'skills found'
+    );
+  });
+});
+
+describe('resolveExpression — fallback operator', () => {
+  it('returns primary when it exists', () => {
+    assert.equal(resolveExpression('inputs.task || "default"', ctx), 'add auth');
+  });
+
+  it('returns fallback when primary is undefined', () => {
+    assert.equal(resolveExpression('state.missing || "default"', ctx), 'default');
+  });
+
+  it('returns empty array fallback', () => {
+    assert.deepEqual(resolveExpression('state.nothing || []', ctx), []);
+  });
+});
+
+describe('resolveExpression — boolean', () => {
+  it('evaluates === comparison (true)', () => {
+    assert.equal(
+      resolveExpression('inputs.complexity === "high"', ctx),
+      true
+    );
+  });
+
+  it('evaluates === comparison (false)', () => {
+    assert.equal(
+      resolveExpression('inputs.complexity === "low"', ctx),
+      false
+    );
+  });
+
+  it('evaluates !== comparison', () => {
+    assert.equal(
+      resolveExpression('inputs.profile !== "yolo"', ctx),
+      true
+    );
+  });
+
+  it('evaluates && expression', () => {
+    assert.equal(
+      resolveExpression('nodes.quality_gate.outputs.tests.exitCode === 0 && nodes.quality_gate.outputs.typescript.exitCode === 0', ctx),
+      true
+    );
+  });
+
+  it('evaluates && expression with false result', () => {
+    assert.equal(
+      resolveExpression('nodes.quality_gate.outputs.tests.exitCode === 0 && nodes.quality_gate.outputs.lint.exitCode === 0', ctx),
+      false
+    );
+  });
+
+  it('evaluates negation', () => {
+    assert.equal(resolveExpression('!false', ctx), true);
+  });
+});
+
+describe('resolveExpression — function calls', () => {
+  it('calls collectOutputs with key', () => {
+    const testCtx = {
+      ...ctx,
+      nodes: {
+        a: { outputs: { files: ['x.js'] } },
+        b: { outputs: { files: ['y.js'] } }
+      }
+    };
+    const result = resolveExpression("collectOutputs('files')", testCtx);
+    assert.deepEqual(result, ['x.js', 'y.js']);
+  });
+
+  it('calls collectDecisions', () => {
+    const result = resolveExpression('collectDecisions()', ctx);
+    assert.deepEqual(result, [{ node: 'a', choice: 'approve' }]);
+  });
+
+  it('calls collectErrors', () => {
+    const result = resolveExpression('collectErrors()', ctx);
+    assert.deepEqual(result, [{ node: 'b', error: 'timeout' }]);
+  });
+
+  it('calls hasCriticalIssues (true case)', () => {
+    const result = resolveExpression(
+      'hasCriticalIssues(nodes.parallel_review.outputs)',
+      ctx
+    );
+    assert.equal(result, true);
+  });
+
+  it('calls hasCriticalIssues (false case)', () => {
+    const safeCtx = {
+      ...ctx,
+      nodes: { parallel_review: { outputs: { branches: {} } } }
+    };
+    const result = resolveExpression(
+      'hasCriticalIssues(nodes.parallel_review.outputs)',
+      safeCtx
+    );
+    assert.equal(result, false);
+  });
+
+  it('calls generateSummary', () => {
+    const result = resolveExpression('generateSummary()', ctx);
+    assert.ok(result.includes('nodes executed'));
+  });
+});
+
+describe('resolveExpression — filters', () => {
+  it('applies slugify filter', () => {
+    assert.equal(resolveExpression('inputs.task | slugify', ctx), 'add-auth');
+  });
+
+  it('slugifies complex strings', () => {
+    const testCtx = { inputs: { task: 'Add User Auth & Login!!!' } };
+    assert.equal(resolveExpression('inputs.task | slugify', testCtx), 'add-user-auth-login');
+  });
+});
+
+describe('resolveTemplate — string interpolation', () => {
+  it('resolves a single expression (returns raw value)', () => {
+    assert.equal(resolveTemplate('{{inputs.task}}', ctx), 'add auth');
+  });
+
+  it('resolves embedded expressions', () => {
+    assert.equal(
+      resolveTemplate('Task: {{inputs.task}} ({{inputs.profile}})', ctx),
+      'Task: add auth (default)'
+    );
+  });
+
+  it('returns array when expression resolves to array', () => {
+    assert.deepEqual(
+      resolveTemplate('{{nodes.skill_discovery.outputs.skillRecommendations}}', ctx),
+      ['context7']
+    );
+  });
+
+  it('handles missing values as empty string in embedded', () => {
+    assert.equal(
+      resolveTemplate('value: {{state.missing}}', ctx),
+      'value: '
+    );
+  });
+});
+
+describe('resolveTemplate — object/array resolution', () => {
+  it('resolves all strings in an object', () => {
+    const template = {
+      key: '{{inputs.task}}',
+      nested: { deep: '{{inputs.profile}}' }
+    };
+    const result = resolveTemplate(template, ctx);
+    assert.equal(result.key, 'add auth');
+    assert.equal(result.nested.deep, 'default');
+  });
+
+  it('resolves strings in an array', () => {
+    const template = ['{{inputs.task}}', '{{inputs.profile}}'];
+    const result = resolveTemplate(template, ctx);
+    assert.deepEqual(result, ['add auth', 'default']);
+  });
+
+  it('passes through non-template values', () => {
+    assert.equal(resolveTemplate(42, ctx), 42);
+    assert.equal(resolveTemplate(true, ctx), true);
+    assert.equal(resolveTemplate(null, ctx), null);
+  });
+});
+
+describe('resolveTemplate — real flow expressions', () => {
+  it('resolves the quality_check condition from real flow', () => {
+    const expr = '{{nodes.quality_gate.outputs.tests.exitCode === 0 && nodes.quality_gate.outputs.typescript.exitCode === 0 && nodes.quality_gate.outputs.lint.exitCode === 0}}';
+    assert.equal(resolveTemplate(expr, ctx), false); // lint is 1
+  });
+
+  it('resolves review_check with negation + function', () => {
+    const expr = '{{!hasCriticalIssues(nodes.parallel_review.outputs)}}';
+    assert.equal(resolveTemplate(expr, ctx), false); // has critical issues
+  });
+
+  it('resolves fallback in skill outputs', () => {
+    const expr = '{{steps.discovery.output.recommended.skills || []}}';
+    const result = resolveTemplate(expr, ctx);
+    assert.deepEqual(result, ['context7', 'stitch']);
+  });
+
+  it('resolves team config with filter', () => {
+    const expr = 'elsabro-{{inputs.task | slugify}}';
+    assert.equal(resolveTemplate(expr, ctx), 'elsabro-add-auth');
+  });
+});