@react-native-harness/jest 1.2.0 → 1.4.0-rc.1

package/src/harness-session.ts

@@ -7,11 +7,13 @@ import {
   HARNESS_BRIDGE_PATH,
   type HarnessContext,
   type BridgeEvents,
+  type TestRunnerEvents,
   type TestExecutionOptions,
   type TestSuiteResult,
 } from '@react-native-harness/bridge';
 import {
   type AppLaunchOptions,
+  type AppSession,
   type HarnessPlatform,
   type HarnessPlatformInitOptions,
   type HarnessPlatformRunner,
@@ -33,8 +35,8 @@ import {
   type HarnessRunSummary,
 } from '@react-native-harness/plugins';
 import {
-  logger,
   createCrashArtifactWriter,
+  logger,
   getTimeoutSignal,
   raceAbortSignals,
 } from '@react-native-harness/tools';
@@ -45,6 +47,7 @@ import {
 } from '@react-native-harness/config';
 import type { Config as JestConfig } from 'jest-runner';
 import { preRunMessage } from 'jest-util';
+import path from 'node:path';
 import { PlatformReadyTimeoutError } from './errors.js';
 import { NoRunnerSpecifiedError, RunnerNotFoundError } from './errors.js';
 import { createCrashMonitor, type CrashMonitor } from './crash-monitor.js';
@@ -75,6 +78,48 @@ import {
 const sessionLogger = logger.child('runtime');
 const defaultResourceLockManager = createResourceLockManager();
 const ignorePromiseRejection = () => undefined;
+const isBridgeDisconnectError = (error: unknown) =>
+  error instanceof Error && error.message === 'App bridge disconnected';
+const TEST_RUN_BRIDGE_STABILITY_WAIT_MS = 500;
+
+type DisconnectObservableBridge = {
+  readonly connection: AppConnection | null;
+  on: (event: 'disconnected', listener: () => void) => void;
+  off: (event: 'disconnected', listener: () => void) => void;
+};
+
+export const waitForBridgeDisconnectOrTimeout = async ({
+  bridge,
+  connection,
+  timeoutMs,
+}: {
+  bridge: DisconnectObservableBridge;
+  connection: AppConnection;
+  timeoutMs: number;
+}): Promise<boolean> => {
+  if (bridge.connection !== connection) {
+    return true;
+  }
+
+  return await new Promise<boolean>((resolve) => {
+    const onDisconnected = () => {
+      cleanup();
+      resolve(true);
+    };
+
+    const cleanup = () => {
+      clearTimeout(timer);
+      bridge.off('disconnected', onDisconnected);
+    };
+
+    const timer = setTimeout(() => {
+      cleanup();
+      resolve(bridge.connection !== connection);
+    }, timeoutMs);
+
+    bridge.on('disconnected', onDisconnected);
+  });
+};
 
 export type HarnessRunState = {
   readonly runId: string;
@@ -92,6 +137,7 @@ export type HarnessRunTestsOptions = Exclude<TestExecutionOptions, 'platform'>;
 export type HarnessSession = {
   readonly config: HarnessConfig;
   readonly context: HarnessContext;
+  onTestRunnerEvent: (listener: (event: TestRunnerEvents) => void) => () => void;
   runTestFile: (path: string, options: HarnessRunTestsOptions) => Promise<TestSuiteResult>;
   ensureAppReady: (testFilePath: string) => Promise<void>;
   restartApp: (testFilePath?: string) => Promise<void>;
@@ -147,13 +193,37 @@ const withPlatformReadyTimeout = async <T>(options: {
 type AppReadyOptions = {
   metroInstance: MetroInstance;
   bridge: HarnessBridge;
-  platformInstance: HarnessPlatformRunner;
   platformId: string;
   bundleStartTimeout: number;
   readyTimeout: number;
   maxAppRestarts: number;
   crashMonitor: CrashMonitor;
-  appLaunchOptions?: AppLaunchOptions;
+  detectNativeCrashes: boolean;
+  restartAppSession: () => Promise<AppSession>;
+};
+
+export const waitForStartupCrash = async ({
+  crashMonitor,
+  detectNativeCrashes,
+  testFilePath,
+  signal,
+}: {
+  crashMonitor: CrashMonitor;
+  detectNativeCrashes: boolean;
+  testFilePath: string;
+  signal: AbortSignal;
+}) => {
+  if (!detectNativeCrashes) {
+    return await waitForAbort(signal);
+  }
+
+  const watch = crashMonitor.watch(testFilePath, 'startup');
+  watch.promise.catch(ignorePromiseRejection); // suppress unhandled-rejection when abort wins race
+  try {
+    return await Promise.race([watch.promise, waitForAbort(signal)]);
+  } finally {
+    watch.cancel();
+  }
 };
 
 const waitForAppReady = async (
@@ -163,13 +233,13 @@ const waitForAppReady = async (
   const {
     metroInstance,
     bridge,
-    platformInstance,
     platformId,
     bundleStartTimeout,
     readyTimeout,
     maxAppRestarts,
     crashMonitor,
-    appLaunchOptions,
+    detectNativeCrashes,
+    restartAppSession,
   } = base;
 
   const logWait = (message: string, ...args: unknown[]) =>
@@ -184,7 +254,7 @@ const waitForAppReady = async (
     signal: new AbortController().signal,
     startAttempt: async () => {
       logWait('launching app for %s', testFilePath);
-      await platformInstance.restartApp(appLaunchOptions);
+      await restartAppSession();
       logWait('launch request completed, waiting for bridge ready');
     },
     waitForReady: async (signal) => {
@@ -195,7 +265,7 @@ const waitForAppReady = async (
       // connection from a previous run would resolve the promise before startAttempt
       // even restarts the app — leaving bridge.connection null after the restart.
       await new Promise<void>((resolve, reject) => {
-        const onConnected = (_conn: AppConnection) => { cleanup(); resolve(); };
+        const onConnected = () => { cleanup(); resolve(); };
         const onAbort = () => { cleanup(); reject(signal.reason ?? new DOMException('Aborted', 'AbortError')); };
         const cleanup = () => {
           bridge.off('connected', onConnected);
@@ -208,14 +278,13 @@ const waitForAppReady = async (
       logWait('runtime ready received');
     },
     waitForCrash: async (signal) => {
-      const watch = crashMonitor.watch(testFilePath, 'startup');
-      watch.promise.catch(ignorePromiseRejection); // suppress unhandled-rejection when abort wins race
-      try {
-        logWait('waiting for crash or runtime ready');
-        return await Promise.race([watch.promise, waitForAbort(signal)]);
-      } finally {
-        watch.cancel();
-      }
+      logWait('waiting for crash or runtime ready');
+      return await waitForStartupCrash({
+        crashMonitor,
+        detectNativeCrashes,
+        testFilePath,
+        signal,
+      });
     },
     onAttemptStart: () => {
       logWait('beginning launch attempt for %s', testFilePath);
@@ -413,6 +482,11 @@ export const createHarnessSession = async (
     const clientLogCollector = createClientLogCollector();
 
     const context: HarnessContext = { platform };
+    const crashArtifactWriter = createCrashArtifactWriter({
+      runnerName: platform.name,
+      platformId: platform.platformId,
+      rootDir: path.join(projectRoot, '.harness', 'crash-reports'),
+    });
 
     const bridge = await createHarnessBridge({
       noServer: true,
@@ -446,6 +520,7 @@ export const createHarnessSession = async (
             return await import(platform.runner).then((module) =>
               module.default(platform.config, runtimeConfig, {
                 signal,
+                crashArtifactWriter,
               } satisfies HarnessPlatformInitOptions),
             ).then((instance) => {
               sessionLogger.debug('platform runner initialized');
@@ -460,27 +535,42 @@ export const createHarnessSession = async (
       throw error;
     }
 
-    const crashArtifactWriter = createCrashArtifactWriter({
-      runnerName: platform.name,
-      platformId: platform.platformId,
-    });
-    const appMonitor = platformInstance.createAppMonitor({ crashArtifactWriter });
     const appLaunchOptions = (platform.config as { appLaunchOptions?: AppLaunchOptions }).appLaunchOptions;
 
-    const crashMonitor = createCrashMonitor({ appMonitor, platformRunner: platformInstance });
+    let currentAppSession: AppSession | null = null;
+    const crashMonitor = createCrashMonitor();
+
+    const disposeCurrentAppSession = async () => {
+      const session = currentAppSession;
+      currentAppSession = null;
+      crashMonitor.setAppSession(null);
+      if (session) {
+        await session.dispose();
+      }
+    };
+
+    const restartAppSession = async (): Promise<AppSession> => {
+      await crashMonitor.stop();
+      await disposeCurrentAppSession();
+      const session = await platformInstance.createAppSession(appLaunchOptions);
+      currentAppSession = session;
+      crashMonitor.setAppSession(session);
+      await crashMonitor.start();
+      return session;
+    };
 
     // Pre-build the options that are constant across all app-ready calls;
     // only testFilePath varies per call.
     const appReadyBaseOptions: AppReadyOptions = {
       metroInstance,
       bridge,
-      platformInstance,
       platformId: platform.platformId,
       bundleStartTimeout: runtimeConfig.bundleStartTimeout ?? 60000,
       readyTimeout: runtimeConfig.bridgeTimeout,
       maxAppRestarts: runtimeConfig.maxAppRestarts ?? 2,
       crashMonitor,
-      appLaunchOptions,
+      detectNativeCrashes: runtimeConfig.detectNativeCrashes !== false,
+      restartAppSession,
     };
 
     // --- Event listeners ---
@@ -497,6 +587,19 @@ export const createHarnessSession = async (
     const flushClientLogs = (): ClientLogBuffer => clientLogCollector.flush();
 
     const clientLogListener = clientLogCollector.handleEvent;
+    const testRunnerEventListeners = new Set<(event: TestRunnerEvents) => void>();
+    const onTestRunnerEvent = (event: BridgeEvents) => {
+      if (
+        event.type === 'test-started' ||
+        event.type === 'test-finished' ||
+        event.type === 'suite-started' ||
+        event.type === 'suite-finished' ||
+        event.type === 'file-started' ||
+        event.type === 'file-finished'
+      ) {
+        testRunnerEventListeners.forEach((listener) => listener(event));
+      }
+    };
 
     const onConnected = (conn: AppConnection) => {
       const runId = getCurrentRunId();
@@ -508,11 +611,15 @@ export const createHarnessSession = async (
       const runId = getCurrentRunId();
       if (!runId) return;
       hooks.schedule(() => pluginManager.callHook('runtime:disconnected', { runId, reason: 'bridge-disconnected' }));
+      if (runtimeConfig.detectNativeCrashes !== false) {
+        crashMonitor.handleBridgeDisconnect();
+      }
     };
 
     bridge.on('connected', onConnected);
     bridge.on('disconnected', onDisconnected);
     bridge.on('event', bridgeEventListener);
+    bridge.on('event', onTestRunnerEvent);
     metroInstance.events.addListener(onMetroEvent);
     if (runtimeConfig.forwardClientLogs) {
       metroInstance.events.addListener(clientLogListener);
@@ -557,11 +664,13 @@ export const createHarnessSession = async (
       bridge.off('connected', onConnected);
       bridge.off('disconnected', onDisconnected);
       bridge.off('event', bridgeEventListener);
+      bridge.off('event', onTestRunnerEvent);
 
       const nativeCoverageConfig = runtimeConfig.coverage?.native?.ios;
       if (nativeCoverageConfig?.pods?.length && platformInstance.collectNativeCoverage) {
         try {
-          await platformInstance.stopApp();
+          await crashMonitor.stop();
+          await disposeCurrentAppSession();
           const lcovPath = await platformInstance.collectNativeCoverage({
             pods: nativeCoverageConfig.pods,
             outputDir: projectRoot,
@@ -578,6 +687,7 @@ export const createHarnessSession = async (
       try {
         await Promise.all([
           crashMonitor.dispose(),
+          disposeCurrentAppSession(),
           bridge.dispose(),
           platformInstance.dispose(),
           metroInstance.dispose(),
@@ -614,8 +724,6 @@ export const createHarnessSession = async (
     try {
       await pluginManager.callHook('harness:before-creation', { appLaunchOptions });
       await hooks.drain();
-      await appMonitor.start();
-      sessionLogger.debug('app monitor started');
       await pluginManager.callHook('harness:before-run', { appLaunchOptions });
       await hooks.drain();
     } catch (error) {
@@ -634,9 +742,12 @@ export const createHarnessSession = async (
       await hooks.drain();
       sessionLogger.debug('ensuring app is ready for %s', testFilePath);
 
-      if (crashMonitor.isAlive() && bridge.connection !== null && await platformInstance.isAppRunning()) {
-        sessionLogger.debug('reusing existing ready app for %s', testFilePath);
-        return;
+      if (crashMonitor.isAlive() && bridge.connection !== null && currentAppSession) {
+        const state = await currentAppSession.getState();
+        if (state.status === 'running') {
+          sessionLogger.debug('reusing existing ready app for %s', testFilePath);
+          return;
+        }
       }
 
       crashMonitor.reset();
@@ -655,17 +766,16 @@ export const createHarnessSession = async (
         testFilePath ? 'stop-and-ensure-ready' : 'direct-restart',
       );
 
-      if (testFilePath) {
-        await platformInstance.stopApp();
-      } else {
-        await platformInstance.restartApp(appLaunchOptions);
-      }
-
-      crashMonitor.reset();
-      await crashMonitor.start();
+      await disposeCurrentAppSession();
 
       if (testFilePath) {
         await ensureAppReady(testFilePath);
+      } else {
+        const session = await platformInstance.createAppSession(appLaunchOptions);
+        currentAppSession = session;
+        crashMonitor.setAppSession(session);
+        crashMonitor.reset();
+        await crashMonitor.start();
       }
 
       await hooks.drain();
@@ -681,7 +791,7 @@ export const createHarnessSession = async (
       if (!conn) throw new Error('No active app connection');
       sessionLogger.debug('running test file on client: %s', testPath);
 
-      if (!runtimeConfig.detectNativeCrashes) {
+      if (runtimeConfig.detectNativeCrashes === false) {
         const result = await conn.runTests(testPath, { ...options, runner: platform.runner });
         await hooks.drain();
         return result;
@@ -692,12 +802,31 @@ export const createHarnessSession = async (
       // crash wins the race or cancel() is called after the test run wins.
       crashWatch.promise.catch(ignorePromiseRejection);
       try {
-        const result = await Promise.race([
-          conn.runTests(testPath, { ...options, runner: platform.runner }),
-          crashWatch.promise,
-        ]);
+        const testRunPromise = conn.runTests(testPath, {
+          ...options,
+          runner: platform.runner,
+        });
+        const result = await Promise.race([testRunPromise, crashWatch.promise]);
+        const bridgeDisconnected = await waitForBridgeDisconnectOrTimeout({
+          bridge,
+          connection: conn,
+          timeoutMs: TEST_RUN_BRIDGE_STABILITY_WAIT_MS,
+        });
+
+        if (bridgeDisconnected) {
+          return await crashWatch.promise;
+        }
+
         await hooks.drain();
         return result;
+      } catch (error) {
+        if (isBridgeDisconnectError(error)) {
+          const result = await crashWatch.promise;
+          await hooks.drain();
+          return result;
+        }
+
+        throw error;
       } finally {
         crashWatch.cancel();
       }
@@ -706,6 +835,12 @@ export const createHarnessSession = async (
     return {
       config: runtimeConfig,
       context,
+      onTestRunnerEvent: (listener) => {
+        testRunnerEventListeners.add(listener);
+        return () => {
+          testRunnerEventListeners.delete(listener);
+        };
+      },
       runTestFile,
       ensureAppReady,
       restartApp,

package/src/index.ts

@@ -1,10 +1,8 @@
 import type {
-  CallbackTestRunnerInterface,
   Config,
-  OnTestFailure,
-  OnTestStart,
-  OnTestSuccess,
+  EmittingTestRunnerInterface,
   Test,
+  TestEvents,
   TestRunnerOptions,
   TestWatcher,
 } from 'jest-runner';
@@ -13,22 +11,41 @@ import { executeRun } from './execute-run.js';
 import { HarnessError } from '@react-native-harness/tools';
 import { getErrorMessage } from './logs.js';
 
-export default class JestHarness implements CallbackTestRunnerInterface {
+type TestEventListener<Name extends keyof TestEvents> = (
+  eventData: TestEvents[Name],
+) => void | Promise<void>;
+
+export default class JestHarness implements EmittingTestRunnerInterface {
   readonly isSerial = true;
+  readonly supportsEventEmitters = true as const;
 
   #globalConfig: Config.GlobalConfig;
   #session: HarnessSession | null = null;
+  #listeners = new Map<keyof TestEvents, Set<TestEventListener<keyof TestEvents>>>();
 
   constructor(globalConfig: Config.GlobalConfig) {
     this.#globalConfig = globalConfig;
   }
 
+  on<Name extends keyof TestEvents>(
+    eventName: Name,
+    listener: TestEventListener<Name>,
+  ): () => void {
+    const listeners = this.#listeners.get(eventName) ?? new Set();
+    listeners.add(listener as TestEventListener<keyof TestEvents>);
+    this.#listeners.set(eventName, listeners);
+
+    return () => {
+      listeners.delete(listener as TestEventListener<keyof TestEvents>);
+      if (listeners.size === 0) {
+        this.#listeners.delete(eventName);
+      }
+    };
+  }
+
   async runTests(
     tests: Array<Test>,
     watcher: TestWatcher,
-    onStart: OnTestStart,
-    onResult: OnTestSuccess,
-    onFailure: OnTestFailure,
     options: TestRunnerOptions,
   ): Promise<void> {
     if (!options.serial) {
@@ -46,9 +63,7 @@ export default class JestHarness implements CallbackTestRunnerInterface {
         this.#session,
         tests,
         watcher,
-        onStart,
-        onResult,
-        onFailure,
+        this.#emit,
         this.#globalConfig,
       );
     } catch (error) {
@@ -63,4 +78,18 @@ export default class JestHarness implements CallbackTestRunnerInterface {
       }
     }
   }
+
+  #emit = async <Name extends keyof TestEvents>(
+    eventName: Name,
+    ...eventData: TestEvents[Name]
+  ): Promise<void> => {
+    const listeners = this.#listeners.get(eventName);
+    if (!listeners) {
+      return;
+    }
+
+    for (const listener of listeners) {
+      await listener(eventData);
+    }
+  };
 }

package/src/run.ts

@@ -111,6 +111,7 @@ export const runHarnessTestFile: RunHarnessTestFile = async ({
         ? `${errorMessage}${codeFrame ? `\n\n${codeFrame.content}` : ''}`
         : undefined,
       title: test.name,
+      fullName: test.fullName,
       status: test.status,
       location: codeFrame?.location
         ? { column: codeFrame.location.column, line: codeFrame.location.row }

package/src/test-file-platform-filter.ts

@@ -0,0 +1,57 @@
+import path from 'node:path';
+import type { TestResult as JestTestResult } from '@jest/test-result';
+import { toTestResult } from './toTestResult.js';
+
+const PLATFORM_SPECIFIC_HARNESS_FILE =
+  /\.([^.]+)\.harness\.(?:[mc]?[jt]sx?)$/;
+
+export const getHarnessTestFilePlatform = (
+  testPath: string,
+  knownPlatformIds: ReadonlySet<string>,
+): string | null => {
+  const match = path.basename(testPath).match(PLATFORM_SPECIFIC_HARNESS_FILE);
+  if (!match) {
+    return null;
+  }
+
+  const candidate = match[1];
+  return knownPlatformIds.has(candidate) ? candidate : null;
+};
+
+export const shouldRunHarnessTestFile = (
+  testPath: string,
+  platformId: string,
+  knownPlatformIds: ReadonlySet<string>,
+): boolean => {
+  const filePlatform = getHarnessTestFilePlatform(testPath, knownPlatformIds);
+  return filePlatform == null || filePlatform === platformId;
+};
+
+export const createPlatformSkippedTestResult = (
+  testPath: string,
+): JestTestResult => {
+  const now = Date.now();
+  const title = path.basename(testPath);
+
+  return toTestResult({
+    stats: {
+      failures: 0,
+      passes: 0,
+      pending: 1,
+      todo: 0,
+      start: now,
+      end: now,
+    },
+    skipped: true,
+    errorMessage: null,
+    tests: [
+      {
+        status: 'skipped',
+        title,
+        fullName: title,
+        testPath,
+      },
+    ],
+    jestTestPath: testPath,
+  });
+};

package/src/toTestResult.ts

@@ -16,6 +16,7 @@ export type Options = {
     errorMessage?: string;
     testPath?: string;
     title?: string;
+    fullName?: string;
     status: Status;
     location?: {
       column: number;
@@ -72,8 +73,8 @@ const getTestResults = ({
       duration: test.duration,
       failureDetails: [],
       failureMessages: actualErrorMessage ? [actualErrorMessage] : [],
-      fullName: jestTestPath || test.testPath || '',
-      numPassingAsserts: test.errorMessage ? 1 : 0,
+      fullName: test.fullName || test.testPath || jestTestPath || '',
+      numPassingAsserts: test.status === 'passed' ? 1 : 0,
       status: test.status,
       title: test.title || '',
       location: test.location,