@react-native-harness/cli 1.0.0-alpha.15 → 1.0.0-alpha.18

package/src/errors/errors.ts

@@ -1,131 +0,0 @@
-import { TestRunnerConfig } from '@react-native-harness/config';
-
-export class NoRunnerSpecifiedError extends Error {
-  constructor(availableRunners: TestRunnerConfig[]) {
-    super('No runner specified');
-    this.name = 'NoRunnerSpecifiedError';
-    this.availableRunners = availableRunners;
-  }
-  availableRunners: TestRunnerConfig[];
-}
-
-export class RunnerNotFoundError extends Error {
-  constructor(runnerName: string, availableRunners: TestRunnerConfig[]) {
-    super(`Runner "${runnerName}" not found`);
-    this.name = 'RunnerNotFoundError';
-    this.runnerName = runnerName;
-    this.availableRunners = availableRunners;
-  }
-  runnerName: string;
-  availableRunners: TestRunnerConfig[];
-}
-
-export class EnvironmentInitializationError extends Error {
-  constructor(
-    message: string,
-    runnerName: string,
-    platform: string,
-    details?: string
-  ) {
-    super(
-      `Failed to initialize environment for "${runnerName}" (${platform}): ${message}`
-    );
-    this.name = 'EnvironmentInitializationError';
-    this.runnerName = runnerName;
-    this.platform = platform;
-    this.details = details;
-  }
-  runnerName: string;
-  platform: string;
-  details?: string;
-}
-
-export class TestExecutionError extends Error {
-  constructor(
-    testFile: string,
-    error: unknown,
-    testSuite?: string,
-    testName?: string
-  ) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    const suiteInfo = testSuite ? ` in suite "${testSuite}"` : '';
-    const testInfo = testName ? ` test "${testName}"` : '';
-
-    super(
-      `Test execution failed for ${testFile}${suiteInfo}${testInfo}: ${errorMessage}`
-    );
-    this.name = 'TestExecutionError';
-    this.testFile = testFile;
-    this.testSuite = testSuite;
-    this.testName = testName;
-    this.originalError = error;
-  }
-  testFile: string;
-  testSuite?: string;
-  testName?: string;
-  originalError: unknown;
-}
-
-export class RpcClientError extends Error {
-  constructor(message: string, bridgePort?: number, connectionStatus?: string) {
-    const portInfo = bridgePort ? ` (port ${bridgePort})` : '';
-    const statusInfo = connectionStatus ? ` - Status: ${connectionStatus}` : '';
-
-    super(`RPC client error${portInfo}: ${message}${statusInfo}`);
-    this.name = 'RpcClientError';
-    this.bridgePort = bridgePort;
-    this.connectionStatus = connectionStatus;
-  }
-  bridgePort?: number;
-  connectionStatus?: string;
-}
-
-export class BridgeTimeoutError extends Error {
-  constructor(
-    public readonly timeout: number,
-    public readonly runnerName: string,
-    public readonly platform: string
-  ) {
-    super(
-      `Bridge connection timed out after ${timeout}ms while waiting for "${runnerName}" (${platform}) runner to be ready`
-    );
-    this.name = 'BridgeTimeoutError';
-  }
-}
-
-export class AppNotInstalledError extends Error {
-  constructor(
-    public readonly deviceName: string,
-    public readonly bundleId: string,
-    public readonly platform: 'ios' | 'android' | 'vega'
-  ) {
-    const deviceType =
-      platform === 'ios'
-        ? 'simulator'
-        : platform === 'android'
-        ? 'emulator'
-        : 'virtual device';
-
-    super(
-      `App "${bundleId}" is not installed on ${deviceType} "${deviceName}"`
-    );
-    this.name = 'AppNotInstalledError';
-  }
-}
-
-export class BundlingFailedError extends Error {
-  constructor(
-    public readonly modulePath: string,
-    public readonly reason: string
-  ) {
-    super(`Bundling of ${modulePath} failed: ${reason}`);
-    this.name = 'BundlingFailedError';
-  }
-}
-
-export class MetroPortUnavailableError extends Error {
-  constructor(public readonly port: number) {
-    super(`Metro port ${port} is not available`);
-    this.name = 'MetroPortUnavailableError';
-  }
-}

package/src/platforms/android/build.ts

@@ -1,49 +0,0 @@
-import path from 'node:path';
-import { spawn } from '@react-native-harness/tools';
-
-export const buildAndroidApp = async (): Promise<void> => {
-  await spawn('react-native', ['build-android', '--tasks', 'assembleDebug']);
-};
-
-export const installApp = async (deviceId: string): Promise<void> => {
-  await spawn('adb', [
-    '-s',
-    deviceId,
-    'install',
-    '-r',
-    path.join(
-      process.cwd(),
-      'android',
-      'app',
-      'build',
-      'outputs',
-      'apk',
-      'debug',
-      'app-debug.apk'
-    ),
-  ]);
-};
-
-export const killApp = async (
-  deviceId: string,
-  bundleId: string
-): Promise<void> => {
-  await spawn('adb', ['-s', deviceId, 'shell', 'am', 'force-stop', bundleId]);
-};
-
-export const runApp = async (
-  deviceId: string,
-  bundleId: string,
-  activityName: string
-): Promise<void> => {
-  await killApp(deviceId, bundleId);
-  await spawn('adb', [
-    '-s',
-    deviceId,
-    'shell',
-    'am',
-    'start',
-    '-n',
-    `${bundleId}/${activityName}`,
-  ]);
-};

package/src/platforms/android/device.ts

@@ -1,48 +0,0 @@
-import { spawn } from '@react-native-harness/tools';
-
-export const killApp = async (
-  deviceId: string,
-  bundleId: string
-): Promise<void> => {
-  await spawn('adb', ['-s', deviceId, 'shell', 'am', 'force-stop', bundleId]);
-};
-
-export const runApp = async (
-  deviceId: string,
-  bundleId: string
-): Promise<void> => {
-  await killApp(deviceId, bundleId);
-  await spawn('adb', [
-    '-s',
-    deviceId,
-    'shell',
-    'am',
-    'start',
-    '-n',
-    `${bundleId}/.MainActivity`,
-  ]);
-};
-
-export const isAppInstalled = async (
-  deviceId: string,
-  bundleId: string
-): Promise<boolean> => {
-  try {
-    const { stdout } = await spawn('adb', [
-      '-s',
-      deviceId,
-      'shell',
-      'pm',
-      'list',
-      'packages',
-      bundleId,
-    ]);
-    return stdout.trim() !== '';
-  } catch {
-    return false;
-  }
-};
-
-export const reversePort = async (port: number): Promise<void> => {
-  await spawn('adb', ['reverse', `tcp:${port}`, `tcp:${port}`]);
-};

package/src/platforms/android/emulator.ts

@@ -1,137 +0,0 @@
-import { spawn } from '@react-native-harness/tools';
-import { ChildProcess } from 'node:child_process';
-
-export type AndroidEmulatorStatus = 'running' | 'loading' | 'stopped';
-
-export const getEmulatorNameFromId = async (
-  emulatorId: string
-): Promise<string | null> => {
-  try {
-    const { stdout } = await spawn('adb', [
-      '-s',
-      emulatorId,
-      'emu',
-      'avd',
-      'name',
-    ]);
-    const avdName = stdout.split('\n')[0].trim();
-    return avdName || null;
-  } catch {
-    return null;
-  }
-};
-
-export const getEmulatorDeviceId = async (
-  avdName: string
-): Promise<string | null> => {
-  try {
-    const { stdout } = await spawn('adb', ['devices']);
-    const lines = stdout.split('\n');
-
-    for (const line of lines) {
-      const parts = line.trim().split('\t');
-      if (parts.length === 2 && parts[0].startsWith('emulator-')) {
-        const emulatorId = parts[0].trim();
-        const name = await getEmulatorNameFromId(emulatorId);
-        if (name === avdName) {
-          return emulatorId;
-        }
-      }
-    }
-    return null;
-  } catch {
-    return null;
-  }
-};
-
-export const getEmulatorStatus = async (
-  avdName: string
-): Promise<AndroidEmulatorStatus> => {
-  const emulatorId = await getEmulatorDeviceId(avdName);
-  if (!emulatorId) {
-    return 'stopped';
-  }
-
-  try {
-    // Check if device is fully booted by checking boot completion
-    const { stdout } = await spawn('adb', [
-      '-s',
-      emulatorId,
-      'shell',
-      'getprop',
-      'sys.boot_completed',
-    ]);
-    const bootCompleted = stdout.trim() === '1';
-    return bootCompleted ? 'running' : 'loading';
-  } catch {
-    return 'loading';
-  }
-};
-
-export const runEmulator = async (name: string): Promise<ChildProcess> => {
-  // Start the emulator
-  const process = spawn('emulator', ['-avd', name]);
-  const nodeChildProcess = await process.nodeChildProcess;
-
-  // Poll for emulator status until it's fully running
-  const checkStatus = async (): Promise<void> => {
-    const status = await getEmulatorStatus(name);
-
-    if (status === 'running') {
-      return;
-    } else if (status === 'loading') {
-      // Check again in 2 seconds
-      await new Promise((resolve) => setTimeout(resolve, 2000));
-      await checkStatus();
-    } else {
-      // Still stopped, check again in 1 second
-      await new Promise((resolve) => setTimeout(resolve, 1000));
-      await checkStatus();
-    }
-  };
-
-  // Start checking status after a brief delay to allow emulator to start
-  await new Promise((resolve) => setTimeout(resolve, 3000));
-  await checkStatus();
-
-  return nodeChildProcess;
-};
-
-export const stopEmulator = async (avdName: string): Promise<void> => {
-  // First, get the emulator device ID
-  const emulatorId = await getEmulatorDeviceId(avdName);
-  if (!emulatorId) {
-    return; // No emulator running, nothing to stop
-  }
-
-  await stopEmulatorById(emulatorId);
-};
-
-const stopEmulatorById = async (emulatorId: string): Promise<void> => {
-  // Stop the emulator using the found ID
-  await spawn('adb', ['-s', emulatorId, 'emu', 'kill']);
-};
-
-export const isAppInstalled = async (
-  emulatorId: string,
-  bundleId: string
-): Promise<boolean> => {
-  try {
-    const { stdout } = await spawn('adb', [
-      '-s',
-      emulatorId,
-      'shell',
-      'pm',
-      'list',
-      'packages',
-      bundleId,
-    ]);
-    return stdout.trim() !== '';
-  } catch {
-    return false;
-  }
-};
-
-export const reversePort = async (port: number): Promise<void> => {
-  await spawn('adb', ['reverse', `tcp:${port}`, `tcp:${port}`]);
-};

package/src/platforms/android/index.ts

@@ -1,87 +0,0 @@
-import { type ChildProcess } from 'node:child_process';
-import {
-  assertAndroidRunnerConfig,
-  TestRunnerConfig,
-} from '@react-native-harness/config';
-import { logger } from '@react-native-harness/tools';
-
-import { type PlatformAdapter } from '../platform-adapter.js';
-import {
-  runEmulator,
-  getEmulatorDeviceId,
-  reversePort,
-  isAppInstalled,
-  getEmulatorStatus,
-} from './emulator.js';
-import { runApp, killApp } from './build.js';
-import { killWithAwait } from '../../process.js';
-import { runMetro } from '../../bundlers/metro.js';
-import { AppNotInstalledError } from '../../errors/errors.js';
-
-const androidPlatformAdapter: PlatformAdapter = {
-  name: 'android',
-  getEnvironment: async (runner: TestRunnerConfig) => {
-    assertAndroidRunnerConfig(runner);
-
-    let emulator: ChildProcess | null = null;
-    const emulatorStatus = await getEmulatorStatus(runner.deviceId);
-    logger.debug(`Emulator status: ${emulatorStatus}`);
-
-    const metroPromise = runMetro();
-
-    if (emulatorStatus === 'stopped') {
-      logger.debug(`Emulator ${runner.deviceId} is stopped, starting it`);
-      emulator = await runEmulator(runner.deviceId);
-    }
-
-    const deviceId = await getEmulatorDeviceId(runner.deviceId);
-    logger.debug(`Device ID: ${deviceId}`);
-
-    if (!deviceId) {
-      throw new Error('Emulator not found');
-    }
-
-    await Promise.all([
-      reversePort(8081),
-      reversePort(8080),
-      reversePort(3001),
-    ]);
-    logger.debug('Ports reversed');
-
-    const isInstalled = await isAppInstalled(deviceId, runner.bundleId);
-    logger.debug(`App is installed: ${isInstalled}`);
-
-    if (!isInstalled) {
-      throw new AppNotInstalledError(
-        runner.deviceId,
-        runner.bundleId,
-        'android'
-      );
-    }
-
-    logger.debug('Waiting for Metro to start');
-    const metro = await metroPromise;
-    logger.debug('Metro started');
-
-    logger.debug('Running app');
-    await runApp(deviceId, runner.bundleId, runner.activityName);
-    logger.debug('App running');
-
-    return {
-      restart: async () => {
-        await runApp(deviceId, runner.bundleId, runner.activityName);
-      },
-      dispose: async () => {
-        await killApp(deviceId, runner.bundleId);
-
-        if (emulator) {
-          await killWithAwait(emulator);
-        }
-
-        await killWithAwait(metro);
-      },
-    };
-  },
-};
-
-export default androidPlatformAdapter;

package/src/platforms/ios/build.ts

@@ -1,71 +0,0 @@
-import { spawn, spawnAndForget } from '@react-native-harness/tools';
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const listDevices = async (): Promise<any> => {
-  const { stdout } = await spawn('xcrun', [
-    'simctl',
-    'list',
-    'devices',
-    '--json',
-  ]);
-  return JSON.parse(stdout);
-};
-
-export const getDeviceByName = async (
-  simulatorName: string,
-  systemVersion: string
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-): Promise<any | null> => {
-  const devices = await listDevices();
-  const expectedRuntimeId = `com.apple.CoreSimulator.SimRuntime.iOS-${systemVersion.replace(
-    /\./,
-    '-'
-  )}`;
-
-  const runtime = devices.devices[expectedRuntimeId];
-
-  if (!runtime) {
-    return null;
-  }
-
-  const runtimeDevices = devices.devices[runtime];
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const device = runtimeDevices.find((d: any) => d.name === simulatorName);
-
-  if (device) {
-    return device;
-  }
-
-  return null;
-};
-
-export const listApps = async (udid: string): Promise<string[]> => {
-  const { stdout: plistOutput } = await spawn('xcrun', [
-    'simctl',
-    'listapps',
-    udid,
-  ]);
-  const { stdout: jsonOutput } = await spawn(
-    'plutil',
-    ['-convert', 'json', '-o', '-', '-'],
-    { stdin: { string: plistOutput } }
-  );
-  return Object.keys(JSON.parse(jsonOutput));
-};
-
-export const isAppInstalled = async (
-  udid: string,
-  bundleId: string
-): Promise<boolean> => {
-  const appList = await listApps(udid);
-  return appList.includes(bundleId);
-};
-
-export const runApp = async (udid: string, appName: string): Promise<void> => {
-  await killApp(udid, appName);
-  await spawn('xcrun', ['simctl', 'launch', udid, appName]);
-};
-
-export const killApp = async (udid: string, appName: string): Promise<void> => {
-  await spawnAndForget('xcrun', ['simctl', 'terminate', udid, appName]);
-};

package/src/platforms/ios/device.ts

@@ -1,79 +0,0 @@
-import { spawn, spawnAndForget } from '@react-native-harness/tools';
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type Device = any;
-
-export const listDevices = async (): Promise<{ devices: Device[] }> => {
-  const { stdout } = await spawn('xcrun', [
-    'simctl',
-    'list',
-    'devices',
-    '--json',
-  ]);
-  return JSON.parse(stdout);
-};
-
-export const getDeviceByName = async (
-  simulatorName: string
-): Promise<Device | null> => {
-  const devices = await listDevices();
-
-  for (const runtime in devices.devices) {
-    const runtimeDevices = devices.devices[runtime];
-    for (const device of runtimeDevices) {
-      if (device.name === simulatorName && device.isAvailable) {
-        return device;
-      }
-    }
-  }
-
-  return null;
-};
-
-export const listApps = async (udid: string): Promise<string[]> => {
-  const { stdout: plistOutput } = await spawn('xcrun', [
-    'simctl',
-    'listapps',
-    udid,
-  ]);
-  const { stdout: jsonOutput } = await spawn(
-    'plutil',
-    ['-convert', 'json', '-o', '-', '-'],
-    { stdin: { string: plistOutput } }
-  );
-  return Object.keys(JSON.parse(jsonOutput));
-};
-
-export const isAppInstalled = async (
-  simulatorName: string,
-  bundleId: string
-): Promise<boolean> => {
-  const device = await getDeviceByName(simulatorName);
-
-  if (!device) {
-    throw new Error(`Simulator ${simulatorName} not found`);
-  }
-
-  const appList = await listApps(device.udid);
-  return appList.includes(bundleId);
-};
-
-export const runApp = async (
-  simulatorName: string,
-  appName: string
-): Promise<void> => {
-  await killApp(simulatorName, appName);
-  await spawn('xcrun', ['simctl', 'launch', simulatorName, appName]);
-};
-
-export const killApp = async (
-  simulatorName: string,
-  appName: string
-): Promise<void> => {
-  await spawnAndForget('xcrun', [
-    'simctl',
-    'terminate',
-    simulatorName,
-    appName,
-  ]);
-};

package/src/platforms/ios/index.ts

@@ -1,66 +0,0 @@
-import {
-  assertIOSRunnerConfig,
-  TestRunnerConfig,
-} from '@react-native-harness/config';
-import { type PlatformAdapter } from '../platform-adapter.js';
-import {
-  getSimulatorDeviceId,
-  getSimulatorStatus,
-  runSimulator,
-  stopSimulator,
-} from './simulator.js';
-import { isAppInstalled, runApp, killApp } from './build.js';
-import { killWithAwait } from '../../process.js';
-import { runMetro } from '../../bundlers/metro.js';
-import { AppNotInstalledError } from '../../errors/errors.js';
-import { assert } from '../../utils.js';
-
-const iosPlatformAdapter: PlatformAdapter = {
-  name: 'ios',
-  getEnvironment: async (runner: TestRunnerConfig) => {
-    assertIOSRunnerConfig(runner);
-    // TODO: system version is also important as there may be two emulators with the same name
-    // but different system versions
-
-    let shouldStopSimulator = false;
-    const udid = await getSimulatorDeviceId(
-      runner.deviceId,
-      runner.systemVersion
-    );
-
-    assert(!!udid, 'Simulator not found');
-
-    const simulatorStatus = await getSimulatorStatus(udid);
-    const metroPromise = runMetro();
-
-    if (simulatorStatus === 'stopped') {
-      await runSimulator(udid);
-      shouldStopSimulator = true;
-    }
-
-    const isInstalled = await isAppInstalled(udid, runner.bundleId);
-
-    if (!isInstalled) {
-      throw new AppNotInstalledError(runner.deviceId, runner.bundleId, 'ios');
-    }
-
-    const metro = await metroPromise;
-    await runApp(udid, runner.bundleId);
-
-    return {
-      restart: async () => {
-        await runApp(udid, runner.bundleId);
-      },
-      dispose: async () => {
-        await killApp(udid, runner.bundleId);
-        if (shouldStopSimulator) {
-          await stopSimulator(udid);
-        }
-
-        await killWithAwait(metro);
-      },
-    };
-  },
-};
-
-export default iosPlatformAdapter;