cli4ai 0.8.0

package/src/core/routine-engine.test.ts

@@ -0,0 +1,139 @@
+/**
+ * Tests for routine-engine.ts
+ */
+
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import { mkdtempSync, rmSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import {
+  dryRunRoutine,
+  loadRoutineDefinition,
+  runRoutine,
+  RoutineParseError,
+  RoutineTemplateError,
+  RoutineValidationError,
+  type RoutineDefinition
+} from './routine-engine.js';
+
+describe('routine-engine', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), 'cli4ai-routine-engine-test-'));
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  test('loadRoutineDefinition throws RoutineParseError on invalid JSON', () => {
+    const path = join(tempDir, 'bad.routine.json');
+    writeFileSync(path, '{not json');
+    expect(() => loadRoutineDefinition(path)).toThrow(RoutineParseError);
+  });
+
+  test('loadRoutineDefinition throws RoutineValidationError on duplicate step ids', () => {
+    const path = join(tempDir, 'dup.routine.json');
+    writeFileSync(
+      path,
+      JSON.stringify({
+        version: 1,
+        name: 'dup',
+        steps: [
+          { id: 'a', type: 'set', vars: {} },
+          { id: 'a', type: 'set', vars: {} }
+        ]
+      })
+    );
+    expect(() => loadRoutineDefinition(path)).toThrow(RoutineValidationError);
+  });
+
+  test('runRoutine executes exec+set steps and renders object result templates', async () => {
+    const def: RoutineDefinition = {
+      version: 1,
+      name: 'demo',
+      vars: {
+        lang: { default: 'rust' }
+      },
+      steps: [
+        {
+          id: 'hello',
+          type: 'exec',
+          cmd: 'bash',
+          args: ['-lc', "echo '{\"x\":1,\"lang\":\"{{vars.lang}}\"}'"],
+          capture: 'json'
+        },
+        {
+          id: 'setvars',
+          type: 'set',
+          vars: {
+            lang2: '{{steps.hello.json.lang}}',
+            x: '{{steps.hello.json.x}}'
+          }
+        },
+        {
+          id: 'echo',
+          type: 'exec',
+          cmd: 'bash',
+          args: ['-lc', "echo '{{vars.lang2}} {{vars.x}}'"],
+          capture: 'text'
+        }
+      ],
+      result: {
+        lang: '{{vars.lang2}}',
+        x: '{{vars.x}}',
+        raw: '{{steps.echo.stdout}}'
+      }
+    };
+
+    const summary = await runRoutine(def, { lang: 'typescript' }, tempDir);
+    expect(summary.status).toBe('success');
+    expect(summary.exitCode).toBe(0);
+    expect(summary.result).toEqual({
+      lang: 'typescript',
+      x: 1,
+      raw: 'typescript 1\n'
+    });
+  });
+
+  test('runRoutine fails fast on missing template path', async () => {
+    const def: RoutineDefinition = {
+      version: 1,
+      name: 'bad-template',
+      steps: [
+        {
+          id: 'set',
+          type: 'set',
+          vars: {
+            x: '{{steps.nope.json.0}}'
+          }
+        }
+      ]
+    };
+
+    await expect(runRoutine(def, {}, tempDir)).rejects.toThrow(RoutineTemplateError);
+  });
+
+  test('dryRunRoutine is lenient for missing step paths', async () => {
+    const def: RoutineDefinition = {
+      version: 1,
+      name: 'dry',
+      steps: [
+        {
+          id: 'set',
+          type: 'set',
+          vars: {
+            x: '{{steps.nope.json.0}}'
+          }
+        }
+      ],
+      result: { x: '{{vars.x}}' }
+    };
+
+    const plan = await dryRunRoutine(def, {}, tempDir);
+    expect(plan.vars.x).toBe('{{steps.nope.json.0}}');
+    expect(plan.result).toEqual({ x: '{{steps.nope.json.0}}' });
+  });
+});
+