@react-native-harness/jest 1.1.0 → 1.2.0

package/src/hook-queue.ts

@@ -0,0 +1,26 @@
+export type HookQueue = {
+  schedule: (work: () => Promise<void>) => void;
+  drain: () => Promise<void>;
+};
+
+export const createHookQueue = (): HookQueue => {
+  let tail: Promise<void> = Promise.resolve();
+  let firstError: unknown;
+
+  const schedule = (work: () => Promise<void>): void => {
+    tail = tail.then(work).catch((err) => {
+      firstError ??= err;
+    });
+  };
+
+  const drain = async (): Promise<void> => {
+    await tail;
+    if (firstError !== undefined) {
+      const err = firstError;
+      firstError = undefined;
+      throw err;
+    }
+  };
+
+  return { schedule, drain };
+};

package/src/index.ts

@@ -8,55 +8,16 @@ import type {
   TestRunnerOptions,
   TestWatcher,
 } from 'jest-runner';
-import pLimit from 'p-limit';
-import { runHarnessTestFile } from './run.js';
-import { Config as HarnessConfig } from '@react-native-harness/config';
-import { type Harness, type HarnessRunState } from './harness.js';
-import { setup } from './setup.js';
-import { teardown } from './teardown.js';
+import { createHarnessSession, type HarnessSession } from './harness-session.js';
+import { executeRun } from './execute-run.js';
 import { HarnessError } from '@react-native-harness/tools';
 import { getErrorMessage } from './logs.js';
-import { DeviceNotRespondingError } from '@react-native-harness/bridge/server';
-import { NativeCrashError, StartupStallError } from './errors.js';
-import { logger } from '@react-native-harness/tools';
-import { randomUUID } from 'node:crypto';
-import path from 'node:path';
-
-const runLogger = logger.child('run');
-
-const createRunSummary = () => ({
-  passed: 0,
-  failed: 0,
-  skipped: 0,
-  todo: 0,
-});
-
-const applyJestResultToSummary = (
-  summary: ReturnType<typeof createRunSummary>,
-  result: {
-    numPassingTests: number;
-    numFailingTests: number;
-    numPendingTests: number;
-    numTodoTests: number;
-  }
-) => {
-  summary.passed += result.numPassingTests;
-  summary.failed += result.numFailingTests;
-  summary.skipped += result.numPendingTests;
-  summary.todo += result.numTodoTests;
-};
-
-class CancelRun extends Error {
-  constructor(message?: string) {
-    super(message);
-    this.name = 'CancelRun';
-  }
-}
 
 export default class JestHarness implements CallbackTestRunnerInterface {
   readonly isSerial = true;
 
   #globalConfig: Config.GlobalConfig;
+  #session: HarnessSession | null = null;
 
   constructor(globalConfig: Config.GlobalConfig) {
     this.#globalConfig = globalConfig;
@@ -68,312 +29,38 @@ export default class JestHarness implements CallbackTestRunnerInterface {
     onStart: OnTestStart,
     onResult: OnTestSuccess,
     onFailure: OnTestFailure,
-    options: TestRunnerOptions
+    options: TestRunnerOptions,
   ): Promise<void> {
     if (!options.serial) {
       throw new Error('Parallel test running is not supported');
     }
 
-    try {
-      // This is necessary as Harness may throw and we want to catch it and display a helpful error message.
-      await setup(this.#globalConfig);
+    const isWatchMode = this.#globalConfig.watch || this.#globalConfig.watchAll;
 
-      const harness = global.HARNESS;
-      const harnessConfig = global.HARNESS_CONFIG;
+    try {
+      if (!this.#session) {
+        this.#session = await createHarnessSession(this.#globalConfig);
+      }
 
-      return await this._createInBandTestRun(
+      await executeRun(
+        this.#session,
         tests,
         watcher,
-        harness,
-        harnessConfig,
         onStart,
         onResult,
-        onFailure
+        onFailure,
+        this.#globalConfig,
       );
     } catch (error) {
       if (error instanceof HarnessError) {
-        // Jest will print strings as they are, without processing them further.
         throw getErrorMessage(error);
       }
-
       throw error;
     } finally {
-      // This is necessary as Harness may throw and we want to catch it and display a helpful error message.
-      await teardown(this.#globalConfig);
-    }
-  }
-
-  async _createInBandTestRun(
-    tests: Array<Test>,
-    watcher: TestWatcher,
-    harness: Harness,
-    harnessConfig: HarnessConfig,
-    onStart: OnTestStart,
-    onResult: OnTestSuccess,
-    onFailure: OnTestFailure
-  ): Promise<void> {
-    const mutex = pLimit(1);
-    let isFirstTest = true;
-    const startTime = Date.now();
-    const runId = randomUUID();
-    const watchMode = this.#globalConfig.watch || this.#globalConfig.watchAll;
-    const rootDir = this.#globalConfig.rootDir ?? process.cwd();
-    const testFiles = tests.map((test) =>
-      path.relative(rootDir, test.path)
-    );
-    const summary = createRunSummary();
-    const updateRunState = (overrides: Partial<HarnessRunState> = {}) => {
-      const nextRunState: HarnessRunState = {
-        runId,
-        startTime,
-        testFiles,
-        watchMode,
-        coverageEnabled: this.#globalConfig.collectCoverage,
-        summary,
-        status: summary.failed > 0 ? 'failed' : 'passed',
-        ...overrides,
-      };
-
-      harness.setRunState(nextRunState);
-      return nextRunState;
-    };
-
-    updateRunState();
-    runLogger.debug(
-      'run started: runId=%s files=%d watchMode=%s coverage=%s',
-      runId,
-      testFiles.length,
-      watchMode,
-      this.#globalConfig.collectCoverage
-    );
-    await harness.callHook('run:started', {
-      runId,
-      startTime,
-      testFiles,
-      watchMode,
-      coverageEnabled: this.#globalConfig.collectCoverage,
-    });
-    await harness.callHook('metro:initialized', {
-      runId,
-      port: harnessConfig.metroPort,
-      host: harnessConfig.host?.trim() || undefined,
-    });
-
-    try {
-      await tests.reduce(
-        (promise, test) =>
-          mutex(() => {
-            let didApplySummary = false;
-
-            return promise
-              .then(async () => {
-                const relativeTestPath = path.relative(
-                  rootDir,
-                  test.path
-                );
-                const testFileStartedAt = Date.now();
-                let didEmitTestFileFinished = false;
-
-                await harness.callHook('test-file:started', {
-                  runId,
-                  file: relativeTestPath,
-                });
-                runLogger.debug('test file started: %s', relativeTestPath);
-
-                const emitTestFileFinished = async (options: {
-                  status: 'passed' | 'failed' | 'skipped' | 'todo';
-                  duration: number;
-                  result: Awaited<ReturnType<typeof runHarnessTestFile>>['harnessResult'] | null;
-                }) => {
-                  didEmitTestFileFinished = true;
-                  runLogger.debug(
-                    'test file finished: %s status=%s duration=%dms',
-                    relativeTestPath,
-                    options.status,
-                    options.duration
-                  );
-                  await harness.callHook('test-file:finished', {
-                    runId,
-                    file: relativeTestPath,
-                    duration: options.duration,
-                    status: options.status,
-                    result: options.result,
-                  });
-                };
-
-                try {
-                  if (watcher.isInterrupted()) {
-                    throw new CancelRun();
-                  }
-
-                  if (
-                    harnessConfig.resetEnvironmentBetweenTestFiles &&
-                    !isFirstTest
-                  ) {
-                    runLogger.debug(
-                      'resetting environment before %s',
-                      relativeTestPath
-                    );
-                    await harness.restart(test.path);
-                  }
-                  isFirstTest = false;
-
-                  const result = await onStart(test).then(async () => {
-                    if (!harnessConfig.detectNativeCrashes) {
-                      runLogger.debug(
-                        'native crash detection disabled for %s',
-                        relativeTestPath
-                      );
-                      await harness.ensureAppReady(test.path);
-                      return runHarnessTestFile({
-                        testPath: test.path,
-                        harness,
-                        globalConfig: this.#globalConfig,
-                        projectConfig: test.context.config,
-                      });
-                    }
-
-                    await harness.ensureAppReady(test.path);
-                    harness.crashSupervisor.beginTestRun(test.path);
-                    runLogger.debug(
-                      'native crash detection armed for %s',
-                      relativeTestPath
-                    );
-                    const crashPromise =
-                      harness.crashSupervisor.waitForCrash(test.path);
-
-                    try {
-                      return await Promise.race([
-                        runHarnessTestFile({
-                          testPath: test.path,
-                          harness,
-                          globalConfig: this.#globalConfig,
-                          projectConfig: test.context.config,
-                        }),
-                        crashPromise,
-                      ]);
-                    } finally {
-                      harness.crashSupervisor.cancelCrashWaiters();
-                    }
-                  });
-
-                  applyJestResultToSummary(summary, result.jestResult);
-                  didApplySummary = true;
-                  updateRunState();
-                  await emitTestFileFinished({
-                    status: result.harnessResult.status,
-                    duration: result.duration,
-                    result: result.harnessResult,
-                  });
-
-                  return result;
-                } catch (error) {
-                  if (!didEmitTestFileFinished) {
-                    await emitTestFileFinished({
-                      status: 'failed',
-                      duration: Date.now() - testFileStartedAt,
-                      result: null,
-                    });
-                  }
-
-                  throw error;
-                }
-              })
-              .then(async (result) => {
-                if (!result) {
-                  return;
-                }
-
-                await onResult(test, result.jestResult);
-              })
-              .catch(async (err) => {
-                if (
-                  err instanceof NativeCrashError ||
-                  err instanceof StartupStallError ||
-                  err instanceof DeviceNotRespondingError
-                ) {
-                  runLogger.debug(
-                    'classified runtime failure for %s: %s',
-                    test.path,
-                    err.name
-                  );
-                  summary.failed += 1;
-                  updateRunState();
-                }
-
-                if (err instanceof NativeCrashError) {
-                  harness.crashSupervisor.reset();
-                  onFailure(test, {
-                    message: err.message,
-                    stack: '',
-                  });
-
-                  return;
-                }
-
-                if (err instanceof StartupStallError) {
-                  onFailure(test, {
-                    message: err.message,
-                    stack: '',
-                  });
-
-                  return;
-                }
-
-                if (err instanceof DeviceNotRespondingError) {
-                  onFailure(test, {
-                    message: err.message,
-                    stack: '',
-                  });
-
-                  return;
-                }
-
-                if (!(err instanceof CancelRun) && !didApplySummary) {
-                  summary.failed += 1;
-                }
-                updateRunState({ error: err });
-                onFailure(test, err);
-              });
-          }),
-        Promise.resolve()
-      );
-
-      const runState = updateRunState();
-      runLogger.debug(
-        'run finished: runId=%s status=%s duration=%dms',
-        runId,
-        runState.status ?? 'passed',
-        Date.now() - startTime
-      );
-      await harness.callHook('run:finished', {
-        runId,
-        startTime,
-        duration: Date.now() - startTime,
-        testFiles,
-        summary,
-        status: runState.status ?? 'passed',
-      });
-    } catch (error) {
-      const runState = updateRunState({
-        error,
-        status: 'failed',
-      });
-      runLogger.debug(
-        'run failed: runId=%s status=%s',
-        runId,
-        runState.status ?? 'failed'
-      );
-      await harness.callHook('run:finished', {
-        runId,
-        startTime,
-        duration: Date.now() - startTime,
-        testFiles,
-        summary,
-        status: runState.status ?? 'failed',
-        error,
-      });
-      throw error;
+      if (!isWatchMode) {
+        await this.#session?.dispose();
+        this.#session = null;
+      }
     }
   }
 }

package/src/logs.ts

@@ -56,6 +56,10 @@ export const logMetroPortFallback = (
   );
 };
 
+export const logNativeCoverageCollected = (lcovPath: string): void => {
+  log(`${TAG} Native coverage written to ${chalk.bold(lcovPath)}\n`);
+};
+
 export const getErrorMessage = (error: HarnessError): string => {
   return `${ERROR_TAG} ${error.message}\n`;
 };

package/src/resource-lock.ts

@@ -60,7 +60,7 @@ const wait = async (ms: number): Promise<void> => {
 const createAbortError = () =>
   new DOMException('The operation was aborted', 'AbortError');
 
-export const hashResourceLockKey = (key: string): string => {
+const hashResourceLockKey = (key: string): string => {
   return crypto.createHash('sha256').update(key).digest('hex');
 };
 

package/src/run.ts

@@ -5,7 +5,7 @@ import type {
   TestSuiteResult as HarnessTestSuiteResult,
   TestResult as HarnessTestResult,
 } from '@react-native-harness/bridge';
-import type { Harness } from './harness.js';
+import type { HarnessSession } from './harness-session.js';
 import { formatResultsErrors } from 'jest-message-util';
 import { toTestResult } from './toTestResult.js';
 
@@ -62,7 +62,7 @@ const calculateStats = (tests: HarnessTestResult[]) => {
 
 export type RunHarnessTestFile = (options: {
   testPath: string;
-  harness: Harness;
+  session: HarnessSession;
   projectConfig: JestConfig.ProjectConfig;
   globalConfig: JestConfig.GlobalConfig;
 }) => Promise<{
@@ -76,7 +76,7 @@ export const runHarnessTestFile: RunHarnessTestFile = async ({
   testPath,
   globalConfig,
   projectConfig,
-  harness,
+  session,
 }) => {
   const start = Date.now();
   const relativeTestPath = path.relative(globalConfig.rootDir, testPath);
@@ -89,11 +89,11 @@ export const runHarnessTestFile: RunHarnessTestFile = async ({
     (setupFile) => path.relative(globalConfig.rootDir, setupFile)
   );
 
-  const harnessResult = await harness.runTests(relativeTestPath, {
+  const harnessResult = await session.runTestFile(relativeTestPath, {
     testNamePattern: globalConfig.testNamePattern,
     setupFiles,
     setupFilesAfterEnv,
-    runner: harness.context.platform.runner,
+    runner: session.context.platform.runner,
   });
   const end = Date.now();
 

package/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"fileNames":[],"fileInfos":[],"root":[],"options":{"composite":true,"declarationMap":true,"emitDeclarationOnly":true,"importHelpers":true,"module":199,"noEmitOnError":true,"noFallthroughCasesInSwitch":true,"noImplicitOverride":true,"noImplicitReturns":true,"noUnusedLocals":true,"skipLibCheck":true,"strict":true,"target":9},"version":"5.9.3"}

package/src/__tests__/crash-supervisor.test.ts

@@ -1,200 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import {
-  type AppMonitor,
-  type AppCrashDetails,
-  type AppMonitorEvent,
-  type AppMonitorListener,
-  type HarnessPlatformRunner,
-} from '@react-native-harness/platforms';
-import { createCrashSupervisor } from '../crash-supervisor.js';
-
-type MockCrashDetailsGetter = (
-  options: {
-    processName?: string;
-    pid?: number;
-    occurredAt: number;
-  }
-) => Promise<AppCrashDetails | null>;
-
-const createMockAppMonitor = (options?: {
-  getCrashDetails?: MockCrashDetailsGetter;
-}) => {
-  const listeners = new Set<AppMonitorListener>();
-  const noop = async () => undefined;
-
-  const appMonitor: AppMonitor & {
-    getCrashDetails?: MockCrashDetailsGetter;
-  } = {
-    start: noop,
-    stop: noop,
-    dispose: noop,
-    addListener: (listener) => {
-      listeners.add(listener);
-    },
-    removeListener: (listener) => {
-      listeners.delete(listener);
-    },
-  };
-
-  if (options?.getCrashDetails) {
-    appMonitor.getCrashDetails = options.getCrashDetails;
-  }
-
-  const emit = (event: AppMonitorEvent) => {
-    for (const listener of listeners) {
-      listener(event);
-    }
-  };
-
-  return {
-    appMonitor,
-    emit,
-  };
-};
-
-const createPlatformRunner = ({
-  isAppRunning,
-  getCrashDetails,
-}: {
-  isAppRunning: () => Promise<boolean>;
-  getCrashDetails?: HarnessPlatformRunner['getCrashDetails'];
-}): HarnessPlatformRunner => ({
-  startApp: async () => undefined,
-  restartApp: async () => undefined,
-  stopApp: async () => undefined,
-  dispose: async () => undefined,
-  isAppRunning,
-  createAppMonitor: () => {
-    throw new Error('Not used in unit tests');
-  },
-  getCrashDetails,
-});
-
-describe('crash-supervisor', () => {
-  it('rejects the active test when the app exits during launch', async () => {
-    const monitor = createMockAppMonitor();
-    const supervisor = createCrashSupervisor({
-      appMonitor: monitor.appMonitor,
-      platformRunner: createPlatformRunner({
-        isAppRunning: vi.fn().mockResolvedValue(false),
-      }),
-    });
-
-    supervisor.beginLaunch('/tmp/startup.harness.ts');
-
-    const crashPromise = supervisor.waitForCrash('/tmp/startup.harness.ts');
-    const expectation =
-      expect(crashPromise).rejects.toMatchObject({
-        name: 'NativeCrashError',
-        phase: 'startup',
-        details: {
-          signal: 'SIGSEGV',
-          processName: 'com.harnessplayground',
-        },
-      });
-    monitor.emit({
-      type: 'app_exited',
-      source: 'logs',
-      crashDetails: {
-        source: 'logs',
-        signal: 'SIGSEGV',
-        processName: 'com.harnessplayground',
-        rawLines: ['Fatal signal 11 (SIGSEGV)'],
-      },
-    });
-
-    await expectation;
-    await supervisor.dispose();
-  });
-
-  it('treats polling exit events as immediately confirmed crashes', async () => {
-    const monitor = createMockAppMonitor();
-    const isAppRunning = vi.fn().mockResolvedValue(true);
-    const supervisor = createCrashSupervisor({
-      appMonitor: monitor.appMonitor,
-      platformRunner: createPlatformRunner({
-        isAppRunning,
-      }),
-    });
-
-    supervisor.beginLaunch('/tmp/polling-exit.harness.ts');
-
-    const crashPromise = supervisor.waitForCrash('/tmp/polling-exit.harness.ts');
-    monitor.emit({ type: 'app_exited', source: 'polling' });
-
-    await expect(crashPromise).rejects.toMatchObject({
-      name: 'NativeCrashError',
-      phase: 'startup',
-    });
-    expect(isAppRunning).not.toHaveBeenCalled();
-    await supervisor.dispose();
-  });
-
-  it('does not reject when monitoring is stopped', async () => {
-    const monitor = createMockAppMonitor();
-    const supervisor = createCrashSupervisor({
-      appMonitor: monitor.appMonitor,
-      platformRunner: createPlatformRunner({
-        isAppRunning: vi.fn().mockResolvedValue(false),
-      }),
-    });
-
-    supervisor.beginTestRun('/tmp/restart.harness.ts');
-    await supervisor.stop();
-
-    const reject = vi.fn();
-    void supervisor.waitForCrash('/tmp/restart.harness.ts').catch(reject);
-
-    monitor.emit({ type: 'app_exited', source: 'polling' });
-    await Promise.resolve();
-
-    expect(reject).not.toHaveBeenCalled();
-    await supervisor.dispose();
-  });
-
-  it('prefers crash details from the started app monitor over the runner', async () => {
-    const monitorGetCrashDetails = vi.fn().mockResolvedValue({
-      source: 'logs',
-      summary: 'full crash block',
-      rawLines: ['full crash block'],
-    });
-    const runnerGetCrashDetails = vi.fn().mockResolvedValue({
-      source: 'logs',
-      summary: 'runner details',
-      rawLines: ['runner details'],
-    });
-    const monitor = createMockAppMonitor({
-      getCrashDetails: monitorGetCrashDetails,
-    });
-    const supervisor = createCrashSupervisor({
-      appMonitor: monitor.appMonitor,
-      platformRunner: createPlatformRunner({
-        isAppRunning: vi.fn().mockResolvedValue(false),
-        getCrashDetails: runnerGetCrashDetails,
-      }),
-    });
-
-    supervisor.beginTestRun('/tmp/monitor-details.harness.ts');
-
-    const crashPromise = supervisor.waitForCrash('/tmp/monitor-details.harness.ts');
-    monitor.emit({
-      type: 'possible_crash',
-      source: 'logs',
-      crashDetails: {
-        source: 'logs',
-        processName: 'com.harnessplayground',
-        pid: 1234,
-        rawLines: ['partial line'],
-      },
-    });
-
-    await expect(crashPromise).rejects.toMatchObject({
-      details: {
-        summary: 'full crash block',
-      },
-    });
-    expect(monitorGetCrashDetails).toHaveBeenCalled();
-    expect(runnerGetCrashDetails).not.toHaveBeenCalled();
-    await supervisor.dispose();
-  });
-});