@react-native-harness/jest 1.4.0 → 1.4.1

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

@@ -1,639 +0,0 @@
-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
-// without needing a real Jest config or Metro bundler.
-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
-// ---------------------------------------------------------------------------
-const makeJestResult = (overrides = {}) => ({
-    testFilePath: '/test/example.ts',
-    testResults: [],
-    failureMessage: null,
-    numFailingTests: 0,
-    numPassingTests: 1,
-    numPendingTests: 0,
-    numTodoTests: 0,
-    leaks: false,
-    openHandles: [],
-    skipped: false,
-    snapshot: {
-        added: 0, fileDeleted: false, matched: 0, unchecked: 0,
-        uncheckedKeys: [], unmatched: 0, updated: 0,
-    },
-    perfStats: { start: 0, end: 1, runtime: 1, slow: false,
-        loadTestEnvironmentStart: 0, loadTestEnvironmentEnd: 0,
-        setupAfterEnvStart: 0, setupAfterEnvEnd: 0,
-        setupFilesStart: 0, setupFilesEnd: 0 },
-    coverage: undefined,
-    ...overrides,
-});
-const makeHarnessResult = (status = 'passed') => ({
-    name: 'suite',
-    tests: [],
-    suites: [],
-    status,
-    duration: 50,
-});
-const makeFileRunResult = (overrides = {}) => ({
-    jestResult: makeJestResult(),
-    harnessResult: makeHarnessResult(),
-    relativeTestPath: 'example.ts',
-    duration: 50,
-    ...overrides,
-});
-const makeTest = (filePath = '/test/example.ts') => ({
-    path: filePath,
-    context: { config: {} },
-});
-const makeWatcher = (interrupted = false) => ({ isInterrupted: () => interrupted });
-const makeGlobalConfig = (overrides = {}) => ({
-    rootDir: '/project',
-    watch: false,
-    watchAll: false,
-    collectCoverage: false,
-    ...overrides,
-});
-const makeSession = (overrides = {}) => ({
-    config: {
-        metroPort: 8081,
-        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: {},
-        },
-    },
-    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
-// ---------------------------------------------------------------------------
-beforeEach(() => {
-    vi.clearAllMocks();
-    mockRunHarnessTestFile.mockResolvedValue(makeFileRunResult());
-});
-describe('executeRun', () => {
-    describe('lifecycle hooks', () => {
-        it('emits run:started then run:finished in order', async () => {
-            const hookNames = [];
-            const session = makeSession({
-                callHook: vi.fn(async (name) => { hookNames.push(name); }),
-            });
-            await executeRun(session, [makeTest()], makeWatcher(), makeEmitEvent().emitEvent, makeGlobalConfig());
-            expect(hookNames[0]).toBe('run:started');
-            expect(hookNames[hookNames.length - 1]).toBe('run:finished');
-        });
-        it('emits test-file:started and test-file:finished around each test', async () => {
-            const hookNames = [];
-            const session = makeSession({
-                callHook: vi.fn(async (name) => { hookNames.push(name); }),
-            });
-            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',
-                'test-file:started', 'test-file:finished',
-            ]);
-        });
-        it('always emits run:finished even when a test throws', async () => {
-            const hookNames = [];
-            const session = makeSession({
-                callHook: vi.fn(async (name) => { hookNames.push(name); }),
-                ensureAppReady: vi.fn(async () => { throw new Error('unexpected'); }),
-            });
-            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('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) => {
-                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(), 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;
-            const session = makeSession({
-                callHook: vi.fn(async (name, payload) => {
-                    if (name === 'run:finished')
-                        finishedPayload = payload;
-                }),
-            });
-            mockRunHarnessTestFile.mockResolvedValue(makeFileRunResult({ jestResult: makeJestResult({ numPassingTests: 3 }) }));
-            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({
-                flushClientLogs: vi.fn()
-                    .mockReturnValueOnce([])
-                    .mockReturnValueOnce(clientLogs),
-            });
-            const { emitEvent, calls } = makeEmitEvent();
-            await executeRun(session, [makeTest()], makeWatcher(), emitEvent, makeGlobalConfig());
-            expect(session.flushClientLogs).toHaveBeenCalledTimes(2);
-            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 { emitEvent, calls } = makeEmitEvent();
-            const session = makeSession({
-                ensureAppReady: vi.fn().mockRejectedValue(new StartupStallError(1500, 3)),
-            });
-            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 { emitEvent, calls } = makeEmitEvent();
-            const session = makeSession({
-                ensureAppReady: vi.fn().mockRejectedValue(new DeviceNotRespondingError('runTests', [])),
-            });
-            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(), makeEmitEvent().emitEvent, makeGlobalConfig());
-            expect(session.resetCrashState).toHaveBeenCalled();
-        });
-        it('counts runtime failures in the summary', async () => {
-            let finishedPayload;
-            const session = makeSession({
-                callHook: vi.fn(async (name, payload) => {
-                    if (name === 'run:finished')
-                        finishedPayload = payload;
-                }),
-                ensureAppReady: vi.fn().mockRejectedValue(new StartupStallError(1000, 2)),
-            });
-            await executeRun(session, [makeTest()], makeWatcher(), makeEmitEvent().emitEvent, makeGlobalConfig());
-            const payload = finishedPayload;
-            expect(payload.summary.failed).toBe(1);
-            expect(payload.status).toBe('failed');
-        });
-    });
-    describe('watcher interrupt', () => {
-        it('stops processing tests and still emits run:finished', async () => {
-            const hookNames = [];
-            const session = makeSession({
-                callHook: vi.fn(async (name) => { hookNames.push(name); }),
-            });
-            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(calls).not.toContainEqual(['test-file-start', expect.anything()]);
-            expect(hookNames).toContain('run:finished');
-        });
-    });
-    describe('resetEnvironmentBetweenTestFiles', () => {
-        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('/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__/fixtures/mock-platform-runner.d.ts

@@ -1,7 +0,0 @@
-import type { HarnessPlatformInitOptions, HarnessPlatformRunner } from '@react-native-harness/platforms';
-import type { Config as HarnessConfig } from '@react-native-harness/config';
-declare global {
-    var __HARNESS_TEST_PLATFORM_RUNNER__: HarnessPlatformRunner | undefined;
-}
-export default function mockPlatformRunner(_platformConfig: Record<string, unknown>, _harnessConfig: HarnessConfig, _init: HarnessPlatformInitOptions): Promise<HarnessPlatformRunner>;
-//# sourceMappingURL=mock-platform-runner.d.ts.map

package/dist/__tests__/fixtures/mock-platform-runner.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mock-platform-runner.d.ts","sourceRoot":"","sources":["../../../src/__tests__/fixtures/mock-platform-runner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,0BAA0B,EAC1B,qBAAqB,EACtB,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,MAAM,IAAI,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAE5E,OAAO,CAAC,MAAM,CAAC;IACb,IAAI,gCAAgC,EAChC,qBAAqB,GACrB,SAAS,CAAC;CACf;AAED,wBAA8B,kBAAkB,CAC9C,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACxC,cAAc,EAAE,aAAa,EAC7B,KAAK,EAAE,0BAA0B,GAChC,OAAO,CAAC,qBAAqB,CAAC,CAMhC"}

package/dist/__tests__/fixtures/mock-platform-runner.js

@@ -1,6 +0,0 @@
-export default async function mockPlatformRunner(_platformConfig, _harnessConfig, _init) {
-    if (!globalThis.__HARNESS_TEST_PLATFORM_RUNNER__) {
-        throw new Error('Missing __HARNESS_TEST_PLATFORM_RUNNER__ test fixture');
-    }
-    return globalThis.__HARNESS_TEST_PLATFORM_RUNNER__;
-}

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

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

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

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