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

package/src/__tests__/errors.test.ts

@@ -1,157 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import path from 'node:path';
-import { AppBridgeDisconnectedError } from '@react-native-harness/bridge/server';
-import { NativeCrashError, PlatformReadyTimeoutError } from '../errors.js';
-
-describe('PlatformReadyTimeoutError', () => {
-  it('includes the configured timeout and config hint', () => {
-    expect(new PlatformReadyTimeoutError(300000).message).toBe(
-      'The platform did not become ready within 300000ms. Increase "platformReadyTimeout" if your device, simulator, or emulator needs more time to start.'
-    );
-  });
-});
-
-describe('NativeCrashError', () => {
-  it('reports the extracted crash log path when available', () => {
-    const error = new NativeCrashError('/tmp/crash.harness.ts', {
-      phase: 'execution',
-      artifactPath: path.join(
-        process.cwd(),
-        '.harness',
-        'crash-reports',
-        'crash.ips'
-      ),
-    });
-
-    expect(error.message).toContain(
-      `Harness extracted the crash log: ${path.join(
-        '.harness',
-        'crash-reports',
-        'crash.ips'
-      )}`
-    );
-  });
-
-  it('lists enrichment artifact paths when available', () => {
-    const error = new NativeCrashError('/tmp/crash.harness.ts', {
-      phase: 'execution',
-      artifactPath: path.join(
-        process.cwd(),
-        '.harness',
-        'crash-reports',
-        'logcat.txt'
-      ),
-      enrichmentArtifacts: [
-        {
-          artifactType: 'dropbox-native-crash',
-          artifactPath: path.join(
-            process.cwd(),
-            '.harness',
-            'crash-reports',
-            'dropbox-native-crash.txt'
-          ),
-        },
-      ],
-    });
-
-    expect(error.message).toContain('Additional crash artifacts:');
-    expect(error.message).toContain(
-      path.join('.harness', 'crash-reports', 'dropbox-native-crash.txt')
-    );
-  });
-
-  it('reports crash log extraction failure when no artifact was pulled', () => {
-    const error = new NativeCrashError('/tmp/crash.harness.ts', {
-      phase: 'execution',
-    });
-
-    expect(error.message).toContain("Harness couldn't extract the crash log.");
-  });
-
-  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.'
-    );
-  });
-});
-
-describe('AppBridgeDisconnectedError', () => {
-  it('explains likely causes without exposing an internal stack', () => {
-    const error = new AppBridgeDisconnectedError('app-disconnected');
-
-    expect(error.message).toBe(
-      'The app bridge disconnected during test execution. This can happen if the app was killed, crashed, reloaded, or restarted while the test file was running.'
-    );
-    expect(error.stack).toBe(`AppBridgeDisconnectedError: ${error.message}`);
-  });
-
-  it('uses a reconnection-specific message when a newer app connection replaces the old one', () => {
-    expect(new AppBridgeDisconnectedError('app-replaced').message).toBe(
-      'The app bridge was replaced by a newer app connection. This can happen when the app reloads, restarts, or reconnects while a test file is still running.'
-    );
-  });
-});

package/src/__tests__/execute-run.test.ts

@@ -1,526 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from 'vitest';
-import type { Config, Test, TestWatcher } from 'jest-runner';
-import type { TestResult as JestTestResult } from '@jest/test-result';
-import type {
-  TestRunnerTestFinishedEvent,
-  TestRunnerTestStartedEvent,
-  TestSuiteResult,
-} from '@react-native-harness/bridge';
-import { NativeCrashError, StartupStallError } from '../errors.js';
-import {
-  AppBridgeDisconnectedError,
-  DeviceNotRespondingError,
-} from '@react-native-harness/bridge/server';
-import type { HarnessSession } from '../harness-session.js';
-import { executeRun } from '../execute-run.js';
-
-type EmitEvent = Parameters<typeof executeRun>[3];
-type RecordedEmitEvent = {
-  emitEvent: EmitEvent;
-  calls: Array<unknown[]>;
-};
-
-const resolveUndefined = async () => undefined;
-
-// Mock the file-runner so we control what jestResult/harnessResult each test returns
-// without needing a real Jest config or Metro bundler.
-const mockRunHarnessTestFile = vi.hoisted(() => vi.fn());
-vi.mock('../run.js', () => ({
-  runHarnessTestFile: mockRunHarnessTestFile,
-}));
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-const makeJestResult = (
-  overrides: Partial<JestTestResult> = {},
-): JestTestResult =>
-  ({
-    testFilePath: '/test/example.ts',
-    testResults: [],
-    failureMessage: null,
-    numFailingTests: 0,
-    numPassingTests: 1,
-    numPendingTests: 0,
-    numTodoTests: 0,
-    leaks: false,
-    openHandles: [],
-    skipped: false,
-    snapshot: {
-      added: 0, fileDeleted: false, matched: 0, unchecked: 0,
-      uncheckedKeys: [], unmatched: 0, updated: 0,
-    },
-    perfStats: { start: 0, end: 1, runtime: 1, slow: false,
-      loadTestEnvironmentStart: 0, loadTestEnvironmentEnd: 0,
-      setupAfterEnvStart: 0, setupAfterEnvEnd: 0,
-      setupFilesStart: 0, setupFilesEnd: 0 },
-    coverage: undefined,
-    ...overrides,
-  } as JestTestResult);
-
-const makeHarnessResult = (status: 'passed' | 'failed' = 'passed'): TestSuiteResult => ({
-  name: 'suite',
-  tests: [],
-  suites: [],
-  status,
-  duration: 50,
-});
-
-const makeFileRunResult = (overrides: Partial<ReturnType<typeof mockRunHarnessTestFile>> = {}) => ({
-  jestResult: makeJestResult(),
-  harnessResult: makeHarnessResult(),
-  relativeTestPath: 'example.ts',
-  duration: 50,
-  ...overrides,
-});
-
-const makeTest = (filePath = '/test/example.ts'): Test => ({
-  path: filePath,
-  context: { config: {} as Config.ProjectConfig },
-} as Test);
-
-const makeWatcher = (interrupted = false): TestWatcher =>
-  ({ isInterrupted: () => interrupted }) as TestWatcher;
-
-const makeGlobalConfig = (overrides: Partial<Config.GlobalConfig> = {}): Config.GlobalConfig =>
-  ({
-    rootDir: '/project',
-    watch: false,
-    watchAll: false,
-    collectCoverage: false,
-    ...overrides,
-  } as Config.GlobalConfig);
-
-const makeSession = (overrides: Partial<HarnessSession> = {}): HarnessSession => ({
-  config: {
-    metroPort: 8081,
-    host: undefined,
-    resetEnvironmentBetweenTestFiles: false,
-    detectNativeCrashes: true,
-    runners: [
-      { platformId: 'android', name: 'android' },
-      { platformId: 'ios', name: 'ios' },
-    ],
-  } as HarnessSession['config'],
-  context: {
-    platform: {
-      platformId: 'android',
-      name: 'android',
-      runner: '/virtual/android-runner.js',
-      cli: '/virtual/android-cli.js',
-      config: {},
-    },
-  } as HarnessSession['context'],
-  ensureAppReady: vi.fn(resolveUndefined),
-  runTestFile: vi.fn(async () => makeHarnessResult()),
-  restartApp: vi.fn(resolveUndefined),
-  resetCrashState: vi.fn(),
-  flushClientLogs: vi.fn(() => []),
-  callHook: vi.fn(resolveUndefined),
-  onTestRunnerEvent: vi.fn(() => () => undefined),
-  setRunState: vi.fn(),
-  dispose: vi.fn(resolveUndefined),
-  ...overrides,
-});
-
-const makeEmitEvent = (): RecordedEmitEvent => {
-  const calls: Array<unknown[]> = [];
-  const emitEvent: EmitEvent = (async (...eventData) => {
-    calls.push(eventData);
-  }) as EmitEvent;
-
-  return { emitEvent, calls };
-};
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-beforeEach(() => {
-  vi.clearAllMocks();
-  mockRunHarnessTestFile.mockResolvedValue(makeFileRunResult());
-});
-
-describe('executeRun', () => {
-  describe('lifecycle hooks', () => {
-    it('emits run:started then run:finished in order', async () => {
-      const hookNames: string[] = [];
-      const session = makeSession({
-        callHook: vi.fn(async (name) => { hookNames.push(name as string); }),
-      });
-
-      await executeRun(session, [makeTest()], makeWatcher(), makeEmitEvent().emitEvent, makeGlobalConfig());
-
-      expect(hookNames[0]).toBe('run:started');
-      expect(hookNames[hookNames.length - 1]).toBe('run:finished');
-    });
-
-    it('emits test-file:started and test-file:finished around each test', async () => {
-      const hookNames: string[] = [];
-      const session = makeSession({
-        callHook: vi.fn(async (name) => { hookNames.push(name as string); }),
-      });
-
-      await executeRun(session, [makeTest('/a.ts'), makeTest('/b.ts')], makeWatcher(), makeEmitEvent().emitEvent, makeGlobalConfig());
-
-      const fileHooks = hookNames.filter((n) =>
-        n === 'test-file:started' || n === 'test-file:finished',
-      );
-      expect(fileHooks).toEqual([
-        'test-file:started', 'test-file:finished',
-        'test-file:started', 'test-file:finished',
-      ]);
-    });
-
-    it('always emits run:finished even when a test throws', async () => {
-      const hookNames: string[] = [];
-      const session = makeSession({
-        callHook: vi.fn(async (name) => { hookNames.push(name as string); }),
-        ensureAppReady: vi.fn(async () => { throw new Error('unexpected'); }),
-      });
-
-      await executeRun(session, [makeTest()], makeWatcher(), makeEmitEvent().emitEvent, makeGlobalConfig());
-
-      expect(hookNames).toContain('run:finished');
-    });
-  });
-
-  describe('happy path', () => {
-    it('emits file start, ensureAppReady, runTestFile, file success in order', async () => {
-      const order: string[] = [];
-      const session = makeSession({
-        ensureAppReady: vi.fn(async () => { order.push('ensureAppReady'); }),
-      });
-      const emitEvent: EmitEvent = (async (eventName, ..._eventData) => {
-        if (eventName === 'test-file-start') {
-          order.push('test-file-start');
-        }
-
-        if (eventName === 'test-file-success') {
-          order.push('test-file-success');
-        }
-      }) as EmitEvent;
-
-      mockRunHarnessTestFile.mockImplementation(async () => {
-        order.push('runTestFile');
-        return makeFileRunResult();
-      });
-
-      await executeRun(session, [makeTest()], makeWatcher(), emitEvent, makeGlobalConfig());
-
-      expect(order).toEqual([
-        'test-file-start',
-        'ensureAppReady',
-        'runTestFile',
-        'test-file-success',
-      ]);
-    });
-
-    it('accumulates passing test counts in run:finished summary', async () => {
-      let finishedPayload: unknown;
-      const session = makeSession({
-        callHook: vi.fn(async (name, payload) => {
-          if (name === 'run:finished') finishedPayload = payload;
-        }),
-      });
-
-      mockRunHarnessTestFile.mockResolvedValue(
-        makeFileRunResult({ jestResult: makeJestResult({ numPassingTests: 3 }) }),
-      );
-
-      await executeRun(session, [makeTest(), makeTest('/b.ts')], makeWatcher(), makeEmitEvent().emitEvent, makeGlobalConfig());
-
-      const payload = finishedPayload as { summary: { passed: number }; status: string };
-      expect(payload.summary.passed).toBe(6);
-      expect(payload.status).toBe('passed');
-    });
-
-    it('attaches buffered client logs to the Jest result', async () => {
-      const clientLogs = [{ message: 'Loaded screen', origin: '', type: 'warn' }] satisfies NonNullable<JestTestResult['console']>;
-      const session = makeSession({
-        flushClientLogs: vi.fn()
-          .mockReturnValueOnce([])
-          .mockReturnValueOnce(clientLogs),
-      });
-      const { emitEvent, calls } = makeEmitEvent();
-
-      await executeRun(
-        session,
-        [makeTest()],
-        makeWatcher(),
-        emitEvent,
-        makeGlobalConfig(),
-      );
-
-      expect(session.flushClientLogs).toHaveBeenCalledTimes(2);
-      expect(calls).toContainEqual([
-        'test-file-success',
-        expect.anything(),
-        expect.objectContaining({ console: clientLogs }),
-      ]);
-    });
-
-    it('emits test-case events before file success', async () => {
-      let testRunnerListener:
-        | ((event: TestRunnerTestStartedEvent | TestRunnerTestFinishedEvent) => void)
-        | undefined;
-      const { emitEvent, calls: emittedEvents } = makeEmitEvent();
-      const session = makeSession({
-        onTestRunnerEvent: vi.fn((listener) => {
-          testRunnerListener = listener as typeof testRunnerListener;
-          return () => undefined;
-        }),
-      });
-
-      mockRunHarnessTestFile.mockImplementation(async () => {
-        testRunnerListener?.({
-          type: 'test-started',
-          file: 'example.ts',
-          suite: 'suite',
-          name: 'works',
-          ancestorTitles: ['suite'],
-          fullName: 'suite works',
-          startedAt: 10,
-          declarationMode: 'only',
-        });
-        testRunnerListener?.({
-          type: 'test-finished',
-          file: 'example.ts',
-          suite: 'suite',
-          name: 'works',
-          ancestorTitles: ['suite'],
-          fullName: 'suite works',
-          startedAt: 10,
-          declarationMode: 'only',
-          duration: 5,
-          status: 'passed',
-        });
-
-        return makeFileRunResult();
-      });
-
-      await executeRun(session, [makeTest()], makeWatcher(), emitEvent, makeGlobalConfig());
-
-      expect(emittedEvents).toEqual([
-        ['test-file-start', expect.anything()],
-        [
-          'test-case-start',
-          'example.ts',
-          expect.objectContaining({
-            ancestorTitles: ['suite'],
-            fullName: 'suite works',
-            mode: 'only',
-            title: 'works',
-            startedAt: 10,
-          }),
-        ],
-        [
-          'test-case-result',
-          'example.ts',
-          expect.objectContaining({
-            ancestorTitles: ['suite'],
-            fullName: 'suite works',
-            numPassingAsserts: 1,
-            startedAt: 10,
-            status: 'passed',
-            title: 'works',
-          }),
-        ],
-        ['test-file-success', expect.anything(), expect.anything()],
-      ]);
-    });
-  });
-
-  describe('runtime failures', () => {
-    it('passes StartupStallError to onFailure with an empty stack', async () => {
-      const { emitEvent, calls } = makeEmitEvent();
-      const session = makeSession({
-        ensureAppReady: vi.fn().mockRejectedValue(new StartupStallError(1500, 3)),
-      });
-
-      await executeRun(session, [makeTest()], makeWatcher(), emitEvent, makeGlobalConfig());
-
-      expect(calls).toContainEqual([
-        'test-file-failure',
-        expect.objectContaining({ path: '/test/example.ts' }),
-        expect.objectContaining({ message: expect.stringContaining('1500'), stack: '' }),
-      ]);
-    });
-
-    it('passes DeviceNotRespondingError to onFailure with an empty stack', async () => {
-      const { emitEvent, calls } = makeEmitEvent();
-      const session = makeSession({
-        ensureAppReady: vi.fn().mockRejectedValue(
-          new DeviceNotRespondingError('runTests', []),
-        ),
-      });
-
-      await executeRun(session, [makeTest()], makeWatcher(), emitEvent, makeGlobalConfig());
-
-      expect(calls).toContainEqual([
-        'test-file-failure',
-        expect.anything(),
-        expect.objectContaining({ stack: '' }),
-      ]);
-    });
-
-    it('passes AppBridgeDisconnectedError to onFailure with an empty stack', async () => {
-      const { emitEvent, calls } = makeEmitEvent();
-      const session = makeSession({
-        ensureAppReady: vi.fn().mockRejectedValue(
-          new AppBridgeDisconnectedError('app-disconnected'),
-        ),
-      });
-
-      await executeRun(session, [makeTest()], makeWatcher(), emitEvent, makeGlobalConfig());
-
-      expect(calls).toContainEqual([
-        'test-file-failure',
-        expect.anything(),
-        expect.objectContaining({
-          message: expect.stringContaining('The app bridge disconnected during test execution.'),
-          stack: '',
-        }),
-      ]);
-    });
-
-    it('calls resetCrashState after a NativeCrashError', async () => {
-      const session = makeSession({
-        ensureAppReady: vi.fn().mockRejectedValue(
-          new NativeCrashError('example.ts', { phase: 'execution', source: 'polling' }),
-        ),
-      });
-
-      await executeRun(session, [makeTest()], makeWatcher(), makeEmitEvent().emitEvent, makeGlobalConfig());
-
-      expect(session.resetCrashState).toHaveBeenCalled();
-    });
-
-    it('counts runtime failures in the summary', async () => {
-      let finishedPayload: unknown;
-      const session = makeSession({
-        callHook: vi.fn(async (name, payload) => {
-          if (name === 'run:finished') finishedPayload = payload;
-        }),
-        ensureAppReady: vi.fn().mockRejectedValue(new StartupStallError(1000, 2)),
-      });
-
-      await executeRun(session, [makeTest()], makeWatcher(), makeEmitEvent().emitEvent, makeGlobalConfig());
-
-      const payload = finishedPayload as { summary: { failed: number }; status: string };
-      expect(payload.summary.failed).toBe(1);
-      expect(payload.status).toBe('failed');
-    });
-  });
-
-  describe('watcher interrupt', () => {
-    it('stops processing tests and still emits run:finished', async () => {
-      const hookNames: string[] = [];
-      const session = makeSession({
-        callHook: vi.fn(async (name) => { hookNames.push(name as string); }),
-      });
-      const { emitEvent, calls } = makeEmitEvent();
-
-      await executeRun(
-        session,
-        [makeTest('/a.ts'), makeTest('/b.ts')],
-        makeWatcher(true /* interrupted */),
-        emitEvent,
-        makeGlobalConfig(),
-      );
-
-      // No test was started; watcher was already interrupted.
-      expect(calls).not.toContainEqual(['test-file-start', expect.anything()]);
-      expect(hookNames).toContain('run:finished');
-    });
-  });
-
-  describe('resetEnvironmentBetweenTestFiles', () => {
-    it('calls restartApp before the second test but not the first', async () => {
-      const session = makeSession({
-        config: {
-          metroPort: 8081,
-          resetEnvironmentBetweenTestFiles: true,
-          detectNativeCrashes: false,
-          runners: [
-            { platformId: 'android', name: 'android' },
-            { platformId: 'ios', name: 'ios' },
-          ],
-        } as HarnessSession['config'],
-      });
-
-      await executeRun(
-        session,
-        [makeTest('/a.ts'), makeTest('/b.ts'), makeTest('/c.ts')],
-        makeWatcher(),
-        makeEmitEvent().emitEvent,
-        makeGlobalConfig(),
-      );
-
-      // restartApp should be called for tests 2 and 3, not test 1.
-      expect(session.restartApp).toHaveBeenCalledTimes(2);
-    });
-  });
-
-  describe('platform-specific test files', () => {
-    it('skips files for other platforms without running them on the device', async () => {
-      const session = makeSession();
-      const { emitEvent, calls } = makeEmitEvent();
-
-      await executeRun(
-        session,
-        [
-          makeTest('/project/smoke.harness.ts'),
-          makeTest('/project/kotlin.android.harness.ts'),
-          makeTest('/project/swift.ios.harness.ts'),
-        ],
-        makeWatcher(),
-        emitEvent,
-        makeGlobalConfig(),
-      );
-
-      expect(mockRunHarnessTestFile).toHaveBeenCalledTimes(2);
-      expect(mockRunHarnessTestFile).toHaveBeenCalledWith(
-        expect.objectContaining({ testPath: '/project/smoke.harness.ts' }),
-      );
-      expect(mockRunHarnessTestFile).toHaveBeenCalledWith(
-        expect.objectContaining({ testPath: '/project/kotlin.android.harness.ts' }),
-      );
-      expect(session.ensureAppReady).toHaveBeenCalledTimes(2);
-      expect(calls).toContainEqual([
-        'test-file-success',
-        expect.objectContaining({ path: '/project/swift.ios.harness.ts' }),
-        expect.objectContaining({ skipped: true }),
-      ]);
-    });
-
-    it('does not restart the app for skipped platform-specific files', async () => {
-      const session = makeSession({
-        config: {
-          metroPort: 8081,
-          resetEnvironmentBetweenTestFiles: true,
-          detectNativeCrashes: false,
-          runners: [
-            { platformId: 'android', name: 'android' },
-            { platformId: 'ios', name: 'ios' },
-          ],
-        } as HarnessSession['config'],
-      });
-
-      await executeRun(
-        session,
-        [
-          makeTest('/project/swift.ios.harness.ts'),
-          makeTest('/project/kotlin.android.harness.ts'),
-        ],
-        makeWatcher(),
-        vi.fn(),
-        makeGlobalConfig(),
-      );
-
-      expect(session.restartApp).not.toHaveBeenCalled();
-      expect(mockRunHarnessTestFile).toHaveBeenCalledTimes(1);
-    });
-  });
-});