@react-native-harness/jest 1.4.0 → 1.4.1

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

@@ -1,27 +0,0 @@
-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');
-    });
-});

package/dist/__tests__/harness-cache.test.d.ts

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

package/dist/__tests__/harness-cache.test.d.ts.map

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

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

@@ -1,72 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { maybeLogMetroCacheReused } from '../harness-session.js';
-const { createHarnessCache, isWarm, logMetroCacheReused } = vi.hoisted(() => {
-    const isWarm = vi.fn();
-    return {
-        isWarm,
-        createHarnessCache: vi.fn((options) => ({
-            paths: {
-                root: `${options.projectRoot}/.harness/cache`,
-                metroTransform: `${options.projectRoot}/.harness/cache/metro`,
-                metroFileMap: `${options.projectRoot}/.harness/cache/metro-file-map`,
-            },
-            isWarm,
-            ensureDomainDirectories: vi.fn(),
-        })),
-        logMetroCacheReused: vi.fn(),
-    };
-});
-vi.mock('@react-native-harness/cache', () => ({
-    createHarnessCache,
-}));
-vi.mock('../logs.js', async (importOriginal) => ({
-    ...(await importOriginal()),
-    logMetroCacheReused,
-}));
-const platform = { name: 'test-runner' };
-describe('maybeLogMetroCacheReused', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it('logs the reuse message when caching is enabled and the cache is warm', () => {
-        isWarm.mockReturnValue(true);
-        maybeLogMetroCacheReused({
-            config: { cache: { metro: true } },
-            projectRoot: '/tmp/app',
-            platform,
-        });
-        expect(createHarnessCache).toHaveBeenCalledWith({
-            projectRoot: '/tmp/app',
-        });
-        expect(isWarm).toHaveBeenCalledWith('metro');
-        expect(logMetroCacheReused).toHaveBeenCalledWith(platform);
-    });
-    it('logs the reuse message with a warm cache when caching is on by default', () => {
-        isWarm.mockReturnValue(true);
-        maybeLogMetroCacheReused({
-            config: {},
-            projectRoot: '/tmp/app',
-            platform,
-        });
-        expect(logMetroCacheReused).toHaveBeenCalledWith(platform);
-    });
-    it('does not log when caching is enabled but the cache is cold', () => {
-        isWarm.mockReturnValue(false);
-        maybeLogMetroCacheReused({
-            config: { cache: { metro: true } },
-            projectRoot: '/tmp/app',
-            platform,
-        });
-        expect(logMetroCacheReused).not.toHaveBeenCalled();
-    });
-    it('does not log when caching is disabled, regardless of cache state', () => {
-        isWarm.mockReturnValue(true);
-        maybeLogMetroCacheReused({
-            config: { cache: { metro: false } },
-            projectRoot: '/tmp/app',
-            platform,
-        });
-        expect(createHarnessCache).not.toHaveBeenCalled();
-        expect(logMetroCacheReused).not.toHaveBeenCalled();
-    });
-});

package/dist/__tests__/harness-session-signal.test.d.ts

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

package/dist/__tests__/harness-session-signal.test.d.ts.map

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

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

@@ -1,298 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-const toolMocks = vi.hoisted(() => ({
-    createCrashArtifactWriter: vi.fn(() => ({
-        persistArtifact: vi.fn(() => '/tmp/harness-artifact'),
-    })),
-    createHarnessBridge: vi.fn(),
-    createHarnessPluginManager: vi.fn(),
-    createHookQueue: vi.fn(),
-    createClientLogCollector: vi.fn(),
-    createCrashMonitor: vi.fn(),
-    getConfig: vi.fn(),
-    getMetroInstance: vi.fn(),
-    getAdditionalCliArgs: vi.fn(),
-    logNoop: vi.fn(),
-    lockAcquire: vi.fn(),
-    processExit: vi.fn(),
-    processOff: vi.fn(),
-    processOnce: vi.fn(),
-    resolveHarnessMetroPort: vi.fn(),
-    runnerFactory: vi.fn(),
-}));
-vi.mock('@react-native-harness/config', () => ({
-    ConfigSchema: {
-        parse: vi.fn((value) => value),
-    },
-    getConfig: toolMocks.getConfig,
-}));
-vi.mock('@react-native-harness/bundler-metro', () => ({
-    getMetroInstance: toolMocks.getMetroInstance,
-    isMetroCacheReusable: vi.fn(() => false),
-    waitForMetroBackedAppReady: vi.fn(),
-}));
-vi.mock('@react-native-harness/bridge/server', () => ({
-    createHarnessBridge: toolMocks.createHarnessBridge,
-}));
-vi.mock('@react-native-harness/plugins', () => ({
-    createHarnessPluginManager: toolMocks.createHarnessPluginManager,
-}));
-vi.mock('@react-native-harness/tools', async () => {
-    const actual = await vi.importActual('@react-native-harness/tools');
-    return {
-        ...actual,
-        createCrashArtifactWriter: toolMocks.createCrashArtifactWriter,
-    };
-});
-vi.mock('jest-util', () => ({
-    preRunMessage: {
-        remove: vi.fn(),
-    },
-}));
-vi.mock('../action-hooks.js', () => ({
-    createActionHooksPlugin: vi.fn(() => ({})),
-}));
-vi.mock('../client-log-handler.js', () => ({
-    createClientLogCollector: toolMocks.createClientLogCollector,
-}));
-vi.mock('../crash-monitor.js', () => ({
-    createCrashMonitor: toolMocks.createCrashMonitor,
-}));
-vi.mock('../hook-queue.js', () => ({
-    createHookQueue: toolMocks.createHookQueue,
-}));
-vi.mock('../cli-args.js', () => ({
-    getAdditionalCliArgs: toolMocks.getAdditionalCliArgs,
-}));
-vi.mock('../logs.js', () => ({
-    logMetroCacheReused: toolMocks.logNoop,
-    logMetroPortFallback: toolMocks.logNoop,
-    logNativeCoverageCollected: toolMocks.logNoop,
-    logRunnerStarting: toolMocks.logNoop,
-    logRunnerStillWaitingInQueue: toolMocks.logNoop,
-    logRunnerWaitingInQueue: toolMocks.logNoop,
-    logTestEnvironmentReady: toolMocks.logNoop,
-    logTestRunHeader: toolMocks.logNoop,
-}));
-vi.mock('../metro-port.js', () => ({
-    resolveHarnessMetroPort: toolMocks.resolveHarnessMetroPort,
-}));
-vi.mock('../resource-lock.js', () => ({
-    createResourceLockManager: vi.fn(() => ({
-        acquire: toolMocks.lockAcquire,
-    })),
-}));
-import { createHarnessSession, getSignalExitCodeForRunState, handleHarnessSignal, } from '../harness-session.js';
-const signalListeners = new Map();
-const createTempRunnerModule = () => {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'rn-harness-session-'));
-    const runnerPath = path.join(root, 'runner.mjs');
-    fs.writeFileSync(runnerPath, [
-        'export default async function runner(config, harnessConfig, init) {',
-        '  return globalThis.__RN_HARNESS_TEST_RUNNER__(config, harnessConfig, init);',
-        '}',
-    ].join('\n'));
-    return {
-        root,
-        runnerUrl: pathToFileURL(runnerPath).href,
-    };
-};
-const createHarnessConfig = (runnerUrl) => {
-    const runnerConfig = {
-        name: 'ios',
-        platformId: 'ios',
-        runner: runnerUrl,
-        config: {},
-        getResourceLockKey: () => 'test-lock',
-    };
-    return {
-        bridgeTimeout: 1000,
-        bundleStartTimeout: 1000,
-        defaultRunner: 'ios',
-        detectNativeCrashes: true,
-        forwardClientLogs: false,
-        maxAppRestarts: 1,
-        metroPort: 8081,
-        permissions: false,
-        platformReadyTimeout: 1000,
-        plugins: [],
-        runners: [runnerConfig],
-        unstable__enableMetroCache: false,
-    };
-};
-const createAppSession = () => ({
-    addListener: vi.fn(),
-    dispose: vi.fn(async () => undefined),
-    getCrashDetails: vi.fn(async () => null),
-    getLogs: vi.fn(() => []),
-    getState: vi.fn(async () => ({ status: 'running' })),
-    removeListener: vi.fn(),
-});
-beforeEach(() => {
-    signalListeners.clear();
-    vi.spyOn(process, 'once').mockImplementation((event, listener) => {
-        signalListeners.set(String(event), listener);
-        return process;
-    });
-    vi.spyOn(process, 'off').mockImplementation((event, listener) => {
-        if (signalListeners.get(String(event)) === listener) {
-            signalListeners.delete(String(event));
-        }
-        return process;
-    });
-    toolMocks.getAdditionalCliArgs.mockReturnValue({});
-    toolMocks.lockAcquire.mockResolvedValue({ release: vi.fn(async () => undefined) });
-    toolMocks.resolveHarnessMetroPort.mockImplementation(async ({ config }) => ({
-        config,
-        didFallback: false,
-        initialMetroPort: config.metroPort,
-        metroPortLease: {
-            release: vi.fn(async () => undefined),
-        },
-    }));
-    toolMocks.createHarnessBridge.mockResolvedValue({
-        connection: null,
-        dispose: vi.fn(async () => undefined),
-        off: vi.fn(),
-        on: vi.fn(),
-        ws: {},
-    });
-    toolMocks.getMetroInstance.mockResolvedValue({
-        dispose: vi.fn(async () => undefined),
-        events: {
-            addListener: vi.fn(),
-            removeListener: vi.fn(),
-        },
-    });
-    toolMocks.createHarnessPluginManager.mockReturnValue({
-        hasPlugins: () => false,
-        callHook: vi.fn(async () => undefined),
-    });
-    toolMocks.createHookQueue.mockReturnValue({
-        drain: vi.fn(async () => undefined),
-        schedule: vi.fn((task) => task()),
-    });
-    toolMocks.createClientLogCollector.mockReturnValue({
-        flush: vi.fn(() => []),
-        handleEvent: vi.fn(),
-    });
-    toolMocks.createCrashMonitor.mockReturnValue({
-        dispose: vi.fn(async () => undefined),
-        handleBridgeDisconnect: vi.fn(),
-        isAlive: vi.fn(() => false),
-        reset: vi.fn(),
-        setAppSession: vi.fn(),
-        start: vi.fn(async () => undefined),
-        stop: vi.fn(async () => undefined),
-        watch: vi.fn(() => ({
-            cancel: vi.fn(),
-            promise: Promise.resolve({}),
-        })),
-    });
-    toolMocks.runnerFactory.mockReset();
-    toolMocks.getConfig.mockResolvedValue({ config: {} });
-});
-afterEach(() => {
-    vi.restoreAllMocks();
-    delete globalThis.__RN_HARNESS_TEST_RUNNER__;
-});
-describe('createHarnessSession signal flow', () => {
-    it('passes session signal into createAppSession and aborts it on dispose', async () => {
-        const { root, runnerUrl } = createTempRunnerModule();
-        const appSession = createAppSession();
-        const createAppSessionMock = vi.fn(async (_options, _context) => {
-            void _options;
-            void _context;
-            return appSession;
-        });
-        globalThis.__RN_HARNESS_TEST_RUNNER__ = toolMocks.runnerFactory.mockImplementation(async () => ({
-            createAppSession: createAppSessionMock,
-            dispose: vi.fn(async () => undefined),
-        }));
-        toolMocks.getConfig.mockResolvedValue({
-            config: createHarnessConfig(runnerUrl),
-        });
-        try {
-            const session = await createHarnessSession({ rootDir: root }, {
-                lockManager: {
-                    acquire: toolMocks.lockAcquire,
-                },
-            });
-            await session.restartApp();
-            const runState = {
-                coverageEnabled: false,
-                runId: 'run-1',
-                startTime: Date.now(),
-                status: 'passed',
-                summary: {
-                    failed: 0,
-                    passed: 1,
-                    skipped: 0,
-                    todo: 0,
-                },
-                testFiles: ['foo.test.ts'],
-                watchMode: false,
-            };
-            session.setRunState(runState);
-            expect(createAppSessionMock).toHaveBeenCalledWith(undefined, expect.objectContaining({
-                signal: expect.any(AbortSignal),
-            }));
-            const context = createAppSessionMock.mock.calls[0]?.[1];
-            expect(context?.signal).toBeInstanceOf(AbortSignal);
-            expect(context?.signal?.aborted).toBe(false);
-            await session.dispose();
-            expect(context?.signal?.aborted).toBe(true);
-        }
-        finally {
-            fs.rmSync(root, { recursive: true, force: true });
-        }
-    });
-    it('maps run state to exit code and aborts controller', async () => {
-        const controller = new AbortController();
-        const dispose = vi.fn(async () => undefined);
-        const exit = vi.fn();
-        const failedRun = {
-            coverageEnabled: false,
-            error: new Error('failed'),
-            runId: 'run-2',
-            startTime: Date.now(),
-            status: 'failed',
-            summary: {
-                failed: 1,
-                passed: 0,
-                skipped: 0,
-                todo: 0,
-            },
-            testFiles: ['foo.test.ts'],
-            watchMode: false,
-        };
-        await handleHarnessSignal({
-            currentRun: {
-                coverageEnabled: false,
-                completed: true,
-                runId: 'run-2',
-                startTime: Date.now(),
-                status: 'passed',
-                summary: {
-                    failed: 0,
-                    passed: 1,
-                    skipped: 0,
-                    todo: 0,
-                },
-                testFiles: ['foo.test.ts'],
-                watchMode: false,
-            },
-            dispose,
-            exit,
-            sessionController: controller,
-        });
-        expect(controller.signal.aborted).toBe(true);
-        expect(dispose).toHaveBeenCalledTimes(1);
-        expect(exit).toHaveBeenCalledWith(0);
-        expect(getSignalExitCodeForRunState(failedRun)).toBe(1);
-        expect(getSignalExitCodeForRunState(null)).toBe(1);
-    });
-});

package/dist/__tests__/harness-session.test.d.ts

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

package/dist/__tests__/harness-session.test.d.ts.map

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

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

@@ -1,233 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { getSignalExitCodeForRunState, waitForBridgeDisconnectOrTimeout, waitForNextConnected, waitForStartupCrash, withPlatformReadyTimeout, } from '../harness-session.js';
-import { PlatformReadyTimeoutError } from '../errors.js';
-const createConnection = () => ({
-    device: {
-        platform: 'ios',
-        manufacturer: 'Apple',
-        model: 'iPhone',
-        osVersion: '18.0',
-    },
-    runTests: vi.fn(),
-    resetEnvironment: vi.fn(),
-});
-const createBridge = (connection) => {
-    let currentConnection = connection;
-    let disconnectedListener = null;
-    return {
-        get connection() {
-            return currentConnection;
-        },
-        on: vi.fn((event, listener) => {
-            if (event === 'disconnected') {
-                disconnectedListener = listener;
-            }
-        }),
-        off: vi.fn((event, listener) => {
-            if (event === 'disconnected' && disconnectedListener === listener) {
-                disconnectedListener = null;
-            }
-        }),
-        disconnect: () => {
-            currentConnection = null;
-            disconnectedListener?.();
-        },
-    };
-};
-describe('waitForBridgeDisconnectOrTimeout', () => {
-    it('returns true when the bridge disconnects before the timeout', async () => {
-        const connection = createConnection();
-        const bridge = createBridge(connection);
-        const waitPromise = waitForBridgeDisconnectOrTimeout({
-            bridge,
-            connection,
-            timeoutMs: 50,
-        });
-        bridge.disconnect();
-        await expect(waitPromise).resolves.toBe(true);
-    });
-    it('returns false when the bridge stays connected through the timeout', async () => {
-        const connection = createConnection();
-        const bridge = createBridge(connection);
-        await expect(waitForBridgeDisconnectOrTimeout({
-            bridge,
-            connection,
-            timeoutMs: 10,
-        })).resolves.toBe(false);
-    });
-});
-describe('waitForNextConnected', () => {
-    const createConnectableBridge = () => {
-        let listener = null;
-        const bridge = {
-            on: vi.fn((event, l) => {
-                if (event === 'connected')
-                    listener = l;
-            }),
-            off: vi.fn((event, l) => {
-                if (event === 'connected' && listener === l)
-                    listener = null;
-            }),
-        };
-        return { bridge, emitConnected: () => listener?.() };
-    };
-    it('resolves when the bridge emits a connected event', async () => {
-        const { bridge, emitConnected } = createConnectableBridge();
-        const controller = new AbortController();
-        const waitPromise = waitForNextConnected({ bridge, signal: controller.signal });
-        emitConnected();
-        await expect(waitPromise).resolves.toBeUndefined();
-    });
-    it('rejects when the signal aborts before a connected event', async () => {
-        const { bridge } = createConnectableBridge();
-        const controller = new AbortController();
-        const waitPromise = waitForNextConnected({ bridge, signal: controller.signal });
-        controller.abort(new DOMException('Aborted', 'AbortError'));
-        await expect(waitPromise).rejects.toThrow('Aborted');
-    });
-    it('rejects immediately when the signal is already aborted', async () => {
-        const { bridge } = createConnectableBridge();
-        const controller = new AbortController();
-        controller.abort(new DOMException('Aborted', 'AbortError'));
-        await expect(waitForNextConnected({ bridge, signal: controller.signal })).rejects.toThrow('Aborted');
-    });
-    it('unsubscribes the connected listener once settled', async () => {
-        const { bridge, emitConnected } = createConnectableBridge();
-        const controller = new AbortController();
-        const waitPromise = waitForNextConnected({ bridge, signal: controller.signal });
-        emitConnected();
-        await waitPromise;
-        expect(bridge.off).toHaveBeenCalledOnce();
-    });
-});
-describe('waitForStartupCrash', () => {
-    it('does not install a startup crash watch when native crash detection is disabled', async () => {
-        const watch = vi.fn();
-        const crashMonitor = {
-            watch,
-        };
-        const controller = new AbortController();
-        const waitPromise = waitForStartupCrash({
-            crashMonitor,
-            detectNativeCrashes: false,
-            testFilePath: '/test.harness.ts',
-            signal: controller.signal,
-        });
-        controller.abort(new DOMException('Aborted', 'AbortError'));
-        await expect(waitPromise).rejects.toThrow('Aborted');
-        expect(watch).not.toHaveBeenCalled();
-    });
-    it('removes its abort listener on the session signal once the crash watch wins', async () => {
-        let rejectWatch;
-        const cancel = vi.fn();
-        const watch = vi.fn(() => ({
-            promise: new Promise((_, reject) => {
-                rejectWatch = reject;
-            }),
-            cancel,
-        }));
-        const crashMonitor = { watch };
-        const controller = new AbortController();
-        const addSpy = vi.spyOn(controller.signal, 'addEventListener');
-        const removeSpy = vi.spyOn(controller.signal, 'removeEventListener');
-        const waitPromise = waitForStartupCrash({
-            crashMonitor,
-            detectNativeCrashes: true,
-            testFilePath: '/test.harness.ts',
-            signal: controller.signal,
-        });
-        // The crash watch wins the race, not the session signal.
-        rejectWatch(new Error('native crash detected'));
-        await expect(waitPromise).rejects.toThrow('native crash detected');
-        expect(cancel).toHaveBeenCalledTimes(1);
-        // Regression: forgetting to cancel the losing waitForAbort() left its
-        // listener attached to this session-lifetime signal for the rest of
-        // the session — one leaked listener per test file.
-        expect(addSpy).toHaveBeenCalledTimes(1);
-        expect(removeSpy).toHaveBeenCalledTimes(1);
-    });
-});
-describe('withPlatformReadyTimeout', () => {
-    afterEach(() => {
-        vi.useRealTimers();
-    });
-    it('passes the real session signal to work, unmodified by the timeout', async () => {
-        const controller = new AbortController();
-        const work = vi.fn(async (signal) => {
-            expect(signal).toBe(controller.signal);
-            return 'ready';
-        });
-        await expect(withPlatformReadyTimeout({
-            timeout: 1_000,
-            signal: controller.signal,
-            work,
-        })).resolves.toBe('ready');
-        expect(work).toHaveBeenCalledTimes(1);
-    });
-    it('throws PlatformReadyTimeoutError on timeout without aborting the session signal', async () => {
-        vi.useFakeTimers();
-        const controller = new AbortController();
-        // Never resolves within the test; simulates a hung platform init.
-        const work = () => new Promise(() => undefined);
-        const resultPromise = withPlatformReadyTimeout({
-            timeout: 1_000,
-            signal: controller.signal,
-            work,
-        });
-        await vi.advanceTimersByTimeAsync(1_000);
-        await expect(resultPromise).rejects.toBeInstanceOf(PlatformReadyTimeoutError);
-        expect(controller.signal.aborted).toBe(false);
-    });
-    it('propagates a genuine abort from the session signal as-is', async () => {
-        const controller = new AbortController();
-        const abortReason = new DOMException('Aborted', 'AbortError');
-        const work = (signal) => new Promise((_, reject) => {
-            signal.addEventListener('abort', () => reject(signal.reason));
-        });
-        const resultPromise = withPlatformReadyTimeout({
-            timeout: 1_000,
-            signal: controller.signal,
-            work,
-        });
-        controller.abort(abortReason);
-        await expect(resultPromise).rejects.toBe(abortReason);
-    });
-});
-describe('getSignalExitCodeForRunState', () => {
-    const createRunState = (overrides = {}) => ({
-        completed: true,
-        coverageEnabled: false,
-        runId: 'run-1',
-        startTime: 0,
-        status: 'passed',
-        summary: {
-            failed: 0,
-            passed: 1,
-            skipped: 0,
-            todo: 0,
-        },
-        testFiles: ['test.harness.ts'],
-        watchMode: false,
-        ...overrides,
-    });
-    it('preserves a successful exit after a completed passing run', () => {
-        expect(getSignalExitCodeForRunState(createRunState())).toBe(0);
-    });
-    it('fails when the run has not completed yet', () => {
-        expect(getSignalExitCodeForRunState(createRunState({ completed: false }))).toBe(1);
-    });
-    it('fails when the completed run has failures', () => {
-        expect(getSignalExitCodeForRunState(createRunState({
-            status: 'failed',
-            summary: {
-                failed: 1,
-                passed: 0,
-                skipped: 0,
-                todo: 0,
-            },
-        }))).toBe(1);
-    });
-    it('fails when no run state is available', () => {
-        expect(getSignalExitCodeForRunState(null)).toBe(1);
-    });
-});

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

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

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

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