@react-native-harness/runtime 1.2.0 → 1.3.0

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