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

package/dist/__tests__/execute-run.test.js

@@ -1,6 +1,6 @@
 import { describe, expect, it, vi, beforeEach } from 'vitest';
 import { NativeCrashError, StartupStallError } from '../errors.js';
-import { DeviceNotRespondingError } from '@react-native-harness/bridge/server';
+import { AppBridgeDisconnectedError, DeviceNotRespondingError, } from '@react-native-harness/bridge/server';
 import { executeRun } from '../execute-run.js';
 const resolveUndefined = async () => undefined;
 // Mock the file-runner so we control what jestResult/harnessResult each test returns
@@ -66,18 +66,38 @@ const makeSession = (overrides = {}) => ({
         host: undefined,
         resetEnvironmentBetweenTestFiles: false,
         detectNativeCrashes: true,
+        runners: [
+            { platformId: 'android', name: 'android' },
+            { platformId: 'ios', name: 'ios' },
+        ],
+    },
+    context: {
+        platform: {
+            platformId: 'android',
+            name: 'android',
+            runner: '/virtual/android-runner.js',
+            cli: '/virtual/android-cli.js',
+            config: {},
+        },
     },
-    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 = () => {
+    const calls = [];
+    const emitEvent = (async (...eventData) => {
+        calls.push(eventData);
+    });
+    return { emitEvent, calls };
+};
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
@@ -92,7 +112,7 @@ describe('executeRun', () => {
             const session = makeSession({
                 callHook: vi.fn(async (name) => { hookNames.push(name); }),
             });
-            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');
         });
@@ -101,7 +121,7 @@ describe('executeRun', () => {
             const session = makeSession({
                 callHook: vi.fn(async (name) => { hookNames.push(name); }),
             });
-            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');
             expect(fileHooks).toEqual([
                 'test-file:started', 'test-file:finished',
@@ -114,24 +134,35 @@ describe('executeRun', () => {
                 callHook: vi.fn(async (name) => { hookNames.push(name); }),
                 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 = [];
             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 = (async (eventName, ..._eventData) => {
+                if (eventName === 'test-file-start') {
+                    order.push('test-file-start');
+                }
+                if (eventName === 'test-file-success') {
+                    order.push('test-file-success');
+                }
+            });
             mockRunHarnessTestFile.mockImplementation(async () => {
                 order.push('runTestFile');
                 return makeFileRunResult();
             });
-            await executeRun(session, [makeTest()], makeWatcher(), onStart, onResult, vi.fn(), makeGlobalConfig());
-            expect(order).toEqual(['onStart', 'ensureAppReady', 'runTestFile', 'onResult']);
+            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;
@@ -142,7 +173,7 @@ describe('executeRun', () => {
                 }),
             });
             mockRunHarnessTestFile.mockResolvedValue(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;
             expect(payload.summary.passed).toBe(6);
             expect(payload.status).toBe('passed');
@@ -154,34 +185,124 @@ describe('executeRun', () => {
                     .mockReturnValueOnce([])
                     .mockReturnValueOnce(clientLogs),
             });
-            const onResult = vi.fn();
-            await executeRun(session, [makeTest()], makeWatcher(), vi.fn(), onResult, vi.fn(), makeGlobalConfig());
+            const { emitEvent, calls } = makeEmitEvent();
+            await executeRun(session, [makeTest()], makeWatcher(), emitEvent, makeGlobalConfig());
             expect(session.flushClientLogs).toHaveBeenCalledTimes(2);
-            expect(onResult).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({ console: clientLogs }));
+            expect(calls).toContainEqual([
+                'test-file-success',
+                expect.anything(),
+                expect.objectContaining({ console: clientLogs }),
+            ]);
+        });
+        it('emits test-case events before file success', async () => {
+            let testRunnerListener;
+            const { emitEvent, calls: emittedEvents } = makeEmitEvent();
+            const session = makeSession({
+                onTestRunnerEvent: vi.fn((listener) => {
+                    testRunnerListener = listener;
+                    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());
-            expect(onFailure).toHaveBeenCalledWith(expect.objectContaining({ path: '/test/example.ts' }), expect.objectContaining({ message: expect.stringContaining('1500'), stack: '' }));
+            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 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());
-            expect(onFailure).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({ stack: '' }));
+            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(), vi.fn(), vi.fn(), vi.fn(), makeGlobalConfig());
+            await executeRun(session, [makeTest()], makeWatcher(), makeEmitEvent().emitEvent, makeGlobalConfig());
             expect(session.resetCrashState).toHaveBeenCalled();
         });
         it('counts runtime failures in the summary', async () => {
@@ -193,7 +314,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;
             expect(payload.summary.failed).toBe(1);
             expect(payload.status).toBe('failed');
@@ -205,10 +326,10 @@ describe('executeRun', () => {
             const session = makeSession({
                 callHook: vi.fn(async (name) => { hookNames.push(name); }),
             });
-            const onStart = vi.fn();
-            await executeRun(session, [makeTest('/a.ts'), makeTest('/b.ts')], makeWatcher(true /* interrupted */), onStart, vi.fn(), vi.fn(), makeGlobalConfig());
+            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(onStart).not.toHaveBeenCalled();
+            expect(calls).not.toContainEqual(['test-file-start', expect.anything()]);
             expect(hookNames).toContain('run:finished');
         });
     });
@@ -219,11 +340,54 @@ describe('executeRun', () => {
                     metroPort: 8081,
                     resetEnvironmentBetweenTestFiles: true,
                     detectNativeCrashes: false,
+                    runners: [
+                        { platformId: 'android', name: 'android' },
+                        { platformId: 'ios', name: 'ios' },
+                    ],
                 },
             });
-            await executeRun(session, [makeTest('/a.ts'), makeTest('/b.ts'), makeTest('/c.ts')], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeGlobalConfig());
+            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' },
+                    ],
+                },
+            });
+            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/dist/__tests__/harness-session.test.js

@@ -1,250 +1,74 @@
-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 { describe, expect, it, vi } from 'vitest';
+import { waitForBridgeDisconnectOrTimeout, waitForStartupCrash, } from '../harness-session.js';
+const createConnection = () => ({
+    device: {
+        platform: 'ios',
+        manufacturer: 'Apple',
+        model: 'iPhone',
+        osVersion: '18.0',
     },
+    runTests: 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;
         },
-    ],
-    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,
+        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?.();
+        },
+    };
 };
-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('waitForStartupCrash', () => {
+    it('does not install a startup crash watch when native crash detection is disabled', async () => {
+        const watch = vi.fn();
+        const crashMonitor = {
+            watch,
         };
-        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');
-        });
-        deviceState.permissions.apply.mockImplementation(async () => {
-            callOrder.push('applyConfiguredPermissions');
-            return { mutation: null };
-        });
-        platformRunner.stopApp = vi.fn(async () => {
-            callOrder.push('stopApp');
-        });
-        await session.restartApp('/test/example.ts');
-        expect(deviceState.permissions.resetOutstanding).toHaveBeenCalledTimes(1);
-        expect(deviceState.permissions.apply).toHaveBeenCalledWith({
-            kind: 'permission-all',
-            decision: 'grant',
-        });
-        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');
-        });
-        platformRunner.dispose = vi.fn(async () => {
-            callOrder.push('dispose');
+        const controller = new AbortController();
+        const waitPromise = waitForStartupCrash({
+            crashMonitor,
+            detectNativeCrashes: false,
+            testFilePath: '/test.harness.ts',
+            signal: controller.signal,
         });
-        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(new DOMException('Aborted', 'AbortError'));
+        await expect(waitPromise).rejects.toThrow('Aborted');
+        expect(watch).not.toHaveBeenCalled();
     });
 });