@react-native-harness/runtime 1.2.0 → 1.3.0

package/out-tsc/vitest/vite.config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vite.config.d.ts","sourceRoot":"","sources":["../../vite.config.ts"],"names":[],"mappings":";AAIA,wBAsBI"}
+{"version":3,"file":"vite.config.d.ts","sourceRoot":"","sources":["../../vite.config.ts"],"names":[],"mappings":";AAIA,wBA0BI"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@react-native-harness/runtime",
   "description": "The core test runtime that executes on React Native devices, providing Jest-compatible APIs (describe, it, expect) and managing test collection, execution, and result reporting in native environments.",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -47,7 +47,7 @@
     "react-native-url-polyfill": "^3.0.0",
     "use-sync-external-store": "^1.6.0",
     "zustand": "^5.0.5",
-    "@react-native-harness/bridge": "1.2.0"
+    "@react-native-harness/bridge": "1.3.0"
   },
   "devDependencies": {
     "@types/chai": "^5.2.2"

package/src/__tests__/runner-context.test.ts

@@ -0,0 +1,483 @@
+import {
+  afterEach,
+  beforeEach,
+  describe as harnessDescribe,
+  getTestCollector,
+  it as harnessIt,
+} from '../collector/index.js';
+import type { HarnessTestContext } from '@react-native-harness/bridge';
+import { getTestRunner } from '../runner/index.js';
+import { describe, expect, it, vi } from 'vitest';
+
+vi.mock('../symbolicate.js', async () => {
+  return {
+    getCodeFrame: vi.fn(async () => null),
+  };
+});
+
+const getTask = (context: HarnessTestContext) => {
+  return context.task;
+};
+
+const getTaskContext = (context: HarnessTestContext) => {
+  return context;
+};
+
+describe('runner task context', () => {
+  it('passes minimal task metadata to tests and per-test hooks', async () => {
+    const observedTasks: Array<{
+      source: 'beforeEach' | 'test' | 'afterEach';
+      task: {
+        name: string;
+        type: 'test';
+        mode: 'run' | 'skip' | 'todo';
+        file: { name: string };
+        suite: { name: string };
+      };
+    }> = [];
+    const collector = getTestCollector();
+    const runner = getTestRunner();
+
+    try {
+      const collection = await collector.collect(() => {
+        harnessDescribe('Task Context Suite', () => {
+          beforeEach((context: HarnessTestContext) => {
+            observedTasks.push({ source: 'beforeEach', task: getTask(context) });
+          });
+
+          afterEach((context: HarnessTestContext) => {
+            observedTasks.push({ source: 'afterEach', task: getTask(context) });
+          });
+
+          harnessIt('exposes task metadata', (context: HarnessTestContext) => {
+            observedTasks.push({ source: 'test', task: getTask(context) });
+          });
+        });
+      }, 'runtime/context.test.ts');
+
+      const result = await runner.run({
+        testSuite: collection.testSuite,
+        testFilePath: 'runtime/context.test.ts',
+        runner: 'ios',
+      });
+
+      expect(result.status).toBe('passed');
+      expect(result.suites[0].tests[0]).toMatchObject({
+        name: 'exposes task metadata',
+        status: 'passed',
+      });
+      expect(observedTasks).toEqual([
+        {
+          source: 'beforeEach',
+          task: {
+            name: 'exposes task metadata',
+            type: 'test',
+            mode: 'run',
+            file: { name: 'runtime/context.test.ts' },
+            suite: { name: 'Task Context Suite' },
+          },
+        },
+        {
+          source: 'test',
+          task: {
+            name: 'exposes task metadata',
+            type: 'test',
+            mode: 'run',
+            file: { name: 'runtime/context.test.ts' },
+            suite: { name: 'Task Context Suite' },
+          },
+        },
+        {
+          source: 'afterEach',
+          task: {
+            name: 'exposes task metadata',
+            type: 'test',
+            mode: 'run',
+            file: { name: 'runtime/context.test.ts' },
+            suite: { name: 'Task Context Suite' },
+          },
+        },
+      ]);
+    } finally {
+      collector.dispose();
+      runner.dispose();
+    }
+  });
+
+  it('keeps zero-argument tests and hooks working', async () => {
+    const calls: string[] = [];
+    const collector = getTestCollector();
+    const runner = getTestRunner();
+
+    try {
+      const collection = await collector.collect(() => {
+        harnessDescribe('Compatibility Suite', () => {
+          beforeEach(() => {
+            calls.push('beforeEach');
+          });
+
+          afterEach(() => {
+            calls.push('afterEach');
+          });
+
+          harnessIt('still runs', () => {
+            calls.push('test');
+          });
+        });
+      }, 'runtime/compatibility.test.ts');
+
+      const result = await runner.run({
+        testSuite: collection.testSuite,
+        testFilePath: 'runtime/compatibility.test.ts',
+        runner: 'android',
+      });
+
+      expect(result.suites[0].tests[0]).toMatchObject({ status: 'passed' });
+      expect(calls).toEqual(['beforeEach', 'test', 'afterEach']);
+    } finally {
+      collector.dispose();
+      runner.dispose();
+    }
+  });
+
+  it('marks dynamically skipped tests as skipped and still runs afterEach', async () => {
+    const calls: string[] = [];
+    const collector = getTestCollector();
+    const runner = getTestRunner();
+
+    try {
+      const collection = await collector.collect(() => {
+        harnessDescribe('Skip Suite', () => {
+          afterEach(() => {
+            calls.push('afterEach');
+          });
+
+          harnessIt('skips from context', (context: HarnessTestContext) => {
+            const { skip } = getTaskContext(context);
+
+            calls.push('before-skip');
+            skip('skip this test');
+            calls.push('after-skip');
+          });
+
+          harnessIt('still runs sibling test', () => {
+            calls.push('sibling');
+          });
+        });
+      }, 'runtime/skip.test.ts');
+
+      const result = await runner.run({
+        testSuite: collection.testSuite,
+        testFilePath: 'runtime/skip.test.ts',
+        runner: 'ios',
+      });
+
+      expect(result.suites[0].tests).toMatchObject([
+        { name: 'skips from context', status: 'skipped' },
+        { name: 'still runs sibling test', status: 'passed' },
+      ]);
+      expect(calls).toEqual([
+        'before-skip',
+        'afterEach',
+        'sibling',
+        'afterEach',
+      ]);
+    } finally {
+      collector.dispose();
+      runner.dispose();
+    }
+  });
+
+  it('supports conditional skipping without changing false conditions', async () => {
+    const calls: string[] = [];
+    const collector = getTestCollector();
+    const runner = getTestRunner();
+
+    try {
+      const collection = await collector.collect(() => {
+        harnessDescribe('Conditional Skip Suite', () => {
+          harnessIt('continues when condition is false', (context: HarnessTestContext) => {
+            const { skip } = getTaskContext(context);
+
+            calls.push('before');
+            skip(false, 'do not skip');
+            calls.push('after');
+          });
+        });
+      }, 'runtime/conditional-skip.test.ts');
+
+      const result = await runner.run({
+        testSuite: collection.testSuite,
+        testFilePath: 'runtime/conditional-skip.test.ts',
+        runner: 'android',
+      });
+
+      expect(result.suites[0].tests[0]).toMatchObject({ status: 'passed' });
+      expect(calls).toEqual(['before', 'after']);
+    } finally {
+      collector.dispose();
+      runner.dispose();
+    }
+  });
+
+  it('runs onTestFinished after afterEach for passing tests', async () => {
+    const calls: string[] = [];
+    const collector = getTestCollector();
+    const runner = getTestRunner();
+
+    try {
+      const collection = await collector.collect(() => {
+        harnessDescribe('Finished Suite', () => {
+          afterEach(() => {
+            calls.push('afterEach');
+          });
+
+          harnessIt('runs finished callbacks', (context: HarnessTestContext) => {
+            const { onTestFinished } = getTaskContext(context);
+
+            onTestFinished(() => {
+              calls.push('onTestFinished:first');
+            });
+            onTestFinished(() => {
+              calls.push('onTestFinished:second');
+            });
+
+            calls.push('test');
+          });
+        });
+      }, 'runtime/on-test-finished-pass.test.ts');
+
+      const result = await runner.run({
+        testSuite: collection.testSuite,
+        testFilePath: 'runtime/on-test-finished-pass.test.ts',
+        runner: 'ios',
+      });
+
+      expect(result.suites[0].tests[0]).toMatchObject({ status: 'passed' });
+      expect(calls).toEqual([
+        'test',
+        'afterEach',
+        'onTestFinished:second',
+        'onTestFinished:first',
+      ]);
+    } finally {
+      collector.dispose();
+      runner.dispose();
+    }
+  });
+
+  it('runs onTestFinished for dynamically skipped tests', async () => {
+    const calls: string[] = [];
+    const collector = getTestCollector();
+    const runner = getTestRunner();
+
+    try {
+      const collection = await collector.collect(() => {
+        harnessDescribe('Finished Skip Suite', () => {
+          afterEach(() => {
+            calls.push('afterEach');
+          });
+
+          harnessIt(
+            'runs finished callback after skip',
+            (context: HarnessTestContext) => {
+              const { onTestFinished, skip } = getTaskContext(context);
+
+            onTestFinished(() => {
+              calls.push('onTestFinished');
+            });
+
+            calls.push('before-skip');
+            skip();
+            },
+          );
+        });
+      }, 'runtime/on-test-finished-skip.test.ts');
+
+      const result = await runner.run({
+        testSuite: collection.testSuite,
+        testFilePath: 'runtime/on-test-finished-skip.test.ts',
+        runner: 'android',
+      });
+
+      expect(result.suites[0].tests[0]).toMatchObject({ status: 'skipped' });
+      expect(calls).toEqual(['before-skip', 'afterEach', 'onTestFinished']);
+    } finally {
+      collector.dispose();
+      runner.dispose();
+    }
+  });
+
+  it('runs onTestFinished for failed tests', async () => {
+    const calls: string[] = [];
+    const collector = getTestCollector();
+    const runner = getTestRunner();
+
+    try {
+      const collection = await collector.collect(() => {
+        harnessDescribe('Finished Failure Suite', () => {
+          afterEach(() => {
+            calls.push('afterEach');
+          });
+
+          harnessIt(
+            'runs finished callback after failure',
+            (context: HarnessTestContext) => {
+              const { onTestFinished } = getTaskContext(context);
+
+            onTestFinished(() => {
+              calls.push('onTestFinished');
+            });
+
+            calls.push('test');
+            throw new Error('expected failure');
+            },
+          );
+        });
+      }, 'runtime/on-test-finished-failure.test.ts');
+
+      const result = await runner.run({
+        testSuite: collection.testSuite,
+        testFilePath: 'runtime/on-test-finished-failure.test.ts',
+        runner: 'ios',
+      });
+
+      expect(result.suites[0].tests[0]).toMatchObject({ status: 'failed' });
+      expect(calls).toEqual(['test', 'afterEach', 'onTestFinished']);
+    } finally {
+      collector.dispose();
+      runner.dispose();
+    }
+  });
+
+  it('runs onTestFailed after afterEach for failed tests', async () => {
+    const calls: string[] = [];
+    const collector = getTestCollector();
+    const runner = getTestRunner();
+
+    try {
+      const collection = await collector.collect(() => {
+        harnessDescribe('Failed Hook Suite', () => {
+          afterEach(() => {
+            calls.push('afterEach');
+          });
+
+          harnessIt('runs failed callbacks', (context: HarnessTestContext) => {
+            const { onTestFailed } = getTaskContext(context);
+
+            onTestFailed(() => {
+              calls.push('onTestFailed:first');
+            });
+            onTestFailed(() => {
+              calls.push('onTestFailed:second');
+            });
+
+            calls.push('test');
+            throw new Error('expected failure');
+          });
+        });
+      }, 'runtime/on-test-failed-failure.test.ts');
+
+      const result = await runner.run({
+        testSuite: collection.testSuite,
+        testFilePath: 'runtime/on-test-failed-failure.test.ts',
+        runner: 'ios',
+      });
+
+      expect(result.suites[0].tests[0]).toMatchObject({ status: 'failed' });
+      expect(calls).toEqual([
+        'test',
+        'afterEach',
+        'onTestFailed:second',
+        'onTestFailed:first',
+      ]);
+    } finally {
+      collector.dispose();
+      runner.dispose();
+    }
+  });
+
+  it('does not run onTestFailed for dynamically skipped tests', async () => {
+    const calls: string[] = [];
+    const collector = getTestCollector();
+    const runner = getTestRunner();
+
+    try {
+      const collection = await collector.collect(() => {
+        harnessDescribe('Failed Skip Suite', () => {
+          afterEach(() => {
+            calls.push('afterEach');
+          });
+
+          harnessIt(
+            'does not run failed callbacks on skip',
+            (context: HarnessTestContext) => {
+              const { onTestFailed, skip } = getTaskContext(context);
+
+            onTestFailed(() => {
+              calls.push('onTestFailed');
+            });
+
+            calls.push('before-skip');
+            skip();
+            },
+          );
+        });
+      }, 'runtime/on-test-failed-skip.test.ts');
+
+      const result = await runner.run({
+        testSuite: collection.testSuite,
+        testFilePath: 'runtime/on-test-failed-skip.test.ts',
+        runner: 'android',
+      });
+
+      expect(result.suites[0].tests[0]).toMatchObject({ status: 'skipped' });
+      expect(calls).toEqual(['before-skip', 'afterEach']);
+    } finally {
+      collector.dispose();
+      runner.dispose();
+    }
+  });
+
+  it('runs onTestFailed when afterEach fails', async () => {
+    const calls: string[] = [];
+    const collector = getTestCollector();
+    const runner = getTestRunner();
+
+    try {
+      const collection = await collector.collect(() => {
+        harnessDescribe('Failed AfterEach Suite', () => {
+          afterEach(() => {
+            calls.push('afterEach');
+            throw new Error('afterEach failure');
+          });
+
+          harnessIt(
+            'runs failed callback after afterEach failure',
+            (context: HarnessTestContext) => {
+              const { onTestFailed } = getTaskContext(context);
+
+            onTestFailed(() => {
+              calls.push('onTestFailed');
+            });
+
+            calls.push('test');
+            },
+          );
+        });
+      }, 'runtime/on-test-failed-after-each.test.ts');
+
+      const result = await runner.run({
+        testSuite: collection.testSuite,
+        testFilePath: 'runtime/on-test-failed-after-each.test.ts',
+        runner: 'ios',
+      });
+
+      expect(result.suites[0].tests[0]).toMatchObject({ status: 'failed' });
+      expect(calls).toEqual(['test', 'afterEach', 'onTestFailed']);
+    } finally {
+      collector.dispose();
+      runner.dispose();
+    }
+  });
+});

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