@dbs-portal/core-api/dist/mocks/server.js

HTTP client and API utilities for DBS Portal

/**
 * MSW server setup for Node.js testing environment
 */
import { setupServer as createMSWServer } from 'msw/node';
/**
 * Setup MSW for Node.js environment (testing)
 */
export function setupServer(handlers, config) {
    try {
        // Create server with handlers
        const server = createMSWServer(...handlers);
        if (config.logging) {
            console.log('MSW: Setting up Node.js server with', handlers.length, 'handlers');
        }
        return server;
    }
    catch (error) {
        console.error('MSW: Failed to setup Node.js server:', error);
        throw error;
    }
}
/**
 * Initialize MSW server for testing
 * This should be called in test setup files
 */
export function initializeServerMocks(handlers = [], options = {}) {
    try {
        const server = createMSWServer(...handlers);
        // Start server
        server.listen({
            onUnhandledRequest: options.onUnhandledRequest ?? 'warn',
        });
        if (!options.quiet) {
            console.log('MSW: Server mocking enabled for testing');
        }
        return server;
    }
    catch (error) {
        console.error('MSW: Failed to initialize server mocks:', error);
        throw error;
    }
}
/**
 * Server-specific mock utilities
 */
export const serverMockUtils = {
    /**
     * Check if running in test environment
     */
    isTestEnvironment() {
        return typeof process !== 'undefined' && process.env?.['NODE_ENV'] === 'test';
    },
    /**
     * Check if running in CI environment
     */
    isCIEnvironment() {
        return typeof process !== 'undefined' &&
            (process.env?.['CI'] === 'true' ||
                process.env?.['CONTINUOUS_INTEGRATION'] === 'true' ||
                !!process.env?.['GITHUB_ACTIONS'] ||
                !!process.env?.['GITLAB_CI'] ||
                !!process.env?.['JENKINS_URL']);
    },
    /**
     * Get Node.js environment info
     */
    getEnvironmentInfo() {
        if (typeof process === 'undefined') {
            return null;
        }
        return {
            nodeVersion: process.version,
            platform: process.platform,
            arch: process.arch,
            env: process.env?.['NODE_ENV'],
            isTest: this.isTestEnvironment(),
            isCI: this.isCIEnvironment(),
        };
    },
    /**
     * Show mock status in console (Node.js)
     */
    logMockStatus(enabled, handlersCount) {
        if (typeof console === 'undefined')
            return;
        const prefix = '[MSW]';
        if (enabled) {
            console.log(`${prefix} Server mocking enabled with ${handlersCount} handlers`);
        }
        else {
            console.log(`${prefix} Server mocking disabled`);
        }
    },
    /**
     * Create test lifecycle helpers
     */
    createTestLifecycle(server) {
        return {
            /**
             * Setup function for beforeAll/beforeEach
             */
            setup: () => {
                server.listen({ onUnhandledRequest: 'error' });
            },
            /**
             * Cleanup function for afterEach
             */
            cleanup: () => {
                server.resetHandlers();
            },
            /**
             * Teardown function for afterAll
             */
            teardown: () => {
                server.close();
            },
            /**
             * Add handlers for specific tests
             */
            addHandlers: (...handlers) => {
                server.use(...handlers);
            },
            /**
             * Reset to original handlers
             */
            resetHandlers: () => {
                server.resetHandlers();
            },
            /**
             * Restore original handlers
             */
            restoreHandlers: () => {
                server.restoreHandlers();
            },
        };
    },
};
/**
 * Global server instance for testing
 */
let globalTestServer = null;
/**
 * Get or create global test server
 */
export function getGlobalTestServer(handlers = []) {
    if (!globalTestServer) {
        globalTestServer = createMSWServer(...handlers);
    }
    return globalTestServer;
}
/**
 * Setup global test server with lifecycle management
 */
export function setupGlobalTestServer(handlers = []) {
    const server = getGlobalTestServer(handlers);
    const lifecycle = serverMockUtils.createTestLifecycle(server);
    // Auto-setup for common test frameworks
    if (typeof globalThis !== 'undefined') {
        const globals = globalThis;
        if (typeof globals.beforeAll !== 'undefined') {
            globals.beforeAll(() => lifecycle.setup());
        }
        if (typeof globals.afterEach !== 'undefined') {
            globals.afterEach(() => lifecycle.cleanup());
        }
        if (typeof globals.afterAll !== 'undefined') {
            globals.afterAll(() => lifecycle.teardown());
        }
    }
    return { server, lifecycle };
}
//# sourceMappingURL=server.js.map