@react-native-harness/runtime 1.2.0-rc.1 → 1.3.0

package/src/collector/functions.ts

@@ -2,6 +2,7 @@ import type {
   TestCase,
   TestSuite,
   CollectionResult,
+  SuiteHookFn,
 } from '@react-native-harness/bridge';
 import type { TestFn } from './types.js';
 import { TestError } from './errors.js';
@@ -24,8 +25,8 @@ type RawTestSuite = {
   tests: RawTestCase[];
   suites: RawTestSuite[];
   hooks: {
-    beforeAll: TestFn[];
-    afterAll: TestFn[];
+    beforeAll: SuiteHookFn[];
+    afterAll: SuiteHookFn[];
     beforeEach: TestFn[];
     afterEach: TestFn[];
   };
@@ -316,7 +317,7 @@ export const test = Object.assign(
 
 export const it = test;
 
-export function beforeAll(fn: TestFn) {
+export function beforeAll(fn: SuiteHookFn) {
   validateTestFunction(fn, 'beforeAll');
 
   const currentSuite = getCurrentSuite();
@@ -326,7 +327,7 @@ export function beforeAll(fn: TestFn) {
   currentSuite.hooks.beforeAll.push(fn);
 }
 
-export function afterAll(fn: TestFn) {
+export function afterAll(fn: SuiteHookFn) {
   validateTestFunction(fn, 'afterAll');
 
   const currentSuite = getCurrentSuite();

package/src/collector/types.ts

@@ -2,9 +2,12 @@ import { EventEmitter } from '../utils/emitter.js';
 import {
   TestCollectorEvents,
   CollectionResult,
+  type HarnessTestContext,
 } from '@react-native-harness/bridge';
 
-export type TestFn = () => void | Promise<void>;
+export type TestFn = (context: HarnessTestContext) => void | Promise<void>;
+
+export type SuiteHookFn = () => void | Promise<void>;
 
 export type TestCollectorEventsEmitter = EventEmitter<TestCollectorEvents>;
 

package/src/collector/validation.ts

@@ -1,5 +1,5 @@
 import { TestError } from './errors.js';
-import { TestFn } from './types.js';
+import { TestFn, SuiteHookFn } from './types.js';
 
 export const validateTestName = (name: string, functionName: string): void => {
   if (!name || typeof name !== 'string' || name.trim() === '') {
@@ -10,7 +10,7 @@ export const validateTestName = (name: string, functionName: string): void => {
 };
 
 export const validateTestFunction = (
-  fn: TestFn,
+  fn: TestFn | SuiteHookFn,
   functionName: string
 ): void => {
   if (typeof fn !== 'function') {

package/src/expect/matchers/toMatchImageSnapshot.ts

@@ -1,9 +1,6 @@
-import { getClientInstance } from '../../client/store.js';
+import { getHandle } from '../../client/store.js';
 import type { MatcherState } from '@vitest/expect';
-import {
-  type ImageSnapshotOptions,
-  generateTransferId,
-} from '@react-native-harness/bridge';
+import type { ImageSnapshotOptions } from '@react-native-harness/bridge';
 import { getHarnessContext } from '../../runner/index.js';
 
 type ScreenshotResult = {
@@ -17,30 +14,19 @@ export async function toMatchImageSnapshot(
   received: ScreenshotResult,
   options: ImageSnapshotOptions
 ): Promise<{ pass: boolean; message: () => string }> {
-  const client = getClientInstance();
+  const handle = getHandle();
   const context = getHarnessContext();
 
-  const transferId = generateTransferId();
-  client.sendBinary(transferId, received.data);
+  const screenshotFile = await handle.transferScreenshot(received.data, {
+    width: received.width,
+    height: received.height,
+  });
 
-  const screenshotFile = await client.rpc['device.screenshot.receive'](
-    {
-      type: 'binary',
-      transferId,
-      size: received.data.length,
-      mimeType: 'image/png',
-    },
-    {
-      width: received.width,
-      height: received.height,
-    }
-  );
-
-  const result = await client.rpc['test.matchImageSnapshot'](
+  const result = await handle.matchImageSnapshot(
     screenshotFile,
     context.testFilePath,
     options,
-    context.runner
+    context.runner,
   );
 
   return {

package/src/initialize.ts

@@ -3,10 +3,19 @@ import { getClient } from './client/index.js';
 import { disableHMRWhenReady } from './disableHMRWhenReady.js';
 import { setupJestMock } from './jest-mock.js';
 
-// Polyfill for EventTarget
+// Polyfill for EventTarget on runtimes that don't ship one (RN's JSC).
+// Do NOT overwrite when a native ctor already exists (RN Web / browsers):
+// Safari's EventTarget.dispatchEvent() does an internal brand check and
+// rejects polyfill instances with a TypeError, which breaks any
+// DOM-event-driven flow in the page — most visibly DRM (FairPlay) via
+// libraries that re-dispatch synthetic `encrypted` events.
 const Shim = require('event-target-shim');
-globalThis.Event = Shim.Event;
-globalThis.EventTarget = Shim.EventTarget;
+if (typeof globalThis.Event !== 'function') {
+  globalThis.Event = Shim.Event;
+}
+if (typeof globalThis.EventTarget !== 'function') {
+  globalThis.EventTarget = Shim.EventTarget;
+}
 
 // Setup jest mock to warn users about using Jest APIs
 setupJestMock();
@@ -25,10 +34,10 @@ setTimeout(() => {
   void (async () => {
     try {
       await disableHMRWhenReady(() => HMRClient.disable(), 50);
-      const client = await getClient();
+      const handle = await getClient();
 
       const deviceDescriptor = getDeviceDescriptor();
-      await client.rpc.reportReady(deviceDescriptor);
+      handle.reportReady(deviceDescriptor);
     } catch (error) {
       console.error('Failed to initialize React Native Harness', error);
     }

package/src/jsx/jsx-dev-runtime.ts

@@ -1,26 +1,45 @@
 import * as ReactJSXRuntimeDev from 'react/jsx-dev-runtime';
 
+type NamedElementType = {
+  displayName?: string;
+  name?: string;
+};
+
+const isNamedElementType = (value: unknown): value is NamedElementType =>
+  (typeof value === 'function' ||
+    (typeof value === 'object' && value !== null)) &&
+  ('displayName' in value || 'name' in value);
+
+const isPropsObject = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null;
+
 export const Fragment = ReactJSXRuntimeDev.Fragment;
 
-export function jsxDEV(
-  type: any,
-  props: any,
-  key: any,
-  isStaticChildren: any,
-  source: any,
-  self: any
-) {
-  if (
-    type &&
-    (type.displayName === 'View' || type.name === 'View') &&
-    props &&
+export function jsxDEV(...args: Parameters<typeof ReactJSXRuntimeDev.jsxDEV>) {
+  const [type, props, key, isStaticChildren, source, self] = args;
+  const isViewType =
+    isNamedElementType(type) &&
+    (type.displayName === 'View' || type.name === 'View');
+  const nextProps =
+    isViewType &&
+    isPropsObject(props) &&
     props.collapsable === undefined
-  ) {
-    props = { ...props, collapsable: true };
+      ? { ...props, collapsable: true }
+      : props;
+
+  if (isViewType && isPropsObject(props) && props.collapsable === undefined) {
+    return ReactJSXRuntimeDev.jsxDEV(
+      type,
+      nextProps,
+      key,
+      isStaticChildren,
+      source,
+      self
+    );
   }
   return ReactJSXRuntimeDev.jsxDEV(
     type,
-    props,
+    nextProps,
     key,
     isStaticChildren,
     source,

package/src/runner/hooks.ts

@@ -1,12 +1,33 @@
-import type { TestSuite } from '@react-native-harness/bridge';
+import type { SuiteHookFn, TestFn, TestSuite } from '@react-native-harness/bridge';
+import type { ActiveTestContext } from './types.js';
 
 export type HookType = 'beforeEach' | 'afterEach' | 'beforeAll' | 'afterAll';
 
 const collectInheritedHooks = (
   suite: TestSuite,
-  hookType: HookType
-): (() => void | Promise<void>)[] => {
-  const hooks: (() => void | Promise<void>)[] = [];
+  hookType: 'beforeEach' | 'afterEach'
+): TestFn[] => {
+  const hooks: TestFn[] = [];
+  const suiteChain: TestSuite[] = [];
+
+  let current: TestSuite | undefined = suite;
+  while (current) {
+    suiteChain.unshift(current);
+    current = current.parent;
+  }
+
+  for (const currentSuite of suiteChain) {
+    hooks.push(...currentSuite[hookType]);
+  }
+
+  return hooks;
+};
+
+const collectSuiteHooks = (
+  suite: TestSuite,
+  hookType: 'beforeAll' | 'afterAll'
+): SuiteHookFn[] => {
+  const hooks: SuiteHookFn[] = [];
   const suiteChain: TestSuite[] = [];
 
   // Collect all suites from current to root
@@ -16,23 +37,15 @@ const collectInheritedHooks = (
     currentSuite = currentSuite.parent;
   }
 
-  if (hookType === 'beforeEach' || hookType === 'beforeAll') {
-    // For beforeEach/beforeAll: run parent hooks first (reverse the chain)
+  if (hookType === 'beforeAll') {
+    // Run parent suite hooks before child suite hooks.
     for (let i = suiteChain.length - 1; i >= 0; i--) {
-      if (hookType === 'beforeEach') {
-        hooks.push(...suiteChain[i].beforeEach);
-      } else {
-        hooks.push(...suiteChain[i].beforeAll);
-      }
+      hooks.push(...suiteChain[i].beforeAll);
     }
   } else {
-    // For afterEach/afterAll: run child hooks first (use chain as-is)
+    // Run child suite hooks before parent suite hooks.
     for (const suiteInChain of suiteChain) {
-      if (hookType === 'afterEach') {
-        hooks.push(...suiteInChain.afterEach);
-      } else {
-        hooks.push(...suiteInChain.afterAll);
-      }
+      hooks.push(...suiteInChain.afterAll);
     }
   }
 
@@ -41,11 +54,22 @@ const collectInheritedHooks = (
 
 export const runHooks = async (
   suite: TestSuite,
-  hookType: HookType
+  hookType: HookType,
+  context?: ActiveTestContext,
 ): Promise<void> => {
+  if (hookType === 'beforeAll' || hookType === 'afterAll') {
+    const hooks = collectSuiteHooks(suite, hookType);
+
+    for (const hook of hooks) {
+      await hook();
+    }
+
+    return;
+  }
+
   const hooks = collectInheritedHooks(suite, hookType);
 
   for (const hook of hooks) {
-    await hook();
+    await hook(context as ActiveTestContext);
   }
 };

package/src/runner/runSuite.ts

@@ -1,4 +1,5 @@
 import type {
+  HarnessTaskContext,
   TestCase,
   TestResult,
   TestSuite,
@@ -11,7 +12,14 @@ import {
 import { flushExpectTestState } from '../expect/errors.js';
 import { runHooks } from './hooks.js';
 import { getTestExecutionError } from './errors.js';
-import { TestRunnerContext } from './types.js';
+import { ActiveTestContext, TestRunnerContext } from './types.js';
+import {
+  createTestContext,
+  createTestLifecycleState,
+  isSkipTestError,
+  runOnTestFailed,
+  runOnTestFinished,
+} from './test-context.js';
 
 declare global {
   var HARNESS_TEST_PATH: string;
@@ -23,6 +31,27 @@ const runTest = async (
   context: TestRunnerContext,
 ): Promise<TestResult> => {
   const startTime = Date.now();
+  const task: HarnessTaskContext = {
+    name: test.name,
+    type: 'test',
+    mode:
+      test.status === 'active'
+        ? 'run'
+        : test.status === 'skipped'
+          ? 'skip'
+          : 'todo',
+    file: {
+      name: context.testFilePath,
+    },
+    suite: {
+      name: suite.name,
+    },
+  };
+  const lifecycleState = createTestLifecycleState();
+  const activeTestContext: ActiveTestContext = createTestContext(
+    task,
+    lifecycleState,
+  );
 
   // Emit test-started event
   context.events.emit({
@@ -78,16 +107,50 @@ const runTest = async (
     setCurrentExpectTestState(expectTestState);
 
     try {
-      // Run all beforeEach hooks from the current suite and its parents
-      await runHooks(suite, 'beforeEach');
-
-      // Run the actual test
-      await test.fn();
-
-      // Run all afterEach hooks from the current suite and its parents
-      await runHooks(suite, 'afterEach');
+      let didSkip = false;
+
+      try {
+        // Run all beforeEach hooks from the current suite and its parents
+        await runHooks(suite, 'beforeEach', activeTestContext);
+
+        // Run the actual test
+        await test.fn(activeTestContext);
+      } catch (error) {
+        if (!isSkipTestError(error)) {
+          throw error;
+        }
+
+        didSkip = true;
+      } finally {
+        // Run all afterEach hooks from the current suite and its parents
+        await runHooks(suite, 'afterEach', activeTestContext);
+      }
+
+      if (didSkip) {
+        const duration = Date.now() - startTime;
+
+        await runOnTestFinished(lifecycleState);
+
+        const result = {
+          name: test.name,
+          status: 'skipped' as const,
+          duration,
+        };
+
+        context.events.emit({
+          type: 'test-finished',
+          file: context.testFilePath,
+          suite: suite.name,
+          name: test.name,
+          duration,
+          status: 'skipped',
+        });
+
+        return result;
+      }
 
       await flushExpectTestState(expectTestState);
+      await runOnTestFinished(lifecycleState);
     } finally {
       setCurrentExpectTestState(undefined);
     }
@@ -112,6 +175,9 @@ const runTest = async (
 
     return result;
   } catch (error) {
+    await runOnTestFailed(lifecycleState);
+    await runOnTestFinished(lifecycleState);
+
     const testError = await getTestExecutionError(
       error,
       context.testFilePath,

package/src/runner/test-context.ts

@@ -0,0 +1,84 @@
+import type { HarnessTaskContext } from '@react-native-harness/bridge';
+import type { ActiveTestContext } from './types.js';
+
+export type TestLifecycleState = {
+  onTestFailed: Array<() => void | Promise<void>>;
+  onTestFinished: Array<() => void | Promise<void>>;
+};
+
+export class SkipTestError extends Error {
+  note?: string;
+
+  constructor(note?: string) {
+    super(note ?? 'Test skipped');
+    this.name = 'SkipTestError';
+    this.note = note;
+  }
+}
+
+export const isSkipTestError = (error: unknown): error is SkipTestError => {
+  return error instanceof SkipTestError;
+};
+
+const createSkip = () => {
+  function skip(noteOrCondition?: boolean | string, note?: string): void {
+    if (typeof noteOrCondition === 'boolean') {
+      if (!noteOrCondition) {
+        return;
+      }
+
+      throw new SkipTestError(note);
+    }
+
+    throw new SkipTestError(noteOrCondition);
+  }
+
+  return skip as ActiveTestContext['skip'];
+};
+
+const createOnTestFinished = (state: TestLifecycleState) => {
+  return (fn: () => void | Promise<void>): void => {
+    state.onTestFinished.push(fn);
+  };
+};
+
+const createOnTestFailed = (state: TestLifecycleState) => {
+  return (fn: () => void | Promise<void>): void => {
+    state.onTestFailed.push(fn);
+  };
+};
+
+export const createTestLifecycleState = (): TestLifecycleState => {
+  return {
+    onTestFailed: [],
+    onTestFinished: [],
+  };
+};
+
+export const runOnTestFailed = async (
+  state: TestLifecycleState,
+): Promise<void> => {
+  for (let i = state.onTestFailed.length - 1; i >= 0; i--) {
+    await state.onTestFailed[i]();
+  }
+};
+
+export const runOnTestFinished = async (
+  state: TestLifecycleState,
+): Promise<void> => {
+  for (let i = state.onTestFinished.length - 1; i >= 0; i--) {
+    await state.onTestFinished[i]();
+  }
+};
+
+export const createTestContext = (
+  task: HarnessTaskContext,
+  state: TestLifecycleState,
+): ActiveTestContext => {
+  return {
+    task,
+    onTestFailed: createOnTestFailed(state),
+    onTestFinished: createOnTestFinished(state),
+    skip: createSkip(),
+  };
+};

package/src/runner/types.ts

@@ -1,5 +1,6 @@
 import { EventEmitter } from '../utils/emitter.js';
 import type {
+  HarnessTestContext,
   TestRunnerEvents,
   TestSuite,
   TestSuiteResult,
@@ -12,6 +13,8 @@ export type TestRunnerContext = {
   testFilePath: string;
 };
 
+export type ActiveTestContext = HarnessTestContext;
+
 export type RunTestsOptions = {
   testSuite: TestSuite;
   testFilePath: string;

package/src/test-utils/react-native-url-polyfill.ts

@@ -0,0 +1 @@
+export const URL = globalThis.URL;

package/src/waitFor.ts

@@ -114,6 +114,12 @@ export interface WaitUntilOptions
 
 type Truthy<T> = T extends false | '' | 0 | null | undefined ? never : T;
 
+const isPromiseLike = <T>(value: T | PromiseLike<T>): value is PromiseLike<T> =>
+  value !== null &&
+  typeof value === 'object' &&
+  'then' in value &&
+  typeof value.then === 'function';
+
 export function waitUntil<T>(
   callback: WaitUntilCallback<T>,
   options: number | WaitUntilOptions = {}
@@ -164,12 +170,8 @@ export function waitUntil<T>(
       }
       try {
         const result = callback();
-        if (
-          result !== null &&
-          typeof result === 'object' &&
-          typeof (result as any).then === 'function'
-        ) {
-          const thenable = result as PromiseLike<T>;
+        if (isPromiseLike(result)) {
+          const thenable = result;
           promiseStatus = 'pending';
           thenable.then(
             (resolvedValue) => {

package/vite.config.ts

@@ -22,6 +22,10 @@ export default defineConfig(() => ({
     alias: {
       '@vitest/spy': path.resolve(__dirname, 'node_modules/@vitest/spy'),
       '@vitest/expect': path.resolve(__dirname, 'node_modules/@vitest/expect'),
+      'react-native-url-polyfill': path.resolve(
+        __dirname,
+        'src/test-utils/react-native-url-polyfill.ts',
+      ),
     },
   },
 }));