@react-native-harness/jest 1.1.0-rc.1 → 1.1.0-rc.3

package/dist/harness.js

@@ -1,163 +1,601 @@
 import { getBridgeServer, } from '@react-native-harness/bridge/server';
-import { getMetroInstance, prewarmMetroBundle, } from '@react-native-harness/bundler-metro';
-import { createCrashArtifactWriter } from '@react-native-harness/tools';
-import { InitializationTimeoutError } from './errors.js';
+import { HARNESS_BRIDGE_PATH, } from '@react-native-harness/bridge';
+import { getMetroInstance, isMetroCacheReusable, waitForMetroBackedAppReady, } from '@react-native-harness/bundler-metro';
+import { createHarnessPluginManager, } from '@react-native-harness/plugins';
+import { logger, createCrashArtifactWriter, getTimeoutSignal, raceAbortSignals, } from '@react-native-harness/tools';
+import { PlatformReadyTimeoutError } from './errors.js';
 import { createCrashSupervisor, } from './crash-supervisor.js';
 import { createClientLogListener } from './client-log-handler.js';
-import { logMetroPrewarmCompleted } from './logs.js';
+import path from 'node:path';
+import { logMetroCacheReused, logRunnerStarting, logRunnerStillWaitingInQueue, logRunnerWaitingInQueue, } from './logs.js';
+import { createResourceLockManager } from './resource-lock.js';
+const harnessLogger = logger.child('runtime');
+const resourceLockManager = createResourceLockManager();
+export const maybeLogMetroCacheReuse = (config, platform, projectRoot) => {
+    if (config.unstable__enableMetroCache && isMetroCacheReusable(projectRoot)) {
+        logMetroCacheReused(platform);
+    }
+};
+const createAbortError = () => new DOMException('The operation was aborted', 'AbortError');
+const getDefaultResourceLockKey = (platform) => `${platform.platformId}:${platform.name}`;
+const waitForAbort = (signal) => {
+    if (signal.aborted) {
+        return Promise.reject(signal.reason ?? createAbortError());
+    }
+    return new Promise((_, reject) => {
+        signal.addEventListener('abort', () => {
+            reject(signal.reason ?? createAbortError());
+        }, { once: true });
+    });
+};
+const withPlatformReadyTimeout = async (options) => {
+    const timeoutSignal = getTimeoutSignal(options.timeout);
+    const combinedSignal = raceAbortSignals([options.signal, timeoutSignal]);
+    try {
+        return await options.work(combinedSignal);
+    }
+    catch (error) {
+        if (error instanceof DOMException &&
+            error.name === 'AbortError' &&
+            timeoutSignal.aborted &&
+            !options.signal.aborted) {
+            throw new PlatformReadyTimeoutError(options.timeout);
+        }
+        throw error;
+    }
+};
 export const waitForAppReady = async (options) => {
-    const { serverBridge, platformInstance, bridgeTimeout, testFilePath, crashSupervisor, appLaunchOptions, } = options;
-    const signal = AbortSignal.timeout(bridgeTimeout);
-    return new Promise((resolve, reject) => {
-        const launchApp = async () => {
+    const { metroInstance, serverBridge, platformInstance, platformId, bundleStartTimeout, readyTimeout, maxAppRestarts, testFilePath, crashSupervisor, appLaunchOptions, launchApp = () => platformInstance.restartApp(appLaunchOptions), } = options;
+    const signal = options.signal ?? new AbortController().signal;
+    const logWait = (message, ...args) => {
+        harnessLogger.debug(`waitForAppReady: ${message}`, ...args);
+    };
+    return await waitForMetroBackedAppReady({
+        metro: metroInstance,
+        platformId,
+        bundleStartTimeout,
+        readyTimeout,
+        maxAppRestarts,
+        signal,
+        startAttempt: async () => {
+            logWait('launching app for %s', testFilePath);
+            await launchApp();
+            logWait('launch request completed, waiting for bridge ready');
+        },
+        waitForReady: async (signal) => {
+            logWait('waiting for runtime ready');
+            return await Promise.race([
+                new Promise((resolve) => {
+                    const onReady = () => {
+                        cleanup();
+                        crashSupervisor.markReady();
+                        logWait('runtime ready received');
+                        resolve();
+                    };
+                    const onAbort = () => {
+                        cleanup();
+                    };
+                    const cleanup = () => {
+                        serverBridge.off('ready', onReady);
+                        signal.removeEventListener('abort', onAbort);
+                    };
+                    serverBridge.on('ready', onReady);
+                    signal.addEventListener('abort', onAbort, { once: true });
+                }),
+                waitForAbort(signal),
+            ]);
+        },
+        waitForCrash: async (signal) => {
+            try {
+                logWait('waiting for crash or runtime ready');
+                return await Promise.race([
+                    crashSupervisor.waitForCrash(testFilePath),
+                    waitForAbort(signal),
+                ]);
+            }
+            finally {
+                crashSupervisor.cancelCrashWaiters();
+            }
+        },
+        onAttemptStart: () => {
+            logWait('beginning launch attempt for %s', testFilePath);
             crashSupervisor.beginLaunch(testFilePath);
-            await platformInstance.restartApp(appLaunchOptions);
-        };
-        const onReady = () => {
-            crashSupervisor.markReady();
-            cleanup();
-            resolve();
-        };
-        const onAbort = () => {
-            cleanup();
-            reject(new DOMException('The operation was aborted', 'AbortError'));
-        };
-        const cleanup = () => {
-            serverBridge.off('ready', onReady);
-            signal.removeEventListener('abort', onAbort);
+        },
+        onAttemptReset: () => {
+            logWait('resetting launch attempt state');
             crashSupervisor.cancelCrashWaiters();
-        };
-        signal.addEventListener('abort', onAbort);
-        serverBridge.once('ready', onReady);
-        void crashSupervisor.waitForCrash(testFilePath).catch((error) => {
-            cleanup();
-            reject(error);
-        });
-        void launchApp().catch((error) => {
-            cleanup();
-            reject(error);
-        });
+        },
     });
 };
 const getHarnessInternal = async (config, platform, projectRoot, signal) => {
     const context = {
         platform,
     };
-    const [metroInstance, platformInstance, serverBridge] = await Promise.all([
-        getMetroInstance({ projectRoot, harnessConfig: config }, signal),
-        import(platform.runner).then((module) => module.default(platform.config, config)),
-        getBridgeServer({
-            port: config.webSocketPort,
-            timeout: config.bridgeTimeout,
-            context,
-        }),
-    ]);
-    const crashArtifactWriter = createCrashArtifactWriter({
-        runnerName: platform.name,
-        platformId: platform.platformId,
-    });
-    const appMonitor = platformInstance.createAppMonitor({
-        crashArtifactWriter,
-    });
-    const appLaunchOptions = platform.config.appLaunchOptions;
-    const clientLogListener = createClientLogListener();
-    const crashSupervisor = createCrashSupervisor({
-        appMonitor,
-        platformRunner: platformInstance,
+    harnessLogger.debug('creating Harness internals for runner=%s platform=%s', platform.name, platform.platformId);
+    const resourceLockKey = await (platform.getResourceLockKey?.() ??
+        getDefaultResourceLockKey(platform));
+    let didWaitForResourceLock = false;
+    let lastStillWaitingLogAt = 0;
+    const resourceLease = await resourceLockManager.acquire(resourceLockKey, {
+        signal,
+        onWait: () => {
+            didWaitForResourceLock = true;
+            logRunnerWaitingInQueue(platform);
+            harnessLogger.debug('waiting in queue for runner=%s key=%s', platform.name, resourceLockKey);
+        },
+        onStillWaiting: (elapsedMs) => {
+            if (elapsedMs - lastStillWaitingLogAt < 5000) {
+                return;
+            }
+            lastStillWaitingLogAt = elapsedMs;
+            logRunnerStillWaitingInQueue(platform);
+            harnessLogger.debug('still waiting in queue for runner=%s key=%s elapsedMs=%d', platform.name, resourceLockKey, elapsedMs);
+        },
     });
-    serverBridge.on('ready', crashSupervisor.markReady);
-    if (config.forwardClientLogs) {
-        metroInstance.events.addListener(clientLogListener);
-    }
-    const dispose = async () => {
-        if (config.forwardClientLogs) {
-            metroInstance.events.removeListener(clientLogListener);
-        }
-        serverBridge.off('ready', crashSupervisor.markReady);
-        await Promise.all([
-            crashSupervisor.dispose(),
-            serverBridge.dispose(),
-            platformInstance.dispose(),
-            metroInstance.dispose(),
-        ]);
-    };
-    if (signal.aborted) {
-        await dispose();
-        throw new DOMException('The operation was aborted', 'AbortError');
+    if (didWaitForResourceLock) {
+        logRunnerStarting(platform);
     }
+    harnessLogger.debug('resource lock acquired for runner=%s key=%s', platform.name, resourceLockKey);
     try {
-        await prewarmMetroBundle({
+        maybeLogMetroCacheReuse(config, platform, projectRoot);
+        const pluginAbortController = new AbortController();
+        const pluginManager = createHarnessPluginManager({
+            plugins: (config.plugins ?? []),
             projectRoot,
-            entryPoint: config.entryPoint,
-            platform: platform.platformId,
-            dev: true,
-            minify: false,
-            signal,
+            config,
+            runner: platform,
+            abortSignal: pluginAbortController.signal,
         });
-        logMetroPrewarmCompleted(platform);
-        await appMonitor.start();
-    }
-    catch (error) {
-        await dispose();
-        throw error;
-    }
-    const ensureAppReady = async (testFilePath) => {
-        crashSupervisor.setActiveTestFile(testFilePath);
-        if (crashSupervisor.isReady() && (await platformInstance.isAppRunning())) {
-            return;
-        }
-        crashSupervisor.reset();
-        await waitForAppReady({
-            serverBridge,
-            platformInstance: platformInstance,
-            bridgeTimeout: config.bridgeTimeout,
-            testFilePath,
-            crashSupervisor,
-            appLaunchOptions,
+        let currentRun = null;
+        let activeTestFilePath;
+        const pendingHookPromises = new Set();
+        let pendingHookError;
+        const getCurrentRunId = () => currentRun?.runId;
+        const toRelativeTestFilePath = (testFilePath) => testFilePath == null
+            ? undefined
+            : path.relative(projectRoot, testFilePath);
+        const setActiveTestFilePath = (testFilePath) => {
+            activeTestFilePath = toRelativeTestFilePath(testFilePath);
+        };
+        const flushPendingHooks = async () => {
+            if (pendingHookPromises.size > 0) {
+                await Promise.allSettled([...pendingHookPromises]);
+            }
+            if (pendingHookError !== undefined) {
+                const error = pendingHookError;
+                pendingHookError = undefined;
+                throw error;
+            }
+        };
+        const trackHook = (promise) => {
+            const trackedPromise = promise
+                .catch((error) => {
+                pendingHookError ??= error;
+            })
+                .finally(() => {
+                pendingHookPromises.delete(trackedPromise);
+            });
+            pendingHookPromises.add(trackedPromise);
+        };
+        const scheduleHook = (name, payload) => {
+            trackHook(pluginManager.callHook(name, payload));
+        };
+        const serverBridge = await getBridgeServer({
+            noServer: true,
+            timeout: config.bridgeTimeout,
+            context,
         });
-    };
-    const restart = async (testFilePath) => {
-        await crashSupervisor.stop();
-        if (testFilePath) {
-            await platformInstance.stopApp();
+        harnessLogger.debug('starting Metro, platform runner, and bridge initialization');
+        harnessLogger.debug('bridge server initialized on Metro websocket path %s', HARNESS_BRIDGE_PATH);
+        const [metroInstance, platformInstance] = await (async () => {
+            try {
+                return await Promise.all([
+                    getMetroInstance({
+                        projectRoot,
+                        harnessConfig: config,
+                        websocketEndpoints: {
+                            [HARNESS_BRIDGE_PATH]: serverBridge.ws,
+                        },
+                    }, signal).then((instance) => {
+                        harnessLogger.debug('Metro initialized');
+                        return instance;
+                    }),
+                    withPlatformReadyTimeout({
+                        timeout: config.platformReadyTimeout,
+                        signal,
+                        work: async () => {
+                            return await import(platform.runner)
+                                .then((module) => module.default(platform.config, config, {
+                                signal,
+                            }))
+                                .then((instance) => {
+                                harnessLogger.debug('platform runner initialized');
+                                return instance;
+                            });
+                        },
+                    }),
+                ]);
+            }
+            catch (error) {
+                await Promise.allSettled([
+                    resourceLease.release(),
+                    serverBridge.dispose(),
+                ]);
+                throw error;
+            }
+        })();
+        const crashArtifactWriter = createCrashArtifactWriter({
+            runnerName: platform.name,
+            platformId: platform.platformId,
+        });
+        const appMonitor = platformInstance.createAppMonitor({
+            crashArtifactWriter,
+        });
+        const appLaunchOptions = platform.config.appLaunchOptions;
+        const clientLogListener = createClientLogListener();
+        const bridgeEventListener = (event) => {
+            const runId = getCurrentRunId();
+            if (!runId) {
+                return;
+            }
+            switch (event.type) {
+                case 'collection-started':
+                    scheduleHook('collection:started', {
+                        runId,
+                        file: event.file,
+                    });
+                    break;
+                case 'collection-finished':
+                    scheduleHook('collection:finished', {
+                        runId,
+                        file: event.file,
+                        duration: event.duration,
+                        totalTests: event.totalTests,
+                    });
+                    break;
+                case 'suite-started':
+                    scheduleHook('suite:started', {
+                        runId,
+                        file: event.file,
+                        name: event.name,
+                    });
+                    break;
+                case 'suite-finished':
+                    scheduleHook('suite:finished', {
+                        runId,
+                        file: event.file,
+                        name: event.name,
+                        duration: event.duration,
+                        status: event.status,
+                        error: event.error,
+                    });
+                    break;
+                case 'test-started':
+                    scheduleHook('test:started', {
+                        runId,
+                        file: event.file,
+                        suite: event.suite,
+                        name: event.name,
+                    });
+                    break;
+                case 'test-finished':
+                    scheduleHook('test:finished', {
+                        runId,
+                        file: event.file,
+                        suite: event.suite,
+                        name: event.name,
+                        duration: event.duration,
+                        status: event.status,
+                        error: event.error,
+                    });
+                    break;
+                case 'module-bundling-started':
+                    scheduleHook('metro:bundle-started', {
+                        runId,
+                        target: 'module',
+                        file: event.file,
+                    });
+                    break;
+                case 'module-bundling-finished':
+                    scheduleHook('metro:bundle-finished', {
+                        runId,
+                        target: 'module',
+                        file: event.file,
+                        duration: event.duration,
+                    });
+                    break;
+                case 'module-bundling-failed':
+                    scheduleHook('metro:bundle-failed', {
+                        runId,
+                        target: 'module',
+                        file: event.file,
+                        duration: event.duration,
+                        error: event.error,
+                    });
+                    break;
+                case 'setup-file-bundling-started':
+                    scheduleHook('metro:bundle-started', {
+                        runId,
+                        target: 'setupFile',
+                        file: event.file,
+                        setupType: event.setupType,
+                    });
+                    break;
+                case 'setup-file-bundling-finished':
+                    scheduleHook('metro:bundle-finished', {
+                        runId,
+                        target: 'setupFile',
+                        file: event.file,
+                        setupType: event.setupType,
+                        duration: event.duration,
+                    });
+                    break;
+                case 'setup-file-bundling-failed':
+                    scheduleHook('metro:bundle-failed', {
+                        runId,
+                        target: 'setupFile',
+                        file: event.file,
+                        setupType: event.setupType,
+                        duration: event.duration,
+                        error: event.error,
+                    });
+                    break;
+            }
+        };
+        const onMetroEvent = (event) => {
+            const runId = getCurrentRunId();
+            if (runId && event.type === 'client_log') {
+                scheduleHook('metro:client-log', {
+                    runId,
+                    level: event.level,
+                    data: event.data,
+                });
+            }
+        };
+        const crashSupervisor = createCrashSupervisor({
+            appMonitor,
+            platformRunner: platformInstance,
+        });
+        const onReady = (device) => {
+            crashSupervisor.markReady();
+            const runId = getCurrentRunId();
+            if (!runId) {
+                return;
+            }
+            scheduleHook('runtime:ready', {
+                runId,
+                device,
+            });
+        };
+        const onDisconnect = () => {
+            const runId = getCurrentRunId();
+            if (!runId) {
+                return;
+            }
+            scheduleHook('runtime:disconnected', {
+                runId,
+                reason: 'bridge-disconnected',
+            });
+        };
+        const onAppMonitorEvent = (event) => {
+            const runId = getCurrentRunId();
+            if (!runId) {
+                return;
+            }
+            if (event.type === 'app_started') {
+                scheduleHook('app:started', {
+                    runId,
+                    testFile: activeTestFilePath,
+                    pid: event.pid,
+                    source: event.source,
+                    line: event.line,
+                });
+                return;
+            }
+            if (event.type === 'app_exited') {
+                scheduleHook('app:exited', {
+                    runId,
+                    testFile: activeTestFilePath,
+                    pid: event.pid,
+                    source: event.source,
+                    line: event.line,
+                    isConfirmed: event.isConfirmed,
+                    crashDetails: event.crashDetails,
+                });
+                return;
+            }
+            if (event.type === 'possible_crash') {
+                scheduleHook('app:possible-crash', {
+                    runId,
+                    testFile: activeTestFilePath,
+                    pid: event.pid,
+                    source: event.source,
+                    line: event.line,
+                    isConfirmed: event.isConfirmed,
+                    crashDetails: event.crashDetails,
+                });
+            }
+        };
+        serverBridge.on('ready', onReady);
+        serverBridge.on('disconnect', onDisconnect);
+        serverBridge.on('event', bridgeEventListener);
+        metroInstance.events.addListener(onMetroEvent);
+        appMonitor.addListener(onAppMonitorEvent);
+        harnessLogger.debug('registered runtime, bridge, and Metro listeners');
+        if (config.forwardClientLogs) {
+            metroInstance.events.addListener(clientLogListener);
+            harnessLogger.debug('client log forwarding enabled');
+        }
+        const dispose = async (reason = 'normal') => {
+            harnessLogger.debug('disposing Harness (reason=%s)', reason);
+            let hookError;
+            try {
+                await flushPendingHooks();
+                await pluginManager.callHook('harness:after-run', {
+                    runId: currentRun?.runId,
+                    reason,
+                    summary: currentRun?.summary,
+                    status: currentRun?.status,
+                    error: currentRun?.error,
+                });
+                await flushPendingHooks();
+                await pluginManager.callHook('harness:before-dispose', {
+                    runId: currentRun?.runId,
+                    reason,
+                    summary: currentRun?.summary,
+                    status: currentRun?.status,
+                    error: currentRun?.error,
+                });
+                await flushPendingHooks();
+            }
+            catch (error) {
+                hookError = error;
+            }
+            if (config.forwardClientLogs) {
+                metroInstance.events.removeListener(clientLogListener);
+            }
+            metroInstance.events.removeListener(onMetroEvent);
+            appMonitor.removeListener(onAppMonitorEvent);
+            serverBridge.off('ready', onReady);
+            serverBridge.off('disconnect', onDisconnect);
+            serverBridge.off('event', bridgeEventListener);
+            let cleanupError;
+            try {
+                await Promise.all([
+                    crashSupervisor.dispose(),
+                    serverBridge.dispose(),
+                    platformInstance.dispose(),
+                    metroInstance.dispose(),
+                ]);
+            }
+            catch (error) {
+                cleanupError = error;
+            }
+            finally {
+                await resourceLease.release();
+                pluginAbortController.abort();
+            }
+            harnessLogger.debug('Harness resources disposed');
+            if (hookError) {
+                throw hookError;
+            }
+            if (cleanupError) {
+                throw cleanupError;
+            }
+        };
+        if (signal.aborted) {
+            await dispose('abort');
+            throw new DOMException('The operation was aborted', 'AbortError');
         }
-        else {
-            await platformInstance.restartApp(appLaunchOptions);
+        try {
+            await pluginManager.callHook('harness:before-creation', {
+                appLaunchOptions,
+            });
+            await flushPendingHooks();
+            await appMonitor.start();
+            harnessLogger.debug('app monitor started');
+            await pluginManager.callHook('harness:before-run', {
+                appLaunchOptions,
+            });
+            await flushPendingHooks();
         }
-        crashSupervisor.reset();
-        await crashSupervisor.start();
-        if (testFilePath) {
-            await ensureAppReady(testFilePath);
+        catch (error) {
+            const runState = currentRun;
+            if (runState) {
+                runState.error = error;
+                currentRun = runState;
+            }
+            await dispose(error instanceof DOMException && error.name === 'AbortError'
+                ? 'abort'
+                : 'error');
+            throw error;
         }
-    };
-    return {
-        context,
-        runTests: async (path, options) => {
-            const client = serverBridge.rpc.clients.at(-1);
-            if (!client) {
-                throw new Error('No client found');
-            }
-            return await client.runTests(path, {
-                ...options,
-                runner: platform.runner,
+        const ensureAppReady = async (testFilePath) => {
+            await flushPendingHooks();
+            setActiveTestFilePath(testFilePath);
+            crashSupervisor.setActiveTestFile(testFilePath);
+            harnessLogger.debug('ensuring app is ready for %s', testFilePath);
+            if (crashSupervisor.isReady() &&
+                (await platformInstance.isAppRunning())) {
+                harnessLogger.debug('reusing existing ready app for %s', testFilePath);
+                return;
+            }
+            crashSupervisor.reset();
+            harnessLogger.debug('app not ready, waiting for launch and runtime readiness');
+            await waitForAppReady({
+                metroInstance,
+                serverBridge,
+                platformInstance: platformInstance,
+                platformId: platform.platformId,
+                bundleStartTimeout: config.bundleStartTimeout ?? 60000,
+                readyTimeout: config.bridgeTimeout,
+                maxAppRestarts: config.maxAppRestarts ?? 2,
+                testFilePath,
+                crashSupervisor,
+                appLaunchOptions,
             });
-        },
-        ensureAppReady,
-        restart,
-        dispose,
-        crashSupervisor,
-    };
-};
-export const getHarness = async (config, platform, projectRoot) => {
-    const abortSignal = AbortSignal.timeout(config.bridgeTimeout);
-    try {
-        const harness = await getHarnessInternal(config, platform, projectRoot, abortSignal);
-        return harness;
+            await flushPendingHooks();
+            harnessLogger.debug('app is ready for %s', testFilePath);
+        };
+        const restart = async (testFilePath) => {
+            await flushPendingHooks();
+            await crashSupervisor.stop();
+            setActiveTestFilePath(testFilePath);
+            harnessLogger.debug('restarting app (testFile=%s mode=%s)', testFilePath ?? 'n/a', testFilePath ? 'stop-and-ensure-ready' : 'direct-restart');
+            if (testFilePath) {
+                harnessLogger.debug('stopping app before restart');
+                await platformInstance.stopApp();
+            }
+            else {
+                harnessLogger.debug('requesting direct app restart');
+                await platformInstance.restartApp(appLaunchOptions);
+            }
+            crashSupervisor.reset();
+            await crashSupervisor.start();
+            if (testFilePath) {
+                await ensureAppReady(testFilePath);
+            }
+            await flushPendingHooks();
+            harnessLogger.debug('restart completed');
+        };
+        return {
+            context,
+            runTests: async (path, options) => {
+                await flushPendingHooks();
+                activeTestFilePath = path;
+                const client = serverBridge.rpc.clients.at(-1);
+                if (!client) {
+                    throw new Error('No client found');
+                }
+                harnessLogger.debug('running test file on client: %s', path);
+                const result = await client.runTests(path, {
+                    ...options,
+                    runner: platform.runner,
+                });
+                await flushPendingHooks();
+                return result;
+            },
+            ensureAppReady,
+            restart,
+            dispose: () => dispose('normal'),
+            crashSupervisor,
+            callHook: async (name, payload) => {
+                await flushPendingHooks();
+                await pluginManager.callHook(name, payload);
+                await flushPendingHooks();
+            },
+            setRunState: (runState) => {
+                currentRun = runState;
+            },
+            getRunState: () => currentRun,
+        };
     }
     catch (error) {
-        if (error instanceof DOMException && error.name === 'AbortError') {
-            throw new InitializationTimeoutError();
-        }
+        await resourceLease.release();
         throw error;
     }
 };
+export const getHarness = async (config, platform, projectRoot) => {
+    harnessLogger.debug('creating Harness with platform ready timeout %dms', config.platformReadyTimeout);
+    return await getHarnessInternal(config, platform, projectRoot, new AbortController().signal);
+};