@react-native-harness/jest 1.0.0 → 1.1.0-rc.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-native-harness/jest",
-  "version": "1.0.0",
+  "version": "1.1.0-rc.1",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -40,11 +40,11 @@
     "p-limit": "^7.1.1",
     "tslib": "^2.3.0",
     "yargs": "^17.7.2",
-    "@react-native-harness/platforms": "1.0.0",
-    "@react-native-harness/bridge": "1.0.0",
-    "@react-native-harness/bundler-metro": "1.0.0",
-    "@react-native-harness/tools": "1.0.0",
-    "@react-native-harness/config": "1.0.0"
+    "@react-native-harness/bridge": "1.1.0-rc.1",
+    "@react-native-harness/bundler-metro": "1.1.0-rc.1",
+    "@react-native-harness/config": "1.1.0-rc.1",
+    "@react-native-harness/platforms": "1.1.0-rc.1",
+    "@react-native-harness/tools": "1.1.0-rc.1"
   },
   "devDependencies": {
     "@types/yargs": "^17.0.32",

package/src/__tests__/crash-supervisor.test.ts

@@ -0,0 +1,200 @@
+import { describe, expect, it, vi } from 'vitest';
+import {
+  type AppMonitor,
+  type AppCrashDetails,
+  type AppMonitorEvent,
+  type AppMonitorListener,
+  type HarnessPlatformRunner,
+} from '@react-native-harness/platforms';
+import { createCrashSupervisor } from '../crash-supervisor.js';
+
+type MockCrashDetailsGetter = (
+  options: {
+    processName?: string;
+    pid?: number;
+    occurredAt: number;
+  }
+) => Promise<AppCrashDetails | null>;
+
+const createMockAppMonitor = (options?: {
+  getCrashDetails?: MockCrashDetailsGetter;
+}) => {
+  const listeners = new Set<AppMonitorListener>();
+  const noop = async () => undefined;
+
+  const appMonitor: AppMonitor & {
+    getCrashDetails?: MockCrashDetailsGetter;
+  } = {
+    start: noop,
+    stop: noop,
+    dispose: noop,
+    addListener: (listener) => {
+      listeners.add(listener);
+    },
+    removeListener: (listener) => {
+      listeners.delete(listener);
+    },
+  };
+
+  if (options?.getCrashDetails) {
+    appMonitor.getCrashDetails = options.getCrashDetails;
+  }
+
+  const emit = (event: AppMonitorEvent) => {
+    for (const listener of listeners) {
+      listener(event);
+    }
+  };
+
+  return {
+    appMonitor,
+    emit,
+  };
+};
+
+const createPlatformRunner = ({
+  isAppRunning,
+  getCrashDetails,
+}: {
+  isAppRunning: () => Promise<boolean>;
+  getCrashDetails?: HarnessPlatformRunner['getCrashDetails'];
+}): HarnessPlatformRunner => ({
+  startApp: async () => undefined,
+  restartApp: async () => undefined,
+  stopApp: async () => undefined,
+  dispose: async () => undefined,
+  isAppRunning,
+  createAppMonitor: () => {
+    throw new Error('Not used in unit tests');
+  },
+  getCrashDetails,
+});
+
+describe('crash-supervisor', () => {
+  it('rejects the active test when the app exits during launch', async () => {
+    const monitor = createMockAppMonitor();
+    const supervisor = createCrashSupervisor({
+      appMonitor: monitor.appMonitor,
+      platformRunner: createPlatformRunner({
+        isAppRunning: vi.fn().mockResolvedValue(false),
+      }),
+    });
+
+    supervisor.beginLaunch('/tmp/startup.harness.ts');
+
+    const crashPromise = supervisor.waitForCrash('/tmp/startup.harness.ts');
+    const expectation =
+      expect(crashPromise).rejects.toMatchObject({
+        name: 'NativeCrashError',
+        phase: 'startup',
+        details: {
+          signal: 'SIGSEGV',
+          processName: 'com.harnessplayground',
+        },
+      });
+    monitor.emit({
+      type: 'app_exited',
+      source: 'logs',
+      crashDetails: {
+        source: 'logs',
+        signal: 'SIGSEGV',
+        processName: 'com.harnessplayground',
+        rawLines: ['Fatal signal 11 (SIGSEGV)'],
+      },
+    });
+
+    await expectation;
+    await supervisor.dispose();
+  });
+
+  it('treats polling exit events as immediately confirmed crashes', async () => {
+    const monitor = createMockAppMonitor();
+    const isAppRunning = vi.fn().mockResolvedValue(true);
+    const supervisor = createCrashSupervisor({
+      appMonitor: monitor.appMonitor,
+      platformRunner: createPlatformRunner({
+        isAppRunning,
+      }),
+    });
+
+    supervisor.beginLaunch('/tmp/polling-exit.harness.ts');
+
+    const crashPromise = supervisor.waitForCrash('/tmp/polling-exit.harness.ts');
+    monitor.emit({ type: 'app_exited', source: 'polling' });
+
+    await expect(crashPromise).rejects.toMatchObject({
+      name: 'NativeCrashError',
+      phase: 'startup',
+    });
+    expect(isAppRunning).not.toHaveBeenCalled();
+    await supervisor.dispose();
+  });
+
+  it('does not reject when monitoring is stopped', async () => {
+    const monitor = createMockAppMonitor();
+    const supervisor = createCrashSupervisor({
+      appMonitor: monitor.appMonitor,
+      platformRunner: createPlatformRunner({
+        isAppRunning: vi.fn().mockResolvedValue(false),
+      }),
+    });
+
+    supervisor.beginTestRun('/tmp/restart.harness.ts');
+    await supervisor.stop();
+
+    const reject = vi.fn();
+    void supervisor.waitForCrash('/tmp/restart.harness.ts').catch(reject);
+
+    monitor.emit({ type: 'app_exited', source: 'polling' });
+    await Promise.resolve();
+
+    expect(reject).not.toHaveBeenCalled();
+    await supervisor.dispose();
+  });
+
+  it('prefers crash details from the started app monitor over the runner', async () => {
+    const monitorGetCrashDetails = vi.fn().mockResolvedValue({
+      source: 'logs',
+      summary: 'full crash block',
+      rawLines: ['full crash block'],
+    });
+    const runnerGetCrashDetails = vi.fn().mockResolvedValue({
+      source: 'logs',
+      summary: 'runner details',
+      rawLines: ['runner details'],
+    });
+    const monitor = createMockAppMonitor({
+      getCrashDetails: monitorGetCrashDetails,
+    });
+    const supervisor = createCrashSupervisor({
+      appMonitor: monitor.appMonitor,
+      platformRunner: createPlatformRunner({
+        isAppRunning: vi.fn().mockResolvedValue(false),
+        getCrashDetails: runnerGetCrashDetails,
+      }),
+    });
+
+    supervisor.beginTestRun('/tmp/monitor-details.harness.ts');
+
+    const crashPromise = supervisor.waitForCrash('/tmp/monitor-details.harness.ts');
+    monitor.emit({
+      type: 'possible_crash',
+      source: 'logs',
+      crashDetails: {
+        source: 'logs',
+        processName: 'com.harnessplayground',
+        pid: 1234,
+        rawLines: ['partial line'],
+      },
+    });
+
+    await expect(crashPromise).rejects.toMatchObject({
+      details: {
+        summary: 'full crash block',
+      },
+    });
+    expect(monitorGetCrashDetails).toHaveBeenCalled();
+    expect(runnerGetCrashDetails).not.toHaveBeenCalled();
+    await supervisor.dispose();
+  });
+});

package/src/__tests__/errors.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, it } from 'vitest';
+import { NativeCrashError } from '../errors.js';
+
+describe('NativeCrashError', () => {
+  it('formats the extracted stack trace in the error message', () => {
+    const error = new NativeCrashError('/tmp/crash.harness.ts', {
+      phase: 'execution',
+      processName: 'HarnessPlayground',
+      pid: 1234,
+      signal: 'SIGTRAP',
+      exceptionType: 'EXC_BREAKPOINT',
+      stackTrace: [
+        '0 AppDelegate.crashIfRequested() (AppDelegate.swift:31)',
+        '1 AppDelegate.application(_:didFinishLaunchingWithOptions:) (AppDelegate.swift:56)',
+      ],
+    });
+
+    expect(error.message).toContain(
+      '  0 AppDelegate.crashIfRequested() (AppDelegate.swift:31)'
+    );
+    expect(error.message).toContain(
+      '  1 AppDelegate.application(_:didFinishLaunchingWithOptions:) (AppDelegate.swift:56)'
+    );
+  });
+
+  it('omits single-line iOS summaries from the rendered error message', () => {
+    const error = new NativeCrashError('/tmp/crash.harness.ts', {
+      phase: 'startup',
+      artifactType: 'ios-crash-report',
+      summary:
+        '2026-03-12 13:46:18.154 Df HarnessPlayground[18007:65e716] [com.apple.dt.xctest:Default] notify_get_state check indicated test daemon not ready.',
+      processName: 'HarnessPlayground',
+      pid: 18007,
+      signal: 'SIGABRT',
+      exceptionType: 'EXC_CRASH',
+    });
+
+    expect(error.message).not.toContain('notify_get_state check indicated test daemon not ready');
+    expect(error.message).toContain('Signal: SIGABRT');
+    expect(error.message).toContain('Exception: EXC_CRASH');
+    expect(error.message).toContain('Process: HarnessPlayground (pid 18007)');
+  });
+
+  it('does not duplicate stack frames when the summary already contains a crash block', () => {
+    const frame =
+      '03-13 07:59:44.943 20373 20373 E AndroidRuntime: \tat com.harnessplayground.MainActivity.onCreate(MainActivity.kt:38)';
+    const error = new NativeCrashError('/tmp/crash.harness.ts', {
+      phase: 'startup',
+      summary: [
+        '--------- beginning of crash',
+        '03-13 07:59:44.943 20373 20373 E AndroidRuntime: FATAL EXCEPTION: main',
+        frame,
+      ].join('\n'),
+      stackTrace: [frame],
+    });
+
+    expect(error.message.match(/MainActivity\.onCreate\(MainActivity\.kt:38\)/g)).toHaveLength(
+      1
+    );
+  });
+
+  it('collapses the native crash stack header so jest does not reprint multiline messages', () => {
+    const error = new NativeCrashError('/tmp/crash.harness.ts', {
+      phase: 'startup',
+      summary: ['line one', 'line two'].join('\n'),
+    });
+
+    expect(error.stack).toBe('NativeCrashError: The native app crashed while preparing to run this test file.');
+  });
+});

package/src/__tests__/harness.test.ts

@@ -0,0 +1,129 @@
+import { EventEmitter } from 'node:events';
+import { describe, expect, it, vi } from 'vitest';
+import { waitForAppReady } from '../harness.js';
+import type { BridgeServer } from '@react-native-harness/bridge/server';
+import type {
+  AppMonitor,
+  AppMonitorListener,
+  HarnessPlatformRunner,
+} from '@react-native-harness/platforms';
+import { createCrashSupervisor } from '../crash-supervisor.js';
+
+const createBridgeServer = () => {
+  const emitter = new EventEmitter();
+
+  return {
+    serverBridge: {
+      on: emitter.on.bind(emitter),
+      once: emitter.once.bind(emitter),
+      off: emitter.off.bind(emitter),
+    } as unknown as BridgeServer,
+    emitReady: () => {
+      emitter.emit('ready');
+    },
+  };
+};
+
+const createAppMonitor = (): AppMonitor => {
+  const listeners = new Set<AppMonitorListener>();
+
+  return {
+    start: async () => undefined,
+    stop: async () => undefined,
+    dispose: async () => undefined,
+    addListener: (listener) => {
+      listeners.add(listener);
+    },
+    removeListener: (listener) => {
+      listeners.delete(listener);
+    },
+  };
+};
+
+const createPlatformRunner = (
+  restartApp: HarnessPlatformRunner['restartApp']
+): HarnessPlatformRunner => ({
+  startApp: async () => undefined,
+  restartApp,
+  stopApp: async () => undefined,
+  dispose: async () => undefined,
+  isAppRunning: async () => true,
+  createAppMonitor: createAppMonitor,
+});
+
+describe('waitForAppReady', () => {
+  it('passes launch options to the initial launch', async () => {
+    const { serverBridge, emitReady } = createBridgeServer();
+    const restartApp = vi.fn().mockResolvedValue(undefined);
+    const platformInstance = createPlatformRunner(restartApp);
+    const crashSupervisor = createCrashSupervisor({
+      appMonitor: createAppMonitor(),
+      platformRunner: platformInstance,
+    });
+
+    const promise = waitForAppReady({
+      serverBridge,
+      platformInstance,
+      bridgeTimeout: 5000,
+      testFilePath: '/tmp/test.harness.ts',
+      crashSupervisor,
+      appLaunchOptions: {
+        extras: {
+          mode: 'startup',
+        },
+      },
+    });
+
+    await Promise.resolve();
+    expect(restartApp).toHaveBeenCalledWith({
+      extras: {
+        mode: 'startup',
+      },
+    });
+
+    emitReady();
+    await promise;
+    await crashSupervisor.dispose();
+  });
+
+  it('does not retry launch when the app never becomes ready', async () => {
+    vi.useFakeTimers();
+
+    const { serverBridge } = createBridgeServer();
+    const restartApp = vi.fn().mockResolvedValue(undefined);
+    const platformInstance = createPlatformRunner(restartApp);
+    const crashSupervisor = createCrashSupervisor({
+      appMonitor: createAppMonitor(),
+      platformRunner: platformInstance,
+    });
+
+    const promise = waitForAppReady({
+      serverBridge,
+      platformInstance,
+      bridgeTimeout: 1000,
+      testFilePath: '/tmp/test.harness.ts',
+      crashSupervisor,
+      appLaunchOptions: {
+        extras: {
+          mode: 'startup',
+        },
+      },
+    });
+
+    await Promise.resolve();
+    await vi.advanceTimersByTimeAsync(1000);
+
+    await expect(promise).rejects.toMatchObject({
+      name: 'AbortError',
+    });
+    expect(restartApp).toHaveBeenCalledTimes(1);
+    expect(restartApp).toHaveBeenCalledWith({
+      extras: {
+        mode: 'startup',
+      },
+    });
+
+    await crashSupervisor.dispose();
+    vi.useRealTimers();
+  });
+});