react-native-harness 0.0.0 → 1.0.0-alpha.1

package/src/platforms/ios/build.ts

@@ -0,0 +1,76 @@
+import { spawn, spawnAndForget } from '@react-native-harness/tools';
+
+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
+): Promise<any | 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/device.ts

@@ -0,0 +1,76 @@
+import { spawn, spawnAndForget } from '@react-native-harness/tools';
+
+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
+): Promise<any | 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

@@ -0,0 +1,55 @@
+import {
+  assertNativeRunnerConfig,
+  TestRunnerConfig,
+} from '@react-native-harness/config';
+import { type PlatformAdapter } from '../platform-adapter.js';
+import {
+  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';
+
+const iosPlatformAdapter: PlatformAdapter = {
+  name: 'ios',
+  getEnvironment: async (runner: TestRunnerConfig) => {
+    assertNativeRunnerConfig(runner);
+
+    let shouldStopSimulator = false;
+    const simulatorStatus = await getSimulatorStatus(runner.deviceId);
+    const metroPromise = runMetro();
+
+    if (simulatorStatus === 'stopped') {
+      await runSimulator(runner.deviceId);
+      shouldStopSimulator = true;
+    }
+
+    const isInstalled = await isAppInstalled(runner.deviceId, runner.bundleId);
+
+    if (!isInstalled) {
+      throw new AppNotInstalledError(runner.deviceId, runner.bundleId, 'ios');
+    }
+
+    const metro = await metroPromise;
+    await runApp(runner.deviceId, runner.bundleId);
+
+    return {
+      restart: async () => {
+        await runApp(runner.deviceId, runner.bundleId);
+      },
+      dispose: async () => {
+        await killApp(runner.deviceId, runner.bundleId);
+        if (shouldStopSimulator) {
+          await stopSimulator(runner.deviceId);
+        }
+
+        await killWithAwait(metro);
+      },
+    };
+  },
+};
+
+export default iosPlatformAdapter;

package/src/platforms/ios/simulator.ts

@@ -0,0 +1,177 @@
+import { spawn } from '@react-native-harness/tools';
+
+export type IOSSimulatorStatus = 'stopped' | 'loading' | 'running';
+
+export const getSimulatorDeviceId = async (
+  simulatorName: string
+): Promise<string | null> => {
+  try {
+    const { stdout } = await spawn('xcrun', [
+      'simctl',
+      'list',
+      'devices',
+      '--json',
+    ]);
+    const devices = JSON.parse(stdout);
+
+    // Find the device across all iOS versions
+    for (const runtime in devices.devices) {
+      if (runtime.includes('iOS')) {
+        const runtimeDevices = devices.devices[runtime];
+        const device = runtimeDevices.find(
+          (d: any) => d.name === simulatorName
+        );
+
+        if (device) {
+          return device.udid;
+        }
+      }
+    }
+
+    return null;
+  } catch {
+    return null;
+  }
+};
+
+export const getAvailableSimulators = async (): Promise<
+  Array<{ name: string; udid: string; runtime: string }>
+> => {
+  try {
+    const { stdout } = await spawn('xcrun', [
+      'simctl',
+      'list',
+      'devices',
+      '--json',
+    ]);
+    const devices = JSON.parse(stdout);
+    const simulators: Array<{
+      name: string;
+      udid: string;
+      runtime: string;
+    }> = [];
+
+    for (const runtime in devices.devices) {
+      if (runtime.includes('iOS')) {
+        const runtimeDevices = devices.devices[runtime];
+        runtimeDevices.forEach((device: any) => {
+          if (device.isAvailable) {
+            simulators.push({
+              name: device.name,
+              udid: device.udid,
+              runtime: runtime,
+            });
+          }
+        });
+      }
+    }
+
+    return simulators;
+  } catch {
+    return [];
+  }
+};
+
+export const getSimulatorStatus = async (
+  simulatorName: string
+): Promise<IOSSimulatorStatus> => {
+  try {
+    const { stdout } = await spawn('xcrun', [
+      'simctl',
+      'list',
+      'devices',
+      '--json',
+    ]);
+    const devices = JSON.parse(stdout);
+
+    for (const runtime in devices.devices) {
+      if (runtime.includes('iOS')) {
+        const runtimeDevices = devices.devices[runtime];
+        const device = runtimeDevices.find(
+          (d: any) => d.name === simulatorName
+        );
+
+        if (device) {
+          switch (device.state) {
+            case 'Booted':
+              return 'running';
+            case 'Booting':
+              return 'loading';
+            default:
+              return 'stopped';
+          }
+        }
+      }
+    }
+
+    return 'stopped';
+  } catch {
+    return 'stopped';
+  }
+};
+
+export const runSimulator = async (name: string): Promise<void> => {
+  const deviceId = await getSimulatorDeviceId(name);
+
+  if (!deviceId) {
+    throw new Error('Simulator not found');
+  }
+
+  try {
+    await spawn('xcrun', ['simctl', 'boot', deviceId]);
+  } catch (bootError: any) {
+    // Ignore if simulator is already booted
+    if (
+      !bootError.stderr?.includes(
+        'Unable to boot device in current state: Booted'
+      )
+    ) {
+      throw bootError;
+    }
+  }
+
+  await spawn('open', ['-a', 'Simulator']);
+
+  let attempts = 0;
+
+  while (true) {
+    attempts++;
+
+    const status = await getSimulatorStatus(name);
+
+    if (status === 'running') {
+      break;
+    }
+
+    if (attempts > 10) {
+      throw new Error('Simulator not running');
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+  }
+};
+
+export const stopSimulator = async (name: string): Promise<void> => {
+  const simulatorId = await getSimulatorDeviceId(name);
+
+  if (!simulatorId) {
+    return; // Already stopped
+  }
+
+  await stopSimulatorById(simulatorId);
+};
+
+const stopSimulatorById = async (simulatorId: string): Promise<void> => {
+  try {
+    await spawn('xcrun', ['simctl', 'shutdown', simulatorId]);
+  } catch (shutdownError: any) {
+    // Ignore if simulator is already shut down
+    if (
+      !shutdownError.stderr?.includes(
+        'Unable to shutdown device in current state: Shutdown'
+      )
+    ) {
+      throw shutdownError;
+    }
+  }
+};

package/src/platforms/platform-adapter.ts

@@ -0,0 +1,11 @@
+import { TestRunnerConfig } from '@react-native-harness/config';
+
+export type Environment = {
+  restart: () => Promise<void>;
+  dispose: () => Promise<void>;
+};
+
+export type PlatformAdapter = {
+  name: string;
+  getEnvironment: (runner: TestRunnerConfig) => Promise<Environment>;
+};

package/src/platforms/platform-registry.ts

@@ -0,0 +1,24 @@
+import { PlatformAdapter } from './platform-adapter.js';
+import androidPlatformAdapter from './android/index.js';
+import iosPlatformAdapter from './ios/index.js';
+import webPlatformAdapter from './web/index.js';
+
+const platformAdapters = {
+  android: androidPlatformAdapter,
+  ios: iosPlatformAdapter,
+  web: webPlatformAdapter,
+};
+
+export const getPlatformAdapter = async (
+  platformName: string
+): Promise<PlatformAdapter> => {
+  if (!(platformName in platformAdapters)) {
+    throw new Error(`Platform adapter for ${platformName} not found`);
+  }
+
+  try {
+    return platformAdapters[platformName as keyof typeof platformAdapters];
+  } catch (error) {
+    throw new Error(`Platform adapter for ${platformName} not found`);
+  }
+};

package/src/platforms/web/index.ts

@@ -0,0 +1,95 @@
+import { TestRunnerConfig, WebTestRunnerConfig, assertWebRunnerConfig } from '@react-native-harness/config';
+import { logger } from '@react-native-harness/tools';
+import { Browser, chromium, firefox, Page, webkit } from 'playwright';
+import { PlatformAdapter } from '../platform-adapter.js';
+import { runMetro } from '../../bundlers/metro.js';
+
+const runBrowser = async (
+  url: string,
+  browserType: WebTestRunnerConfig['browser']
+): Promise<{ browser: Browser; page: Page }> => {
+  // For now, we're only supporting Firefox, but this will be expanded
+  // to support other browsers based on the config
+  let browser: Browser;
+  
+  switch (browserType) {
+    case 'firefox':
+      browser = await firefox.launch({
+        headless: false,
+        devtools: false,
+        args: [
+          '--no-sandbox',
+          '--disable-setuid-sandbox',
+          '--disable-dev-shm-usage',
+          '--disable-web-security',
+          '--allow-insecure-localhost',
+          '--ignore-certificate-errors',
+        ],
+        ignoreDefaultArgs: ['--disable-extensions'],
+      });
+      break;
+    case 'chrome':
+      browser = await chromium.launch({
+        headless: false,
+        devtools: false,
+      });
+      break;
+    case 'safari':
+      browser = await webkit.launch({
+        headless: false,
+        devtools: false,
+      });
+      break;
+    default:
+      throw new Error(`Unsupported browser type: ${browserType}`);
+  }
+
+  const context = await browser.newContext({
+    bypassCSP: true,
+    ignoreHTTPSErrors: true,
+  });
+
+  const page = await context.newPage();
+
+  await page.setViewportSize({ width: 1280, height: 720 });
+
+  await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 60000 });
+
+  return { browser, page };
+};
+
+export const webPlatformAdapter: PlatformAdapter = {
+  name: 'web',
+  getEnvironment: async (runner: TestRunnerConfig) => {
+    assertWebRunnerConfig(runner);
+    
+    logger.debug('Starting web environment');
+    
+
+
+    logger.debug('Running metro');
+    const metro = await runMetro(true);
+    logger.debug('Metro running');
+
+    logger.debug(`Running browser: ${runner.browser}`);
+    const { browser, page } = await runBrowser('http://localhost:8081', runner.browser);
+    logger.debug('Browser running');
+    
+
+
+    return {
+      restart: async () => {
+        logger.debug('Reloading page');
+        await page.reload({ waitUntil: 'domcontentloaded', timeout: 60000 });
+      },
+      dispose: async () => {
+        logger.debug('Closing browser');
+        await browser.close();
+
+        metro.kill();
+      },
+    };
+  },
+};
+
+export default webPlatformAdapter;

package/src/process.ts

@@ -0,0 +1,33 @@
+import { type ChildProcess } from 'node:child_process';
+
+export const killWithAwait = (child: ChildProcess): Promise<void> => {
+  return new Promise((resolve) => {
+    const timeout = setTimeout(() => {
+      child.kill('SIGTERM');
+      resolve();
+    }, 10000);
+
+    if (child.killed || child.exitCode !== null) {
+      clearTimeout(timeout);
+      resolve();
+      return;
+    }
+
+    child.on('exit', () => {
+      clearTimeout(timeout);
+      resolve();
+    });
+
+    child.on('error', () => {
+      clearTimeout(timeout);
+      resolve();
+    });
+
+    try {
+      child.kill();
+    } catch (error) {
+      clearTimeout(timeout);
+      resolve();
+    }
+  });
+};

package/src/reporters/default-reporter.ts

@@ -0,0 +1,149 @@
+import { color, spinner } from '@react-native-harness/tools';
+import type { TestSuiteResult, TestResult } from '@react-native-harness/bridge';
+import { Reporter } from '@react-native-harness/config';
+
+export const defaultReporter: Reporter = {
+  report: async (results) => {
+    const resultsSpinner = spinner();
+    resultsSpinner.start('Test Results');
+
+    for (const suite of results) {
+      resultsSpinner.message(formatSuiteResult(suite));
+    }
+
+    // Summary
+    let totalPassed = 0,
+      totalFailed = 0,
+      totalSkipped = 0,
+      totalTodo = 0;
+    let totalDuration = 0;
+
+    for (const suite of results) {
+      const summary = getTestSummary(suite);
+      totalPassed += summary.passed;
+      totalFailed += summary.failed;
+      totalSkipped += summary.skipped;
+      totalTodo += summary.todo;
+      totalDuration += suite.duration || 0;
+    }
+
+    const summaryText = [
+      color.green(`${totalPassed} passed`),
+      color.red(`${totalFailed} failed`),
+      color.yellow(`${totalSkipped} skipped`),
+      color.blue(`${totalTodo} todo`),
+    ].join(', ');
+
+    resultsSpinner.message(`Summary: ${summaryText}`);
+    resultsSpinner.message(`Total time: ${formatDuration(totalDuration)}`);
+  },
+};
+
+const formatDuration = (duration?: number): string => {
+  if (duration == null) return '';
+  return color.dim(` (${duration}ms)`);
+};
+
+const getStatusIcon = (status: string): string => {
+  switch (status) {
+    case 'passed':
+      return color.green('✓');
+    case 'failed':
+      return color.red('✗');
+    case 'skipped':
+      return color.yellow('○');
+    case 'todo':
+      return color.blue('◐');
+    default:
+      return '?';
+  }
+};
+
+const formatTestResult = (test: TestResult, indent = ''): string => {
+  const icon = getStatusIcon(test.status);
+  const name = test.status === 'failed' ? color.red(test.name) : test.name;
+  const duration = formatDuration(test.duration);
+
+  let result = `${indent}${icon} ${name}${duration}`;
+
+  if (test.error) {
+    const errorLines = test.error.message?.split('\n') || [];
+    result +=
+      '\n' +
+      errorLines
+        .map((line: string) => `${indent}  ${color.red(line)}`)
+        .join('\n');
+  }
+
+  return result;
+};
+
+const formatSuiteResult = (suite: TestSuiteResult, indent = ''): string => {
+  const icon = getStatusIcon(suite.status);
+  const name =
+    suite.status === 'failed' ? color.red(suite.name) : color.bold(suite.name);
+  const duration = formatDuration(suite.duration);
+
+  let result = `${indent}${icon} ${name}${duration}`;
+
+  if (suite.error) {
+    const errorLines = suite.error.message.split('\n');
+    result +=
+      '\n' +
+      errorLines
+        .map((line: string) => `${indent}  ${color.red(line)}`)
+        .join('\n');
+  }
+
+  const childIndent = indent + '  ';
+
+  // Format tests
+  for (const test of suite.tests) {
+    result += '\n' + formatTestResult(test, childIndent);
+  }
+
+  // Format nested suites
+  for (const childSuite of suite.suites) {
+    result += '\n' + formatSuiteResult(childSuite, childIndent);
+  }
+
+  return result;
+};
+
+const getTestSummary = (
+  suite: TestSuiteResult
+): { passed: number; failed: number; skipped: number; todo: number } => {
+  let passed = 0,
+    failed = 0,
+    skipped = 0,
+    todo = 0;
+
+  // Count tests in current suite
+  for (const test of suite.tests) {
+    switch (test.status) {
+      case 'passed':
+        passed++;
+        break;
+      case 'failed':
+        failed++;
+        break;
+      case 'skipped':
+        skipped++;
+        break;
+      case 'todo':
+        todo++;
+        break;
+    }
+  }
+
+  // Count tests in nested suites
+  for (const childSuite of suite.suites) {
+    const childSummary = getTestSummary(childSuite);
+    passed += childSummary.passed;
+    failed += childSummary.failed;
+    skipped += childSummary.skipped;
+    todo += childSummary.todo;
+  }
+
+  return { passed, failed, skipped, todo };
+};