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

package/dist/index.js

@@ -1,36 +1,11 @@
-import pLimit from 'p-limit';
-import { runHarnessTestFile } from './run.js';
-import { setup } from './setup.js';
-import { teardown } from './teardown.js';
+import { createHarnessSession } from './harness-session.js';
+import { executeRun } from './execute-run.js';
 import { HarnessError } from '@react-native-harness/tools';
 import { getErrorMessage } from './logs.js';
-import { DeviceNotRespondingError } from '@react-native-harness/bridge/server';
-import { NativeCrashError, StartupStallError } from './errors.js';
-import { logger } from '@react-native-harness/tools';
-import { randomUUID } from 'node:crypto';
-import path from 'node:path';
-const runLogger = logger.child('run');
-const createRunSummary = () => ({
-    passed: 0,
-    failed: 0,
-    skipped: 0,
-    todo: 0,
-});
-const applyJestResultToSummary = (summary, result) => {
-    summary.passed += result.numPassingTests;
-    summary.failed += result.numFailingTests;
-    summary.skipped += result.numPendingTests;
-    summary.todo += result.numTodoTests;
-};
-class CancelRun extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'CancelRun';
-    }
-}
 export default class JestHarness {
     isSerial = true;
     #globalConfig;
+    #session = null;
     constructor(globalConfig) {
         this.#globalConfig = globalConfig;
     }
@@ -38,217 +13,24 @@ export default class JestHarness {
         if (!options.serial) {
             throw new Error('Parallel test running is not supported');
         }
+        const isWatchMode = this.#globalConfig.watch || this.#globalConfig.watchAll;
         try {
-            // This is necessary as Harness may throw and we want to catch it and display a helpful error message.
-            await setup(this.#globalConfig);
-            const harness = global.HARNESS;
-            const harnessConfig = global.HARNESS_CONFIG;
-            return await this._createInBandTestRun(tests, watcher, harness, harnessConfig, onStart, onResult, onFailure);
+            if (!this.#session) {
+                this.#session = await createHarnessSession(this.#globalConfig);
+            }
+            await executeRun(this.#session, tests, watcher, onStart, onResult, onFailure, this.#globalConfig);
         }
         catch (error) {
             if (error instanceof HarnessError) {
-                // Jest will print strings as they are, without processing them further.
                 throw getErrorMessage(error);
             }
             throw error;
         }
         finally {
-            // This is necessary as Harness may throw and we want to catch it and display a helpful error message.
-            await teardown(this.#globalConfig);
-        }
-    }
-    async _createInBandTestRun(tests, watcher, harness, harnessConfig, onStart, onResult, onFailure) {
-        const mutex = pLimit(1);
-        let isFirstTest = true;
-        const startTime = Date.now();
-        const runId = randomUUID();
-        const watchMode = this.#globalConfig.watch || this.#globalConfig.watchAll;
-        const rootDir = this.#globalConfig.rootDir ?? process.cwd();
-        const testFiles = tests.map((test) => path.relative(rootDir, test.path));
-        const summary = createRunSummary();
-        const updateRunState = (overrides = {}) => {
-            const nextRunState = {
-                runId,
-                startTime,
-                testFiles,
-                watchMode,
-                coverageEnabled: this.#globalConfig.collectCoverage,
-                summary,
-                status: summary.failed > 0 ? 'failed' : 'passed',
-                ...overrides,
-            };
-            harness.setRunState(nextRunState);
-            return nextRunState;
-        };
-        updateRunState();
-        runLogger.debug('run started: runId=%s files=%d watchMode=%s coverage=%s', runId, testFiles.length, watchMode, this.#globalConfig.collectCoverage);
-        await harness.callHook('run:started', {
-            runId,
-            startTime,
-            testFiles,
-            watchMode,
-            coverageEnabled: this.#globalConfig.collectCoverage,
-        });
-        await harness.callHook('metro:initialized', {
-            runId,
-            port: harnessConfig.metroPort,
-            host: harnessConfig.host?.trim() || undefined,
-        });
-        try {
-            await tests.reduce((promise, test) => mutex(() => {
-                let didApplySummary = false;
-                return promise
-                    .then(async () => {
-                    const relativeTestPath = path.relative(rootDir, test.path);
-                    const testFileStartedAt = Date.now();
-                    let didEmitTestFileFinished = false;
-                    await harness.callHook('test-file:started', {
-                        runId,
-                        file: relativeTestPath,
-                    });
-                    runLogger.debug('test file started: %s', relativeTestPath);
-                    const emitTestFileFinished = async (options) => {
-                        didEmitTestFileFinished = true;
-                        runLogger.debug('test file finished: %s status=%s duration=%dms', relativeTestPath, options.status, options.duration);
-                        await harness.callHook('test-file:finished', {
-                            runId,
-                            file: relativeTestPath,
-                            duration: options.duration,
-                            status: options.status,
-                            result: options.result,
-                        });
-                    };
-                    try {
-                        if (watcher.isInterrupted()) {
-                            throw new CancelRun();
-                        }
-                        if (harnessConfig.resetEnvironmentBetweenTestFiles &&
-                            !isFirstTest) {
-                            runLogger.debug('resetting environment before %s', relativeTestPath);
-                            await harness.restart(test.path);
-                        }
-                        isFirstTest = false;
-                        const result = await onStart(test).then(async () => {
-                            if (!harnessConfig.detectNativeCrashes) {
-                                runLogger.debug('native crash detection disabled for %s', relativeTestPath);
-                                await harness.ensureAppReady(test.path);
-                                return runHarnessTestFile({
-                                    testPath: test.path,
-                                    harness,
-                                    globalConfig: this.#globalConfig,
-                                    projectConfig: test.context.config,
-                                });
-                            }
-                            await harness.ensureAppReady(test.path);
-                            harness.crashSupervisor.beginTestRun(test.path);
-                            runLogger.debug('native crash detection armed for %s', relativeTestPath);
-                            const crashPromise = harness.crashSupervisor.waitForCrash(test.path);
-                            try {
-                                return await Promise.race([
-                                    runHarnessTestFile({
-                                        testPath: test.path,
-                                        harness,
-                                        globalConfig: this.#globalConfig,
-                                        projectConfig: test.context.config,
-                                    }),
-                                    crashPromise,
-                                ]);
-                            }
-                            finally {
-                                harness.crashSupervisor.cancelCrashWaiters();
-                            }
-                        });
-                        applyJestResultToSummary(summary, result.jestResult);
-                        didApplySummary = true;
-                        updateRunState();
-                        await emitTestFileFinished({
-                            status: result.harnessResult.status,
-                            duration: result.duration,
-                            result: result.harnessResult,
-                        });
-                        return result;
-                    }
-                    catch (error) {
-                        if (!didEmitTestFileFinished) {
-                            await emitTestFileFinished({
-                                status: 'failed',
-                                duration: Date.now() - testFileStartedAt,
-                                result: null,
-                            });
-                        }
-                        throw error;
-                    }
-                })
-                    .then(async (result) => {
-                    if (!result) {
-                        return;
-                    }
-                    await onResult(test, result.jestResult);
-                })
-                    .catch(async (err) => {
-                    if (err instanceof NativeCrashError ||
-                        err instanceof StartupStallError ||
-                        err instanceof DeviceNotRespondingError) {
-                        runLogger.debug('classified runtime failure for %s: %s', test.path, err.name);
-                        summary.failed += 1;
-                        updateRunState();
-                    }
-                    if (err instanceof NativeCrashError) {
-                        harness.crashSupervisor.reset();
-                        onFailure(test, {
-                            message: err.message,
-                            stack: '',
-                        });
-                        return;
-                    }
-                    if (err instanceof StartupStallError) {
-                        onFailure(test, {
-                            message: err.message,
-                            stack: '',
-                        });
-                        return;
-                    }
-                    if (err instanceof DeviceNotRespondingError) {
-                        onFailure(test, {
-                            message: err.message,
-                            stack: '',
-                        });
-                        return;
-                    }
-                    if (!(err instanceof CancelRun) && !didApplySummary) {
-                        summary.failed += 1;
-                    }
-                    updateRunState({ error: err });
-                    onFailure(test, err);
-                });
-            }), Promise.resolve());
-            const runState = updateRunState();
-            runLogger.debug('run finished: runId=%s status=%s duration=%dms', runId, runState.status ?? 'passed', Date.now() - startTime);
-            await harness.callHook('run:finished', {
-                runId,
-                startTime,
-                duration: Date.now() - startTime,
-                testFiles,
-                summary,
-                status: runState.status ?? 'passed',
-            });
-        }
-        catch (error) {
-            const runState = updateRunState({
-                error,
-                status: 'failed',
-            });
-            runLogger.debug('run failed: runId=%s status=%s', runId, runState.status ?? 'failed');
-            await harness.callHook('run:finished', {
-                runId,
-                startTime,
-                duration: Date.now() - startTime,
-                testFiles,
-                summary,
-                status: runState.status ?? 'failed',
-                error,
-            });
-            throw error;
+            if (!isWatchMode) {
+                await this.#session?.dispose();
+                this.#session = null;
+            }
         }
     }
 }

package/dist/logs.d.ts

@@ -9,5 +9,6 @@ export declare const logRunnerStarting: (runner: HarnessPlatform) => void;
 export declare const logMetroPrewarmCompleted: (runner: HarnessPlatform) => void;
 export declare const logMetroCacheReused: (runner: HarnessPlatform) => void;
 export declare const logMetroPortFallback: (initialPort: number, selectedPort: number) => void;
+export declare const logNativeCoverageCollected: (lcovPath: string) => void;
 export declare const getErrorMessage: (error: HarnessError) => string;
 //# sourceMappingURL=logs.d.ts.map

package/dist/logs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logs.d.ts","sourceRoot":"","sources":["../src/logs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAClE,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAY3D,eAAO,MAAM,GAAG,GAAI,SAAS,MAAM,KAAG,IAErC,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,QAAQ,eAAe,KAAG,IAI1D,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAI,QAAQ,eAAe,KAAG,IAEjE,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAI,QAAQ,eAAe,KAAG,IAEjE,CAAC;AAEF,eAAO,MAAM,4BAA4B,GAAI,QAAQ,eAAe,KAAG,IAEtE,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,QAAQ,eAAe,KAAG,IAE3D,CAAC;AAEF,eAAO,MAAM,wBAAwB,GAAI,QAAQ,eAAe,KAAG,IAElE,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,QAAQ,eAAe,KAAG,IAE7D,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,aAAa,MAAM,EACnB,cAAc,MAAM,KACnB,IAMF,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,OAAO,YAAY,KAAG,MAErD,CAAC"}
+{"version":3,"file":"logs.d.ts","sourceRoot":"","sources":["../src/logs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAClE,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAY3D,eAAO,MAAM,GAAG,GAAI,SAAS,MAAM,KAAG,IAErC,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,QAAQ,eAAe,KAAG,IAI1D,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAI,QAAQ,eAAe,KAAG,IAEjE,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAI,QAAQ,eAAe,KAAG,IAEjE,CAAC;AAEF,eAAO,MAAM,4BAA4B,GAAI,QAAQ,eAAe,KAAG,IAEtE,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,QAAQ,eAAe,KAAG,IAE3D,CAAC;AAEF,eAAO,MAAM,wBAAwB,GAAI,QAAQ,eAAe,KAAG,IAElE,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,QAAQ,eAAe,KAAG,IAE7D,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,aAAa,MAAM,EACnB,cAAc,MAAM,KACnB,IAMF,CAAC;AAEF,eAAO,MAAM,0BAA0B,GAAI,UAAU,MAAM,KAAG,IAE7D,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,OAAO,YAAY,KAAG,MAErD,CAAC"}

package/dist/logs.js

@@ -33,6 +33,9 @@ export const logMetroCacheReused = (runner) => {
 export const logMetroPortFallback = (initialPort, selectedPort) => {
     log(`${TAG} Harness could not use Metro port ${chalk.bold(String(initialPort))} and is using ${chalk.bold(String(selectedPort))} instead.\n`);
 };
+export const logNativeCoverageCollected = (lcovPath) => {
+    log(`${TAG} Native coverage written to ${chalk.bold(lcovPath)}\n`);
+};
 export const getErrorMessage = (error) => {
     return `${ERROR_TAG} ${error.message}\n`;
 };

package/dist/resource-lock.d.ts

@@ -19,7 +19,6 @@ type ResourceLockManagerOptions = {
     logger?: HarnessLogger;
     isProcessActive?: (pid: number) => boolean;
 };
-export declare const hashResourceLockKey: (key: string) => string;
 export declare const createResourceLockManager: (options?: ResourceLockManagerOptions) => ResourceLockManager;
 export {};
 //# sourceMappingURL=resource-lock.d.ts.map

package/dist/resource-lock.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resource-lock.d.ts","sourceRoot":"","sources":["../src/resource-lock.ts"],"names":[],"mappings":"AAIA,OAAO,EAAU,KAAK,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAiBzE,MAAM,MAAM,0BAA0B,GAAG;IACvC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;IACpB,cAAc,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;CAC9C,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,OAAO,EAAE,CACP,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,0BAA0B,KACjC,OAAO,CAAC,aAAa,CAAC,CAAC;CAC7B,CAAC;AAEF,KAAK,0BAA0B,GAAG;IAChC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,aAAa,CAAC;IACvB,eAAe,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;CAC5C,CAAC;AAgBF,eAAO,MAAM,mBAAmB,GAAI,KAAK,MAAM,KAAG,MAEjD,CAAC;AAmPF,eAAO,MAAM,yBAAyB,GACpC,UAAS,0BAA+B,KACvC,mBAkKF,CAAC"}
+{"version":3,"file":"resource-lock.d.ts","sourceRoot":"","sources":["../src/resource-lock.ts"],"names":[],"mappings":"AAIA,OAAO,EAAU,KAAK,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAiBzE,MAAM,MAAM,0BAA0B,GAAG;IACvC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;IACpB,cAAc,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;CAC9C,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,OAAO,EAAE,CACP,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,0BAA0B,KACjC,OAAO,CAAC,aAAa,CAAC,CAAC;CAC7B,CAAC;AAEF,KAAK,0BAA0B,GAAG;IAChC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,aAAa,CAAC;IACvB,eAAe,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;CAC5C,CAAC;AAqQF,eAAO,MAAM,yBAAyB,GACpC,UAAS,0BAA+B,KACvC,mBAkKF,CAAC"}

package/dist/resource-lock.js

@@ -12,7 +12,7 @@ const wait = async (ms) => {
     await new Promise((resolve) => setTimeout(resolve, ms));
 };
 const createAbortError = () => new DOMException('The operation was aborted', 'AbortError');
-export const hashResourceLockKey = (key) => {
+const hashResourceLockKey = (key) => {
     return crypto.createHash('sha256').update(key).digest('hex');
 };
 const getPathsForKey = (rootDir, key) => {

package/dist/run.d.ts

@@ -1,10 +1,10 @@
 import type { Config as JestConfig } from 'jest-runner';
 import { TestResult as JestTestResult } from '@jest/test-result';
 import type { TestSuiteResult as HarnessTestSuiteResult } from '@react-native-harness/bridge';
-import type { Harness } from './harness.js';
+import type { HarnessSession } from './harness-session.js';
 export type RunHarnessTestFile = (options: {
     testPath: string;
-    harness: Harness;
+    session: HarnessSession;
     projectConfig: JestConfig.ProjectConfig;
     globalConfig: JestConfig.GlobalConfig;
 }) => Promise<{

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,OAAO,EAAE,MAAM,cAAc,CAAC;AAuD5C,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,EAAE;IACzC,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,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,kBAkFhC,CAAC"}

package/dist/run.js

@@ -42,17 +42,17 @@ const calculateStats = (tests) => {
     }
     return { passes, failures, pending, todo };
 };
-export const runHarnessTestFile = async ({ testPath, globalConfig, projectConfig, harness, }) => {
+export const runHarnessTestFile = async ({ testPath, globalConfig, projectConfig, session, }) => {
     const start = Date.now();
     const relativeTestPath = path.relative(globalConfig.rootDir, testPath);
     // Extract setup files from Jest config and convert to relative paths
     const setupFiles = projectConfig.setupFiles?.map((setupFile) => path.relative(globalConfig.rootDir, setupFile));
     const setupFilesAfterEnv = projectConfig.setupFilesAfterEnv?.map((setupFile) => path.relative(globalConfig.rootDir, setupFile));
-    const harnessResult = await harness.runTests(relativeTestPath, {
+    const harnessResult = await session.runTestFile(relativeTestPath, {
         testNamePattern: globalConfig.testNamePattern,
         setupFiles,
         setupFilesAfterEnv,
-        runner: harness.context.platform.runner,
+        runner: session.context.platform.runner,
     });
     const end = Date.now();
     const allTests = flattenTests(harnessResult);