@react-native-harness/jest 1.3.0 → 1.4.0

package/dist/__tests__/harness-session.test.js

@@ -1,250 +1,233 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { createHarnessSession } from '../harness-session.js';
-const pluginManagerMocks = vi.hoisted(() => ({
-    callHook: vi.fn(async () => undefined),
-}));
-const getConfigMock = vi.hoisted(() => vi.fn());
-const resolveHarnessMetroPortMock = vi.hoisted(() => vi.fn());
-const getMetroInstanceMock = vi.hoisted(() => vi.fn());
-const createHarnessBridgeMock = vi.hoisted(() => vi.fn());
-const createCrashMonitorMock = vi.hoisted(() => vi.fn());
-vi.mock('@react-native-harness/plugins', async () => {
-    const actual = await vi.importActual('@react-native-harness/plugins');
-    return {
-        ...actual,
-        createHarnessPluginManager: vi.fn(() => ({
-            callHook: pluginManagerMocks.callHook,
-        })),
-    };
-});
-vi.mock('@react-native-harness/config', async () => {
-    const actual = await vi.importActual('@react-native-harness/config');
-    return {
-        ...actual,
-        getConfig: getConfigMock,
-    };
-});
-vi.mock('../metro-port.js', async () => {
-    const actual = await vi.importActual('../metro-port.js');
-    return {
-        ...actual,
-        resolveHarnessMetroPort: resolveHarnessMetroPortMock,
-    };
-});
-vi.mock('@react-native-harness/bundler-metro', async () => {
-    const actual = await vi.importActual('@react-native-harness/bundler-metro');
-    return {
-        ...actual,
-        getMetroInstance: getMetroInstanceMock,
-    };
-});
-vi.mock('@react-native-harness/bridge/server', async () => {
-    const actual = await vi.importActual('@react-native-harness/bridge/server');
-    return {
-        ...actual,
-        createHarnessBridge: createHarnessBridgeMock,
-    };
-});
-vi.mock('../crash-monitor.js', async () => {
-    const actual = await vi.importActual('../crash-monitor.js');
-    return {
-        ...actual,
-        createCrashMonitor: createCrashMonitorMock,
-    };
-});
-const createAppMonitor = () => ({
-    start: vi.fn(async () => undefined),
-    stop: vi.fn(async () => undefined),
-    dispose: vi.fn(async () => undefined),
-    addListener: vi.fn(),
-    removeListener: vi.fn(),
-});
-const makeBridge = () => ({
-    ws: {},
-    connection: null,
-    on: vi.fn(),
-    off: vi.fn(),
-    nextConnection: vi.fn(),
-    dispose: vi.fn(async () => undefined),
-});
-const makeMetroInstance = () => ({
-    events: {
-        addListener: vi.fn(),
-        removeListener: vi.fn(),
-    },
-    waitUntilHealthy: vi.fn(async () => 'packager-status:running'),
-    prewarm: vi.fn(async () => false),
-    dispose: vi.fn(async () => undefined),
-});
-const makeLockManager = () => ({
-    acquire: vi.fn(async () => ({
-        release: vi.fn(async () => undefined),
-    })),
-});
-const makeCrashMonitor = () => ({
-    watch: vi.fn(),
-    isAlive: vi.fn(() => false),
-    stop: vi.fn(async () => undefined),
-    start: vi.fn(async () => undefined),
-    reset: vi.fn(),
-    dispose: vi.fn(async () => undefined),
-});
-const makeDeviceState = () => ({
-    permissions: {
-        apply: vi.fn(async () => ({ mutation: null })),
-        revert: vi.fn(),
-        resetOutstanding: vi.fn(async () => undefined),
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { getSignalExitCodeForRunState, waitForBridgeDisconnectOrTimeout, waitForNextConnected, waitForStartupCrash, withPlatformReadyTimeout, } from '../harness-session.js';
+import { PlatformReadyTimeoutError } from '../errors.js';
+const createConnection = () => ({
+    device: {
+        platform: 'ios',
+        manufacturer: 'Apple',
+        model: 'iPhone',
+        osVersion: '18.0',
     },
+    runTests: vi.fn(),
+    resetEnvironment: vi.fn(),
 });
-const makePlatformRunner = (overrides = {}) => ({
-    startApp: vi.fn(async () => undefined),
-    restartApp: vi.fn(async () => undefined),
-    stopApp: vi.fn(async () => undefined),
-    dispose: vi.fn(async () => undefined),
-    isAppRunning: vi.fn(async () => false),
-    createAppMonitor: vi.fn(() => createAppMonitor()),
-    ...overrides,
-});
-const globalConfig = {
-    rootDir: '/project',
-    watch: false,
-    watchAll: false,
-    collectCoverage: false,
-};
-const harnessConfig = {
-    entryPoint: 'index.js',
-    appRegistryComponentName: 'App',
-    runners: [
-        {
-            name: 'ios',
-            platformId: 'ios',
-            runner: './__tests__/fixtures/mock-platform-runner.ts',
-            config: {},
+const createBridge = (connection) => {
+    let currentConnection = connection;
+    let disconnectedListener = null;
+    return {
+        get connection() {
+            return currentConnection;
+        },
+        on: vi.fn((event, listener) => {
+            if (event === 'disconnected') {
+                disconnectedListener = listener;
+            }
+        }),
+        off: vi.fn((event, listener) => {
+            if (event === 'disconnected' && disconnectedListener === listener) {
+                disconnectedListener = null;
+            }
+        }),
+        disconnect: () => {
+            currentConnection = null;
+            disconnectedListener?.();
         },
-    ],
-    defaultRunner: 'ios',
-    metroPort: 8081,
-    bridgeTimeout: 1000,
-    platformReadyTimeout: 1000,
-    bundleStartTimeout: 1000,
-    maxAppRestarts: 1,
-    resetEnvironmentBetweenTestFiles: true,
-    detectNativeCrashes: false,
-    forwardClientLogs: false,
-    permissions: false,
-    plugins: [],
-    unstable__skipAlreadyIncludedModules: false,
-    unstable__enableMetroCache: false,
-    disableViewFlattening: false,
+    };
 };
-describe('createHarnessSession permission cleanup', () => {
-    let bridge;
-    let metroInstance;
-    let crashMonitor;
-    let lockManager;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        bridge = makeBridge();
-        metroInstance = makeMetroInstance();
-        crashMonitor = makeCrashMonitor();
-        lockManager = makeLockManager();
-        getConfigMock.mockResolvedValue({ config: harnessConfig });
-        resolveHarnessMetroPortMock.mockResolvedValue({
-            config: harnessConfig,
-            initialMetroPort: 8081,
-            didFallback: false,
-            metroPortLease: { release: vi.fn(async () => undefined) },
+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,
         });
-        getMetroInstanceMock.mockResolvedValue(metroInstance);
-        createHarnessBridgeMock.mockResolvedValue(bridge);
-        createCrashMonitorMock.mockReturnValue(crashMonitor);
+        bridge.disconnect();
+        await expect(waitPromise).resolves.toBe(true);
     });
-    afterEach(() => {
-        delete globalThis.__HARNESS_TEST_PLATFORM_RUNNER__;
+    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);
     });
-    it('resets outstanding permission mutations before restart between test files', async () => {
-        const deviceState = makeDeviceState();
-        const platformRunner = makePlatformRunner({
-            deviceState,
-            isAppRunning: vi.fn(async () => true),
-        });
-        bridge.connection = {};
-        crashMonitor.isAlive.mockReturnValue(true);
-        globalThis.__HARNESS_TEST_PLATFORM_RUNNER__ = platformRunner;
-        const session = await createHarnessSession(globalConfig, { lockManager });
-        const callOrder = [];
-        deviceState.permissions.resetOutstanding.mockImplementation(async () => {
-            callOrder.push('resetOutstanding');
-        });
-        platformRunner.stopApp = vi.fn(async () => {
-            callOrder.push('stopApp');
-        });
-        await session.restartApp('/test/example.ts');
-        expect(deviceState.permissions.resetOutstanding).toHaveBeenCalledTimes(1);
-        expect(deviceState.permissions.apply).not.toHaveBeenCalled();
-        expect(callOrder).toEqual(['resetOutstanding', 'stopApp']);
-        await session.dispose();
-    });
-    it('reapplies configured permissions after cleanup before restart between test files', async () => {
-        const deviceState = makeDeviceState();
-        const platformRunner = makePlatformRunner({
-            deviceState,
-            isAppRunning: vi.fn(async () => true),
-        });
-        bridge.connection = {};
-        crashMonitor.isAlive.mockReturnValue(true);
-        globalThis.__HARNESS_TEST_PLATFORM_RUNNER__ = platformRunner;
-        const permissionsEnabledConfig = {
-            ...harnessConfig,
-            permissions: true,
+});
+describe('waitForNextConnected', () => {
+    const createConnectableBridge = () => {
+        let listener = null;
+        const bridge = {
+            on: vi.fn((event, l) => {
+                if (event === 'connected')
+                    listener = l;
+            }),
+            off: vi.fn((event, l) => {
+                if (event === 'connected' && listener === l)
+                    listener = null;
+            }),
         };
-        getConfigMock.mockResolvedValue({ config: permissionsEnabledConfig });
-        resolveHarnessMetroPortMock.mockResolvedValue({
-            config: permissionsEnabledConfig,
-            initialMetroPort: 8081,
-            didFallback: false,
-            metroPortLease: { release: vi.fn(async () => undefined) },
-        });
-        const session = await createHarnessSession(globalConfig, { lockManager });
-        const callOrder = [];
-        deviceState.permissions.apply.mockClear();
-        deviceState.permissions.resetOutstanding.mockImplementation(async () => {
-            callOrder.push('resetOutstanding');
+        return { bridge, emitConnected: () => listener?.() };
+    };
+    it('resolves when the bridge emits a connected event', async () => {
+        const { bridge, emitConnected } = createConnectableBridge();
+        const controller = new AbortController();
+        const waitPromise = waitForNextConnected({ bridge, signal: controller.signal });
+        emitConnected();
+        await expect(waitPromise).resolves.toBeUndefined();
+    });
+    it('rejects when the signal aborts before a connected event', async () => {
+        const { bridge } = createConnectableBridge();
+        const controller = new AbortController();
+        const waitPromise = waitForNextConnected({ bridge, signal: controller.signal });
+        controller.abort(new DOMException('Aborted', 'AbortError'));
+        await expect(waitPromise).rejects.toThrow('Aborted');
+    });
+    it('rejects immediately when the signal is already aborted', async () => {
+        const { bridge } = createConnectableBridge();
+        const controller = new AbortController();
+        controller.abort(new DOMException('Aborted', 'AbortError'));
+        await expect(waitForNextConnected({ bridge, signal: controller.signal })).rejects.toThrow('Aborted');
+    });
+    it('unsubscribes the connected listener once settled', async () => {
+        const { bridge, emitConnected } = createConnectableBridge();
+        const controller = new AbortController();
+        const waitPromise = waitForNextConnected({ bridge, signal: controller.signal });
+        emitConnected();
+        await waitPromise;
+        expect(bridge.off).toHaveBeenCalledOnce();
+    });
+});
+describe('waitForStartupCrash', () => {
+    it('does not install a startup crash watch when native crash detection is disabled', async () => {
+        const watch = vi.fn();
+        const crashMonitor = {
+            watch,
+        };
+        const controller = new AbortController();
+        const waitPromise = waitForStartupCrash({
+            crashMonitor,
+            detectNativeCrashes: false,
+            testFilePath: '/test.harness.ts',
+            signal: controller.signal,
         });
-        deviceState.permissions.apply.mockImplementation(async () => {
-            callOrder.push('applyConfiguredPermissions');
-            return { mutation: null };
+        controller.abort(new DOMException('Aborted', 'AbortError'));
+        await expect(waitPromise).rejects.toThrow('Aborted');
+        expect(watch).not.toHaveBeenCalled();
+    });
+    it('removes its abort listener on the session signal once the crash watch wins', async () => {
+        let rejectWatch;
+        const cancel = vi.fn();
+        const watch = vi.fn(() => ({
+            promise: new Promise((_, reject) => {
+                rejectWatch = reject;
+            }),
+            cancel,
+        }));
+        const crashMonitor = { watch };
+        const controller = new AbortController();
+        const addSpy = vi.spyOn(controller.signal, 'addEventListener');
+        const removeSpy = vi.spyOn(controller.signal, 'removeEventListener');
+        const waitPromise = waitForStartupCrash({
+            crashMonitor,
+            detectNativeCrashes: true,
+            testFilePath: '/test.harness.ts',
+            signal: controller.signal,
         });
-        platformRunner.stopApp = vi.fn(async () => {
-            callOrder.push('stopApp');
+        // The crash watch wins the race, not the session signal.
+        rejectWatch(new Error('native crash detected'));
+        await expect(waitPromise).rejects.toThrow('native crash detected');
+        expect(cancel).toHaveBeenCalledTimes(1);
+        // Regression: forgetting to cancel the losing waitForAbort() left its
+        // listener attached to this session-lifetime signal for the rest of
+        // the session — one leaked listener per test file.
+        expect(addSpy).toHaveBeenCalledTimes(1);
+        expect(removeSpy).toHaveBeenCalledTimes(1);
+    });
+});
+describe('withPlatformReadyTimeout', () => {
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    it('passes the real session signal to work, unmodified by the timeout', async () => {
+        const controller = new AbortController();
+        const work = vi.fn(async (signal) => {
+            expect(signal).toBe(controller.signal);
+            return 'ready';
         });
-        await session.restartApp('/test/example.ts');
-        expect(deviceState.permissions.resetOutstanding).toHaveBeenCalledTimes(1);
-        expect(deviceState.permissions.apply).toHaveBeenCalledWith({
-            kind: 'permission-all',
-            decision: 'grant',
+        await expect(withPlatformReadyTimeout({
+            timeout: 1_000,
+            signal: controller.signal,
+            work,
+        })).resolves.toBe('ready');
+        expect(work).toHaveBeenCalledTimes(1);
+    });
+    it('throws PlatformReadyTimeoutError on timeout without aborting the session signal', async () => {
+        vi.useFakeTimers();
+        const controller = new AbortController();
+        // Never resolves within the test; simulates a hung platform init.
+        const work = () => new Promise(() => undefined);
+        const resultPromise = withPlatformReadyTimeout({
+            timeout: 1_000,
+            signal: controller.signal,
+            work,
         });
-        expect(callOrder).toEqual([
-            'resetOutstanding',
-            'applyConfiguredPermissions',
-            'stopApp',
-        ]);
-        await session.dispose();
-    });
-    it('resets outstanding permission mutations during dispose', async () => {
-        const deviceState = makeDeviceState();
-        const callOrder = [];
-        const platformRunner = makePlatformRunner({ deviceState });
-        deviceState.permissions.resetOutstanding.mockImplementation(async () => {
-            callOrder.push('resetOutstanding');
+        await vi.advanceTimersByTimeAsync(1_000);
+        await expect(resultPromise).rejects.toBeInstanceOf(PlatformReadyTimeoutError);
+        expect(controller.signal.aborted).toBe(false);
+    });
+    it('propagates a genuine abort from the session signal as-is', async () => {
+        const controller = new AbortController();
+        const abortReason = new DOMException('Aborted', 'AbortError');
+        const work = (signal) => new Promise((_, reject) => {
+            signal.addEventListener('abort', () => reject(signal.reason));
         });
-        platformRunner.dispose = vi.fn(async () => {
-            callOrder.push('dispose');
+        const resultPromise = withPlatformReadyTimeout({
+            timeout: 1_000,
+            signal: controller.signal,
+            work,
         });
-        globalThis.__HARNESS_TEST_PLATFORM_RUNNER__ = platformRunner;
-        const session = await createHarnessSession(globalConfig, { lockManager });
-        await session.dispose();
-        expect(deviceState.permissions.resetOutstanding).toHaveBeenCalledTimes(1);
-        expect(callOrder).toEqual(['resetOutstanding', 'dispose']);
+        controller.abort(abortReason);
+        await expect(resultPromise).rejects.toBe(abortReason);
+    });
+});
+describe('getSignalExitCodeForRunState', () => {
+    const createRunState = (overrides = {}) => ({
+        completed: true,
+        coverageEnabled: false,
+        runId: 'run-1',
+        startTime: 0,
+        status: 'passed',
+        summary: {
+            failed: 0,
+            passed: 1,
+            skipped: 0,
+            todo: 0,
+        },
+        testFiles: ['test.harness.ts'],
+        watchMode: false,
+        ...overrides,
+    });
+    it('preserves a successful exit after a completed passing run', () => {
+        expect(getSignalExitCodeForRunState(createRunState())).toBe(0);
+    });
+    it('fails when the run has not completed yet', () => {
+        expect(getSignalExitCodeForRunState(createRunState({ completed: false }))).toBe(1);
+    });
+    it('fails when the completed run has failures', () => {
+        expect(getSignalExitCodeForRunState(createRunState({
+            status: 'failed',
+            summary: {
+                failed: 1,
+                passed: 0,
+                skipped: 0,
+                todo: 0,
+            },
+        }))).toBe(1);
+    });
+    it('fails when no run state is available', () => {
+        expect(getSignalExitCodeForRunState(null)).toBe(1);
     });
 });

package/dist/__tests__/index.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, it, vi, beforeEach } from 'vitest';
-import { HarnessError } from '@react-native-harness/tools';
+import { createDiagnostics, HarnessError } from '@react-native-harness/tools';
 import JestHarness from '../index.js';
 const resolveUndefined = async () => undefined;
 // ---------------------------------------------------------------------------
@@ -8,6 +8,8 @@ const resolveUndefined = async () => undefined;
 const mockSession = {
     config: { metroPort: 8081 },
     context: {},
+    diagnostics: createDiagnostics({ enabled: false }),
+    onTestRunnerEvent: vi.fn(() => () => undefined),
     ensureAppReady: vi.fn(resolveUndefined),
     runTestFile: vi.fn(async () => ({
         name: '',
@@ -17,6 +19,7 @@ const mockSession = {
         duration: 0,
     })),
     restartApp: vi.fn(resolveUndefined),
+    resetEnvironment: vi.fn(resolveUndefined),
     resetCrashState: vi.fn(),
     flushClientLogs: vi.fn(() => []),
     callHook: vi.fn(resolveUndefined),
@@ -41,40 +44,88 @@ const makeTest = () => ({
     context: { config: {} },
 });
 const makeGlobalConfig = (overrides = {}) => ({ rootDir: '/project', watch: false, watchAll: false, collectCoverage: false, ...overrides });
+const typedMockExecuteRun = mockExecuteRun;
+const makeTestCaseStartPayload = () => [
+    '/test/example.ts',
+    {
+        ancestorTitles: [],
+        fullName: 'suite case',
+        mode: undefined,
+        title: 'case',
+        startedAt: 1,
+    },
+];
+const makeTestCaseResultPayload = () => [
+    '/test/example.ts',
+    {
+        ancestorTitles: [],
+        duration: 1,
+        failureDetails: [],
+        failureMessages: [],
+        fullName: 'suite case',
+        numPassingAsserts: 1,
+        startedAt: 1,
+        status: 'passed',
+        title: 'case',
+    },
+];
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
 beforeEach(() => {
     vi.clearAllMocks();
     mockSession.dispose.mockResolvedValue(undefined);
-    mockExecuteRun.mockResolvedValue(undefined);
+    typedMockExecuteRun.mockResolvedValue(undefined);
     mockCreateHarnessSession.mockResolvedValue(mockSession);
 });
 describe('JestHarness', () => {
     describe('session lifecycle', () => {
         it('creates a session on the first run', async () => {
             const runner = new JestHarness(makeGlobalConfig());
-            await runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeOptions());
+            await runner.runTests([makeTest()], makeWatcher(), makeOptions());
             expect(mockCreateHarnessSession).toHaveBeenCalledOnce();
         });
         it('reuses the session across runs in watch mode', async () => {
             const runner = new JestHarness(makeGlobalConfig({ watch: true }));
-            await runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeOptions());
-            await runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeOptions());
+            await runner.runTests([makeTest()], makeWatcher(), makeOptions());
+            await runner.runTests([makeTest()], makeWatcher(), makeOptions());
             expect(mockCreateHarnessSession).toHaveBeenCalledOnce();
             expect(mockSession.dispose).not.toHaveBeenCalled();
         });
         it('disposes the session after each run in normal mode', async () => {
             const runner = new JestHarness(makeGlobalConfig());
-            await runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeOptions());
+            await runner.runTests([makeTest()], makeWatcher(), makeOptions());
             expect(mockSession.dispose).toHaveBeenCalledOnce();
         });
         it('creates a fresh session for each run in normal mode', async () => {
             const runner = new JestHarness(makeGlobalConfig());
-            await runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeOptions());
-            await runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeOptions());
+            await runner.runTests([makeTest()], makeWatcher(), makeOptions());
+            await runner.runTests([makeTest()], makeWatcher(), makeOptions());
             expect(mockCreateHarnessSession).toHaveBeenCalledTimes(2);
         });
+        it('emits registered Jest events', async () => {
+            const runner = new JestHarness(makeGlobalConfig());
+            const listener = vi.fn();
+            const eventPayload = makeTestCaseStartPayload();
+            runner.on('test-case-start', listener);
+            typedMockExecuteRun.mockImplementationOnce(async (_session, _tests, _watcher, emitEvent) => {
+                await emitEvent('test-case-start', ...eventPayload);
+            });
+            await runner.runTests([makeTest()], makeWatcher(), makeOptions());
+            expect(listener).toHaveBeenCalledWith(eventPayload);
+        });
+        it('stops emitting after listener unsubscribe', async () => {
+            const runner = new JestHarness(makeGlobalConfig());
+            const listener = vi.fn();
+            const unsubscribe = runner.on('test-case-result', listener);
+            const eventPayload = makeTestCaseResultPayload();
+            unsubscribe();
+            typedMockExecuteRun.mockImplementationOnce(async (_session, _tests, _watcher, emitEvent) => {
+                await emitEvent('test-case-result', ...eventPayload);
+            });
+            await runner.runTests([makeTest()], makeWatcher(), makeOptions());
+            expect(listener).not.toHaveBeenCalled();
+        });
     });
     describe('error handling', () => {
         it('converts HarnessError into a formatted string before throwing', async () => {
@@ -83,17 +134,17 @@ describe('JestHarness', () => {
             }
             mockCreateHarnessSession.mockRejectedValue(new TestHarnessError());
             const runner = new JestHarness(makeGlobalConfig());
-            await expect(runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeOptions())).rejects.toBeTypeOf('string');
+            await expect(runner.runTests([makeTest()], makeWatcher(), makeOptions())).rejects.toBeTypeOf('string');
         });
         it('propagates non-HarnessError exceptions as-is', async () => {
             const cause = new TypeError('unexpected');
             mockCreateHarnessSession.mockRejectedValue(cause);
             const runner = new JestHarness(makeGlobalConfig());
-            await expect(runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeOptions())).rejects.toBe(cause);
+            await expect(runner.runTests([makeTest()], makeWatcher(), makeOptions())).rejects.toBe(cause);
         });
         it('throws when called without serial flag', async () => {
             const runner = new JestHarness(makeGlobalConfig());
-            await expect(runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), { serial: false })).rejects.toThrow('Parallel test running is not supported');
+            await expect(runner.runTests([makeTest()], makeWatcher(), { serial: false })).rejects.toThrow('Parallel test running is not supported');
         });
     });
 });

package/dist/__tests__/metro-port.test.js

@@ -16,11 +16,13 @@ const createConfig = (overrides = {}) => ({
     disableViewFlattening: false,
     entryPoint: 'index.js',
     forwardClientLogs: false,
+    diagnostics: false,
     maxAppRestarts: 2,
     metroPort: 8081,
     platformReadyTimeout: 300_000,
     resetEnvironmentBetweenTestFiles: true,
     runners: [],
+    testTimeout: 5_000,
     unstable__enableMetroCache: false,
     unstable__skipAlreadyIncludedModules: false,
     ...overrides,

package/dist/__tests__/run.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=run.test.d.ts.map

package/dist/__tests__/run.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/run.test.ts"],"names":[],"mappings":""}