@react-native-harness/jest 1.3.0 → 1.4.0

package/dist/__tests__/bridge.test.js

@@ -1,7 +1,7 @@
 /**
  * Integration test pairing createHarnessBridge (CLI side) with
  * connectToHarness (app side). Tests the full connection lifecycle and
- * RPC round-trip without knowing birpc internals.
+ * RPC round-trip without coupling tests to the transport internals.
  */
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { createHarnessBridge } from '@react-native-harness/bridge/server';
@@ -28,7 +28,10 @@ afterEach(async () => {
     // Allow the server to close cleanly.
     await new Promise((r) => setTimeout(r, 10));
 });
-const connect = (callbacks = { runTests: vi.fn() }) => connectToHarness(`ws://127.0.0.1:${bridgePort}`, callbacks);
+const connect = (callbacks = {
+    runTests: vi.fn(),
+    resetEnvironment: vi.fn(),
+}) => connectToHarness(`ws://127.0.0.1:${bridgePort}`, callbacks);
 const device = {
     platform: 'ios',
     manufacturer: 'Apple',
@@ -107,7 +110,7 @@ describe('bridge: createHarnessBridge + connectToHarness', () => {
             };
             const runTestsCb = vi.fn(async () => suiteResult);
             const connectionPromise = bridge.nextConnection();
-            const handle = await connect({ runTests: runTestsCb });
+            const handle = await connect({ runTests: runTestsCb, resetEnvironment: vi.fn() });
             handle.reportReady(device);
             const conn = await connectionPromise;
             const result = await conn.runTests('example.ts', {
@@ -117,6 +120,28 @@ describe('bridge: createHarnessBridge + connectToHarness', () => {
             expect(result.tests[0].name).toBe('passes');
             handle.disconnect();
         });
+        it('rejects pending app calls when a newer client replaces the session', async () => {
+            const firstHandle = await connect({
+                runTests: async () => await new Promise(() => undefined),
+                resetEnvironment: vi.fn(),
+            });
+            firstHandle.reportReady(device);
+            const firstConnection = await bridge.nextConnection();
+            const pendingRun = firstConnection.runTests('example.ts', {
+                runner: '/runner.js',
+            });
+            const pendingRunAssertion = expect(pendingRun).rejects.toThrow('The app bridge was replaced by a newer app connection.');
+            const secondHandle = await connect();
+            secondHandle.reportReady({
+                ...device,
+                model: 'iPhone 17 Pro Replacement',
+            });
+            await pendingRunAssertion;
+            await new Promise((r) => setTimeout(r, 20));
+            expect(bridge.connection?.device.model).toBe('iPhone 17 Pro Replacement');
+            secondHandle.disconnect();
+            firstHandle.disconnect();
+        });
     });
     describe('bridge events', () => {
         it('emitEvent on app side fires the event listener on bridge', async () => {
@@ -136,7 +161,7 @@ describe('bridge: createHarnessBridge + connectToHarness', () => {
         it('rejects pending nextConnection() waiters', async () => {
             const pending = bridge.nextConnection();
             bridge.dispose();
-            await expect(pending).rejects.toThrow('Bridge disposed');
+            await expect(pending).rejects.toThrow('The app bridge was disposed before the test file finished running.');
         });
     });
 });

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

@@ -1,212 +1,230 @@
 import { describe, expect, it, vi } from 'vitest';
+import path from 'node:path';
 import { createCrashMonitor, CrashWatchCancelledError, } from '../crash-monitor.js';
-import { NativeCrashError } from '../errors.js';
+import { NativeCrashError, RuntimeDisconnectError } from '../errors.js';
 const noop = () => undefined;
-const resolveUndefined = async () => undefined;
-// ---------------------------------------------------------------------------
-// Test doubles
-// ---------------------------------------------------------------------------
-const createAppMonitorMock = () => {
-    let registeredListener = null;
-    const monitor = {
-        start: vi.fn(resolveUndefined),
-        stop: vi.fn(resolveUndefined),
-        dispose: vi.fn(resolveUndefined),
+const waitForClassification = () => new Promise((resolve) => setTimeout(resolve, 1600));
+const createAppSessionMock = (initialState = { status: 'running' }, logs = [], getCrashDetails) => {
+    let state = initialState;
+    let listener = null;
+    const session = {
+        dispose: vi.fn(async () => undefined),
+        getState: vi.fn(async () => state),
+        getLogs: vi.fn(() => logs),
         addListener: vi.fn((l) => {
-            registeredListener = l;
+            listener = l;
         }),
         removeListener: vi.fn((l) => {
-            if (registeredListener === l)
-                registeredListener = null;
+            if (listener === l)
+                listener = null;
         }),
     };
+    if (getCrashDetails) {
+        session.getCrashDetails = getCrashDetails;
+    }
     return {
-        monitor,
-        emit: (event) => registeredListener?.(event),
+        session,
+        setState: (nextState) => {
+            state = nextState;
+        },
+        emit: (event) => listener?.(event),
     };
 };
-const createPlatformRunnerMock = (isRunning = false, crashDetails = null) => ({
-    isAppRunning: vi.fn(async () => isRunning),
-    getCrashDetails: vi.fn(async () => crashDetails),
-    startApp: vi.fn(resolveUndefined),
-    restartApp: vi.fn(resolveUndefined),
-    stopApp: vi.fn(resolveUndefined),
-    dispose: vi.fn(resolveUndefined),
-    createAppMonitor: vi.fn(),
-});
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
 describe('createCrashMonitor', () => {
-    describe('liveness', () => {
-        it('starts not alive', () => {
-            const { monitor } = createAppMonitorMock();
-            const cm = createCrashMonitor({ appMonitor: monitor, platformRunner: createPlatformRunnerMock() });
-            expect(cm.isAlive()).toBe(false);
-        });
-        it('becomes alive when the app starts', () => {
-            const { monitor, emit } = createAppMonitorMock();
-            const cm = createCrashMonitor({ appMonitor: monitor, platformRunner: createPlatformRunnerMock() });
-            emit({ type: 'app_started' });
-            expect(cm.isAlive()).toBe(true);
-        });
-        it('becomes not alive after a confirmed crash', async () => {
-            const { monitor, emit } = createAppMonitorMock();
-            const cm = createCrashMonitor({ appMonitor: monitor, platformRunner: createPlatformRunnerMock() });
-            emit({ type: 'app_started' });
-            const watch = cm.watch('test.ts', 'execution');
-            watch.promise.catch(noop);
-            emit({ type: 'app_exited', isConfirmed: true });
-            await watch.promise.catch(noop);
-            expect(cm.isAlive()).toBe(false);
-        });
+    it('starts not alive and becomes alive when an app session is attached', () => {
+        const cm = createCrashMonitor();
+        const { session } = createAppSessionMock();
+        expect(cm.isAlive()).toBe(false);
+        cm.setAppSession(session);
+        expect(cm.isAlive()).toBe(true);
     });
-    describe('watch', () => {
-        it('promise rejects with NativeCrashError on confirmed app_exited', async () => {
-            const { monitor, emit } = createAppMonitorMock();
-            const cm = createCrashMonitor({ appMonitor: monitor, platformRunner: createPlatformRunnerMock() });
-            const watch = cm.watch('/test/example.ts', 'execution');
-            watch.promise.catch(noop);
-            emit({ type: 'app_exited', isConfirmed: true });
-            await expect(watch.promise).rejects.toBeInstanceOf(NativeCrashError);
-        });
-        it('attributes the crash to the file and phase passed to watch()', async () => {
-            const { monitor, emit } = createAppMonitorMock();
-            const cm = createCrashMonitor({ appMonitor: monitor, platformRunner: createPlatformRunnerMock() });
-            const watch = cm.watch('/test/example.ts', 'startup');
-            watch.promise.catch(noop);
-            emit({ type: 'app_exited', isConfirmed: true });
-            const error = await watch.promise.catch((e) => e);
-            expect(error.testFilePath).toBe('/test/example.ts');
-            expect(error.details.phase).toBe('startup');
-        });
-        it('settles the promise with CrashWatchCancelledError on cancel()', async () => {
-            const { monitor } = createAppMonitorMock();
-            const cm = createCrashMonitor({ appMonitor: monitor, platformRunner: createPlatformRunnerMock() });
-            const watch = cm.watch('test.ts', 'execution');
-            watch.cancel();
-            await expect(watch.promise).rejects.toBeInstanceOf(CrashWatchCancelledError);
-        });
-        it('subsequent cancel() after crash is a no-op', async () => {
-            const { monitor, emit } = createAppMonitorMock();
-            const cm = createCrashMonitor({ appMonitor: monitor, platformRunner: createPlatformRunnerMock() });
-            const watch = cm.watch('test.ts', 'execution');
-            watch.promise.catch(noop);
-            emit({ type: 'app_exited', isConfirmed: true });
-            await watch.promise.catch(noop);
-            // Second cancel should not throw or cause issues.
-            expect(() => watch.cancel()).not.toThrow();
-        });
+    it('rejects a watch with NativeCrashError when the app session exits', async () => {
+        const { session, emit } = createAppSessionMock({
+            status: 'exited',
+            occurredAt: Date.now(),
+            reason: 'observed-exit',
+        });
+        const cm = createCrashMonitor({ appSession: session });
+        const watch = cm.watch('/test/example.ts', 'execution');
+        watch.promise.catch(noop);
+        emit({ type: 'app_exited' });
+        const error = await watch.promise.catch((err) => err);
+        expect(error).toBeInstanceOf(NativeCrashError);
+        expect(error.testFilePath).toBe('/test/example.ts');
+        expect(error.details.phase).toBe('execution');
+        expect(cm.isAlive()).toBe(false);
+    });
+    it('classifies bridge disconnect plus exited app as NativeCrashError', async () => {
+        const { session, setState } = createAppSessionMock();
+        const cm = createCrashMonitor({ appSession: session });
+        const watch = cm.watch('test.ts', 'execution');
+        watch.promise.catch(noop);
+        cm.handleBridgeDisconnect();
+        setState({
+            status: 'exited',
+            occurredAt: Date.now(),
+            reason: 'process-gone',
+        });
+        await expect(watch.promise).rejects.toBeInstanceOf(NativeCrashError);
+    });
+    it('classifies bridge disconnect plus running app as RuntimeDisconnectError', async () => {
+        const { session } = createAppSessionMock({ status: 'running' });
+        const cm = createCrashMonitor({ appSession: session });
+        const watch = cm.watch('test.ts', 'execution');
+        watch.promise.catch(noop);
+        cm.handleBridgeDisconnect();
+        await expect(watch.promise).rejects.toBeInstanceOf(RuntimeDisconnectError);
+    });
+    it('attaches matching session log evidence to native crash details', async () => {
+        const occurredAt = Date.now();
+        const logs = [
+            { line: 'ordinary app log', occurredAt },
+            { line: 'MyApp[123] fatal error: boom', occurredAt },
+        ];
+        const { session, setState } = createAppSessionMock({ status: 'running' }, logs);
+        const cm = createCrashMonitor({ appSession: session });
+        const watch = cm.watch('test.ts', 'execution');
+        watch.promise.catch(noop);
+        cm.handleBridgeDisconnect();
+        setState({ status: 'exited', occurredAt, reason: 'process-gone' });
+        const error = await watch.promise.catch((err) => err);
+        expect(error).toBeInstanceOf(NativeCrashError);
+        expect(error.details.rawLines).toEqual(['MyApp[123] fatal error: boom']);
+    });
+    it('asks the app session to extract native crash details for the current test', async () => {
+        const occurredAt = Date.now();
+        const getCrashDetails = vi.fn(async () => ({
+            artifactType: 'logcat',
+            artifactPath: '/tmp/.harness/crash-reports/crash-logcat.txt',
+            processName: 'com.harnessplayground',
+            pid: 7777,
+        }));
+        const { session, setState } = createAppSessionMock({ status: 'running' }, [], getCrashDetails);
+        const cm = createCrashMonitor({ appSession: session });
+        const watch = cm.watch('/test/example.ts', 'execution');
+        watch.promise.catch(noop);
+        cm.handleBridgeDisconnect();
+        setState({
+            status: 'exited',
+            occurredAt,
+            pid: 7777,
+            reason: 'process-gone',
+        });
+        const error = await watch.promise.catch((err) => err);
+        expect(getCrashDetails).toHaveBeenCalledWith({
+            occurredAt: expect.any(Number),
+            pid: 7777,
+            processName: undefined,
+            testFilePath: '/test/example.ts',
+        });
+        expect(error.details.artifactPath).toBe('/tmp/.harness/crash-reports/crash-logcat.txt');
+        expect(error.message).toContain(`Harness extracted the crash log: ${path.relative(process.cwd(), '/tmp/.harness/crash-reports/crash-logcat.txt')}`);
+    });
+    it('falls back to log details when native crash extraction fails', async () => {
+        const occurredAt = Date.now();
+        const getCrashDetails = vi.fn(async () => {
+            throw new Error('copy failed');
+        });
+        const { session, setState } = createAppSessionMock({ status: 'running' }, [{ line: 'MyApp[123] fatal error: boom', occurredAt }], getCrashDetails);
+        const cm = createCrashMonitor({ appSession: session });
+        const watch = cm.watch('/test/example.ts', 'execution');
+        watch.promise.catch(noop);
+        cm.handleBridgeDisconnect();
+        setState({ status: 'exited', occurredAt, reason: 'process-gone' });
+        const error = await watch.promise.catch((err) => err);
+        expect(error.details.rawLines).toEqual(['MyApp[123] fatal error: boom']);
+        expect(error.message).toContain("Harness couldn't extract the crash log.");
+    });
+    it('settles the promise with CrashWatchCancelledError on cancel()', async () => {
+        const cm = createCrashMonitor();
+        const watch = cm.watch('test.ts', 'execution');
+        watch.cancel();
+        await expect(watch.promise).rejects.toBeInstanceOf(CrashWatchCancelledError);
     });
-    describe('unconfirmed events', () => {
-        it('fires the crash if isAppRunning returns false', async () => {
-            const { monitor, emit } = createAppMonitorMock();
-            const runner = createPlatformRunnerMock(false /* not running */);
-            const cm = createCrashMonitor({ appMonitor: monitor, platformRunner: runner });
+    it('ignores session events while stopped', async () => {
+        const { session, emit } = createAppSessionMock({
+            status: 'exited',
+            occurredAt: Date.now(),
+        });
+        const cm = createCrashMonitor({ appSession: session });
+        await cm.stop();
+        const watch = cm.watch('test.ts', 'execution');
+        const settled = vi.fn();
+        watch.promise.then(settled, settled);
+        emit({ type: 'app_exited' });
+        await waitForClassification();
+        expect(settled).not.toHaveBeenCalled();
+        watch.cancel();
+    });
+    it('removes the app session listener on dispose', async () => {
+        const { session } = createAppSessionMock();
+        const cm = createCrashMonitor({ appSession: session });
+        await cm.dispose();
+        expect(session.removeListener).toHaveBeenCalledOnce();
+        expect(cm.isAlive()).toBe(false);
+    });
+    describe('expectDisconnect', () => {
+        it('suppresses handleBridgeDisconnect while the window is open', async () => {
+            const { session } = createAppSessionMock({ status: 'running' });
+            const cm = createCrashMonitor({ appSession: session });
             const watch = cm.watch('test.ts', 'execution');
             watch.promise.catch(noop);
-            emit({ type: 'app_exited', isConfirmed: false });
-            await expect(watch.promise).rejects.toBeInstanceOf(NativeCrashError);
-        });
-        it('does not fire if isAppRunning returns true', async () => {
-            const { monitor, emit } = createAppMonitorMock();
-            const runner = createPlatformRunnerMock(true /* still running */);
-            const cm = createCrashMonitor({ appMonitor: monitor, platformRunner: runner });
-            const watch = cm.watch('test.ts', 'execution');
+            const closeWindow = cm.expectDisconnect();
+            cm.handleBridgeDisconnect();
+            await waitForClassification();
             const settled = vi.fn();
             watch.promise.then(settled, settled);
-            emit({ type: 'app_exited', isConfirmed: false });
-            await new Promise((r) => setTimeout(r, 20));
+            await Promise.resolve();
             expect(settled).not.toHaveBeenCalled();
+            closeWindow();
             watch.cancel();
         });
-        it('fires on possible_crash when confirmed', async () => {
-            const { monitor, emit } = createAppMonitorMock();
-            const cm = createCrashMonitor({ appMonitor: monitor, platformRunner: createPlatformRunnerMock() });
+        it('resumes classifying disconnects once the window closes', async () => {
+            const { session } = createAppSessionMock({ status: 'running' });
+            const cm = createCrashMonitor({ appSession: session });
             const watch = cm.watch('test.ts', 'execution');
             watch.promise.catch(noop);
-            emit({ type: 'possible_crash', isConfirmed: true });
-            await expect(watch.promise).rejects.toBeInstanceOf(NativeCrashError);
-        });
-    });
-    describe('crash detail enrichment', () => {
-        it('merges initial and enriched crash details', async () => {
-            const { monitor, emit } = createAppMonitorMock();
-            const runner = createPlatformRunnerMock(false, {
-                processName: 'MyApp',
-                signal: 'SIGSEGV',
-                summary: 'Segmentation fault',
-            });
-            const cm = createCrashMonitor({ appMonitor: monitor, platformRunner: runner });
+            const closeWindow = cm.expectDisconnect();
+            closeWindow();
+            cm.handleBridgeDisconnect();
+            await expect(watch.promise).rejects.toBeInstanceOf(RuntimeDisconnectError);
+        });
+        it('keeps the window open until every opener has closed it (nested windows)', async () => {
+            const { session } = createAppSessionMock({ status: 'running' });
+            const cm = createCrashMonitor({ appSession: session });
             const watch = cm.watch('test.ts', 'execution');
             watch.promise.catch(noop);
-            emit({ type: 'app_exited', isConfirmed: true, crashDetails: { pid: 1234 } });
-            const error = await watch.promise.catch((e) => e);
-            expect(error.details.processName).toBe('MyApp');
-            expect(error.details.signal).toBe('SIGSEGV');
-            expect(error.details.pid).toBe(1234);
-        });
-    });
-    describe('stop / start', () => {
-        it('ignores events while stopped', async () => {
-            const { monitor, emit } = createAppMonitorMock();
-            const cm = createCrashMonitor({ appMonitor: monitor, platformRunner: createPlatformRunnerMock() });
-            await cm.stop();
-            const watch = cm.watch('test.ts', 'execution');
+            const closeFirst = cm.expectDisconnect();
+            const closeSecond = cm.expectDisconnect();
+            closeFirst();
+            cm.handleBridgeDisconnect();
+            await waitForClassification();
             const settled = vi.fn();
             watch.promise.then(settled, settled);
-            emit({ type: 'app_exited', isConfirmed: true });
-            await new Promise((r) => setTimeout(r, 10));
+            await Promise.resolve();
             expect(settled).not.toHaveBeenCalled();
+            closeSecond();
             watch.cancel();
         });
-        it('resumes monitoring after start()', async () => {
-            const { monitor, emit } = createAppMonitorMock();
-            const cm = createCrashMonitor({ appMonitor: monitor, platformRunner: createPlatformRunnerMock() });
-            await cm.stop();
-            await cm.start();
+        it('ignores a redundant close() call', async () => {
+            const { session } = createAppSessionMock({ status: 'running' });
+            const cm = createCrashMonitor({ appSession: session });
             const watch = cm.watch('test.ts', 'execution');
             watch.promise.catch(noop);
-            emit({ type: 'app_exited', isConfirmed: true });
-            await expect(watch.promise).rejects.toBeInstanceOf(NativeCrashError);
-        });
-    });
-    describe('reset', () => {
-        it('clears alive state and pending watchers', async () => {
-            const { monitor, emit } = createAppMonitorMock();
-            const cm = createCrashMonitor({ appMonitor: monitor, platformRunner: createPlatformRunnerMock() });
-            emit({ type: 'app_started' });
-            const watch = cm.watch('test.ts', 'execution');
-            watch.promise.catch(noop);
-            cm.reset();
-            expect(cm.isAlive()).toBe(false);
-            // The watcher was cleared; a crash fired now should not reach the old watch.
-            emit({ type: 'app_exited', isConfirmed: true });
-            await new Promise((r) => setTimeout(r, 10));
-            // Old promise is still pending (we can verify by cancel resolving it).
-            watch.cancel();
-            await expect(watch.promise).rejects.toBeInstanceOf(CrashWatchCancelledError);
-        });
-    });
-    describe('dispose', () => {
-        it('ignores events after dispose', async () => {
-            const { monitor, emit } = createAppMonitorMock();
-            const cm = createCrashMonitor({ appMonitor: monitor, platformRunner: createPlatformRunnerMock() });
-            const watch = cm.watch('test.ts', 'execution');
-            watch.promise.catch(noop);
-            await cm.dispose();
-            emit({ type: 'app_exited', isConfirmed: true });
-            await new Promise((r) => setTimeout(r, 10));
-            // After dispose watchers are cleared, so crash didn't propagate.
-            // The promise is still pending - cancel to settle it.
-            watch.cancel();
-            await expect(watch.promise).rejects.toBeInstanceOf(CrashWatchCancelledError);
-        });
-        it('calls appMonitor.dispose()', async () => {
-            const { monitor } = createAppMonitorMock();
-            const cm = createCrashMonitor({ appMonitor: monitor, platformRunner: createPlatformRunnerMock() });
+            const closeWindow = cm.expectDisconnect();
+            closeWindow();
+            closeWindow();
+            cm.handleBridgeDisconnect();
+            await expect(watch.promise).rejects.toBeInstanceOf(RuntimeDisconnectError);
+        });
+        it('clears the expected-disconnect window on dispose', async () => {
+            const { session } = createAppSessionMock({ status: 'running' });
+            const cm = createCrashMonitor({ appSession: session });
+            cm.expectDisconnect();
             await cm.dispose();
-            expect(monitor.dispose).toHaveBeenCalledOnce();
+            // A disconnect after dispose should not throw or hang; monitoring is
+            // fully torn down regardless of the window state.
+            expect(() => cm.handleBridgeDisconnect()).not.toThrow();
         });
     });
 });

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

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

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

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