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

package/dist/__tests__/bridge.test.js

@@ -28,7 +28,10 @@ afterEach(async () => {
     // Allow the server to close cleanly.
     await new Promise((r) => setTimeout(r, 10));
 });
-const connect = (callbacks = { runTests: vi.fn() }) => connectToHarness(`ws://127.0.0.1:${bridgePort}`, callbacks);
+const connect = (callbacks = {
+    runTests: vi.fn(),
+    resetEnvironment: vi.fn(),
+}) => connectToHarness(`ws://127.0.0.1:${bridgePort}`, callbacks);
 const device = {
     platform: 'ios',
     manufacturer: 'Apple',
@@ -107,7 +110,7 @@ describe('bridge: createHarnessBridge + connectToHarness', () => {
             };
             const runTestsCb = vi.fn(async () => suiteResult);
             const connectionPromise = bridge.nextConnection();
-            const handle = await connect({ runTests: runTestsCb });
+            const handle = await connect({ runTests: runTestsCb, resetEnvironment: vi.fn() });
             handle.reportReady(device);
             const conn = await connectionPromise;
             const result = await conn.runTests('example.ts', {
@@ -120,6 +123,7 @@ describe('bridge: createHarnessBridge + connectToHarness', () => {
         it('rejects pending app calls when a newer client replaces the session', async () => {
             const firstHandle = await connect({
                 runTests: async () => await new Promise(() => undefined),
+                resetEnvironment: vi.fn(),
             });
             firstHandle.reportReady(device);
             const firstConnection = await bridge.nextConnection();

package/dist/__tests__/crash-monitor.test.js

@@ -163,4 +163,68 @@ describe('createCrashMonitor', () => {
         expect(session.removeListener).toHaveBeenCalledOnce();
         expect(cm.isAlive()).toBe(false);
     });
+    describe('expectDisconnect', () => {
+        it('suppresses handleBridgeDisconnect while the window is open', async () => {
+            const { session } = createAppSessionMock({ status: 'running' });
+            const cm = createCrashMonitor({ appSession: session });
+            const watch = cm.watch('test.ts', 'execution');
+            watch.promise.catch(noop);
+            const closeWindow = cm.expectDisconnect();
+            cm.handleBridgeDisconnect();
+            await waitForClassification();
+            const settled = vi.fn();
+            watch.promise.then(settled, settled);
+            await Promise.resolve();
+            expect(settled).not.toHaveBeenCalled();
+            closeWindow();
+            watch.cancel();
+        });
+        it('resumes classifying disconnects once the window closes', async () => {
+            const { session } = createAppSessionMock({ status: 'running' });
+            const cm = createCrashMonitor({ appSession: session });
+            const watch = cm.watch('test.ts', 'execution');
+            watch.promise.catch(noop);
+            const closeWindow = cm.expectDisconnect();
+            closeWindow();
+            cm.handleBridgeDisconnect();
+            await expect(watch.promise).rejects.toBeInstanceOf(RuntimeDisconnectError);
+        });
+        it('keeps the window open until every opener has closed it (nested windows)', async () => {
+            const { session } = createAppSessionMock({ status: 'running' });
+            const cm = createCrashMonitor({ appSession: session });
+            const watch = cm.watch('test.ts', 'execution');
+            watch.promise.catch(noop);
+            const closeFirst = cm.expectDisconnect();
+            const closeSecond = cm.expectDisconnect();
+            closeFirst();
+            cm.handleBridgeDisconnect();
+            await waitForClassification();
+            const settled = vi.fn();
+            watch.promise.then(settled, settled);
+            await Promise.resolve();
+            expect(settled).not.toHaveBeenCalled();
+            closeSecond();
+            watch.cancel();
+        });
+        it('ignores a redundant close() call', async () => {
+            const { session } = createAppSessionMock({ status: 'running' });
+            const cm = createCrashMonitor({ appSession: session });
+            const watch = cm.watch('test.ts', 'execution');
+            watch.promise.catch(noop);
+            const closeWindow = cm.expectDisconnect();
+            closeWindow();
+            closeWindow();
+            cm.handleBridgeDisconnect();
+            await expect(watch.promise).rejects.toBeInstanceOf(RuntimeDisconnectError);
+        });
+        it('clears the expected-disconnect window on dispose', async () => {
+            const { session } = createAppSessionMock({ status: 'running' });
+            const cm = createCrashMonitor({ appSession: session });
+            cm.expectDisconnect();
+            await cm.dispose();
+            // A disconnect after dispose should not throw or hang; monitoring is
+            // fully torn down regardless of the window state.
+            expect(() => cm.handleBridgeDisconnect()).not.toThrow();
+        });
+    });
 });

package/dist/__tests__/environment-reset.test.d.ts

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

package/dist/__tests__/environment-reset.test.d.ts.map

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

package/dist/__tests__/environment-reset.test.js

@@ -0,0 +1,238 @@
+import { describe, expect, it, vi } from 'vitest';
+import { createProcessResetStrategy, createRuntimeResetStrategy, resolveResetStrategyKind, withEscalation, } from '../environment-reset.js';
+describe('resolveResetStrategyKind', () => {
+    it('normalizes true to the process strategy', () => {
+        expect(resolveResetStrategyKind(true)).toBe('process');
+    });
+    it('normalizes false to null (no reset)', () => {
+        expect(resolveResetStrategyKind(false)).toBeNull();
+    });
+    it('passes through the process string value', () => {
+        expect(resolveResetStrategyKind('process')).toBe('process');
+    });
+    it('passes through the runtime string value', () => {
+        expect(resolveResetStrategyKind('runtime')).toBe('runtime');
+    });
+});
+describe('createProcessResetStrategy', () => {
+    it('has kind "process" and delegates to the injected restart function', async () => {
+        const restart = vi.fn(async () => undefined);
+        const strategy = createProcessResetStrategy({ restart });
+        expect(strategy.kind).toBe('process');
+        await strategy.reset({ testFilePath: '/tests/example.harness.ts' });
+        expect(restart).toHaveBeenCalledWith('/tests/example.harness.ts');
+    });
+    it('propagates restart failures', async () => {
+        const restart = vi.fn(async () => {
+            throw new Error('restart failed');
+        });
+        const strategy = createProcessResetStrategy({ restart });
+        await expect(strategy.reset({ testFilePath: '/tests/example.harness.ts' })).rejects.toThrow('restart failed');
+    });
+});
+describe('createRuntimeResetStrategy', () => {
+    const testFilePath = '/tests/example.harness.ts';
+    it('has kind "runtime" and resets via the connection then waits for reconnect', async () => {
+        const callOrder = [];
+        const closeWindow = vi.fn();
+        const connection = {
+            resetEnvironment: vi.fn(async () => {
+                callOrder.push('resetEnvironment');
+            }),
+        };
+        const waitForReconnect = vi.fn(async () => {
+            callOrder.push('waitForReconnect-started');
+        });
+        const strategy = createRuntimeResetStrategy({
+            getConnection: () => connection,
+            expectDisconnect: () => {
+                callOrder.push('expectDisconnect');
+                return closeWindow;
+            },
+            waitForReconnect,
+            isDisconnectError: () => false,
+            timeoutMs: 1000,
+        });
+        expect(strategy.kind).toBe('runtime');
+        await strategy.reset({ testFilePath });
+        expect(callOrder).toEqual([
+            'expectDisconnect',
+            'waitForReconnect-started',
+            'resetEnvironment',
+        ]);
+        expect(waitForReconnect).toHaveBeenCalledWith(expect.any(AbortSignal));
+        expect(closeWindow).toHaveBeenCalledOnce();
+    });
+    it('starts waiting for reconnect before firing the RPC', async () => {
+        const callOrder = [];
+        const connection = {
+            resetEnvironment: vi.fn(async () => {
+                callOrder.push('resetEnvironment');
+            }),
+        };
+        const waitForReconnect = vi.fn(() => {
+            callOrder.push('waitForReconnect-called');
+            return Promise.resolve();
+        });
+        const strategy = createRuntimeResetStrategy({
+            getConnection: () => connection,
+            expectDisconnect: () => () => undefined,
+            waitForReconnect,
+            isDisconnectError: () => false,
+            timeoutMs: 1000,
+        });
+        await strategy.reset({ testFilePath });
+        expect(callOrder).toEqual(['waitForReconnect-called', 'resetEnvironment']);
+    });
+    it('throws when there is no active app connection', async () => {
+        const expectDisconnect = vi.fn();
+        const strategy = createRuntimeResetStrategy({
+            getConnection: () => null,
+            expectDisconnect,
+            waitForReconnect: vi.fn(async () => undefined),
+            isDisconnectError: () => false,
+            timeoutMs: 1000,
+        });
+        await expect(strategy.reset({ testFilePath })).rejects.toThrow('No active app connection');
+        expect(expectDisconnect).not.toHaveBeenCalled();
+    });
+    it('closes the expected-disconnect window even when the RPC call fails', async () => {
+        const closeWindow = vi.fn();
+        const connection = {
+            resetEnvironment: vi.fn(async () => {
+                throw new Error('rpc failed');
+            }),
+        };
+        const strategy = createRuntimeResetStrategy({
+            getConnection: () => connection,
+            expectDisconnect: () => closeWindow,
+            waitForReconnect: vi.fn(async () => undefined),
+            isDisconnectError: () => false,
+            timeoutMs: 1000,
+        });
+        await expect(strategy.reset({ testFilePath })).rejects.toThrow('rpc failed');
+        expect(closeWindow).toHaveBeenCalledOnce();
+    });
+    it('closes the expected-disconnect window even when reconnect times out', async () => {
+        const closeWindow = vi.fn();
+        const connection = { resetEnvironment: vi.fn(async () => undefined) };
+        const strategy = createRuntimeResetStrategy({
+            getConnection: () => connection,
+            expectDisconnect: () => closeWindow,
+            waitForReconnect: vi.fn(async () => {
+                throw new Error('reconnect timed out');
+            }),
+            isDisconnectError: () => false,
+            timeoutMs: 1000,
+        });
+        await expect(strategy.reset({ testFilePath })).rejects.toThrow('reconnect timed out');
+        expect(closeWindow).toHaveBeenCalledOnce();
+    });
+    it('treats a disconnect-flavored RPC rejection as reload-in-flight and succeeds', async () => {
+        const disconnectError = new Error('app bridge disconnected');
+        const connection = {
+            resetEnvironment: vi.fn(async () => {
+                throw disconnectError;
+            }),
+        };
+        const waitForReconnect = vi.fn(async () => undefined);
+        const strategy = createRuntimeResetStrategy({
+            getConnection: () => connection,
+            expectDisconnect: () => () => undefined,
+            waitForReconnect,
+            isDisconnectError: (error) => error === disconnectError,
+            timeoutMs: 1000,
+        });
+        await expect(strategy.reset({ testFilePath })).resolves.toBeUndefined();
+        expect(waitForReconnect).toHaveBeenCalledOnce();
+    });
+    it('still throws on a non-disconnect RPC rejection', async () => {
+        const connection = {
+            resetEnvironment: vi.fn(async () => {
+                throw new Error('rpc failed');
+            }),
+        };
+        const strategy = createRuntimeResetStrategy({
+            getConnection: () => connection,
+            expectDisconnect: () => () => undefined,
+            waitForReconnect: vi.fn(async () => undefined),
+            isDisconnectError: (error) => error instanceof Error && error.message === 'app bridge disconnected',
+            timeoutMs: 1000,
+        });
+        await expect(strategy.reset({ testFilePath })).rejects.toThrow('rpc failed');
+    });
+    it('does not leave an unhandled rejection when the RPC fails before the reconnect wait settles', async () => {
+        let rejectReconnect;
+        const waitForReconnect = vi.fn(() => new Promise((_, reject) => {
+            rejectReconnect = reject;
+        }));
+        const connection = {
+            resetEnvironment: vi.fn(async () => {
+                throw new Error('rpc failed');
+            }),
+        };
+        const unhandled = [];
+        const onUnhandledRejection = (reason) => {
+            unhandled.push(reason);
+        };
+        process.on('unhandledRejection', onUnhandledRejection);
+        try {
+            const strategy = createRuntimeResetStrategy({
+                getConnection: () => connection,
+                expectDisconnect: () => () => undefined,
+                waitForReconnect,
+                isDisconnectError: () => false,
+                timeoutMs: 1000,
+            });
+            await expect(strategy.reset({ testFilePath })).rejects.toThrow('rpc failed');
+            // Simulate the reconnect timeout firing after the strategy already
+            // threw; the strategy must have attached a rejection handler.
+            rejectReconnect(new Error('reconnect timed out'));
+            await new Promise((resolve) => setImmediate(resolve));
+            expect(unhandled).toEqual([]);
+        }
+        finally {
+            process.off('unhandledRejection', onUnhandledRejection);
+        }
+    });
+});
+describe('withEscalation', () => {
+    const testFilePath = '/tests/example.harness.ts';
+    const makeStrategy = (kind, reset) => ({ kind, reset });
+    it('reports the primary strategy kind', () => {
+        const primary = makeStrategy('runtime', async () => undefined);
+        const fallback = makeStrategy('process', async () => undefined);
+        expect(withEscalation(primary, fallback).kind).toBe('runtime');
+    });
+    it('does not call the fallback when the primary succeeds', async () => {
+        const fallbackReset = vi.fn(async () => undefined);
+        const primary = makeStrategy('runtime', async () => undefined);
+        const fallback = makeStrategy('process', fallbackReset);
+        const onEscalate = vi.fn();
+        await withEscalation(primary, fallback, { onEscalate }).reset({ testFilePath });
+        expect(fallbackReset).not.toHaveBeenCalled();
+        expect(onEscalate).not.toHaveBeenCalled();
+    });
+    it('escalates to the fallback when the primary fails', async () => {
+        const primaryError = new Error('runtime reset failed');
+        const fallbackReset = vi.fn(async () => undefined);
+        const primary = makeStrategy('runtime', async () => {
+            throw primaryError;
+        });
+        const fallback = makeStrategy('process', fallbackReset);
+        const onEscalate = vi.fn();
+        await withEscalation(primary, fallback, { onEscalate }).reset({ testFilePath });
+        expect(fallbackReset).toHaveBeenCalledWith({ testFilePath });
+        expect(onEscalate).toHaveBeenCalledWith(primaryError);
+    });
+    it('propagates the fallback error when both strategies fail', async () => {
+        const fallbackError = new Error('process reset also failed');
+        const primary = makeStrategy('runtime', async () => {
+            throw new Error('runtime reset failed');
+        });
+        const fallback = makeStrategy('process', async () => {
+            throw fallbackError;
+        });
+        await expect(withEscalation(primary, fallback).reset({ testFilePath })).rejects.toBe(fallbackError);
+    });
+});

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

@@ -1,6 +1,7 @@
 import { describe, expect, it, vi, beforeEach } from 'vitest';
 import { NativeCrashError, StartupStallError } from '../errors.js';
 import { AppBridgeDisconnectedError, DeviceNotRespondingError, } from '@react-native-harness/bridge/server';
+import { createDiagnostics } from '@react-native-harness/tools';
 import { executeRun } from '../execute-run.js';
 const resolveUndefined = async () => undefined;
 // Mock the file-runner so we control what jestResult/harnessResult each test returns
@@ -9,6 +10,15 @@ const mockRunHarnessTestFile = vi.hoisted(() => vi.fn());
 vi.mock('../run.js', () => ({
     runHarnessTestFile: mockRunHarnessTestFile,
 }));
+// Mock the reporting module so diagnostics tests can inspect the entries that
+// would have been reported without touching the real filesystem, and so
+// asserting on them doesn't race with executeRun's own diagnostics.flush().
+const mockPrintSummary = vi.hoisted(() => vi.fn());
+const mockWriteTraceFile = vi.hoisted(() => vi.fn(async () => '/fake/trace.json'));
+vi.mock('../diagnostics/index.js', () => ({
+    printSummary: mockPrintSummary,
+    writeTraceFile: mockWriteTraceFile,
+}));
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -80,9 +90,11 @@ const makeSession = (overrides = {}) => ({
             config: {},
         },
     },
+    diagnostics: createDiagnostics({ enabled: false }),
     ensureAppReady: vi.fn(resolveUndefined),
     runTestFile: vi.fn(async () => makeHarnessResult()),
     restartApp: vi.fn(resolveUndefined),
+    resetEnvironment: vi.fn(resolveUndefined),
     resetCrashState: vi.fn(),
     flushClientLogs: vi.fn(() => []),
     callHook: vi.fn(resolveUndefined),
@@ -138,13 +150,57 @@ describe('executeRun', () => {
             expect(hookNames).toContain('run:finished');
         });
     });
+    describe('diagnostics', () => {
+        beforeEach(() => {
+            mockPrintSummary.mockClear();
+            mockWriteTraceFile.mockClear();
+        });
+        it('records run.total and run.file spans when diagnostics is enabled', async () => {
+            const diagnostics = createDiagnostics({ enabled: true });
+            const session = makeSession({ diagnostics });
+            await executeRun(session, [makeTest('/a.ts')], makeWatcher(), makeEmitEvent().emitEvent, makeGlobalConfig());
+            // executeRun flushes and hands entries to the (mocked) reporter in its
+            // finally block, so we inspect what was reported rather than flushing
+            // the diagnostics instance ourselves.
+            expect(mockPrintSummary).toHaveBeenCalledTimes(1);
+            const entries = mockPrintSummary.mock.calls[0]?.[0];
+            const runEntry = entries.find((e) => e.label === 'run.total');
+            const fileEntry = entries.find((e) => e.label === 'run.file');
+            expect(runEntry).toMatchObject({ status: 'ok', attrs: { status: 'passed' } });
+            expect(runEntry?.attrs?.runId).toBeTypeOf('string');
+            expect(fileEntry).toMatchObject({ status: 'ok', attrs: { file: '../a.ts', status: 'passed' } });
+            expect(fileEntry?.attrs?.runId).toBeTypeOf('string');
+            expect(mockWriteTraceFile).toHaveBeenCalledWith(entries, expect.objectContaining({ runId: expect.any(String) }));
+        });
+        it('still records run.total when a test throws', async () => {
+            const diagnostics = createDiagnostics({ enabled: true });
+            const session = makeSession({
+                diagnostics,
+                ensureAppReady: vi.fn(async () => { throw new Error('unexpected'); }),
+            });
+            await executeRun(session, [makeTest()], makeWatcher(), makeEmitEvent().emitEvent, makeGlobalConfig());
+            const entries = mockPrintSummary.mock.calls[0]?.[0];
+            expect(entries.find((e) => e.label === 'run.total')).toBeDefined();
+            expect(entries.find((e) => e.label === 'run.file')).toMatchObject({
+                attrs: { status: 'failed' },
+            });
+        });
+        it('is a no-op and does not generate a report when diagnostics is disabled', async () => {
+            const diagnostics = createDiagnostics({ enabled: false });
+            const session = makeSession({ diagnostics });
+            await executeRun(session, [makeTest()], makeWatcher(), makeEmitEvent().emitEvent, makeGlobalConfig());
+            expect(diagnostics.flush()).toEqual([]);
+            expect(mockPrintSummary).not.toHaveBeenCalled();
+            expect(mockWriteTraceFile).not.toHaveBeenCalled();
+        });
+    });
     describe('happy path', () => {
         it('emits file start, ensureAppReady, runTestFile, file success in order', async () => {
             const order = [];
             const session = makeSession({
                 ensureAppReady: vi.fn(async () => { order.push('ensureAppReady'); }),
             });
-            const emitEvent = (async (eventName, ..._eventData) => {
+            const emitEvent = (async (eventName) => {
                 if (eventName === 'test-file-start') {
                     order.push('test-file-start');
                 }
@@ -178,6 +234,14 @@ describe('executeRun', () => {
             expect(payload.summary.passed).toBe(6);
             expect(payload.status).toBe('passed');
         });
+        it('marks the final run state as completed', async () => {
+            const session = makeSession();
+            await executeRun(session, [makeTest()], makeWatcher(), makeEmitEvent().emitEvent, makeGlobalConfig());
+            expect(session.setRunState).toHaveBeenLastCalledWith(expect.objectContaining({
+                completed: true,
+                status: 'passed',
+            }));
+        });
         it('attaches buffered client logs to the Jest result', async () => {
             const clientLogs = [{ message: 'Loaded screen', origin: '', type: 'warn' }];
             const session = makeSession({
@@ -257,6 +321,56 @@ describe('executeRun', () => {
                 ['test-file-success', expect.anything(), expect.anything()],
             ]);
         });
+        it('includes pending promise diagnostics in live test-case failures', 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-finished',
+                    file: 'example.ts',
+                    suite: 'suite',
+                    name: 'hangs',
+                    ancestorTitles: ['suite'],
+                    fullName: 'suite hangs',
+                    startedAt: 100,
+                    duration: 50,
+                    status: 'failed',
+                    error: {
+                        name: 'TestCaseTimeoutError',
+                        message: 'Test timed out after 50ms: suite hangs',
+                        diagnostics: {
+                            pendingPromises: {
+                                total: 1,
+                                items: [
+                                    {
+                                        id: 7,
+                                        createdAt: 110,
+                                        stack: 'Error: Promise created\n    at hangs (example.ts:10:5)',
+                                    },
+                                ],
+                            },
+                        },
+                    },
+                });
+                return makeFileRunResult();
+            });
+            await executeRun(session, [makeTest()], makeWatcher(), emitEvent, makeGlobalConfig());
+            expect(emittedEvents).toContainEqual([
+                'test-case-result',
+                'example.ts',
+                expect.objectContaining({
+                    failureMessages: [
+                        expect.stringContaining('Pending promises at timeout: 1\n\nPromise #7, created 10ms after test start:'),
+                    ],
+                }),
+            ]);
+        });
     });
     describe('runtime failures', () => {
         it('passes StartupStallError to onFailure with an empty stack', async () => {
@@ -334,7 +448,7 @@ describe('executeRun', () => {
         });
     });
     describe('resetEnvironmentBetweenTestFiles', () => {
-        it('calls restartApp before the second test but not the first', async () => {
+        it('calls resetEnvironment before the second test but not the first', async () => {
             const session = makeSession({
                 config: {
                     metroPort: 8081,
@@ -347,8 +461,139 @@ describe('executeRun', () => {
                 },
             });
             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);
+            // resetEnvironment should be called for tests 2 and 3, not test 1.
+            expect(session.resetEnvironment).toHaveBeenCalledTimes(2);
+            expect(session.restartApp).not.toHaveBeenCalled();
+        });
+        it('calls resetEnvironment with the "runtime" strategy configured', async () => {
+            const session = makeSession({
+                config: {
+                    metroPort: 8081,
+                    resetEnvironmentBetweenTestFiles: 'runtime',
+                    detectNativeCrashes: false,
+                    runners: [
+                        { platformId: 'android', name: 'android' },
+                        { platformId: 'ios', name: 'ios' },
+                    ],
+                },
+            });
+            await executeRun(session, [makeTest('/a.ts'), makeTest('/b.ts')], makeWatcher(), makeEmitEvent().emitEvent, makeGlobalConfig());
+            expect(session.resetEnvironment).toHaveBeenCalledTimes(1);
+            expect(session.resetEnvironment).toHaveBeenCalledWith('/b.ts');
+        });
+        it('does not call resetEnvironment when resetEnvironmentBetweenTestFiles is false', async () => {
+            const session = makeSession({
+                config: {
+                    metroPort: 8081,
+                    resetEnvironmentBetweenTestFiles: false,
+                    detectNativeCrashes: false,
+                    runners: [
+                        { platformId: 'android', name: 'android' },
+                        { platformId: 'ios', name: 'ios' },
+                    ],
+                },
+            });
+            await executeRun(session, [makeTest('/a.ts'), makeTest('/b.ts')], makeWatcher(), makeEmitEvent().emitEvent, makeGlobalConfig());
+            expect(session.resetEnvironment).not.toHaveBeenCalled();
+        });
+        it('restarts after a test case timeout before the next runnable file', async () => {
+            const timedOutResult = makeHarnessResult('failed');
+            timedOutResult.tests = [
+                {
+                    name: 'hangs',
+                    status: 'failed',
+                    duration: 10,
+                    error: {
+                        name: 'TestCaseTimeoutError',
+                        message: 'Test timed out after 10ms: hangs',
+                    },
+                },
+            ];
+            mockRunHarnessTestFile
+                .mockResolvedValueOnce(makeFileRunResult({
+                harnessResult: timedOutResult,
+                jestResult: makeJestResult({
+                    numFailingTests: 1,
+                    numPassingTests: 0,
+                }),
+            }))
+                .mockResolvedValueOnce(makeFileRunResult());
+            const session = makeSession({
+                config: {
+                    metroPort: 8081,
+                    resetEnvironmentBetweenTestFiles: false,
+                    detectNativeCrashes: false,
+                    runners: [
+                        { platformId: 'android', name: 'android' },
+                        { platformId: 'ios', name: 'ios' },
+                    ],
+                },
+            });
+            await executeRun(session, [makeTest('/a.ts'), makeTest('/b.ts')], makeWatcher(), makeEmitEvent().emitEvent, makeGlobalConfig());
+            expect(session.restartApp).toHaveBeenCalledTimes(1);
+            expect(session.restartApp).toHaveBeenCalledWith('/a.ts');
+        });
+        it('restarts after a timeout in the last runnable file', async () => {
+            const timedOutResult = makeHarnessResult('failed');
+            timedOutResult.tests = [
+                {
+                    name: 'hangs',
+                    status: 'failed',
+                    duration: 10,
+                    error: {
+                        name: 'TestCaseTimeoutError',
+                        message: 'Test timed out after 10ms: hangs',
+                    },
+                },
+            ];
+            mockRunHarnessTestFile.mockResolvedValueOnce(makeFileRunResult({
+                harnessResult: timedOutResult,
+                jestResult: makeJestResult({
+                    numFailingTests: 1,
+                    numPassingTests: 0,
+                }),
+            }));
+            const session = makeSession({
+                config: {
+                    metroPort: 8081,
+                    resetEnvironmentBetweenTestFiles: false,
+                    detectNativeCrashes: false,
+                    runners: [
+                        { platformId: 'android', name: 'android' },
+                        { platformId: 'ios', name: 'ios' },
+                    ],
+                },
+            });
+            await executeRun(session, [makeTest('/a.ts')], makeWatcher(), makeEmitEvent().emitEvent, makeGlobalConfig({ watch: true }));
+            expect(session.restartApp).toHaveBeenCalledTimes(1);
+            expect(session.restartApp).toHaveBeenCalledWith('/a.ts');
+        });
+        it('restarts after a suite hook timeout', async () => {
+            const timedOutResult = makeHarnessResult('failed');
+            timedOutResult.suites = [
+                {
+                    name: 'suite',
+                    tests: [],
+                    suites: [],
+                    status: 'failed',
+                    duration: 10,
+                    error: {
+                        name: 'SuiteHookTimeoutError',
+                        message: 'beforeAll hook timed out after 10ms in suite: suite',
+                    },
+                },
+            ];
+            mockRunHarnessTestFile.mockResolvedValueOnce(makeFileRunResult({
+                harnessResult: timedOutResult,
+                jestResult: makeJestResult({
+                    numFailingTests: 1,
+                    numPassingTests: 0,
+                }),
+            }));
+            const session = makeSession();
+            await executeRun(session, [makeTest('/a.ts')], makeWatcher(), makeEmitEvent().emitEvent, makeGlobalConfig());
+            expect(session.restartApp).toHaveBeenCalledTimes(1);
+            expect(session.restartApp).toHaveBeenCalledWith('/a.ts');
         });
     });
     describe('platform-specific test files', () => {
@@ -387,6 +632,7 @@ describe('executeRun', () => {
                 makeTest('/project/kotlin.android.harness.ts'),
             ], makeWatcher(), vi.fn(), makeGlobalConfig());
             expect(session.restartApp).not.toHaveBeenCalled();
+            expect(session.resetEnvironment).not.toHaveBeenCalled();
             expect(mockRunHarnessTestFile).toHaveBeenCalledTimes(1);
         });
     });

package/dist/__tests__/format-harness-error.test.d.ts

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

package/dist/__tests__/format-harness-error.test.d.ts.map

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