@react-native-harness/jest 1.3.0 → 1.4.0

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 { DeviceNotRespondingError } from '@react-native-harness/bridge/server';
+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
 // ---------------------------------------------------------------------------
@@ -66,18 +76,40 @@ 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: {},
+    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),
+    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 +124,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 +133,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 +146,79 @@ 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('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('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) => {
+                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,11 +229,19 @@ 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');
         });
+        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({
@@ -154,34 +249,174 @@ 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()],
+            ]);
+        });
+        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 () => {
-            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 +428,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,25 +440,200 @@ 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');
         });
     });
     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,
+                    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(), makeEmitEvent().emitEvent, makeGlobalConfig());
+            // 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', () => {
+        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('/a.ts'), makeTest('/b.ts'), makeTest('/c.ts')], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeGlobalConfig());
-            // restartApp should be called for tests 2 and 3, not test 1.
-            expect(session.restartApp).toHaveBeenCalledTimes(2);
+            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(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":""}

package/dist/__tests__/format-harness-error.test.js

@@ -0,0 +1,27 @@
+import { describe, expect, it } from 'vitest';
+import { formatHarnessErrorMessage } from '../format-harness-error.js';
+describe('formatHarnessErrorMessage', () => {
+    it('formats pending promise diagnostics for timeout errors', () => {
+        const message = formatHarnessErrorMessage({
+            name: 'TestCaseTimeoutError',
+            message: 'Test timed out after 50ms: suite hangs',
+            diagnostics: {
+                pendingPromises: {
+                    total: 2,
+                    items: [
+                        {
+                            id: 7,
+                            createdAt: 110,
+                            stack: 'Error: Promise created\n    at hangs (example.ts:10:5)',
+                        },
+                    ],
+                },
+            },
+        }, { testStartedAt: 100 });
+        expect(message).toContain('Test timed out after 50ms: suite hangs');
+        expect(message).toContain('Pending promises at timeout: 2');
+        expect(message).toContain('Showing 1 of 2 pending promises.');
+        expect(message).toContain('Promise #7, created 10ms after test start:');
+        expect(message).toContain('  Error: Promise created');
+    });
+});