@react-native-harness/jest 1.0.0 → 1.1.0-rc.2

package/src/index.ts

@@ -11,13 +11,40 @@ import type {
 import pLimit from 'p-limit';
 import { runHarnessTestFile } from './run.js';
 import { Config as HarnessConfig } from '@react-native-harness/config';
-import { type Harness } from './harness.js';
+import { type Harness, type HarnessRunState } from './harness.js';
 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/server';
-import { NativeCrashError } from './errors.js';
+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) {
@@ -87,83 +114,266 @@ export default class JestHarness implements CallbackTestRunnerInterface {
   ): 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,
+      };
 
-    return tests.reduce(
-      (promise, test) =>
-        mutex(() =>
-          promise
-            .then(async () => {
-              if (watcher.isInterrupted()) {
-                throw new CancelRun();
-              }
-
-              if (
-                harnessConfig.resetEnvironmentBetweenTestFiles &&
-                !isFirstTest
-              ) {
-                await harness.restart();
-              }
-              isFirstTest = false;
-
-              return onStart(test).then(async () => {
-                if (!harnessConfig.detectNativeCrashes) {
-                  return runHarnessTestFile({
-                    testPath: test.path,
-                    harness,
-                    globalConfig: this.#globalConfig,
-                    projectConfig: test.context.config,
-                  });
-                }
+      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,
+    });
 
-                // Start crash monitoring
-                const crashPromise = harness.crashMonitor.startMonitoring(
+    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 {
-                  const result = await Promise.race([
-                    runHarnessTestFile({
-                      testPath: test.path,
-                      harness,
-                      globalConfig: this.#globalConfig,
-                      projectConfig: test.context.config,
-                    }),
-                    crashPromise,
-                  ]);
+                  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;
-                } finally {
-                  harness.crashMonitor.stopMonitoring();
+                } catch (error) {
+                  if (!didEmitTestFileFinished) {
+                    await emitTestFileFinished({
+                      status: 'failed',
+                      duration: Date.now() - testFileStartedAt,
+                      result: null,
+                    });
+                  }
+
+                  throw error;
+                }
+              })
+              .then(async (result) => {
+                if (!result) {
+                  return;
                 }
-              });
-            })
-            .then((result) => onResult(test, result))
-            .catch(async (err) => {
-              if (err instanceof NativeCrashError) {
-                onFailure(test, {
-                  message: err.message,
-                  stack: '',
-                });
 
-                // Restart the app for the next test file
-                await harness.restart();
+                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();
+                }
 
-                return;
-              }
+                if (err instanceof NativeCrashError) {
+                  harness.crashSupervisor.reset();
+                  onFailure(test, {
+                    message: err.message,
+                    stack: '',
+                  });
 
-              if (err instanceof DeviceNotRespondingError) {
-                onFailure(test, {
-                  message: err.message,
-                  stack: '',
-                });
+                  return;
+                }
 
-                return;
-              }
+                if (err instanceof StartupStallError) {
+                  onFailure(test, {
+                    message: err.message,
+                    stack: '',
+                  });
 
-              onFailure(test, err);
-            })
-        ),
-      Promise.resolve()
-    );
+                  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;
+    }
   }
 }

package/src/logs.ts

@@ -31,6 +31,10 @@ export const logMetroPrewarmCompleted = (runner: HarnessPlatform): void => {
   );
 };
 
+export const logMetroCacheReused = (runner: HarnessPlatform): void => {
+  log(`${TAG} Reusing Metro cache for ${chalk.bold(runner.name)}\n`);
+};
+
 export const getErrorMessage = (error: HarnessError): string => {
   return `${ERROR_TAG} ${error.message}\n`;
 };

package/src/run.ts

@@ -65,7 +65,12 @@ export type RunHarnessTestFile = (options: {
   harness: Harness;
   projectConfig: JestConfig.ProjectConfig;
   globalConfig: JestConfig.GlobalConfig;
-}) => Promise<JestTestResult>;
+}) => Promise<{
+  jestResult: JestTestResult;
+  harnessResult: HarnessTestSuiteResult;
+  relativeTestPath: string;
+  duration: number;
+}>;
 
 export const runHarnessTestFile: RunHarnessTestFile = async ({
   testPath,
@@ -84,7 +89,7 @@ export const runHarnessTestFile: RunHarnessTestFile = async ({
     (setupFile) => path.relative(globalConfig.rootDir, setupFile)
   );
 
-  const results = await harness.runTests(relativeTestPath, {
+  const harnessResult = await harness.runTests(relativeTestPath, {
     testNamePattern: globalConfig.testNamePattern,
     setupFiles,
     setupFilesAfterEnv,
@@ -92,7 +97,7 @@ export const runHarnessTestFile: RunHarnessTestFile = async ({
   });
   const end = Date.now();
 
-  const allTests = flattenTests(results);
+  const allTests = flattenTests(harnessResult);
   const stats = calculateStats(allTests);
 
   // Convert TestResult[] to the format expected by toTestResult
@@ -115,12 +120,12 @@ export const runHarnessTestFile: RunHarnessTestFile = async ({
   });
 
   // Check if the entire suite was skipped
-  const skipped = results.status === 'skipped';
+  const skipped = harnessResult.status === 'skipped';
 
   // Get error message from suite if it failed
-  const errorMessage = results.error?.message || null;
+  const errorMessage = harnessResult.error?.message || null;
 
-  const totalResults = toTestResult({
+  const jestResult = toTestResult({
     stats: {
       failures: stats.failures,
       pending: stats.pending,
@@ -133,15 +138,20 @@ export const runHarnessTestFile: RunHarnessTestFile = async ({
     errorMessage,
     tests,
     jestTestPath: testPath,
-    coverage: results.coverage as JestTestResult['coverage'],
+    coverage: harnessResult.coverage as JestTestResult['coverage'],
   });
 
-  totalResults.failureMessage = formatResultsErrors(
-    totalResults.testResults,
+  jestResult.failureMessage = formatResultsErrors(
+    jestResult.testResults,
     projectConfig,
     globalConfig,
     testPath
   );
 
-  return totalResults;
+  return {
+    jestResult,
+    harnessResult,
+    relativeTestPath,
+    duration: end - start,
+  };
 };

package/src/setup.ts

@@ -1,6 +1,7 @@
 import {
   getConfig,
   type Config as HarnessConfig,
+  ConfigSchema,
 } from '@react-native-harness/config';
 import type { Config as JestConfig } from 'jest-runner';
 import { getHarness } from './harness.js';
@@ -9,12 +10,17 @@ import { getAdditionalCliArgs, HarnessCliArgs } from './cli-args.js';
 import { logTestEnvironmentReady, logTestRunHeader } from './logs.js';
 import { NoRunnerSpecifiedError, RunnerNotFoundError } from './errors.js';
 import { HarnessPlatform } from '@react-native-harness/platforms';
+import { logger } from '@react-native-harness/tools';
+
+const setupLogger = logger.child('setup');
 
 const getHarnessConfig = async (
   globalConfig: JestConfig.GlobalConfig
 ): Promise<HarnessConfig> => {
   const projectRoot = globalConfig.rootDir;
+  setupLogger.debug('loading Harness config from %s', projectRoot);
   const { config: harnessConfig } = await getConfig(projectRoot);
+  setupLogger.debug('loaded Harness config');
   return harnessConfig;
 };
 
@@ -36,23 +42,19 @@ const getHarnessRunner = (
     throw new RunnerNotFoundError(selectedRunnerName);
   }
 
+  setupLogger.debug('selected runner %s (%s)', runner.name, runner.platformId);
   return runner;
 };
 
 export const setup = async (globalConfig: JestConfig.GlobalConfig) => {
   preRunMessage.remove(process.stderr);
-  const harnessConfig =
+  let harnessConfig =
     global.HARNESS_CONFIG ?? (await getHarnessConfig(globalConfig));
 
   if (global.HARNESS) {
     // Do not setup again if HARNESS is already initialized
     // This is useful when running tests in watch mode
 
-    if (harnessConfig.resetEnvironmentBetweenTestFiles) {
-      // In watch mode, we want to restart the environment before each test run
-      await global.HARNESS.restart();
-    }
-
     return;
   }
 
@@ -62,6 +64,15 @@ export const setup = async (globalConfig: JestConfig.GlobalConfig) => {
   });
 
   const cliArgs = getAdditionalCliArgs();
+
+  if (cliArgs.metroPort != null) {
+    setupLogger.debug('applying CLI metro port override: %d', cliArgs.metroPort);
+    harnessConfig = ConfigSchema.parse({
+      ...harnessConfig,
+      metroPort: cliArgs.metroPort,
+    });
+  }
+
   const selectedRunner = getHarnessRunner(harnessConfig, cliArgs);
 
   if (globalConfig.collectCoverage) {
@@ -72,19 +83,24 @@ export const setup = async (globalConfig: JestConfig.GlobalConfig) => {
     if (harnessConfig.coverage?.root) {
       process.env.RN_HARNESS_COVERAGE_ROOT = harnessConfig.coverage.root;
     }
+
+    setupLogger.debug('coverage enabled for this run');
   }
 
   if (harnessConfig.disableViewFlattening) {
     process.env.RN_HARNESS_VIEW_FLATTENING = 'false';
+    setupLogger.debug('view flattening disabled for runtime');
   }
 
   logTestRunHeader(selectedRunner);
+  setupLogger.debug('creating Harness instance');
   const harness = await getHarness(
     harnessConfig,
     selectedRunner,
     globalConfig.rootDir
   );
   logTestEnvironmentReady(selectedRunner);
+  setupLogger.debug('Harness instance is ready');
 
   global.HARNESS_CONFIG = harnessConfig;
   global.HARNESS = harness;

package/tsconfig.json

@@ -3,15 +3,15 @@
   "files": [],
   "include": [],
   "references": [
-    {
-      "path": "../cli"
-    },
     {
       "path": "../tools"
     },
     {
       "path": "../platforms"
     },
+    {
+      "path": "../plugins"
+    },
     {
       "path": "../config"
     },

package/tsconfig.lib.json

@@ -8,24 +8,24 @@
     "emitDeclarationOnly": false,
     "forceConsistentCasingInFileNames": true,
     "types": ["node"],
-    "lib": ["DOM"]
+    "lib": ["DOM", "ES2022"]
   },
   "include": ["src/**/*.ts"],
   "references": [
     {
-      "path": "../cli/tsconfig.lib.json"
+      "path": "../tools/tsconfig.lib.json"
     },
     {
-      "path": "../bundler-metro/tsconfig.lib.json"
+      "path": "../platforms/tsconfig.lib.json"
     },
     {
-      "path": "../tools/tsconfig.lib.json"
+      "path": "../plugins/tsconfig.lib.json"
     },
     {
-      "path": "../platforms/tsconfig.lib.json"
+      "path": "../config/tsconfig.lib.json"
     },
     {
-      "path": "../config/tsconfig.lib.json"
+      "path": "../bundler-metro/tsconfig.lib.json"
     },
     {
       "path": "../bridge/tsconfig.lib.json"

package/dist/cli-args.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=cli-args.test.d.ts.map

package/dist/cli-args.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli-args.test.d.ts","sourceRoot":"","sources":["../src/cli-args.test.ts"],"names":[],"mappings":""}

package/dist/cli-args.test.js

@@ -1 +0,0 @@
-export {};

package/dist/crash-monitor.d.ts

@@ -1,16 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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"}