autotel 4.1.0 → 4.2.0

package/src/workflow.test.ts

@@ -1,647 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import {
-  traceWorkflow,
-  traceStep,
-  getCurrentWorkflowContext,
-  isInWorkflow,
-  type WorkflowConfig,
-  type WorkflowContext,
-  type StepContext,
-} from './workflow';
-
-// Mock the functional trace
-vi.mock('./functional', () => ({
-  trace: vi.fn((name, factory) => {
-    return (...args: unknown[]) => {
-      const mockCtx = createMockTraceContext();
-      const fn = factory(mockCtx);
-      return fn(...args);
-    };
-  }),
-}));
-
-// Mock trace-helpers
-vi.mock('./trace-helpers', () => ({
-  getActiveSpan: vi.fn(() => ({
-    spanContext: () => ({
-      traceId: '00000000000000000000000000000001',
-      spanId: '0000000000000001',
-      traceFlags: 1,
-    }),
-  })),
-  finalizeSpan: vi.fn(),
-}));
-
-function createMockTraceContext() {
-  const attributes: Record<string, unknown> = {};
-  const events: Array<{ name: string; attributes?: Record<string, unknown> }> =
-    [];
-  const links: unknown[] = [];
-
-  return {
-    setAttribute: vi.fn((key, value) => {
-      attributes[key] = value;
-    }),
-    setAttributes: vi.fn((attrs) => {
-      Object.assign(attributes, attrs);
-    }),
-    addEvent: vi.fn((name, attrs) => {
-      events.push({ name, attributes: attrs });
-    }),
-    addLink: vi.fn((link) => {
-      links.push(link);
-    }),
-    addLinks: vi.fn((newLinks) => {
-      links.push(...newLinks);
-    }),
-    setStatus: vi.fn(),
-    getAttributes: () => attributes,
-    getEvents: () => events,
-    getLinks: () => links,
-  };
-}
-
-describe('Workflow Helpers', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe('traceWorkflow', () => {
-    it('should create a workflow function', async () => {
-      const config: WorkflowConfig = {
-        name: 'TestWorkflow',
-        workflowId: 'wf-123',
-      };
-
-      const workflow = traceWorkflow(config)(
-        (_ctx) => async (input: string) => {
-          return `processed: ${input}`;
-        },
-      );
-
-      const result = await workflow('test-input');
-      expect(result).toBe('processed: test-input');
-    });
-
-    it('should generate workflow ID from function', async () => {
-      const config: WorkflowConfig<[{ id: string }]> = {
-        name: 'OrderWorkflow',
-        workflowId: (order) => order.id,
-      };
-
-      const workflow = traceWorkflow(config)(
-        (_ctx) => async (order: { id: string }) => {
-          return { processed: true, orderId: order.id };
-        },
-      );
-
-      const result = await workflow({ id: 'order-456' });
-      expect(result).toEqual({ processed: true, orderId: 'order-456' });
-    });
-
-    it('should support workflow version', () => {
-      const config: WorkflowConfig = {
-        name: 'VersionedWorkflow',
-        workflowId: 'wf-1',
-        version: '2.0.0',
-      };
-
-      const workflow = traceWorkflow(config)((_ctx) => async () => {
-        return true;
-      });
-
-      expect(workflow).toBeDefined();
-    });
-
-    it('should support custom attributes', async () => {
-      const config: WorkflowConfig = {
-        name: 'AttributedWorkflow',
-        workflowId: 'wf-1',
-        attributes: {
-          'workflow.type': 'fulfillment',
-          'workflow.priority': 'high',
-        },
-      };
-
-      const workflow = traceWorkflow(config)((_ctx) => async () => {
-        return true;
-      });
-
-      await workflow();
-      expect(workflow).toBeDefined();
-    });
-
-    it('should call onComplete callback on success', async () => {
-      const onComplete = vi.fn();
-      const config: WorkflowConfig = {
-        name: 'SuccessWorkflow',
-        workflowId: 'wf-1',
-        onComplete,
-      };
-
-      const workflow = traceWorkflow(config)((_ctx) => async () => {
-        return { success: true };
-      });
-
-      await workflow();
-      expect(onComplete).toHaveBeenCalled();
-    });
-
-    it('should call onFailed callback on error', async () => {
-      const onFailed = vi.fn();
-      const testError = new Error('Workflow failed');
-
-      const config: WorkflowConfig = {
-        name: 'FailedWorkflow',
-        workflowId: 'wf-1',
-        onFailed,
-      };
-
-      const workflow = traceWorkflow(config)((_ctx) => async () => {
-        throw testError;
-      });
-
-      await expect(workflow()).rejects.toThrow('Workflow failed');
-      expect(onFailed).toHaveBeenCalledWith(expect.anything(), testError);
-    });
-
-    it('should call onCompensating when compensations exist', async () => {
-      const onCompensating = vi.fn();
-      const config: WorkflowConfig = {
-        name: 'CompensatingWorkflow',
-        workflowId: 'wf-1',
-        onCompensating,
-      };
-
-      const workflow = traceWorkflow(config)((ctx) => async () => {
-        // Register a compensation and mark step as completed
-        ctx.registerCompensation('step1', async () => {});
-        ctx.completeStep('step1');
-        throw new Error('Trigger compensation');
-      });
-
-      await expect(workflow()).rejects.toThrow();
-      // Note: In mock environment, onCompensating may not be called
-      // because the actual workflow state is mocked
-      expect(workflow).toBeDefined();
-    });
-  });
-
-  describe('WorkflowContext', () => {
-    it('getWorkflowId should return the workflow ID', async () => {
-      const workflow = traceWorkflow({
-        name: 'Test',
-        workflowId: 'my-workflow-123',
-      })((ctx) => async () => {
-        return ctx.getWorkflowId();
-      });
-
-      const result = await workflow();
-      expect(result).toBe('my-workflow-123');
-    });
-
-    it('getWorkflowName should return the workflow name', async () => {
-      const workflow = traceWorkflow({
-        name: 'MyTestWorkflow',
-        workflowId: 'wf-1',
-      })((ctx) => async () => {
-        return ctx.getWorkflowName();
-      });
-
-      const result = await workflow();
-      expect(result).toBe('MyTestWorkflow');
-    });
-
-    it('getStatus should return current status', async () => {
-      const workflow = traceWorkflow({
-        name: 'StatusWorkflow',
-        workflowId: 'wf-1',
-      })((ctx) => async () => {
-        return ctx.getStatus();
-      });
-
-      const result = await workflow();
-      expect(result).toBe('running');
-    });
-
-    it('getCompletedSteps should return list of completed steps', async () => {
-      // Note: Due to mocking, the internal state isn't fully simulated
-      // This test verifies the method exists and is callable
-      const workflow = traceWorkflow({
-        name: 'StepsWorkflow',
-        workflowId: 'wf-1',
-      })((ctx) => async () => {
-        ctx.completeStep('step1');
-        ctx.completeStep('step2');
-        const steps = ctx.getCompletedSteps();
-        // In mocked environment, steps tracking may not work
-        expect(Array.isArray(steps)).toBe(true);
-        return steps;
-      });
-
-      await workflow();
-    });
-
-    it('registerCompensation should store compensation handler', async () => {
-      const compensation = vi.fn();
-
-      const workflow = traceWorkflow({
-        name: 'CompWorkflow',
-        workflowId: 'wf-1',
-      })((ctx) => async () => {
-        ctx.registerCompensation('myStep', compensation);
-        ctx.completeStep('myStep');
-        throw new Error('trigger');
-      });
-
-      try {
-        await workflow();
-      } catch {
-        // Expected
-      }
-
-      // Note: In mocked environment, compensation may not be called
-      // because the internal WeakMap state is bypassed by mocks
-      expect(workflow).toBeDefined();
-    });
-
-    it('setWorkflowStatus should update status', async () => {
-      let finalStatus = '';
-
-      const workflow = traceWorkflow({
-        name: 'StatusWorkflow',
-        workflowId: 'wf-1',
-        onComplete: (ctx) => {
-          finalStatus = ctx.getStatus();
-        },
-      })((_ctx) => async () => {
-        return true;
-      });
-
-      await workflow();
-      expect(finalStatus).toBe('completed');
-    });
-  });
-
-  describe('traceStep', () => {
-    it('should create a step function', async () => {
-      const step = traceStep({
-        name: 'TestStep',
-      })(async (input: string) => {
-        return `step result: ${input}`;
-      });
-
-      const result = await step('test');
-      expect(result).toBe('step result: test');
-    });
-
-    it('should support step description', () => {
-      const step = traceStep({
-        name: 'DescribedStep',
-        description: 'This step validates the order',
-      })(async () => true);
-
-      expect(step).toBeDefined();
-    });
-
-    it('should support explicit step index', () => {
-      const step = traceStep({
-        name: 'IndexedStep',
-        index: 5,
-      })(async () => true);
-
-      expect(step).toBeDefined();
-    });
-
-    it('should support custom attributes', () => {
-      const step = traceStep({
-        name: 'AttributedStep',
-        attributes: {
-          'step.type': 'validation',
-          'step.critical': true,
-        },
-      })(async () => true);
-
-      expect(step).toBeDefined();
-    });
-
-    it('should support idempotent flag', () => {
-      const step = traceStep({
-        name: 'IdempotentStep',
-        idempotent: true,
-      })(async () => true);
-
-      expect(step).toBeDefined();
-    });
-
-    it('should support retry configuration', async () => {
-      let attempts = 0;
-
-      const step = traceStep({
-        name: 'RetryStep',
-        retry: {
-          maxAttempts: 3,
-          backoffMs: 10,
-        },
-      })(async () => {
-        attempts++;
-        if (attempts < 3) {
-          throw new Error('Retry needed');
-        }
-        return true;
-      });
-
-      const result = await step();
-      expect(result).toBe(true);
-      expect(attempts).toBe(3);
-    });
-
-    it('should call onComplete callback on success', async () => {
-      const onComplete = vi.fn();
-
-      const step = traceStep({
-        name: 'SuccessStep',
-        onComplete,
-      })(async () => 'done');
-
-      await step();
-      expect(onComplete).toHaveBeenCalled();
-    });
-
-    it('should call onFailed callback on error', async () => {
-      const onFailed = vi.fn();
-      const testError = new Error('Step failed');
-
-      const step = traceStep({
-        name: 'FailedStep',
-        onFailed,
-      })(async () => {
-        throw testError;
-      });
-
-      await expect(step()).rejects.toThrow('Step failed');
-      expect(onFailed).toHaveBeenCalled();
-    });
-
-    it('should support compensation handler', () => {
-      const compensate = vi.fn();
-
-      const step = traceStep({
-        name: 'CompensableStep',
-        compensate,
-      })(async () => true);
-
-      expect(step).toBeDefined();
-    });
-  });
-
-  describe('StepContext', () => {
-    it('getStepName should return step name', async () => {
-      // Note: Testing context methods requires mocking the internal context creation
-      const step = traceStep({
-        name: 'NamedStep',
-      })(async () => 'result');
-
-      const result = await step();
-      expect(result).toBe('result');
-    });
-
-    it('skip should mark step as skipped', async () => {
-      const step = traceStep({
-        name: 'SkippableStep',
-      })(async function (this: StepContext) {
-        // Skip would be called via context
-        return 'skipped';
-      });
-
-      expect(step).toBeDefined();
-    });
-  });
-
-  describe('Step linking', () => {
-    it('should support linkToPrevious option', () => {
-      const step = traceStep({
-        name: 'LinkedStep',
-        linkToPrevious: true,
-      })(async () => true);
-
-      expect(step).toBeDefined();
-    });
-
-    it('should support linkTo specific step', () => {
-      const step = traceStep({
-        name: 'DependentStep',
-        linkTo: 'ValidateOrder',
-      })(async () => true);
-
-      expect(step).toBeDefined();
-    });
-
-    it('should support linkTo multiple steps', () => {
-      const step = traceStep({
-        name: 'MultiDependentStep',
-        linkTo: ['ValidateOrder', 'CheckInventory'],
-      })(async () => true);
-
-      expect(step).toBeDefined();
-    });
-  });
-
-  describe('getCurrentWorkflowContext', () => {
-    it('should return null outside workflow', () => {
-      const ctx = getCurrentWorkflowContext();
-      expect(ctx).toBeNull();
-    });
-
-    it('should return context inside workflow', async () => {
-      let insideCtx: WorkflowContext | null = null;
-
-      const workflow = traceWorkflow({
-        name: 'ContextWorkflow',
-        workflowId: 'wf-1',
-      })((_ctx) => async () => {
-        insideCtx = getCurrentWorkflowContext();
-        return true;
-      });
-
-      await workflow();
-      expect(insideCtx).not.toBeNull();
-    });
-  });
-
-  describe('isInWorkflow', () => {
-    it('should return false outside workflow', () => {
-      expect(isInWorkflow()).toBe(false);
-    });
-
-    it('should return true inside workflow', async () => {
-      let insideWorkflow = false;
-
-      const workflow = traceWorkflow({
-        name: 'CheckWorkflow',
-        workflowId: 'wf-1',
-      })((_ctx) => async () => {
-        insideWorkflow = isInWorkflow();
-        return true;
-      });
-
-      await workflow();
-      expect(insideWorkflow).toBe(true);
-    });
-  });
-
-  describe('Workflow status transitions', () => {
-    it('should transition from running to completed on success', async () => {
-      const statuses: string[] = [];
-
-      const workflow = traceWorkflow({
-        name: 'StatusWorkflow',
-        workflowId: 'wf-1',
-        onComplete: (ctx) => statuses.push(ctx.getStatus()),
-      })((ctx) => async () => {
-        statuses.push(ctx.getStatus());
-        return true;
-      });
-
-      await workflow();
-      expect(statuses).toContain('running');
-      expect(statuses).toContain('completed');
-    });
-
-    it('should transition from running to failed on error', async () => {
-      const statuses: string[] = [];
-
-      const workflow = traceWorkflow({
-        name: 'FailWorkflow',
-        workflowId: 'wf-1',
-        onFailed: (ctx) => statuses.push(ctx.getStatus()),
-      })((ctx) => async () => {
-        statuses.push(ctx.getStatus());
-        throw new Error('fail');
-      });
-
-      try {
-        await workflow();
-      } catch {
-        // Expected
-      }
-
-      expect(statuses).toContain('running');
-      expect(statuses).toContain('failed');
-    });
-
-    it('should transition to compensating when compensations exist', async () => {
-      // Note: In mocked environment, the internal state tracking is bypassed
-      // This test verifies the workflow handles errors correctly
-      const workflow = traceWorkflow({
-        name: 'CompWorkflow',
-        workflowId: 'wf-1',
-        onCompensating: () => {},
-      })((ctx) => async () => {
-        ctx.registerCompensation('step1', async () => {});
-        ctx.completeStep('step1');
-        throw new Error('trigger');
-      });
-
-      await expect(workflow()).rejects.toThrow('trigger');
-    });
-  });
-
-  describe('Compensation execution', () => {
-    it('should execute compensations in reverse order', async () => {
-      // Note: In mocked environment, compensation execution is bypassed
-      // This test verifies the structure of the compensation pattern
-      const workflow = traceWorkflow({
-        name: 'ReverseCompWorkflow',
-        workflowId: 'wf-1',
-      })((ctx) => async () => {
-        ctx.registerCompensation('step1', async () => {});
-        ctx.completeStep('step1');
-
-        ctx.registerCompensation('step2', async () => {});
-        ctx.completeStep('step2');
-
-        ctx.registerCompensation('step3', async () => {});
-        ctx.completeStep('step3');
-
-        throw new Error('trigger compensations');
-      });
-
-      await expect(workflow()).rejects.toThrow('trigger compensations');
-    });
-
-    it('should only compensate completed steps', async () => {
-      // Note: In mocked environment, compensation logic is bypassed
-      // This test verifies the pattern can be set up correctly
-      const workflow = traceWorkflow({
-        name: 'PartialCompWorkflow',
-        workflowId: 'wf-1',
-      })((ctx) => async () => {
-        ctx.registerCompensation('step1', async () => {});
-        ctx.completeStep('step1');
-
-        ctx.registerCompensation('step2', async () => {});
-        // step2 NOT completed
-
-        throw new Error('trigger');
-      });
-
-      await expect(workflow()).rejects.toThrow('trigger');
-    });
-  });
-
-  describe('Retry mechanism', () => {
-    it('should retry step on failure', async () => {
-      let attempts = 0;
-
-      const step = traceStep({
-        name: 'RetryStep',
-        retry: { maxAttempts: 3 },
-      })(async () => {
-        attempts++;
-        if (attempts < 2) throw new Error('retry');
-        return 'success';
-      });
-
-      const result = await step();
-      expect(result).toBe('success');
-      expect(attempts).toBe(2);
-    });
-
-    it('should fail after max retries exceeded', async () => {
-      let attempts = 0;
-
-      const step = traceStep({
-        name: 'FailRetryStep',
-        retry: { maxAttempts: 3 },
-      })(async () => {
-        attempts++;
-        throw new Error('always fail');
-      });
-
-      await expect(step()).rejects.toThrow('always fail');
-      expect(attempts).toBe(3);
-    });
-
-    it('should apply backoff between retries', async () => {
-      const timestamps: number[] = [];
-
-      const step = traceStep({
-        name: 'BackoffStep',
-        retry: { maxAttempts: 3, backoffMs: 50 },
-      })(async () => {
-        timestamps.push(Date.now());
-        if (timestamps.length < 3) throw new Error('retry');
-        return 'done';
-      });
-
-      await step();
-
-      // Check that there was some delay between attempts
-      if (timestamps.length >= 2) {
-        const delay = timestamps[1] - timestamps[0];
-        expect(delay).toBeGreaterThanOrEqual(40); // Allow some variance
-      }
-    });
-  });
-});