@react-native-harness/cli 1.0.0-alpha.11 → 1.0.0-alpha.13

package/src/discovery/testDiscovery.ts

@@ -0,0 +1,50 @@
+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;
+};

package/src/errors/errorHandler.ts

@@ -128,10 +128,14 @@ export const handleError = (error: unknown): void => {
     console.error(`\nPlease check your bridge connection and try again.`);
   } else if (error instanceof AppNotInstalledError) {
     console.error(`\n❌ App Not Installed`);
+    const deviceType =
+      error.platform === 'ios'
+        ? 'simulator'
+        : error.platform === 'android'
+        ? 'emulator'
+        : 'virtual device';
     console.error(
-      `\nThe app "${error.bundleId}" is not installed on ${
-        error.platform === 'ios' ? 'simulator' : 'emulator'
-      } "${error.deviceName}".`
+      `\nThe app "${error.bundleId}" is not installed on ${deviceType} "${error.deviceName}".`
     );
     console.error(`\nTo resolve this issue:`);
     if (error.platform === 'ios') {
@@ -141,13 +145,21 @@ export const handleError = (error: unknown): void => {
       console.error(
         `  • Or install from Xcode: Open ios/*.xcworkspace and run the project`
       );
-    } else {
+    } else if (error.platform === 'android') {
       console.error(
         `  • Build and install the app: npx react-native run-android`
       );
       console.error(
         `  • Or build manually: ./gradlew assembleDebug && adb install android/app/build/outputs/apk/debug/app-debug.apk`
       );
+    } else if (error.platform === 'vega') {
+      console.error(`  • Build the Vega app: npm run build:app`);
+      console.error(
+        `  • Install the app: kepler device install-app -p <path-to-vpkg> --device "${error.deviceName}"`
+      );
+      console.error(
+        `  • Or use the combined command: kepler run-kepler <path-to-vpkg> "${error.bundleId}" -d "${error.deviceName}"`
+      );
     }
     console.error(`\nPlease install the app and try running the tests again.`);
   } else if (error instanceof BundlingFailedError) {

package/src/errors/errors.ts

@@ -97,12 +97,17 @@ export class AppNotInstalledError extends Error {
   constructor(
     public readonly deviceName: string,
     public readonly bundleId: string,
-    public readonly platform: 'ios' | 'android'
+    public readonly platform: 'ios' | 'android' | 'vega'
   ) {
+    const deviceType =
+      platform === 'ios'
+        ? 'simulator'
+        : platform === 'android'
+        ? 'emulator'
+        : 'virtual device';
+
     super(
-      `App "${bundleId}" is not installed on ${
-        platform === 'ios' ? 'simulator' : 'emulator'
-      } "${deviceName}"`
+      `App "${bundleId}" is not installed on ${deviceType} "${deviceName}"`
     );
     this.name = 'AppNotInstalledError';
   }

package/src/index.ts

@@ -13,14 +13,20 @@ const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
 
 const program = new Command();
 
-logger.setVerbose(true);
-
 program
   .name('react-native-harness')
   .description(
     'React Native Test Harness - A comprehensive testing framework for React Native applications'
   )
-  .version(packageJson.version);
+  .version(packageJson.version)
+  .option('-v, --verbose', 'Enable verbose logging')
+  .hook('preAction', (thisCommand) => {
+    // Handle global verbose option
+    const opts = thisCommand.optsWithGlobals();
+    if (opts.verbose) {
+      logger.setVerbose(true);
+    }
+  });
 
 program
   .command('test')
@@ -33,9 +39,31 @@ program
     '[pattern]',
     'glob pattern to match test files (uses config.include if not specified)'
   )
-  .action(async (runner, pattern) => {
+  .option(
+    '-t, --testNamePattern <pattern>',
+    'Run only tests with names matching regex pattern'
+  )
+  .option(
+    '--testPathPattern <pattern>',
+    'Run only test files with paths matching regex pattern'
+  )
+  .option(
+    '--testPathIgnorePatterns <patterns...>',
+    'Ignore test files matching these patterns'
+  )
+  .option(
+    '--testMatch <patterns...>',
+    'Override config.include with these glob patterns'
+  )
+  .action(async (runner, pattern, options) => {
     try {
-      await testCommand(runner, pattern);
+      // Convert CLI pattern argument to testMatch option
+      const mergedOptions = {
+        ...options,
+        testMatch: pattern ? [pattern] : options.testMatch,
+      };
+
+      await testCommand(runner, mergedOptions);
     } catch (error) {
       handleError(error);
       process.exit(1);

package/src/platforms/android/index.ts

@@ -69,7 +69,7 @@ const androidPlatformAdapter: PlatformAdapter = {
 
     return {
       restart: async () => {
-        await runApp(runner.deviceId, runner.bundleId, runner.activityName);
+        await runApp(deviceId, runner.bundleId, runner.activityName);
       },
       dispose: async () => {
         await killApp(deviceId, runner.bundleId);

package/src/platforms/platform-registry.ts

@@ -2,11 +2,13 @@ import { PlatformAdapter } from './platform-adapter.js';
 import androidPlatformAdapter from './android/index.js';
 import iosPlatformAdapter from './ios/index.js';
 import webPlatformAdapter from './web/index.js';
+import vegaPlatformAdapter from './vega/index.js';
 
 const platformAdapters = {
   android: androidPlatformAdapter,
   ios: iosPlatformAdapter,
   web: webPlatformAdapter,
+  vega: vegaPlatformAdapter,
 };
 
 export const getPlatformAdapter = async (

package/src/platforms/vega/build.ts

@@ -0,0 +1,85 @@
+import path from 'node:path';
+import { spawn } from '@react-native-harness/tools';
+
+export type VegaBuildTarget = 'sim_tv_x86_64' | 'sim_tv_aarch64';
+export type VegaBuildType = 'Debug' | 'Release';
+
+/**
+ * Build Vega app and produce .vpkg file
+ */
+export const buildVegaApp = async (
+  buildType: VegaBuildType = 'Release',
+  target?: VegaBuildTarget
+): Promise<void> => {
+  const args = ['run', 'build:app'];
+
+  if (buildType) {
+    args.push('-b', buildType);
+  }
+
+  if (target) {
+    args.push('-t', target);
+  }
+
+  await spawn('npm', args);
+};
+
+/**
+ * Clean build artifacts
+ */
+export const cleanBuild = async (): Promise<void> => {
+  await spawn('kepler', ['clean']);
+};
+
+/**
+ * Get the expected .vpkg file path based on build configuration
+ */
+export const getVpkgPath = (
+  appName: string,
+  buildType: VegaBuildType = 'Release',
+  target: VegaBuildTarget = 'sim_tv_x86_64'
+): string => {
+  const buildTypeStr = buildType.toLowerCase();
+  const vpkgFileName = `${appName}_${target}.vpkg`;
+
+  return path.join(
+    process.cwd(),
+    'build',
+    `${target}-${buildTypeStr}`,
+    vpkgFileName
+  );
+};
+
+/**
+ * Launch an already installed app on specified Vega virtual device
+ */
+export const runApp = async (
+  deviceId: string,
+  bundleId: string
+): Promise<void> => {
+  await spawn('kepler', [
+    'device',
+    'launch-app',
+    '--device',
+    deviceId,
+    '--appName',
+    bundleId,
+  ]);
+};
+
+/**
+ * Kill/terminate app on specified Vega virtual device
+ */
+export const killApp = async (
+  deviceId: string,
+  bundleId: string
+): Promise<void> => {
+  await spawn('kepler', [
+    'device',
+    'terminate-app',
+    '--device',
+    deviceId,
+    '--appName',
+    bundleId,
+  ]);
+};

package/src/platforms/vega/device.ts

@@ -0,0 +1,258 @@
+import { spawn } from '@react-native-harness/tools';
+
+export type VegaVirtualDeviceStatus = 'running' | 'stopped';
+
+/**
+ * List all available Vega virtual devices
+ * Returns array of device identifiers that can be used with kepler commands
+ */
+export const listVegaDevices = async (): Promise<string[]> => {
+  try {
+    const { stdout } = await spawn('kepler', ['device', 'list']);
+    const lines = stdout.trim().split('\n');
+    const devices: string[] = [];
+
+    for (const line of lines) {
+      if (line.trim()) {
+        // Parse device line format: "VirtualDevice : tv - x86_64 - OS - hostname"
+        // or potentially "VegaTV_1 : tv - x86_64 - OS - hostname" for named instances
+        const deviceId = line.split(' : ')[0].trim();
+        if (
+          deviceId &&
+          (deviceId === 'VirtualDevice' || deviceId.startsWith('Vega'))
+        ) {
+          devices.push(deviceId);
+        }
+      }
+    }
+
+    return devices;
+  } catch {
+    return [];
+  }
+};
+
+/**
+ * Check if a specific Vega virtual device is connected/available
+ */
+export const isVegaDeviceConnected = async (
+  deviceId: string
+): Promise<boolean> => {
+  try {
+    const { stdout } = await spawn('kepler', [
+      'device',
+      'is-connected',
+      '--device',
+      deviceId,
+    ]);
+    return stdout.includes('is connected');
+  } catch {
+    return false;
+  }
+};
+
+/**
+ * Check if an app is installed on the specified Vega virtual device
+ */
+export const isAppInstalled = async (
+  deviceId: string,
+  bundleId: string
+): Promise<boolean> => {
+  try {
+    await spawn('kepler', [
+      'device',
+      'is-app-installed',
+      '--device',
+      deviceId,
+      '--appName',
+      bundleId,
+    ]);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+/**
+ * Check if an app is currently running on the specified Vega virtual device
+ */
+export const isAppRunning = async (
+  deviceId: string,
+  bundleId: string
+): Promise<boolean> => {
+  try {
+    await spawn('kepler', [
+      'device',
+      'is-app-running',
+      '--device',
+      deviceId,
+      '--appName',
+      bundleId,
+    ]);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+/**
+ * Install app on specified Vega virtual device using .vpkg file
+ */
+export const installApp = async (
+  deviceId: string,
+  vpkgPath: string
+): Promise<void> => {
+  await spawn('kepler', [
+    'device',
+    'install-app',
+    '-p',
+    vpkgPath,
+    '--device',
+    deviceId,
+  ]);
+};
+
+/**
+ * Terminate app on specified Vega virtual device
+ */
+export const terminateApp = async (
+  deviceId: string,
+  bundleId: string
+): Promise<void> => {
+  await spawn('kepler', [
+    'device',
+    'terminate-app',
+    '--device',
+    deviceId,
+    '--appName',
+    bundleId,
+  ]);
+};
+
+/**
+ * Uninstall app from specified Vega virtual device
+ */
+export const uninstallApp = async (
+  deviceId: string,
+  bundleId: string
+): Promise<void> => {
+  await spawn('kepler', [
+    'device',
+    'uninstall-app',
+    '--device',
+    deviceId,
+    '--appName',
+    bundleId,
+  ]);
+};
+
+/**
+ * Start port forwarding for debugging on specified Vega virtual device
+ */
+export const startPortForwarding = async (
+  deviceId: string,
+  port: number,
+  forward: boolean = true
+): Promise<void> => {
+  await spawn('kepler', [
+    'device',
+    'start-port-forwarding',
+    '--device',
+    deviceId,
+    '--port',
+    port.toString(),
+    '--forward',
+    forward.toString(),
+  ]);
+};
+
+/**
+ * Stop port forwarding on specified Vega virtual device
+ */
+export const stopPortForwarding = async (
+  deviceId: string,
+  port: number,
+  forward: boolean = true
+): Promise<void> => {
+  await spawn('kepler', [
+    'device',
+    'stop-port-forwarding',
+    '--device',
+    deviceId,
+    '--port',
+    port.toString(),
+    '--forward',
+    forward.toString(),
+  ]);
+};
+
+/**
+ * Get status of a specific Vega virtual device
+ * Note: Vega CLI might manage virtual devices globally, so this checks if the device is available
+ */
+export const getVegaDeviceStatus = async (
+  deviceId: string
+): Promise<VegaVirtualDeviceStatus> => {
+  try {
+    // First check if the device is connected/available
+    const isConnected = await isVegaDeviceConnected(deviceId);
+    if (isConnected) {
+      return 'running';
+    }
+
+    // Check general virtual device status
+    const { stdout } = await spawn('kepler', ['virtual-device', 'status']);
+    // Parse the status output to determine if VVD is running
+    return stdout.toLowerCase().includes('running') ||
+      stdout.toLowerCase().includes('ready')
+      ? 'running'
+      : 'stopped';
+  } catch {
+    return 'stopped';
+  }
+};
+
+/**
+ * Start Vega Virtual Device
+ * Note: Vega might manage virtual devices globally, this starts the virtual device system
+ */
+export const startVirtualDevice = async (): Promise<void> => {
+  await spawn('kepler', ['virtual-device', 'start']);
+
+  // Poll for VVD status until it's running
+  let attempts = 0;
+  const maxAttempts = 30; // 30 seconds timeout
+
+  while (attempts < maxAttempts) {
+    const { stdout } = await spawn('kepler', ['virtual-device', 'status']);
+    if (
+      stdout.toLowerCase().includes('running') ||
+      stdout.toLowerCase().includes('ready')
+    ) {
+      return;
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+    attempts++;
+  }
+
+  throw new Error('Vega Virtual Device failed to start within timeout');
+};
+
+/**
+ * Stop Vega Virtual Device
+ */
+export const stopVirtualDevice = async (): Promise<void> => {
+  await spawn('kepler', ['virtual-device', 'stop']);
+};
+
+/**
+ * Combined install and run command for specified Vega virtual device (Vega-specific convenience method)
+ */
+export const runKepler = async (
+  deviceId: string,
+  vpkgPath: string,
+  bundleId: string
+): Promise<void> => {
+  await spawn('kepler', ['run-kepler', vpkgPath, bundleId, '-d', deviceId]);
+};

package/src/platforms/vega/index.ts

@@ -0,0 +1,107 @@
+import {
+  assertVegaRunnerConfig,
+  TestRunnerConfig,
+} from '@react-native-harness/config';
+import { logger } from '@react-native-harness/tools';
+
+import { type PlatformAdapter } from '../platform-adapter.js';
+import {
+  isAppInstalled,
+  getVegaDeviceStatus,
+  isVegaDeviceConnected,
+  startVirtualDevice,
+  stopVirtualDevice,
+  startPortForwarding,
+  stopPortForwarding,
+} from './device.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 vegaPlatformAdapter: PlatformAdapter = {
+  name: 'vega',
+  getEnvironment: async (runner: TestRunnerConfig) => {
+    assertVegaRunnerConfig(runner);
+
+    let shouldStopVirtualDevice = false;
+
+    // Check if the specific Vega device is available
+    const deviceStatus = await getVegaDeviceStatus(runner.deviceId);
+    logger.debug(`Vega device ${runner.deviceId} status: ${deviceStatus}`);
+
+    if (deviceStatus === 'stopped') {
+      logger.debug('Starting Vega Virtual Device system');
+      await startVirtualDevice();
+      shouldStopVirtualDevice = true;
+
+      // Wait a bit for the device to become available
+      await new Promise((resolve) => setTimeout(resolve, 2000));
+    }
+
+    // Verify device is now connected
+    const isConnected = await isVegaDeviceConnected(runner.deviceId);
+    if (!isConnected) {
+      throw new Error(
+        `Vega device ${runner.deviceId} is not available. Make sure the virtual device is configured and running.`
+      );
+    }
+
+    // Start Metro bundler
+    const metroPromise = runMetro();
+
+    // Set up port forwarding for debugging (similar to Android)
+    await Promise.all([
+      startPortForwarding(runner.deviceId, 8081, false), // reverse port forwarding for JS debugging
+      startPortForwarding(runner.deviceId, 8080, false),
+      startPortForwarding(runner.deviceId, 3001, false),
+    ]);
+    logger.debug('Port forwarding established');
+
+    // Check if app is installed
+    const isInstalled = await isAppInstalled(runner.deviceId, runner.bundleId);
+    logger.debug(`App is installed: ${isInstalled}`);
+
+    if (!isInstalled) {
+      throw new AppNotInstalledError(runner.deviceId, runner.bundleId, 'vega');
+    }
+
+    logger.debug('Waiting for Metro to start');
+    const metro = await metroPromise;
+    logger.debug('Metro started');
+
+    logger.debug('Running Vega app');
+    await runApp(runner.deviceId, runner.bundleId);
+    logger.debug('Vega app running');
+
+    return {
+      restart: async () => {
+        await runApp(runner.deviceId, runner.bundleId);
+      },
+      dispose: async () => {
+        // Kill the app
+        await killApp(runner.deviceId, runner.bundleId);
+
+        // Stop port forwarding
+        await Promise.all([
+          stopPortForwarding(runner.deviceId, 8081, false),
+          stopPortForwarding(runner.deviceId, 8080, false),
+          stopPortForwarding(runner.deviceId, 3001, false),
+        ]).catch((error) => {
+          // Don't fail disposal if port forwarding cleanup fails
+          logger.debug(`Port forwarding cleanup failed: ${error.message}`);
+        });
+
+        // Stop Virtual Device if we started it
+        if (shouldStopVirtualDevice) {
+          await stopVirtualDevice();
+        }
+
+        // Kill Metro
+        await killWithAwait(metro);
+      },
+    };
+  },
+};
+
+export default vegaPlatformAdapter;