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

package/src/errors.ts

@@ -1,4 +1,4 @@
-import { HarnessError } from '@react-native-harness/tools';
+import { formatPath, HarnessError } from '@react-native-harness/tools';
 import type { AppCrashDetails } from '@react-native-harness/platforms';
 export {
   StartupStallError,
@@ -55,6 +55,10 @@ export type NativeCrashDetails = AppCrashDetails & {
   phase: NativeCrashPhase;
 };
 
+export type RuntimeDisconnectDetails = AppCrashDetails & {
+  phase: NativeCrashPhase;
+};
+
 const buildNativeCrashMessage = ({
   phase,
   summary,
@@ -64,12 +68,28 @@ const buildNativeCrashMessage = ({
   pid,
   stackTrace,
   artifactType,
+  artifactPath,
+  enrichmentArtifacts,
 }: NativeCrashDetails) => {
   const lines = [
     phase === 'startup'
       ? 'The native app crashed while preparing to run this test file.'
       : 'The native app crashed during test execution.',
   ];
+
+  lines.push(
+    artifactPath
+      ? `Harness extracted the crash log: ${formatPath(artifactPath)}`
+      : "Harness couldn't extract the crash log."
+  );
+
+  if (enrichmentArtifacts && enrichmentArtifacts.length > 0) {
+    lines.push('Additional crash artifacts:');
+    for (const artifact of enrichmentArtifacts) {
+      lines.push(`  - ${formatPath(artifact.artifactPath)}`);
+    }
+  }
+
   const hasCrashBlock = summary?.includes('\n') ?? false;
   const shouldRenderSummary =
     Boolean(summary) &&
@@ -119,3 +139,44 @@ export class NativeCrashError extends HarnessError {
     return this.details.phase;
   }
 }
+
+const buildRuntimeDisconnectMessage = ({
+  phase,
+  summary,
+  rawLines,
+}: RuntimeDisconnectDetails) => {
+  const lines = [
+    phase === 'startup'
+      ? 'The native runtime disconnected while preparing to run this test file.'
+      : 'The native runtime disconnected during test execution.',
+  ];
+
+  if (summary) {
+    lines.push('');
+    lines.push(summary);
+  }
+
+  if (rawLines && rawLines.length > 0 && summary !== rawLines.join('\n')) {
+    lines.push('');
+    lines.push(...rawLines);
+  }
+
+  return lines.join('\n');
+};
+
+export class RuntimeDisconnectError extends HarnessError {
+  constructor(
+    public readonly testFilePath: string,
+    public readonly details: RuntimeDisconnectDetails
+  ) {
+    super(buildRuntimeDisconnectMessage(details));
+    this.name = 'RuntimeDisconnectError';
+    this.stack = `${this.name}: ${this.message.split('\n')[0]}`;
+  }
+
+  get phase() {
+    return this.details.phase;
+  }
+}
+
+export type HarnessRuntimeFailure = NativeCrashError | RuntimeDisconnectError;

package/src/execute-run.ts

@@ -1,10 +1,8 @@
 import type {
-  OnTestFailure,
-  OnTestStart,
-  OnTestSuccess,
   Test,
   TestWatcher,
   Config,
+  TestEvents,
 } from 'jest-runner';
 import { randomUUID } from 'node:crypto';
 import path from 'node:path';
@@ -12,9 +10,28 @@ import { type HarnessSession, type HarnessRunState } from './harness-session.js'
 import { runHarnessTestFile } from './run.js';
 import {
   NativeCrashError,
+  RuntimeDisconnectError,
   StartupStallError,
 } from './errors.js';
-import { DeviceNotRespondingError } from '@react-native-harness/bridge/server';
+import {
+  AppBridgeDisconnectedError,
+  DeviceNotRespondingError,
+} from '@react-native-harness/bridge/server';
+import type { TestCaseResult } from '@jest/test-result';
+import type {
+  TestRunnerEvents,
+  TestRunnerTestFinishedEvent,
+  TestRunnerTestStartedEvent,
+} from '@react-native-harness/bridge';
+import {
+  createPlatformSkippedTestResult,
+  shouldRunHarnessTestFile,
+} from './test-file-platform-filter.js';
+
+type EmitTestEvent = <Name extends keyof TestEvents>(
+  eventName: Name,
+  ...eventData: TestEvents[Name]
+) => Promise<void>;
 
 const createRunSummary = () => ({ passed: 0, failed: 0, skipped: 0, todo: 0 });
 
@@ -38,7 +55,9 @@ class CancelRun extends Error {
 const buildTestFailure = (err: unknown): { message: string; stack: string } => {
   if (
     err instanceof NativeCrashError ||
+    err instanceof RuntimeDisconnectError ||
     err instanceof StartupStallError ||
+    err instanceof AppBridgeDisconnectedError ||
     err instanceof DeviceNotRespondingError
   ) {
     return { message: (err as Error).message, stack: '' };
@@ -46,13 +65,60 @@ const buildTestFailure = (err: unknown): { message: string; stack: string } => {
   return err as { message: string; stack: string };
 };
 
+const toJestMode = (
+  declarationMode?: 'only' | 'skip' | 'todo',
+): 'only' | 'skip' | 'todo' | undefined => declarationMode;
+
+const emitHarnessTestStarted = async (
+  emitEvent: EmitTestEvent,
+  event: TestRunnerTestStartedEvent,
+): Promise<void> => {
+  await emitEvent('test-case-start', event.file, {
+    ancestorTitles: event.ancestorTitles,
+    fullName: event.fullName,
+    mode: toJestMode(event.declarationMode),
+    title: event.name,
+    startedAt: event.startedAt,
+  });
+};
+
+const emitHarnessTestFinished = async (
+  emitEvent: EmitTestEvent,
+  event: TestRunnerTestFinishedEvent,
+): Promise<void> => {
+  const failureMessage = event.error?.message;
+  const codeFrame = event.error?.codeFrame;
+  const location = codeFrame?.location
+    ? { column: codeFrame.location.column, line: codeFrame.location.row }
+    : null;
+  const testCaseResult: TestCaseResult = {
+    ancestorTitles: event.ancestorTitles,
+    duration: event.duration,
+    failureDetails: [],
+    failureMessages: failureMessage
+      ? [`${failureMessage}${codeFrame ? `\n\n${codeFrame.content}` : ''}`]
+      : [],
+    fullName: event.fullName,
+    location,
+    numPassingAsserts: event.status === 'passed' ? 1 : 0,
+    startedAt: event.startedAt,
+    status: event.status,
+    title: event.name,
+  };
+
+  await emitEvent('test-case-result', event.file, testCaseResult);
+};
+
+const isHarnessCaseEvent = (
+  event: TestRunnerEvents,
+): event is TestRunnerTestStartedEvent | TestRunnerTestFinishedEvent =>
+  event.type === 'test-started' || event.type === 'test-finished';
+
 export const executeRun = async (
   session: HarnessSession,
   tests: Array<Test>,
   watcher: TestWatcher,
-  onStart: OnTestStart,
-  onResult: OnTestSuccess,
-  onFailure: OnTestFailure,
+  emitEvent: EmitTestEvent,
   globalConfig: Config.GlobalConfig,
 ): Promise<void> => {
   const runId = randomUUID();
@@ -61,6 +127,16 @@ export const executeRun = async (
   const rootDir = globalConfig.rootDir ?? process.cwd();
   const testFiles = tests.map((t) => path.relative(rootDir, t.path));
   const summary = createRunSummary();
+  let caseEventChain = Promise.resolve();
+  const unsubscribe = session.onTestRunnerEvent((event) => {
+    if (isHarnessCaseEvent(event)) {
+      caseEventChain = caseEventChain.then(() =>
+        event.type === 'test-started'
+          ? emitHarnessTestStarted(emitEvent, event)
+          : emitHarnessTestFinished(emitEvent, event),
+      );
+    }
+  });
 
   const updateRunState = (overrides: Partial<HarnessRunState> = {}) => {
     const state: HarnessRunState = {
@@ -93,6 +169,10 @@ export const executeRun = async (
   });
 
   const shouldResetEnv = session.config.resetEnvironmentBetweenTestFiles;
+  const platformId = session.context.platform.platformId;
+  const knownPlatformIds = new Set(
+    session.config.runners.map((runner) => runner.platformId),
+  );
   let isFirstTest = true;
   let runError: unknown;
 
@@ -121,6 +201,34 @@ export const executeRun = async (
 
       await session.callHook('test-file:started', { runId, file: relativeTestPath });
 
+      if (
+        !shouldRunHarnessTestFile(test.path, platformId, knownPlatformIds)
+      ) {
+        try {
+          await emitEvent('test-file-start', test);
+          const skippedResult = createPlatformSkippedTestResult(test.path);
+          applyJestResultToSummary(summary, skippedResult);
+          updateRunState();
+          await emitTestFileFinished({
+            status: 'skipped',
+            duration: Date.now() - fileStartedAt,
+            result: null,
+          });
+          await emitEvent('test-file-success', test, skippedResult);
+        } catch (err) {
+          if (!emittedTestFileFinished) {
+            await emitTestFileFinished({
+              status: 'failed',
+              duration: Date.now() - fileStartedAt,
+              result: null,
+            });
+          }
+          updateRunState({ error: err });
+          await emitEvent('test-file-failure', test, buildTestFailure(err));
+        }
+        continue;
+      }
+
       try {
         if (shouldResetEnv && !isFirstTest) {
           await session.restartApp(test.path);
@@ -128,7 +236,7 @@ export const executeRun = async (
         isFirstTest = false;
 
         session.flushClientLogs();
-        await onStart(test);
+        await emitEvent('test-file-start', test);
         await session.ensureAppReady(test.path);
 
         // Crash detection is handled inside session.runTestFile; NativeCrashError
@@ -151,7 +259,8 @@ export const executeRun = async (
           duration: result.duration,
           result: result.harnessResult,
         });
-        await onResult(test, result.jestResult);
+        await caseEventChain;
+        await emitEvent('test-file-success', test, result.jestResult);
       } catch (err) {
         if (!emittedTestFileFinished) {
           await emitTestFileFinished({
@@ -163,7 +272,9 @@ export const executeRun = async (
 
         const isRuntimeFailure =
           err instanceof NativeCrashError ||
+          err instanceof RuntimeDisconnectError ||
           err instanceof StartupStallError ||
+          err instanceof AppBridgeDisconnectedError ||
           err instanceof DeviceNotRespondingError;
 
         if (isRuntimeFailure) {
@@ -171,12 +282,13 @@ export const executeRun = async (
           updateRunState();
         }
 
-        if (err instanceof NativeCrashError) {
+        if (err instanceof NativeCrashError || err instanceof RuntimeDisconnectError) {
           session.resetCrashState();
         }
 
         updateRunState({ error: isRuntimeFailure ? undefined : err });
-        onFailure(test, buildTestFailure(err));
+        await caseEventChain;
+        await emitEvent('test-file-failure', test, buildTestFailure(err));
       }
     }
   } catch (err) {
@@ -195,5 +307,7 @@ export const executeRun = async (
       status: runState.status ?? (runError != null ? 'failed' : 'passed'),
       ...(runError != null ? { error: runError } : {}),
     });
+    await caseEventChain;
+    unsubscribe();
   }
 };