@alwaysmeticulous/cli 2.40.0 → 2.40.4

package/dist/parallel-tests/__tests__/parrallel-tests.handler.spec.js

@@ -1,205 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const common_1 = require("@alwaysmeticulous/common");
-const parallel_tests_handler_1 = require("../parallel-tests.handler");
-const mock_test_results_1 = require("./mock-test-results");
-describe("runAllTestsInParallel", () => {
-    it("maximises the number of tests run in parralel, up to the provided limit", async () => {
-        let progress = {
-            runningTestCases: 4,
-            failedTestCases: 0,
-            flakedTestCases: 0,
-            passedTestCases: 0,
-        };
-        let testsStarted = 0;
-        const testRunPromises = [(0, common_1.defer)(), (0, common_1.defer)(), (0, common_1.defer)(), (0, common_1.defer)()];
-        const overallPromise = (0, parallel_tests_handler_1.runAllTestsInParallel)({
-            testsToRun: [testCase(0), testCase(1), testCase(2), testCase(3)],
-            parallelTasks: 2,
-            maxRetriesOnFailure: 0,
-            rerunTestsNTimes: 0,
-            executeTest: async (testCase) => {
-                var _a;
-                testsStarted++;
-                await testRunPromises[parseInt((_a = testCase.title) !== null && _a !== void 0 ? _a : "")].promise;
-                return (0, mock_test_results_1.testResult)("pass", [(0, mock_test_results_1.noDiff)(0)], testCase);
-            },
-            onTestFinished: async (newProgress) => {
-                progress = newProgress;
-            },
-        });
-        await waitForPromisesToFlush();
-        expect(testsStarted).toEqual(2);
-        expect(progress).toEqual({
-            runningTestCases: 4,
-            failedTestCases: 0,
-            flakedTestCases: 0,
-            passedTestCases: 0,
-        });
-        testRunPromises[0].resolve();
-        await waitForPromisesToFlush();
-        expect(testsStarted).toEqual(3);
-        expect(progress).toEqual({
-            runningTestCases: 3,
-            failedTestCases: 0,
-            flakedTestCases: 0,
-            passedTestCases: 1,
-        });
-        testRunPromises[1].resolve();
-        testRunPromises[2].resolve();
-        await waitForPromisesToFlush();
-        expect(testsStarted).toEqual(4);
-        expect(progress).toEqual({
-            runningTestCases: 1,
-            failedTestCases: 0,
-            flakedTestCases: 0,
-            passedTestCases: 3,
-        });
-        await expectPromiseToNotHaveResolved(overallPromise);
-        testRunPromises[3].resolve();
-        await waitForPromisesToFlush();
-        expect(progress).toEqual({
-            runningTestCases: 0,
-            failedTestCases: 0,
-            flakedTestCases: 0,
-            passedTestCases: 4,
-        });
-        await overallPromise;
-    });
-    it("can handle a test failing to run", async () => {
-        let progress = {
-            runningTestCases: 4,
-            failedTestCases: 0,
-            flakedTestCases: 0,
-            passedTestCases: 0,
-        };
-        const testRunPromises = [(0, common_1.defer)(), (0, common_1.defer)(), (0, common_1.defer)(), (0, common_1.defer)()];
-        const overallPromise = (0, parallel_tests_handler_1.runAllTestsInParallel)({
-            testsToRun: [testCase(0), testCase(1), testCase(2), testCase(3)],
-            parallelTasks: 2,
-            maxRetriesOnFailure: 0,
-            rerunTestsNTimes: 0,
-            executeTest: async (testCase) => {
-                var _a;
-                await testRunPromises[parseInt((_a = testCase.title) !== null && _a !== void 0 ? _a : "")].promise;
-                return (0, mock_test_results_1.testResult)("pass", [(0, mock_test_results_1.noDiff)(0)], testCase);
-            },
-            onTestFinished: async (newProgress) => {
-                progress = newProgress;
-            },
-        });
-        testRunPromises[0].resolve();
-        testRunPromises[1].reject();
-        testRunPromises[2].resolve();
-        testRunPromises[3].resolve();
-        const result = await overallPromise;
-        expect(progress).toEqual({
-            runningTestCases: 0,
-            failedTestCases: 1,
-            flakedTestCases: 0,
-            passedTestCases: 3,
-        });
-        // No result given for test 1 (it can't, because it doesn't have a headReplayId)
-        expect(result).toEqual([
-            (0, mock_test_results_1.testResult)("pass", [(0, mock_test_results_1.noDiff)(0)], testCase(0)),
-            (0, mock_test_results_1.testResult)("pass", [(0, mock_test_results_1.noDiff)(0)], testCase(2)),
-            (0, mock_test_results_1.testResult)("pass", [(0, mock_test_results_1.noDiff)(0)], testCase(3)),
-        ]);
-    });
-    it("does not retry failed tests if maxRetriesOnFailure is 0", async () => {
-        const results = await (0, parallel_tests_handler_1.runAllTestsInParallel)({
-            testsToRun: [testCase(0)],
-            parallelTasks: 2,
-            maxRetriesOnFailure: 0,
-            rerunTestsNTimes: 0,
-            executeTest: async (testCase) => {
-                return (0, mock_test_results_1.testResult)("fail", [(0, mock_test_results_1.diff)(0)], testCase);
-            },
-        });
-        expect(results).toEqual([(0, mock_test_results_1.testResult)("fail", [(0, mock_test_results_1.diff)(0)], testCase(0))]);
-    });
-    it("retries failed tests until maxRetriesOnFailure reached or first flake seen for all screenshots if maxRetriesOnFailure > 0", async () => {
-        let retryNum = 0;
-        const results = await (0, parallel_tests_handler_1.runAllTestsInParallel)({
-            testsToRun: [testCase(0)],
-            parallelTasks: 2,
-            maxRetriesOnFailure: 10,
-            rerunTestsNTimes: 0,
-            executeTest: async (testCase, isRetry) => {
-                if (!isRetry) {
-                    return (0, mock_test_results_1.testResult)("fail", [(0, mock_test_results_1.diff)(0), (0, mock_test_results_1.diff)(1)], testCase);
-                }
-                if (retryNum === 3) {
-                    return (0, mock_test_results_1.testResult)("fail", [(0, mock_test_results_1.missingHead)(0), (0, mock_test_results_1.diff)(1)], testCase);
-                }
-                retryNum++;
-                return (0, mock_test_results_1.testResult)("pass", [(0, mock_test_results_1.noDiff)(0), (0, mock_test_results_1.diff)(1)], testCase);
-            },
-        });
-        expect(retryNum).toEqual(3);
-        expect(results).toEqual([
-            (0, mock_test_results_1.testResult)("flake", [
-                (0, mock_test_results_1.flake)(0, (0, mock_test_results_1.diff)(), [(0, mock_test_results_1.missingHead)()]),
-                (0, mock_test_results_1.flake)(1, (0, mock_test_results_1.diff)(), [(0, mock_test_results_1.diff)(), (0, mock_test_results_1.diff)(), (0, mock_test_results_1.diff)(), (0, mock_test_results_1.diff)()]),
-            ], testCase(0)),
-        ]);
-    });
-    it("marks test as a failure if hit max number of retries and no flakes detected", async () => {
-        const results = await (0, parallel_tests_handler_1.runAllTestsInParallel)({
-            testsToRun: [testCase(0)],
-            parallelTasks: 2,
-            maxRetriesOnFailure: 3,
-            rerunTestsNTimes: 0,
-            executeTest: async (testCase, isRetry) => {
-                if (!isRetry) {
-                    return (0, mock_test_results_1.testResult)("fail", [(0, mock_test_results_1.diff)(0), (0, mock_test_results_1.diff)(1)], testCase);
-                }
-                return (0, mock_test_results_1.testResult)("pass", [(0, mock_test_results_1.noDiff)(0), (0, mock_test_results_1.diff)(1)], testCase);
-            },
-        });
-        expect(results).toEqual([
-            (0, mock_test_results_1.testResult)("fail", [(0, mock_test_results_1.diff)(0), (0, mock_test_results_1.flake)(1, (0, mock_test_results_1.diff)(), [(0, mock_test_results_1.diff)(), (0, mock_test_results_1.diff)(), (0, mock_test_results_1.diff)()])], testCase(0)),
-        ]);
-    });
-    it("retries N times if rerunTestsNTimes > 0", async () => {
-        let rerunNum = 0;
-        const results = await (0, parallel_tests_handler_1.runAllTestsInParallel)({
-            testsToRun: [testCase(0)],
-            parallelTasks: 2,
-            maxRetriesOnFailure: 0,
-            rerunTestsNTimes: 3,
-            executeTest: async (testCase, isRetry) => {
-                if (!isRetry) {
-                    return (0, mock_test_results_1.testResult)("pass", [(0, mock_test_results_1.diff)(0), (0, mock_test_results_1.noDiff)(1)], testCase);
-                }
-                if (rerunNum === 2) {
-                    return (0, mock_test_results_1.testResult)("fail", [(0, mock_test_results_1.missingHead)(0), (0, mock_test_results_1.diff)(1)], testCase);
-                }
-                rerunNum++;
-                return (0, mock_test_results_1.testResult)("pass", [(0, mock_test_results_1.noDiff)(0), (0, mock_test_results_1.noDiff)(1)], testCase);
-            },
-        });
-        expect(rerunNum).toEqual(2);
-        expect(results).toEqual([
-            (0, mock_test_results_1.testResult)(
-            // Flake outcome is returned iff all screenshots are flaky.
-            "flake", [(0, mock_test_results_1.flake)(0, (0, mock_test_results_1.diff)(), [(0, mock_test_results_1.missingHead)()]), (0, mock_test_results_1.flake)(1, (0, mock_test_results_1.noDiff)(), [(0, mock_test_results_1.diff)()])], testCase(0)),
-        ]);
-    });
-});
-const testCase = (num) => ({
-    sessionId: "mock-session-id",
-    title: `${num}`,
-    baseTestRunId: "mock-base-test-run-id",
-});
-const expectPromiseToNotHaveResolved = async (promise) => {
-    let resolved = false;
-    promise.then(() => {
-        resolved = true;
-    }, () => {
-        resolved = true;
-    });
-    await waitForPromisesToFlush();
-    expect(resolved).toEqual(false);
-};
-const waitForPromisesToFlush = () => new Promise((resolve) => setTimeout(resolve, 0));

package/dist/parallel-tests/execute-test-in-child-process.d.ts

@@ -1,3 +0,0 @@
-import { DetailedTestCaseResult } from "../config/config.types";
-import { InitMessage } from "./messages.types";
-export declare const executeTestInChildProcess: (initMessage: InitMessage) => Promise<DetailedTestCaseResult>;

package/dist/parallel-tests/execute-test-in-child-process.js

@@ -1,44 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeTestInChildProcess = void 0;
-const child_process_1 = require("child_process");
-const path_1 = require("path");
-const common_1 = require("@alwaysmeticulous/common");
-const loglevel_1 = __importDefault(require("loglevel"));
-const executeTestInChildProcess = (initMessage) => {
-    const logger = loglevel_1.default.getLogger(common_1.METICULOUS_LOGGER_NAME);
-    const isTypeScript = __filename.endsWith(".ts");
-    const taskHandler = (0, path_1.join)(__dirname, `task.handler${isTypeScript ? ".ts" : ".js"}`);
-    const deferredResult = (0, common_1.defer)();
-    const child = (0, child_process_1.fork)(taskHandler, [], { stdio: "inherit" });
-    const messageHandler = (message) => {
-        if (message &&
-            typeof message === "object" &&
-            message["kind"] === "result") {
-            const resultMessage = message;
-            deferredResult.resolve(resultMessage.data.result);
-            child.off("message", messageHandler);
-        }
-    };
-    child.on("error", (error) => {
-        if (deferredResult.getState() === "pending") {
-            deferredResult.reject(error);
-        }
-    });
-    child.on("exit", (code) => {
-        if (code) {
-            logger.debug(`child exited with code: ${code}`);
-        }
-        if (deferredResult.getState() === "pending") {
-            deferredResult.reject(new Error("No result"));
-        }
-    });
-    child.on("message", messageHandler);
-    // Send test case and arguments to child process
-    child.send(initMessage);
-    return deferredResult.promise;
-};
-exports.executeTestInChildProcess = executeTestInChildProcess;

package/dist/parallel-tests/merge-test-results.d.ts

@@ -1,12 +0,0 @@
-import { ScreenshotDiffResult } from "@alwaysmeticulous/api";
-import { DetailedTestCaseResult, TestCaseResult } from "../config/config.types";
-export interface ResultsToMerge {
-    currentResult: DetailedTestCaseResult;
-    /**
-     * The result of replaying the session once more against the head commit and
-     * comparing the screenshots to those taken on the first replay against the head commit.
-     */
-    comparisonToHeadReplay: DetailedTestCaseResult;
-}
-export declare const mergeResults: ({ currentResult, comparisonToHeadReplay, }: ResultsToMerge) => DetailedTestCaseResult;
-export declare const testRunOutcomeFromDiffResults: (currentResult: TestCaseResult["result"], newScreenshotDiffResults: ScreenshotDiffResult[]) => TestCaseResult["result"];

package/dist/parallel-tests/merge-test-results.js

@@ -1,106 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.testRunOutcomeFromDiffResults = exports.mergeResults = void 0;
-const fast_json_stable_stringify_1 = __importDefault(require("fast-json-stable-stringify"));
-const has_notable_differences_1 = require("../commands/screenshot-diff/utils/has-notable-differences");
-const screenshot_diff_results_utils_1 = require("./screenshot-diff-results.utils");
-const mergeResults = ({ currentResult, comparisonToHeadReplay, }) => {
-    // If any of the screenshots diffs in comparisonToHeadReplay show a diff against one
-    // of the screenshots that orignally failed in currentResult then we have a flake
-    // on our hands
-    const retryDiffById = new Map();
-    (0, screenshot_diff_results_utils_1.flattenScreenshotDiffResults)(comparisonToHeadReplay).forEach((result) => {
-        const hash = hashScreenshotIdentifier(result.identifier);
-        if (retryDiffById.has(hash)) {
-            throw new Error(`Received two screenshots for the same identifier '${hash}'. Screenshots should be unique.`);
-        }
-        retryDiffById.set(hash, result);
-    });
-    const newScreenshotDiffResults = (0, screenshot_diff_results_utils_1.flattenScreenshotDiffResults)(currentResult).map((currentDiff) => {
-        const hash = hashScreenshotIdentifier(currentDiff.identifier);
-        const diffWhenRetrying = retryDiffById.get(hash);
-        // diffWhenRetrying is null in the case that there is a base screenshot for the base replay,
-        // but the first replay on head did not generate a head screenshot (got 'missing-head'),
-        // and the replay of that did not generate a head screenshot either (if the first replay on head
-        // did generate a screenshot, then diffWhenRetrying.outcome would be 'missing-head' instead)
-        if (diffWhenRetrying == null) {
-            const diffToBaseScreenshotOutcome = currentDiff.outcome === "flake"
-                ? currentDiff.diffToBaseScreenshot.outcome
-                : currentDiff.outcome;
-            if (diffToBaseScreenshotOutcome !== "missing-head") {
-                throw new Error(`Expected to find a screenshot comparison for ${hash}, but none was found. The screenshot must
-            have existed in the orginal replay, since the orginal comparison outcome was not '${diffToBaseScreenshotOutcome}'.`);
-            }
-            if (currentDiff.outcome === "flake") {
-                // Original comparison had missing-head, so we re-ran to check if it was flakey. In this case
-                // we got the same result.
-                return {
-                    ...currentDiff,
-                    diffsToHeadScreenshotOnRetries: [
-                        ...currentDiff.diffsToHeadScreenshotOnRetries,
-                        { outcome: "missing-base-and-head" },
-                    ],
-                };
-            }
-            return currentDiff; // no difference, both screenshots were missing
-        }
-        if (diffWhenRetrying.outcome === "flake") {
-            throw new Error("Expected diffs when retrying and comparing to the original head screenshot to be first-try diffs, but got a flake.");
-        }
-        if (currentDiff.outcome === "flake") {
-            return {
-                ...currentDiff,
-                diffsToHeadScreenshotOnRetries: [
-                    ...currentDiff.diffsToHeadScreenshotOnRetries,
-                    withoutIdentifiers(diffWhenRetrying),
-                ],
-            };
-        }
-        else if ((diffWhenRetrying === null || diffWhenRetrying === void 0 ? void 0 : diffWhenRetrying.outcome) === "no-diff") {
-            return currentDiff;
-        }
-        else {
-            return {
-                baseReplayId: currentDiff.baseReplayId,
-                identifier: currentDiff.identifier,
-                outcome: "flake",
-                diffToBaseScreenshot: withoutIdentifiers(currentDiff),
-                diffsToHeadScreenshotOnRetries: [withoutIdentifiers(diffWhenRetrying)],
-            };
-        }
-    });
-    return {
-        ...currentResult,
-        result: (0, exports.testRunOutcomeFromDiffResults)(currentResult.result, newScreenshotDiffResults),
-        screenshotDiffResultsByBaseReplayId: (0, screenshot_diff_results_utils_1.groupScreenshotDiffResults)(newScreenshotDiffResults),
-    };
-};
-exports.mergeResults = mergeResults;
-const withoutIdentifiers = ({ 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-identifier: _identifier, 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-baseReplayId: _baseReplayId, ...rest }) => rest;
-const hashScreenshotIdentifier = (identifier) => {
-    return (0, fast_json_stable_stringify_1.default)(identifier);
-};
-const testRunOutcomeFromDiffResults = (currentResult, newScreenshotDiffResults) => {
-    // If a test run is already flakey, we don't want to overwrite that with a 'fail' result.
-    if (currentResult === "flake") {
-        return "flake";
-    }
-    const hasOnlyFlakes = newScreenshotDiffResults.every(({ outcome }) => outcome === "flake" || outcome === "no-diff");
-    if (hasOnlyFlakes) {
-        return "flake";
-    }
-    // If we've had a test run has already failed, we don't want to overwrite that with a 'pass' result.
-    // Otherwise, if there are any notable differences, we want to fail the test run.
-    return currentResult === "fail" ||
-        (0, has_notable_differences_1.hasNotableDifferences)(newScreenshotDiffResults)
-        ? "fail"
-        : "pass";
-};
-exports.testRunOutcomeFromDiffResults = testRunOutcomeFromDiffResults;

package/dist/parallel-tests/messages.types.d.ts

@@ -1,17 +0,0 @@
-import log from "loglevel";
-import { DetailedTestCaseResult } from "../config/config.types";
-import { ParallelTestsReplayOptions } from "./parallel-replay.types";
-export interface InitMessage {
-    kind: "init";
-    data: {
-        logLevel: log.LogLevel[keyof log.LogLevel];
-        dataDir: string;
-        replayOptions: ParallelTestsReplayOptions;
-    };
-}
-export interface ResultMessage {
-    kind: "result";
-    data: {
-        result: DetailedTestCaseResult;
-    };
-}

package/dist/parallel-tests/messages.types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/parallel-tests/parallel-replay.handler.d.ts

@@ -1,3 +0,0 @@
-import { DetailedTestCaseResult } from "../config/config.types";
-import { ParallelTestsReplayOptions } from "./parallel-replay.types";
-export declare const handleReplay: ({ testCase, replayTarget, executionOptions, screenshottingOptions, apiToken, commitSha, generatedBy, testRunId, replayEventsDependencies, suppressScreenshotDiffLogging, baseTestRunId, }: ParallelTestsReplayOptions) => Promise<DetailedTestCaseResult>;

package/dist/parallel-tests/parallel-replay.handler.js

@@ -1,56 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleReplay = void 0;
-const replay_command_1 = require("../commands/replay/replay.command");
-const has_notable_differences_1 = require("../commands/screenshot-diff/utils/has-notable-differences");
-const handleReplay = async ({ testCase, replayTarget, executionOptions, screenshottingOptions, apiToken, commitSha, generatedBy, testRunId, replayEventsDependencies, suppressScreenshotDiffLogging, baseTestRunId, }) => {
-    var _a, _b;
-    const { replay, screenshotDiffResultsByBaseReplayId } = await (0, replay_command_1.replayCommandHandler)({
-        replayTarget,
-        executionOptions: applyTestCaseExecutionOptionOverrides(executionOptions, (_a = testCase.options) !== null && _a !== void 0 ? _a : {}),
-        screenshottingOptions: applyTestCaseScreenshottingOptionsOverrides(screenshottingOptions, (_b = testCase.options) !== null && _b !== void 0 ? _b : {}),
-        apiToken,
-        commitSha,
-        sessionId: testCase.sessionId,
-        baseTestRunId,
-        cookiesFile: null,
-        generatedBy,
-        testRunId,
-        replayEventsDependencies,
-        suppressScreenshotDiffLogging,
-        debugger: false,
-    });
-    const result = (0, has_notable_differences_1.hasNotableDifferences)(Object.values(screenshotDiffResultsByBaseReplayId).flat())
-        ? "fail"
-        : "pass";
-    return {
-        ...testCase,
-        headReplayId: replay.id,
-        result,
-        screenshotDiffResultsByBaseReplayId,
-    };
-};
-exports.handleReplay = handleReplay;
-const applyTestCaseExecutionOptionOverrides = (executionOptionsFromCliFlags, overridesFromTestCase) => {
-    var _a;
-    // Options specified in the test case override those passed as CLI flags
-    // (CLI flags set the defaults)
-    return {
-        ...executionOptionsFromCliFlags,
-        moveBeforeClick: (_a = overridesFromTestCase.moveBeforeClick) !== null && _a !== void 0 ? _a : executionOptionsFromCliFlags.moveBeforeClick,
-    };
-};
-const applyTestCaseScreenshottingOptionsOverrides = (screenshottingOptionsFromCliFlags, overridesFromTestCase) => {
-    var _a, _b;
-    // Options specified in the test case override those passed as CLI flags
-    // (CLI flags set the defaults)
-    const diffOptions = {
-        diffThreshold: (_a = overridesFromTestCase.diffThreshold) !== null && _a !== void 0 ? _a : screenshottingOptionsFromCliFlags.diffOptions.diffThreshold,
-        diffPixelThreshold: (_b = overridesFromTestCase.diffPixelThreshold) !== null && _b !== void 0 ? _b : screenshottingOptionsFromCliFlags.diffOptions.diffPixelThreshold,
-    };
-    return {
-        enabled: true,
-        diffOptions,
-        storyboardOptions: screenshottingOptionsFromCliFlags.storyboardOptions,
-    };
-};

package/dist/parallel-tests/parallel-replay.types.d.ts

@@ -1,16 +0,0 @@
-import { TestCase } from "@alwaysmeticulous/api";
-import { GeneratedBy, ReplayEventsDependencies, ReplayExecutionOptions, ReplayTarget } from "@alwaysmeticulous/common";
-import { ScreenshotAssertionsEnabledOptions } from "../command-utils/common-types";
-export interface ParallelTestsReplayOptions {
-    replayTarget: ReplayTarget;
-    executionOptions: ReplayExecutionOptions;
-    screenshottingOptions: ScreenshotAssertionsEnabledOptions;
-    testCase: TestCase;
-    apiToken: string | null;
-    commitSha: string;
-    generatedBy: GeneratedBy;
-    testRunId: string | null;
-    baseTestRunId: string | null;
-    replayEventsDependencies: ReplayEventsDependencies;
-    suppressScreenshotDiffLogging: boolean;
-}

package/dist/parallel-tests/parallel-replay.types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/parallel-tests/parallel-tests.handler.d.ts

@@ -1,14 +0,0 @@
-import { TestCase } from "@alwaysmeticulous/api";
-import { DetailedTestCaseResult } from "../config/config.types";
-import { TestRunProgress } from "./run-all-tests.types";
-export interface RunAllTestsInParallelOptions {
-    testsToRun: TestCase[];
-    parallelTasks: number | null;
-    maxRetriesOnFailure: number;
-    rerunTestsNTimes: number;
-    executeTest: (testCase: TestCase, isRetry: boolean) => Promise<DetailedTestCaseResult>;
-    onTestFinished?: (progress: TestRunProgress, resultsSoFar: DetailedTestCaseResult[]) => Promise<void>;
-    onTestFailedToRun?: (progress: TestRunProgress) => Promise<void>;
-}
-/** Handler for running Meticulous tests in parallel using child processes */
-export declare const runAllTestsInParallel: (options: RunAllTestsInParallelOptions) => Promise<DetailedTestCaseResult[]>;