@alwaysmeticulous/cli 2.3.2 → 2.4.0

package/dist/commands/screenshot-diff/screenshot-diff.command.js

@@ -6,13 +6,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.screenshotDiff = exports.diffScreenshots = exports.DiffError = void 0;
 const common_1 = require("@alwaysmeticulous/common");
 const loglevel_1 = __importDefault(require("loglevel"));
+const path_1 = require("path");
 const client_1 = require("../../api/client");
 const replay_api_1 = require("../../api/replay.api");
+const common_options_1 = require("../../command-utils/common-options");
 const diff_utils_1 = require("../../image/diff.utils");
+const io_utils_1 = require("../../image/io.utils");
 const replays_1 = require("../../local-data/replays");
 const screenshot_diffs_1 = require("../../local-data/screenshot-diffs");
 const sentry_utils_1 = require("../../utils/sentry.utils");
-const DEFAULT_MISMATCH_THRESHOLD = 0.01;
 class DiffError extends Error {
     constructor(message, extras) {
         super(message);
@@ -20,40 +22,85 @@ class DiffError extends Error {
     }
 }
 exports.DiffError = DiffError;
-const diffScreenshots = async ({ client, baseReplayId, headReplayId, baseScreenshot, headScreenshot, threshold: threshold_, pixelThreshold, exitOnMismatch, }) => {
+const diffScreenshots = async ({ client, baseReplayId, headReplayId, baseScreenshotsDir, headScreenshotsDir, diffOptions, exitOnMismatch, }) => {
+    const { diffThreshold, diffPixelThreshold } = diffOptions;
     const logger = loglevel_1.default.getLogger(common_1.METICULOUS_LOGGER_NAME);
-    const threshold = threshold_ || DEFAULT_MISMATCH_THRESHOLD;
-    const pixelmatchOptions = pixelThreshold ? { threshold: pixelThreshold } : null;
+    const baseReplayScreenshots = await (0, replays_1.getScreenshotFiles)(baseScreenshotsDir);
+    const headReplayScreenshots = await (0, replays_1.getScreenshotFiles)(headScreenshotsDir);
+    // Assume base replay screenshots are always a subset of the head replay screenshots.
+    // We report any missing base replay screenshots for visibility but don't count it as a difference.
+    const missingHeadImages = new Set([...baseReplayScreenshots].filter((file) => !headReplayScreenshots.includes(file)));
+    let totalMismatchPixels = 0;
+    const comparisonResults = [];
     try {
-        const { mismatchPixels, mismatchFraction, diff } = (0, diff_utils_1.compareImages)({
-            base: baseScreenshot,
-            head: headScreenshot,
-            ...(pixelmatchOptions ? pixelmatchOptions : {}),
-        });
-        logger.debug({ mismatchPixels, mismatchFraction });
-        logger.info(`${Math.round(mismatchFraction * 100)}% pixel mismatch (threshold is ${Math.round(threshold * 100)}%) => ${mismatchFraction > threshold ? "FAIL!" : "PASS"}`);
-        await (0, screenshot_diffs_1.writeScreenshotDiff)({ baseReplayId, headReplayId, diff });
-        const diffUrl = await (0, replay_api_1.getDiffUrl)(client, baseReplayId, headReplayId);
-        logger.info(`View screenshot diff at ${diffUrl}`);
+        if (missingHeadImages.size > 0) {
+            logComparisonResultMessage(logger, `Head replay is missing screenshots: ${[...missingHeadImages].sort()}`, "fail");
+            throw new DiffError(`Head replay is missing screenshots: ${[...missingHeadImages].sort()}`, {
+                baseReplayId,
+                headReplayId,
+                threshold: diffThreshold,
+            });
+        }
+        for (const screenshotFileName of headReplayScreenshots) {
+            if (!baseReplayScreenshots.includes(screenshotFileName)) {
+                logger.info(`Screenshot ${screenshotFileName} not present in base replay`);
+                continue;
+            }
+            const baseScreenshotFile = (0, path_1.join)(baseScreenshotsDir, screenshotFileName);
+            const headScreenshotFile = (0, path_1.join)(headScreenshotsDir, screenshotFileName);
+            const baseScreenshot = await (0, io_utils_1.readPng)(baseScreenshotFile);
+            const headScreenshot = await (0, io_utils_1.readPng)(headScreenshotFile);
+            const comparisonResult = (0, diff_utils_1.compareImages)({
+                base: baseScreenshot,
+                head: headScreenshot,
+                pixelThreshold: diffPixelThreshold,
+            });
+            totalMismatchPixels += comparisonResult.mismatchPixels;
+            logger.debug({
+                screenshotFileName,
+                mismatchPixels: comparisonResult.mismatchPixels,
+                mismatchFraction: comparisonResult.mismatchFraction,
+            });
+            await (0, screenshot_diffs_1.writeScreenshotDiff)({
+                baseReplayId,
+                headReplayId,
+                screenshotFileName,
+                diff: comparisonResult.diff,
+            });
+            comparisonResults.push({
+                baseScreenshotFile,
+                headScreenshotFile,
+                comparisonResult,
+                outcome: comparisonResult.mismatchFraction > diffThreshold ? "fail" : "pass",
+            });
+        }
         await (0, replay_api_1.postScreenshotDiffStats)(client, {
             baseReplayId,
             headReplayId,
             stats: {
-                width: baseScreenshot.width,
-                height: baseScreenshot.height,
-                mismatchPixels,
+                width: 0,
+                height: 0,
+                mismatchPixels: totalMismatchPixels,
             },
         });
-        if (mismatchFraction > threshold) {
-            logger.info("Screenshots do not match!");
+        const diffUrl = await (0, replay_api_1.getDiffUrl)(client, baseReplayId, headReplayId);
+        logger.info(`View screenshot diff at ${diffUrl}`);
+        comparisonResults.forEach((result) => {
+            logComparisonResultMessage(logger, `${Math.round(result.comparisonResult.mismatchFraction * 100)}% pixel mismatch for screenshot ${(0, path_1.basename)(result.headScreenshotFile)} (threshold is ${Math.round(diffThreshold * 100)}%)`, result.outcome);
+        });
+        // Check if individual screenshot mismatch is higher than the threshold.
+        const mismatchingScreenshots = comparisonResults.filter((result) => result.outcome == "fail");
+        if (mismatchingScreenshots.length) {
+            logger.info(`Screenshots ${mismatchingScreenshots
+                .map((result) => (0, path_1.basename)(result.headScreenshotFile))
+                .sort()} do not match!`);
             if (exitOnMismatch) {
                 process.exit(1);
             }
-            throw new DiffError("Screenshots do not match!", {
+            throw new DiffError(`Screenshots ${mismatchingScreenshots.map((result) => (0, path_1.basename)(result.headScreenshotFile))} do not match!`, {
                 baseReplayId,
                 headReplayId,
-                threshold,
-                value: mismatchFraction,
+                threshold: diffThreshold,
             });
         }
     }
@@ -67,28 +114,34 @@ const diffScreenshots = async ({ client, baseReplayId, headReplayId, baseScreens
         throw new DiffError(`Error while diffing: ${error}`, {
             baseReplayId,
             headReplayId,
-            threshold,
+            threshold: diffThreshold,
             value: 1,
         });
     }
+    return comparisonResults;
 };
 exports.diffScreenshots = diffScreenshots;
+const logComparisonResultMessage = (logger, message, outcome) => {
+    logger.info(`${message} => ${outcome === "pass" ? "PASS" : "FAIL!"}`);
+};
 const handler = async ({ apiToken, baseSimulationId: baseReplayId, headSimulationId: headReplayId, threshold, pixelThreshold, }) => {
     const client = (0, client_1.createClient)({ apiToken });
     await (0, replays_1.getOrFetchReplay)(client, baseReplayId);
     await (0, replays_1.getOrFetchReplayArchive)(client, baseReplayId);
     await (0, replays_1.getOrFetchReplay)(client, headReplayId);
     await (0, replays_1.getOrFetchReplayArchive)(client, headReplayId);
-    const baseScreenshot = await (0, replays_1.readReplayScreenshot)(baseReplayId);
-    const headScreenshot = await (0, replays_1.readReplayScreenshot)(headReplayId);
+    const baseScreenshotsDir = (0, replays_1.getScreenshotsDir)((0, replays_1.getReplayDir)(baseReplayId));
+    const headScreenshotsDir = (0, replays_1.getScreenshotsDir)((0, replays_1.getReplayDir)(headReplayId));
     await (0, exports.diffScreenshots)({
         client,
         baseReplayId,
         headReplayId,
-        baseScreenshot,
-        headScreenshot,
-        threshold,
-        pixelThreshold,
+        baseScreenshotsDir,
+        headScreenshotsDir,
+        diffOptions: {
+            diffThreshold: threshold,
+            diffPixelThreshold: pixelThreshold,
+        },
         exitOnMismatch: true,
     });
 };
@@ -109,12 +162,8 @@ exports.screenshotDiff = {
             demandOption: true,
             alias: "headReplayId",
         },
-        threshold: {
-            number: true,
-        },
-        pixelThreshold: {
-            number: true,
-        },
+        threshold: common_options_1.SCREENSHOT_DIFF_OPTIONS.diffThreshold,
+        pixelThreshold: common_options_1.SCREENSHOT_DIFF_OPTIONS.diffPixelThreshold,
     },
     handler: (0, sentry_utils_1.wrapHandler)(handler),
 };

package/dist/config/config.js

@@ -22,14 +22,13 @@ const getConfigFilePath = async () => {
     return configFilePath;
 };
 const validateReplayOptions = (prevOptions) => {
-    const { screenshotSelector, diffThreshold, diffPixelThreshold, cookies, moveBeforeClick, useAssetsFromReplayId, } = prevOptions;
+    const { screenshotSelector, diffThreshold, diffPixelThreshold, moveBeforeClick, simulationIdForAssets, } = prevOptions;
     return {
         ...(screenshotSelector ? { screenshotSelector } : {}),
         ...(diffThreshold ? { diffThreshold } : {}),
         ...(diffPixelThreshold ? { diffPixelThreshold } : {}),
-        ...(cookies ? { cookies } : {}),
         ...(moveBeforeClick ? { moveBeforeClick } : {}),
-        ...(useAssetsFromReplayId ? { useAssetsFromReplayId } : {}),
+        ...(simulationIdForAssets ? { simulationIdForAssets } : {}),
     };
 };
 const validateConfig = (prevConfig) => {

package/dist/config/config.types.d.ts

@@ -1,19 +1,18 @@
-export interface ReplayOptions {
-    screenshotSelector?: string;
-    diffThreshold?: number;
-    diffPixelThreshold?: number;
-    cookies?: Record<string, any>[];
-    moveBeforeClick?: boolean;
+import { ScreenshotDiffOptions } from "../command-utils/common-types";
+export interface TestCaseReplayOptions extends Partial<ScreenshotDiffOptions> {
+    appUrl?: string | null | undefined;
     /**
      * If present will run the session against a local server serving up previously snapshotted assets (HTML, JS, CSS etc.) from the specified prior replay, instead of against a URL.
      */
-    useAssetsFromReplayId?: string;
+    simulationIdForAssets?: string | undefined;
+    screenshotSelector?: string;
+    moveBeforeClick?: boolean;
 }
 export interface TestCase {
     title: string;
     sessionId: string;
     baseReplayId: string;
-    options?: ReplayOptions;
+    options?: TestCaseReplayOptions;
 }
 export interface MeticulousCliConfig {
     testCases?: TestCase[];

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

@@ -1,7 +1,16 @@
-import { ReplayCommandHandlerOptions } from "../commands/replay/replay.command";
+import { ReplayExecutionOptions, ReplayTarget } from "@alwaysmeticulous/common/dist/types/replay.types";
+import { ScreenshotAssertionsEnabledOptions } from "../command-utils/common-types";
 import { TestCase, TestCaseResult } from "../config/config.types";
-export interface DeflakeReplayCommandHandlerOptions extends ReplayCommandHandlerOptions {
-    testCase: TestCase;
+export interface DeflakeReplayCommandHandlerOptions extends HandleReplayOptions {
     deflake: boolean;
 }
+interface HandleReplayOptions {
+    replayTarget: ReplayTarget;
+    executionOptions: ReplayExecutionOptions;
+    screenshottingOptions: ScreenshotAssertionsEnabledOptions;
+    testCase: TestCase;
+    apiToken: string | undefined;
+    commitSha: string;
+}
 export declare const deflakeReplayCommandHandler: (options: DeflakeReplayCommandHandlerOptions) => Promise<TestCaseResult>;
+export {};

package/dist/deflake-tests/deflake-tests.handler.js

@@ -8,9 +8,21 @@ const common_1 = require("@alwaysmeticulous/common");
 const loglevel_1 = __importDefault(require("loglevel"));
 const replay_command_1 = require("../commands/replay/replay.command");
 const screenshot_diff_command_1 = require("../commands/screenshot-diff/screenshot-diff.command");
-const handleReplay = async ({ testCase, options }) => {
+const handleReplay = async ({ testCase, replayTarget, executionOptions, screenshottingOptions, apiToken, commitSha, }) => {
+    var _a, _b;
     const logger = loglevel_1.default.getLogger(common_1.METICULOUS_LOGGER_NAME);
-    const replayPromise = (0, replay_command_1.replayCommandHandler)(options);
+    const replayPromise = (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,
+        baseSimulationId: testCase.baseReplayId,
+        save: false,
+        exitOnMismatch: false,
+        cookiesFile: undefined,
+    });
     const result = await replayPromise
         .then((replay) => ({
         ...testCase,
@@ -30,18 +42,41 @@ const handleReplay = async ({ testCase, options }) => {
     });
     return result;
 };
-const deflakeReplayCommandHandler = async ({ testCase, deflake, ...options }) => {
+const deflakeReplayCommandHandler = async ({ deflake, ...otherOptions }) => {
     const logger = loglevel_1.default.getLogger(common_1.METICULOUS_LOGGER_NAME);
-    const firstResult = await handleReplay({ testCase, options });
+    const firstResult = await handleReplay(otherOptions);
     if (firstResult.result === "pass" || !deflake) {
         return firstResult;
     }
-    const secondResult = await handleReplay({ testCase, options });
+    const secondResult = await handleReplay(otherOptions);
     if (secondResult.result === "fail") {
         return secondResult;
     }
-    const thirdResult = await handleReplay({ testCase, options });
+    const thirdResult = await handleReplay(otherOptions);
     logger.info(`FLAKE: ${thirdResult.title} => ${thirdResult.result}`);
     return thirdResult;
 };
 exports.deflakeReplayCommandHandler = deflakeReplayCommandHandler;
+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, _c;
+    // 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,
+        screenshotSelector: (_c = overridesFromTestCase.screenshotSelector) !== null && _c !== void 0 ? _c : screenshottingOptionsFromCliFlags.screenshotSelector,
+        diffOptions,
+    };
+};

package/dist/image/diff.utils.d.ts

@@ -2,9 +2,14 @@ import { PNG } from "pngjs";
 export interface CompareImageOptions {
     base: PNG;
     head: PNG;
-    pixelmatchOptions?: {
-        threshold: number;
-    };
+    /**
+     * Maximum colour distance a given pixel is allowed to differ before counting two
+     * pixels as different.
+     *
+     * Measure is based on "Measuring perceived color difference using YIQ NTSC transmission color space
+     * in mobile applications" by Y. Kotsarenko and F. Ramos
+     */
+    pixelThreshold: number;
 }
 export interface CompareImageResult {
     mismatchPixels: number;

package/dist/image/diff.utils.js

@@ -6,15 +6,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.compareImages = void 0;
 const pixelmatch_1 = __importDefault(require("pixelmatch"));
 const pngjs_1 = require("pngjs");
-const compareImages = ({ base, head, pixelmatchOptions }) => {
+const compareImages = ({ base, head, pixelThreshold }) => {
     if (base.width !== head.width || base.height !== head.height) {
         throw new Error("Cannot handle different size yet");
     }
     const { width, height } = base;
     const diff = new pngjs_1.PNG({ width, height });
-    const threshold = (pixelmatchOptions === null || pixelmatchOptions === void 0 ? void 0 : pixelmatchOptions.threshold) || 0.01;
     const mismatchPixels = (0, pixelmatch_1.default)(base.data, head.data, diff.data, width, height, {
-        threshold,
+        threshold: pixelThreshold,
     });
     const mismatchFraction = mismatchPixels / (width * height);
     return {

package/dist/local-data/replays.d.ts

@@ -1,7 +1,7 @@
 import { AxiosInstance } from "axios";
-import { PNG } from "pngjs";
 export declare const getOrFetchReplay: (client: AxiosInstance, replayId: string) => Promise<any>;
 export declare const getOrFetchReplayArchive: (client: AxiosInstance, replayId: string) => Promise<void>;
-export declare const readReplayScreenshot: (replayId: string) => Promise<PNG>;
-export declare const readLocalReplayScreenshot: (tempDir: string) => Promise<PNG>;
+export declare const getScreenshotFiles: (screenshotsDirPath: string) => Promise<string[]>;
 export declare const getSnapshottedAssetsDir: (replayId: string) => string;
+export declare const getScreenshotsDir: (replayDir: string) => string;
+export declare const getReplayDir: (replayId: string) => string;

package/dist/local-data/replays.js

@@ -3,21 +3,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSnapshottedAssetsDir = exports.readLocalReplayScreenshot = exports.readReplayScreenshot = exports.getOrFetchReplayArchive = exports.getOrFetchReplay = void 0;
+exports.getReplayDir = exports.getScreenshotsDir = exports.getSnapshottedAssetsDir = exports.getScreenshotFiles = exports.getOrFetchReplayArchive = exports.getOrFetchReplay = void 0;
 const common_1 = require("@alwaysmeticulous/common");
 const adm_zip_1 = __importDefault(require("adm-zip"));
 const promises_1 = require("fs/promises");
+const promises_2 = require("fs/promises");
 const loglevel_1 = __importDefault(require("loglevel"));
 const path_1 = require("path");
 const download_1 = require("../api/download");
 const replay_api_1 = require("../api/replay.api");
-const io_utils_1 = require("../image/io.utils");
 const getOrFetchReplay = async (client, replayId) => {
     const logger = loglevel_1.default.getLogger(common_1.METICULOUS_LOGGER_NAME);
-    const replayDir = getReplayDir(replayId);
-    await (0, promises_1.mkdir)(replayDir, { recursive: true });
+    const replayDir = (0, exports.getReplayDir)(replayId);
+    await (0, promises_2.mkdir)(replayDir, { recursive: true });
     const replayFile = (0, path_1.join)(replayDir, `${replayId}.json`);
-    const existingReplay = await (0, promises_1.readFile)(replayFile)
+    const existingReplay = await (0, promises_2.readFile)(replayFile)
         .then((data) => JSON.parse(data.toString("utf-8")))
         .catch(() => null);
     if (existingReplay) {
@@ -29,20 +29,20 @@ const getOrFetchReplay = async (client, replayId) => {
         logger.error(`Error: Could not retrieve replay with id "${replayId}". Is the API token correct?`);
         process.exit(1);
     }
-    await (0, promises_1.writeFile)(replayFile, JSON.stringify(replay, null, 2));
+    await (0, promises_2.writeFile)(replayFile, JSON.stringify(replay, null, 2));
     logger.debug(`Wrote replay to ${replayFile}`);
     return replay;
 };
 exports.getOrFetchReplay = getOrFetchReplay;
 const getOrFetchReplayArchive = async (client, replayId) => {
     const logger = loglevel_1.default.getLogger(common_1.METICULOUS_LOGGER_NAME);
-    const replayDir = getReplayDir(replayId);
-    await (0, promises_1.mkdir)(replayDir, { recursive: true });
+    const replayDir = (0, exports.getReplayDir)(replayId);
+    await (0, promises_2.mkdir)(replayDir, { recursive: true });
     const replayArchiveFile = (0, path_1.join)(replayDir, `${replayId}.zip`);
     const paramsFile = (0, path_1.join)(replayDir, "replayEventsParams.json");
     // Check if "replayEventsParams.json" exists. If yes, we assume the replay
     // zip archive has been downloaded and extracted.
-    const paramsFileExists = await (0, promises_1.access)(paramsFile)
+    const paramsFileExists = await (0, promises_2.access)(paramsFile)
         .then(() => true)
         .catch(() => false);
     if (paramsFileExists) {
@@ -57,23 +57,25 @@ const getOrFetchReplayArchive = async (client, replayId) => {
     await (0, download_1.downloadFile)(downloadUrlData.dowloadUrl, replayArchiveFile);
     const zipFile = new adm_zip_1.default(replayArchiveFile);
     zipFile.extractAllTo(replayDir, /*overwrite=*/ true);
-    await (0, promises_1.rm)(replayArchiveFile);
+    await (0, promises_2.rm)(replayArchiveFile);
     logger.debug(`Exrtracted replay archive in ${replayDir}`);
 };
 exports.getOrFetchReplayArchive = getOrFetchReplayArchive;
-const readReplayScreenshot = async (replayId) => {
-    const replayDir = getReplayDir(replayId);
-    const screenshotFile = (0, path_1.join)(replayDir, "screenshots", "final-state.png");
-    const png = await (0, io_utils_1.readPng)(screenshotFile);
-    return png;
-};
-exports.readReplayScreenshot = readReplayScreenshot;
-const readLocalReplayScreenshot = async (tempDir) => {
-    const screenshotFile = (0, path_1.join)(tempDir, "screenshots", "final-state.png");
-    const png = await (0, io_utils_1.readPng)(screenshotFile);
-    return png;
+const getScreenshotFiles = async (screenshotsDirPath) => {
+    const screenshotFiles = [];
+    const screenshotsDir = await (0, promises_1.opendir)(screenshotsDirPath);
+    for await (const dirEntry of screenshotsDir) {
+        if (dirEntry.isFile() && dirEntry.name.endsWith(".png")) {
+            screenshotFiles.push(dirEntry.name);
+        }
+    }
+    // Sort files alphabetically to help when reading results.
+    return screenshotFiles.sort();
 };
-exports.readLocalReplayScreenshot = readLocalReplayScreenshot;
-const getSnapshottedAssetsDir = (replayId) => (0, path_1.join)(getReplayDir(replayId), "snapshotted-assets");
+exports.getScreenshotFiles = getScreenshotFiles;
+const getSnapshottedAssetsDir = (replayId) => (0, path_1.join)((0, exports.getReplayDir)(replayId), "snapshotted-assets");
 exports.getSnapshottedAssetsDir = getSnapshottedAssetsDir;
+const getScreenshotsDir = (replayDir) => (0, path_1.join)(replayDir, "screenshots");
+exports.getScreenshotsDir = getScreenshotsDir;
 const getReplayDir = (replayId) => (0, path_1.join)((0, common_1.getMeticulousLocalDataDir)(), "replays", replayId);
+exports.getReplayDir = getReplayDir;

package/dist/local-data/screenshot-diffs.d.ts

@@ -2,5 +2,6 @@ import { PNG } from "pngjs";
 export declare const writeScreenshotDiff: (options: {
     baseReplayId: string;
     headReplayId: string;
+    screenshotFileName: string;
     diff: PNG;
 }) => Promise<void>;

package/dist/local-data/screenshot-diffs.js

@@ -9,11 +9,11 @@ const promises_1 = require("fs/promises");
 const path_1 = require("path");
 const loglevel_1 = __importDefault(require("loglevel"));
 const io_utils_1 = require("../image/io.utils");
-const writeScreenshotDiff = async ({ baseReplayId, headReplayId, diff }) => {
+const writeScreenshotDiff = async ({ baseReplayId, headReplayId, screenshotFileName, diff, }) => {
     const logger = loglevel_1.default.getLogger(common_1.METICULOUS_LOGGER_NAME);
     const diffDir = (0, path_1.join)((0, common_1.getMeticulousLocalDataDir)(), "screenshot-diffs");
     await (0, promises_1.mkdir)(diffDir, { recursive: true });
-    const diffFile = (0, path_1.join)(diffDir, `${baseReplayId}+${headReplayId}.png`);
+    const diffFile = (0, path_1.join)(diffDir, `${baseReplayId}+${headReplayId}+${screenshotFileName}.png`);
     await (0, io_utils_1.writePng)(diff, diffFile);
     logger.debug(`Screenshot diff written to ${diffFile}`);
 };

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

@@ -1,27 +1,12 @@
 import log from "loglevel";
-import { TestCase, TestCaseResult } from "../config/config.types";
+import { TestCaseResult } from "../config/config.types";
+import { DeflakeReplayCommandHandlerOptions } from "../deflake-tests/deflake-tests.handler";
 export interface InitMessage {
     kind: "init";
     data: {
         logLevel: log.LogLevel[keyof log.LogLevel];
         dataDir: string;
-        runAllOptions: {
-            apiToken: string | null | undefined;
-            commitSha: string | null | undefined;
-            appUrl: string | null | undefined;
-            simulationIdForAssets?: string | null | undefined;
-            headless: boolean | null | undefined;
-            devTools: boolean | null | undefined;
-            bypassCSP: boolean | null | undefined;
-            diffThreshold: number | null | undefined;
-            diffPixelThreshold: number | null | undefined;
-            padTime: boolean;
-            shiftTime: boolean;
-            networkStubbing: boolean;
-            accelerate: boolean;
-        };
-        testCase: TestCase;
-        deflake: boolean;
+        replayOptions: DeflakeReplayCommandHandlerOptions;
     };
 }
 export interface ResultMessage {

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

@@ -1,26 +1,21 @@
+import { ReplayExecutionOptions } from "@alwaysmeticulous/common";
 import { AxiosInstance } from "axios";
 import { TestRun } from "../api/test-run.api";
+import { ScreenshotAssertionsEnabledOptions } from "../command-utils/common-types";
 import { MeticulousCliConfig, TestCaseResult } from "../config/config.types";
 export interface RunAllTestsInParallelOptions {
     config: MeticulousCliConfig;
     client: AxiosInstance;
     testRun: TestRun;
-    apiToken: string | null | undefined;
-    commitSha: string | null | undefined;
-    appUrl: string | null | undefined;
-    useAssetsSnapshottedInBaseSimulation?: boolean | null | undefined;
-    headless: boolean | null | undefined;
-    devTools: boolean | null | undefined;
-    bypassCSP: boolean | null | undefined;
-    diffThreshold: number | null | undefined;
-    diffPixelThreshold: number | null | undefined;
-    padTime: boolean;
-    shiftTime: boolean;
-    networkStubbing: boolean;
-    parallelTasks: number | null | undefined;
+    executionOptions: ReplayExecutionOptions;
+    screenshottingOptions: ScreenshotAssertionsEnabledOptions;
+    apiToken: string | undefined;
+    commitSha: string;
+    appUrl: string | undefined;
+    useAssetsSnapshottedInBaseSimulation: boolean;
+    parallelTasks: number | undefined;
     deflake: boolean;
     cachedTestRunResults: TestCaseResult[];
-    accelerate: boolean;
 }
 /** Handler for running Meticulous tests in parallel using child processes */
 export declare const runAllTestsInParallel: (options: RunAllTestsInParallelOptions) => Promise<TestCaseResult[]>;

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

@@ -13,7 +13,7 @@ const test_run_api_1 = require("../api/test-run.api");
 const config_utils_1 = require("../utils/config.utils");
 const run_all_tests_utils_1 = require("../utils/run-all-tests.utils");
 /** Handler for running Meticulous tests in parallel using child processes */
-const runAllTestsInParallel = async ({ config, client, testRun, apiToken, commitSha, appUrl, useAssetsSnapshottedInBaseSimulation, headless, devTools, bypassCSP, diffThreshold, diffPixelThreshold, padTime, shiftTime, networkStubbing, parallelTasks, deflake, cachedTestRunResults, accelerate, }) => {
+const runAllTestsInParallel = async ({ config, client, testRun, apiToken, commitSha, appUrl, useAssetsSnapshottedInBaseSimulation, executionOptions, screenshottingOptions, parallelTasks, deflake, cachedTestRunResults, }) => {
     const logger = loglevel_1.default.getLogger(common_1.METICULOUS_LOGGER_NAME);
     const results = [...cachedTestRunResults];
     const queue = (0, run_all_tests_utils_1.getTestsToRun)({
@@ -58,23 +58,19 @@ const runAllTestsInParallel = async ({ config, client, testRun, apiToken, commit
             data: {
                 logLevel: logger.getLevel(),
                 dataDir: (0, common_1.getMeticulousLocalDataDir)(),
-                runAllOptions: {
+                replayOptions: {
                     apiToken,
                     commitSha,
-                    appUrl,
-                    headless,
-                    devTools,
-                    bypassCSP,
-                    diffThreshold,
-                    diffPixelThreshold,
-                    padTime,
-                    shiftTime,
-                    networkStubbing,
-                    simulationIdForAssets: (0, config_utils_1.getSimulationIdForAssets)(testCase, useAssetsSnapshottedInBaseSimulation),
-                    accelerate,
+                    testCase,
+                    deflake,
+                    replayTarget: (0, config_utils_1.getReplayTargetForTestCase)({
+                        useAssetsSnapshottedInBaseSimulation,
+                        appUrl,
+                        testCase,
+                    }),
+                    executionOptions,
+                    screenshottingOptions,
                 },
-                testCase,
-                deflake,
             },
         };
         child.send(initMessage);

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

@@ -38,34 +38,10 @@ const main = async () => {
         process.exit(1);
     }
     const initMessage = await waitForInitMessage();
-    const { logLevel, dataDir, runAllOptions, testCase, deflake } = initMessage.data;
+    const { logLevel, dataDir, replayOptions } = initMessage.data;
     logger.setLevel(logLevel);
     (0, common_1.setMeticulousLocalDataDir)(dataDir);
-    const { apiToken, commitSha, appUrl, simulationIdForAssets, headless, devTools, bypassCSP, diffThreshold, diffPixelThreshold, padTime, shiftTime, networkStubbing, accelerate, } = runAllOptions;
-    const { sessionId, baseReplayId, options } = testCase;
-    const result = await (0, deflake_tests_handler_1.deflakeReplayCommandHandler)({
-        testCase,
-        deflake,
-        apiToken,
-        commitSha,
-        sessionId,
-        appUrl,
-        simulationIdForAssets,
-        headless,
-        devTools,
-        bypassCSP,
-        screenshot: true,
-        baseSimulationId: baseReplayId,
-        diffThreshold,
-        diffPixelThreshold,
-        save: false,
-        exitOnMismatch: false,
-        padTime,
-        shiftTime,
-        networkStubbing,
-        accelerate,
-        ...options,
-    });
+    const result = await (0, deflake_tests_handler_1.deflakeReplayCommandHandler)(replayOptions);
     const resultMessage = {
         kind: "result",
         data: {