@c-a-f/testing 1.0.1

package/.build/src/core/UseCaseTestHelpers.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Test helpers for UseCase.
+ *
+ * Provides utilities for testing UseCase implementations.
+ *
+ * @example
+ * ```ts
+ * import { createMockUseCase, createUseCaseTester } from '@c-a-f/testing/core';
+ * import { UseCase, RequestResult, pulse } from '@c-a-f/core';
+ *
+ * // Create a mock use case
+ * const mockUseCase = createMockUseCase<User[]>((args) => ({
+ *   loading: pulse(false),
+ *   data: pulse([{ id: '1', name: 'John' }]),
+ *   error: pulse(null! as Error),
+ * }));
+ *
+ * // Test use case
+ * const tester = createUseCaseTester(mockUseCase);
+ * const result = await tester.execute([], { timeout: 1000 });
+ * ```
+ */
+import type { UseCase, RequestResult } from '@c-a-f/core';
+/**
+ * Mock UseCase implementation for testing.
+ */
+export declare class MockUseCase<A extends any[], T> implements UseCase<A, T> {
+    private implementation;
+    constructor(implementation: (...args: A) => Promise<RequestResult<T>> | RequestResult<T>);
+    execute(...args: A): Promise<RequestResult<T>>;
+}
+/**
+ * Create a mock UseCase from an implementation.
+ */
+export declare function createMockUseCase<A extends any[], T>(implementation: (...args: A) => Promise<RequestResult<T>> | RequestResult<T>): UseCase<A, T>;
+/**
+ * Create a mock UseCase that always returns success with the given data.
+ * Useful for unit tests that do not care about loading/error states.
+ *
+ * @example
+ * ```ts
+ * const useCase = createMockUseCaseSuccess([{ id: '1', name: 'John' }]);
+ * const result = await useCase.execute();
+ * expect(result.data.value).toEqual([{ id: '1', name: 'John' }]);
+ * ```
+ */
+export declare function createMockUseCaseSuccess<T>(data: T): UseCase<[], T>;
+/**
+ * Create a mock UseCase that always returns the given error.
+ *
+ * @example
+ * ```ts
+ * const useCase = createMockUseCaseError(new Error('Network failed'));
+ * const result = await useCase.execute();
+ * expect(result.error.value?.message).toBe('Network failed');
+ * ```
+ */
+export declare function createMockUseCaseError<T = unknown>(error: Error): UseCase<[], T>;
+/**
+ * Create a mock UseCase that returns loading then success (async).
+ * Useful for testing loading states.
+ */
+export declare function createMockUseCaseAsync<T>(data: T, delayMs?: number): UseCase<[], T>;
+/**
+ * UseCase tester utility.
+ */
+export declare class UseCaseTester<A extends any[], T> {
+    readonly useCase: UseCase<A, T>;
+    constructor(useCase: UseCase<A, T>);
+    /**
+     * Execute the use case and wait for completion.
+     */
+    execute(args: A, options?: {
+        timeout?: number;
+    }): Promise<RequestResult<T>>;
+    /**
+     * Execute the use case and extract data.
+     */
+    executeAndGetData(args: A): Promise<T>;
+    /**
+     * Execute the use case and check if it succeeds.
+     */
+    executeAndCheckSuccess(args: A): Promise<boolean>;
+}
+/**
+ * Create a UseCase tester instance.
+ */
+export declare function createUseCaseTester<A extends any[], T>(useCase: UseCase<A, T>): UseCaseTester<A, T>;
+/**
+ * Create a successful RequestResult.
+ */
+export declare function createSuccessResult<T>(data: T): RequestResult<T>;
+/**
+ * Create a failed RequestResult.
+ */
+export declare function createErrorResult<T>(error: Error): RequestResult<T>;
+/**
+ * Create a loading RequestResult.
+ */
+export declare function createLoadingResult<T>(): RequestResult<T>;

package/.build/src/core/UseCaseTestHelpers.js

@@ -0,0 +1,161 @@
+/**
+ * Test helpers for UseCase.
+ *
+ * Provides utilities for testing UseCase implementations.
+ *
+ * @example
+ * ```ts
+ * import { createMockUseCase, createUseCaseTester } from '@c-a-f/testing/core';
+ * import { UseCase, RequestResult, pulse } from '@c-a-f/core';
+ *
+ * // Create a mock use case
+ * const mockUseCase = createMockUseCase<User[]>((args) => ({
+ *   loading: pulse(false),
+ *   data: pulse([{ id: '1', name: 'John' }]),
+ *   error: pulse(null! as Error),
+ * }));
+ *
+ * // Test use case
+ * const tester = createUseCaseTester(mockUseCase);
+ * const result = await tester.execute([], { timeout: 1000 });
+ * ```
+ */
+import { pulse } from '@c-a-f/core';
+/**
+ * Mock UseCase implementation for testing.
+ */
+export class MockUseCase {
+    implementation;
+    constructor(implementation) {
+        this.implementation = implementation;
+    }
+    async execute(...args) {
+        return await this.implementation(...args);
+    }
+}
+/**
+ * Create a mock UseCase from an implementation.
+ */
+export function createMockUseCase(implementation) {
+    return new MockUseCase(implementation);
+}
+/**
+ * Create a mock UseCase that always returns success with the given data.
+ * Useful for unit tests that do not care about loading/error states.
+ *
+ * @example
+ * ```ts
+ * const useCase = createMockUseCaseSuccess([{ id: '1', name: 'John' }]);
+ * const result = await useCase.execute();
+ * expect(result.data.value).toEqual([{ id: '1', name: 'John' }]);
+ * ```
+ */
+export function createMockUseCaseSuccess(data) {
+    return new MockUseCase(() => createSuccessResult(data));
+}
+/**
+ * Create a mock UseCase that always returns the given error.
+ *
+ * @example
+ * ```ts
+ * const useCase = createMockUseCaseError(new Error('Network failed'));
+ * const result = await useCase.execute();
+ * expect(result.error.value?.message).toBe('Network failed');
+ * ```
+ */
+export function createMockUseCaseError(error) {
+    return new MockUseCase(() => createErrorResult(error));
+}
+/**
+ * Create a mock UseCase that returns loading then success (async).
+ * Useful for testing loading states.
+ */
+export function createMockUseCaseAsync(data, delayMs = 0) {
+    return new MockUseCase(() => new Promise((resolve) => {
+        if (delayMs <= 0) {
+            resolve(createSuccessResult(data));
+        }
+        else {
+            setTimeout(() => resolve(createSuccessResult(data)), delayMs);
+        }
+    }));
+}
+/**
+ * UseCase tester utility.
+ */
+export class UseCaseTester {
+    useCase;
+    constructor(useCase) {
+        this.useCase = useCase;
+    }
+    /**
+     * Execute the use case and wait for completion.
+     */
+    async execute(args, options) {
+        const timeout = options?.timeout || 5000;
+        return Promise.race([
+            this.useCase.execute(...args),
+            new Promise((_, reject) => {
+                setTimeout(() => reject(new Error(`UseCase execution timeout (${timeout}ms)`)), timeout);
+            }),
+        ]);
+    }
+    /**
+     * Execute the use case and extract data.
+     */
+    async executeAndGetData(args) {
+        const result = await this.execute(args);
+        if (result.error.value) {
+            throw result.error.value;
+        }
+        return result.data.value;
+    }
+    /**
+     * Execute the use case and check if it succeeds.
+     */
+    async executeAndCheckSuccess(args) {
+        try {
+            const result = await this.execute(args);
+            return !result.error.value;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+/**
+ * Create a UseCase tester instance.
+ */
+export function createUseCaseTester(useCase) {
+    return new UseCaseTester(useCase);
+}
+/**
+ * Create a successful RequestResult.
+ */
+export function createSuccessResult(data) {
+    return {
+        loading: pulse(false),
+        data: pulse(data),
+        error: pulse(null),
+    };
+}
+/**
+ * Create a failed RequestResult.
+ */
+export function createErrorResult(error) {
+    return {
+        loading: pulse(false),
+        data: pulse(null),
+        error: pulse(error),
+    };
+}
+/**
+ * Create a loading RequestResult.
+ */
+export function createLoadingResult() {
+    return {
+        loading: pulse(true),
+        data: pulse(null),
+        error: pulse(null),
+    };
+}

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

@@ -0,0 +1,6 @@
+export * from './PlocTestHelpers';
+export * from './PulseTestHelpers';
+export * from './UseCaseTestHelpers';
+export * from './RouteTestHelpers';
+export * from './RepositoryTestHelpers';
+export * from './IntegrationTestHelpers';

package/.build/src/core/index.js

@@ -0,0 +1,6 @@
+export * from './PlocTestHelpers';
+export * from './PulseTestHelpers';
+export * from './UseCaseTestHelpers';
+export * from './RouteTestHelpers';
+export * from './RepositoryTestHelpers';
+export * from './IntegrationTestHelpers';

package/.build/src/i18n/I18nTestHelpers.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Test helpers for I18n.
+ *
+ * Provides utilities for testing translation managers and translators.
+ *
+ * @example
+ * ```ts
+ * import { createMockTranslator, createTranslationTester } from '@c-a-f/testing/i18n';
+ * import { TranslationManager } from '@c-a-f/i18n';
+ *
+ * const mockTranslator = createMockTranslator({
+ *   en: { 'greeting': 'Hello', 'welcome': 'Welcome {{name}}' },
+ *   fa: { 'greeting': 'سلام', 'welcome': 'خوش آمدید {{name}}' },
+ * });
+ * const manager = new TranslationManager(mockTranslator);
+ * const tester = createTranslationTester(manager);
+ *
+ * expect(tester.t('greeting')).toBe('Hello');
+ * ```
+ */
+import type { ITranslator, TranslationManager } from '@c-a-f/i18n';
+/**
+ * Mock Translator implementation for testing.
+ */
+export declare class MockTranslator implements ITranslator {
+    private translations;
+    private currentLanguage;
+    constructor(translations?: Record<string, Record<string, string>>, currentLanguage?: string);
+    translate(key: string, options?: Record<string, unknown>): string;
+    getCurrentLanguage(): string;
+    changeLanguage(language: string): Promise<void>;
+    exists(key: string): boolean;
+    /**
+     * Add translations (for testing).
+     */
+    addTranslations(language: string, translations: Record<string, string>): void;
+}
+/**
+ * Create a mock Translator.
+ */
+export declare function createMockTranslator(translations?: Record<string, Record<string, string>>, initialLanguage?: string): MockTranslator;
+/**
+ * Translation tester utility.
+ */
+export declare class TranslationTester {
+    readonly manager: TranslationManager;
+    constructor(manager: TranslationManager);
+    /**
+     * Translate a key.
+     */
+    t(key: string, options?: Record<string, unknown>): string;
+    /**
+     * Translate with values.
+     */
+    translateWithValues(key: string, values: Record<string, unknown>): string;
+    /**
+     * Translate plural.
+     */
+    translatePlural(key: string, count: number, options?: Record<string, unknown>): string;
+    /**
+     * Get current language.
+     */
+    getCurrentLanguage(): string;
+    /**
+     * Change language.
+     */
+    changeLanguage(language: string): Promise<void>;
+    /**
+     * Check if key exists.
+     */
+    hasKey(key: string): boolean;
+}
+/**
+ * Create a Translation tester instance.
+ */
+export declare function createTranslationTester(manager: TranslationManager): TranslationTester;

package/.build/src/i18n/I18nTestHelpers.js

@@ -0,0 +1,122 @@
+/**
+ * Test helpers for I18n.
+ *
+ * Provides utilities for testing translation managers and translators.
+ *
+ * @example
+ * ```ts
+ * import { createMockTranslator, createTranslationTester } from '@c-a-f/testing/i18n';
+ * import { TranslationManager } from '@c-a-f/i18n';
+ *
+ * const mockTranslator = createMockTranslator({
+ *   en: { 'greeting': 'Hello', 'welcome': 'Welcome {{name}}' },
+ *   fa: { 'greeting': 'سلام', 'welcome': 'خوش آمدید {{name}}' },
+ * });
+ * const manager = new TranslationManager(mockTranslator);
+ * const tester = createTranslationTester(manager);
+ *
+ * expect(tester.t('greeting')).toBe('Hello');
+ * ```
+ */
+/**
+ * Mock Translator implementation for testing.
+ */
+export class MockTranslator {
+    translations;
+    currentLanguage;
+    constructor(translations = {}, currentLanguage = 'en') {
+        this.translations = translations;
+        this.currentLanguage = currentLanguage;
+    }
+    translate(key, options) {
+        const langTranslations = this.translations[this.currentLanguage] || {};
+        let text = langTranslations[key] || key;
+        // Simple interpolation
+        if (options) {
+            Object.keys(options).forEach((k) => {
+                if (k !== 'ns' && k !== 'defaultValue' && k !== 'count' && k !== 'returnObjects') {
+                    const value = String(options[k]);
+                    text = text.replace(new RegExp(`{{${k}}}`, 'g'), value);
+                    text = text.replace(new RegExp(`\\{${k}\\}`, 'g'), value);
+                }
+            });
+        }
+        return text;
+    }
+    getCurrentLanguage() {
+        return this.currentLanguage;
+    }
+    async changeLanguage(language) {
+        this.currentLanguage = language;
+    }
+    exists(key) {
+        const langTranslations = this.translations[this.currentLanguage] || {};
+        return key in langTranslations;
+    }
+    /**
+     * Add translations (for testing).
+     */
+    addTranslations(language, translations) {
+        if (!this.translations[language]) {
+            this.translations[language] = {};
+        }
+        this.translations[language] = { ...this.translations[language], ...translations };
+    }
+}
+/**
+ * Create a mock Translator.
+ */
+export function createMockTranslator(translations = {}, initialLanguage = 'en') {
+    return new MockTranslator(translations, initialLanguage);
+}
+/**
+ * Translation tester utility.
+ */
+export class TranslationTester {
+    manager;
+    constructor(manager) {
+        this.manager = manager;
+    }
+    /**
+     * Translate a key.
+     */
+    t(key, options) {
+        return this.manager.t(key, options);
+    }
+    /**
+     * Translate with values.
+     */
+    translateWithValues(key, values) {
+        return this.manager.translateWithValues(key, values);
+    }
+    /**
+     * Translate plural.
+     */
+    translatePlural(key, count, options) {
+        return this.manager.translatePlural(key, count, options);
+    }
+    /**
+     * Get current language.
+     */
+    getCurrentLanguage() {
+        return this.manager.getCurrentLanguage();
+    }
+    /**
+     * Change language.
+     */
+    async changeLanguage(language) {
+        await this.manager.changeLanguage(language);
+    }
+    /**
+     * Check if key exists.
+     */
+    hasKey(key) {
+        return this.manager.hasKey(key);
+    }
+}
+/**
+ * Create a Translation tester instance.
+ */
+export function createTranslationTester(manager) {
+    return new TranslationTester(manager);
+}

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

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

package/.build/src/i18n/index.js

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

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

@@ -0,0 +1,5 @@
+export * from './core';
+export * from './workflow';
+export * from './permission';
+export * from './i18n';
+export * from './validation';

package/.build/src/index.js

@@ -0,0 +1,10 @@
+// Core testing utilities
+export * from './core';
+// Workflow testing utilities
+export * from './workflow';
+// Permission testing utilities
+export * from './permission';
+// I18n testing utilities
+export * from './i18n';
+// Validation testing utilities
+export * from './validation';

package/.build/src/permission/PermissionTestHelpers.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Test helpers for Permission.
+ *
+ * Provides utilities for testing permission checkers and managers.
+ *
+ * @example
+ * ```ts
+ * import { createMockPermissionChecker, createPermissionTester } from '@c-a-f/testing/permission';
+ * import { PermissionManager } from '@c-a-f/permission';
+ *
+ * const mockChecker = createMockPermissionChecker(['user.edit', 'post.create']);
+ * const manager = new PermissionManager(mockChecker);
+ * const tester = createPermissionTester(manager);
+ *
+ * expect(await tester.hasPermission('user.edit')).toBe(true);
+ * ```
+ */
+import type { IPermissionChecker, PermissionResult, PermissionManager } from '@c-a-f/permission';
+/**
+ * Mock PermissionChecker implementation for testing.
+ */
+export declare class MockPermissionChecker implements IPermissionChecker {
+    private allowedPermissions;
+    constructor(allowedPermissions?: string[]);
+    check(permission: string): PermissionResult;
+    checkAny(permissions: string[]): PermissionResult;
+    checkAll(permissions: string[]): PermissionResult;
+    /**
+     * Add a permission (for testing).
+     */
+    addPermission(permission: string): void;
+    /**
+     * Remove a permission (for testing).
+     */
+    removePermission(permission: string): void;
+}
+/**
+ * Create a mock PermissionChecker.
+ */
+export declare function createMockPermissionChecker(allowedPermissions?: string[]): MockPermissionChecker;
+/**
+ * Permission tester utility.
+ */
+export declare class PermissionTester {
+    readonly manager: PermissionManager;
+    constructor(manager: PermissionManager);
+    /**
+     * Check if permission is granted.
+     */
+    hasPermission(permission: string): Promise<boolean>;
+    /**
+     * Check if any permission is granted.
+     */
+    hasAnyPermission(permissions: string[]): Promise<boolean>;
+    /**
+     * Check if all permissions are granted.
+     */
+    hasAllPermissions(permissions: string[]): Promise<boolean>;
+    /**
+     * Require permission (throws if denied).
+     */
+    requirePermission(permission: string): Promise<void>;
+    /**
+     * Require any permission (throws if all denied).
+     */
+    requireAnyPermission(permissions: string[]): Promise<void>;
+    /**
+     * Require all permissions (throws if any denied).
+     */
+    requireAllPermissions(permissions: string[]): Promise<void>;
+}
+/**
+ * Create a Permission tester instance.
+ */
+export declare function createPermissionTester(manager: PermissionManager): PermissionTester;

package/.build/src/permission/PermissionTestHelpers.js

@@ -0,0 +1,121 @@
+/**
+ * Test helpers for Permission.
+ *
+ * Provides utilities for testing permission checkers and managers.
+ *
+ * @example
+ * ```ts
+ * import { createMockPermissionChecker, createPermissionTester } from '@c-a-f/testing/permission';
+ * import { PermissionManager } from '@c-a-f/permission';
+ *
+ * const mockChecker = createMockPermissionChecker(['user.edit', 'post.create']);
+ * const manager = new PermissionManager(mockChecker);
+ * const tester = createPermissionTester(manager);
+ *
+ * expect(await tester.hasPermission('user.edit')).toBe(true);
+ * ```
+ */
+/**
+ * Mock PermissionChecker implementation for testing.
+ */
+export class MockPermissionChecker {
+    allowedPermissions;
+    constructor(allowedPermissions = []) {
+        this.allowedPermissions = allowedPermissions;
+    }
+    check(permission) {
+        const granted = this.allowedPermissions.includes(permission);
+        return {
+            granted,
+            reason: granted ? undefined : `Permission '${permission}' not granted`,
+        };
+    }
+    checkAny(permissions) {
+        const granted = permissions.some(p => this.allowedPermissions.includes(p));
+        return {
+            granted,
+            reason: granted ? undefined : 'None of the permissions are granted',
+        };
+    }
+    checkAll(permissions) {
+        const missing = permissions.filter(p => !this.allowedPermissions.includes(p));
+        return {
+            granted: missing.length === 0,
+            reason: missing.length > 0 ? `Missing permissions: ${missing.join(', ')}` : undefined,
+        };
+    }
+    /**
+     * Add a permission (for testing).
+     */
+    addPermission(permission) {
+        if (!this.allowedPermissions.includes(permission)) {
+            this.allowedPermissions.push(permission);
+        }
+    }
+    /**
+     * Remove a permission (for testing).
+     */
+    removePermission(permission) {
+        const index = this.allowedPermissions.indexOf(permission);
+        if (index > -1) {
+            this.allowedPermissions.splice(index, 1);
+        }
+    }
+}
+/**
+ * Create a mock PermissionChecker.
+ */
+export function createMockPermissionChecker(allowedPermissions = []) {
+    return new MockPermissionChecker(allowedPermissions);
+}
+/**
+ * Permission tester utility.
+ */
+export class PermissionTester {
+    manager;
+    constructor(manager) {
+        this.manager = manager;
+    }
+    /**
+     * Check if permission is granted.
+     */
+    async hasPermission(permission) {
+        return await this.manager.hasPermission(permission);
+    }
+    /**
+     * Check if any permission is granted.
+     */
+    async hasAnyPermission(permissions) {
+        return await this.manager.hasAnyPermission(permissions);
+    }
+    /**
+     * Check if all permissions are granted.
+     */
+    async hasAllPermissions(permissions) {
+        return await this.manager.hasAllPermissions(permissions);
+    }
+    /**
+     * Require permission (throws if denied).
+     */
+    async requirePermission(permission) {
+        await this.manager.requirePermission(permission);
+    }
+    /**
+     * Require any permission (throws if all denied).
+     */
+    async requireAnyPermission(permissions) {
+        await this.manager.requireAnyPermission(permissions);
+    }
+    /**
+     * Require all permissions (throws if any denied).
+     */
+    async requireAllPermissions(permissions) {
+        await this.manager.requireAllPermissions(permissions);
+    }
+}
+/**
+ * Create a Permission tester instance.
+ */
+export function createPermissionTester(manager) {
+    return new PermissionTester(manager);
+}

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

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