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

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,63 @@ 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';
+
+const getAncestorTitles = (suite: TestSuite): string[] => {
+  const ancestorTitles: string[] = [];
+  let currentSuite = suite.parent;
+
+  while (currentSuite) {
+    if (currentSuite.name !== 'root') {
+      ancestorTitles.unshift(currentSuite.name);
+    }
+    currentSuite = currentSuite.parent;
+  }
+
+  if (suite.name !== 'root') {
+    ancestorTitles.push(suite.name);
+  }
+
+  return ancestorTitles;
+};
+
+const getFullName = (ancestorTitles: string[], testName: string): string =>
+  [...ancestorTitles, testName].join(' ');
+
+const emitTestFinished = (
+  context: TestRunnerContext,
+  options: {
+    test: TestCase;
+    suite: TestSuite;
+    startedAt: number;
+    duration: number;
+    status: 'passed' | 'failed' | 'skipped' | 'todo';
+    error?: TestResult['error'];
+  },
+) => {
+  const ancestorTitles = getAncestorTitles(options.suite);
+
+  context.events.emit({
+    type: 'test-finished',
+    file: context.testFilePath,
+    suite: options.suite.name,
+    name: options.test.name,
+    ancestorTitles,
+    fullName: getFullName(ancestorTitles, options.test.name),
+    startedAt: options.startedAt,
+    declarationMode: options.test.declarationMode,
+    duration: options.duration,
+    error: options.error,
+    status: options.status,
+  });
+};
 
 declare global {
   var HARNESS_TEST_PATH: string;
@@ -22,14 +79,40 @@ const runTest = async (
   suite: TestSuite,
   context: TestRunnerContext,
 ): Promise<TestResult> => {
-  const startTime = Date.now();
+  const startedAt = 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
+  const ancestorTitles = getAncestorTitles(suite);
   context.events.emit({
     type: 'test-started',
     name: test.name,
     suite: suite.name,
     file: context.testFilePath,
+    ancestorTitles,
+    fullName: getFullName(ancestorTitles, test.name),
+    startedAt,
+    declarationMode: test.declarationMode,
   });
 
   try {
@@ -38,14 +121,16 @@ const runTest = async (
         name: test.name,
         status: 'skipped' as const,
         duration: 0,
+        ancestorTitles,
+        fullName: getFullName(ancestorTitles, test.name),
+        startedAt,
+        declarationMode: test.declarationMode,
       };
 
-      // Emit test-finished event
-      context.events.emit({
-        type: 'test-finished',
-        name: test.name,
-        suite: suite.name,
-        file: context.testFilePath,
+      emitTestFinished(context, {
+        test,
+        suite,
+        startedAt,
         duration: 0,
         status: 'skipped',
       });
@@ -59,14 +144,16 @@ const runTest = async (
         name: test.name,
         status: 'todo' as const,
         duration: 0,
+        ancestorTitles,
+        fullName: getFullName(ancestorTitles, test.name),
+        startedAt,
+        declarationMode: test.declarationMode,
       };
 
-      // Emit test-finished event
-      context.events.emit({
-        type: 'test-finished',
-        name: test.name,
-        suite: suite.name,
-        file: context.testFilePath,
+      emitTestFinished(context, {
+        test,
+        suite,
+        startedAt,
         duration: 0,
         status: 'todo',
       });
@@ -78,61 +165,105 @@ 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() - startedAt;
+
+        await runOnTestFinished(lifecycleState);
+
+        const result = {
+          name: test.name,
+          status: 'skipped' as const,
+          duration,
+          ancestorTitles,
+          fullName: getFullName(ancestorTitles, test.name),
+          startedAt,
+          declarationMode: test.declarationMode,
+        };
+
+        emitTestFinished(context, {
+          test,
+          suite,
+          startedAt,
+          duration,
+          status: 'skipped',
+        });
+
+        return result;
+      }
 
       await flushExpectTestState(expectTestState);
+      await runOnTestFinished(lifecycleState);
     } finally {
       setCurrentExpectTestState(undefined);
     }
 
-    const duration = Date.now() - startTime;
+    const duration = Date.now() - startedAt;
 
     const result = {
       name: test.name,
       status: 'passed' as const,
       duration,
+      ancestorTitles,
+      fullName: getFullName(ancestorTitles, test.name),
+      startedAt,
+      declarationMode: test.declarationMode,
     };
 
-    // Emit test-finished event
-    context.events.emit({
-      type: 'test-finished',
-      file: context.testFilePath,
-      suite: suite.name,
-      name: test.name,
+    emitTestFinished(context, {
+      test,
+      suite,
+      startedAt,
       duration,
       status: 'passed',
     });
 
     return result;
   } catch (error) {
+    await runOnTestFailed(lifecycleState);
+    await runOnTestFinished(lifecycleState);
+
     const testError = await getTestExecutionError(
       error,
       context.testFilePath,
       suite.name,
       test.name,
     );
-    const duration = Date.now() - startTime;
+    const duration = Date.now() - startedAt;
 
     const result = {
       name: test.name,
       status: 'failed' as const,
       error: testError.toSerializedJSON(),
       duration,
+      ancestorTitles,
+      fullName: getFullName(ancestorTitles, test.name),
+      startedAt,
+      declarationMode: test.declarationMode,
     };
 
-    // Emit test-finished event
-    context.events.emit({
-      type: 'test-finished',
-      file: context.testFilePath,
-      suite: suite.name,
-      name: test.name,
+    emitTestFinished(context, {
+      test,
+      suite,
+      startedAt,
       duration,
       error: testError.toSerializedJSON(),
       status: 'failed',
@@ -157,10 +288,19 @@ export const runSuite = async (
 
   // Check if suite should be skipped or is todo
   if (suite.status === 'skipped') {
+    const testResults = await Promise.all(
+      suite.tests.map((test) => runTest({ ...test, status: 'skipped' }, suite, context)),
+    );
+    const suiteResults = await Promise.all(
+      suite.suites.map((childSuite) =>
+        runSuite({ ...childSuite, status: 'skipped' }, context),
+      ),
+    );
+
     const result = {
       name: suite.name,
-      tests: [],
-      suites: [],
+      tests: testResults,
+      suites: suiteResults,
       status: 'skipped' as const,
       duration: 0,
     };

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/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',
+      ),
     },
   },
 }));