@react-native-harness/cli 1.0.0-alpha.14 → 1.0.0-alpha.17

package/src/platforms/android/emulator.ts

@@ -7,7 +7,13 @@ export const getEmulatorNameFromId = async (
   emulatorId: string
 ): Promise<string | null> => {
   try {
-    const { stdout } = await spawn('adb', ['-s', emulatorId, 'emu', 'avd', 'name']);
+    const { stdout } = await spawn('adb', [
+      '-s',
+      emulatorId,
+      'emu',
+      'avd',
+      'name',
+    ]);
     const avdName = stdout.split('\n')[0].trim();
     return avdName || null;
   } catch {
@@ -48,7 +54,13 @@ export const getEmulatorStatus = async (
 
   try {
     // Check if device is fully booted by checking boot completion
-    const { stdout } = await spawn('adb', ['-s', emulatorId, 'shell', 'getprop', 'sys.boot_completed']);
+    const { stdout } = await spawn('adb', [
+      '-s',
+      emulatorId,
+      'shell',
+      'getprop',
+      'sys.boot_completed',
+    ]);
     const bootCompleted = stdout.trim() === '1';
     return bootCompleted ? 'running' : 'loading';
   } catch {
@@ -69,17 +81,17 @@ export const runEmulator = async (name: string): Promise<ChildProcess> => {
       return;
     } else if (status === 'loading') {
       // Check again in 2 seconds
-      await new Promise(resolve => setTimeout(resolve, 2000));
+      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 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 new Promise((resolve) => setTimeout(resolve, 3000));
   await checkStatus();
 
   return nodeChildProcess;
@@ -105,7 +117,15 @@ export const isAppInstalled = async (
   bundleId: string
 ): Promise<boolean> => {
   try {
-    const { stdout } = await spawn('adb', ['-s', emulatorId, 'shell', 'pm', 'list', 'packages', bundleId]);
+    const { stdout } = await spawn('adb', [
+      '-s',
+      emulatorId,
+      'shell',
+      'pm',
+      'list',
+      'packages',
+      bundleId,
+    ]);
     return stdout.trim() !== '';
   } catch {
     return false;
@@ -115,25 +135,3 @@ export const isAppInstalled = async (
 export const reversePort = async (port: number): Promise<void> => {
   await spawn('adb', ['reverse', `tcp:${port}`, `tcp:${port}`]);
 };
-
-export const getEmulatorScreenshot = async (
-  emulatorId: string,
-  name: string = `${emulatorId}-${new Date()
-    .toISOString()
-    .replace(/:/g, '-')
-    .replace(/\//g, '-')}.png`
-): Promise<string> => {
-  // Use screencap to save directly to device, then pull the file
-  const devicePath = '/sdcard/screenshot.png';
-
-  // Take screenshot and save to device
-  await spawn('adb', ['-s', emulatorId, 'shell', 'screencap', '-p', devicePath]);
-
-  // Pull the file from device to local
-  await spawn('adb', ['-s', emulatorId, 'pull', devicePath, name]);
-
-  // Clean up the file on device
-  await spawn('adb', ['-s', emulatorId, 'shell', 'rm', devicePath]);
-
-  return name;
-};

package/src/platforms/ios/build.ts

@@ -1,5 +1,6 @@
 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',
@@ -13,6 +14,7 @@ export const listDevices = async (): Promise<any> => {
 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(
@@ -27,6 +29,7 @@ export const getDeviceByName = async (
   }
 
   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) {

package/src/platforms/ios/device.ts

@@ -1,6 +1,9 @@
 import { spawn, spawnAndForget } from '@react-native-harness/tools';
 
-export const listDevices = async (): Promise<any> => {
+// 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',
@@ -12,7 +15,7 @@ export const listDevices = async (): Promise<any> => {
 
 export const getDeviceByName = async (
   simulatorName: string
-): Promise<any | null> => {
+): Promise<Device | null> => {
   const devices = await listDevices();
 
   for (const runtime in devices.devices) {

package/src/platforms/ios/simulator.ts

@@ -1,4 +1,4 @@
-import { spawn } from '@react-native-harness/tools';
+import { spawn, SubprocessError } from '@react-native-harness/tools';
 
 export type IOSSimulatorStatus = 'stopped' | 'loading' | 'running';
 
@@ -25,6 +25,7 @@ export const getSimulatorDeviceId = async (
       return null;
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const device = runtime.find((d: any) => d.name === simulatorName);
 
     if (device) {
@@ -57,6 +58,7 @@ export const getAvailableSimulators = async (): Promise<
     for (const runtime in devices.devices) {
       if (runtime.includes('iOS')) {
         const runtimeDevices = devices.devices[runtime];
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         runtimeDevices.forEach((device: any) => {
           if (device.isAvailable) {
             simulators.push({
@@ -90,6 +92,7 @@ export const getSimulatorStatus = async (
     for (const runtime in devices.devices) {
       if (runtime.includes('iOS')) {
         const runtimeDevices = devices.devices[runtime];
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const device = runtimeDevices.find((d: any) => d.udid === udid);
 
         if (device) {
@@ -114,9 +117,10 @@ export const getSimulatorStatus = async (
 export const runSimulator = async (udid: string): Promise<void> => {
   try {
     await spawn('xcrun', ['simctl', 'boot', udid]);
-  } catch (bootError: any) {
+  } catch (bootError) {
     // Ignore if simulator is already booted
     if (
+      bootError instanceof SubprocessError &&
       !bootError.stderr?.includes(
         'Unable to boot device in current state: Booted'
       )
@@ -153,9 +157,10 @@ export const stopSimulator = async (udid: string): Promise<void> => {
 const stopSimulatorById = async (udid: string): Promise<void> => {
   try {
     await spawn('xcrun', ['simctl', 'shutdown', udid]);
-  } catch (shutdownError: any) {
+  } catch (shutdownError) {
     // Ignore if simulator is already shut down
     if (
+      shutdownError instanceof SubprocessError &&
       !shutdownError.stderr?.includes(
         'Unable to shutdown device in current state: Shutdown'
       )

package/src/platforms/platform-registry.ts

@@ -20,7 +20,7 @@ export const getPlatformAdapter = async (
 
   try {
     return platformAdapters[platformName as keyof typeof platformAdapters];
-  } catch (error) {
+  } catch {
     throw new Error(`Platform adapter for ${platformName} not found`);
   }
 };

package/src/platforms/vega/device.ts

@@ -152,7 +152,7 @@ export const uninstallApp = async (
 export const startPortForwarding = async (
   deviceId: string,
   port: number,
-  forward: boolean = true
+  forward = true
 ): Promise<void> => {
   await spawn('kepler', [
     'device',
@@ -172,7 +172,7 @@ export const startPortForwarding = async (
 export const stopPortForwarding = async (
   deviceId: string,
   port: number,
-  forward: boolean = true
+  forward = true
 ): Promise<void> => {
   await spawn('kepler', [
     'device',

package/src/process.ts

@@ -25,7 +25,7 @@ export const killWithAwait = (child: ChildProcess): Promise<void> => {
 
     try {
       child.kill();
-    } catch (error) {
+    } catch {
       clearTimeout(timeout);
       resolve();
     }

package/src/utils.ts

@@ -1,3 +1,5 @@
+import net from 'node:net';
+
 export function assert(condition: boolean, message: string): asserts condition {
   if (!condition) {
     throw new AssertionError(message);
@@ -10,3 +12,18 @@ export class AssertionError extends Error {
     this.name = 'AssertionError';
   }
 }
+
+export const isPortAvailable = (port: number): Promise<boolean> => {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.once('error', () => {
+      server.close();
+      resolve(false);
+    });
+    server.once('listening', () => {
+      server.close();
+      resolve(true);
+    });
+    server.listen(port);
+  });
+};

package/tsconfig.json

@@ -3,6 +3,9 @@
   "files": [],
   "include": [],
   "references": [
+    {
+      "path": "../tools"
+    },
     {
       "path": "../config"
     },

package/src/commands/test.ts

@@ -1,228 +0,0 @@
-import {
-  getBridgeServer,
-  type BridgeServer,
-} from '@react-native-harness/bridge/server';
-import { TestExecutionOptions } from '@react-native-harness/bridge';
-import {
-  Config,
-  getConfig,
-  TestRunnerConfig,
-} from '@react-native-harness/config';
-import { getPlatformAdapter } from '../platforms/platform-registry.js';
-import { intro, logger, outro, spinner } from '@react-native-harness/tools';
-import { type Environment } from '../platforms/platform-adapter.js';
-import { BridgeTimeoutError } from '../errors/errors.js';
-import { assert } from '../utils.js';
-import {
-  EnvironmentInitializationError,
-  NoRunnerSpecifiedError,
-  RpcClientError,
-  RunnerNotFoundError,
-} from '../errors/errors.js';
-import { TestSuiteResult } from '@react-native-harness/bridge';
-import {
-  discoverTestFiles,
-  type TestFilterOptions,
-} from '../discovery/index.js';
-
-type TestRunContext = {
-  config: Config;
-  runner: TestRunnerConfig;
-  bridge?: BridgeServer;
-  environment?: Environment;
-  testFiles?: string[];
-  results?: TestSuiteResult[];
-  projectRoot: string;
-};
-
-const setupEnvironment = async (context: TestRunContext): Promise<void> => {
-  const startSpinner = spinner();
-  const platform = context.runner.platform;
-
-  startSpinner.start(`Starting "${context.runner.name}" (${platform}) runner`);
-
-  const platformAdapter = await getPlatformAdapter(platform);
-  const serverBridge = await getBridgeServer({
-    port: 3001,
-  });
-
-  context.bridge = serverBridge;
-
-  const readyPromise = new Promise<void>((resolve, reject) => {
-    const timeout = setTimeout(() => {
-      reject(
-        new BridgeTimeoutError(
-          context.config.bridgeTimeout,
-          context.runner.name,
-          platform
-        )
-      );
-    }, context.config.bridgeTimeout);
-
-    serverBridge.once('ready', () => {
-      clearTimeout(timeout);
-      resolve();
-    });
-  });
-
-  context.environment = await platformAdapter.getEnvironment(context.runner);
-
-  logger.debug('Waiting for bridge to be ready');
-  await readyPromise;
-  logger.debug('Bridge is ready');
-
-  if (!context.environment) {
-    throw new EnvironmentInitializationError(
-      'Failed to initialize environment',
-      context.runner.name,
-      platform,
-      'Platform adapter returned null environment'
-    );
-  }
-
-  startSpinner.stop(`"${context.runner.name}" (${platform}) runner started`);
-};
-
-const findTestFiles = async (
-  context: TestRunContext,
-  options: TestFilterOptions = {}
-): Promise<void> => {
-  const discoverSpinner = spinner();
-  discoverSpinner.start('Discovering tests');
-
-  context.testFiles = await discoverTestFiles(
-    context.projectRoot,
-    context.config.include,
-    options
-  );
-
-  discoverSpinner.stop(`Found ${context.testFiles.length} test files`);
-};
-
-const runTests = async (
-  context: TestRunContext,
-  options: TestFilterOptions = {}
-): Promise<void> => {
-  const { bridge, environment, testFiles } = context;
-  assert(bridge != null, 'Bridge not initialized');
-  assert(environment != null, 'Environment not initialized');
-  assert(testFiles != null, 'Test files not initialized');
-
-  let runSpinner = spinner();
-  runSpinner.start('Running tests');
-
-  let shouldRestart = false;
-
-  for (const testFile of testFiles) {
-    if (shouldRestart) {
-      runSpinner = spinner();
-      runSpinner.start(`Restarting environment for next test file`);
-
-      await new Promise((resolve) => {
-        bridge.once('ready', resolve);
-        environment.restart();
-      });
-    }
-
-    runSpinner.message(`Running tests in ${testFile}`);
-    const client = bridge.rpc.clients.at(-1);
-    if (!client) {
-      throw new RpcClientError(
-        'No RPC client available',
-        3001,
-        'No clients connected'
-      );
-    }
-
-    // Pass only testNamePattern to runtime (file filtering already done)
-    const executionOptions: TestExecutionOptions = {
-      testNamePattern: options.testNamePattern,
-    };
-
-    const result = await client.runTests(testFile, executionOptions);
-    context.results = [...(context.results ?? []), ...result.suites];
-    shouldRestart = true;
-    runSpinner.stop(`Test file ${testFile} completed`);
-  }
-
-  runSpinner.stop('Tests completed');
-};
-
-const cleanUp = async (context: TestRunContext): Promise<void> => {
-  if (context.bridge) {
-    context.bridge.dispose();
-  }
-  if (context.environment) {
-    await context.environment.dispose();
-  }
-};
-
-const hasFailedTests = (results: TestSuiteResult[]): boolean => {
-  for (const suite of results) {
-    // Check if the suite itself failed
-    if (suite.status === 'failed') {
-      return true;
-    }
-
-    // Check individual tests in the suite
-    for (const test of suite.tests) {
-      if (test.status === 'failed') {
-        return true;
-      }
-    }
-
-    // Recursively check nested suites
-    if (suite.suites && hasFailedTests(suite.suites)) {
-      return true;
-    }
-  }
-
-  return false;
-};
-
-export const testCommand = async (
-  runnerName?: string,
-  options: TestFilterOptions = {}
-): Promise<void> => {
-  intro('React Native Test Harness');
-
-  const { config, projectRoot } = await getConfig(process.cwd());
-  const selectedRunnerName = runnerName ?? config.defaultRunner;
-
-  if (!selectedRunnerName) {
-    throw new NoRunnerSpecifiedError(config.runners);
-  }
-
-  const runner = config.runners.find((r) => r.name === selectedRunnerName);
-
-  if (!runner) {
-    throw new RunnerNotFoundError(selectedRunnerName, config.runners);
-  }
-
-  const context: TestRunContext = {
-    config,
-    runner,
-    testFiles: [],
-    results: [],
-    projectRoot,
-  };
-
-  try {
-    await setupEnvironment(context);
-    await findTestFiles(context, options);
-    await runTests(context, options);
-
-    assert(context.results != null, 'Results not initialized');
-    config.reporter?.report(context.results);
-  } finally {
-    await cleanUp(context);
-  }
-
-  // Check if any tests failed and exit with appropriate code
-  if (hasFailedTests(context.results)) {
-    outro('Test run completed with failures');
-    process.exit(1);
-  } else {
-    outro('Test run completed successfully');
-  }
-};

package/src/discovery/index.ts

@@ -1,2 +0,0 @@
-export { discoverTestFiles } from './testDiscovery.js';
-export type { TestFilterOptions } from './testDiscovery.js';

package/src/discovery/testDiscovery.ts

@@ -1,50 +0,0 @@
-import { Glob } from 'glob';
-
-export type TestFilterOptions = {
-  testNamePattern?: string;
-  testPathPattern?: string;
-  testPathIgnorePatterns?: string[];
-  testMatch?: string[];
-};
-
-/**
- * Discovers test files based on patterns and filtering options
- */
-export const discoverTestFiles = async (
-  projectRoot: string,
-  configInclude: string | string[],
-  options: TestFilterOptions = {}
-): Promise<string[]> => {
-  // Priority: testMatch > configInclude
-  const patterns = options.testMatch || configInclude;
-  const patternArray = Array.isArray(patterns) ? patterns : [patterns];
-
-  // Glob discovery
-  const allFiles: string[] = [];
-  for (const pattern of patternArray) {
-    const glob = new Glob(pattern, { cwd: projectRoot, nodir: true });
-    const files = await glob.walk();
-    allFiles.push(...files);
-  }
-
-  // Remove duplicates
-  let uniqueFiles = [...new Set(allFiles)];
-
-  // Apply testPathPattern filtering
-  if (options.testPathPattern) {
-    const regex = new RegExp(options.testPathPattern);
-    uniqueFiles = uniqueFiles.filter((file) => regex.test(file));
-  }
-
-  // Apply testPathIgnorePatterns filtering
-  if (options.testPathIgnorePatterns?.length) {
-    const ignoreRegexes = options.testPathIgnorePatterns.map(
-      (p) => new RegExp(p)
-    );
-    uniqueFiles = uniqueFiles.filter(
-      (file) => !ignoreRegexes.some((regex) => regex.test(file))
-    );
-  }
-
-  return uniqueFiles;
-};