@react-native-harness/jest 1.0.0 → 1.1.0-rc.2

package/dist/harness.js

@@ -1,159 +1,501 @@
 import { getBridgeServer, } from '@react-native-harness/bridge/server';
-import { getMetroInstance, prewarmMetroBundle, } from '@react-native-harness/bundler-metro';
-import { InitializationTimeoutError, MaxAppRestartsError } from './errors.js';
-import { createCrashMonitor } from './crash-monitor.js';
+import { getMetroInstance, isMetroCacheReusable, waitForMetroBackedAppReady, } from '@react-native-harness/bundler-metro';
+import { createHarnessPluginManager, } from '@react-native-harness/plugins';
+import { logger, createCrashArtifactWriter } from '@react-native-harness/tools';
+import { InitializationTimeoutError } 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 } from './logs.js';
+const harnessLogger = logger.child('runtime');
+export const maybeLogMetroCacheReuse = (config, platform, projectRoot) => {
+    if (config.unstable__enableMetroCache &&
+        isMetroCacheReusable(projectRoot)) {
+        logMetroCacheReused(platform);
+    }
+};
+const createAbortError = () => new DOMException('The operation was aborted', 'AbortError');
+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 });
+    });
+};
 export const waitForAppReady = async (options) => {
-    const { metroEvents, serverBridge, platformInstance, bundleStartTimeout, maxRestarts, signal, } = options;
-    let restartCount = 0;
-    let isBundling = false;
-    let bundleTimeoutId = null;
-    const clearBundleTimeout = () => {
-        if (bundleTimeoutId) {
-            clearTimeout(bundleTimeoutId);
-            bundleTimeoutId = null;
-        }
+    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 new Promise((resolve, reject) => {
-        // Handle abort signal
-        signal.addEventListener('abort', () => {
-            clearBundleTimeout();
-            reject(new DOMException('The operation was aborted', 'AbortError'));
-        });
-        // Start/restart the bundle timeout
-        const startBundleTimeout = () => {
-            clearBundleTimeout();
-            bundleTimeoutId = setTimeout(() => {
-                if (isBundling)
-                    return; // Don't restart while bundling
-                if (restartCount >= maxRestarts) {
-                    cleanup();
-                    reject(new MaxAppRestartsError(restartCount + 1));
-                    return;
-                }
-                restartCount++;
-                platformInstance.restartApp().catch(reject);
-                startBundleTimeout(); // Reset timer for next attempt
-            }, bundleStartTimeout);
-        };
-        // Metro event listener
-        const onMetroEvent = (event) => {
-            if (event.type === 'bundle_build_started') {
-                isBundling = true;
-                clearBundleTimeout(); // Cancel restart timer while bundling
+    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),
+                ]);
             }
-            else if (event.type === 'bundle_build_done' ||
-                event.type === 'bundle_build_failed') {
-                isBundling = false;
-                startBundleTimeout(); // Reset timer after bundle completes
+            finally {
+                crashSupervisor.cancelCrashWaiters();
             }
-        };
-        // Bridge ready listener
-        const onReady = () => {
-            cleanup();
-            resolve();
-        };
-        const cleanup = () => {
-            clearBundleTimeout();
-            metroEvents.removeListener(onMetroEvent);
-            serverBridge.off('ready', onReady);
-        };
-        // Setup listeners
-        metroEvents.addListener(onMetroEvent);
-        serverBridge.once('ready', onReady);
-        // Start the app and timeout
-        platformInstance.restartApp().catch(reject);
-        startBundleTimeout();
+        },
+        onAttemptStart: () => {
+            logWait('beginning launch attempt for %s', testFilePath);
+            crashSupervisor.beginLaunch(testFilePath);
+        },
+        onAttemptReset: () => {
+            logWait('resetting launch attempt state');
+            crashSupervisor.cancelCrashWaiters();
+        },
     });
 };
 const getHarnessInternal = async (config, platform, projectRoot, signal) => {
     const context = {
         platform,
     };
+    harnessLogger.debug('creating Harness internals for runner=%s platform=%s', platform.name, platform.platformId);
+    maybeLogMetroCacheReuse(config, platform, projectRoot);
+    const pluginAbortController = new AbortController();
+    const pluginManager = createHarnessPluginManager({
+        plugins: (config.plugins ?? []),
+        projectRoot,
+        config,
+        runner: platform,
+        abortSignal: pluginAbortController.signal,
+    });
+    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));
+    };
+    harnessLogger.debug('starting Metro, platform runner, and bridge initialization');
     const [metroInstance, platformInstance, serverBridge] = await Promise.all([
-        getMetroInstance({ projectRoot, harnessConfig: config }, signal),
-        import(platform.runner).then((module) => module.default(platform.config, config)),
+        getMetroInstance({ projectRoot, harnessConfig: config }, signal).then((instance) => {
+            harnessLogger.debug('Metro initialized');
+            return instance;
+        }),
+        import(platform.runner)
+            .then((module) => module.default(platform.config, config))
+            .then((instance) => {
+            harnessLogger.debug('platform runner initialized');
+            return instance;
+        }),
         getBridgeServer({
             port: config.webSocketPort,
             timeout: config.bridgeTimeout,
             context,
+        }).then((bridge) => {
+            harnessLogger.debug('bridge server initialized on port %d', config.webSocketPort);
+            return bridge;
         }),
     ]);
-    // Forward client logs to console if enabled
+    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 () => {
+    const dispose = async (reason = 'normal') => {
+        harnessLogger.debug('disposing Harness (reason=%s)', reason);
+        let hookError;
+        try {
+            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);
         await Promise.all([
+            crashSupervisor.dispose(),
             serverBridge.dispose(),
             platformInstance.dispose(),
             metroInstance.dispose(),
         ]);
+        pluginAbortController.abort();
+        harnessLogger.debug('Harness resources disposed');
+        if (hookError) {
+            throw hookError;
+        }
     };
-    const crashMonitor = createCrashMonitor({
-        interval: config.crashDetectionInterval,
-        platformRunner: platformInstance,
-        bridgeServer: serverBridge,
-    });
     if (signal.aborted) {
-        await dispose();
+        await dispose('abort');
         throw new DOMException('The operation was aborted', 'AbortError');
     }
     try {
-        await prewarmMetroBundle({
-            projectRoot,
-            entryPoint: config.entryPoint,
-            platform: platform.platformId,
-            dev: true,
-            minify: false,
-            signal,
-        });
-        logMetroPrewarmCompleted(platform);
-        await waitForAppReady({
-            metroEvents: metroInstance.events,
-            serverBridge,
-            platformInstance: platformInstance,
-            bundleStartTimeout: config.bundleStartTimeout,
-            maxRestarts: config.maxAppRestarts,
-            signal,
+        await pluginManager.callHook('harness:before-creation', {
+            appLaunchOptions,
         });
+        await appMonitor.start();
+        harnessLogger.debug('app monitor started');
     }
     catch (error) {
-        await dispose();
+        const runState = currentRun;
+        if (runState) {
+            runState.error = error;
+            currentRun = runState;
+        }
+        await dispose(error instanceof DOMException && error.name === 'AbortError' ? 'abort' : 'error');
         throw error;
     }
-    const restart = () => new Promise((resolve, reject) => {
-        crashMonitor.markIntentionalRestart();
-        serverBridge.once('ready', () => {
-            crashMonitor.clearIntentionalRestart();
-            resolve();
+    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,
         });
-        platformInstance.restartApp().catch(reject);
-    });
+        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');
             }
-            return await client.runTests(path, {
+            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,
-        crashMonitor,
+        dispose: () => dispose('normal'),
+        crashSupervisor,
+        callHook: async (name, payload) => {
+            await flushPendingHooks();
+            await pluginManager.callHook(name, payload);
+            await flushPendingHooks();
+        },
+        setRunState: (runState) => {
+            currentRun = runState;
+        },
+        getRunState: () => currentRun,
     };
 };
 export const getHarness = async (config, platform, projectRoot) => {
     const abortSignal = AbortSignal.timeout(config.bridgeTimeout);
+    harnessLogger.debug('creating Harness with bridge timeout %dms', config.bridgeTimeout);
     try {
         const harness = await getHarnessInternal(config, platform, projectRoot, abortSignal);
         return harness;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,2BAA2B,EAC3B,MAAM,EACN,aAAa,EACb,WAAW,EACX,aAAa,EACb,IAAI,EACJ,iBAAiB,EACjB,WAAW,EACZ,MAAM,aAAa,CAAC;AAGrB,OAAO,EAAE,MAAM,IAAI,aAAa,EAAE,MAAM,8BAA8B,CAAC;AACvE,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,cAAc,CAAC;AAe5C,MAAM,CAAC,OAAO,OAAO,WAAY,YAAW,2BAA2B;;IACrE,QAAQ,CAAC,QAAQ,QAAQ;gBAIb,YAAY,EAAE,MAAM,CAAC,YAAY;IAIvC,QAAQ,CACZ,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,EAClB,OAAO,EAAE,WAAW,EACpB,OAAO,EAAE,WAAW,EACpB,QAAQ,EAAE,aAAa,EACvB,SAAS,EAAE,aAAa,EACxB,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,IAAI,CAAC;IAkCV,oBAAoB,CACxB,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,EAClB,OAAO,EAAE,WAAW,EACpB,OAAO,EAAE,OAAO,EAChB,aAAa,EAAE,aAAa,EAC5B,OAAO,EAAE,WAAW,EACpB,QAAQ,EAAE,aAAa,EACvB,SAAS,EAAE,aAAa,GACvB,OAAO,CAAC,IAAI,CAAC;CAkFjB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,2BAA2B,EAC3B,MAAM,EACN,aAAa,EACb,WAAW,EACX,aAAa,EACb,IAAI,EACJ,iBAAiB,EACjB,WAAW,EACZ,MAAM,aAAa,CAAC;AAGrB,OAAO,EAAE,MAAM,IAAI,aAAa,EAAE,MAAM,8BAA8B,CAAC;AACvE,OAAO,EAAE,KAAK,OAAO,EAAwB,MAAM,cAAc,CAAC;AA0ClE,MAAM,CAAC,OAAO,OAAO,WAAY,YAAW,2BAA2B;;IACrE,QAAQ,CAAC,QAAQ,QAAQ;gBAIb,YAAY,EAAE,MAAM,CAAC,YAAY;IAIvC,QAAQ,CACZ,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,EAClB,OAAO,EAAE,WAAW,EACpB,OAAO,EAAE,WAAW,EACpB,QAAQ,EAAE,aAAa,EACvB,SAAS,EAAE,aAAa,EACxB,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,IAAI,CAAC;IAkCV,oBAAoB,CACxB,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,EAClB,OAAO,EAAE,WAAW,EACpB,OAAO,EAAE,OAAO,EAChB,aAAa,EAAE,aAAa,EAC5B,OAAO,EAAE,WAAW,EACpB,QAAQ,EAAE,aAAa,EACvB,SAAS,EAAE,aAAa,GACvB,OAAO,CAAC,IAAI,CAAC;CAyQjB"}