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

package/src/harness.ts

@@ -0,0 +1,105 @@
+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 { Config as HarnessConfig } from '@react-native-harness/config';
+import pRetry from 'p-retry';
+
+const BRIDGE_READY_TIMEOUT = 10000;
+
+export type Harness = {
+  runTests: BridgeClientFunctions['runTests'];
+  restart: () => Promise<void>;
+  dispose: () => Promise<void>;
+};
+
+const getHarnessInternal = async (
+  config: HarnessConfig,
+  platform: HarnessPlatform,
+  signal: AbortSignal
+): Promise<Harness> => {
+  const [metroInstance, platformInstance, serverBridge] = await Promise.all([
+    getMetroInstance(),
+    platform.getInstance(),
+    getBridgeServer({
+      port: 3001,
+      timeout: config.bridgeTimeout,
+    }),
+  ]);
+
+  const dispose = async () => {
+    await Promise.all([
+      serverBridge.dispose(),
+      platformInstance.dispose(),
+      metroInstance.dispose(),
+    ]);
+  };
+
+  if (signal.aborted) {
+    await dispose();
+
+    throw new DOMException('The operation was aborted', 'AbortError');
+  }
+
+  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,
+      }
+    );
+  } catch (error) {
+    await dispose();
+    throw error;
+  }
+
+  const restart = () =>
+    new Promise<void>((resolve, reject) => {
+      serverBridge.once('ready', () => resolve());
+      platformInstance.restartApp().catch(reject);
+    });
+
+  return {
+    runTests: async (path, options) => {
+      const client = serverBridge.rpc.clients.at(-1);
+
+      if (!client) {
+        throw new Error('No client found');
+      }
+
+      return await client.runTests(path, options);
+    },
+    restart,
+    dispose,
+  };
+};
+
+export const getHarness = async (
+  config: HarnessConfig,
+  platform: HarnessPlatform
+): Promise<Harness> => {
+  const abortSignal = AbortSignal.timeout(config.bridgeTimeout);
+
+  try {
+    const harness = await getHarnessInternal(config, platform, abortSignal);
+    return harness;
+  } catch (error) {
+    if (error instanceof DOMException && error.name === 'AbortError') {
+      throw new InitializationTimeoutError();
+    }
+
+    throw error;
+  }
+};

package/src/index.ts

@@ -11,9 +11,12 @@ import type {
 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 { type Harness } 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';
 
 class CancelRun extends Error {
   constructor(message?: string) {
@@ -60,8 +63,12 @@ export default class JestHarness implements CallbackTestRunnerInterface {
         onFailure
       );
     } catch (error) {
-      // Jest will print strings as they are, without processing them further.
-      throw formatError(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);
@@ -93,10 +100,7 @@ export default class JestHarness implements CallbackTestRunnerInterface {
                 harnessConfig.resetEnvironmentBetweenTestFiles &&
                 !isFirstTest
               ) {
-                await new Promise((resolve) => {
-                  harness.bridge.once('ready', resolve);
-                  harness.environment.restart();
-                });
+                await harness.restart();
               }
               isFirstTest = false;
 
@@ -110,7 +114,18 @@ export default class JestHarness implements CallbackTestRunnerInterface {
               );
             })
             .then((result) => onResult(test, result))
-            .catch((err) => onFailure(test, err))
+            .catch((err) => {
+              if (err instanceof DeviceNotRespondingError) {
+                onFailure(test, {
+                  message: err.message,
+                  stack: '',
+                });
+
+                return;
+              }
+
+              onFailure(test, err);
+            })
         ),
       Promise.resolve()
     );

package/src/logs.ts

@@ -1,21 +1,30 @@
-import { TestRunnerConfig } from '@react-native-harness/config';
+import { HarnessPlatform } from '@react-native-harness/platforms';
+import { HarnessError } from '@react-native-harness/tools';
 import chalk from 'chalk';
 
 const TAG = chalk.supportsColor
   ? chalk.reset.inverse.bold.magenta(` HARNESS `)
   : 'HARNESS';
 
+const ERROR_TAG = chalk.supportsColor
+  ? chalk.reset.inverse.bold.red(` 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 => {
+export const logTestRunHeader = (runner: HarnessPlatform): void => {
   log(
     `${TAG} Preparing to run tests using ${chalk.bold(runner.name)} runner\n`
   );
 };
 
-export const logTestEnvironmentReady = (runner: TestRunnerConfig): void => {
+export const logTestEnvironmentReady = (runner: HarnessPlatform): void => {
   log(`${TAG} Runner ${chalk.bold(runner.name)} ready\n`);
 };
+
+export const getErrorMessage = (error: HarnessError): string => {
+  return `${ERROR_TAG} ${error.message}\n`;
+};

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 '@react-native-harness/cli/external';
+import type { Harness } from './harness.js';
 import { formatResultsErrors } from 'jest-message-util';
 import { toTestResult } from './toTestResult.js';
 
@@ -84,8 +84,7 @@ export const runHarnessTestFile: RunHarnessTestFile = async ({
     (setupFile) => path.relative(globalConfig.rootDir, setupFile)
   );
 
-  const client = harness.bridge.rpc.clients.at(-1)!;
-  const results = await client.runTests(relativeTestPath, {
+  const results = await harness.runTests(relativeTestPath, {
     testNamePattern: globalConfig.testNamePattern,
     setupFiles,
     setupFilesAfterEnv,

package/src/setup.ts

@@ -1,19 +1,14 @@
 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 { getHarness } from './harness.js';
 import { preRunMessage } from 'jest-util';
 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';
 
 const getHarnessConfig = async (
   globalConfig: JestConfig.GlobalConfig
@@ -26,11 +21,11 @@ const getHarnessConfig = async (
 const getHarnessRunner = (
   config: HarnessConfig,
   cliArgs: HarnessCliArgs
-): HarnessTestRunnerConfig => {
+): HarnessPlatform => {
   const selectedRunnerName = cliArgs.harnessRunner ?? config.defaultRunner;
 
   if (!selectedRunnerName) {
-    throw new NoRunnerSpecifiedError(config.runners);
+    throw new NoRunnerSpecifiedError();
   }
 
   const runner = config.runners.find(
@@ -38,21 +33,16 @@ const getHarnessRunner = (
   );
 
   if (!runner) {
-    throw new RunnerNotFoundError(selectedRunnerName, config.runners);
+    throw new RunnerNotFoundError(selectedRunnerName);
   }
 
   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
@@ -60,22 +50,16 @@ export const setup = async (globalConfig: JestConfig.GlobalConfig) => {
 
     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();
-      });
+      await global.HARNESS.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();
-    });
-  }
+  // Gracefully dispose the Harness when the process exits.
+  process.on('exit', async () => {
+    await global.HARNESS.dispose();
+  });
 
   const cliArgs = getAdditionalCliArgs();
   const selectedRunner = getHarnessRunner(harnessConfig, cliArgs);
@@ -87,7 +71,7 @@ export const setup = async (globalConfig: JestConfig.GlobalConfig) => {
   }
 
   logTestRunHeader(selectedRunner);
-  const harness = await getHarness(selectedRunner);
+  const harness = await getHarness(harnessConfig, selectedRunner);
   logTestEnvironmentReady(selectedRunner);
 
   global.HARNESS_CONFIG = harnessConfig;

package/src/teardown.ts

@@ -9,7 +9,6 @@ export const teardown = async (globalConfig: JestConfig.GlobalConfig) => {
   }
 
   if (global.HARNESS) {
-    await global.HARNESS.bridge.dispose();
-    await global.HARNESS.environment.dispose();
+    await global.HARNESS.dispose();
   }
 };

package/tsconfig.json

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

package/tsconfig.lib.json

@@ -15,6 +15,15 @@
     {
       "path": "../cli/tsconfig.lib.json"
     },
+    {
+      "path": "../bundler-metro/tsconfig.lib.json"
+    },
+    {
+      "path": "../tools/tsconfig.lib.json"
+    },
+    {
+      "path": "../platforms/tsconfig.lib.json"
+    },
     {
       "path": "../config/tsconfig.lib.json"
     },