@react-native-harness/jest 1.1.0 → 1.2.0

package/dist/event-mapper.js

@@ -0,0 +1,120 @@
+export const getHarnessEventMapper = (emit) => {
+    const state = {
+        suiteHierarchy: [],
+        testResults: new Map(),
+        fileStartTime: 0,
+    };
+    const handleBridgeEvent = (event, test) => {
+        // Filter to only process test runner events
+        if (event.type.startsWith('test-') ||
+            event.type.startsWith('suite-') ||
+            event.type.startsWith('file-')) {
+            switch (event.type) {
+                case 'file-started':
+                    handleFileStarted(event, test);
+                    break;
+                case 'file-finished':
+                    handleFileFinished(event, test);
+                    break;
+                case 'suite-started':
+                    handleSuiteStarted(event);
+                    break;
+                case 'suite-finished':
+                    handleSuiteFinished(event);
+                    break;
+                case 'test-started':
+                    handleTestStarted(event, test);
+                    break;
+                case 'test-finished':
+                    handleTestFinished(event, test);
+                    break;
+            }
+        }
+    };
+    const handleFileStarted = (event, test) => {
+        state.currentTest = test;
+        state.fileStartTime = Date.now();
+        state.suiteHierarchy = [];
+        state.testResults.clear();
+        // Don't emit test-file-start here - that should be handled by the Jest runner
+        // when it actually starts running the test file
+    };
+    const handleFileFinished = (_event, _test) => {
+        // File finished - all test results should already be emitted
+        // The final TestResult will be handled by the runHarnessTestFile function
+    };
+    const handleSuiteStarted = (event) => {
+        state.suiteHierarchy.push(event.name);
+    };
+    const handleSuiteFinished = (event) => {
+        // Remove the suite from hierarchy when it finishes
+        const index = state.suiteHierarchy.lastIndexOf(event.name);
+        if (index !== -1) {
+            state.suiteHierarchy.splice(index, 1);
+        }
+    };
+    const handleTestStarted = (event, test) => {
+        const testCaseStartInfo = {
+            ancestorTitles: [...state.suiteHierarchy],
+            fullName: `${state.suiteHierarchy.join(' ')} ${event.name}`.trim(),
+            title: event.name,
+            mode: 'skip', // Default mode, will be updated based on test status
+        };
+        emit('test-case-start', [test.path, testCaseStartInfo]);
+    };
+    const handleTestFinished = (event, test) => {
+        const testCaseResult = {
+            ancestorTitles: [...state.suiteHierarchy],
+            duration: event.duration,
+            failureDetails: [],
+            failureMessages: event.error ? [formatError(event.error)] : [],
+            fullName: `${state.suiteHierarchy.join(' ')} ${event.name}`.trim(),
+            numPassingAsserts: event.status === 'passed' ? 1 : 0,
+            status: mapStatus(event.status),
+            title: event.name,
+            startedAt: Date.now() - event.duration,
+        };
+        state.testResults.set(event.name, testCaseResult);
+        emit('test-case-result', [test.path, testCaseResult]);
+    };
+    const mapStatus = (status) => {
+        return status;
+    };
+    const formatError = (error) => {
+        let errorMessage = `${error.name}: ${error.message}`;
+        if (error.codeFrame) {
+            errorMessage += '\n\n' + formatCodeFrame(error.codeFrame);
+        }
+        return errorMessage;
+    };
+    const formatCodeFrame = (codeFrame) => {
+        const lines = codeFrame.content.split('\n');
+        const lineNumber = codeFrame.location?.row || 1;
+        const column = codeFrame.location?.column || 1;
+        let formatted = `\n${codeFrame.fileName}:${lineNumber}:${column}\n`;
+        // Add context lines around the error
+        const startLine = Math.max(0, lineNumber - 3);
+        const endLine = Math.min(lines.length, lineNumber + 2);
+        for (let i = startLine; i < endLine; i++) {
+            const lineNum = i + 1;
+            const line = lines[i];
+            const isErrorLine = lineNum === lineNumber;
+            formatted += `${lineNum.toString().padStart(3)} | ${line}\n`;
+            if (isErrorLine && column > 0) {
+                const pointer = ' '.repeat(column + 5) + '^';
+                formatted += pointer + '\n';
+            }
+        }
+        return formatted;
+    };
+    const reset = () => {
+        state.suiteHierarchy = [];
+        state.testResults.clear();
+        state.fileStartTime = 0;
+        state.currentTest = undefined;
+    };
+    return {
+        handleBridgeEvent,
+        reset,
+    };
+};

package/dist/execute-run.d.ts

@@ -0,0 +1,4 @@
+import type { OnTestFailure, OnTestStart, OnTestSuccess, Test, TestWatcher, Config } from 'jest-runner';
+import { type HarnessSession } from './harness-session.js';
+export declare const executeRun: (session: HarnessSession, tests: Array<Test>, watcher: TestWatcher, onStart: OnTestStart, onResult: OnTestSuccess, onFailure: OnTestFailure, globalConfig: Config.GlobalConfig) => Promise<void>;
+//# sourceMappingURL=execute-run.d.ts.map

package/dist/execute-run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute-run.d.ts","sourceRoot":"","sources":["../src/execute-run.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,WAAW,EACX,aAAa,EACb,IAAI,EACJ,WAAW,EACX,MAAM,EACP,MAAM,aAAa,CAAC;AAGrB,OAAO,EAAE,KAAK,cAAc,EAAwB,MAAM,sBAAsB,CAAC;AAsCjF,eAAO,MAAM,UAAU,GACrB,SAAS,cAAc,EACvB,OAAO,KAAK,CAAC,IAAI,CAAC,EAClB,SAAS,WAAW,EACpB,SAAS,WAAW,EACpB,UAAU,aAAa,EACvB,WAAW,aAAa,EACxB,cAAc,MAAM,CAAC,YAAY,KAChC,OAAO,CAAC,IAAI,CA8Id,CAAC"}

package/dist/execute-run.js

@@ -0,0 +1,151 @@
+import { randomUUID } from 'node:crypto';
+import path from 'node:path';
+import { runHarnessTestFile } from './run.js';
+import { NativeCrashError, StartupStallError, } from './errors.js';
+import { DeviceNotRespondingError } from '@react-native-harness/bridge/server';
+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';
+    }
+}
+const buildTestFailure = (err) => {
+    if (err instanceof NativeCrashError ||
+        err instanceof StartupStallError ||
+        err instanceof DeviceNotRespondingError) {
+        return { message: err.message, stack: '' };
+    }
+    return err;
+};
+export const executeRun = async (session, tests, watcher, onStart, onResult, onFailure, globalConfig) => {
+    const runId = randomUUID();
+    const startTime = Date.now();
+    const watchMode = globalConfig.watch || globalConfig.watchAll;
+    const rootDir = globalConfig.rootDir ?? process.cwd();
+    const testFiles = tests.map((t) => path.relative(rootDir, t.path));
+    const summary = createRunSummary();
+    const updateRunState = (overrides = {}) => {
+        const state = {
+            runId,
+            startTime,
+            testFiles,
+            watchMode,
+            coverageEnabled: globalConfig.collectCoverage,
+            summary,
+            status: summary.failed > 0 ? 'failed' : 'passed',
+            ...overrides,
+        };
+        session.setRunState(state);
+        return state;
+    };
+    updateRunState();
+    await session.callHook('run:started', {
+        runId,
+        startTime,
+        testFiles,
+        watchMode,
+        coverageEnabled: globalConfig.collectCoverage,
+    });
+    await session.callHook('metro:initialized', {
+        runId,
+        port: session.config.metroPort,
+        host: session.config.host?.trim() || undefined,
+    });
+    const shouldResetEnv = session.config.resetEnvironmentBetweenTestFiles;
+    let isFirstTest = true;
+    let runError;
+    try {
+        for (const test of tests) {
+            if (watcher.isInterrupted())
+                throw new CancelRun();
+            const relativeTestPath = path.relative(rootDir, test.path);
+            const fileStartedAt = Date.now();
+            let emittedTestFileFinished = false;
+            const emitTestFileFinished = async (options) => {
+                emittedTestFileFinished = true;
+                await session.callHook('test-file:finished', {
+                    runId,
+                    file: relativeTestPath,
+                    duration: options.duration,
+                    status: options.status,
+                    result: options.result,
+                });
+            };
+            await session.callHook('test-file:started', { runId, file: relativeTestPath });
+            try {
+                if (shouldResetEnv && !isFirstTest) {
+                    await session.restartApp(test.path);
+                }
+                isFirstTest = false;
+                session.flushClientLogs();
+                await onStart(test);
+                await session.ensureAppReady(test.path);
+                // Crash detection is handled inside session.runTestFile; NativeCrashError
+                // propagates here if a crash wins the race.
+                const result = await runHarnessTestFile({
+                    testPath: test.path,
+                    session,
+                    globalConfig,
+                    projectConfig: test.context.config,
+                });
+                applyJestResultToSummary(summary, result.jestResult);
+                const clientLogs = session.flushClientLogs();
+                if (clientLogs.length > 0) {
+                    result.jestResult.console = clientLogs;
+                }
+                updateRunState();
+                await emitTestFileFinished({
+                    status: result.harnessResult.status,
+                    duration: result.duration,
+                    result: result.harnessResult,
+                });
+                await onResult(test, result.jestResult);
+            }
+            catch (err) {
+                if (!emittedTestFileFinished) {
+                    await emitTestFileFinished({
+                        status: 'failed',
+                        duration: Date.now() - fileStartedAt,
+                        result: null,
+                    });
+                }
+                const isRuntimeFailure = err instanceof NativeCrashError ||
+                    err instanceof StartupStallError ||
+                    err instanceof DeviceNotRespondingError;
+                if (isRuntimeFailure) {
+                    summary.failed += 1;
+                    updateRunState();
+                }
+                if (err instanceof NativeCrashError) {
+                    session.resetCrashState();
+                }
+                updateRunState({ error: isRuntimeFailure ? undefined : err });
+                onFailure(test, buildTestFailure(err));
+            }
+        }
+    }
+    catch (err) {
+        runError = err;
+        if (!(err instanceof CancelRun))
+            throw err;
+    }
+    finally {
+        const runState = updateRunState(runError != null ? { error: runError, status: 'failed' } : {});
+        await session.callHook('run:finished', {
+            runId,
+            startTime,
+            duration: Date.now() - startTime,
+            testFiles,
+            summary,
+            status: runState.status ?? (runError != null ? 'failed' : 'passed'),
+            ...(runError != null ? { error: runError } : {}),
+        });
+    }
+};

package/dist/global-setup.d.ts

@@ -0,0 +1,3 @@
+import type { Config as JestConfig } from 'jest-runner';
+export default function (globalConfig: JestConfig.GlobalConfig): Promise<void>;
+//# sourceMappingURL=global-setup.d.ts.map

package/dist/global-setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"global-setup.d.ts","sourceRoot":"","sources":["../src/global-setup.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,aAAa,CAAC;AA4CxD,yBAA+B,YAAY,EAAE,UAAU,CAAC,YAAY,iBA4CnE"}

package/dist/global-setup.js

@@ -0,0 +1,60 @@
+import { getConfig, } from '@react-native-harness/config';
+import { getHarness as getHarnessExternal, NoRunnerSpecifiedError, RunnerNotFoundError, } from '@react-native-harness/cli/external';
+import { preRunMessage } from 'jest-util';
+import { getAdditionalCliArgs } from './cli-args.js';
+import { logTestEnvironmentReady, logTestRunHeader } from './logs.js';
+const getHarnessConfig = async (globalConfig) => {
+    const projectRoot = globalConfig.rootDir;
+    const { config: harnessConfig } = await getConfig(projectRoot);
+    return harnessConfig;
+};
+const getHarnessRunner = (config, cliArgs) => {
+    const selectedRunnerName = cliArgs.harnessRunner ?? config.defaultRunner;
+    if (!selectedRunnerName) {
+        throw new NoRunnerSpecifiedError(config.runners);
+    }
+    const runner = config.runners.find((runner) => runner.name === selectedRunnerName);
+    if (!runner) {
+        throw new RunnerNotFoundError(selectedRunnerName, config.runners);
+    }
+    return runner;
+};
+const getHarness = async (runner) => {
+    return await getHarnessExternal(runner);
+};
+export default async function (globalConfig) {
+    preRunMessage.remove(process.stderr);
+    const harnessConfig = global.HARNESS_CONFIG ?? (await getHarnessConfig(globalConfig));
+    const isWatchMode = globalConfig.watch || globalConfig.watchAll;
+    if (global.HARNESS) {
+        // Do not setup again if HARNESS is already initialized
+        // This is useful when running tests in watch mode
+        if (harnessConfig.resetEnvironmentBetweenTestFiles) {
+            // In watch mode, we want to restart the environment before each test run
+            await new Promise((resolve) => {
+                global.HARNESS.bridge.once('ready', resolve);
+                global.HARNESS.environment.restart();
+            });
+        }
+        return;
+    }
+    if (isWatchMode) {
+        // In watch mode, we want to dispose the Harness when the process exits.
+        process.on('exit', async () => {
+            await global.HARNESS.bridge.dispose();
+            await global.HARNESS.environment.dispose();
+        });
+    }
+    const cliArgs = getAdditionalCliArgs();
+    const selectedRunner = getHarnessRunner(harnessConfig, cliArgs);
+    if (globalConfig.collectCoverage) {
+        // This is going to be used by @react-native-harness/babel-preset
+        // to enable instrumentation of test files.
+        process.env.RN_HARNESS_COLLECT_COVERAGE = 'true';
+    }
+    logTestRunHeader(selectedRunner);
+    const harness = await getHarness(selectedRunner);
+    logTestEnvironmentReady(selectedRunner);
+    global.HARNESS_CONFIG = harnessConfig;
+    global.HARNESS = harness;
+}

package/dist/global-teardown.d.ts

@@ -0,0 +1,3 @@
+import type { Config as JestConfig } from 'jest-runner';
+export default function (globalConfig: JestConfig.GlobalConfig): Promise<void>;
+//# sourceMappingURL=global-teardown.d.ts.map

package/dist/global-teardown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"global-teardown.d.ts","sourceRoot":"","sources":["../src/global-teardown.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,aAAa,CAAC;AAExD,yBAA+B,YAAY,EAAE,UAAU,CAAC,YAAY,iBAYnE"}

package/dist/global-teardown.js

@@ -0,0 +1,11 @@
+export default async function (globalConfig) {
+    const isWatchMode = globalConfig.watch || globalConfig.watchAll;
+    if (isWatchMode) {
+        // In watch mode, we don't want to dispose the Harness.
+        return;
+    }
+    if (global.HARNESS) {
+        await global.HARNESS.bridge.dispose();
+        await global.HARNESS.environment.dispose();
+    }
+}

package/dist/harness-reporter.d.ts

@@ -0,0 +1,8 @@
+import { BaseReporter } from '@jest/reporters';
+import { Config } from '@jest/types';
+export default class HarnessReporter extends BaseReporter {
+    #private;
+    constructor(globalConfig: Config.GlobalConfig);
+    onRunStart(): void;
+}
+//# sourceMappingURL=harness-reporter.d.ts.map

package/dist/harness-reporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"harness-reporter.d.ts","sourceRoot":"","sources":["../src/harness-reporter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,MAAM,CAAC,OAAO,OAAO,eAAgB,SAAQ,YAAY;;gBAE3C,YAAY,EAAE,MAAM,CAAC,YAAY;IAKpC,UAAU,IAAI,IAAI;CAM5B"}

package/dist/harness-reporter.js

@@ -0,0 +1,12 @@
+import { BaseReporter } from '@jest/reporters';
+export default class HarnessReporter extends BaseReporter {
+    #globalConfig;
+    constructor(globalConfig) {
+        super();
+        this.#globalConfig = globalConfig;
+    }
+    onRunStart() {
+        super.onRunStart();
+        this.log(`Selected runner: ${this.#globalConfig.selectedRunner.name}`);
+    }
+}

package/dist/harness-session.d.ts

@@ -0,0 +1,34 @@
+import { type HarnessContext, type TestExecutionOptions, type TestSuiteResult } from '@react-native-harness/bridge';
+import { type HarnessPlatform } from '@react-native-harness/platforms';
+import { type HarnessPluginManager, type HarnessRunStatus, type HarnessRunSummary } from '@react-native-harness/plugins';
+import { type Config as HarnessConfig } from '@react-native-harness/config';
+import type { Config as JestConfig } from 'jest-runner';
+import { type ClientLogBuffer } from './client-log-handler.js';
+import { type ResourceLockManager } from './resource-lock.js';
+export type HarnessRunState = {
+    readonly runId: string;
+    readonly startTime: number;
+    readonly testFiles: string[];
+    readonly watchMode: boolean;
+    readonly coverageEnabled: boolean;
+    readonly summary?: HarnessRunSummary;
+    readonly status?: HarnessRunStatus;
+    readonly error?: unknown;
+};
+export type HarnessRunTestsOptions = Exclude<TestExecutionOptions, 'platform'>;
+export type HarnessSession = {
+    readonly config: HarnessConfig;
+    readonly context: HarnessContext;
+    runTestFile: (path: string, options: HarnessRunTestsOptions) => Promise<TestSuiteResult>;
+    ensureAppReady: (testFilePath: string) => Promise<void>;
+    restartApp: (testFilePath?: string) => Promise<void>;
+    resetCrashState: () => void;
+    flushClientLogs: () => ClientLogBuffer;
+    callHook: HarnessPluginManager<HarnessConfig, HarnessPlatform>['callHook'];
+    setRunState: (state: HarnessRunState | null) => void;
+    dispose: (reason?: 'normal' | 'abort' | 'error') => Promise<void>;
+};
+export declare const createHarnessSession: (globalConfig: JestConfig.GlobalConfig, { lockManager }?: {
+    lockManager?: ResourceLockManager;
+}) => Promise<HarnessSession>;
+//# sourceMappingURL=harness-session.d.ts.map

package/dist/harness-session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"harness-session.d.ts","sourceRoot":"","sources":["../src/harness-session.ts"],"names":[],"mappings":"AAKA,OAAO,EAEL,KAAK,cAAc,EAEnB,KAAK,oBAAoB,EACzB,KAAK,eAAe,EACrB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAEL,KAAK,eAAe,EAGrB,MAAM,iCAAiC,CAAC;AASzC,OAAO,EAIL,KAAK,oBAAoB,EACzB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACvB,MAAM,+BAA+B,CAAC;AAOvC,OAAO,EAEL,KAAK,MAAM,IAAI,aAAa,EAE7B,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,aAAa,CAAC;AAMxD,OAAO,EAEL,KAAK,eAAe,EACrB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAEL,KAAK,mBAAmB,EAEzB,MAAM,oBAAoB,CAAC;AAkB5B,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;IAClC,QAAQ,CAAC,OAAO,CAAC,EAAE,iBAAiB,CAAC;IACrC,QAAQ,CAAC,MAAM,CAAC,EAAE,gBAAgB,CAAC;IACnC,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG,OAAO,CAAC,oBAAoB,EAAE,UAAU,CAAC,CAAC;AAE/E,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAC/B,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC;IACjC,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,sBAAsB,KAAK,OAAO,CAAC,eAAe,CAAC,CAAC;IACzF,cAAc,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACxD,UAAU,EAAE,CAAC,YAAY,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACrD,eAAe,EAAE,MAAM,IAAI,CAAC;IAC5B,eAAe,EAAE,MAAM,eAAe,CAAC;IACvC,QAAQ,EAAE,oBAAoB,CAAC,aAAa,EAAE,eAAe,CAAC,CAAC,UAAU,CAAC,CAAC;IAC3E,WAAW,EAAE,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI,KAAK,IAAI,CAAC;IACrD,OAAO,EAAE,CAAC,MAAM,CAAC,EAAE,QAAQ,GAAG,OAAO,GAAG,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACnE,CAAC;AAuOF,eAAO,MAAM,oBAAoB,GAC/B,cAAc,UAAU,CAAC,YAAY,EACrC,kBAA8C;IAAE,WAAW,CAAC,EAAE,mBAAmB,CAAA;CAAO,KACvF,OAAO,CAAC,cAAc,CA6YxB,CAAC"}