@react-native-harness/jest 1.0.0-canary.1766225407244 → 1.0.0

package/src/harness.ts

@@ -1,17 +1,128 @@
-import { getBridgeServer } 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 {
+  getBridgeServer,
+  BridgeServer,
+} from '@react-native-harness/bridge/server';
+import {
+  HarnessContext,
+  TestExecutionOptions,
+  TestSuiteResult,
+} from '@react-native-harness/bridge';
+import {
+  HarnessPlatform,
+  HarnessPlatformRunner,
+} from '@react-native-harness/platforms';
+import {
+  getMetroInstance,
+  prewarmMetroBundle,
+  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';
+import { createCrashMonitor, CrashMonitor } from './crash-monitor.js';
+import { createClientLogListener } from './client-log-handler.js';
+import { logMetroPrewarmCompleted } from './logs.js';
 
-const BRIDGE_READY_TIMEOUT = 10000;
+export type HarnessRunTestsOptions = Exclude<TestExecutionOptions, 'platform'>;
 
 export type Harness = {
-  runTests: BridgeClientFunctions['runTests'];
+  context: HarnessContext;
+  runTests: (
+    path: string,
+    options: HarnessRunTestsOptions
+  ) => Promise<TestSuiteResult>;
   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 (
@@ -20,16 +131,33 @@ const getHarnessInternal = async (
   projectRoot: string,
   signal: AbortSignal
 ): Promise<Harness> => {
+  const context: HarnessContext = {
+    platform,
+  };
+
   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,
+      context,
     }),
   ]);
 
+  // Forward client logs to console if enabled
+  const clientLogListener = createClientLogListener();
+
+  if (config.forwardClientLogs) {
+    metroInstance.events.addListener(clientLogListener);
+  }
+
   const dispose = async () => {
+    if (config.forwardClientLogs) {
+      metroInstance.events.removeListener(clientLogListener);
+    }
     await Promise.all([
       serverBridge.dispose(),
       platformInstance.dispose(),
@@ -37,6 +165,12 @@ const getHarnessInternal = async (
     ]);
   };
 
+  const crashMonitor = createCrashMonitor({
+    interval: config.crashDetectionInterval,
+    platformRunner: platformInstance,
+    bridgeServer: serverBridge,
+  });
+
   if (signal.aborted) {
     await dispose();
 
@@ -44,23 +178,24 @@ 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 prewarmMetroBundle({
+      projectRoot,
+      entryPoint: config.entryPoint,
+      platform: platform.platformId,
+      dev: true,
+      minify: false,
+      signal,
+    });
+    logMetroPrewarmCompleted(platform);
+
+    await waitForAppReady({
+      metroEvents: metroInstance.events,
+      serverBridge,
+      platformInstance: platformInstance as HarnessPlatformRunner,
+      bundleStartTimeout: config.bundleStartTimeout,
+      maxRestarts: config.maxAppRestarts,
+      signal,
+    });
   } catch (error) {
     await dispose();
     throw error;
@@ -68,11 +203,16 @@ 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);
     });
 
   return {
+    context,
     runTests: async (path, options) => {
       const client = serverBridge.rpc.clients.at(-1);
 
@@ -80,10 +220,14 @@ const getHarnessInternal = async (
         throw new Error('No client found');
       }
 
-      return await client.runTests(path, options);
+      return await client.runTests(path, {
+        ...options,
+        runner: platform.runner,
+      });
     },
     restart,
     dispose,
+    crashMonitor,
   };
 };
 

package/src/index.ts

@@ -16,7 +16,8 @@ import { setup } from './setup.js';
 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 { DeviceNotRespondingError } from '@react-native-harness/bridge/server';
+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,

package/src/logs.ts

@@ -25,6 +25,12 @@ export const logTestEnvironmentReady = (runner: HarnessPlatform): void => {
   log(`${TAG} Runner ${chalk.bold(runner.name)} ready\n`);
 };
 
+export const logMetroPrewarmCompleted = (runner: HarnessPlatform): void => {
+  log(
+    `${TAG} Metro pre-warm for ${chalk.bold(runner.name)} completed\n`
+  );
+};
+
 export const getErrorMessage = (error: HarnessError): string => {
   return `${ERROR_TAG} ${error.message}\n`;
 };

package/src/run.ts

@@ -88,6 +88,7 @@ export const runHarnessTestFile: RunHarnessTestFile = async ({
     testNamePattern: globalConfig.testNamePattern,
     setupFiles,
     setupFilesAfterEnv,
+    runner: harness.context.platform.runner,
   });
   const end = Date.now();
 

package/src/setup.ts

@@ -68,6 +68,14 @@ export const setup = async (globalConfig: JestConfig.GlobalConfig) => {
     // This is going to be used by @react-native-harness/babel-preset
     // to enable instrumentation of test files.
     process.env.RN_HARNESS_COLLECT_COVERAGE = 'true';
+
+    if (harnessConfig.coverage?.root) {
+      process.env.RN_HARNESS_COVERAGE_ROOT = harnessConfig.coverage.root;
+    }
+  }
+
+  if (harnessConfig.disableViewFlattening) {
+    process.env.RN_HARNESS_VIEW_FLATTENING = 'false';
   }
 
   logTestRunHeader(selectedRunner);

package/tsconfig.json

@@ -6,9 +6,6 @@
     {
       "path": "../cli"
     },
-    {
-      "path": "../bundler-metro"
-    },
     {
       "path": "../tools"
     },
@@ -18,6 +15,9 @@
     {
       "path": "../config"
     },
+    {
+      "path": "../bundler-metro"
+    },
     {
       "path": "../bridge"
     },

package/vite.config.ts

@@ -0,0 +1,18 @@
+/// <reference types='vitest' />
+import { defineConfig } from 'vite';
+
+export default defineConfig(() => ({
+  root: __dirname,
+  cacheDir: '../../node_modules/.vite/packages/jest',
+  test: {
+    watch: false,
+    globals: true,
+    environment: 'node',
+    include: ['{src,tests}/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
+    reporters: ['default'],
+    coverage: {
+      reportsDirectory: './test-output/vitest/coverage',
+      provider: 'v8' as const,
+    },
+  },
+}));