@c-a-f/testing 1.0.1

package/.build/src/permission/index.js

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

package/.build/src/react/createTestPloc.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Create a Ploc instance for React component tests. Same as createMockPloc from core:
+ * a Ploc with controllable state and no business logic. Use with renderWithCAF.
+ *
+ * @example
+ * ```tsx
+ * import { createTestPloc, renderWithCAF } from '@c-a-f/testing/react';
+ *
+ * const ploc = createTestPloc({ count: 0 });
+ * const { getByRole } = renderWithCAF(<Counter />, { plocs: { counter: ploc } });
+ * ploc.changeState({ count: 1 });
+ * expect(screen.getByText('1')).toBeInTheDocument();
+ * ```
+ */
+import type { Ploc } from '@c-a-f/core';
+/**
+ * Create a test Ploc with initial state. Use changeState() to drive state in tests.
+ */
+export declare function createTestPloc<S>(initialState: S): Ploc<S>;

package/.build/src/react/createTestPloc.js

@@ -0,0 +1,21 @@
+/**
+ * Create a Ploc instance for React component tests. Same as createMockPloc from core:
+ * a Ploc with controllable state and no business logic. Use with renderWithCAF.
+ *
+ * @example
+ * ```tsx
+ * import { createTestPloc, renderWithCAF } from '@c-a-f/testing/react';
+ *
+ * const ploc = createTestPloc({ count: 0 });
+ * const { getByRole } = renderWithCAF(<Counter />, { plocs: { counter: ploc } });
+ * ploc.changeState({ count: 1 });
+ * expect(screen.getByText('1')).toBeInTheDocument();
+ * ```
+ */
+import { createMockPloc } from '../core/PlocTestHelpers';
+/**
+ * Create a test Ploc with initial state. Use changeState() to drive state in tests.
+ */
+export function createTestPloc(initialState) {
+    return createMockPloc(initialState);
+}

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

@@ -0,0 +1,12 @@
+/**
+ * React testing utilities for CAF.
+ *
+ * - renderWithCAF: render with CAFProvider (Ploc/UseCase context)
+ * - createTestPloc: create a test Ploc with controllable state
+ * - waitForPlocState: wait for Ploc state to match a predicate
+ * - mockUseCase: mock UseCase (success, error, async, fn)
+ */
+export { renderWithCAF, type RenderWithCAFOptions } from './renderWithCAF';
+export { createTestPloc } from './createTestPloc';
+export { waitForPlocState } from './waitForPlocState';
+export { mockUseCase } from './mockUseCase';

package/.build/src/react/index.js

@@ -0,0 +1,12 @@
+/**
+ * React testing utilities for CAF.
+ *
+ * - renderWithCAF: render with CAFProvider (Ploc/UseCase context)
+ * - createTestPloc: create a test Ploc with controllable state
+ * - waitForPlocState: wait for Ploc state to match a predicate
+ * - mockUseCase: mock UseCase (success, error, async, fn)
+ */
+export { renderWithCAF } from './renderWithCAF';
+export { createTestPloc } from './createTestPloc';
+export { waitForPlocState } from './waitForPlocState';
+export { mockUseCase } from './mockUseCase';

package/.build/src/react/mockUseCase.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Helpers to create mock UseCases for React component tests. Use with renderWithCAF.
+ *
+ * @example
+ * ```tsx
+ * import { renderWithCAF, mockUseCase } from '@c-a-f/testing/react';
+ *
+ * const submit = mockUseCase.success({ id: '1' });
+ * renderWithCAF(<Form />, { useCases: { submit } });
+ *
+ * // Or error
+ * const load = mockUseCase.error(new Error('Network error'));
+ *
+ * // Or custom implementation
+ * const search = mockUseCase.fn((query: string) => createSuccessResult([{ id: '1', title: query }]));
+ * ```
+ */
+import type { UseCase, RequestResult } from '@c-a-f/core';
+export declare const mockUseCase: {
+    /**
+     * UseCase that always returns success with the given data.
+     */
+    success<T>(data: T): UseCase<[], T>;
+    /**
+     * UseCase that always returns the given error.
+     */
+    error<T_1 = unknown>(error: Error): UseCase<[], T_1>;
+    /**
+     * UseCase that resolves with data after an optional delay (for loading-state tests).
+     */
+    async<T_2>(data: T_2, delayMs?: number): UseCase<[], T_2>;
+    /**
+     * UseCase with a custom implementation (same as createMockUseCase).
+     */
+    fn<A extends any[], T_3>(implementation: (...args: A) => RequestResult<T_3> | Promise<RequestResult<T_3>>): UseCase<A, T_3>;
+};

package/.build/src/react/mockUseCase.js

@@ -0,0 +1,44 @@
+/**
+ * Helpers to create mock UseCases for React component tests. Use with renderWithCAF.
+ *
+ * @example
+ * ```tsx
+ * import { renderWithCAF, mockUseCase } from '@c-a-f/testing/react';
+ *
+ * const submit = mockUseCase.success({ id: '1' });
+ * renderWithCAF(<Form />, { useCases: { submit } });
+ *
+ * // Or error
+ * const load = mockUseCase.error(new Error('Network error'));
+ *
+ * // Or custom implementation
+ * const search = mockUseCase.fn((query: string) => createSuccessResult([{ id: '1', title: query }]));
+ * ```
+ */
+import { createMockUseCase, createMockUseCaseSuccess, createMockUseCaseError, createMockUseCaseAsync, } from '../core/UseCaseTestHelpers';
+export const mockUseCase = {
+    /**
+     * UseCase that always returns success with the given data.
+     */
+    success(data) {
+        return createMockUseCaseSuccess(data);
+    },
+    /**
+     * UseCase that always returns the given error.
+     */
+    error(error) {
+        return createMockUseCaseError(error);
+    },
+    /**
+     * UseCase that resolves with data after an optional delay (for loading-state tests).
+     */
+    async(data, delayMs = 0) {
+        return createMockUseCaseAsync(data, delayMs);
+    },
+    /**
+     * UseCase with a custom implementation (same as createMockUseCase).
+     */
+    fn(implementation) {
+        return createMockUseCase(implementation);
+    },
+};

package/.build/src/react/renderWithCAF.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Render a React component with CAFProvider so that usePlocFromContext and
+ * useUseCaseFromContext work. Use this instead of raw render() when testing
+ * components that depend on CAF context.
+ *
+ * @example
+ * ```tsx
+ * import { renderWithCAF, createTestPloc, mockUseCase } from '@c-a-f/testing/react';
+ *
+ * const ploc = createTestPloc({ count: 0 });
+ * const { getByRole } = renderWithCAF(<Counter />, {
+ *   plocs: { counter: ploc },
+ *   useCases: { submit: mockUseCase.success({ id: '1' }) },
+ * });
+ * ```
+ */
+import { type ReactElement } from 'react';
+import { type RenderOptions, type RenderResult } from '@testing-library/react';
+import type { Ploc } from '@c-a-f/core';
+import type { UseCase } from '@c-a-f/core';
+export interface RenderWithCAFOptions extends Omit<RenderOptions, 'wrapper'> {
+    /** Plocs to provide (keyed by string). */
+    plocs?: Record<string, Ploc<unknown>>;
+    /** UseCases to provide (keyed by string). */
+    useCases?: Record<string, UseCase<any[], any>>;
+}
+/**
+ * Render a component with CAFProvider so Ploc/UseCase context is available.
+ * Returns the same result as React Testing Library's render().
+ */
+export declare function renderWithCAF(ui: ReactElement, options?: RenderWithCAFOptions): RenderResult;

package/.build/src/react/renderWithCAF.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from '@testing-library/react';
+import { CAFProvider } from '@c-a-f/infrastructure-react';
+/**
+ * Wrapper that provides CAFProvider around the component tree.
+ */
+function createCAFWrapper(plocs, useCases) {
+    return function Wrapper({ children }) {
+        return (_jsx(CAFProvider, { plocs: plocs ?? {}, useCases: useCases ?? {}, children: children }));
+    };
+}
+/**
+ * Render a component with CAFProvider so Ploc/UseCase context is available.
+ * Returns the same result as React Testing Library's render().
+ */
+export function renderWithCAF(ui, options = {}) {
+    const { plocs, useCases, ...renderOptions } = options;
+    const Wrapper = createCAFWrapper(plocs, useCases);
+    return render(ui, {
+        ...renderOptions,
+        wrapper: Wrapper,
+    });
+}

package/.build/src/react/waitForPlocState.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Wait for a Ploc to reach a state that matches a predicate. Useful in React tests
+ * after triggering an action that updates the Ploc asynchronously.
+ *
+ * @example
+ * ```tsx
+ * import { renderWithCAF, createTestPloc, waitForPlocState } from '@c-a-f/testing/react';
+ *
+ * const ploc = createTestPloc({ loading: true, items: [] });
+ * renderWithCAF(<List />, { plocs: { list: ploc } });
+ *
+ * // Simulate load complete
+ * ploc.changeState({ loading: false, items: [{ id: '1' }] });
+ * await waitForPlocState(ploc, (state) => !state.loading && state.items.length > 0);
+ * expect(screen.getByText('1')).toBeInTheDocument();
+ * ```
+ */
+import type { Ploc } from '@c-a-f/core';
+/**
+ * Wait until the Ploc's state satisfies the predicate (or timeout).
+ */
+export declare function waitForPlocState<S>(ploc: Ploc<S>, predicate: (state: S) => boolean, timeoutMs?: number): Promise<S>;

package/.build/src/react/waitForPlocState.js

@@ -0,0 +1,24 @@
+/**
+ * Wait for a Ploc to reach a state that matches a predicate. Useful in React tests
+ * after triggering an action that updates the Ploc asynchronously.
+ *
+ * @example
+ * ```tsx
+ * import { renderWithCAF, createTestPloc, waitForPlocState } from '@c-a-f/testing/react';
+ *
+ * const ploc = createTestPloc({ loading: true, items: [] });
+ * renderWithCAF(<List />, { plocs: { list: ploc } });
+ *
+ * // Simulate load complete
+ * ploc.changeState({ loading: false, items: [{ id: '1' }] });
+ * await waitForPlocState(ploc, (state) => !state.loading && state.items.length > 0);
+ * expect(screen.getByText('1')).toBeInTheDocument();
+ * ```
+ */
+import { waitForStateChange } from '../core/PlocTestHelpers';
+/**
+ * Wait until the Ploc's state satisfies the predicate (or timeout).
+ */
+export function waitForPlocState(ploc, predicate, timeoutMs = 5000) {
+    return waitForStateChange(ploc, predicate, timeoutMs);
+}

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/vue/createTestPloc.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Create a Ploc instance for Vue component tests. Same as createMockPloc from core:
+ * a Ploc with controllable state and no business logic. Use with mountWithCAF.
+ *
+ * @example
+ * ```ts
+ * import { createTestPloc, mountWithCAF } from '@c-a-f/testing/vue';
+ *
+ * const ploc = createTestPloc({ count: 0 });
+ * const wrapper = mountWithCAF(MyComponent, { plocs: { counter: ploc } });
+ * ploc.changeState({ count: 1 });
+ * expect(wrapper.text()).toContain('1');
+ * ```
+ */
+import type { Ploc } from '@c-a-f/core';
+/**
+ * Create a test Ploc with initial state. Use changeState() to drive state in tests.
+ */
+export declare function createTestPloc<S>(initialState: S): Ploc<S>;

package/.build/src/vue/createTestPloc.js

@@ -0,0 +1,21 @@
+/**
+ * Create a Ploc instance for Vue component tests. Same as createMockPloc from core:
+ * a Ploc with controllable state and no business logic. Use with mountWithCAF.
+ *
+ * @example
+ * ```ts
+ * import { createTestPloc, mountWithCAF } from '@c-a-f/testing/vue';
+ *
+ * const ploc = createTestPloc({ count: 0 });
+ * const wrapper = mountWithCAF(MyComponent, { plocs: { counter: ploc } });
+ * ploc.changeState({ count: 1 });
+ * expect(wrapper.text()).toContain('1');
+ * ```
+ */
+import { createMockPloc } from '../core/PlocTestHelpers';
+/**
+ * Create a test Ploc with initial state. Use changeState() to drive state in tests.
+ */
+export function createTestPloc(initialState) {
+    return createMockPloc(initialState);
+}

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

@@ -0,0 +1,12 @@
+/**
+ * Vue testing utilities for CAF.
+ *
+ * - mountWithCAF: mount with CAF context (Ploc/UseCase provide)
+ * - createTestPloc: create a test Ploc with controllable state
+ * - waitForPlocState: wait for Ploc state to match a predicate
+ * - mockUseCase: mock UseCase (success, error, async, fn)
+ */
+export { mountWithCAF, type MountWithCAFOptions } from './mountWithCAF';
+export { createTestPloc } from './createTestPloc';
+export { waitForPlocState } from './waitForPlocState';
+export { mockUseCase } from './mockUseCase';

package/.build/src/vue/index.js

@@ -0,0 +1,12 @@
+/**
+ * Vue testing utilities for CAF.
+ *
+ * - mountWithCAF: mount with CAF context (Ploc/UseCase provide)
+ * - createTestPloc: create a test Ploc with controllable state
+ * - waitForPlocState: wait for Ploc state to match a predicate
+ * - mockUseCase: mock UseCase (success, error, async, fn)
+ */
+export { mountWithCAF } from './mountWithCAF';
+export { createTestPloc } from './createTestPloc';
+export { waitForPlocState } from './waitForPlocState';
+export { mockUseCase } from './mockUseCase';

package/.build/src/vue/mockUseCase.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Helpers to create mock UseCases for Vue component tests. Use with mountWithCAF.
+ *
+ * @example
+ * ```ts
+ * import { mountWithCAF, mockUseCase } from '@c-a-f/testing/vue';
+ *
+ * const submit = mockUseCase.success({ id: '1' });
+ * mountWithCAF(FormComponent, { useCases: { submit } });
+ *
+ * const load = mockUseCase.error(new Error('Network error'));
+ *
+ * const search = mockUseCase.fn((query: string) => createSuccessResult([{ id: '1', title: query }]));
+ * ```
+ */
+import type { UseCase, RequestResult } from '@c-a-f/core';
+export declare const mockUseCase: {
+    /**
+     * UseCase that always returns success with the given data.
+     */
+    success<T>(data: T): UseCase<[], T>;
+    /**
+     * UseCase that always returns the given error.
+     */
+    error<T_1 = unknown>(error: Error): UseCase<[], T_1>;
+    /**
+     * UseCase that resolves with data after an optional delay (for loading-state tests).
+     */
+    async<T_2>(data: T_2, delayMs?: number): UseCase<[], T_2>;
+    /**
+     * UseCase with a custom implementation (same as createMockUseCase).
+     */
+    fn<A extends any[], T_3>(implementation: (...args: A) => RequestResult<T_3> | Promise<RequestResult<T_3>>): UseCase<A, T_3>;
+};

package/.build/src/vue/mockUseCase.js

@@ -0,0 +1,42 @@
+/**
+ * Helpers to create mock UseCases for Vue component tests. Use with mountWithCAF.
+ *
+ * @example
+ * ```ts
+ * import { mountWithCAF, mockUseCase } from '@c-a-f/testing/vue';
+ *
+ * const submit = mockUseCase.success({ id: '1' });
+ * mountWithCAF(FormComponent, { useCases: { submit } });
+ *
+ * const load = mockUseCase.error(new Error('Network error'));
+ *
+ * const search = mockUseCase.fn((query: string) => createSuccessResult([{ id: '1', title: query }]));
+ * ```
+ */
+import { createMockUseCase, createMockUseCaseSuccess, createMockUseCaseError, createMockUseCaseAsync, } from '../core/UseCaseTestHelpers';
+export const mockUseCase = {
+    /**
+     * UseCase that always returns success with the given data.
+     */
+    success(data) {
+        return createMockUseCaseSuccess(data);
+    },
+    /**
+     * UseCase that always returns the given error.
+     */
+    error(error) {
+        return createMockUseCaseError(error);
+    },
+    /**
+     * UseCase that resolves with data after an optional delay (for loading-state tests).
+     */
+    async(data, delayMs = 0) {
+        return createMockUseCaseAsync(data, delayMs);
+    },
+    /**
+     * UseCase with a custom implementation (same as createMockUseCase).
+     */
+    fn(implementation) {
+        return createMockUseCase(implementation);
+    },
+};

package/.build/src/vue/mountWithCAF.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Mount a Vue component with CAF context (Plocs/UseCases) so that usePlocFromContext
+ * and useUseCaseFromContext work. Use this instead of raw mount() when testing
+ * components that depend on CAF context.
+ *
+ * @example
+ * ```ts
+ * import { mountWithCAF, createTestPloc, mockUseCase } from '@c-a-f/testing/vue';
+ * import { mount } from '@vue/test-utils';
+ *
+ * const ploc = createTestPloc({ count: 0 });
+ * const wrapper = mountWithCAF(MyComponent, {
+ *   plocs: { counter: ploc },
+ *   useCases: { submit: mockUseCase.success({ id: '1' }) },
+ * });
+ * ```
+ */
+import type { Component } from 'vue';
+import { type MountingOptions, type VueWrapper } from '@vue/test-utils';
+import type { Ploc, UseCase } from '@c-a-f/core';
+export interface MountWithCAFOptions<Props = unknown> extends MountingOptions<Props> {
+    /** Plocs to provide (keyed by string). */
+    plocs?: Record<string, Ploc<unknown>>;
+    /** UseCases to provide (keyed by string). */
+    useCases?: Record<string, UseCase<any[], any>>;
+}
+/**
+ * Mount a component with CAF context so Ploc/UseCase inject is available.
+ * Returns the same VueWrapper as @vue/test-utils mount().
+ */
+export declare function mountWithCAF<ComponentPublicInstance = unknown>(component: Component, options?: MountWithCAFOptions): VueWrapper<ComponentPublicInstance>;

package/.build/src/vue/mountWithCAF.js

@@ -0,0 +1,40 @@
+/**
+ * Mount a Vue component with CAF context (Plocs/UseCases) so that usePlocFromContext
+ * and useUseCaseFromContext work. Use this instead of raw mount() when testing
+ * components that depend on CAF context.
+ *
+ * @example
+ * ```ts
+ * import { mountWithCAF, createTestPloc, mockUseCase } from '@c-a-f/testing/vue';
+ * import { mount } from '@vue/test-utils';
+ *
+ * const ploc = createTestPloc({ count: 0 });
+ * const wrapper = mountWithCAF(MyComponent, {
+ *   plocs: { counter: ploc },
+ *   useCases: { submit: mockUseCase.success({ id: '1' }) },
+ * });
+ * ```
+ */
+import { mount } from '@vue/test-utils';
+import { CAFContextKey } from '@c-a-f/infrastructure-vue';
+/**
+ * Mount a component with CAF context so Ploc/UseCase inject is available.
+ * Returns the same VueWrapper as @vue/test-utils mount().
+ */
+export function mountWithCAF(component, options = {}) {
+    const { plocs, useCases, global: globalOptions, ...rest } = options;
+    const cafValue = {
+        plocs: plocs ?? {},
+        useCases: useCases ?? {},
+    };
+    return mount(component, {
+        ...rest,
+        global: {
+            ...globalOptions,
+            provide: {
+                ...globalOptions?.provide,
+                [CAFContextKey]: cafValue,
+            },
+        },
+    });
+}