@alwaysmeticulous/cli 2.3.4 → 2.4.0

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,7 +2,14 @@ import { PNG } from "pngjs";
 export interface CompareImageOptions {
     base: PNG;
     head: PNG;
-    pixelThreshold: number | null;
+    /**
+     * 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

@@ -7,17 +7,13 @@ exports.compareImages = void 0;
 const pixelmatch_1 = __importDefault(require("pixelmatch"));
 const pngjs_1 = require("pngjs");
 const compareImages = ({ base, head, pixelThreshold }) => {
-    const pixelmatchOptions = pixelThreshold
-        ? { threshold: pixelThreshold }
-        : null;
     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/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: {