@c.a.f/testing 1.0.0

package/.build/src/validation/ValidationTestHelpers.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Test helpers for Validation.
+ *
+ * Provides utilities for testing validators and validation runners.
+ *
+ * @example
+ * ```ts
+ * import { createMockValidator, createValidationTester } from '@c.a.f/testing/validation';
+ * import { ValidationRunner } from '@c.a.f/validation';
+ *
+ * const mockValidator = createMockValidator((data) => {
+ *   return data.email && data.email.includes('@');
+ * });
+ * const tester = createValidationTester(mockValidator);
+ *
+ * const result = await tester.validate({ email: 'test@example.com' });
+ * expect(result.success).toBe(true);
+ * ```
+ */
+import type { IValidator, ValidationResult, ValidationError } from '@c.a.f/validation';
+/**
+ * Mock Validator implementation for testing.
+ */
+export declare class MockValidator<T = unknown> implements IValidator<T> {
+    private validateFn;
+    private errorMessage?;
+    constructor(validateFn: (data: unknown) => boolean | Promise<boolean>, errorMessage?: string | undefined);
+    validate(data: unknown): Promise<ValidationResult>;
+    parse(data: unknown): Promise<T>;
+    isValid(data: unknown): Promise<boolean>;
+}
+/**
+ * Create a mock Validator.
+ */
+export declare function createMockValidator<T = unknown>(validateFn: (data: unknown) => boolean | Promise<boolean>, errorMessage?: string): IValidator<T>;
+/**
+ * Validation tester utility.
+ */
+export declare class ValidationTester<T = unknown> {
+    readonly validator: IValidator<T>;
+    constructor(validator: IValidator<T>);
+    /**
+     * Validate data.
+     */
+    validate(data: unknown): Promise<ValidationResult>;
+    /**
+     * Parse and validate data.
+     */
+    parse(data: unknown): Promise<T>;
+    /**
+     * Check if data is valid.
+     */
+    isValid(data: unknown): Promise<boolean>;
+    /**
+     * Validate and expect success.
+     */
+    expectSuccess(data: unknown): Promise<T>;
+    /**
+     * Validate and expect failure.
+     */
+    expectFailure(data: unknown): Promise<ValidationError[]>;
+}
+/**
+ * Create a Validation tester instance.
+ */
+export declare function createValidationTester<T = unknown>(validator: IValidator<T>): ValidationTester<T>;

package/.build/src/validation/ValidationTestHelpers.js

@@ -0,0 +1,118 @@
+/**
+ * Test helpers for Validation.
+ *
+ * Provides utilities for testing validators and validation runners.
+ *
+ * @example
+ * ```ts
+ * import { createMockValidator, createValidationTester } from '@c.a.f/testing/validation';
+ * import { ValidationRunner } from '@c.a.f/validation';
+ *
+ * const mockValidator = createMockValidator((data) => {
+ *   return data.email && data.email.includes('@');
+ * });
+ * const tester = createValidationTester(mockValidator);
+ *
+ * const result = await tester.validate({ email: 'test@example.com' });
+ * expect(result.success).toBe(true);
+ * ```
+ */
+/**
+ * Mock Validator implementation for testing.
+ */
+export class MockValidator {
+    validateFn;
+    errorMessage;
+    constructor(validateFn, errorMessage) {
+        this.validateFn = validateFn;
+        this.errorMessage = errorMessage;
+    }
+    async validate(data) {
+        const isValid = await this.validateFn(data);
+        if (isValid) {
+            return {
+                success: true,
+                errors: [],
+                data: data,
+            };
+        }
+        return {
+            success: false,
+            errors: [
+                {
+                    path: '',
+                    message: this.errorMessage || 'Validation failed',
+                },
+            ],
+        };
+    }
+    async parse(data) {
+        const result = await this.validate(data);
+        if (!result.success) {
+            throw new Error(result.errors.map(e => e.message).join(', '));
+        }
+        return result.data;
+    }
+    async isValid(data) {
+        return await this.validateFn(data);
+    }
+}
+/**
+ * Create a mock Validator.
+ */
+export function createMockValidator(validateFn, errorMessage) {
+    return new MockValidator(validateFn, errorMessage);
+}
+/**
+ * Validation tester utility.
+ */
+export class ValidationTester {
+    validator;
+    constructor(validator) {
+        this.validator = validator;
+    }
+    /**
+     * Validate data.
+     */
+    async validate(data) {
+        return await this.validator.validate(data);
+    }
+    /**
+     * Parse and validate data.
+     */
+    async parse(data) {
+        return await this.validator.parse(data);
+    }
+    /**
+     * Check if data is valid.
+     */
+    async isValid(data) {
+        return await this.validator.isValid(data);
+    }
+    /**
+     * Validate and expect success.
+     */
+    async expectSuccess(data) {
+        const result = await this.validate(data);
+        if (!result.success) {
+            throw new Error(`Expected validation success but got errors: ${result.errors.map(e => e.message).join(', ')}`);
+        }
+        return result.data;
+    }
+    /**
+     * Validate and expect failure.
+     */
+    async expectFailure(data) {
+        const result = await this.validate(data);
+        if (result.success) {
+            throw new Error('Expected validation failure but validation succeeded');
+        }
+        return result.errors;
+    }
+}
+/**
+ * Create a Validation tester instance.
+ */
+export function createValidationTester(validator) {
+    return new ValidationTester(validator);
+}

package/.build/src/validation/index.d.ts

@@ -0,0 +1 @@
+export * from './ValidationTestHelpers';

package/.build/src/validation/index.js

@@ -0,0 +1 @@
+export * from './ValidationTestHelpers';

package/.build/src/workflow/WorkflowTestHelpers.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Test helpers for Workflow.
+ *
+ * Provides utilities for testing WorkflowManager instances.
+ *
+ * @example
+ * ```ts
+ * import { createWorkflowTester, waitForWorkflowState } from '@c.a.f/testing/workflow';
+ * import { WorkflowManager, WorkflowDefinition } from '@c.a.f/workflow';
+ *
+ * const workflow = new WorkflowManager(definition);
+ * const tester = createWorkflowTester(workflow);
+ *
+ * await tester.dispatch('approve');
+ * await waitForWorkflowState(workflow, 'approved');
+ * ```
+ */
+import type { WorkflowManager, WorkflowStateId, WorkflowStateSnapshot } from '@c.a.f/workflow';
+/**
+ * Workflow tester utility.
+ */
+export declare class WorkflowTester {
+    readonly workflow: WorkflowManager;
+    private stateHistory;
+    private listener;
+    constructor(workflow: WorkflowManager);
+    /**
+     * Get the current state snapshot.
+     */
+    getState(): WorkflowStateSnapshot;
+    /**
+     * Get the current state ID.
+     */
+    getCurrentState(): WorkflowStateId;
+    /**
+     * Get the state history.
+     */
+    getStateHistory(): WorkflowStateSnapshot[];
+    /**
+     * Dispatch an event and wait for transition.
+     */
+    dispatch(event: string, payload?: unknown): Promise<boolean>;
+    /**
+     * Check if a transition is available.
+     */
+    canTransition(event: string): boolean;
+    /**
+     * Reset the workflow.
+     */
+    reset(): Promise<void>;
+    /**
+     * Update workflow context.
+     */
+    updateContext(context: Record<string, unknown>): void;
+    /**
+     * Get available transitions from current state.
+     */
+    getAvailableTransitions(): Record<string, unknown>;
+    /**
+     * Cleanup: unsubscribe from state changes.
+     */
+    cleanup(): void;
+}
+/**
+ * Create a Workflow tester instance.
+ */
+export declare function createWorkflowTester(workflow: WorkflowManager): WorkflowTester;
+/**
+ * Wait for workflow to reach a specific state.
+ */
+export declare function waitForWorkflowState(workflow: WorkflowManager, targetState: WorkflowStateId, timeout?: number): Promise<WorkflowStateSnapshot>;
+/**
+ * Wait for workflow to reach a final state.
+ */
+export declare function waitForFinalState(workflow: WorkflowManager, timeout?: number): Promise<WorkflowStateSnapshot>;

package/.build/src/workflow/WorkflowTestHelpers.js

@@ -0,0 +1,146 @@
+/**
+ * Test helpers for Workflow.
+ *
+ * Provides utilities for testing WorkflowManager instances.
+ *
+ * @example
+ * ```ts
+ * import { createWorkflowTester, waitForWorkflowState } from '@c.a.f/testing/workflow';
+ * import { WorkflowManager, WorkflowDefinition } from '@c.a.f/workflow';
+ *
+ * const workflow = new WorkflowManager(definition);
+ * const tester = createWorkflowTester(workflow);
+ *
+ * await tester.dispatch('approve');
+ * await waitForWorkflowState(workflow, 'approved');
+ * ```
+ */
+/**
+ * Workflow tester utility.
+ */
+export class WorkflowTester {
+    workflow;
+    stateHistory = [];
+    listener = null;
+    constructor(workflow) {
+        this.workflow = workflow;
+        this.stateHistory.push(workflow.getState());
+        this.listener = (snapshot) => {
+            this.stateHistory.push(snapshot);
+        };
+        workflow.subscribe(this.listener);
+    }
+    /**
+     * Get the current state snapshot.
+     */
+    getState() {
+        return this.workflow.getState();
+    }
+    /**
+     * Get the current state ID.
+     */
+    getCurrentState() {
+        return this.workflow.getState().currentState;
+    }
+    /**
+     * Get the state history.
+     */
+    getStateHistory() {
+        return [...this.stateHistory];
+    }
+    /**
+     * Dispatch an event and wait for transition.
+     */
+    async dispatch(event, payload) {
+        return await this.workflow.dispatch(event, payload);
+    }
+    /**
+     * Check if a transition is available.
+     */
+    canTransition(event) {
+        return this.workflow.canTransition(event);
+    }
+    /**
+     * Reset the workflow.
+     */
+    async reset() {
+        await this.workflow.reset();
+    }
+    /**
+     * Update workflow context.
+     */
+    updateContext(context) {
+        this.workflow.updateContext(context);
+    }
+    /**
+     * Get available transitions from current state.
+     */
+    getAvailableTransitions() {
+        return this.workflow.getAvailableTransitions();
+    }
+    /**
+     * Cleanup: unsubscribe from state changes.
+     */
+    cleanup() {
+        if (this.listener) {
+            this.workflow.unsubscribe(this.listener);
+            this.listener = null;
+        }
+    }
+}
+/**
+ * Create a Workflow tester instance.
+ */
+export function createWorkflowTester(workflow) {
+    return new WorkflowTester(workflow);
+}
+/**
+ * Wait for workflow to reach a specific state.
+ */
+export function waitForWorkflowState(workflow, targetState, timeout = 5000) {
+    return new Promise((resolve, reject) => {
+        // Check current state first
+        const currentState = workflow.getState();
+        if (currentState.currentState === targetState) {
+            resolve(currentState);
+            return;
+        }
+        const listener = (snapshot) => {
+            if (snapshot.currentState === targetState) {
+                clearTimeout(timer);
+                workflow.unsubscribe(listener);
+                resolve(snapshot);
+            }
+        };
+        const timer = setTimeout(() => {
+            workflow.unsubscribe(listener);
+            reject(new Error(`Timeout waiting for workflow state '${targetState}' (${timeout}ms)`));
+        }, timeout);
+        workflow.subscribe(listener);
+    });
+}
+/**
+ * Wait for workflow to reach a final state.
+ */
+export function waitForFinalState(workflow, timeout = 5000) {
+    return new Promise((resolve, reject) => {
+        // Check current state first
+        const currentState = workflow.getState();
+        if (currentState.isFinal) {
+            resolve(currentState);
+            return;
+        }
+        const listener = (snapshot) => {
+            if (snapshot.isFinal) {
+                clearTimeout(timer);
+                workflow.unsubscribe(listener);
+                resolve(snapshot);
+            }
+        };
+        const timer = setTimeout(() => {
+            workflow.unsubscribe(listener);
+            reject(new Error(`Timeout waiting for final state (${timeout}ms)`));
+        }, timeout);
+        workflow.subscribe(listener);
+    });
+}

package/.build/src/workflow/index.d.ts

@@ -0,0 +1 @@
+export * from './WorkflowTestHelpers';

package/.build/src/workflow/index.js

@@ -0,0 +1 @@
+export * from './WorkflowTestHelpers';

package/.build/vitest.config.d.ts

@@ -0,0 +1,7 @@
+declare const _default: {
+    test: {
+        environment: string;
+        include: string[];
+    };
+};
+export default _default;

package/.build/vitest.config.js

@@ -0,0 +1,6 @@
+export default {
+    test: {
+        environment: 'happy-dom',
+        include: ['**/*.spec.ts', '**/*.spec.tsx'],
+    },
+};