@react-native-harness/runtime 1.0.0-alpha.9 → 1.0.0-canary.1761729829908

package/src/client/factory.ts

@@ -1,15 +1,19 @@
 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';
+import { setup } from '../render/setup.js';
+import { runSetupFiles } from './setup-files.js';
 
 export const getClient = async () => {
   const client = await getBridgeClient(getWSServer(), {
@@ -18,7 +22,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 +34,58 @@ 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);
+      await runSetupFiles({
+        setupFiles: options.setupFiles ?? [],
+        setupFilesAfterEnv: [],
+        events: events as EventEmitter<BundlerEvents>,
+        bundler: bundler as Bundler,
+        evaluateModule,
+      });
 
-      const moduleJs = await fetchModule(path);
-      const collectionResult = await collector.collect(
-        () => evaluateModule(moduleJs, path),
-        path
-      );
-      const result = await runner.run(collectionResult.testSuite, path);
+      const moduleJs = await bundler.getModule(path);
+      const collectionResult = await collector.collect(async () => {
+        await runSetupFiles({
+          setupFiles: [],
+          setupFilesAfterEnv: options.setupFilesAfterEnv ?? [],
+          events: events as EventEmitter<BundlerEvents>,
+          bundler: bundler as Bundler,
+          evaluateModule,
+        });
+
+        // Setup automatic cleanup for rendered components
+        setup();
+        evaluateModule(moduleJs, path);
+      }, 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/client/setup-files.ts

@@ -0,0 +1,81 @@
+import { EventEmitter } from '../utils/emitter.js';
+import { Bundler } from '../bundler/index.js';
+import { BundlerEvents } from '@react-native-harness/bridge';
+
+export type RunSetupFilesOptions = {
+  setupFiles: string[];
+  setupFilesAfterEnv: string[];
+  events: EventEmitter<BundlerEvents>;
+  bundler: Bundler;
+  evaluateModule: (moduleJs: string, filePath: string) => void;
+};
+
+export const runSetupFiles = async ({
+  setupFiles,
+  setupFilesAfterEnv,
+  events,
+  bundler,
+  evaluateModule,
+}: RunSetupFilesOptions) => {
+  for (const setupFile of 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;
+    }
+  }
+
+  for (const setupFile of setupFilesAfterEnv) {
+    const startTime = Date.now();
+    events.emit({
+      type: 'setup-file-bundling-started',
+      file: setupFile,
+      setupType: 'setupFilesAfterEnv',
+    });
+
+    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;
+    }
+  }
+};

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';
 };
 
@@ -356,11 +370,13 @@ const countTests = (suite: TestSuite): number => {
   return count;
 };
 
-export const collectTests = (fn: () => void): CollectionResult => {
+export const collectTests = async (
+  fn: () => void | Promise<void>
+): Promise<CollectionResult> => {
   currentContext = clearState();
 
   try {
-    fn();
+    await fn();
 
     // Convert raw structure to final structure using computation phase
     const testSuite = convertRawTestSuiteToTestSuite(getRootSuite());

package/src/collector/types.ts

@@ -10,6 +10,9 @@ export type TestCollectorEventsEmitter = EventEmitter<TestCollectorEvents>;
 
 export type TestCollector = {
   events: TestCollectorEventsEmitter;
-  collect: (fn: () => void, testFilePath: string) => Promise<CollectionResult>;
+  collect: (
+    fn: () => void | Promise<void>,
+    testFilePath: string
+  ) => Promise<CollectionResult>;
   dispose: () => void;
 };

package/src/constants.ts

@@ -1,2 +1 @@
-export const LOGO_IMAGE = require('../assets/logo.png');
 export const WS_SERVER_PORT = 3001;

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,6 @@ 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';
+export * from './render/index.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;
-}