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

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

@@ -1,12 +1,25 @@
 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 { TestSuiteResult } from '@react-native-harness/bridge';
+import type {
+  TestRunnerTestFinishedEvent,
+  TestRunnerTestStartedEvent,
+  TestSuiteResult,
+} from '@react-native-harness/bridge';
 import { NativeCrashError, StartupStallError } from '../errors.js';
-import { DeviceNotRespondingError } from '@react-native-harness/bridge/server';
+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
@@ -85,19 +98,41 @@ const makeSession = (overrides: Partial<HarnessSession> = {}): HarnessSession =>
     host: undefined,
     resetEnvironmentBetweenTestFiles: false,
     detectNativeCrashes: true,
+    runners: [
+      { platformId: 'android', name: 'android' },
+      { platformId: 'ios', name: 'ios' },
+    ],
   } as HarnessSession['config'],
-  context: {} as HarnessSession['context'],
+  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
 // ---------------------------------------------------------------------------
@@ -115,7 +150,7 @@ describe('executeRun', () => {
         callHook: vi.fn(async (name) => { hookNames.push(name as string); }),
       });
 
-      await executeRun(session, [makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeGlobalConfig());
+      await executeRun(session, [makeTest()], makeWatcher(), makeEmitEvent().emitEvent, makeGlobalConfig());
 
       expect(hookNames[0]).toBe('run:started');
       expect(hookNames[hookNames.length - 1]).toBe('run:finished');
@@ -127,7 +162,7 @@ describe('executeRun', () => {
         callHook: vi.fn(async (name) => { hookNames.push(name as string); }),
       });
 
-      await executeRun(session, [makeTest('/a.ts'), makeTest('/b.ts')], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeGlobalConfig());
+      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',
@@ -145,29 +180,41 @@ describe('executeRun', () => {
         ensureAppReady: vi.fn(async () => { throw new Error('unexpected'); }),
       });
 
-      await executeRun(session, [makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeGlobalConfig());
+      await executeRun(session, [makeTest()], makeWatcher(), makeEmitEvent().emitEvent, makeGlobalConfig());
 
       expect(hookNames).toContain('run:finished');
     });
   });
 
   describe('happy path', () => {
-    it('calls onStart, ensureAppReady, runTestFile, onResult in order', async () => {
+    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 onStart = vi.fn(async () => { order.push('onStart'); });
-      const onResult = vi.fn(async () => { order.push('onResult'); });
+      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(), onStart, onResult, vi.fn(), makeGlobalConfig());
+      await executeRun(session, [makeTest()], makeWatcher(), emitEvent, makeGlobalConfig());
 
-      expect(order).toEqual(['onStart', 'ensureAppReady', 'runTestFile', 'onResult']);
+      expect(order).toEqual([
+        'test-file-start',
+        'ensureAppReady',
+        'runTestFile',
+        'test-file-success',
+      ]);
     });
 
     it('accumulates passing test counts in run:finished summary', async () => {
@@ -182,7 +229,7 @@ describe('executeRun', () => {
         makeFileRunResult({ jestResult: makeJestResult({ numPassingTests: 3 }) }),
       );
 
-      await executeRun(session, [makeTest(), makeTest('/b.ts')], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeGlobalConfig());
+      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);
@@ -196,55 +243,146 @@ describe('executeRun', () => {
           .mockReturnValueOnce([])
           .mockReturnValueOnce(clientLogs),
       });
-      const onResult = vi.fn();
+      const { emitEvent, calls } = makeEmitEvent();
 
       await executeRun(
         session,
         [makeTest()],
         makeWatcher(),
-        vi.fn(),
-        onResult,
-        vi.fn(),
+        emitEvent,
         makeGlobalConfig(),
       );
 
       expect(session.flushClientLogs).toHaveBeenCalledTimes(2);
-      expect(onResult).toHaveBeenCalledWith(
+      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 onFailure = vi.fn();
+      const { emitEvent, calls } = makeEmitEvent();
       const session = makeSession({
         ensureAppReady: vi.fn().mockRejectedValue(new StartupStallError(1500, 3)),
       });
 
-      await executeRun(session, [makeTest()], makeWatcher(), vi.fn(), vi.fn(), onFailure, makeGlobalConfig());
+      await executeRun(session, [makeTest()], makeWatcher(), emitEvent, makeGlobalConfig());
 
-      expect(onFailure).toHaveBeenCalledWith(
+      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 onFailure = vi.fn();
+      const { emitEvent, calls } = makeEmitEvent();
       const session = makeSession({
         ensureAppReady: vi.fn().mockRejectedValue(
           new DeviceNotRespondingError('runTests', []),
         ),
       });
 
-      await executeRun(session, [makeTest()], makeWatcher(), vi.fn(), vi.fn(), onFailure, makeGlobalConfig());
+      await executeRun(session, [makeTest()], makeWatcher(), emitEvent, makeGlobalConfig());
 
-      expect(onFailure).toHaveBeenCalledWith(
+      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 () => {
@@ -254,7 +392,7 @@ describe('executeRun', () => {
         ),
       });
 
-      await executeRun(session, [makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeGlobalConfig());
+      await executeRun(session, [makeTest()], makeWatcher(), makeEmitEvent().emitEvent, makeGlobalConfig());
 
       expect(session.resetCrashState).toHaveBeenCalled();
     });
@@ -268,7 +406,7 @@ describe('executeRun', () => {
         ensureAppReady: vi.fn().mockRejectedValue(new StartupStallError(1000, 2)),
       });
 
-      await executeRun(session, [makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeGlobalConfig());
+      await executeRun(session, [makeTest()], makeWatcher(), makeEmitEvent().emitEvent, makeGlobalConfig());
 
       const payload = finishedPayload as { summary: { failed: number }; status: string };
       expect(payload.summary.failed).toBe(1);
@@ -282,20 +420,18 @@ describe('executeRun', () => {
       const session = makeSession({
         callHook: vi.fn(async (name) => { hookNames.push(name as string); }),
       });
-      const onStart = vi.fn();
+      const { emitEvent, calls } = makeEmitEvent();
 
       await executeRun(
         session,
         [makeTest('/a.ts'), makeTest('/b.ts')],
         makeWatcher(true /* interrupted */),
-        onStart,
-        vi.fn(),
-        vi.fn(),
+        emitEvent,
         makeGlobalConfig(),
       );
 
       // No test was started; watcher was already interrupted.
-      expect(onStart).not.toHaveBeenCalled();
+      expect(calls).not.toContainEqual(['test-file-start', expect.anything()]);
       expect(hookNames).toContain('run:finished');
     });
   });
@@ -307,6 +443,10 @@ describe('executeRun', () => {
           metroPort: 8081,
           resetEnvironmentBetweenTestFiles: true,
           detectNativeCrashes: false,
+          runners: [
+            { platformId: 'android', name: 'android' },
+            { platformId: 'ios', name: 'ios' },
+          ],
         } as HarnessSession['config'],
       });
 
@@ -314,7 +454,7 @@ describe('executeRun', () => {
         session,
         [makeTest('/a.ts'), makeTest('/b.ts'), makeTest('/c.ts')],
         makeWatcher(),
-        vi.fn(), vi.fn(), vi.fn(),
+        makeEmitEvent().emitEvent,
         makeGlobalConfig(),
       );
 
@@ -322,4 +462,65 @@ describe('executeRun', () => {
       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);
+    });
+  });
 });

package/src/__tests__/harness-session.test.ts

@@ -0,0 +1,93 @@
+import { describe, expect, it, vi } from 'vitest';
+import type { AppConnection } from '@react-native-harness/bridge/server';
+import {
+  waitForBridgeDisconnectOrTimeout,
+  waitForStartupCrash,
+} from '../harness-session.js';
+import type { CrashMonitor } from '../crash-monitor.js';
+
+const createConnection = (): AppConnection => ({
+  device: {
+    platform: 'ios',
+    manufacturer: 'Apple',
+    model: 'iPhone',
+    osVersion: '18.0',
+  },
+  runTests: vi.fn(),
+});
+
+const createBridge = (connection: AppConnection | null) => {
+  let currentConnection = connection;
+  let disconnectedListener: (() => void) | null = null;
+
+  return {
+    get connection() {
+      return currentConnection;
+    },
+    on: vi.fn((event: 'disconnected', listener: () => void) => {
+      if (event === 'disconnected') {
+        disconnectedListener = listener;
+      }
+    }),
+    off: vi.fn((event: 'disconnected', listener: () => void) => {
+      if (event === 'disconnected' && disconnectedListener === listener) {
+        disconnectedListener = null;
+      }
+    }),
+    disconnect: () => {
+      currentConnection = null;
+      disconnectedListener?.();
+    },
+  };
+};
+
+describe('waitForBridgeDisconnectOrTimeout', () => {
+  it('returns true when the bridge disconnects before the timeout', async () => {
+    const connection = createConnection();
+    const bridge = createBridge(connection);
+
+    const waitPromise = waitForBridgeDisconnectOrTimeout({
+      bridge,
+      connection,
+      timeoutMs: 50,
+    });
+
+    bridge.disconnect();
+
+    await expect(waitPromise).resolves.toBe(true);
+  });
+
+  it('returns false when the bridge stays connected through the timeout', async () => {
+    const connection = createConnection();
+    const bridge = createBridge(connection);
+
+    await expect(
+      waitForBridgeDisconnectOrTimeout({
+        bridge,
+        connection,
+        timeoutMs: 10,
+      }),
+    ).resolves.toBe(false);
+  });
+});
+
+describe('waitForStartupCrash', () => {
+  it('does not install a startup crash watch when native crash detection is disabled', async () => {
+    const watch = vi.fn();
+    const crashMonitor = {
+      watch,
+    } as unknown as CrashMonitor;
+    const controller = new AbortController();
+    const waitPromise = waitForStartupCrash({
+      crashMonitor,
+      detectNativeCrashes: false,
+      testFilePath: '/test.harness.ts',
+      signal: controller.signal,
+    });
+
+    controller.abort(new DOMException('Aborted', 'AbortError'));
+
+    await expect(waitPromise).rejects.toThrow('Aborted');
+    expect(watch).not.toHaveBeenCalled();
+  });
+});