@react-native-harness/runtime 1.0.0-alpha.8 → 1.0.0-canary.1761046904277

package/src/client/factory.ts

@@ -1,15 +1,17 @@
 import type {
   TestRunnerEvents,
   TestCollectorEvents,
+  BundlerEvents,
+  TestExecutionOptions,
 } from '@react-native-harness/bridge';
 import { getBridgeClient } from '@react-native-harness/bridge/client';
 import { store } from '../ui/state.js';
 import { getTestRunner, TestRunner } from '../runner/index.js';
 import { getTestCollector, TestCollector } from '../collector/index.js';
 import { combineEventEmitters, EventEmitter } from '../utils/emitter.js';
-import { attachProgressLogger } from '../utils/progressLogger.js';
 import { getWSServer } from './getWSServer.js';
-import { fetchModule, evaluateModule } from '../bundler/index.js';
+import { getBundler, evaluateModule, Bundler } from '../bundler/index.js';
+import { markTestsAsSkippedByName } from '../filtering/index.js';
 
 export const getClient = async () => {
   const client = await getBridgeClient(getWSServer(), {
@@ -18,7 +20,10 @@ export const getClient = async () => {
     },
   });
 
-  client.rpc.$functions.runTests = async (path: string) => {
+  client.rpc.$functions.runTests = async (
+    path: string,
+    options: TestExecutionOptions = {}
+  ) => {
     if (store.getState().status === 'running') {
       throw new Error('Already running tests');
     }
@@ -27,30 +32,108 @@ export const getClient = async () => {
 
     let collector: TestCollector | null = null;
     let runner: TestRunner | null = null;
-    let events: EventEmitter<TestRunnerEvents | TestCollectorEvents> | null =
-      null;
+    let events: EventEmitter<
+      TestRunnerEvents | TestCollectorEvents | BundlerEvents
+    > | null = null;
+    let bundler: Bundler | null = null;
 
     try {
       collector = getTestCollector();
       runner = getTestRunner();
-      events = combineEventEmitters(collector.events, runner.events);
+      bundler = getBundler();
+      events = combineEventEmitters(
+        collector.events,
+        runner.events,
+        bundler.events
+      );
 
       events.addListener((event) => {
         client.rpc.emitEvent(event.type, event);
       });
 
-      // Add console logging for progress information
-      attachProgressLogger(events, path);
+      // Execute setup files before test collection
+      if (options.setupFiles) {
+        for (const setupFile of options.setupFiles) {
+          const startTime = Date.now();
+          events.emit({
+            type: 'setup-file-bundling-started',
+            file: setupFile,
+            setupType: 'setupFiles',
+          });
+
+          try {
+            const setupModuleJs = await bundler.getModule(setupFile);
+            events.emit({
+              type: 'setup-file-bundling-finished',
+              file: setupFile,
+              setupType: 'setupFiles',
+              duration: Date.now() - startTime,
+            });
+            evaluateModule(setupModuleJs, setupFile);
+          } catch (error) {
+            const errorMessage =
+              error instanceof Error ? error.message : 'Unknown error';
+            events.emit({
+              type: 'setup-file-bundling-failed',
+              file: setupFile,
+              setupType: 'setupFiles',
+              duration: Date.now() - startTime,
+              error: errorMessage,
+            });
+            throw error;
+          }
+        }
+      }
+
+      if (options.setupFilesAfterEnv) {
+        for (const setupFile of options.setupFilesAfterEnv) {
+          const startTime = Date.now();
+          events.emit({
+            type: 'setup-file-bundling-started',
+            file: setupFile,
+            setupType: 'setupFilesAfterEnv',
+          });
 
-      const moduleJs = await fetchModule(path);
+          try {
+            const setupModuleJs = await bundler.getModule(setupFile);
+            events.emit({
+              type: 'setup-file-bundling-finished',
+              file: setupFile,
+              setupType: 'setupFilesAfterEnv',
+              duration: Date.now() - startTime,
+            });
+            evaluateModule(setupModuleJs, setupFile);
+          } catch (error) {
+            const errorMessage =
+              error instanceof Error ? error.message : 'Unknown error';
+            events.emit({
+              type: 'setup-file-bundling-failed',
+              file: setupFile,
+              setupType: 'setupFilesAfterEnv',
+              duration: Date.now() - startTime,
+              error: errorMessage,
+            });
+            throw error;
+          }
+        }
+      }
+
+      const moduleJs = await bundler.getModule(path);
       const collectionResult = await collector.collect(
         () => evaluateModule(moduleJs, path),
         path
       );
-      const result = await runner.run(collectionResult.testSuite, path);
+
+      // Apply test name pattern by marking non-matching tests as skipped
+      const processedTestSuite = options.testNamePattern
+        ? markTestsAsSkippedByName(
+            collectionResult.testSuite,
+            options.testNamePattern
+          )
+        : collectionResult.testSuite;
+
+      const result = await runner.run(processedTestSuite, path);
       return result;
-    } catch (error) {
-      throw error;
     } finally {
       collector?.dispose();
       runner?.dispose();

package/src/client/getDeviceDescriptor.ts

@@ -1,28 +1,49 @@
-import { Platform } from 'react-native';
+import { Platform, PlatformConstants, PlatformStatic } from 'react-native';
+
+interface PlatformKeplerStatic extends PlatformStatic {
+  constants: PlatformConstants;
+  OS: 'kepler';
+  Version: number;
+}
+
+const getPlatform = (): Platform | PlatformKeplerStatic => {
+  return Platform as Platform | PlatformKeplerStatic;
+};
 
 export type DeviceDescriptor = {
-  platform: 'ios' | 'android';
+  platform: 'ios' | 'android' | 'vega';
   manufacturer: string;
   model: string;
   osVersion: string;
 };
 
 export const getDeviceDescriptor = (): DeviceDescriptor => {
-  if (Platform.OS === 'ios') {
+  const platform = getPlatform();
+
+  if (platform.OS === 'ios') {
     return {
       platform: 'ios',
       manufacturer: 'Apple',
       model: 'Unknown',
-      osVersion: Platform.constants.osVersion,
+      osVersion: platform.constants.osVersion,
     };
   }
 
-  if (Platform.OS === 'android') {
+  if (platform.OS === 'android') {
     return {
       platform: 'android',
-      manufacturer: Platform.constants.Manufacturer,
-      model: Platform.constants.Model,
-      osVersion: Platform.constants.Release,
+      manufacturer: platform.constants.Manufacturer,
+      model: platform.constants.Model,
+      osVersion: platform.constants.Release,
+    };
+  }
+
+  if (platform.OS === 'kepler') {
+    return {
+      platform: 'vega',
+      manufacturer: '',
+      model: '',
+      osVersion: '',
     };
   }
 

package/src/collector/functions.ts

@@ -53,7 +53,21 @@ const computeSuiteStatus = (
 ): TestStatus => {
   if (suite.options.skip) return 'skipped';
   if (suite.options.only) return 'active';
+
+  // Check if this suite has any focused content (tests or child suites)
+  const hasFocusedTests = suite.tests.some((test) => test.options.only);
+  const hasFocusedChildren = suite.suites.some(
+    (childSuite) =>
+      childSuite.options.only ||
+      childSuite.tests.some((test) => test.options.only)
+  );
+
+  // If this suite has focused content, it should be active
+  if (hasFocusedTests || hasFocusedChildren) return 'active';
+
+  // If parent has focused children and this suite has no focused content, skip it
   if (parentContext.hasFocusedChildren) return 'skipped';
+
   return 'active';
 };
 

package/src/entry-point.ts

@@ -0,0 +1,8 @@
+import { AppRegistry } from 'react-native';
+import { getHarnessGlobal } from './globals.js';
+import { UI } from './ui/index.js';
+
+AppRegistry.registerComponent(
+  getHarnessGlobal().appRegistryComponentName,
+  () => UI
+);

package/src/expect/index.ts

@@ -1,3 +1,6 @@
+// This is adapted version of https://github.com/vitest-dev/vitest/blob/main/packages/vitest/src/integrations/chai/index.ts
+// Credits to Vitest team for the original implementation.
+
 import type { Assertion, ExpectStatic, MatcherState } from '@vitest/expect';
 import {
   addCustomEqualityTesters,
@@ -13,13 +16,16 @@ import * as chai from 'chai';
 import './setup.js';
 
 export function createExpect(): ExpectStatic {
-  const expect = ((value: any, message?: string): Assertion => {
+  const expect = ((value: unknown, message?: string): Assertion => {
     const { assertionCalls } = getState(expect);
     setState({ assertionCalls: assertionCalls + 1 }, expect);
     return chai.expect(value, message) as unknown as Assertion;
   }) as ExpectStatic;
   Object.assign(expect, chai.expect);
-  Object.assign(expect, (globalThis as any)[ASYMMETRIC_MATCHERS_OBJECT]);
+  Object.assign(
+    expect,
+    globalThis[ASYMMETRIC_MATCHERS_OBJECT as unknown as keyof typeof globalThis]
+  );
 
   expect.getState = () => getState<MatcherState>(expect);
   expect.setState = (state) => setState(state as Partial<MatcherState>, expect);

package/src/expect/setup.ts

@@ -1,3 +1,6 @@
+// This is adapted version of https://github.com/vitest-dev/vitest/blob/main/packages/vitest/src/integrations/chai/setup.ts
+// Credits to Vitest team for the original implementation.
+
 import {
   JestAsymmetricMatchers,
   JestChaiExpect,

package/src/filtering/index.ts

@@ -0,0 +1,4 @@
+export {
+  filterTestsByName,
+  markTestsAsSkippedByName,
+} from './testNameFilter.js';

package/src/filtering/testNameFilter.ts

@@ -0,0 +1,82 @@
+import { TestSuite } from '@react-native-harness/bridge';
+
+/**
+ * Filters tests by name pattern, matching against test names and suite+test combinations
+ * @deprecated Use markTestsAsSkippedByName instead - this function will be removed in a future version
+ */
+export const filterTestsByName = (
+  suite: TestSuite,
+  testNamePattern: string
+): TestSuite => {
+  const regex = new RegExp(testNamePattern);
+  return filterSuiteRecursively(suite, regex);
+};
+
+/**
+ * Marks tests as skipped based on name pattern, keeping all tests in the structure
+ * but setting non-matching tests to 'skipped' status
+ */
+export const markTestsAsSkippedByName = (
+  suite: TestSuite,
+  testNamePattern: string
+): TestSuite => {
+  const regex = new RegExp(testNamePattern);
+  return markTestsRecursively(suite, regex);
+};
+
+const markTestsRecursively = (suite: TestSuite, regex: RegExp): TestSuite => {
+  // Mark tests in current suite - skip tests that don't match the pattern
+  const updatedTests = suite.tests.map((test) => {
+    const matches =
+      regex.test(test.name) || regex.test(`${suite.name} ${test.name}`);
+
+    // If test doesn't match pattern and is currently active, mark it as skipped
+    if (!matches && test.status === 'active') {
+      return {
+        ...test,
+        status: 'skipped' as const,
+      };
+    }
+
+    // Keep original status for matching tests or already skipped/todo tests
+    return test;
+  });
+
+  // Recursively process child suites
+  const updatedChildSuites = suite.suites.map((childSuite) =>
+    markTestsRecursively(childSuite, regex)
+  );
+
+  return {
+    ...suite,
+    tests: updatedTests,
+    suites: updatedChildSuites,
+  };
+};
+
+const filterSuiteRecursively = (suite: TestSuite, regex: RegExp): TestSuite => {
+  // Filter tests in current suite - match against test name or "suite test" combination
+  const filteredTests = suite.tests.filter(
+    (test) => regex.test(test.name) || regex.test(`${suite.name} ${test.name}`)
+  );
+
+  // Recursively filter child suites
+  const filteredChildSuites = suite.suites
+    .map((childSuite) => filterSuiteRecursively(childSuite, regex))
+    .filter((childSuite) => hasAnyActiveTests(childSuite));
+
+  return {
+    ...suite,
+    tests: filteredTests,
+    suites: filteredChildSuites,
+  };
+};
+
+const hasAnyActiveTests = (suite: TestSuite): boolean => {
+  const hasDirectTests = suite.tests.some((test) => test.status === 'active');
+  const hasChildTests = suite.suites.some((childSuite) =>
+    hasAnyActiveTests(childSuite)
+  );
+
+  return hasDirectTests || hasChildTests;
+};

package/src/globals.ts

@@ -1,5 +1,17 @@
+export type HarnessGlobal = {
+  appRegistryComponentName: string;
+};
+
 declare global {
-  var RN_HARNESS: boolean | undefined;
+  var RN_HARNESS: HarnessGlobal | undefined;
 }
 
-export {};
+export const getHarnessGlobal = (): HarnessGlobal => {
+  const harnessGlobal = global.RN_HARNESS;
+
+  if (!harnessGlobal) {
+    throw new Error('RN_HARNESS global is not set');
+  }
+
+  return harnessGlobal;
+};

package/src/index.ts

@@ -5,3 +5,5 @@ export * from './spy/index.js';
 export * from './expect/index.js';
 export * from './collector/index.js';
 export * from './mocker/index.js';
+export * from './namespace.js';
+export * from './waitFor.js';

package/src/initialize.ts

@@ -1,18 +1,23 @@
 import { getDeviceDescriptor } from './client/getDeviceDescriptor.js';
 import { getClient } from './client/index.js';
+import { setupJestMock } from './jest-mock.js';
 
 // Polyfill for EventTarget
 const Shim = require('event-target-shim');
 globalThis.Event = Shim.Event;
 globalThis.EventTarget = Shim.EventTarget;
 
+// Setup jest mock to warn users about using Jest APIs
+setupJestMock();
+
 // Turn off LogBox
 const { LogBox } = require('react-native');
 LogBox.ignoreAllLogs(true);
 
 // Turn off HMR
 const HMRClientModule = require('react-native/Libraries/Utilities/HMRClient');
-const HMRClient = 'default' in HMRClientModule ? HMRClientModule.default : HMRClientModule;
+const HMRClient =
+  'default' in HMRClientModule ? HMRClientModule.default : HMRClientModule;
 
 // Wait for HMRClient to be initialized
 setTimeout(() => {
@@ -23,3 +28,8 @@ setTimeout(() => {
     client.rpc.reportReady(getDeviceDescriptor())
   );
 });
+
+// Re-throw fatal errors
+ErrorUtils.setGlobalHandler((error) => {
+  throw error;
+});

package/src/jest-mock.ts

@@ -0,0 +1,32 @@
+// Mock jest global to warn users about using Jest APIs in Harness tests
+export const setupJestMock = (): void => {
+  function throwError(): never {
+    throw new Error(
+      `Jest globals are not available in Harness tests. Import from 'react-native-harness' instead (e.g., import { harness } from 'react-native-harness'; harness.fn())`
+    );
+  }
+
+  const jestMock = new Proxy(
+    {},
+    {
+      get() {
+        throwError();
+      },
+      set() {
+        throwError();
+      },
+      has() {
+        throwError();
+      },
+      ownKeys() {
+        throwError();
+      },
+    }
+  );
+
+  Object.defineProperty(globalThis, 'jest', {
+    value: jestMock,
+    writable: false,
+    configurable: false,
+  });
+};

package/src/mocker/index.ts

@@ -1 +1,7 @@
-export { mock, requireActual, clearMocks } from './registry.js';
+export {
+  mock,
+  requireActual,
+  clearMocks,
+  unmock,
+  resetModules,
+} from './registry.js';

package/src/mocker/metro-require.d.ts

@@ -2,4 +2,6 @@ import type { Require } from './types.js';
 
 declare global {
   var __r: Require;
+  var __resetAllModules: () => void;
+  var __clearModule: (moduleId: number) => void;
 }

package/src/mocker/registry.ts

@@ -15,11 +15,7 @@ export const clearMocks = (): void => {
   mockCache.clear();
 };
 
-export const getMockRegistry = (): Map<number, ModuleFactory> => {
-  return mockRegistry;
-};
-
-export const getMockImplementation = (moduleId: number): unknown | null => {
+const getMockImplementation = (moduleId: number): unknown | null => {
   if (mockCache.has(moduleId)) {
     return mockCache.get(moduleId);
   }
@@ -39,6 +35,18 @@ export const requireActual = <T = any>(moduleId: string): T =>
   // babel plugin will transform 'moduleId' to a number
   originalRequire(moduleId as unknown as ModuleId) as T;
 
+export const unmock = (moduleId: string) => {
+  mockRegistry.delete(moduleId as unknown as ModuleId);
+  mockCache.delete(moduleId as unknown as ModuleId);
+};
+
+export const resetModules = (): void => {
+  mockCache.clear();
+
+  // Reset Metro's module cache
+  global.__resetAllModules();
+};
+
 const mockRequire = (moduleId: string) => {
   // babel plugin will transform 'moduleId' to a number
   const mockedModule = getMockImplementation(moduleId as unknown as ModuleId);

package/src/namespace.ts

@@ -0,0 +1,41 @@
+import {
+  spyOn,
+  fn,
+  clearAllMocks,
+  resetAllMocks,
+  restoreAllMocks,
+} from './spy/index.js';
+import { mock, unmock, requireActual, resetModules } from './mocker/index.js';
+import { waitFor, waitUntil } from './waitFor.js';
+
+export type HarnessNamespace = {
+  spyOn: typeof spyOn;
+  fn: typeof fn;
+  mock: typeof mock;
+  unmock: typeof unmock;
+  requireActual: typeof requireActual;
+  clearAllMocks: typeof clearAllMocks;
+  resetAllMocks: typeof resetAllMocks;
+  restoreAllMocks: typeof restoreAllMocks;
+  resetModules: typeof resetModules;
+  waitFor: typeof waitFor;
+  waitUntil: typeof waitUntil;
+};
+
+const createHarnessNamespace = (): HarnessNamespace => {
+  return {
+    spyOn,
+    fn,
+    mock,
+    unmock,
+    requireActual,
+    clearAllMocks,
+    resetAllMocks,
+    restoreAllMocks,
+    resetModules,
+    waitFor,
+    waitUntil,
+  };
+};
+
+export const harness = createHarnessNamespace();

package/src/react-native.d.ts

@@ -16,7 +16,7 @@ declare module 'react-native/Libraries/Core/Devtools/symbolicateStackTrace' {
       | {
           row: number;
           column: number;
-          [key: string]: any;
+          [key: string]: unknown;
         }
       | null
       | undefined;
@@ -30,7 +30,7 @@ declare module 'react-native/Libraries/Core/Devtools/symbolicateStackTrace' {
 
   export default function symbolicateStackTrace(
     stack: ReadonlyArray<StackFrame>,
-    extraData?: any
+    extraData?: unknown
   ): Promise<SymbolicatedStackTrace>;
 }
 
@@ -43,11 +43,3 @@ declare module 'react-native/Libraries/Core/Devtools/parseErrorStack' {
   };
   export default function parseErrorStack(errorStack?: string): StackFrame[];
 }
-
-declare global {
-  var __r:
-    | {
-        (moduleId: number): unknown;
-      }
-    | undefined;
-}

package/src/runner/factory.ts

@@ -9,10 +9,17 @@ export const getTestRunner = (): TestRunner => {
   return {
     events,
     run: async (testSuite, testFilePath) => {
-      return runSuite(testSuite, {
+      const result = await runSuite(testSuite, {
         events,
         testFilePath,
       });
+
+      // If coverage is enabled, there will be a global variable called __coverage__
+      if ('__coverage__' in global && !!global.__coverage__) {
+        result.coverage = global.__coverage__;
+      }
+
+      return result;
     },
     dispose: () => {
       events.clearAllListeners();

package/src/runner/runSuite.ts

@@ -137,6 +137,49 @@ export const runSuite = async (
     file: context.testFilePath,
   });
 
+  // Check if suite should be skipped or is todo
+  if (suite.status === 'skipped') {
+    const result = {
+      name: suite.name,
+      tests: [],
+      suites: [],
+      status: 'skipped' as const,
+      duration: 0,
+    };
+
+    // Emit suite-finished event
+    context.events.emit({
+      type: 'suite-finished',
+      file: context.testFilePath,
+      name: suite.name,
+      duration: 0,
+      status: 'skipped',
+    });
+
+    return result;
+  }
+
+  if (suite.status === 'todo') {
+    const result = {
+      name: suite.name,
+      tests: [],
+      suites: [],
+      status: 'todo' as const,
+      duration: 0,
+    };
+
+    // Emit suite-finished event
+    context.events.emit({
+      type: 'suite-finished',
+      file: context.testFilePath,
+      name: suite.name,
+      duration: 0,
+      status: 'todo',
+    });
+
+    return result;
+  }
+
   const testResults: TestResult[] = [];
   const suiteResults: TestSuiteResult[] = [];
 

package/src/symbolicate.ts

@@ -6,16 +6,18 @@ export const getCodeFrame = async (error: Error): Promise<CodeFrame | null> => {
   const parsedStack = parseErrorStack(error.stack);
   const symbolicatedStack = await symbolicateStackTrace(parsedStack);
 
-  if (!symbolicatedStack.codeFrame) {
+  if (!('codeFrame' in symbolicatedStack) || !symbolicatedStack.codeFrame) {
     return null;
   }
 
+  const codeFrame = symbolicatedStack.codeFrame as CodeFrame;
+
   // Normalize optionality (null -> undefined)
   return {
-    ...symbolicatedStack.codeFrame,
-    location: symbolicatedStack.codeFrame.location
+    ...codeFrame,
+    location: codeFrame.location
       ? {
-          ...symbolicatedStack.codeFrame.location,
+          ...codeFrame.location,
         }
       : undefined,
   };

package/src/utils/emitter.ts

@@ -26,6 +26,7 @@ export const getEmitter = <TEvents>() => {
   };
 };
 
+/* eslint-disable no-redeclare */
 export function combineEventEmitters<TEvents0, TEvents1>(
   emitter0: EventEmitter<TEvents0>,
   emitter1: EventEmitter<TEvents1>