@react-native-harness/cli 1.0.0-alpha.10 → 1.0.0-alpha.12

package/src/commands/test.ts

@@ -2,20 +2,14 @@ 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 { Glob } from 'glob';
-import {
-  intro,
-  logger,
-  outro,
-  spinner,
-  progress,
-} from '@react-native-harness/tools';
+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';
@@ -26,6 +20,10 @@ import {
   RunnerNotFoundError,
 } from '../errors/errors.js';
 import { TestSuiteResult } from '@react-native-harness/bridge';
+import {
+  discoverTestFiles,
+  type TestFilterOptions,
+} from '../discovery/index.js';
 
 type TestRunContext = {
   config: Config;
@@ -87,34 +85,38 @@ const setupEnvironment = async (context: TestRunContext): Promise<void> => {
 
 const findTestFiles = async (
   context: TestRunContext,
-  pattern?: string
+  options: TestFilterOptions = {}
 ): Promise<void> => {
   const discoverSpinner = spinner();
   discoverSpinner.start('Discovering tests');
 
-  const globPattern = pattern || context.config.include;
-  const glob = new Glob(globPattern, {
-    cwd: context.projectRoot,
-  });
-  context.testFiles = await glob.walk();
+  context.testFiles = await discoverTestFiles(
+    context.projectRoot,
+    context.config.include,
+    options
+  );
+
   discoverSpinner.stop(`Found ${context.testFiles.length} test files`);
 };
 
-const runTests = async (context: TestRunContext): Promise<void> => {
+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 = progress({ style: 'block' });
+  let runSpinner = spinner();
   runSpinner.start('Running tests');
 
   let shouldRestart = false;
 
   for (const testFile of testFiles) {
     if (shouldRestart) {
-      runSpinner = progress({ style: 'block' });
-      runSpinner.message(`Restarting environment for next test file`);
+      runSpinner = spinner();
+      runSpinner.start(`Restarting environment for next test file`);
 
       await new Promise((resolve) => {
         bridge.once('ready', resolve);
@@ -132,15 +134,23 @@ const runTests = async (context: TestRunContext): Promise<void> => {
       );
     }
 
-    const result = await client.runTests(testFile);
+    // 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.ws.close();
+    context.bridge.dispose();
   }
   if (context.environment) {
     await context.environment.dispose();
@@ -172,7 +182,7 @@ const hasFailedTests = (results: TestSuiteResult[]): boolean => {
 
 export const testCommand = async (
   runnerName?: string,
-  pattern?: string
+  options: TestFilterOptions = {}
 ): Promise<void> => {
   intro('React Native Test Harness');
 
@@ -199,8 +209,8 @@ export const testCommand = async (
 
   try {
     await setupEnvironment(context);
-    await findTestFiles(context, pattern);
-    await runTests(context);
+    await findTestFiles(context, options);
+    await runTests(context, options);
 
     assert(context.results != null, 'Results not initialized');
     config.reporter?.report(context.results);

package/src/discovery/index.ts

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

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]);
+};