syntropylog/dist/testing/SyntropyLogMock.js

An instance manager with observability for Node.js applications

import { randomUUID } from 'crypto';
/**
 * Create a mock logger instance
 */
export function createMockLogger() {
    const logs = [];
    return {
        info: (message, metadata) => {
            logs.push({ level: 'info', message, metadata });
        },
        warn: (message, metadata) => {
            logs.push({ level: 'warn', message, metadata });
        },
        error: (message, metadata) => {
            logs.push({ level: 'error', message, metadata });
        },
        debug: (message, metadata) => {
            logs.push({ level: 'debug', message, metadata });
        },
        trace: (message, metadata) => {
            logs.push({ level: 'trace', message, metadata });
        },
        fatal: (message, metadata) => {
            logs.push({ level: 'fatal', message, metadata });
        },
        withSource: (source) => {
            return createMockLogger(); // Return new instance with source context
        },
    };
}
/**
 * Create a mock context manager instance
 */
export function createMockContextManager() {
    const context = {};
    return {
        run: async (fn) => {
            // Simulate context execution
            const correlationId = randomUUID();
            const transactionId = randomUUID();
            // Set default context values
            context['x-correlation-id'] = correlationId;
            context['x-transaction-id'] = transactionId;
            context['x-correlation-id-test'] = correlationId;
            // Execute the function with context
            return await fn();
        },
        set: (key, value) => {
            context[key] = value;
        },
        get: (key) => {
            return context[key] || null;
        },
        getCorrelationIdHeaderName: () => 'x-correlation-id',
        getTransactionIdHeaderName: () => 'x-transaction-id',
    };
}
/**
 * Create a mock HTTP manager instance
 */
export function createMockHttpManager() {
    return {
        createClient: () => ({
            get: async () => ({ data: {} }),
            post: async () => ({ data: {} }),
            put: async () => ({ data: {} }),
            delete: async () => ({ data: {} }),
        }),
    };
}
/**
 * Create a mock broker manager instance
 */
export function createMockBrokerManager() {
    return {
        createClient: () => ({
            publish: async () => undefined,
            subscribe: async () => undefined,
        }),
    };
}
/**
 * Create a mock serialization manager instance
 */
export function createMockSerializationManager() {
    return {
        serialize: async () => '{}',
        deserialize: async () => ({}),
    };
}
// Global mock instances
let mockLogger;
let mockContextManager;
let mockHttpManager;
let mockBrokerManager;
let mockSerializationManager;
/**
 * Get or create mock logger instance
 */
export function getMockLogger() {
    if (!mockLogger) {
        mockLogger = createMockLogger();
    }
    return mockLogger;
}
/**
 * Get or create mock context manager instance
 */
export function getMockContextManager() {
    if (!mockContextManager) {
        mockContextManager = createMockContextManager();
    }
    return mockContextManager;
}
/**
 * Get or create mock HTTP manager instance
 */
export function getMockHttpManager() {
    if (!mockHttpManager) {
        mockHttpManager = createMockHttpManager();
    }
    return mockHttpManager;
}
/**
 * Get or create mock broker manager instance
 */
export function getMockBrokerManager() {
    if (!mockBrokerManager) {
        mockBrokerManager = createMockBrokerManager();
    }
    return mockBrokerManager;
}
/**
 * Get or create mock serialization manager instance
 */
export function getMockSerializationManager() {
    if (!mockSerializationManager) {
        mockSerializationManager = createMockSerializationManager();
    }
    return mockSerializationManager;
}
/**
 * Create a complete mock of SyntropyLog
 *
 * @param spyFn - Optional spy function for framework compatibility (vi.fn, jest.fn, etc.)
 */
export function createSyntropyLogMock(spyFn) {
    const createMock = (implementation) => {
        if (spyFn) {
            return spyFn(implementation);
        }
        // Fallback to simple function if no spy provided
        return implementation || (() => undefined);
    };
    return {
        init: createMock(async () => undefined),
        shutdown: createMock(async () => undefined),
        getLogger: createMock(() => getMockLogger()),
        getContextManager: createMock(() => getMockContextManager()),
        getHttpManager: createMock(() => getMockHttpManager()),
        getBrokerManager: createMock(() => getMockBrokerManager()),
        getSerializationManager: createMock(() => getMockSerializationManager()),
    };
}
/**
 * Reset all mock instances
 */
export function resetSyntropyLogMocks() {
    mockLogger = undefined;
    mockContextManager = undefined;
    mockHttpManager = undefined;
    mockBrokerManager = undefined;
    mockSerializationManager = undefined;
}
//# sourceMappingURL=SyntropyLogMock.js.map