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

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/filtering/index.ts

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

package/src/filtering/testNameFilter.ts

@@ -0,0 +1,37 @@
+import { TestSuite } from '@react-native-harness/bridge';
+
+/**
+ * Filters tests by name pattern, matching against test names and suite+test combinations
+ */
+export const filterTestsByName = (
+  suite: TestSuite, 
+  testNamePattern: string
+): TestSuite => {
+  const regex = new RegExp(testNamePattern);
+  return filterSuiteRecursively(suite, regex);
+};
+
+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/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/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,5 @@ import type { Require } from './types.js';
 
 declare global {
   var __r: Require;
+  var __resetAllModules: () => 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/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/waitFor.ts

@@ -0,0 +1,194 @@
+// This is adapted implementation of waitFor from Vitest, which can be found here:
+// https://github.com/vitest-dev/vitest/blob/main/packages/vitest/src/integrations/wait.ts
+
+export type WaitForCallback<T> = () => T | Promise<T>;
+
+export interface WaitForOptions {
+  /**
+   * @description Time in ms between each check callback
+   * @default 50ms
+   */
+  interval?: number;
+  /**
+   * @description Time in ms after which the throw a timeout error
+   * @default 1000ms
+   */
+  timeout?: number;
+}
+
+function copyStackTrace(target: Error, source: Error) {
+  if (source.stack !== undefined) {
+    target.stack = source.stack.replace(source.message, target.message);
+  }
+  return target;
+}
+
+export function waitFor<T>(
+  callback: WaitForCallback<T>,
+  options: number | WaitForOptions = {}
+): Promise<T> {
+  const { interval = 50, timeout = 1000 } =
+    typeof options === 'number' ? { timeout: options } : options;
+  const STACK_TRACE_ERROR = new Error('STACK_TRACE_ERROR');
+
+  return new Promise<T>((resolve, reject) => {
+    let lastError: unknown;
+    let promiseStatus: 'idle' | 'pending' | 'resolved' | 'rejected' = 'idle';
+    let timeoutId: ReturnType<typeof setTimeout>;
+    let intervalId: ReturnType<typeof setInterval>;
+
+    const onResolve = (result: T): void => {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      if (intervalId) {
+        clearInterval(intervalId);
+      }
+
+      resolve(result);
+    };
+
+    const handleTimeout = (): void => {
+      if (intervalId) {
+        clearInterval(intervalId);
+      }
+      let error = lastError;
+      if (!error) {
+        error = copyStackTrace(
+          new Error('Timed out in waitFor!'),
+          STACK_TRACE_ERROR
+        );
+      }
+
+      reject(error);
+    };
+
+    const checkCallback = (): boolean | void => {
+      if (promiseStatus === 'pending') {
+        return;
+      }
+      try {
+        const result = callback();
+        if (
+          result !== null &&
+          typeof result === 'object' &&
+          typeof (result as any).then === 'function'
+        ) {
+          const thenable = result as PromiseLike<T>;
+          promiseStatus = 'pending';
+          thenable.then(
+            (resolvedValue) => {
+              promiseStatus = 'resolved';
+              onResolve(resolvedValue);
+            },
+            (rejectedValue) => {
+              promiseStatus = 'rejected';
+              lastError = rejectedValue;
+            }
+          );
+        } else {
+          onResolve(result as T);
+          return true;
+        }
+      } catch (error) {
+        lastError = error;
+      }
+    };
+
+    if (checkCallback() === true) {
+      return;
+    }
+
+    timeoutId = setTimeout(handleTimeout, timeout);
+    intervalId = setInterval(checkCallback, interval);
+  });
+}
+
+export type WaitUntilCallback<T> = () => T | Promise<T>;
+
+export interface WaitUntilOptions
+  extends Pick<WaitForOptions, 'interval' | 'timeout'> {}
+
+type Truthy<T> = T extends false | '' | 0 | null | undefined ? never : T;
+
+export function waitUntil<T>(
+  callback: WaitUntilCallback<T>,
+  options: number | WaitUntilOptions = {}
+): Promise<Truthy<T>> {
+  const { interval = 50, timeout = 1000 } =
+    typeof options === 'number' ? { timeout: options } : options;
+  const STACK_TRACE_ERROR = new Error('STACK_TRACE_ERROR');
+
+  return new Promise<Truthy<T>>((resolve, reject) => {
+    let promiseStatus: 'idle' | 'pending' | 'resolved' | 'rejected' = 'idle';
+    let timeoutId: ReturnType<typeof setTimeout>;
+    let intervalId: ReturnType<typeof setInterval>;
+
+    const onReject = (error?: Error) => {
+      if (intervalId) {
+        clearInterval(intervalId);
+      }
+      if (!error) {
+        error = copyStackTrace(
+          new Error('Timed out in waitUntil!'),
+          STACK_TRACE_ERROR
+        );
+      }
+      reject(error);
+    };
+
+    const onResolve = (result: T): true | void => {
+      if (!result) {
+        return;
+      }
+
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      if (intervalId) {
+        clearInterval(intervalId);
+      }
+
+      resolve(result as Truthy<T>);
+      return true;
+    };
+
+    const checkCallback = (): boolean | void => {
+      if (promiseStatus === 'pending') {
+        return;
+      }
+      try {
+        const result = callback();
+        if (
+          result !== null &&
+          typeof result === 'object' &&
+          typeof (result as any).then === 'function'
+        ) {
+          const thenable = result as PromiseLike<T>;
+          promiseStatus = 'pending';
+          thenable.then(
+            (resolvedValue) => {
+              promiseStatus = 'resolved';
+              onResolve(resolvedValue);
+            },
+            (rejectedValue) => {
+              promiseStatus = 'rejected';
+              onReject(rejectedValue);
+            }
+          );
+        } else {
+          return onResolve(result as T);
+        }
+      } catch (error) {
+        onReject(error as Error);
+      }
+    };
+
+    if (checkCallback() === true) {
+      return;
+    }
+
+    timeoutId = setTimeout(onReject, timeout);
+    intervalId = setInterval(checkCallback, interval);
+  });
+}