@react-native-harness/jest 1.3.0 → 1.4.0

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

@@ -1,51 +1,72 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-const mocks = vi.hoisted(() => ({
-    isMetroCacheReusable: vi.fn(),
-    logMetroCacheReused: vi.fn(),
-    logMetroPrewarmCompleted: vi.fn(),
-}));
-vi.mock('@react-native-harness/bundler-metro', () => ({
-    isMetroCacheReusable: mocks.isMetroCacheReusable,
+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', () => ({
-    logMetroCacheReused: mocks.logMetroCacheReused,
-    logMetroPrewarmCompleted: mocks.logMetroPrewarmCompleted,
+vi.mock('../logs.js', async (importOriginal) => ({
+    ...(await importOriginal()),
+    logMetroCacheReused,
 }));
-import { maybeLogMetroCacheReuse } from '../harness.js';
-const platform = {
-    name: 'ios',
-    platformId: 'ios',
-    runner: '/virtual/platform-runner.js',
-    config: {},
-    getResourceLockKey: () => 'ios:simulator:iPhone 17 Pro:26.2',
-};
-const createHarnessConfig = (overrides = {}) => ({
-    appRegistryComponentName: 'App',
-    disableViewFlattening: false,
-    bridgeTimeout: 5000,
-    entryPoint: 'index.js',
-    unstable__enableMetroCache: true,
-    forwardClientLogs: false,
-    ...overrides,
-});
-describe('maybeLogMetroCacheReuse', () => {
+const platform = { name: 'test-runner' };
+describe('maybeLogMetroCacheReused', () => {
     beforeEach(() => {
         vi.clearAllMocks();
-        mocks.isMetroCacheReusable.mockReturnValue(false);
     });
-    it('logs when an existing metro cache will be reused', () => {
-        mocks.isMetroCacheReusable.mockReturnValue(true);
-        maybeLogMetroCacheReuse(createHarnessConfig(), platform, '/tmp/project');
-        expect(mocks.isMetroCacheReusable).toHaveBeenCalledWith('/tmp/project');
-        expect(mocks.logMetroCacheReused).toHaveBeenCalledWith(platform);
+    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 metro cache reuse is disabled', () => {
-        maybeLogMetroCacheReuse(createHarnessConfig({ unstable__enableMetroCache: false }), platform, '/tmp/project');
-        expect(mocks.isMetroCacheReusable).not.toHaveBeenCalled();
-        expect(mocks.logMetroCacheReused).not.toHaveBeenCalled();
+    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 the metro cache is absent', () => {
-        maybeLogMetroCacheReuse(createHarnessConfig(), platform, '/tmp/project');
-        expect(mocks.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

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

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

@@ -0,0 +1 @@
+{"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

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