@react-native-harness/jest 1.3.0 → 1.4.0

package/dist/__tests__/run.test.js

@@ -0,0 +1,48 @@
+import { describe, expect, it, vi } from 'vitest';
+import { runHarnessTestFile } from '../run.js';
+vi.mock('jest-message-util', () => ({
+    formatResultsErrors: vi.fn(() => ''),
+}));
+const createHarnessResult = () => ({
+    name: 'root',
+    tests: [],
+    suites: [],
+    status: 'passed',
+    duration: 0,
+});
+const createSession = (testTimeout) => ({
+    config: { testTimeout },
+    context: {
+        platform: {
+            runner: './runner.js',
+        },
+    },
+    runTestFile: vi.fn(async () => createHarnessResult()),
+});
+const createGlobalConfig = (overrides = {}) => ({
+    rootDir: '/project',
+    ...overrides,
+});
+const createProjectConfig = (overrides = {}) => overrides;
+describe('runHarnessTestFile', () => {
+    it('uses Harness config testTimeout when Jest config does not set one', async () => {
+        const session = createSession(15000);
+        await runHarnessTestFile({
+            testPath: '/project/example.harness.ts',
+            session,
+            globalConfig: createGlobalConfig(),
+            projectConfig: createProjectConfig(),
+        });
+        expect(session.runTestFile).toHaveBeenCalledWith('example.harness.ts', expect.objectContaining({ testTimeout: 15000 }));
+    });
+    it('keeps Harness config testTimeout above Jest config testTimeout', async () => {
+        const session = createSession(15000);
+        await runHarnessTestFile({
+            testPath: '/project/example.harness.ts',
+            session,
+            globalConfig: createGlobalConfig({ testTimeout: 20000 }),
+            projectConfig: createProjectConfig({ testTimeout: 30000 }),
+        });
+        expect(session.runTestFile).toHaveBeenCalledWith('example.harness.ts', expect.objectContaining({ testTimeout: 15000 }));
+    });
+});

package/dist/__tests__/test-file-platform-filter.test.d.ts

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

package/dist/__tests__/test-file-platform-filter.test.d.ts.map

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

package/dist/__tests__/test-file-platform-filter.test.js

@@ -0,0 +1,47 @@
+import { describe, expect, it } from 'vitest';
+import { createPlatformSkippedTestResult, getHarnessTestFilePlatform, shouldRunHarnessTestFile, } from '../test-file-platform-filter.js';
+const knownPlatformIds = new Set(['android', 'ios', 'web', 'vega']);
+describe('getHarnessTestFilePlatform', () => {
+    it('returns null for shared harness test files', () => {
+        expect(getHarnessTestFilePlatform('/tests/smoke.harness.ts', knownPlatformIds)).toBeNull();
+        expect(getHarnessTestFilePlatform('/tests/smoke.harness.tsx', knownPlatformIds)).toBeNull();
+        expect(getHarnessTestFilePlatform('/tests/smoke.harness.mjs', knownPlatformIds)).toBeNull();
+    });
+    it('returns the platform id for platform-specific harness test files', () => {
+        expect(getHarnessTestFilePlatform('/tests/kotlin.android.harness.ts', knownPlatformIds)).toBe('android');
+        expect(getHarnessTestFilePlatform('/tests/swift.ios.harness.ts', knownPlatformIds)).toBe('ios');
+        expect(getHarnessTestFilePlatform('/tests/browser.web.harness.ts', knownPlatformIds)).toBe('web');
+    });
+    it('returns null when the segment before .harness is not a known platform id', () => {
+        expect(getHarnessTestFilePlatform('/tests/smoke.harness.ts', knownPlatformIds)).toBeNull();
+        expect(getHarnessTestFilePlatform('/tests/custom.foo.harness.ts', knownPlatformIds)).toBeNull();
+    });
+});
+describe('shouldRunHarnessTestFile', () => {
+    it('runs shared harness test files on every platform', () => {
+        expect(shouldRunHarnessTestFile('/tests/smoke.harness.ts', 'android', knownPlatformIds)).toBe(true);
+        expect(shouldRunHarnessTestFile('/tests/smoke.harness.ts', 'ios', knownPlatformIds)).toBe(true);
+    });
+    it('runs platform-specific files only on the matching platform', () => {
+        expect(shouldRunHarnessTestFile('/tests/kotlin.android.harness.ts', 'android', knownPlatformIds)).toBe(true);
+        expect(shouldRunHarnessTestFile('/tests/kotlin.android.harness.ts', 'ios', knownPlatformIds)).toBe(false);
+        expect(shouldRunHarnessTestFile('/tests/swift.ios.harness.ts', 'ios', knownPlatformIds)).toBe(true);
+        expect(shouldRunHarnessTestFile('/tests/swift.ios.harness.ts', 'android', knownPlatformIds)).toBe(false);
+    });
+});
+describe('createPlatformSkippedTestResult', () => {
+    it('marks the entire test file as skipped', () => {
+        const result = createPlatformSkippedTestResult('/tests/swift.ios.harness.ts');
+        expect(result.skipped).toBe(true);
+        expect(result.numPassingTests).toBe(0);
+        expect(result.numFailingTests).toBe(0);
+        expect(result.numPendingTests).toBe(1);
+        expect(result.testResults).toHaveLength(1);
+        expect(result.testResults[0]).toEqual(expect.objectContaining({
+            status: 'skipped',
+            title: 'swift.ios.harness.ts',
+            fullName: 'swift.ios.harness.ts',
+        }));
+        expect(result.testFilePath).toBe('/tests/swift.ios.harness.ts');
+    });
+});

package/dist/crash-monitor.d.ts

@@ -1,4 +1,4 @@
-import { type AppMonitor, type HarnessPlatformRunner } from '@react-native-harness/platforms';
+import { type AppSession } from '@react-native-harness/platforms';
 import { type NativeCrashPhase } from './errors.js';
 export declare class CrashWatchCancelledError extends Error {
     constructor();
@@ -13,11 +13,19 @@ export type CrashMonitor = {
     stop: () => Promise<void>;
     start: () => Promise<void>;
     reset: () => void;
+    setAppSession: (session: AppSession | null) => void;
+    handleBridgeDisconnect: () => void;
+    /**
+     * Opens a window during which handleBridgeDisconnect() is suppressed,
+     * for use around operations (like a runtime reset) that intentionally
+     * disconnect the bridge without the app process dying. Returns a closer
+     * that ends the window; safe to call multiple times or nest.
+     */
+    expectDisconnect: () => () => void;
     dispose: () => Promise<void>;
 };
 export type CrashMonitorOptions = {
-    appMonitor: AppMonitor;
-    platformRunner: HarnessPlatformRunner;
+    appSession?: AppSession | null;
 };
-export declare const createCrashMonitor: ({ appMonitor, platformRunner, }: CrashMonitorOptions) => CrashMonitor;
+export declare const createCrashMonitor: ({ appSession: initialAppSession, }?: CrashMonitorOptions) => CrashMonitor;
 //# sourceMappingURL=crash-monitor.d.ts.map

package/dist/crash-monitor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"crash-monitor.d.ts","sourceRoot":"","sources":["../src/crash-monitor.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,UAAU,EAIf,KAAK,qBAAqB,EAC3B,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAGL,KAAK,gBAAgB,EACtB,MAAM,aAAa,CAAC;AAKrB,qBAAa,wBAAyB,SAAQ,KAAK;;CAKlD;AAED,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;IACjC,MAAM,EAAE,MAAM,IAAI,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,EAAE,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,gBAAgB,KAAK,UAAU,CAAC;IACrE,OAAO,EAAE,MAAM,OAAO,CAAC;IACvB,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3B,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,UAAU,EAAE,UAAU,CAAC;IACvB,cAAc,EAAE,qBAAqB,CAAC;CACvC,CAAC;AA6BF,eAAO,MAAM,kBAAkB,GAAI,iCAGhC,mBAAmB,KAAG,YA+KxB,CAAC"}
+{"version":3,"file":"crash-monitor.d.ts","sourceRoot":"","sources":["../src/crash-monitor.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,UAAU,EAKhB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAKL,KAAK,gBAAgB,EAEtB,MAAM,aAAa,CAAC;AAOrB,qBAAa,wBAAyB,SAAQ,KAAK;;CAKlD;AAED,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;IACjC,MAAM,EAAE,MAAM,IAAI,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,EAAE,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,gBAAgB,KAAK,UAAU,CAAC;IACrE,OAAO,EAAE,MAAM,OAAO,CAAC;IACvB,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3B,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,aAAa,EAAE,CAAC,OAAO,EAAE,UAAU,GAAG,IAAI,KAAK,IAAI,CAAC;IACpD,sBAAsB,EAAE,MAAM,IAAI,CAAC;IACnC;;;;;OAKG;IACH,gBAAgB,EAAE,MAAM,MAAM,IAAI,CAAC;IACnC,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,UAAU,CAAC,EAAE,UAAU,GAAG,IAAI,CAAC;CAChC,CAAC;AA0EF,eAAO,MAAM,kBAAkB,GAAI,qCAEhC,mBAAwB,KAAG,YA8M7B,CAAC"}

package/dist/crash-monitor.js

@@ -1,136 +1,144 @@
-import { NativeCrashError, } from './errors.js';
+import { NativeCrashError, RuntimeDisconnectError, } from './errors.js';
 import { logger } from '@react-native-harness/tools';
 const crashLogger = logger.child('crash');
+const CRASH_CLASSIFICATION_SETTLE_MS = 1500;
+const CRASH_LOG_WINDOW_MS = 3000;
 export class CrashWatchCancelledError extends Error {
     constructor() {
         super('Crash watch was cancelled');
         this.name = 'CrashWatchCancelledError';
     }
 }
-const mergeCrashDetails = (phase, initial, enriched, fallbackSummary) => ({
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const isCrashIndicator = (line) => /uncaught exception|terminating app due to|fatal error|EXC_[A-Z_]+|termination reason|crash|abort/i.test(line) || /\bSIG[A-Z]{2,}\b/.test(line);
+const getMatchingCrashLines = (logs, occurredAt) => logs
+    .filter((log) => Math.abs(log.occurredAt - occurredAt) <= CRASH_LOG_WINDOW_MS)
+    .map((log) => log.line)
+    .filter(isCrashIndicator);
+const buildNativeCrashDetails = (phase, rawLines, summary) => ({
     phase,
-    source: enriched?.source ?? initial?.source,
-    summary: enriched?.summary ?? initial?.summary ?? fallbackSummary,
-    signal: enriched?.signal ?? initial?.signal,
-    exceptionType: enriched?.exceptionType ?? initial?.exceptionType,
-    processName: enriched?.processName ?? initial?.processName,
-    pid: enriched?.pid ?? initial?.pid,
-    stackTrace: enriched?.stackTrace ?? initial?.stackTrace,
-    rawLines: enriched?.rawLines ?? initial?.rawLines,
-    artifactType: enriched?.artifactType ?? initial?.artifactType,
-    artifactPath: enriched?.artifactPath ?? initial?.artifactPath,
+    source: rawLines.length > 0 ? 'logs' : 'bridge',
+    summary: rawLines.length > 0 ? rawLines.join('\n') : summary,
+    rawLines: rawLines.length > 0 ? rawLines : undefined,
 });
-export const createCrashMonitor = ({ appMonitor, platformRunner, }) => {
+const getStatePid = (state) => {
+    if (state && 'pid' in state) {
+        return state.pid;
+    }
+    return undefined;
+};
+const mergeCrashDetails = (fallback, extracted) => {
+    if (!extracted) {
+        return fallback;
+    }
+    return {
+        ...fallback,
+        ...extracted,
+        phase: fallback.phase,
+        source: extracted.source ?? fallback.source,
+        summary: extracted.summary ?? fallback.summary,
+        rawLines: extracted.rawLines ?? fallback.rawLines,
+    };
+};
+const buildRuntimeDisconnectDetails = (phase, rawLines) => ({
+    phase,
+    source: 'bridge',
+    summary: 'The runtime bridge disconnected, but the app session still appears to be running.',
+    rawLines: rawLines.length > 0 ? rawLines : undefined,
+});
+export const createCrashMonitor = ({ appSession: initialAppSession = null, } = {}) => {
     let alive = false;
     let monitoring = true;
     let isResolvingCrash = false;
     let disposed = false;
-    // Both updated when watch() is called so crashes are attributed to the
-    // correct test file and lifecycle phase.
+    let appSession = null;
+    let pendingTimer = null;
     let currentTestFilePath = '';
     let currentPhase = 'startup';
+    let expectedDisconnectDepth = 0;
     const watchers = new Set();
-    const getCrashDetailsProvider = () => {
-        if ('getCrashDetails' in appMonitor) {
-            return appMonitor;
-        }
-        if (platformRunner.getCrashDetails) {
-            return platformRunner;
-        }
-        return null;
-    };
-    const notifyCrash = (err) => {
+    const notifyFailure = (err) => {
         const pending = [...watchers];
         watchers.clear();
         for (const fn of pending)
             fn(err);
     };
-    const handleCrash = async (phase, details, fallbackSummary) => {
-        if (isResolvingCrash)
+    const clearPendingTimer = () => {
+        if (pendingTimer) {
+            clearTimeout(pendingTimer);
+            pendingTimer = null;
+        }
+    };
+    const classify = async (pending, trigger) => {
+        if (disposed || !monitoring || isResolvingCrash) {
             return;
-        isResolvingCrash = true;
-        alive = false;
-        crashLogger.debug('native crash detected (phase=%s)', phase);
-        for (const line of details?.rawLines ?? []) {
-            crashLogger.debug('%s', line);
         }
+        isResolvingCrash = true;
         try {
-            const enriched = await getCrashDetailsProvider()?.getCrashDetails?.({
-                processName: details?.processName,
-                pid: details?.pid,
-                occurredAt: Date.now(),
-            });
-            const merged = mergeCrashDetails(phase, details, enriched, fallbackSummary);
-            crashLogger.debug('crash details: %o', {
-                phase: merged.phase,
-                source: merged.source,
-                summary: merged.summary,
-                signal: merged.signal,
-                exceptionType: merged.exceptionType,
-                processName: merged.processName,
-                pid: merged.pid,
-            });
-            notifyCrash(new NativeCrashError(currentTestFilePath, merged));
+            const session = appSession;
+            const state = await session?.getState();
+            const logs = session?.getLogs() ?? [];
+            const rawLines = getMatchingCrashLines(logs, pending.occurredAt);
+            if (state?.status === 'running' && trigger === 'bridge-disconnect') {
+                crashLogger.debug('runtime bridge disconnected without confirmed app death');
+                notifyFailure(new RuntimeDisconnectError(pending.testFilePath, buildRuntimeDisconnectDetails(pending.phase, rawLines)));
+                return;
+            }
+            alive = false;
+            crashLogger.debug('native crash detected (phase=%s)', pending.phase);
+            for (const line of rawLines) {
+                crashLogger.debug('%s', line);
+            }
+            const fallbackSummary = trigger === 'bridge-disconnect'
+                ? 'The app process exited after the runtime bridge disconnected, but no crash log lines were found.'
+                : 'The app process exited, but no crash log lines were found.';
+            const details = buildNativeCrashDetails(pending.phase, rawLines, fallbackSummary);
+            const extractedDetails = session?.getCrashDetails
+                ? await session
+                    .getCrashDetails({
+                    occurredAt: pending.occurredAt,
+                    pid: getStatePid(state),
+                    processName: details.processName,
+                    testFilePath: pending.testFilePath,
+                })
+                    .catch((error) => {
+                    crashLogger.warn('failed to extract native crash details: %s', error);
+                    return null;
+                })
+                : null;
+            notifyFailure(new NativeCrashError(pending.testFilePath, mergeCrashDetails(details, extractedDetails)));
         }
         finally {
             isResolvingCrash = false;
+            pendingTimer = null;
         }
     };
-    const confirmAndHandleCrash = async (phase, details, fallbackSummary) => {
-        if (disposed || !monitoring)
+    const startCrashResolution = (trigger) => {
+        if (disposed || !monitoring || isResolvingCrash) {
             return;
-        try {
-            const isRunning = await platformRunner.isAppRunning();
-            if (!isRunning) {
-                void handleCrash(phase, details, fallbackSummary);
-            }
-        }
-        catch (error) {
-            crashLogger.debug('crash confirmation failed', error);
         }
+        clearPendingTimer();
+        const pending = {
+            testFilePath: currentTestFilePath,
+            phase: currentPhase,
+            occurredAt: Date.now(),
+        };
+        pendingTimer = setTimeout(() => {
+            void classify(pending, trigger);
+        }, trigger === 'bridge-disconnect' ? CRASH_CLASSIFICATION_SETTLE_MS : 0);
     };
-    const extractCrashDetails = (event) => event.crashDetails
-        ? {
-            source: event.crashDetails.source ?? event.source,
-            summary: event.crashDetails.summary,
-            signal: event.crashDetails.signal,
-            exceptionType: event.crashDetails.exceptionType,
-            processName: event.crashDetails.processName,
-            pid: event.crashDetails.pid ?? event.pid,
-            stackTrace: event.crashDetails.stackTrace,
-            rawLines: event.crashDetails.rawLines ??
-                (event.line ? [event.line] : undefined),
-        }
-        : undefined;
-    const appMonitorListener = (event) => {
-        if (disposed || !monitoring)
-            return;
-        if (event.type === 'app_started') {
-            alive = true;
-            return;
-        }
+    const appSessionListener = (event) => {
         if (event.type === 'app_exited') {
-            const details = extractCrashDetails(event);
-            if (event.isConfirmed ?? event.source === 'polling') {
-                void handleCrash(currentPhase, details);
-            }
-            else {
-                void confirmAndHandleCrash(currentPhase, details);
-            }
-            return;
-        }
-        if (event.type === 'possible_crash') {
-            const details = extractCrashDetails(event);
-            const fallback = `possible crash signal (${event.source ?? 'unknown'})`;
-            if (event.isConfirmed) {
-                void handleCrash(currentPhase, details, fallback);
-            }
-            else {
-                void confirmAndHandleCrash(currentPhase, details, fallback);
-            }
+            startCrashResolution('app-exit');
         }
     };
-    appMonitor.addListener(appMonitorListener);
+    const setAppSession = (session) => {
+        appSession?.removeListener(appSessionListener);
+        appSession = session;
+        alive = Boolean(session);
+        session?.addListener(appSessionListener);
+    };
+    setAppSession(initialAppSession);
     const watch = (testFilePath, phase) => {
         currentTestFilePath = testFilePath;
         currentPhase = phase;
@@ -147,30 +155,55 @@ export const createCrashMonitor = ({ appMonitor, platformRunner, }) => {
         };
         return { promise, cancel };
     };
+    const expectDisconnect = () => {
+        expectedDisconnectDepth += 1;
+        let closed = false;
+        return () => {
+            if (closed) {
+                return;
+            }
+            closed = true;
+            expectedDisconnectDepth = Math.max(0, expectedDisconnectDepth - 1);
+        };
+    };
     return {
         watch,
         isAlive: () => alive,
         stop: async () => {
             monitoring = false;
-            await appMonitor.stop();
+            clearPendingTimer();
+            await sleep(0);
         },
         start: async () => {
             monitoring = true;
-            await appMonitor.start();
         },
         reset: () => {
-            alive = false;
+            alive = Boolean(appSession);
             watchers.clear();
             isResolvingCrash = false;
             currentTestFilePath = '';
+            expectedDisconnectDepth = 0;
+            clearPendingTimer();
         },
+        setAppSession,
+        handleBridgeDisconnect: () => {
+            if (expectedDisconnectDepth > 0) {
+                crashLogger.debug('ignoring expected bridge disconnect');
+                return;
+            }
+            startCrashResolution('bridge-disconnect');
+        },
+        expectDisconnect,
         dispose: async () => {
             disposed = true;
             monitoring = false;
+            expectedDisconnectDepth = 0;
             watchers.clear();
             isResolvingCrash = false;
-            appMonitor.removeListener(appMonitorListener);
-            await appMonitor.dispose();
+            clearPendingTimer();
+            appSession?.removeListener(appSessionListener);
+            appSession = null;
+            alive = false;
         },
     };
 };

package/dist/diagnostics/__tests__/derivers.test.d.ts

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

package/dist/diagnostics/__tests__/derivers.test.d.ts.map

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