@react-native-harness/jest 1.3.0 → 1.4.0

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

@@ -0,0 +1,83 @@
+import { describe, expect, it } from 'vitest';
+import {
+  createPlatformSkippedTestResult,
+  getHarnessTestFilePlatform,
+  shouldRunHarnessTestFile,
+} from '../test-file-platform-filter.js';
+
+const knownPlatformIds = new Set(['android', 'ios', 'web', 'vega']);
+
+describe('getHarnessTestFilePlatform', () => {
+  it('returns null for shared harness test files', () => {
+    expect(getHarnessTestFilePlatform('/tests/smoke.harness.ts', knownPlatformIds)).toBeNull();
+    expect(getHarnessTestFilePlatform('/tests/smoke.harness.tsx', knownPlatformIds)).toBeNull();
+    expect(getHarnessTestFilePlatform('/tests/smoke.harness.mjs', knownPlatformIds)).toBeNull();
+  });
+
+  it('returns the platform id for platform-specific harness test files', () => {
+    expect(
+      getHarnessTestFilePlatform('/tests/kotlin.android.harness.ts', knownPlatformIds),
+    ).toBe('android');
+    expect(
+      getHarnessTestFilePlatform('/tests/swift.ios.harness.ts', knownPlatformIds),
+    ).toBe('ios');
+    expect(
+      getHarnessTestFilePlatform('/tests/browser.web.harness.ts', knownPlatformIds),
+    ).toBe('web');
+  });
+
+  it('returns null when the segment before .harness is not a known platform id', () => {
+    expect(
+      getHarnessTestFilePlatform('/tests/smoke.harness.ts', knownPlatformIds),
+    ).toBeNull();
+    expect(
+      getHarnessTestFilePlatform('/tests/custom.foo.harness.ts', knownPlatformIds),
+    ).toBeNull();
+  });
+});
+
+describe('shouldRunHarnessTestFile', () => {
+  it('runs shared harness test files on every platform', () => {
+    expect(
+      shouldRunHarnessTestFile('/tests/smoke.harness.ts', 'android', knownPlatformIds),
+    ).toBe(true);
+    expect(
+      shouldRunHarnessTestFile('/tests/smoke.harness.ts', 'ios', knownPlatformIds),
+    ).toBe(true);
+  });
+
+  it('runs platform-specific files only on the matching platform', () => {
+    expect(
+      shouldRunHarnessTestFile('/tests/kotlin.android.harness.ts', 'android', knownPlatformIds),
+    ).toBe(true);
+    expect(
+      shouldRunHarnessTestFile('/tests/kotlin.android.harness.ts', 'ios', knownPlatformIds),
+    ).toBe(false);
+    expect(
+      shouldRunHarnessTestFile('/tests/swift.ios.harness.ts', 'ios', knownPlatformIds),
+    ).toBe(true);
+    expect(
+      shouldRunHarnessTestFile('/tests/swift.ios.harness.ts', 'android', knownPlatformIds),
+    ).toBe(false);
+  });
+});
+
+describe('createPlatformSkippedTestResult', () => {
+  it('marks the entire test file as skipped', () => {
+    const result = createPlatformSkippedTestResult('/tests/swift.ios.harness.ts');
+
+    expect(result.skipped).toBe(true);
+    expect(result.numPassingTests).toBe(0);
+    expect(result.numFailingTests).toBe(0);
+    expect(result.numPendingTests).toBe(1);
+    expect(result.testResults).toHaveLength(1);
+    expect(result.testResults[0]).toEqual(
+      expect.objectContaining({
+        status: 'skipped',
+        title: 'swift.ios.harness.ts',
+        fullName: 'swift.ios.harness.ts',
+      }),
+    );
+    expect(result.testFilePath).toBe('/tests/swift.ios.harness.ts');
+  });
+});

package/src/crash-monitor.ts

@@ -1,18 +1,24 @@
 import {
-  type AppMonitor,
   type AppCrashDetails,
-  type AppMonitorEvent,
-  type AppMonitorListener,
-  type HarnessPlatformRunner,
+  type AppSession,
+  type AppSessionEvent,
+  type AppSessionListener,
+  type AppSessionLog,
+  type AppSessionState,
 } from '@react-native-harness/platforms';
 import {
   NativeCrashError,
+  RuntimeDisconnectError,
+  type HarnessRuntimeFailure,
   type NativeCrashDetails,
   type NativeCrashPhase,
+  type RuntimeDisconnectDetails,
 } from './errors.js';
 import { logger } from '@react-native-harness/tools';
 
 const crashLogger = logger.child('crash');
+const CRASH_CLASSIFICATION_SETTLE_MS = 1500;
+const CRASH_LOG_WINDOW_MS = 3000;
 
 export class CrashWatchCancelledError extends Error {
   constructor() {
@@ -32,172 +38,228 @@ export type CrashMonitor = {
   stop: () => Promise<void>;
   start: () => Promise<void>;
   reset: () => void;
+  setAppSession: (session: AppSession | null) => void;
+  handleBridgeDisconnect: () => void;
+  /**
+   * Opens a window during which handleBridgeDisconnect() is suppressed,
+   * for use around operations (like a runtime reset) that intentionally
+   * disconnect the bridge without the app process dying. Returns a closer
+   * that ends the window; safe to call multiple times or nest.
+   */
+  expectDisconnect: () => () => void;
   dispose: () => Promise<void>;
 };
 
 export type CrashMonitorOptions = {
-  appMonitor: AppMonitor;
-  platformRunner: HarnessPlatformRunner;
+  appSession?: AppSession | null;
 };
 
-type CrashDetailsProvider = {
-  getCrashDetails?: (options: {
-    processName?: string;
-    pid?: number;
-    occurredAt: number;
-  }) => Promise<AppCrashDetails | null>;
+type PendingCrash = {
+  testFilePath: string;
+  phase: NativeCrashPhase;
+  occurredAt: number;
 };
 
-const mergeCrashDetails = (
+const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+const isCrashIndicator = (line: string) =>
+  /uncaught exception|terminating app due to|fatal error|EXC_[A-Z_]+|termination reason|crash|abort/i.test(
+    line
+  ) || /\bSIG[A-Z]{2,}\b/.test(line);
+
+const getMatchingCrashLines = (
+  logs: AppSessionLog[],
+  occurredAt: number
+): string[] =>
+  logs
+    .filter(
+      (log) => Math.abs(log.occurredAt - occurredAt) <= CRASH_LOG_WINDOW_MS
+    )
+    .map((log) => log.line)
+    .filter(isCrashIndicator);
+
+const buildNativeCrashDetails = (
   phase: NativeCrashPhase,
-  initial?: AppCrashDetails,
-  enriched?: AppCrashDetails | null,
-  fallbackSummary?: string,
+  rawLines: string[],
+  summary: string
 ): NativeCrashDetails => ({
   phase,
-  source: enriched?.source ?? initial?.source,
-  summary: enriched?.summary ?? initial?.summary ?? fallbackSummary,
-  signal: enriched?.signal ?? initial?.signal,
-  exceptionType: enriched?.exceptionType ?? initial?.exceptionType,
-  processName: enriched?.processName ?? initial?.processName,
-  pid: enriched?.pid ?? initial?.pid,
-  stackTrace: enriched?.stackTrace ?? initial?.stackTrace,
-  rawLines: enriched?.rawLines ?? initial?.rawLines,
-  artifactType: enriched?.artifactType ?? initial?.artifactType,
-  artifactPath: enriched?.artifactPath ?? initial?.artifactPath,
+  source: rawLines.length > 0 ? 'logs' : 'bridge',
+  summary: rawLines.length > 0 ? rawLines.join('\n') : summary,
+  rawLines: rawLines.length > 0 ? rawLines : undefined,
+});
+
+const getStatePid = (state: AppSessionState | undefined) => {
+  if (state && 'pid' in state) {
+    return state.pid;
+  }
+
+  return undefined;
+};
+
+const mergeCrashDetails = (
+  fallback: NativeCrashDetails,
+  extracted: AppCrashDetails | null
+): NativeCrashDetails => {
+  if (!extracted) {
+    return fallback;
+  }
+
+  return {
+    ...fallback,
+    ...extracted,
+    phase: fallback.phase,
+    source: extracted.source ?? fallback.source,
+    summary: extracted.summary ?? fallback.summary,
+    rawLines: extracted.rawLines ?? fallback.rawLines,
+  };
+};
+
+const buildRuntimeDisconnectDetails = (
+  phase: NativeCrashPhase,
+  rawLines: string[]
+): RuntimeDisconnectDetails => ({
+  phase,
+  source: 'bridge',
+  summary:
+    'The runtime bridge disconnected, but the app session still appears to be running.',
+  rawLines: rawLines.length > 0 ? rawLines : undefined,
 });
 
 export const createCrashMonitor = ({
-  appMonitor,
-  platformRunner,
-}: CrashMonitorOptions): CrashMonitor => {
+  appSession: initialAppSession = null,
+}: CrashMonitorOptions = {}): CrashMonitor => {
   let alive = false;
   let monitoring = true;
   let isResolvingCrash = false;
   let disposed = false;
+  let appSession: AppSession | null = null;
+  let pendingTimer: NodeJS.Timeout | null = null;
 
-  // Both updated when watch() is called so crashes are attributed to the
-  // correct test file and lifecycle phase.
   let currentTestFilePath = '';
   let currentPhase: NativeCrashPhase = 'startup';
-  const watchers = new Set<(err: NativeCrashError) => void>();
-
-  const getCrashDetailsProvider = (): CrashDetailsProvider | null => {
-    if ('getCrashDetails' in appMonitor) {
-      return appMonitor as AppMonitor & CrashDetailsProvider;
-    }
-    if (platformRunner.getCrashDetails) {
-      return platformRunner;
-    }
-    return null;
-  };
+  let expectedDisconnectDepth = 0;
+  const watchers = new Set<(err: HarnessRuntimeFailure) => void>();
 
-  const notifyCrash = (err: NativeCrashError) => {
+  const notifyFailure = (err: HarnessRuntimeFailure) => {
     const pending = [...watchers];
     watchers.clear();
     for (const fn of pending) fn(err);
   };
 
-  const handleCrash = async (
-    phase: NativeCrashPhase,
-    details?: AppCrashDetails,
-    fallbackSummary?: string,
-  ) => {
-    if (isResolvingCrash) return;
-    isResolvingCrash = true;
-    alive = false;
-
-    crashLogger.debug('native crash detected (phase=%s)', phase);
-    for (const line of details?.rawLines ?? []) {
-      crashLogger.debug('%s', line);
-    }
-
-    try {
-      const enriched = await getCrashDetailsProvider()?.getCrashDetails?.({
-        processName: details?.processName,
-        pid: details?.pid,
-        occurredAt: Date.now(),
-      });
-      const merged = mergeCrashDetails(phase, details, enriched, fallbackSummary);
-      crashLogger.debug('crash details: %o', {
-        phase: merged.phase,
-        source: merged.source,
-        summary: merged.summary,
-        signal: merged.signal,
-        exceptionType: merged.exceptionType,
-        processName: merged.processName,
-        pid: merged.pid,
-      });
-      notifyCrash(new NativeCrashError(currentTestFilePath, merged));
-    } finally {
-      isResolvingCrash = false;
+  const clearPendingTimer = () => {
+    if (pendingTimer) {
+      clearTimeout(pendingTimer);
+      pendingTimer = null;
     }
   };
 
-  const confirmAndHandleCrash = async (
-    phase: NativeCrashPhase,
-    details?: AppCrashDetails,
-    fallbackSummary?: string,
+  const classify = async (
+    pending: PendingCrash,
+    trigger: 'bridge-disconnect' | 'app-exit'
   ) => {
-    if (disposed || !monitoring) return;
+    if (disposed || !monitoring || isResolvingCrash) {
+      return;
+    }
+
+    isResolvingCrash = true;
+
     try {
-      const isRunning = await platformRunner.isAppRunning();
-      if (!isRunning) {
-        void handleCrash(phase, details, fallbackSummary);
+      const session = appSession;
+      const state = await session?.getState();
+      const logs = session?.getLogs() ?? [];
+      const rawLines = getMatchingCrashLines(logs, pending.occurredAt);
+
+      if (state?.status === 'running' && trigger === 'bridge-disconnect') {
+        crashLogger.debug(
+          'runtime bridge disconnected without confirmed app death'
+        );
+        notifyFailure(
+          new RuntimeDisconnectError(
+            pending.testFilePath,
+            buildRuntimeDisconnectDetails(pending.phase, rawLines)
+          )
+        );
+        return;
       }
-    } catch (error) {
-      crashLogger.debug('crash confirmation failed', error);
+
+      alive = false;
+      crashLogger.debug('native crash detected (phase=%s)', pending.phase);
+      for (const line of rawLines) {
+        crashLogger.debug('%s', line);
+      }
+
+      const fallbackSummary =
+        trigger === 'bridge-disconnect'
+          ? 'The app process exited after the runtime bridge disconnected, but no crash log lines were found.'
+          : 'The app process exited, but no crash log lines were found.';
+      const details = buildNativeCrashDetails(
+        pending.phase,
+        rawLines,
+        fallbackSummary
+      );
+      const extractedDetails = session?.getCrashDetails
+        ? await session
+            .getCrashDetails({
+              occurredAt: pending.occurredAt,
+              pid: getStatePid(state),
+              processName: details.processName,
+              testFilePath: pending.testFilePath,
+            })
+            .catch((error) => {
+              crashLogger.warn(
+                'failed to extract native crash details: %s',
+                error
+              );
+              return null;
+            })
+        : null;
+      notifyFailure(
+        new NativeCrashError(
+          pending.testFilePath,
+          mergeCrashDetails(details, extractedDetails)
+        )
+      );
+    } finally {
+      isResolvingCrash = false;
+      pendingTimer = null;
     }
   };
 
-  const extractCrashDetails = (
-    event: Extract<AppMonitorEvent, { type: 'app_exited' | 'possible_crash' }>,
-  ): AppCrashDetails | undefined =>
-    event.crashDetails
-      ? {
-          source: event.crashDetails.source ?? event.source,
-          summary: event.crashDetails.summary,
-          signal: event.crashDetails.signal,
-          exceptionType: event.crashDetails.exceptionType,
-          processName: event.crashDetails.processName,
-          pid: event.crashDetails.pid ?? event.pid,
-          stackTrace: event.crashDetails.stackTrace,
-          rawLines:
-            event.crashDetails.rawLines ??
-            (event.line ? [event.line] : undefined),
-        }
-      : undefined;
-
-  const appMonitorListener: AppMonitorListener = (event: AppMonitorEvent) => {
-    if (disposed || !monitoring) return;
-
-    if (event.type === 'app_started') {
-      alive = true;
+  const startCrashResolution = (trigger: 'bridge-disconnect' | 'app-exit') => {
+    if (disposed || !monitoring || isResolvingCrash) {
       return;
     }
 
+    clearPendingTimer();
+    const pending: PendingCrash = {
+      testFilePath: currentTestFilePath,
+      phase: currentPhase,
+      occurredAt: Date.now(),
+    };
+
+    pendingTimer = setTimeout(
+      () => {
+        void classify(pending, trigger);
+      },
+      trigger === 'bridge-disconnect' ? CRASH_CLASSIFICATION_SETTLE_MS : 0
+    );
+  };
+
+  const appSessionListener: AppSessionListener = (event: AppSessionEvent) => {
     if (event.type === 'app_exited') {
-      const details = extractCrashDetails(event);
-      if (event.isConfirmed ?? event.source === 'polling') {
-        void handleCrash(currentPhase, details);
-      } else {
-        void confirmAndHandleCrash(currentPhase, details);
-      }
-      return;
+      startCrashResolution('app-exit');
     }
+  };
 
-    if (event.type === 'possible_crash') {
-      const details = extractCrashDetails(event);
-      const fallback = `possible crash signal (${event.source ?? 'unknown'})`;
-      if (event.isConfirmed) {
-        void handleCrash(currentPhase, details, fallback);
-      } else {
-        void confirmAndHandleCrash(currentPhase, details, fallback);
-      }
-    }
+  const setAppSession = (session: AppSession | null) => {
+    appSession?.removeListener(appSessionListener);
+    appSession = session;
+    alive = Boolean(session);
+    session?.addListener(appSessionListener);
   };
 
-  appMonitor.addListener(appMonitorListener);
+  setAppSession(initialAppSession);
 
   const watch = (testFilePath: string, phase: NativeCrashPhase): CrashWatch => {
     currentTestFilePath = testFilePath;
@@ -219,30 +281,57 @@ export const createCrashMonitor = ({
     return { promise, cancel };
   };
 
+  const expectDisconnect = (): (() => void) => {
+    expectedDisconnectDepth += 1;
+    let closed = false;
+
+    return () => {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      expectedDisconnectDepth = Math.max(0, expectedDisconnectDepth - 1);
+    };
+  };
+
   return {
     watch,
     isAlive: () => alive,
     stop: async () => {
       monitoring = false;
-      await appMonitor.stop();
+      clearPendingTimer();
+      await sleep(0);
     },
     start: async () => {
       monitoring = true;
-      await appMonitor.start();
     },
     reset: () => {
-      alive = false;
+      alive = Boolean(appSession);
       watchers.clear();
       isResolvingCrash = false;
       currentTestFilePath = '';
+      expectedDisconnectDepth = 0;
+      clearPendingTimer();
     },
+    setAppSession,
+    handleBridgeDisconnect: () => {
+      if (expectedDisconnectDepth > 0) {
+        crashLogger.debug('ignoring expected bridge disconnect');
+        return;
+      }
+      startCrashResolution('bridge-disconnect');
+    },
+    expectDisconnect,
     dispose: async () => {
       disposed = true;
       monitoring = false;
+      expectedDisconnectDepth = 0;
       watchers.clear();
       isResolvingCrash = false;
-      appMonitor.removeListener(appMonitorListener);
-      await appMonitor.dispose();
+      clearPendingTimer();
+      appSession?.removeListener(appSessionListener);
+      appSession = null;
+      alive = false;
     },
   };
 };