swarmdo 1.4.8 → 1.5.0

package/v3/@swarmdo/testing/dist/helpers/assertion-helpers.js

@@ -1,435 +0,0 @@
-/**
- * @swarmdo/testing - Assertion Helpers
- *
- * Custom Vitest matchers and assertion utilities for V3 module testing.
- * Implements London School TDD behavior verification patterns.
- */
-import { expect } from 'vitest';
-/**
- * Assert that a mock was called with arguments matching a pattern
- *
- * @example
- * assertCalledWithPattern(mockFn, { userId: expect.any(String) });
- */
-export function assertCalledWithPattern(mock, pattern) {
-    const calls = mock.mock.calls;
-    const matched = calls.some(call => {
-        if (Array.isArray(pattern)) {
-            return pattern.every((expected, i) => {
-                if (typeof expected === 'object' && expected !== null && 'asymmetricMatch' in expected) {
-                    return expected.asymmetricMatch(call[i]);
-                }
-                return JSON.stringify(call[i]) === JSON.stringify(expected);
-            });
-        }
-        const callArg = call[0];
-        return Object.entries(pattern).every(([key, expected]) => {
-            if (typeof expected === 'object' && expected !== null && 'asymmetricMatch' in expected) {
-                return expected.asymmetricMatch(callArg[key]);
-            }
-            return JSON.stringify(callArg[key]) === JSON.stringify(expected);
-        });
-    });
-    expect(matched).toBe(true);
-}
-/**
- * Assert that events were published in order
- *
- * @example
- * assertEventOrder(mockEventBus.publish, ['UserCreated', 'EmailSent']);
- */
-export function assertEventOrder(publishMock, expectedEventTypes) {
-    const actualEventTypes = publishMock.mock.calls
-        .map(call => call[0].type)
-        .filter(type => expectedEventTypes.includes(type));
-    expect(actualEventTypes).toEqual(expectedEventTypes);
-}
-/**
- * Assert that an event was published with specific payload
- *
- * @example
- * assertEventPublished(mockEventBus, 'UserCreated', { userId: '123' });
- */
-export function assertEventPublished(eventBusMock, eventType, expectedPayload) {
-    const publishMock = 'publish' in eventBusMock ? eventBusMock.publish : eventBusMock;
-    const calls = publishMock.mock.calls;
-    const matchingEvent = calls.find(call => {
-        const event = call[0];
-        return event.type === eventType;
-    });
-    expect(matchingEvent).toBeDefined();
-    if (expectedPayload && matchingEvent) {
-        const actualPayload = matchingEvent[0].payload;
-        expect(actualPayload).toMatchObject(expectedPayload);
-    }
-}
-/**
- * Assert that no event of a specific type was published
- *
- * @example
- * assertEventNotPublished(mockEventBus, 'UserDeleted');
- */
-export function assertEventNotPublished(eventBusMock, eventType) {
-    const publishMock = 'publish' in eventBusMock ? eventBusMock.publish : eventBusMock;
-    const calls = publishMock.mock.calls;
-    const matchingEvent = calls.find(call => {
-        const event = call[0];
-        return event.type === eventType;
-    });
-    expect(matchingEvent).toBeUndefined();
-}
-/**
- * Assert that mocks were called in a specific order
- *
- * @example
- * assertMocksCalledInOrder([mockValidate, mockSave, mockNotify]);
- */
-export function assertMocksCalledInOrder(mocks) {
-    const orders = mocks.map(mock => {
-        if (mock.mock.invocationCallOrder.length === 0) {
-            return Infinity;
-        }
-        return Math.min(...mock.mock.invocationCallOrder);
-    });
-    for (let i = 1; i < orders.length; i++) {
-        expect(orders[i]).toBeGreaterThan(orders[i - 1]);
-    }
-}
-/**
- * Assert that a mock was called exactly n times with specific arguments
- *
- * @example
- * assertCalledNTimesWith(mockFn, 3, ['arg1', 'arg2']);
- */
-export function assertCalledNTimesWith(mock, times, args) {
-    const matchingCalls = mock.mock.calls.filter(call => JSON.stringify(call) === JSON.stringify(args));
-    expect(matchingCalls).toHaveLength(times);
-}
-/**
- * Assert that async operations completed within time limit
- *
- * @example
- * await assertCompletesWithin(async () => await slowOp(), 1000);
- */
-export async function assertCompletesWithin(operation, maxMs) {
-    const start = performance.now();
-    await operation();
-    const duration = performance.now() - start;
-    expect(duration).toBeLessThanOrEqual(maxMs);
-}
-/**
- * Assert that an operation throws a specific error
- *
- * @example
- * await assertThrowsError(
- *   async () => await riskyOp(),
- *   ValidationError,
- *   'Invalid input'
- * );
- */
-export async function assertThrowsError(operation, ErrorType, messagePattern) {
-    let error;
-    try {
-        await operation();
-    }
-    catch (e) {
-        error = e;
-    }
-    expect(error).toBeInstanceOf(ErrorType);
-    if (messagePattern && error) {
-        if (typeof messagePattern === 'string') {
-            expect(error.message).toContain(messagePattern);
-        }
-        else {
-            expect(error.message).toMatch(messagePattern);
-        }
-    }
-    return error;
-}
-/**
- * Assert that no sensitive data appears in logs
- *
- * @example
- * assertNoSensitiveData(mockLogger.logs, ['password', 'token', 'secret']);
- */
-export function assertNoSensitiveData(logs, sensitivePatterns) {
-    for (const log of logs) {
-        const content = JSON.stringify(log).toLowerCase();
-        for (const pattern of sensitivePatterns) {
-            expect(content).not.toContain(pattern.toLowerCase());
-        }
-    }
-}
-/**
- * Assert that a value matches a snapshot with custom serialization
- *
- * @example
- * assertMatchesSnapshot(result, { ignoreFields: ['timestamp', 'id'] });
- */
-export function assertMatchesSnapshot(value, options = {}) {
-    const { ignoreFields = [], transform } = options;
-    let processed = value;
-    if (ignoreFields.length > 0 && typeof processed === 'object' && processed !== null) {
-        processed = removeFields(processed, ignoreFields);
-    }
-    if (transform) {
-        processed = transform(processed);
-    }
-    expect(processed).toMatchSnapshot();
-}
-/**
- * Remove fields from object for snapshot comparison
- */
-function removeFields(obj, fields) {
-    const result = { ...obj };
-    for (const field of fields) {
-        delete result[field];
-    }
-    for (const [key, value] of Object.entries(result)) {
-        if (typeof value === 'object' && value !== null) {
-            result[key] = removeFields(value, fields);
-        }
-    }
-    return result;
-}
-/**
- * Assert that performance metrics meet V3 targets
- *
- * @example
- * assertV3PerformanceTargets({
- *   searchSpeedup: 160,
- *   memoryReduction: 0.55,
- * });
- */
-export function assertV3PerformanceTargets(metrics) {
-    // Search speedup: 150x - 12500x
-    if (metrics.searchSpeedup !== undefined) {
-        expect(metrics.searchSpeedup).toBeGreaterThanOrEqual(150);
-        expect(metrics.searchSpeedup).toBeLessThanOrEqual(12500);
-    }
-    // Flash attention speedup: 2.49x - 7.47x
-    if (metrics.flashAttentionSpeedup !== undefined) {
-        expect(metrics.flashAttentionSpeedup).toBeGreaterThanOrEqual(2.49);
-        expect(metrics.flashAttentionSpeedup).toBeLessThanOrEqual(7.47);
-    }
-    // Memory reduction: >= 50%
-    if (metrics.memoryReduction !== undefined) {
-        expect(metrics.memoryReduction).toBeGreaterThanOrEqual(0.50);
-    }
-    // Startup time: < 500ms
-    if (metrics.startupTimeMs !== undefined) {
-        expect(metrics.startupTimeMs).toBeLessThan(500);
-    }
-    // Response time: sub-100ms
-    if (metrics.responseTimeMs !== undefined) {
-        expect(metrics.responseTimeMs).toBeLessThan(100);
-    }
-}
-/**
- * Assert that a domain object is valid
- *
- * @example
- * assertValidDomainObject(user, UserSchema);
- */
-export function assertValidDomainObject(object, validator) {
-    const result = validator(object);
-    if (!result.valid) {
-        throw new Error(`Invalid domain object: ${result.errors?.join(', ')}`);
-    }
-}
-/**
- * Assert that a mock was only called with allowed arguments
- *
- * @example
- * assertOnlyCalledWithAllowed(mockFn, [['valid1'], ['valid2']]);
- */
-export function assertOnlyCalledWithAllowed(mock, allowedCalls) {
-    const calls = mock.mock.calls;
-    for (const call of calls) {
-        const isAllowed = allowedCalls.some(allowed => JSON.stringify(call) === JSON.stringify(allowed));
-        if (!isAllowed) {
-            throw new Error(`Mock was called with unexpected arguments: ${JSON.stringify(call)}\n` +
-                `Allowed: ${JSON.stringify(allowedCalls)}`);
-        }
-    }
-}
-/**
- * Assert that an array contains elements in partial order
- *
- * @example
- * assertPartialOrder(events, [
- *   { type: 'Start' },
- *   { type: 'Process' },
- *   { type: 'End' },
- * ]);
- */
-export function assertPartialOrder(actual, expectedOrder) {
-    let lastIndex = -1;
-    for (const expected of expectedOrder) {
-        const index = actual.findIndex((item, i) => i > lastIndex &&
-            Object.entries(expected).every(([key, value]) => item[key] === value));
-        if (index === -1) {
-            throw new Error(`Expected to find ${JSON.stringify(expected)} after index ${lastIndex} in array`);
-        }
-        lastIndex = index;
-    }
-}
-/**
- * Assert that all items in a collection pass a predicate
- *
- * @example
- * assertAllPass(results, result => result.success);
- */
-export function assertAllPass(items, predicate, message) {
-    for (let i = 0; i < items.length; i++) {
-        if (!predicate(items[i], i)) {
-            throw new Error(message ?? `Item at index ${i} failed predicate: ${JSON.stringify(items[i])}`);
-        }
-    }
-}
-/**
- * Assert that none of the items in a collection pass a predicate
- *
- * @example
- * assertNonePass(results, result => result.error);
- */
-export function assertNonePass(items, predicate, message) {
-    for (let i = 0; i < items.length; i++) {
-        if (predicate(items[i], i)) {
-            throw new Error(message ?? `Item at index ${i} passed predicate but should not have: ${JSON.stringify(items[i])}`);
-        }
-    }
-}
-/**
- * Assert that two arrays have the same elements regardless of order
- *
- * @example
- * assertSameElements([1, 2, 3], [3, 1, 2]);
- */
-export function assertSameElements(actual, expected) {
-    expect(actual).toHaveLength(expected.length);
-    const actualSorted = [...actual].sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)));
-    const expectedSorted = [...expected].sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)));
-    expect(actualSorted).toEqual(expectedSorted);
-}
-/**
- * Assert that a mock returns expected results in sequence
- *
- * @example
- * await assertMockReturnsSequence(mockFn, [1, 2, 3]);
- */
-export async function assertMockReturnsSequence(mock, expectedResults) {
-    for (const expected of expectedResults) {
-        const result = await mock();
-        expect(result).toEqual(expected);
-    }
-}
-/**
- * Assert state transition is valid
- *
- * @example
- * assertValidStateTransition(
- *   'pending',
- *   'running',
- *   { pending: ['running', 'cancelled'], running: ['completed', 'failed'] }
- * );
- */
-export function assertValidStateTransition(from, to, allowedTransitions) {
-    const allowed = allowedTransitions[from];
-    if (!allowed || !allowed.includes(to)) {
-        throw new Error(`Invalid state transition from '${from}' to '${to}'. ` +
-            `Allowed transitions from '${from}': ${allowed?.join(', ') ?? 'none'}`);
-    }
-}
-/**
- * Assert that a retry policy was followed
- *
- * @example
- * assertRetryPattern(mockFn, { attempts: 3, backoffPattern: 'exponential' });
- */
-export function assertRetryPattern(mock, options) {
-    const calls = mock.mock.calls;
-    expect(calls).toHaveLength(options.attempts);
-    if (options.backoffPattern === 'exponential' && calls.length > 1) {
-        // Check that intervals roughly follow exponential pattern
-        const invocationOrder = mock.mock.invocationCallOrder;
-        for (let i = 2; i < invocationOrder.length; i++) {
-            const prevGap = invocationOrder[i - 1] - invocationOrder[i - 2];
-            const currentGap = invocationOrder[i] - invocationOrder[i - 1];
-            // Allow some variance in timing
-            expect(currentGap).toBeGreaterThanOrEqual(prevGap * 0.8);
-        }
-    }
-}
-/**
- * Assert that a dependency was properly injected
- *
- * @example
- * assertDependencyInjected(service, 'repository', mockRepository);
- */
-export function assertDependencyInjected(subject, propertyName, expectedDependency) {
-    expect(subject[propertyName]).toBe(expectedDependency);
-}
-/**
- * Custom Vitest matcher declarations
- * Note: Main declarations in setup.ts - these extend CustomMatchers
- */
-/**
- * Register custom Vitest matchers
- */
-export function registerCustomMatchers() {
-    expect.extend({
-        toHaveBeenCalledWithPattern(received, pattern) {
-            const calls = received.mock.calls;
-            const pass = calls.some(call => {
-                const callArg = call[0];
-                return Object.entries(pattern).every(([key, expected]) => JSON.stringify(callArg[key]) === JSON.stringify(expected));
-            });
-            return {
-                pass,
-                message: () => pass
-                    ? `Expected mock not to have been called with pattern ${JSON.stringify(pattern)}`
-                    : `Expected mock to have been called with pattern ${JSON.stringify(pattern)}`,
-            };
-        },
-        toHaveEventType(received, eventType) {
-            const pass = received.type === eventType;
-            return {
-                pass,
-                message: () => pass
-                    ? `Expected event not to have type ${eventType}`
-                    : `Expected event to have type ${eventType}, but got ${received.type}`,
-            };
-        },
-        toMeetV3PerformanceTargets(received) {
-            const issues = [];
-            if (received.searchSpeedup !== undefined) {
-                if (received.searchSpeedup < 150) {
-                    issues.push(`Search speedup ${received.searchSpeedup}x is below minimum 150x`);
-                }
-            }
-            if (received.flashAttentionSpeedup !== undefined) {
-                if (received.flashAttentionSpeedup < 2.49) {
-                    issues.push(`Flash attention speedup ${received.flashAttentionSpeedup}x is below minimum 2.49x`);
-                }
-            }
-            if (received.memoryReduction !== undefined) {
-                if (received.memoryReduction < 0.50) {
-                    issues.push(`Memory reduction ${received.memoryReduction * 100}% is below target 50%`);
-                }
-            }
-            if (received.startupTimeMs !== undefined) {
-                if (received.startupTimeMs >= 500) {
-                    issues.push(`Startup time ${received.startupTimeMs}ms exceeds target 500ms`);
-                }
-            }
-            return {
-                pass: issues.length === 0,
-                message: () => issues.length === 0
-                    ? 'Performance metrics meet V3 targets'
-                    : `Performance issues: ${issues.join('; ')}`,
-            };
-        },
-    });
-}
-//# sourceMappingURL=assertion-helpers.js.map

package/v3/@swarmdo/testing/dist/helpers/assertions.d.ts

@@ -1,135 +0,0 @@
-/**
- * V3 Swarmdo Custom Assertions
- *
- * London School TDD Custom Assertions
- * - Behavior-focused assertions
- * - Interaction verification helpers
- * - Contract testing utilities
- */
-import { type Mock } from 'vitest';
-/**
- * Assert that a mock was called in a specific sequence
- *
- * @example
- * assertCallSequence([
- *   [mockRepo.findById, ['123']],
- *   [mockValidator.validate, [user]],
- *   [mockRepo.save, [user]],
- * ]);
- */
-export declare function assertCallSequence(sequence: Array<[Mock, unknown[]]>): void;
-/**
- * Assert that a mock was NOT called with specific arguments
- *
- * @example
- * assertNotCalledWith(mockRepo.save, [invalidUser]);
- */
-export declare function assertNotCalledWith(mock: Mock, args: unknown[]): void;
-/**
- * Assert interaction count for behavior verification
- *
- * @example
- * assertInteractionCount(mockService.process, 3);
- */
-export declare function assertInteractionCount(mock: Mock, expectedCount: number): void;
-/**
- * Assert that all mocks in a group were called
- *
- * @example
- * assertAllCalled([mockA.method, mockB.method, mockC.method]);
- */
-export declare function assertAllCalled(mocks: Mock[]): void;
-/**
- * Assert that none of the mocks were called
- *
- * @example
- * assertNoneCalled([mockA.method, mockB.method]);
- */
-export declare function assertNoneCalled(mocks: Mock[]): void;
-/**
- * Assert contract compliance
- * Verifies that an object implements expected interface
- *
- * @example
- * assertContractCompliance(userService, UserServiceContract);
- */
-export declare function assertContractCompliance<T extends object>(implementation: T, contract: ContractDefinition<T>): void;
-/**
- * Contract definition for interface compliance
- */
-export interface ContractDefinition<T> {
-    methods: {
-        [K in keyof T]?: {
-            params: Array<{
-                name: string;
-                type: string;
-            }>;
-            returns: string;
-        };
-    };
-}
-/**
- * Assert async operation timing
- *
- * @example
- * await assertTimingWithin(async () => service.process(), 100);
- */
-export declare function assertTimingWithin(operation: () => Promise<unknown>, maxMs: number): Promise<void>;
-/**
- * Assert that an async operation completes within expected time range
- *
- * @example
- * await assertTimingRange(async () => service.process(), 50, 150);
- */
-export declare function assertTimingRange(operation: () => Promise<unknown>, minMs: number, maxMs: number): Promise<void>;
-/**
- * Assert error type and message
- *
- * @example
- * await assertThrowsWithMessage(
- *   async () => service.validate(invalid),
- *   ValidationError,
- *   'Invalid input'
- * );
- */
-export declare function assertThrowsWithMessage(operation: () => Promise<unknown>, ErrorType: new (...args: unknown[]) => Error, expectedMessage: string | RegExp): Promise<void>;
-/**
- * Assert domain event was published
- *
- * @example
- * await assertEventPublished(mockEventBus, 'UserCreated', { userId: '123' });
- */
-export declare function assertEventPublished(eventBusMock: Mock, eventType: string, expectedPayload?: Record<string, unknown>): void;
-/**
- * Assert that mock returns expected values in sequence
- *
- * @example
- * assertMockSequence(mockCounter.next, [1, 2, 3]);
- */
-export declare function assertMockSequence(mock: Mock, expectedValues: unknown[]): Promise<void>;
-/**
- * Security assertion - verify sensitive data handling
- *
- * @example
- * assertNoSensitiveDataLogged(mockLogger, ['password', 'token', 'secret']);
- */
-export declare function assertNoSensitiveDataLogged(loggerMock: Mock, sensitivePatterns: string[]): void;
-/**
- * Performance assertion - verify operation meets target
- *
- * @example
- * await assertPerformanceTarget(
- *   async () => await search.execute(query),
- *   { targetMs: 100, iterations: 10 }
- * );
- */
-export declare function assertPerformanceTarget(operation: () => Promise<unknown>, config: {
-    targetMs: number;
-    iterations: number;
-    warmupIterations?: number;
-}): Promise<{
-    averageMs: number;
-    minMs: number;
-    maxMs: number;
-}>;
-//# sourceMappingURL=assertions.d.ts.map