@react-native-harness/jest 1.1.0-rc.1 → 1.1.0-rc.2

package/dist/index.js

@@ -5,7 +5,23 @@ import { teardown } from './teardown.js';
 import { HarnessError } from '@react-native-harness/tools';
 import { getErrorMessage } from './logs.js';
 import { DeviceNotRespondingError } from '@react-native-harness/bridge/server';
-import { NativeCrashError } from './errors.js';
+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);
@@ -44,64 +60,195 @@ export default class JestHarness {
     async _createInBandTestRun(tests, watcher, harness, harnessConfig, onStart, onResult, onFailure) {
         const mutex = pLimit(1);
         let isFirstTest = true;
-        return tests.reduce((promise, test) => mutex(() => promise
-            .then(async () => {
-            if (watcher.isInterrupted()) {
-                throw new CancelRun();
-            }
-            if (harnessConfig.resetEnvironmentBetweenTestFiles &&
-                !isFirstTest) {
-                await harness.restart(test.path);
-            }
-            isFirstTest = false;
-            return onStart(test).then(async () => {
-                if (!harnessConfig.detectNativeCrashes) {
-                    await harness.ensureAppReady(test.path);
-                    return runHarnessTestFile({
-                        testPath: test.path,
-                        harness,
-                        globalConfig: this.#globalConfig,
-                        projectConfig: test.context.config,
+        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,
                     });
-                }
-                await harness.ensureAppReady(test.path);
-                harness.crashSupervisor.beginTestRun(test.path);
-                const crashPromise = harness.crashSupervisor.waitForCrash(test.path);
-                try {
-                    const result = await Promise.race([
-                        runHarnessTestFile({
-                            testPath: test.path,
-                            harness,
-                            globalConfig: this.#globalConfig,
-                            projectConfig: test.context.config,
-                        }),
-                        crashPromise,
-                    ]);
-                    return result;
-                }
-                finally {
-                    harness.crashSupervisor.cancelCrashWaiters();
-                }
-            });
-        })
-            .then((result) => onResult(test, result))
-            .catch(async (err) => {
-            if (err instanceof NativeCrashError) {
-                harness.crashSupervisor.reset();
-                onFailure(test, {
-                    message: err.message,
-                    stack: '',
+                    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);
                 });
-                return;
-            }
-            if (err instanceof DeviceNotRespondingError) {
-                onFailure(test, {
-                    message: err.message,
-                    stack: '',
-                });
-                return;
-            }
-            onFailure(test, err);
-        })), Promise.resolve());
+            }), 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;
+        }
     }
 }

package/dist/logs.d.ts

@@ -4,5 +4,6 @@ export declare const log: (message: string) => void;
 export declare const logTestRunHeader: (runner: HarnessPlatform) => void;
 export declare const logTestEnvironmentReady: (runner: HarnessPlatform) => void;
 export declare const logMetroPrewarmCompleted: (runner: HarnessPlatform) => void;
+export declare const logMetroCacheReused: (runner: HarnessPlatform) => 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,wBAAwB,GAAI,QAAQ,eAAe,KAAG,IAIlE,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,wBAAwB,GAAI,QAAQ,eAAe,KAAG,IAIlE,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,QAAQ,eAAe,KAAG,IAE7D,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,OAAO,YAAY,KAAG,MAErD,CAAC"}

package/dist/logs.js

@@ -18,6 +18,9 @@ export const logTestEnvironmentReady = (runner) => {
 export const logMetroPrewarmCompleted = (runner) => {
     log(`${TAG} Metro pre-warm for ${chalk.bold(runner.name)} completed\n`);
 };
+export const logMetroCacheReused = (runner) => {
+    log(`${TAG} Reusing Metro cache for ${chalk.bold(runner.name)}\n`);
+};
 export const getErrorMessage = (error) => {
     return `${ERROR_TAG} ${error.message}\n`;
 };

package/dist/run.d.ts

@@ -1,11 +1,17 @@
 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';
 export type RunHarnessTestFile = (options: {
     testPath: string;
     harness: Harness;
     projectConfig: JestConfig.ProjectConfig;
     globalConfig: JestConfig.GlobalConfig;
-}) => Promise<JestTestResult>;
+}) => Promise<{
+    jestResult: JestTestResult;
+    harnessResult: HarnessTestSuiteResult;
+    relativeTestPath: string;
+    duration: number;
+}>;
 export declare const runHarnessTestFile: RunHarnessTestFile;
 //# sourceMappingURL=run.d.ts.map

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;AAKjE,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,cAAc,CAAC,CAAC;AAE9B,eAAO,MAAM,kBAAkB,EAAE,kBA6EhC,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,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"}

package/dist/run.js

@@ -48,14 +48,14 @@ export const runHarnessTestFile = async ({ testPath, globalConfig, projectConfig
     // 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 results = await harness.runTests(relativeTestPath, {
+    const harnessResult = await harness.runTests(relativeTestPath, {
         testNamePattern: globalConfig.testNamePattern,
         setupFiles,
         setupFilesAfterEnv,
         runner: harness.context.platform.runner,
     });
     const end = Date.now();
-    const allTests = flattenTests(results);
+    const allTests = flattenTests(harnessResult);
     const stats = calculateStats(allTests);
     // Convert TestResult[] to the format expected by toTestResult
     const tests = allTests.map((test) => {
@@ -75,10 +75,10 @@ export const runHarnessTestFile = async ({ testPath, globalConfig, projectConfig
         };
     });
     // Check if the entire suite was skipped
-    const skipped = results.status === 'skipped';
+    const skipped = harnessResult.status === 'skipped';
     // Get error message from suite if it failed
-    const errorMessage = results.error?.message || null;
-    const totalResults = toTestResult({
+    const errorMessage = harnessResult.error?.message || null;
+    const jestResult = toTestResult({
         stats: {
             failures: stats.failures,
             pending: stats.pending,
@@ -91,8 +91,13 @@ export const runHarnessTestFile = async ({ testPath, globalConfig, projectConfig
         errorMessage,
         tests,
         jestTestPath: testPath,
-        coverage: results.coverage,
+        coverage: harnessResult.coverage,
     });
-    totalResults.failureMessage = formatResultsErrors(totalResults.testResults, projectConfig, globalConfig, testPath);
-    return totalResults;
+    jestResult.failureMessage = formatResultsErrors(jestResult.testResults, projectConfig, globalConfig, testPath);
+    return {
+        jestResult,
+        harnessResult,
+        relativeTestPath,
+        duration: end - start,
+    };
 };

package/dist/setup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../src/setup.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,aAAa,CAAC;AAqCxD,eAAO,MAAM,KAAK,GAAU,cAAc,UAAU,CAAC,YAAY,kBA4ChE,CAAC"}
+{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../src/setup.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,aAAa,CAAC;AA2CxD,eAAO,MAAM,KAAK,GAAU,cAAc,UAAU,CAAC,YAAY,kBA0DhE,CAAC"}

package/dist/setup.js

@@ -1,12 +1,16 @@
-import { getConfig, } from '@react-native-harness/config';
+import { getConfig, ConfigSchema, } from '@react-native-harness/config';
 import { getHarness } from './harness.js';
 import { preRunMessage } from 'jest-util';
 import { getAdditionalCliArgs } from './cli-args.js';
 import { logTestEnvironmentReady, logTestRunHeader } from './logs.js';
 import { NoRunnerSpecifiedError, RunnerNotFoundError } from './errors.js';
+import { logger } from '@react-native-harness/tools';
+const setupLogger = logger.child('setup');
 const getHarnessConfig = async (globalConfig) => {
     const projectRoot = globalConfig.rootDir;
+    setupLogger.debug('loading Harness config from %s', projectRoot);
     const { config: harnessConfig } = await getConfig(projectRoot);
+    setupLogger.debug('loaded Harness config');
     return harnessConfig;
 };
 const getHarnessRunner = (config, cliArgs) => {
@@ -18,11 +22,12 @@ const getHarnessRunner = (config, cliArgs) => {
     if (!runner) {
         throw new RunnerNotFoundError(selectedRunnerName);
     }
+    setupLogger.debug('selected runner %s (%s)', runner.name, runner.platformId);
     return runner;
 };
 export const setup = async (globalConfig) => {
     preRunMessage.remove(process.stderr);
-    const harnessConfig = global.HARNESS_CONFIG ?? (await getHarnessConfig(globalConfig));
+    let harnessConfig = global.HARNESS_CONFIG ?? (await getHarnessConfig(globalConfig));
     if (global.HARNESS) {
         // Do not setup again if HARNESS is already initialized
         // This is useful when running tests in watch mode
@@ -33,6 +38,13 @@ export const setup = async (globalConfig) => {
         await global.HARNESS.dispose();
     });
     const cliArgs = getAdditionalCliArgs();
+    if (cliArgs.metroPort != null) {
+        setupLogger.debug('applying CLI metro port override: %d', cliArgs.metroPort);
+        harnessConfig = ConfigSchema.parse({
+            ...harnessConfig,
+            metroPort: cliArgs.metroPort,
+        });
+    }
     const selectedRunner = getHarnessRunner(harnessConfig, cliArgs);
     if (globalConfig.collectCoverage) {
         // This is going to be used by @react-native-harness/babel-preset
@@ -41,13 +53,17 @@ export const setup = async (globalConfig) => {
         if (harnessConfig.coverage?.root) {
             process.env.RN_HARNESS_COVERAGE_ROOT = harnessConfig.coverage.root;
         }
+        setupLogger.debug('coverage enabled for this run');
     }
     if (harnessConfig.disableViewFlattening) {
         process.env.RN_HARNESS_VIEW_FLATTENING = 'false';
+        setupLogger.debug('view flattening disabled for runtime');
     }
     logTestRunHeader(selectedRunner);
+    setupLogger.debug('creating Harness instance');
     const harness = await getHarness(harnessConfig, selectedRunner, globalConfig.rootDir);
     logTestEnvironmentReady(selectedRunner);
+    setupLogger.debug('Harness instance is ready');
     global.HARNESS_CONFIG = harnessConfig;
     global.HARNESS = harness;
 };