npm install --save-dev @siglo/testing

import { expect } from 'chai';
import { Step, flow } from '@siglo/core';
import { createWorkflowHarness } from '@siglo/testing';

const validateUser = Step.create('validate', async (param: { email: string }) => {
    if (!param.email.includes('@')) throw new Error('Invalid email');
    return { valid: true };
});

const sendEmail = Step.create('sendEmail', async (param: { email: string }) => {
    return { delivered: true };
});

const onboardingFlow = flow(validateUser, sendEmail);

describe('User Onboarding Workflow', () => {
    it('executes steps and verifies completion with harness', async () => {
        const harness = createWorkflowHarness(onboardingFlow);

        // Spy on individual steps
        const emailSpy = harness.spyStep('sendEmail');

        const result = await harness.run({ email: '[email protected]' });

        expect(result.delivered).to.be.true;
        expect(emailSpy.called).to.be.true;
        expect(emailSpy.callCount).to.equal(1);

        // Assertion helpers
        harness.assertStepExecuted('validate');
        harness.assertStepExecuted('sendEmail');
    });
});

it('mocks payment step and verifies compensation rollback', async () => {
    const harness = createWorkflowHarness(checkoutFlow);

    // Mock payment step to throw a simulated decline
    harness.mockStep('chargePayment', async input => {
        throw new Error('Card declined: Insufficient funds');
    });

    try {
        await harness.run({ orderId: 'ord-123', amount: 500 });
        expect.fail('Workflow should have thrown');
    } catch (err: any) {
        expect(err.message).to.include('Card declined');
        harness.assertStepFailed('chargePayment');
    }
});

import { FakeClock } from '@siglo/testing';

const clock = new FakeClock();

// Advance virtual timestamp by 1 hour
clock.advanceTime(60 * 60 * 1000);

// Advance virtual clock and flush microtask loop
await clock.tick(1000);

import { createWorkflowHarness, sanitizeExecutionRecord, replayExecution } from '@siglo/testing';

it('replays a recorded execution and validates deterministic parity', async () => {
    const harness = createWorkflowHarness(orderPipeline);
    const result = await harness.run({ orderId: '1001', amount: 150 });

    // 1. Export execution trace record
    const record = harness.exportExecutionRecord();

    // 2. Sanitize sensitive keys
    const sanitized = sanitizeExecutionRecord(record, { excludeKeys: ['creditCard', 'cvv'] });

    // 3. Replay against workflow definition
    const replay = await replayExecution(sanitized, orderPipeline);

    expect(replay.matched).to.be.true;
    expect(replay.discrepancies).to.have.length(0);
});