@react-native-harness/jest 1.0.0-alpha.17

package/src/index.ts

@@ -0,0 +1,118 @@
+import type {
+  CallbackTestRunnerInterface,
+  Config,
+  OnTestFailure,
+  OnTestStart,
+  OnTestSuccess,
+  Test,
+  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 { formatError, type Harness } from '@react-native-harness/cli/external';
+import { setup } from './setup.js';
+import { teardown } from './teardown.js';
+
+class CancelRun extends Error {
+  constructor(message?: string) {
+    super(message);
+    this.name = 'CancelRun';
+  }
+}
+
+export default class JestHarness implements CallbackTestRunnerInterface {
+  readonly isSerial = true;
+
+  #globalConfig: Config.GlobalConfig;
+
+  constructor(globalConfig: Config.GlobalConfig) {
+    this.#globalConfig = globalConfig;
+  }
+
+  async runTests(
+    tests: Array<Test>,
+    watcher: TestWatcher,
+    onStart: OnTestStart,
+    onResult: OnTestSuccess,
+    onFailure: OnTestFailure,
+    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 harness = global.HARNESS;
+      const harnessConfig = global.HARNESS_CONFIG;
+
+      return await this._createInBandTestRun(
+        tests,
+        watcher,
+        harness,
+        harnessConfig,
+        onStart,
+        onResult,
+        onFailure
+      );
+    } catch (error) {
+      // Jest will print strings as they are, without processing them further.
+      throw formatError(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;
+
+    return tests.reduce(
+      (promise, test) =>
+        mutex(() =>
+          promise
+            .then(async () => {
+              if (watcher.isInterrupted()) {
+                throw new CancelRun();
+              }
+
+              if (
+                harnessConfig.resetEnvironmentBetweenTestFiles &&
+                !isFirstTest
+              ) {
+                await new Promise((resolve) => {
+                  harness.bridge.once('ready', resolve);
+                  harness.environment.restart();
+                });
+              }
+              isFirstTest = false;
+
+              return onStart(test).then(() =>
+                runHarnessTestFile({
+                  testPath: test.path,
+                  harness,
+                  globalConfig: this.#globalConfig,
+                  projectConfig: test.context.config,
+                })
+              );
+            })
+            .then((result) => onResult(test, result))
+            .catch((err) => onFailure(test, err))
+        ),
+      Promise.resolve()
+    );
+  }
+}

package/src/jest-preset.ts

@@ -0,0 +1,3 @@
+export default {
+  runner: '@react-native-harness/jest',
+};

package/src/logs.ts

@@ -0,0 +1,21 @@
+import { TestRunnerConfig } from '@react-native-harness/config';
+import chalk from 'chalk';
+
+const TAG = chalk.supportsColor
+  ? chalk.reset.inverse.bold.magenta(` HARNESS `)
+  : 'HARNESS';
+
+// @see https://github.com/jestjs/jest/blob/main/packages/jest-reporters/src/BaseReporter.ts#L25
+export const log = (message: string): void => {
+  process.stderr.write(`${message}\n`);
+};
+
+export const logTestRunHeader = (runner: TestRunnerConfig): void => {
+  log(
+    `${TAG} Preparing to run tests using ${chalk.bold(runner.name)} runner\n`
+  );
+};
+
+export const logTestEnvironmentReady = (runner: TestRunnerConfig): void => {
+  log(`${TAG} Runner ${chalk.bold(runner.name)} ready\n`);
+};

package/src/run.ts

@@ -0,0 +1,147 @@
+import path from 'node:path';
+import type { Config as JestConfig } from 'jest-runner';
+import { TestResult as JestTestResult } from '@jest/test-result';
+import type {
+  TestSuiteResult as HarnessTestSuiteResult,
+  TestResult as HarnessTestResult,
+} from '@react-native-harness/bridge';
+import type { Harness } from '@react-native-harness/cli/external';
+import { formatResultsErrors } from 'jest-message-util';
+import { toTestResult } from './toTestResult.js';
+
+// Helper function to flatten nested test suites into a flat array of tests with hierarchy
+const flattenTests = (
+  suiteResult: HarnessTestSuiteResult,
+  ancestorTitles: string[] = []
+): Array<HarnessTestResult & { ancestorTitles: string[] }> => {
+  const tests: Array<HarnessTestResult & { ancestorTitles: string[] }> = [];
+
+  // Add tests from current suite with current hierarchy
+  for (const test of suiteResult.tests) {
+    tests.push({
+      ...test,
+      ancestorTitles: [...ancestorTitles],
+    });
+  }
+
+  // Process child suites with updated hierarchy
+  for (const childSuite of suiteResult.suites) {
+    const newAncestorTitles = [...ancestorTitles, childSuite.name];
+    tests.push(...flattenTests(childSuite, newAncestorTitles));
+  }
+
+  return tests;
+};
+
+// Helper function to calculate test statistics
+const calculateStats = (tests: HarnessTestResult[]) => {
+  let passes = 0;
+  let failures = 0;
+  let pending = 0;
+  let todo = 0;
+
+  for (const test of tests) {
+    switch (test.status) {
+      case 'passed':
+        passes++;
+        break;
+      case 'failed':
+        failures++;
+        break;
+      case 'skipped':
+        pending++;
+        break;
+      case 'todo':
+        todo++;
+        break;
+    }
+  }
+
+  return { passes, failures, pending, todo };
+};
+
+export type RunHarnessTestFile = (options: {
+  testPath: string;
+  harness: Harness;
+  projectConfig: JestConfig.ProjectConfig;
+  globalConfig: JestConfig.GlobalConfig;
+}) => Promise<JestTestResult>;
+
+export const runHarnessTestFile: RunHarnessTestFile = async ({
+  testPath,
+  globalConfig,
+  projectConfig,
+  harness,
+}) => {
+  const start = Date.now();
+  const relativeTestPath = path.relative(globalConfig.rootDir, testPath);
+
+  // Extract setup files from Jest config and convert to relative paths
+  const setupFiles = projectConfig.setupFiles?.map((setupFile) =>
+    path.relative(globalConfig.rootDir, setupFile)
+  );
+  const setupFilesAfterEnv = projectConfig.setupFilesAfterEnv?.map(
+    (setupFile) => path.relative(globalConfig.rootDir, setupFile)
+  );
+
+  const client = harness.bridge.rpc.clients.at(-1)!;
+  const results = await client.runTests(relativeTestPath, {
+    testNamePattern: globalConfig.testNamePattern,
+    setupFiles,
+    setupFilesAfterEnv,
+  });
+  const end = Date.now();
+
+  const allTests = flattenTests(results);
+  const stats = calculateStats(allTests);
+
+  // Convert TestResult[] to the format expected by toTestResult
+  const tests = allTests.map((test) => {
+    const errorMessage = test.error?.message;
+    const codeFrame = test.error?.codeFrame;
+
+    return {
+      duration: test.duration,
+      errorMessage: errorMessage
+        ? `${errorMessage}${codeFrame ? `\n\n${codeFrame.content}` : ''}`
+        : undefined,
+      title: test.name,
+      status: test.status,
+      location: codeFrame?.location
+        ? { column: codeFrame.location.column, line: codeFrame.location.row }
+        : undefined,
+      ancestorTitles: test.ancestorTitles,
+    };
+  });
+
+  // Check if the entire suite was skipped
+  const skipped = results.status === 'skipped';
+
+  // Get error message from suite if it failed
+  const errorMessage = results.error?.message || null;
+
+  const totalResults = toTestResult({
+    stats: {
+      failures: stats.failures,
+      pending: stats.pending,
+      passes: stats.passes,
+      todo: stats.todo,
+      start,
+      end,
+    },
+    skipped,
+    errorMessage,
+    tests,
+    jestTestPath: testPath,
+    coverage: results.coverage as JestTestResult['coverage'],
+  });
+
+  totalResults.failureMessage = formatResultsErrors(
+    totalResults.testResults,
+    projectConfig,
+    globalConfig,
+    testPath
+  );
+
+  return totalResults;
+};

package/src/setup.ts

@@ -0,0 +1,95 @@
+import {
+  getConfig,
+  TestRunnerConfig,
+  type Config as HarnessConfig,
+  type TestRunnerConfig as HarnessTestRunnerConfig,
+} from '@react-native-harness/config';
+import type { Config as JestConfig } from 'jest-runner';
+import {
+  getHarness as getHarnessExternal,
+  NoRunnerSpecifiedError,
+  RunnerNotFoundError,
+  type Harness,
+} from '@react-native-harness/cli/external';
+import { preRunMessage } from 'jest-util';
+import { getAdditionalCliArgs, HarnessCliArgs } from './cli-args.js';
+import { logTestEnvironmentReady, logTestRunHeader } from './logs.js';
+
+const getHarnessConfig = async (
+  globalConfig: JestConfig.GlobalConfig
+): Promise<HarnessConfig> => {
+  const projectRoot = globalConfig.rootDir;
+  const { config: harnessConfig } = await getConfig(projectRoot);
+  return harnessConfig;
+};
+
+const getHarnessRunner = (
+  config: HarnessConfig,
+  cliArgs: HarnessCliArgs
+): HarnessTestRunnerConfig => {
+  const selectedRunnerName = cliArgs.harnessRunner ?? config.defaultRunner;
+
+  if (!selectedRunnerName) {
+    throw new NoRunnerSpecifiedError(config.runners);
+  }
+
+  const runner = config.runners.find(
+    (runner) => runner.name === selectedRunnerName
+  );
+
+  if (!runner) {
+    throw new RunnerNotFoundError(selectedRunnerName, config.runners);
+  }
+
+  return runner;
+};
+
+const getHarness = async (runner: TestRunnerConfig): Promise<Harness> => {
+  return await getHarnessExternal(runner);
+};
+
+export const setup = async (globalConfig: JestConfig.GlobalConfig) => {
+  preRunMessage.remove(process.stderr);
+  const harnessConfig =
+    global.HARNESS_CONFIG ?? (await getHarnessConfig(globalConfig));
+  const isWatchMode = globalConfig.watch || globalConfig.watchAll;
+
+  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 new Promise((resolve) => {
+        global.HARNESS.bridge.once('ready', resolve);
+        global.HARNESS.environment.restart();
+      });
+    }
+
+    return;
+  }
+
+  if (isWatchMode) {
+    // In watch mode, we want to dispose the Harness when the process exits.
+    process.on('exit', async () => {
+      await global.HARNESS.bridge.dispose();
+      await global.HARNESS.environment.dispose();
+    });
+  }
+
+  const cliArgs = getAdditionalCliArgs();
+  const selectedRunner = getHarnessRunner(harnessConfig, cliArgs);
+
+  if (globalConfig.collectCoverage) {
+    // 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';
+  }
+
+  logTestRunHeader(selectedRunner);
+  const harness = await getHarness(selectedRunner);
+  logTestEnvironmentReady(selectedRunner);
+
+  global.HARNESS_CONFIG = harnessConfig;
+  global.HARNESS = harness;
+};

package/src/teardown.ts

@@ -0,0 +1,15 @@
+import type { Config as JestConfig } from 'jest-runner';
+
+export const teardown = async (globalConfig: JestConfig.GlobalConfig) => {
+  const isWatchMode = globalConfig.watch || globalConfig.watchAll;
+
+  if (isWatchMode) {
+    // In watch mode, we don't want to dispose the Harness.
+    return;
+  }
+
+  if (global.HARNESS) {
+    await global.HARNESS.bridge.dispose();
+    await global.HARNESS.environment.dispose();
+  }
+};

package/src/toTestResult.ts

@@ -0,0 +1,101 @@
+import type { Status, TestResult } from '@jest/test-result';
+
+export type Options = {
+  stats: {
+    failures: number;
+    passes: number;
+    pending: number;
+    todo: number;
+    start: number;
+    end: number;
+  };
+  skipped: boolean;
+  errorMessage?: string | null;
+  tests: Array<{
+    duration?: number | null;
+    errorMessage?: string;
+    testPath?: string;
+    title?: string;
+    status: Status;
+    location?: {
+      column: number;
+      line: number;
+    };
+    ancestorTitles?: string[];
+  }>;
+  jestTestPath: string;
+  coverage?: TestResult['coverage'];
+};
+
+const getPerfStats = ({ stats }: Options): TestResult['perfStats'] => {
+  const start = new Date(stats.start).getTime();
+  const end = new Date(stats.end).getTime();
+  const runtime = end - start;
+  // Note: this flag is set in 'lib/createJestRunner.ts'
+  const slow = false;
+  return {
+    start,
+    end,
+    runtime,
+    slow,
+    loadTestEnvironmentStart: 0,
+    loadTestEnvironmentEnd: 0,
+    setupAfterEnvStart: 0,
+    setupAfterEnvEnd: 0,
+    setupFilesStart: 0,
+    setupFilesEnd: 0,
+  };
+};
+
+const getSnapshot = (): TestResult['snapshot'] => {
+  return {
+    added: 0,
+    fileDeleted: false,
+    matched: 0,
+    unchecked: 0,
+    uncheckedKeys: [],
+    unmatched: 0,
+    updated: 0,
+  };
+};
+
+const getTestResults = ({
+  errorMessage,
+  tests,
+  jestTestPath,
+}: Options): TestResult['testResults'] => {
+  return tests.map((test) => {
+    const actualErrorMessage = errorMessage || test.errorMessage;
+
+    return {
+      ancestorTitles: test.ancestorTitles || [],
+      duration: test.duration,
+      failureDetails: [],
+      failureMessages: actualErrorMessage ? [actualErrorMessage] : [],
+      fullName: jestTestPath || test.testPath || '',
+      numPassingAsserts: test.errorMessage ? 1 : 0,
+      status: test.status,
+      title: test.title || '',
+      location: test.location,
+    };
+  });
+};
+
+export const toTestResult = (options: Options): TestResult => {
+  const { stats, skipped, errorMessage, jestTestPath, coverage } = options;
+  return {
+    failureMessage: errorMessage,
+    leaks: false,
+    numFailingTests: stats.failures,
+    numPassingTests: stats.passes,
+    numPendingTests: stats.pending,
+    numTodoTests: stats.todo,
+    openHandles: [],
+    perfStats: getPerfStats(options),
+    skipped,
+    snapshot: getSnapshot(),
+    testFilePath: jestTestPath,
+    testResults: getTestResults(options),
+    coverage,
+  };
+};

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "../cli"
+    },
+    {
+      "path": "../config"
+    },
+    {
+      "path": "../bridge"
+    },
+    {
+      "path": "./tsconfig.lib.json"
+    }
+  ]
+}

package/tsconfig.lib.json

@@ -0,0 +1,25 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "baseUrl": ".",
+    "rootDir": "src",
+    "outDir": "dist",
+    "tsBuildInfoFile": "dist/tsconfig.lib.tsbuildinfo",
+    "emitDeclarationOnly": false,
+    "forceConsistentCasingInFileNames": true,
+    "types": ["node"],
+    "lib": ["DOM"]
+  },
+  "include": ["src/**/*.ts"],
+  "references": [
+    {
+      "path": "../cli/tsconfig.lib.json"
+    },
+    {
+      "path": "../config/tsconfig.lib.json"
+    },
+    {
+      "path": "../bridge/tsconfig.lib.json"
+    }
+  ]
+}