elsabro 7.3.0 → 7.3.1

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

@@ -0,0 +1,476 @@
+'use strict';
+
+const { describe, it, before, after, beforeEach } = require('node:test');
+const assert = require('node:assert/strict');
+const { executeCondition, ExecutorError } = require('../src/executors');
+const { CheckpointManager } = require('../src/checkpoint');
+const fs = require('fs');
+const path = require('path');
+
+// Helper to create a mock context
+function makeContext(overrides = {}) {
+  return {
+    inputs: {},
+    nodes: {},
+    steps: {},
+    state: {},
+    _iterations: {},
+    ...overrides
+  };
+}
+
+describe('Checkpoint save before condition errors', () => {
+  it('saves checkpoint before error when condition field is missing', async () => {
+    let checkpointData = null;
+
+    const callbacks = {
+      onCheckpoint: async (data) => {
+        checkpointData = data;
+      }
+    };
+
+    const node = {
+      id: 'bad_condition',
+      type: 'condition',
+      true: 'success_node',
+      false: 'failure_node'
+      // condition is missing!
+    };
+
+    const context = makeContext({ inputs: { test: 'value' } });
+
+    // Should throw ExecutorError
+    await assert.rejects(
+      executeCondition(node, context, callbacks),
+      ExecutorError
+    );
+
+    // Should have saved a checkpoint
+    assert.notEqual(checkpointData, null, 'Checkpoint should be saved');
+    assert.equal(checkpointData.currentNode, 'bad_condition');
+    assert.equal(checkpointData.nextNode, null);
+    assert.equal(checkpointData.stoppedAt, 'bad_condition');
+    assert.equal(checkpointData.reason, 'Condition node has no "condition" field');
+    assert.ok(checkpointData.context, 'Context should be serialized');
+  });
+
+  it('saves checkpoint before error when true branch is undefined', async () => {
+    let checkpointData = null;
+
+    const callbacks = {
+      onCheckpoint: async (data) => {
+        checkpointData = data;
+      }
+    };
+
+    const node = {
+      id: 'missing_true',
+      type: 'condition',
+      condition: '{{inputs.test === "pass"}}',
+      // true branch is missing!
+      false: 'failure_node'
+    };
+
+    const context = makeContext({ inputs: { test: 'pass' } });
+
+    // Should throw ExecutorError
+    await assert.rejects(
+      executeCondition(node, context, callbacks),
+      ExecutorError
+    );
+
+    // Should have saved a checkpoint
+    assert.notEqual(checkpointData, null, 'Checkpoint should be saved');
+    assert.equal(checkpointData.currentNode, 'missing_true');
+    assert.equal(checkpointData.nextNode, null);
+    assert.equal(checkpointData.stoppedAt, 'missing_true');
+    assert.ok(checkpointData.reason.includes('true'), 'Reason should mention true branch');
+    assert.ok(checkpointData.context, 'Context should be serialized');
+  });
+
+  it('saves checkpoint before error when false branch is undefined', async () => {
+    let checkpointData = null;
+
+    const callbacks = {
+      onCheckpoint: async (data) => {
+        checkpointData = data;
+      }
+    };
+
+    const node = {
+      id: 'missing_false',
+      type: 'condition',
+      condition: '{{inputs.test === "pass"}}',
+      true: 'success_node'
+      // false branch is missing!
+    };
+
+    const context = makeContext({ inputs: { test: 'fail' } });
+
+    // Should throw ExecutorError
+    await assert.rejects(
+      executeCondition(node, context, callbacks),
+      ExecutorError
+    );
+
+    // Should have saved a checkpoint
+    assert.notEqual(checkpointData, null, 'Checkpoint should be saved');
+    assert.equal(checkpointData.currentNode, 'missing_false');
+    assert.equal(checkpointData.nextNode, null);
+    assert.equal(checkpointData.stoppedAt, 'missing_false');
+    assert.ok(checkpointData.reason.includes('false'), 'Reason should mention false branch');
+    assert.ok(checkpointData.context, 'Context should be serialized');
+  });
+
+  it('does not error when onCheckpoint callback is not provided', async () => {
+    const node = {
+      id: 'no_callback',
+      type: 'condition',
+      true: 'a',
+      false: 'b'
+      // condition is missing
+    };
+
+    const context = makeContext();
+
+    // Should still throw ExecutorError even without checkpoint callback
+    await assert.rejects(
+      executeCondition(node, context, {}),
+      ExecutorError
+    );
+  });
+
+  it('preserves context data in checkpoint', async () => {
+    let checkpointData = null;
+
+    const callbacks = {
+      onCheckpoint: async (data) => {
+        checkpointData = data;
+      }
+    };
+
+    const node = {
+      id: 'context_test',
+      type: 'condition',
+      condition: '{{inputs.check}}',
+      true: 'next'
+      // false branch missing
+    };
+
+    const context = makeContext({
+      inputs: { check: false, user: 'alice' },
+      nodes: { prev: { outputs: { result: 42 } } },
+      state: { counter: 10 }
+    });
+
+    // Should throw ExecutorError
+    await assert.rejects(
+      executeCondition(node, context, callbacks),
+      ExecutorError
+    );
+
+    // Verify context was properly serialized
+    assert.notEqual(checkpointData, null);
+    assert.ok(checkpointData.context.inputs, 'Context should have inputs');
+    assert.equal(checkpointData.context.inputs.user, 'alice');
+    assert.ok(checkpointData.context.nodes, 'Context should have nodes');
+    assert.ok(checkpointData.context.state, 'Context should have state');
+  });
+});
+
+describe('CheckpointManager auto-cleanup', () => {
+  const testDir = path.join(process.cwd(), '.test-checkpoints');
+  let manager;
+
+  before(() => {
+    // Create test directory
+    if (fs.existsSync(testDir)) {
+      fs.rmSync(testDir, { recursive: true });
+    }
+    fs.mkdirSync(testDir, { recursive: true });
+    manager = new CheckpointManager({ dir: testDir });
+  });
+
+  beforeEach(() => {
+    // Clean directory before each test to ensure isolation
+    if (fs.existsSync(testDir)) {
+      const files = fs.readdirSync(testDir);
+      files.forEach(file => {
+        fs.unlinkSync(path.join(testDir, file));
+      });
+    }
+  });
+
+  after(() => {
+    // Clean up test directory
+    if (fs.existsSync(testDir)) {
+      fs.rmSync(testDir, { recursive: true });
+    }
+  });
+
+  it('removes checkpoints older than 7 days', () => {
+    const flowId = 'test_flow';
+    const now = Date.now();
+    const eightDaysAgo = now - (8 * 24 * 60 * 60 * 1000);
+    const sixDaysAgo = now - (6 * 24 * 60 * 60 * 1000);
+
+    // Create old checkpoint (8 days ago)
+    const oldFilename = `${flowId}-${eightDaysAgo}-0001.json`;
+    fs.writeFileSync(
+      path.join(testDir, oldFilename),
+      JSON.stringify({ flowId, timestamp: eightDaysAgo })
+    );
+
+    // Create recent checkpoint (6 days ago)
+    const recentFilename = `${flowId}-${sixDaysAgo}-0002.json`;
+    fs.writeFileSync(
+      path.join(testDir, recentFilename),
+      JSON.stringify({ flowId, timestamp: sixDaysAgo })
+    );
+
+    // Run auto-cleanup with 7-day threshold
+    const removed = manager.autoCleanup(flowId, 7);
+
+    // Verify old checkpoint removed, recent kept
+    assert.equal(removed, 1, 'Should remove 1 old checkpoint');
+    assert.ok(!fs.existsSync(path.join(testDir, oldFilename)), 'Old checkpoint should be removed');
+    assert.ok(fs.existsSync(path.join(testDir, recentFilename)), 'Recent checkpoint should be kept');
+  });
+
+  it('removes checkpoints for all flows when flowId not specified', () => {
+    const now = Date.now();
+    const eightDaysAgo = now - (8 * 24 * 60 * 60 * 1000);
+
+    // Create old checkpoints for different flows
+    const flow1File = `flow1-${eightDaysAgo}-0001.json`;
+    const flow2File = `flow2-${eightDaysAgo}-0001.json`;
+
+    fs.writeFileSync(
+      path.join(testDir, flow1File),
+      JSON.stringify({ flowId: 'flow1', timestamp: eightDaysAgo })
+    );
+    fs.writeFileSync(
+      path.join(testDir, flow2File),
+      JSON.stringify({ flowId: 'flow2', timestamp: eightDaysAgo })
+    );
+
+    // Run auto-cleanup without flowId (cleans all flows)
+    const removed = manager.autoCleanup(null, 7);
+
+    // Verify both old checkpoints removed
+    assert.equal(removed, 2, 'Should remove 2 old checkpoints');
+    assert.ok(!fs.existsSync(path.join(testDir, flow1File)), 'flow1 checkpoint should be removed');
+    assert.ok(!fs.existsSync(path.join(testDir, flow2File)), 'flow2 checkpoint should be removed');
+  });
+
+  it('returns 0 when checkpoint directory does not exist', () => {
+    const nonExistentManager = new CheckpointManager({ dir: '/non/existent/path' });
+    const removed = nonExistentManager.autoCleanup('test_flow', 7);
+    assert.equal(removed, 0, 'Should return 0 when directory does not exist');
+  });
+
+  it('handles custom days threshold', () => {
+    const flowId = 'custom_flow';
+    const now = Date.now();
+    const tenDaysAgo = now - (10 * 24 * 60 * 60 * 1000);
+    const fiveDaysAgo = now - (5 * 24 * 60 * 60 * 1000);
+
+    // Create checkpoints at different ages
+    const oldFilename = `${flowId}-${tenDaysAgo}-0001.json`;
+    const recentFilename = `${flowId}-${fiveDaysAgo}-0002.json`;
+
+    fs.writeFileSync(
+      path.join(testDir, oldFilename),
+      JSON.stringify({ flowId, timestamp: tenDaysAgo })
+    );
+    fs.writeFileSync(
+      path.join(testDir, recentFilename),
+      JSON.stringify({ flowId, timestamp: fiveDaysAgo })
+    );
+
+    // Run auto-cleanup with 3-day threshold
+    const removed = manager.autoCleanup(flowId, 3);
+
+    // Both should be removed (both older than 3 days)
+    assert.equal(removed, 2, 'Should remove 2 checkpoints older than 3 days');
+    assert.ok(!fs.existsSync(path.join(testDir, oldFilename)), 'Old checkpoint should be removed');
+    assert.ok(!fs.existsSync(path.join(testDir, recentFilename)), 'Recent checkpoint should be removed');
+  });
+
+  it('keeps checkpoints exactly at threshold boundary', () => {
+    const flowId = 'boundary_flow';
+    const now = Date.now();
+    // Use a margin to account for time between Date.now() calls
+    // Make one clearly within threshold and one clearly outside
+    const sixDaysAgo = now - (6 * 24 * 60 * 60 * 1000);
+    const eightDaysAgo = now - (8 * 24 * 60 * 60 * 1000);
+
+    // Create checkpoint within threshold (6 days old, should be kept)
+    const recentFilename = `${flowId}-${sixDaysAgo}-0001.json`;
+    fs.writeFileSync(
+      path.join(testDir, recentFilename),
+      JSON.stringify({ flowId, timestamp: sixDaysAgo })
+    );
+
+    // Create checkpoint outside threshold (8 days old, should be removed)
+    const oldFilename = `${flowId}-${eightDaysAgo}-0002.json`;
+    fs.writeFileSync(
+      path.join(testDir, oldFilename),
+      JSON.stringify({ flowId, timestamp: eightDaysAgo })
+    );
+
+    // Run auto-cleanup with 7-day threshold
+    const removed = manager.autoCleanup(flowId, 7);
+
+    // Only the 8-day-old checkpoint should be removed
+    assert.equal(removed, 1, 'Should remove only checkpoints older than threshold');
+    assert.ok(fs.existsSync(path.join(testDir, recentFilename)), 'Recent checkpoint (6 days) should be kept');
+    assert.ok(!fs.existsSync(path.join(testDir, oldFilename)), 'Old checkpoint (8 days) should be removed');
+  });
+
+  it('skips files with invalid filename patterns', () => {
+    const flowId = 'pattern_flow';
+    const now = Date.now();
+    const tenDaysAgo = now - (10 * 24 * 60 * 60 * 1000);
+
+    // Create valid checkpoint
+    const validFilename = `${flowId}-${tenDaysAgo}-0001.json`;
+    fs.writeFileSync(
+      path.join(testDir, validFilename),
+      JSON.stringify({ flowId, timestamp: tenDaysAgo })
+    );
+
+    // Create files with invalid patterns (should be ignored)
+    const invalidFiles = [
+      'invalid.json',
+      `${flowId}-notanumber-0001.json`,
+      `${flowId}.json`,
+      'random-file.txt'
+    ];
+
+    invalidFiles.forEach(filename => {
+      fs.writeFileSync(path.join(testDir, filename), 'test content');
+    });
+
+    // Run auto-cleanup
+    const removed = manager.autoCleanup(flowId, 7);
+
+    // Only the valid old checkpoint should be removed
+    assert.equal(removed, 1, 'Should only remove valid checkpoint files');
+    assert.ok(!fs.existsSync(path.join(testDir, validFilename)), 'Valid old checkpoint should be removed');
+
+    // Invalid files should still exist
+    invalidFiles.forEach(filename => {
+      assert.ok(fs.existsSync(path.join(testDir, filename)), `Invalid file ${filename} should be ignored and kept`);
+    });
+  });
+
+  it('handles zero threshold (removes all checkpoints)', () => {
+    const flowId = 'zero_flow';
+    const now = Date.now();
+    const oneHourAgo = now - (60 * 60 * 1000);
+
+    // Create very recent checkpoint
+    const recentFilename = `${flowId}-${oneHourAgo}-0001.json`;
+    fs.writeFileSync(
+      path.join(testDir, recentFilename),
+      JSON.stringify({ flowId, timestamp: oneHourAgo })
+    );
+
+    // Run auto-cleanup with 0-day threshold
+    const removed = manager.autoCleanup(flowId, 0);
+
+    // Even recent checkpoint should be removed with 0 threshold
+    assert.equal(removed, 1, 'Should remove all checkpoints with 0-day threshold');
+    assert.ok(!fs.existsSync(path.join(testDir, recentFilename)), 'Recent checkpoint should be removed with 0 threshold');
+  });
+
+  it('returns 0 when no checkpoints match criteria', () => {
+    const flowId = 'no_match_flow';
+    const now = Date.now();
+    const twoDaysAgo = now - (2 * 24 * 60 * 60 * 1000);
+
+    // Create recent checkpoint
+    const recentFilename = `${flowId}-${twoDaysAgo}-0001.json`;
+    fs.writeFileSync(
+      path.join(testDir, recentFilename),
+      JSON.stringify({ flowId, timestamp: twoDaysAgo })
+    );
+
+    // Run auto-cleanup with 7-day threshold (checkpoint is only 2 days old)
+    const removed = manager.autoCleanup(flowId, 7);
+
+    // Nothing should be removed
+    assert.equal(removed, 0, 'Should return 0 when no checkpoints match removal criteria');
+    assert.ok(fs.existsSync(path.join(testDir, recentFilename)), 'Recent checkpoint should be kept');
+  });
+
+  it('cleans up multiple old checkpoints for same flow', () => {
+    const flowId = 'multi_flow';
+    const now = Date.now();
+
+    // Create multiple old checkpoints
+    const oldCheckpoints = [];
+    for (let i = 0; i < 5; i++) {
+      const daysAgo = (8 + i) * 24 * 60 * 60 * 1000;
+      const timestamp = now - daysAgo;
+      const filename = `${flowId}-${timestamp}-${String(i).padStart(4, '0')}.json`;
+      oldCheckpoints.push(filename);
+      fs.writeFileSync(
+        path.join(testDir, filename),
+        JSON.stringify({ flowId, timestamp })
+      );
+    }
+
+    // Create one recent checkpoint
+    const recentTimestamp = now - (2 * 24 * 60 * 60 * 1000);
+    const recentFilename = `${flowId}-${recentTimestamp}-0005.json`;
+    fs.writeFileSync(
+      path.join(testDir, recentFilename),
+      JSON.stringify({ flowId, timestamp: recentTimestamp })
+    );
+
+    // Run auto-cleanup with 7-day threshold
+    const removed = manager.autoCleanup(flowId, 7);
+
+    // All 5 old checkpoints should be removed
+    assert.equal(removed, 5, 'Should remove all old checkpoints');
+
+    oldCheckpoints.forEach(filename => {
+      assert.ok(!fs.existsSync(path.join(testDir, filename)), `Old checkpoint ${filename} should be removed`);
+    });
+
+    assert.ok(fs.existsSync(path.join(testDir, recentFilename)), 'Recent checkpoint should be kept');
+  });
+
+  it('does not remove non-json files in checkpoint directory', () => {
+    const flowId = 'mixed_flow';
+    const now = Date.now();
+    const tenDaysAgo = now - (10 * 24 * 60 * 60 * 1000);
+
+    // Create old checkpoint
+    const oldCheckpoint = `${flowId}-${tenDaysAgo}-0001.json`;
+    fs.writeFileSync(
+      path.join(testDir, oldCheckpoint),
+      JSON.stringify({ flowId, timestamp: tenDaysAgo })
+    );
+
+    // Create non-JSON files
+    const otherFiles = ['.gitkeep', 'README.md', 'backup.txt'];
+    otherFiles.forEach(filename => {
+      fs.writeFileSync(path.join(testDir, filename), 'content');
+    });
+
+    // Run auto-cleanup
+    const removed = manager.autoCleanup(flowId, 7);
+
+    // Only the old checkpoint should be removed
+    assert.equal(removed, 1, 'Should only remove JSON checkpoint files');
+    assert.ok(!fs.existsSync(path.join(testDir, oldCheckpoint)), 'Old checkpoint should be removed');
+
+    // Other files should remain
+    otherFiles.forEach(filename => {
+      assert.ok(fs.existsSync(path.join(testDir, filename)), `Non-JSON file ${filename} should not be removed`);
+    });
+  });
+});