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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-native-harness/jest",
-  "version": "1.0.0-alpha.19",
+  "version": "1.0.0-alpha.21",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -38,14 +38,13 @@
     "jest-message-util": "^30.2.0",
     "jest-util": "^30.2.0",
     "p-limit": "^7.1.1",
-    "p-retry": "^7.1.0",
     "tslib": "^2.3.0",
     "yargs": "^17.7.2",
-    "@react-native-harness/bridge": "1.0.0-alpha.19",
-    "@react-native-harness/config": "1.0.0-alpha.19",
-    "@react-native-harness/bundler-metro": "1.0.0-alpha.19",
-    "@react-native-harness/tools": "1.0.0-alpha.19",
-    "@react-native-harness/platforms": "1.0.0-alpha.19"
+    "@react-native-harness/bridge": "1.0.0-alpha.21",
+    "@react-native-harness/bundler-metro": "1.0.0-alpha.21",
+    "@react-native-harness/config": "1.0.0-alpha.21",
+    "@react-native-harness/platforms": "1.0.0-alpha.21",
+    "@react-native-harness/tools": "1.0.0-alpha.21"
   },
   "devDependencies": {
     "@types/yargs": "^17.0.32",

package/src/crash-monitor.ts

@@ -0,0 +1,109 @@
+import { HarnessPlatformRunner } from '@react-native-harness/platforms';
+import { BridgeServer } from '@react-native-harness/bridge/server';
+import { NativeCrashError } from './errors.js';
+import { logger } from '@react-native-harness/tools';
+
+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 const createCrashMonitor = ({
+  interval,
+  platformRunner,
+  bridgeServer,
+}: CrashMonitorOptions): CrashMonitor => {
+  let pollingInterval: NodeJS.Timeout | null = null;
+  let isIntentionalRestart = false;
+  let currentTestFilePath: string | null = null;
+  let rejectFn: ((error: NativeCrashError) => void) | null = 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: string): Promise<never> => {
+    currentTestFilePath = testFilePath;
+
+    return new Promise<never>((_, 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/src/errors.ts

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

package/src/harness.ts

@@ -1,17 +1,115 @@
-import { getBridgeServer } from '@react-native-harness/bridge/server';
+import {
+  getBridgeServer,
+  BridgeServer,
+} from '@react-native-harness/bridge/server';
 import { BridgeClientFunctions } from '@react-native-harness/bridge';
-import { HarnessPlatform } from '@react-native-harness/platforms';
-import { getMetroInstance } from '@react-native-harness/bundler-metro';
-import { InitializationTimeoutError } from './errors.js';
+import {
+  HarnessPlatform,
+  HarnessPlatformRunner,
+} from '@react-native-harness/platforms';
+import {
+  getMetroInstance,
+  Reporter,
+  ReportableEvent,
+} from '@react-native-harness/bundler-metro';
+import { InitializationTimeoutError, MaxAppRestartsError } from './errors.js';
 import { Config as HarnessConfig } from '@react-native-harness/config';
-import pRetry from 'p-retry';
-
-const BRIDGE_READY_TIMEOUT = 10000;
+import { createCrashMonitor, CrashMonitor } from './crash-monitor.js';
 
 export type Harness = {
   runTests: BridgeClientFunctions['runTests'];
   restart: () => Promise<void>;
   dispose: () => Promise<void>;
+  crashMonitor: CrashMonitor;
+};
+
+export const waitForAppReady = async (options: {
+  metroEvents: Reporter;
+  serverBridge: BridgeServer;
+  platformInstance: HarnessPlatformRunner;
+  bundleStartTimeout: number;
+  maxRestarts: number;
+  signal: AbortSignal;
+}): Promise<void> => {
+  const {
+    metroEvents,
+    serverBridge,
+    platformInstance,
+    bundleStartTimeout,
+    maxRestarts,
+    signal,
+  } = options;
+
+  let restartCount = 0;
+  let isBundling = false;
+  let bundleTimeoutId: NodeJS.Timeout | null = null;
+
+  const clearBundleTimeout = () => {
+    if (bundleTimeoutId) {
+      clearTimeout(bundleTimeoutId);
+      bundleTimeoutId = null;
+    }
+  };
+
+  return new Promise<void>((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: ReportableEvent) => {
+      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 (
@@ -22,9 +120,11 @@ const getHarnessInternal = async (
 ): Promise<Harness> => {
   const [metroInstance, platformInstance, serverBridge] = await Promise.all([
     getMetroInstance({ projectRoot, harnessConfig: config }, signal),
-    import(platform.runner).then((module) => module.default(platform.config)),
+    import(platform.runner).then((module) =>
+      module.default(platform.config, config)
+    ),
     getBridgeServer({
-      port: 3001,
+      port: config.webSocketPort,
       timeout: config.bridgeTimeout,
     }),
   ]);
@@ -37,6 +137,12 @@ const getHarnessInternal = async (
     ]);
   };
 
+  const crashMonitor = createCrashMonitor({
+    interval: config.crashDetectionInterval,
+    platformRunner: platformInstance,
+    bridgeServer: serverBridge,
+  });
+
   if (signal.aborted) {
     await dispose();
 
@@ -44,23 +150,14 @@ const getHarnessInternal = async (
   }
 
   try {
-    await pRetry(
-      () =>
-        new Promise<void>((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,
-        signal,
-      }
-    );
+    await waitForAppReady({
+      metroEvents: metroInstance.events,
+      serverBridge,
+      platformInstance: platformInstance as HarnessPlatformRunner,
+      bundleStartTimeout: config.bundleStartTimeout,
+      maxRestarts: config.maxAppRestarts,
+      signal,
+    });
   } catch (error) {
     await dispose();
     throw error;
@@ -68,7 +165,11 @@ const getHarnessInternal = async (
 
   const restart = () =>
     new Promise<void>((resolve, reject) => {
-      serverBridge.once('ready', () => resolve());
+      crashMonitor.markIntentionalRestart();
+      serverBridge.once('ready', () => {
+        crashMonitor.clearIntentionalRestart();
+        resolve();
+      });
       platformInstance.restartApp().catch(reject);
     });
 
@@ -84,6 +185,7 @@ const getHarnessInternal = async (
     },
     restart,
     dispose,
+    crashMonitor,
   };
 };
 

package/src/index.ts

@@ -17,6 +17,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?: string) {
@@ -104,17 +105,52 @@ export default class JestHarness implements CallbackTestRunnerInterface {
               }
               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,