@react-native-harness/runtime 1.2.0-rc.1 → 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-rc.1",
+  "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-rc.1"
+    "@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/client/factory.ts

@@ -4,7 +4,7 @@ import type {
   BundlerEvents,
   TestExecutionOptions,
 } from '@react-native-harness/bridge';
-import { getBridgeClient } from '@react-native-harness/bridge/client';
+import { connectToHarness, type HarnessHandle } from '@react-native-harness/bridge/client';
 import { store } from '../ui/state.js';
 import { getTestRunner, TestRunner } from '../runner/index.js';
 import { getTestCollector, TestCollector } from '../collector/index.js';
@@ -14,92 +14,81 @@ import { getBundler, evaluateModule, Bundler } from '../bundler/index.js';
 import { markTestsAsSkippedByName } from '../filtering/index.js';
 import { setup } from '../render/setup.js';
 import { runSetupFiles } from './setup-files.js';
-import { setClient } from './store.js';
+import { setHandle } from './store.js';
 
-export const getClient = async () => {
-  const client = await getBridgeClient(getWSServer(), {
-    runTests: async () => {
-      throw new Error('Not implemented');
-    },
-  });
-
-  setClient(client);
-
-  client.rpc.$functions.runTests = async (
-    path: string,
-    options: TestExecutionOptions
-  ) => {
-    if (store.getState().status === 'running') {
-      throw new Error('Already running tests');
-    }
-
-    store.getState().setStatus('running');
+export const getClient = async (): Promise<HarnessHandle> => {
+  const handle = await connectToHarness(getWSServer(), {
+    runTests: async (path: string, options: TestExecutionOptions) => {
+      if (store.getState().status === 'running') {
+        throw new Error('Already running tests');
+      }
 
-    let collector: TestCollector | null = null;
-    let runner: TestRunner | null = null;
-    let events: EventEmitter<
-      TestRunnerEvents | TestCollectorEvents | BundlerEvents
-    > | null = null;
-    let bundler: Bundler | null = null;
+      store.getState().setStatus('running');
 
-    try {
-      collector = getTestCollector();
-      runner = getTestRunner();
-      bundler = getBundler();
-      events = combineEventEmitters(
-        collector.events,
-        runner.events,
-        bundler.events
-      );
+      let collector: TestCollector | null = null;
+      let runner: TestRunner | null = null;
+      let events: EventEmitter<
+        TestRunnerEvents | TestCollectorEvents | BundlerEvents
+      > | null = null;
+      let bundler: Bundler | null = null;
 
-      events.addListener((event) => {
-        client.rpc.emitEvent(event.type, event);
-      });
+      try {
+        collector = getTestCollector();
+        runner = getTestRunner();
+        bundler = getBundler();
+        events = combineEventEmitters(
+          collector.events,
+          runner.events,
+          bundler.events,
+        );
 
-      await runSetupFiles({
-        setupFiles: options.setupFiles ?? [],
-        setupFilesAfterEnv: [],
-        events: events as EventEmitter<BundlerEvents>,
-        bundler: bundler as Bundler,
-        evaluateModule,
-      });
+        events.addListener((event) => {
+          handle.emitEvent(event);
+        });
 
-      const moduleJs = await bundler.getModule(path);
-      const collectionResult = await collector.collect(async () => {
         await runSetupFiles({
-          setupFiles: [],
-          setupFilesAfterEnv: options.setupFilesAfterEnv ?? [],
+          setupFiles: options.setupFiles ?? [],
+          setupFilesAfterEnv: [],
           events: events as EventEmitter<BundlerEvents>,
           bundler: bundler as Bundler,
           evaluateModule,
         });
 
-        // Setup automatic cleanup for rendered components
-        setup();
-        evaluateModule(moduleJs, path);
-      }, path);
+        const moduleJs = await bundler.getModule(path);
+        const collectionResult = await collector.collect(async () => {
+          await runSetupFiles({
+            setupFiles: [],
+            setupFilesAfterEnv: options.setupFilesAfterEnv ?? [],
+            events: events as EventEmitter<BundlerEvents>,
+            bundler: bundler as Bundler,
+            evaluateModule,
+          });
+
+          setup();
+          evaluateModule(moduleJs, path);
+        }, path);
 
-      // Apply test name pattern by marking non-matching tests as skipped
-      const processedTestSuite = options.testNamePattern
-        ? markTestsAsSkippedByName(
-            collectionResult.testSuite,
-            options.testNamePattern
-          )
-        : collectionResult.testSuite;
+        const processedTestSuite = options.testNamePattern
+          ? markTestsAsSkippedByName(
+              collectionResult.testSuite,
+              options.testNamePattern,
+            )
+          : collectionResult.testSuite;
 
-      const result = await runner.run({
-        testSuite: processedTestSuite,
-        testFilePath: path,
-        runner: options.runner,
-      });
-      return result;
-    } finally {
-      collector?.dispose();
-      runner?.dispose();
-      events?.clearAllListeners();
-      store.getState().setStatus('idle');
-    }
-  };
+        return await runner.run({
+          testSuite: processedTestSuite,
+          testFilePath: path,
+          runner: options.runner,
+        });
+      } finally {
+        collector?.dispose();
+        runner?.dispose();
+        events?.clearAllListeners();
+        store.getState().setStatus('idle');
+      }
+    },
+  });
 
-  return client;
+  setHandle(handle);
+  return handle;
 };

package/src/client/store.ts

@@ -1,16 +1,16 @@
-import type { BridgeClient } from '@react-native-harness/bridge/client';
+import type { HarnessHandle } from '@react-native-harness/bridge/client';
 
-let clientInstance: BridgeClient | null = null;
+let handle: HarnessHandle | null = null;
 
-export const setClient = (client: BridgeClient): void => {
-  clientInstance = client;
+export const setHandle = (h: HarnessHandle): void => {
+  handle = h;
 };
 
-export const getClientInstance = (): BridgeClient => {
-  if (!clientInstance) {
+export const getHandle = (): HarnessHandle => {
+  if (!handle) {
     throw new Error(
-      'Bridge client not initialized. This should not happen in normal operation.'
+      'Harness not connected. This should not happen in normal operation.'
     );
   }
-  return clientInstance;
+  return handle;
 };