@react-native-harness/jest 1.0.0-alpha.20 → 1.0.0-alpha.21

package/dist/crash-monitor.d.ts

@@ -0,0 +1,16 @@
+import { HarnessPlatformRunner } from '@react-native-harness/platforms';
+import { BridgeServer } from '@react-native-harness/bridge/server';
+export type CrashMonitor = {
+    startMonitoring(testFilePath: string): Promise<never>;
+    stopMonitoring(): void;
+    markIntentionalRestart(): void;
+    clearIntentionalRestart(): void;
+    dispose(): void;
+};
+export type CrashMonitorOptions = {
+    interval: number;
+    platformRunner: HarnessPlatformRunner;
+    bridgeServer: BridgeServer;
+};
+export declare const createCrashMonitor: ({ interval, platformRunner, bridgeServer, }: CrashMonitorOptions) => CrashMonitor;
+//# sourceMappingURL=crash-monitor.d.ts.map

package/dist/crash-monitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crash-monitor.d.ts","sourceRoot":"","sources":["../src/crash-monitor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AACxE,OAAO,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AAInE,MAAM,MAAM,YAAY,GAAG;IACzB,eAAe,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IACtD,cAAc,IAAI,IAAI,CAAC;IACvB,sBAAsB,IAAI,IAAI,CAAC;IAC/B,uBAAuB,IAAI,IAAI,CAAC;IAChC,OAAO,IAAI,IAAI,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,qBAAqB,CAAC;IACtC,YAAY,EAAE,YAAY,CAAC;CAC5B,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,6CAIhC,mBAAmB,KAAG,YAqFxB,CAAC"}

package/dist/crash-monitor.js

@@ -0,0 +1,75 @@
+import { NativeCrashError } from './errors.js';
+import { logger } from '@react-native-harness/tools';
+export const createCrashMonitor = ({ interval, platformRunner, bridgeServer, }) => {
+    let pollingInterval = null;
+    let isIntentionalRestart = false;
+    let currentTestFilePath = null;
+    let rejectFn = null;
+    const handleDisconnect = () => {
+        // Verify if it's actually a crash by checking if app is still running
+        if (!isIntentionalRestart && currentTestFilePath) {
+            // Capture the value to avoid it being null when setTimeout callback runs
+            const testFilePath = currentTestFilePath;
+            logger.debug('Bridge disconnected, checking if app crashed');
+            // Use a slight delay to allow the OS to clean up the process
+            setTimeout(async () => {
+                const isRunning = await platformRunner.isAppRunning();
+                if (!isRunning && !isIntentionalRestart && rejectFn) {
+                    logger.debug(`Native crash detected during: ${testFilePath}`);
+                    rejectFn(new NativeCrashError(testFilePath));
+                }
+            }, 100);
+        }
+    };
+    const startMonitoring = (testFilePath) => {
+        currentTestFilePath = testFilePath;
+        return new Promise((_, reject) => {
+            rejectFn = reject;
+            // Listen for bridge disconnect as early indicator
+            bridgeServer.on('disconnect', handleDisconnect);
+            // Poll for app running status
+            pollingInterval = setInterval(async () => {
+                // Skip check during intentional restarts
+                if (isIntentionalRestart) {
+                    return;
+                }
+                try {
+                    const isRunning = await platformRunner.isAppRunning();
+                    if (!isRunning && currentTestFilePath) {
+                        logger.debug(`Native crash detected during: ${currentTestFilePath}`);
+                        stopMonitoring();
+                        reject(new NativeCrashError(currentTestFilePath));
+                    }
+                }
+                catch (error) {
+                    logger.error('Error checking app status:', error);
+                }
+            }, interval);
+        });
+    };
+    const stopMonitoring = () => {
+        if (pollingInterval) {
+            clearInterval(pollingInterval);
+            pollingInterval = null;
+        }
+        bridgeServer.off('disconnect', handleDisconnect);
+        currentTestFilePath = null;
+        rejectFn = null;
+    };
+    const markIntentionalRestart = () => {
+        isIntentionalRestart = true;
+    };
+    const clearIntentionalRestart = () => {
+        isIntentionalRestart = false;
+    };
+    const dispose = () => {
+        stopMonitoring();
+    };
+    return {
+        startMonitoring,
+        stopMonitoring,
+        markIntentionalRestart,
+        clearIntentionalRestart,
+        dispose,
+    };
+};

package/dist/errors.d.ts

@@ -9,4 +9,12 @@ export declare class RunnerNotFoundError extends HarnessError {
 export declare class InitializationTimeoutError extends HarnessError {
     constructor();
 }
+export declare class MaxAppRestartsError extends HarnessError {
+    constructor(attempts: number);
+}
+export declare class NativeCrashError extends HarnessError {
+    readonly testFilePath: string;
+    readonly lastKnownTest?: string | undefined;
+    constructor(testFilePath: string, lastKnownTest?: string | undefined);
+}
 //# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAE3D,qBAAa,sBAAuB,SAAQ,YAAY;;CAKvD;AAED,qBAAa,mBAAoB,SAAQ,YAAY;aACvB,UAAU,EAAE,MAAM;gBAAlB,UAAU,EAAE,MAAM;CAI/C;AAED,qBAAa,0BAA2B,SAAQ,YAAY;;CAK3D"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAE3D,qBAAa,sBAAuB,SAAQ,YAAY;;CAKvD;AAED,qBAAa,mBAAoB,SAAQ,YAAY;aACvB,UAAU,EAAE,MAAM;gBAAlB,UAAU,EAAE,MAAM;CAI/C;AAED,qBAAa,0BAA2B,SAAQ,YAAY;;CAK3D;AAED,qBAAa,mBAAoB,SAAQ,YAAY;gBACvC,QAAQ,EAAE,MAAM;CAO7B;AAED,qBAAa,gBAAiB,SAAQ,YAAY;aAE9B,YAAY,EAAE,MAAM;aACpB,aAAa,CAAC,EAAE,MAAM;gBADtB,YAAY,EAAE,MAAM,EACpB,aAAa,CAAC,EAAE,MAAM,YAAA;CAKzC"}

package/dist/errors.js

@@ -19,3 +19,20 @@ export class InitializationTimeoutError extends HarnessError {
         this.name = 'InitializationTimeoutError';
     }
 }
+export class MaxAppRestartsError extends HarnessError {
+    constructor(attempts) {
+        super(`App failed to start after ${attempts} attempts. ` +
+            `No bundling activity detected within timeout period.`);
+        this.name = 'MaxAppRestartsError';
+    }
+}
+export class NativeCrashError extends HarnessError {
+    testFilePath;
+    lastKnownTest;
+    constructor(testFilePath, lastKnownTest) {
+        super('The native app crashed during test execution.');
+        this.testFilePath = testFilePath;
+        this.lastKnownTest = lastKnownTest;
+        this.name = 'NativeCrashError';
+    }
+}

package/dist/harness.d.ts

@@ -1,10 +1,22 @@
+import { BridgeServer } from '@react-native-harness/bridge/server';
 import { BridgeClientFunctions } from '@react-native-harness/bridge';
-import { HarnessPlatform } from '@react-native-harness/platforms';
+import { HarnessPlatform, HarnessPlatformRunner } from '@react-native-harness/platforms';
+import { Reporter } from '@react-native-harness/bundler-metro';
 import { Config as HarnessConfig } from '@react-native-harness/config';
+import { CrashMonitor } from './crash-monitor.js';
 export type Harness = {
     runTests: BridgeClientFunctions['runTests'];
     restart: () => Promise<void>;
     dispose: () => Promise<void>;
+    crashMonitor: CrashMonitor;
 };
+export declare const waitForAppReady: (options: {
+    metroEvents: Reporter;
+    serverBridge: BridgeServer;
+    platformInstance: HarnessPlatformRunner;
+    bundleStartTimeout: number;
+    maxRestarts: number;
+    signal: AbortSignal;
+}) => Promise<void>;
 export declare const getHarness: (config: HarnessConfig, platform: HarnessPlatform, projectRoot: string) => Promise<Harness>;
 //# sourceMappingURL=harness.d.ts.map

package/dist/harness.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"harness.d.ts","sourceRoot":"","sources":["../src/harness.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAGlE,OAAO,EAAE,MAAM,IAAI,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAKvE,MAAM,MAAM,OAAO,GAAG;IACpB,QAAQ,EAAE,qBAAqB,CAAC,UAAU,CAAC,CAAC;IAC5C,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B,CAAC;AA6EF,eAAO,MAAM,UAAU,GACrB,QAAQ,aAAa,EACrB,UAAU,eAAe,EACzB,aAAa,MAAM,KAClB,OAAO,CAAC,OAAO,CAkBjB,CAAC"}
+{"version":3,"file":"harness.d.ts","sourceRoot":"","sources":["../src/harness.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,YAAY,EACb,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,EACL,eAAe,EACf,qBAAqB,EACtB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAEL,QAAQ,EAET,MAAM,qCAAqC,CAAC;AAE7C,OAAO,EAAE,MAAM,IAAI,aAAa,EAAE,MAAM,8BAA8B,CAAC;AACvE,OAAO,EAAsB,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEtE,MAAM,MAAM,OAAO,GAAG;IACpB,QAAQ,EAAE,qBAAqB,CAAC,UAAU,CAAC,CAAC;IAC5C,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B,YAAY,EAAE,YAAY,CAAC;CAC5B,CAAC;AAEF,eAAO,MAAM,eAAe,GAAU,SAAS;IAC7C,WAAW,EAAE,QAAQ,CAAC;IACtB,YAAY,EAAE,YAAY,CAAC;IAC3B,gBAAgB,EAAE,qBAAqB,CAAC;IACxC,kBAAkB,EAAE,MAAM,CAAC;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,WAAW,CAAC;CACrB,KAAG,OAAO,CAAC,IAAI,CAgFf,CAAC;AA+EF,eAAO,MAAM,UAAU,GACrB,QAAQ,aAAa,EACrB,UAAU,eAAe,EACzB,aAAa,MAAM,KAClB,OAAO,CAAC,OAAO,CAkBjB,CAAC"}

package/dist/harness.js

@@ -1,8 +1,70 @@
-import { getBridgeServer } from '@react-native-harness/bridge/server';
-import { getMetroInstance } from '@react-native-harness/bundler-metro';
-import { InitializationTimeoutError } from './errors.js';
-import pRetry from 'p-retry';
-const BRIDGE_READY_TIMEOUT = 10000;
+import { getBridgeServer, } from '@react-native-harness/bridge/server';
+import { getMetroInstance, } from '@react-native-harness/bundler-metro';
+import { InitializationTimeoutError, MaxAppRestartsError } from './errors.js';
+import { createCrashMonitor } from './crash-monitor.js';
+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;
+        }
+    };
+    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
+            }
+            else if (event.type === 'bundle_build_done' ||
+                event.type === 'bundle_build_failed') {
+                isBundling = false;
+                startBundleTimeout(); // Reset timer after bundle completes
+            }
+        };
+        // 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();
+    });
+};
 const getHarnessInternal = async (config, platform, projectRoot, signal) => {
     const [metroInstance, platformInstance, serverBridge] = await Promise.all([
         getMetroInstance({ projectRoot, harnessConfig: config }, signal),
@@ -19,21 +81,22 @@ const getHarnessInternal = async (config, platform, projectRoot, signal) => {
             metroInstance.dispose(),
         ]);
     };
+    const crashMonitor = createCrashMonitor({
+        interval: config.crashDetectionInterval,
+        platformRunner: platformInstance,
+        bridgeServer: serverBridge,
+    });
     if (signal.aborted) {
         await dispose();
         throw new DOMException('The operation was aborted', 'AbortError');
     }
     try {
-        await pRetry(() => new Promise((resolve, reject) => {
-            signal.addEventListener('abort', () => {
-                reject(new DOMException('The operation was aborted', 'AbortError'));
-            });
-            serverBridge.once('ready', () => resolve());
-            platformInstance.restartApp().catch(reject);
-        }), {
-            minTimeout: BRIDGE_READY_TIMEOUT,
-            maxTimeout: BRIDGE_READY_TIMEOUT,
-            retries: Infinity,
+        await waitForAppReady({
+            metroEvents: metroInstance.events,
+            serverBridge,
+            platformInstance: platformInstance,
+            bundleStartTimeout: config.bundleStartTimeout,
+            maxRestarts: config.maxAppRestarts,
             signal,
         });
     }
@@ -42,7 +105,11 @@ const getHarnessInternal = async (config, platform, projectRoot, signal) => {
         throw error;
     }
     const restart = () => new Promise((resolve, reject) => {
-        serverBridge.once('ready', () => resolve());
+        crashMonitor.markIntentionalRestart();
+        serverBridge.once('ready', () => {
+            crashMonitor.clearIntentionalRestart();
+            resolve();
+        });
         platformInstance.restartApp().catch(reject);
     });
     return {
@@ -55,6 +122,7 @@ const getHarnessInternal = async (config, platform, projectRoot, signal) => {
         },
         restart,
         dispose,
+        crashMonitor,
     };
 };
 export const getHarness = async (config, platform, projectRoot) => {

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;AAc5C,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;CA+CjB"}
+{"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"}

package/dist/index.js

@@ -5,6 +5,7 @@ import { teardown } from './teardown.js';
 import { HarnessError } from '@react-native-harness/tools';
 import { getErrorMessage } from './logs.js';
 import { DeviceNotRespondingError } from '@react-native-harness/bridge';
+import { NativeCrashError } from './errors.js';
 class CancelRun extends Error {
     constructor(message) {
         super(message);
@@ -53,15 +54,45 @@ export default class JestHarness {
                 await harness.restart();
             }
             isFirstTest = false;
-            return onStart(test).then(() => runHarnessTestFile({
-                testPath: test.path,
-                harness,
-                globalConfig: this.#globalConfig,
-                projectConfig: test.context.config,
-            }));
+            return onStart(test).then(async () => {
+                if (!harnessConfig.detectNativeCrashes) {
+                    return runHarnessTestFile({
+                        testPath: test.path,
+                        harness,
+                        globalConfig: this.#globalConfig,
+                        projectConfig: test.context.config,
+                    });
+                }
+                // Start crash monitoring
+                const crashPromise = harness.crashMonitor.startMonitoring(test.path);
+                try {
+                    const result = await Promise.race([
+                        runHarnessTestFile({
+                            testPath: test.path,
+                            harness,
+                            globalConfig: this.#globalConfig,
+                            projectConfig: test.context.config,
+                        }),
+                        crashPromise,
+                    ]);
+                    return result;
+                }
+                finally {
+                    harness.crashMonitor.stopMonitoring();
+                }
+            });
         })
             .then((result) => onResult(test, result))
-            .catch((err) => {
+            .catch(async (err) => {
+            if (err instanceof NativeCrashError) {
+                onFailure(test, {
+                    message: err.message,
+                    stack: '',
+                });
+                // Restart the app for the next test file
+                await harness.restart();
+                return;
+            }
             if (err instanceof DeviceNotRespondingError) {
                 onFailure(test, {
                     message: err.message,