@react-native-harness/jest 1.2.0 → 1.4.0-rc.1

package/dist/harness-session.js

@@ -2,9 +2,10 @@ import { createHarnessBridge, } from '@react-native-harness/bridge/server';
 import { HARNESS_BRIDGE_PATH, } from '@react-native-harness/bridge';
 import { getMetroInstance, isMetroCacheReusable, waitForMetroBackedAppReady, } from '@react-native-harness/bundler-metro';
 import { createHarnessPluginManager, } from '@react-native-harness/plugins';
-import { logger, createCrashArtifactWriter, getTimeoutSignal, raceAbortSignals, } from '@react-native-harness/tools';
+import { createCrashArtifactWriter, logger, getTimeoutSignal, raceAbortSignals, } from '@react-native-harness/tools';
 import { getConfig, ConfigSchema, } from '@react-native-harness/config';
 import { preRunMessage } from 'jest-util';
+import path from 'node:path';
 import { PlatformReadyTimeoutError } from './errors.js';
 import { NoRunnerSpecifiedError, RunnerNotFoundError } from './errors.js';
 import { createCrashMonitor } from './crash-monitor.js';
@@ -18,6 +19,28 @@ import { logMetroCacheReused, logMetroPortFallback, logNativeCoverageCollected,
 const sessionLogger = logger.child('runtime');
 const defaultResourceLockManager = createResourceLockManager();
 const ignorePromiseRejection = () => undefined;
+const isBridgeDisconnectError = (error) => error instanceof Error && error.message === 'App bridge disconnected';
+const TEST_RUN_BRIDGE_STABILITY_WAIT_MS = 500;
+export const waitForBridgeDisconnectOrTimeout = async ({ bridge, connection, timeoutMs, }) => {
+    if (bridge.connection !== connection) {
+        return true;
+    }
+    return await new Promise((resolve) => {
+        const onDisconnected = () => {
+            cleanup();
+            resolve(true);
+        };
+        const cleanup = () => {
+            clearTimeout(timer);
+            bridge.off('disconnected', onDisconnected);
+        };
+        const timer = setTimeout(() => {
+            cleanup();
+            resolve(bridge.connection !== connection);
+        }, timeoutMs);
+        bridge.on('disconnected', onDisconnected);
+    });
+};
 // ---------------------------------------------------------------------------
 // Internal helpers
 // ---------------------------------------------------------------------------
@@ -46,8 +69,21 @@ const withPlatformReadyTimeout = async (options) => {
         throw error;
     }
 };
+export const waitForStartupCrash = async ({ crashMonitor, detectNativeCrashes, testFilePath, signal, }) => {
+    if (!detectNativeCrashes) {
+        return await waitForAbort(signal);
+    }
+    const watch = crashMonitor.watch(testFilePath, 'startup');
+    watch.promise.catch(ignorePromiseRejection); // suppress unhandled-rejection when abort wins race
+    try {
+        return await Promise.race([watch.promise, waitForAbort(signal)]);
+    }
+    finally {
+        watch.cancel();
+    }
+};
 const waitForAppReady = async (base, testFilePath) => {
-    const { metroInstance, bridge, platformInstance, platformId, bundleStartTimeout, readyTimeout, maxAppRestarts, crashMonitor, appLaunchOptions, } = base;
+    const { metroInstance, bridge, platformId, bundleStartTimeout, readyTimeout, maxAppRestarts, crashMonitor, detectNativeCrashes, restartAppSession, } = base;
     const logWait = (message, ...args) => sessionLogger.debug(`waitForAppReady: ${message}`, ...args);
     return await waitForMetroBackedAppReady({
         metro: metroInstance,
@@ -58,7 +94,7 @@ const waitForAppReady = async (base, testFilePath) => {
         signal: new AbortController().signal,
         startAttempt: async () => {
             logWait('launching app for %s', testFilePath);
-            await platformInstance.restartApp(appLaunchOptions);
+            await restartAppSession();
             logWait('launch request completed, waiting for bridge ready');
         },
         waitForReady: async (signal) => {
@@ -69,7 +105,7 @@ const waitForAppReady = async (base, testFilePath) => {
             // connection from a previous run would resolve the promise before startAttempt
             // even restarts the app — leaving bridge.connection null after the restart.
             await new Promise((resolve, reject) => {
-                const onConnected = (_conn) => { cleanup(); resolve(); };
+                const onConnected = () => { cleanup(); resolve(); };
                 const onAbort = () => { cleanup(); reject(signal.reason ?? new DOMException('Aborted', 'AbortError')); };
                 const cleanup = () => {
                     bridge.off('connected', onConnected);
@@ -85,15 +121,13 @@ const waitForAppReady = async (base, testFilePath) => {
             logWait('runtime ready received');
         },
         waitForCrash: async (signal) => {
-            const watch = crashMonitor.watch(testFilePath, 'startup');
-            watch.promise.catch(ignorePromiseRejection); // suppress unhandled-rejection when abort wins race
-            try {
-                logWait('waiting for crash or runtime ready');
-                return await Promise.race([watch.promise, waitForAbort(signal)]);
-            }
-            finally {
-                watch.cancel();
-            }
+            logWait('waiting for crash or runtime ready');
+            return await waitForStartupCrash({
+                crashMonitor,
+                detectNativeCrashes,
+                testFilePath,
+                signal,
+            });
         },
         onAttemptStart: () => {
             logWait('beginning launch attempt for %s', testFilePath);
@@ -242,6 +276,11 @@ export const createHarnessSession = async (globalConfig, { lockManager = default
         const getCurrentRunId = () => currentRun?.runId;
         const clientLogCollector = createClientLogCollector();
         const context = { platform };
+        const crashArtifactWriter = createCrashArtifactWriter({
+            runnerName: platform.name,
+            platformId: platform.platformId,
+            rootDir: path.join(projectRoot, '.harness', 'crash-reports'),
+        });
         const bridge = await createHarnessBridge({
             noServer: true,
             timeout: runtimeConfig.bridgeTimeout,
@@ -268,6 +307,7 @@ export const createHarnessSession = async (globalConfig, { lockManager = default
                     work: async (signal) => {
                         return await import(platform.runner).then((module) => module.default(platform.config, runtimeConfig, {
                             signal,
+                            crashArtifactWriter,
                         })).then((instance) => {
                             sessionLogger.debug('platform runner initialized');
                             return instance;
@@ -281,25 +321,38 @@ export const createHarnessSession = async (globalConfig, { lockManager = default
             await bridge.dispose();
             throw error;
         }
-        const crashArtifactWriter = createCrashArtifactWriter({
-            runnerName: platform.name,
-            platformId: platform.platformId,
-        });
-        const appMonitor = platformInstance.createAppMonitor({ crashArtifactWriter });
         const appLaunchOptions = platform.config.appLaunchOptions;
-        const crashMonitor = createCrashMonitor({ appMonitor, platformRunner: platformInstance });
+        let currentAppSession = null;
+        const crashMonitor = createCrashMonitor();
+        const disposeCurrentAppSession = async () => {
+            const session = currentAppSession;
+            currentAppSession = null;
+            crashMonitor.setAppSession(null);
+            if (session) {
+                await session.dispose();
+            }
+        };
+        const restartAppSession = async () => {
+            await crashMonitor.stop();
+            await disposeCurrentAppSession();
+            const session = await platformInstance.createAppSession(appLaunchOptions);
+            currentAppSession = session;
+            crashMonitor.setAppSession(session);
+            await crashMonitor.start();
+            return session;
+        };
         // Pre-build the options that are constant across all app-ready calls;
         // only testFilePath varies per call.
         const appReadyBaseOptions = {
             metroInstance,
             bridge,
-            platformInstance,
             platformId: platform.platformId,
             bundleStartTimeout: runtimeConfig.bundleStartTimeout ?? 60000,
             readyTimeout: runtimeConfig.bridgeTimeout,
             maxAppRestarts: runtimeConfig.maxAppRestarts ?? 2,
             crashMonitor,
-            appLaunchOptions,
+            detectNativeCrashes: runtimeConfig.detectNativeCrashes !== false,
+            restartAppSession,
         };
         // --- Event listeners ---
         const bridgeEventListener = buildBridgeHookScheduler(hooks, pluginManager, getCurrentRunId);
@@ -311,6 +364,17 @@ export const createHarnessSession = async (globalConfig, { lockManager = default
         };
         const flushClientLogs = () => clientLogCollector.flush();
         const clientLogListener = clientLogCollector.handleEvent;
+        const testRunnerEventListeners = new Set();
+        const onTestRunnerEvent = (event) => {
+            if (event.type === 'test-started' ||
+                event.type === 'test-finished' ||
+                event.type === 'suite-started' ||
+                event.type === 'suite-finished' ||
+                event.type === 'file-started' ||
+                event.type === 'file-finished') {
+                testRunnerEventListeners.forEach((listener) => listener(event));
+            }
+        };
         const onConnected = (conn) => {
             const runId = getCurrentRunId();
             if (!runId)
@@ -322,10 +386,14 @@ export const createHarnessSession = async (globalConfig, { lockManager = default
             if (!runId)
                 return;
             hooks.schedule(() => pluginManager.callHook('runtime:disconnected', { runId, reason: 'bridge-disconnected' }));
+            if (runtimeConfig.detectNativeCrashes !== false) {
+                crashMonitor.handleBridgeDisconnect();
+            }
         };
         bridge.on('connected', onConnected);
         bridge.on('disconnected', onDisconnected);
         bridge.on('event', bridgeEventListener);
+        bridge.on('event', onTestRunnerEvent);
         metroInstance.events.addListener(onMetroEvent);
         if (runtimeConfig.forwardClientLogs) {
             metroInstance.events.addListener(clientLogListener);
@@ -365,10 +433,12 @@ export const createHarnessSession = async (globalConfig, { lockManager = default
             bridge.off('connected', onConnected);
             bridge.off('disconnected', onDisconnected);
             bridge.off('event', bridgeEventListener);
+            bridge.off('event', onTestRunnerEvent);
             const nativeCoverageConfig = runtimeConfig.coverage?.native?.ios;
             if (nativeCoverageConfig?.pods?.length && platformInstance.collectNativeCoverage) {
                 try {
-                    await platformInstance.stopApp();
+                    await crashMonitor.stop();
+                    await disposeCurrentAppSession();
                     const lcovPath = await platformInstance.collectNativeCoverage({
                         pods: nativeCoverageConfig.pods,
                         outputDir: projectRoot,
@@ -385,6 +455,7 @@ export const createHarnessSession = async (globalConfig, { lockManager = default
             try {
                 await Promise.all([
                     crashMonitor.dispose(),
+                    disposeCurrentAppSession(),
                     bridge.dispose(),
                     platformInstance.dispose(),
                     metroInstance.dispose(),
@@ -419,8 +490,6 @@ export const createHarnessSession = async (globalConfig, { lockManager = default
         try {
             await pluginManager.callHook('harness:before-creation', { appLaunchOptions });
             await hooks.drain();
-            await appMonitor.start();
-            sessionLogger.debug('app monitor started');
             await pluginManager.callHook('harness:before-run', { appLaunchOptions });
             await hooks.drain();
         }
@@ -436,9 +505,12 @@ export const createHarnessSession = async (globalConfig, { lockManager = default
         const ensureAppReady = async (testFilePath) => {
             await hooks.drain();
             sessionLogger.debug('ensuring app is ready for %s', testFilePath);
-            if (crashMonitor.isAlive() && bridge.connection !== null && await platformInstance.isAppRunning()) {
-                sessionLogger.debug('reusing existing ready app for %s', testFilePath);
-                return;
+            if (crashMonitor.isAlive() && bridge.connection !== null && currentAppSession) {
+                const state = await currentAppSession.getState();
+                if (state.status === 'running') {
+                    sessionLogger.debug('reusing existing ready app for %s', testFilePath);
+                    return;
+                }
             }
             crashMonitor.reset();
             sessionLogger.debug('app not ready, waiting for launch and runtime readiness');
@@ -450,16 +522,16 @@ export const createHarnessSession = async (globalConfig, { lockManager = default
             await hooks.drain();
             await crashMonitor.stop();
             sessionLogger.debug('restarting app (testFile=%s mode=%s)', testFilePath ?? 'n/a', testFilePath ? 'stop-and-ensure-ready' : 'direct-restart');
+            await disposeCurrentAppSession();
             if (testFilePath) {
-                await platformInstance.stopApp();
+                await ensureAppReady(testFilePath);
             }
             else {
-                await platformInstance.restartApp(appLaunchOptions);
-            }
-            crashMonitor.reset();
-            await crashMonitor.start();
-            if (testFilePath) {
-                await ensureAppReady(testFilePath);
+                const session = await platformInstance.createAppSession(appLaunchOptions);
+                currentAppSession = session;
+                crashMonitor.setAppSession(session);
+                crashMonitor.reset();
+                await crashMonitor.start();
             }
             await hooks.drain();
             sessionLogger.debug('restart completed');
@@ -470,7 +542,7 @@ export const createHarnessSession = async (globalConfig, { lockManager = default
             if (!conn)
                 throw new Error('No active app connection');
             sessionLogger.debug('running test file on client: %s', testPath);
-            if (!runtimeConfig.detectNativeCrashes) {
+            if (runtimeConfig.detectNativeCrashes === false) {
                 const result = await conn.runTests(testPath, { ...options, runner: platform.runner });
                 await hooks.drain();
                 return result;
@@ -480,13 +552,30 @@ export const createHarnessSession = async (globalConfig, { lockManager = default
             // crash wins the race or cancel() is called after the test run wins.
             crashWatch.promise.catch(ignorePromiseRejection);
             try {
-                const result = await Promise.race([
-                    conn.runTests(testPath, { ...options, runner: platform.runner }),
-                    crashWatch.promise,
-                ]);
+                const testRunPromise = conn.runTests(testPath, {
+                    ...options,
+                    runner: platform.runner,
+                });
+                const result = await Promise.race([testRunPromise, crashWatch.promise]);
+                const bridgeDisconnected = await waitForBridgeDisconnectOrTimeout({
+                    bridge,
+                    connection: conn,
+                    timeoutMs: TEST_RUN_BRIDGE_STABILITY_WAIT_MS,
+                });
+                if (bridgeDisconnected) {
+                    return await crashWatch.promise;
+                }
                 await hooks.drain();
                 return result;
             }
+            catch (error) {
+                if (isBridgeDisconnectError(error)) {
+                    const result = await crashWatch.promise;
+                    await hooks.drain();
+                    return result;
+                }
+                throw error;
+            }
             finally {
                 crashWatch.cancel();
             }
@@ -494,6 +583,12 @@ export const createHarnessSession = async (globalConfig, { lockManager = default
         return {
             config: runtimeConfig,
             context,
+            onTestRunnerEvent: (listener) => {
+                testRunnerEventListeners.add(listener);
+                return () => {
+                    testRunnerEventListeners.delete(listener);
+                };
+            },
             runTestFile,
             ensureAppReady,
             restartApp,

package/dist/index.d.ts

@@ -1,8 +1,12 @@
-import type { CallbackTestRunnerInterface, Config, OnTestFailure, OnTestStart, OnTestSuccess, Test, TestRunnerOptions, TestWatcher } from 'jest-runner';
-export default class JestHarness implements CallbackTestRunnerInterface {
+import type { Config, EmittingTestRunnerInterface, Test, TestEvents, TestRunnerOptions, TestWatcher } from 'jest-runner';
+type TestEventListener<Name extends keyof TestEvents> = (eventData: TestEvents[Name]) => void | Promise<void>;
+export default class JestHarness implements EmittingTestRunnerInterface {
     #private;
     readonly isSerial = true;
+    readonly supportsEventEmitters: true;
     constructor(globalConfig: Config.GlobalConfig);
-    runTests(tests: Array<Test>, watcher: TestWatcher, onStart: OnTestStart, onResult: OnTestSuccess, onFailure: OnTestFailure, options: TestRunnerOptions): Promise<void>;
+    on<Name extends keyof TestEvents>(eventName: Name, listener: TestEventListener<Name>): () => void;
+    runTests(tests: Array<Test>, watcher: TestWatcher, options: TestRunnerOptions): Promise<void>;
 }
+export {};
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,2BAA2B,EAC3B,MAAM,EACN,aAAa,EACb,WAAW,EACX,aAAa,EACb,IAAI,EACJ,iBAAiB,EACjB,WAAW,EACZ,MAAM,aAAa,CAAC;AAMrB,MAAM,CAAC,OAAO,OAAO,WAAY,YAAW,2BAA2B;;IACrE,QAAQ,CAAC,QAAQ,QAAQ;gBAKb,YAAY,EAAE,MAAM,CAAC,YAAY;IAIvC,QAAQ,CACZ,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,EAClB,OAAO,EAAE,WAAW,EACpB,OAAO,EAAE,WAAW,EACpB,QAAQ,EAAE,aAAa,EACvB,SAAS,EAAE,aAAa,EACxB,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,IAAI,CAAC;CAiCjB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,MAAM,EACN,2BAA2B,EAC3B,IAAI,EACJ,UAAU,EACV,iBAAiB,EACjB,WAAW,EACZ,MAAM,aAAa,CAAC;AAMrB,KAAK,iBAAiB,CAAC,IAAI,SAAS,MAAM,UAAU,IAAI,CACtD,SAAS,EAAE,UAAU,CAAC,IAAI,CAAC,KACxB,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAE1B,MAAM,CAAC,OAAO,OAAO,WAAY,YAAW,2BAA2B;;IACrE,QAAQ,CAAC,QAAQ,QAAQ;IACzB,QAAQ,CAAC,qBAAqB,EAAG,IAAI,CAAU;gBAMnC,YAAY,EAAE,MAAM,CAAC,YAAY;IAI7C,EAAE,CAAC,IAAI,SAAS,MAAM,UAAU,EAC9B,SAAS,EAAE,IAAI,EACf,QAAQ,EAAE,iBAAiB,CAAC,IAAI,CAAC,GAChC,MAAM,IAAI;IAaP,QAAQ,CACZ,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,EAClB,OAAO,EAAE,WAAW,EACpB,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,IAAI,CAAC;CA6CjB"}

package/dist/index.js

@@ -4,12 +4,25 @@ import { HarnessError } from '@react-native-harness/tools';
 import { getErrorMessage } from './logs.js';
 export default class JestHarness {
     isSerial = true;
+    supportsEventEmitters = true;
     #globalConfig;
     #session = null;
+    #listeners = new Map();
     constructor(globalConfig) {
         this.#globalConfig = globalConfig;
     }
-    async runTests(tests, watcher, onStart, onResult, onFailure, options) {
+    on(eventName, listener) {
+        const listeners = this.#listeners.get(eventName) ?? new Set();
+        listeners.add(listener);
+        this.#listeners.set(eventName, listeners);
+        return () => {
+            listeners.delete(listener);
+            if (listeners.size === 0) {
+                this.#listeners.delete(eventName);
+            }
+        };
+    }
+    async runTests(tests, watcher, options) {
         if (!options.serial) {
             throw new Error('Parallel test running is not supported');
         }
@@ -18,7 +31,7 @@ export default class JestHarness {
             if (!this.#session) {
                 this.#session = await createHarnessSession(this.#globalConfig);
             }
-            await executeRun(this.#session, tests, watcher, onStart, onResult, onFailure, this.#globalConfig);
+            await executeRun(this.#session, tests, watcher, this.#emit, this.#globalConfig);
         }
         catch (error) {
             if (error instanceof HarnessError) {
@@ -33,4 +46,13 @@ export default class JestHarness {
             }
         }
     }
+    #emit = async (eventName, ...eventData) => {
+        const listeners = this.#listeners.get(eventName);
+        if (!listeners) {
+            return;
+        }
+        for (const listener of listeners) {
+            await listener(eventData);
+        }
+    };
 }

package/dist/run.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../src/run.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,EAAE,UAAU,IAAI,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACjE,OAAO,KAAK,EACV,eAAe,IAAI,sBAAsB,EAE1C,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAuD3D,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,EAAE;IACzC,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,cAAc,CAAC;IACxB,aAAa,EAAE,UAAU,CAAC,aAAa,CAAC;IACxC,YAAY,EAAE,UAAU,CAAC,YAAY,CAAC;CACvC,KAAK,OAAO,CAAC;IACZ,UAAU,EAAE,cAAc,CAAC;IAC3B,aAAa,EAAE,sBAAsB,CAAC;IACtC,gBAAgB,EAAE,MAAM,CAAC;IACzB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC,CAAC;AAEH,eAAO,MAAM,kBAAkB,EAAE,kBAkFhC,CAAC"}
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../src/run.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,EAAE,UAAU,IAAI,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACjE,OAAO,KAAK,EACV,eAAe,IAAI,sBAAsB,EAE1C,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAuD3D,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,EAAE;IACzC,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,cAAc,CAAC;IACxB,aAAa,EAAE,UAAU,CAAC,aAAa,CAAC;IACxC,YAAY,EAAE,UAAU,CAAC,YAAY,CAAC;CACvC,KAAK,OAAO,CAAC;IACZ,UAAU,EAAE,cAAc,CAAC;IAC3B,aAAa,EAAE,sBAAsB,CAAC;IACtC,gBAAgB,EAAE,MAAM,CAAC;IACzB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC,CAAC;AAEH,eAAO,MAAM,kBAAkB,EAAE,kBAmFhC,CAAC"}

package/dist/run.js

@@ -67,6 +67,7 @@ export const runHarnessTestFile = async ({ testPath, globalConfig, projectConfig
                 ? `${errorMessage}${codeFrame ? `\n\n${codeFrame.content}` : ''}`
                 : undefined,
             title: test.name,
+            fullName: test.fullName,
             status: test.status,
             location: codeFrame?.location
                 ? { column: codeFrame.location.column, line: codeFrame.location.row }

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

@@ -0,0 +1,5 @@
+import type { TestResult as JestTestResult } from '@jest/test-result';
+export declare const getHarnessTestFilePlatform: (testPath: string, knownPlatformIds: ReadonlySet<string>) => string | null;
+export declare const shouldRunHarnessTestFile: (testPath: string, platformId: string, knownPlatformIds: ReadonlySet<string>) => boolean;
+export declare const createPlatformSkippedTestResult: (testPath: string) => JestTestResult;
+//# sourceMappingURL=test-file-platform-filter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"test-file-platform-filter.d.ts","sourceRoot":"","sources":["../src/test-file-platform-filter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,IAAI,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAMtE,eAAO,MAAM,0BAA0B,GACrC,UAAU,MAAM,EAChB,kBAAkB,WAAW,CAAC,MAAM,CAAC,KACpC,MAAM,GAAG,IAQX,CAAC;AAEF,eAAO,MAAM,wBAAwB,GACnC,UAAU,MAAM,EAChB,YAAY,MAAM,EAClB,kBAAkB,WAAW,CAAC,MAAM,CAAC,KACpC,OAGF,CAAC;AAEF,eAAO,MAAM,+BAA+B,GAC1C,UAAU,MAAM,KACf,cAyBF,CAAC"}

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

@@ -0,0 +1,40 @@
+import path from 'node:path';
+import { toTestResult } from './toTestResult.js';
+const PLATFORM_SPECIFIC_HARNESS_FILE = /\.([^.]+)\.harness\.(?:[mc]?[jt]sx?)$/;
+export const getHarnessTestFilePlatform = (testPath, knownPlatformIds) => {
+    const match = path.basename(testPath).match(PLATFORM_SPECIFIC_HARNESS_FILE);
+    if (!match) {
+        return null;
+    }
+    const candidate = match[1];
+    return knownPlatformIds.has(candidate) ? candidate : null;
+};
+export const shouldRunHarnessTestFile = (testPath, platformId, knownPlatformIds) => {
+    const filePlatform = getHarnessTestFilePlatform(testPath, knownPlatformIds);
+    return filePlatform == null || filePlatform === platformId;
+};
+export const createPlatformSkippedTestResult = (testPath) => {
+    const now = Date.now();
+    const title = path.basename(testPath);
+    return toTestResult({
+        stats: {
+            failures: 0,
+            passes: 0,
+            pending: 1,
+            todo: 0,
+            start: now,
+            end: now,
+        },
+        skipped: true,
+        errorMessage: null,
+        tests: [
+            {
+                status: 'skipped',
+                title,
+                fullName: title,
+                testPath,
+            },
+        ],
+        jestTestPath: testPath,
+    });
+};

package/dist/toTestResult.d.ts

@@ -15,6 +15,7 @@ export type Options = {
         errorMessage?: string;
         testPath?: string;
         title?: string;
+        fullName?: string;
         status: Status;
         location?: {
             column: number;

package/dist/toTestResult.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toTestResult.d.ts","sourceRoot":"","sources":["../src/toTestResult.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAE5D,MAAM,MAAM,OAAO,GAAG;IACpB,KAAK,EAAE;QACL,QAAQ,EAAE,MAAM,CAAC;QACjB,MAAM,EAAE,MAAM,CAAC;QACf,OAAO,EAAE,MAAM,CAAC;QAChB,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;QACd,GAAG,EAAE,MAAM,CAAC;KACb,CAAC;IACF,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,KAAK,EAAE,KAAK,CAAC;QACX,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QACzB,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,MAAM,EAAE,MAAM,CAAC;QACf,QAAQ,CAAC,EAAE;YACT,MAAM,EAAE,MAAM,CAAC;YACf,IAAI,EAAE,MAAM,CAAC;SACd,CAAC;QACF,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;KAC3B,CAAC,CAAC;IACH,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,UAAU,CAAC,UAAU,CAAC,CAAC;CACnC,CAAC;AAwDF,eAAO,MAAM,YAAY,GAAI,SAAS,OAAO,KAAG,UAiB/C,CAAC"}
+{"version":3,"file":"toTestResult.d.ts","sourceRoot":"","sources":["../src/toTestResult.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAE5D,MAAM,MAAM,OAAO,GAAG;IACpB,KAAK,EAAE;QACL,QAAQ,EAAE,MAAM,CAAC;QACjB,MAAM,EAAE,MAAM,CAAC;QACf,OAAO,EAAE,MAAM,CAAC;QAChB,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;QACd,GAAG,EAAE,MAAM,CAAC;KACb,CAAC;IACF,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,KAAK,EAAE,KAAK,CAAC;QACX,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QACzB,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,MAAM,EAAE,MAAM,CAAC;QACf,QAAQ,CAAC,EAAE;YACT,MAAM,EAAE,MAAM,CAAC;YACf,IAAI,EAAE,MAAM,CAAC;SACd,CAAC;QACF,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;KAC3B,CAAC,CAAC;IACH,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,UAAU,CAAC,UAAU,CAAC,CAAC;CACnC,CAAC;AAwDF,eAAO,MAAM,YAAY,GAAI,SAAS,OAAO,KAAG,UAiB/C,CAAC"}

package/dist/toTestResult.js

@@ -36,8 +36,8 @@ const getTestResults = ({ errorMessage, tests, jestTestPath, }) => {
             duration: test.duration,
             failureDetails: [],
             failureMessages: actualErrorMessage ? [actualErrorMessage] : [],
-            fullName: jestTestPath || test.testPath || '',
-            numPassingAsserts: test.errorMessage ? 1 : 0,
+            fullName: test.fullName || test.testPath || jestTestPath || '',
+            numPassingAsserts: test.status === 'passed' ? 1 : 0,
             status: test.status,
             title: test.title || '',
             location: test.location,