@react-native-harness/jest 1.3.0 → 1.4.0

package/src/index.ts

@@ -1,10 +1,8 @@
 import type {
-  CallbackTestRunnerInterface,
   Config,
-  OnTestFailure,
-  OnTestStart,
-  OnTestSuccess,
+  EmittingTestRunnerInterface,
   Test,
+  TestEvents,
   TestRunnerOptions,
   TestWatcher,
 } from 'jest-runner';
@@ -13,22 +11,41 @@ import { executeRun } from './execute-run.js';
 import { HarnessError } from '@react-native-harness/tools';
 import { getErrorMessage } from './logs.js';
 
-export default class JestHarness implements CallbackTestRunnerInterface {
+type TestEventListener<Name extends keyof TestEvents> = (
+  eventData: TestEvents[Name],
+) => void | Promise<void>;
+
+export default class JestHarness implements EmittingTestRunnerInterface {
   readonly isSerial = true;
+  readonly supportsEventEmitters = true as const;
 
   #globalConfig: Config.GlobalConfig;
   #session: HarnessSession | null = null;
+  #listeners = new Map<keyof TestEvents, Set<TestEventListener<keyof TestEvents>>>();
 
   constructor(globalConfig: Config.GlobalConfig) {
     this.#globalConfig = globalConfig;
   }
 
+  on<Name extends keyof TestEvents>(
+    eventName: Name,
+    listener: TestEventListener<Name>,
+  ): () => void {
+    const listeners = this.#listeners.get(eventName) ?? new Set();
+    listeners.add(listener as TestEventListener<keyof TestEvents>);
+    this.#listeners.set(eventName, listeners);
+
+    return () => {
+      listeners.delete(listener as TestEventListener<keyof TestEvents>);
+      if (listeners.size === 0) {
+        this.#listeners.delete(eventName);
+      }
+    };
+  }
+
   async runTests(
     tests: Array<Test>,
     watcher: TestWatcher,
-    onStart: OnTestStart,
-    onResult: OnTestSuccess,
-    onFailure: OnTestFailure,
     options: TestRunnerOptions,
   ): Promise<void> {
     if (!options.serial) {
@@ -46,9 +63,7 @@ export default class JestHarness implements CallbackTestRunnerInterface {
         this.#session,
         tests,
         watcher,
-        onStart,
-        onResult,
-        onFailure,
+        this.#emit,
         this.#globalConfig,
       );
     } catch (error) {
@@ -63,4 +78,18 @@ export default class JestHarness implements CallbackTestRunnerInterface {
       }
     }
   }
+
+  #emit = async <Name extends keyof TestEvents>(
+    eventName: Name,
+    ...eventData: TestEvents[Name]
+  ): Promise<void> => {
+    const listeners = this.#listeners.get(eventName);
+    if (!listeners) {
+      return;
+    }
+
+    for (const listener of listeners) {
+      await listener(eventData);
+    }
+  };
 }

package/src/run.ts

@@ -8,6 +8,7 @@ import type {
 import type { HarnessSession } from './harness-session.js';
 import { formatResultsErrors } from 'jest-message-util';
 import { toTestResult } from './toTestResult.js';
+import { formatHarnessErrorMessage } from './format-harness-error.js';
 
 // Helper function to flatten nested test suites into a flat array of tests with hierarchy
 const flattenTests = (
@@ -16,6 +17,17 @@ const flattenTests = (
 ): Array<HarnessTestResult & { ancestorTitles: string[] }> => {
   const tests: Array<HarnessTestResult & { ancestorTitles: string[] }> = [];
 
+  if (suiteResult.error) {
+    tests.push({
+      name: suiteResult.name,
+      status: 'failed',
+      duration: suiteResult.duration,
+      error: suiteResult.error,
+      ancestorTitles: [...ancestorTitles],
+      fullName: [...ancestorTitles, suiteResult.name].join(' '),
+    });
+  }
+
   // Add tests from current suite with current hierarchy
   for (const test of suiteResult.tests) {
     tests.push({
@@ -88,11 +100,18 @@ export const runHarnessTestFile: RunHarnessTestFile = async ({
   const setupFilesAfterEnv = projectConfig.setupFilesAfterEnv?.map(
     (setupFile) => path.relative(globalConfig.rootDir, setupFile)
   );
+  const testTimeout =
+    session.config.testTimeout ??
+    (projectConfig as JestConfig.ProjectConfig & { testTimeout?: number })
+      .testTimeout ??
+    (globalConfig as JestConfig.GlobalConfig & { testTimeout?: number })
+      .testTimeout;
 
   const harnessResult = await session.runTestFile(relativeTestPath, {
     testNamePattern: globalConfig.testNamePattern,
     setupFiles,
     setupFilesAfterEnv,
+    testTimeout,
     runner: session.context.platform.runner,
   });
   const end = Date.now();
@@ -102,15 +121,16 @@ export const runHarnessTestFile: RunHarnessTestFile = async ({
 
   // Convert TestResult[] to the format expected by toTestResult
   const tests = allTests.map((test) => {
-    const errorMessage = test.error?.message;
     const codeFrame = test.error?.codeFrame;
+    const errorMessage = formatHarnessErrorMessage(test.error, {
+      testStartedAt: test.startedAt,
+    });
 
     return {
       duration: test.duration,
-      errorMessage: errorMessage
-        ? `${errorMessage}${codeFrame ? `\n\n${codeFrame.content}` : ''}`
-        : undefined,
+      errorMessage,
       title: test.name,
+      fullName: test.fullName,
       status: test.status,
       location: codeFrame?.location
         ? { column: codeFrame.location.column, line: codeFrame.location.row }

package/src/test-file-platform-filter.ts

@@ -0,0 +1,57 @@
+import path from 'node:path';
+import type { TestResult as JestTestResult } from '@jest/test-result';
+import { toTestResult } from './toTestResult.js';
+
+const PLATFORM_SPECIFIC_HARNESS_FILE =
+  /\.([^.]+)\.harness\.(?:[mc]?[jt]sx?)$/;
+
+export const getHarnessTestFilePlatform = (
+  testPath: string,
+  knownPlatformIds: ReadonlySet<string>,
+): string | null => {
+  const match = path.basename(testPath).match(PLATFORM_SPECIFIC_HARNESS_FILE);
+  if (!match) {
+    return null;
+  }
+
+  const candidate = match[1];
+  return knownPlatformIds.has(candidate) ? candidate : null;
+};
+
+export const shouldRunHarnessTestFile = (
+  testPath: string,
+  platformId: string,
+  knownPlatformIds: ReadonlySet<string>,
+): boolean => {
+  const filePlatform = getHarnessTestFilePlatform(testPath, knownPlatformIds);
+  return filePlatform == null || filePlatform === platformId;
+};
+
+export const createPlatformSkippedTestResult = (
+  testPath: string,
+): JestTestResult => {
+  const now = Date.now();
+  const title = path.basename(testPath);
+
+  return toTestResult({
+    stats: {
+      failures: 0,
+      passes: 0,
+      pending: 1,
+      todo: 0,
+      start: now,
+      end: now,
+    },
+    skipped: true,
+    errorMessage: null,
+    tests: [
+      {
+        status: 'skipped',
+        title,
+        fullName: title,
+        testPath,
+      },
+    ],
+    jestTestPath: testPath,
+  });
+};

package/src/toTestResult.ts

@@ -16,6 +16,7 @@ export type Options = {
     errorMessage?: string;
     testPath?: string;
     title?: string;
+    fullName?: string;
     status: Status;
     location?: {
       column: number;
@@ -72,8 +73,8 @@ const getTestResults = ({
       duration: test.duration,
       failureDetails: [],
       failureMessages: actualErrorMessage ? [actualErrorMessage] : [],
-      fullName: jestTestPath || test.testPath || '',
-      numPassingAsserts: test.errorMessage ? 1 : 0,
+      fullName: test.fullName || test.testPath || jestTestPath || '',
+      numPassingAsserts: test.status === 'passed' ? 1 : 0,
       status: test.status,
       title: test.title || '',
       location: test.location,

package/tsconfig.json

@@ -6,6 +6,9 @@
     {
       "path": "../tools"
     },
+    {
+      "path": "../cache"
+    },
     {
       "path": "../platforms"
     },

package/tsconfig.lib.json

@@ -15,6 +15,9 @@
     {
       "path": "../tools/tsconfig.lib.json"
     },
+    {
+      "path": "../cache/tsconfig.lib.json"
+    },
     {
       "path": "../platforms/tsconfig.lib.json"
     },