@alwaysmeticulous/cli 1.4.1 → 1.5.1

package/dist/local-data/replays.js

@@ -7,11 +7,13 @@ exports.readLocalReplayScreenshot = exports.readReplayScreenshot = exports.getOr
 const common_1 = require("@alwaysmeticulous/common");
 const adm_zip_1 = __importDefault(require("adm-zip"));
 const promises_1 = 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 = (0, path_1.join)((0, common_1.getMeticulousLocalDataDir)(), "replays", replayId);
     await (0, promises_1.mkdir)(replayDir, { recursive: true });
     const replayFile = (0, path_1.join)(replayDir, `${replayId}.json`);
@@ -19,20 +21,21 @@ const getOrFetchReplay = async (client, replayId) => {
         .then((data) => JSON.parse(data.toString("utf-8")))
         .catch(() => null);
     if (existingReplay) {
-        console.log(`Reading replay from local copy in ${replayFile}`);
+        logger.debug(`Reading replay from local copy in ${replayFile}`);
         return existingReplay;
     }
     const replay = await (0, replay_api_1.getReplay)(client, replayId);
     if (!replay) {
-        console.error("Error: Could not retrieve replay. Is the API token correct?");
+        logger.error("Error: Could not retrieve replay. Is the API token correct?");
         process.exit(1);
     }
     await (0, promises_1.writeFile)(replayFile, JSON.stringify(replay, null, 2));
-    console.log(`Wrote replay to ${replayFile}`);
+    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 = (0, path_1.join)((0, common_1.getMeticulousLocalDataDir)(), "replays", replayId);
     await (0, promises_1.mkdir)(replayDir, { recursive: true });
     const replayArchiveFile = (0, path_1.join)(replayDir, `${replayId}.zip`);
@@ -43,19 +46,19 @@ const getOrFetchReplayArchive = async (client, replayId) => {
         .then(() => true)
         .catch(() => false);
     if (paramsFileExists) {
-        console.log(`Replay archive already downloaded at ${replayDir}`);
+        logger.debug(`Replay archive already downloaded at ${replayDir}`);
         return;
     }
     const dowloadUrlData = await (0, replay_api_1.getReplayDownloadUrl)(client, replayId);
     if (!dowloadUrlData) {
-        console.error("Error: Could not retrieve replay archive URL. This may be an invalid replay");
+        logger.error("Error: Could not retrieve replay archive URL. This may be an invalid replay");
         process.exit(1);
     }
     await (0, download_1.downloadFile)(dowloadUrlData.dowloadUrl, replayArchiveFile);
     const zipFile = new adm_zip_1.default(replayArchiveFile);
     zipFile.extractAllTo(replayDir, /*overwrite=*/ true);
     await (0, promises_1.rm)(replayArchiveFile);
-    console.log(`Exrtracted replay archive in ${replayDir}`);
+    logger.debug(`Exrtracted replay archive in ${replayDir}`);
 };
 exports.getOrFetchReplayArchive = getOrFetchReplayArchive;
 const readReplayScreenshot = async (replayId) => {

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

@@ -1,15 +1,20 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.writeScreenshotDiff = void 0;
 const common_1 = require("@alwaysmeticulous/common");
 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 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`);
     await (0, io_utils_1.writePng)(diff, diffFile);
-    console.log(`Screenshot diff written to ${diffFile}`);
+    logger.debug(`Screenshot diff written to ${diffFile}`);
 };
 exports.writeScreenshotDiff = writeScreenshotDiff;

package/dist/local-data/sessions.js

@@ -1,12 +1,17 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getOrFetchRecordedSessionData = exports.getOrFetchRecordedSession = void 0;
 const common_1 = require("@alwaysmeticulous/common");
 const promises_1 = require("fs/promises");
+const loglevel_1 = __importDefault(require("loglevel"));
 const path_1 = require("path");
 const session_api_1 = require("../api/session.api");
 const local_data_utils_1 = require("./local-data.utils");
 const getOrFetchRecordedSession = async (client, sessionId) => {
+    const logger = loglevel_1.default.getLogger(common_1.METICULOUS_LOGGER_NAME);
     const sessionsDir = (0, path_1.join)((0, common_1.getMeticulousLocalDataDir)(), "sessions");
     await (0, promises_1.mkdir)(sessionsDir, { recursive: true });
     const sessionFile = (0, path_1.join)(sessionsDir, `${(0, local_data_utils_1.sanitizeFilename)(sessionId)}.json`);
@@ -14,20 +19,21 @@ const getOrFetchRecordedSession = async (client, sessionId) => {
         .then((data) => JSON.parse(data.toString("utf-8")))
         .catch(() => null);
     if (existingSession) {
-        console.log(`Reading session from local copy in ${sessionFile}`);
+        logger.debug(`Reading session from local copy in ${sessionFile}`);
         return existingSession;
     }
     const session = await (0, session_api_1.getRecordedSession)(client, sessionId);
     if (!session) {
-        console.error("Error: Could not retrieve session. Is the API token correct?");
+        logger.error("Error: Could not retrieve session. Is the API token correct?");
         process.exit(1);
     }
     await (0, promises_1.writeFile)(sessionFile, JSON.stringify(session, null, 2));
-    console.log(`Wrote session to ${sessionFile}`);
+    logger.debug(`Wrote session to ${sessionFile}`);
     return session;
 };
 exports.getOrFetchRecordedSession = getOrFetchRecordedSession;
 const getOrFetchRecordedSessionData = async (client, sessionId) => {
+    const logger = loglevel_1.default.getLogger(common_1.METICULOUS_LOGGER_NAME);
     const sessionsDir = (0, path_1.join)((0, common_1.getMeticulousLocalDataDir)(), "sessions");
     await (0, promises_1.mkdir)(sessionsDir, { recursive: true });
     const sessionDataFile = (0, path_1.join)(sessionsDir, `${(0, local_data_utils_1.sanitizeFilename)(sessionId)}_data.json`);
@@ -35,16 +41,16 @@ const getOrFetchRecordedSessionData = async (client, sessionId) => {
         .then((data) => JSON.parse(data.toString("utf-8")))
         .catch(() => null);
     if (existingSessionData) {
-        console.log(`Reading session data from local copy in ${sessionDataFile}`);
+        logger.debug(`Reading session data from local copy in ${sessionDataFile}`);
         return existingSessionData;
     }
     const sessionData = await (0, session_api_1.getRecordedSessionData)(client, sessionId);
     if (!sessionData) {
-        console.error("Error: Could not retrieve session data. This may be an invalid session");
+        logger.error("Error: Could not retrieve session data. This may be an invalid session");
         process.exit(1);
     }
     await (0, promises_1.writeFile)(sessionDataFile, JSON.stringify(sessionData, null, 2));
-    console.log(`Wrote session data to ${sessionDataFile}`);
+    logger.debug(`Wrote session data to ${sessionDataFile}`);
     return sessionData;
 };
 exports.getOrFetchRecordedSessionData = getOrFetchRecordedSessionData;

package/dist/main.js

@@ -15,11 +15,13 @@ const run_all_tests_command_1 = require("./commands/run-all-tests/run-all-tests.
 const screenshot_diff_command_1 = require("./commands/screenshot-diff/screenshot-diff.command");
 const show_project_command_1 = require("./commands/show-project/show-project.command");
 const upload_build_command_1 = require("./commands/upload-build/upload-build.command");
+const logger_utils_1 = require("./utils/logger.utils");
 const sentry_utils_1 = require("./utils/sentry.utils");
 const handleDataDir = (dataDir) => {
     (0, common_1.getMeticulousLocalDataDir)(dataDir);
 };
 const main = () => {
+    (0, logger_utils_1.initLogger)();
     (0, sentry_utils_1.initSentry)();
     const promise = yargs_1.default
         .scriptName("meticulous")
@@ -39,12 +41,17 @@ const main = () => {
         .strict()
         .demandCommand()
         .option({
+        logLevel: {
+            choices: ["trace", "debug", "info", "warn", "error", "silent"],
+            description: "Log level",
+        },
         dataDir: {
             string: true,
             description: "Where Meticulous stores data (sessions, replays, etc.)",
         },
     })
         .middleware([
+        (argv) => (0, logger_utils_1.setLogLevel)(argv.logLevel),
         (argv) => handleDataDir(argv.dataDir),
         (argv) => (0, sentry_utils_1.setOptions)(argv),
     ]).argv;

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

@@ -0,0 +1,28 @@
+import log from "loglevel";
+import { TestCase, TestCaseResult } from "../config/config.types";
+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;
+            headless: boolean | null | undefined;
+            devTools: boolean | null | undefined;
+            bypassCSP: boolean | null | undefined;
+            diffThreshold: number | null | undefined;
+            diffPixelThreshold: number | null | undefined;
+            padTime: boolean;
+            networkStubbing: boolean;
+        };
+        testCase: TestCase;
+    };
+}
+export interface ResultMessage {
+    kind: "result";
+    data: {
+        result: TestCaseResult;
+    };
+}

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

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

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

@@ -0,0 +1,21 @@
+import { AxiosInstance } from "axios";
+import { TestRun } from "../api/test-run.api";
+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;
+    headless: boolean | null | undefined;
+    devTools: boolean | null | undefined;
+    bypassCSP: boolean | null | undefined;
+    diffThreshold: number | null | undefined;
+    diffPixelThreshold: number | null | undefined;
+    padTime: boolean;
+    networkStubbing: boolean;
+    parallelTasks: number | null | undefined;
+}
+/** 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

@@ -0,0 +1,120 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAllTestsInParallel = void 0;
+const common_1 = require("@alwaysmeticulous/common");
+const child_process_1 = require("child_process");
+const loglevel_1 = __importDefault(require("loglevel"));
+const os_1 = require("os");
+const path_1 = require("path");
+const test_run_api_1 = require("../api/test-run.api");
+/** Handler for running Meticulous tests in parallel using child processes */
+const runAllTestsInParallel = async ({ config, client, testRun, apiToken, commitSha, appUrl, headless, devTools, bypassCSP, diffThreshold, diffPixelThreshold, padTime, networkStubbing, parallelTasks, }) => {
+    const logger = loglevel_1.default.getLogger(common_1.METICULOUS_LOGGER_NAME);
+    const results = [];
+    const queue = [...(config.testCases || [])];
+    const allTasksDone = (0, common_1.defer)();
+    let inProgress = 0;
+    const maxTasks = parallelTasks !== null && parallelTasks !== void 0 ? parallelTasks : Math.max((0, os_1.cpus)().length, 1);
+    logger.debug(`Running with ${maxTasks} maximum tasks in parallel`);
+    const taskHandler = (0, path_1.join)(__dirname, "task.handler.js");
+    // Starts running a test case in a child process
+    const startTask = (testCase) => {
+        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
+        const initMessage = {
+            kind: "init",
+            data: {
+                logLevel: logger.getLevel(),
+                dataDir: (0, common_1.getMeticulousLocalDataDir)(),
+                runAllOptions: {
+                    apiToken,
+                    commitSha,
+                    appUrl,
+                    headless,
+                    devTools,
+                    bypassCSP,
+                    diffThreshold,
+                    diffPixelThreshold,
+                    padTime,
+                    networkStubbing,
+                },
+                testCase,
+            },
+        };
+        child.send(initMessage);
+        // Handle task completion
+        deferredResult.promise
+            .catch(() => {
+            const result = {
+                ...testCase,
+                headReplayId: "",
+                result: "fail",
+            };
+            return result;
+        })
+            .then(async (result) => {
+            --inProgress;
+            results.push(result);
+            (0, test_run_api_1.putTestRunResults)({
+                client,
+                testRunId: testRun.id,
+                status: "Running",
+                resultData: { results },
+            })
+                .catch((error) => {
+                logger.error(`Error while pushing partial results: ${error}`);
+            })
+                .then(() => {
+                var _a;
+                if (results.length === (((_a = config.testCases) === null || _a === void 0 ? void 0 : _a.length) || 0)) {
+                    allTasksDone.resolve();
+                }
+            });
+            process.nextTick(checkNextTask);
+        });
+    };
+    // Checks if we can start a new child process
+    const checkNextTask = () => {
+        if (inProgress >= maxTasks) {
+            return;
+        }
+        const testCase = queue.shift();
+        if (!testCase) {
+            return;
+        }
+        ++inProgress;
+        startTask(testCase);
+        process.nextTick(checkNextTask);
+    };
+    process.nextTick(checkNextTask);
+    await allTasksDone.promise;
+    return results;
+};
+exports.runAllTestsInParallel = runAllTestsInParallel;

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const common_1 = require("@alwaysmeticulous/common");
+const loglevel_1 = __importDefault(require("loglevel"));
+const luxon_1 = require("luxon");
+const replay_command_1 = require("../commands/replay/replay.command");
+const screenshot_diff_command_1 = require("../commands/screenshot-diff/screenshot-diff.command");
+const logger_utils_1 = require("../utils/logger.utils");
+const INIT_TIMEOUT = luxon_1.Duration.fromObject({ second: 1 });
+const waitForInitMessage = () => {
+    return Promise.race([
+        new Promise((resolve) => {
+            const messageHandler = (message) => {
+                if (message &&
+                    typeof message === "object" &&
+                    message["kind"] === "init") {
+                    const initMessage = message;
+                    resolve(initMessage);
+                    process.off("message", messageHandler);
+                }
+            };
+            process.on("message", messageHandler);
+        }),
+        new Promise((_resolve, reject) => {
+            setTimeout(() => {
+                reject(new Error("Timed out waiting for init message"));
+            }, INIT_TIMEOUT.toMillis());
+        }),
+    ]);
+};
+const main = async () => {
+    (0, logger_utils_1.initLogger)();
+    const logger = loglevel_1.default.getLogger(common_1.METICULOUS_LOGGER_NAME);
+    if (!process.send) {
+        console.error("Error: not started as a child process");
+        process.exit(1);
+    }
+    const initMessage = await waitForInitMessage();
+    const { logLevel, dataDir, runAllOptions, testCase } = initMessage.data;
+    logger.setLevel(logLevel);
+    (0, common_1.getMeticulousLocalDataDir)(dataDir);
+    const { apiToken, commitSha, appUrl, headless, devTools, bypassCSP, diffThreshold, diffPixelThreshold, padTime, networkStubbing, } = runAllOptions;
+    const { sessionId, baseReplayId, options } = testCase;
+    const replayPromise = (0, replay_command_1.replayCommandHandler)({
+        apiToken,
+        commitSha,
+        sessionId,
+        appUrl,
+        headless,
+        devTools,
+        bypassCSP,
+        screenshot: true,
+        baseReplayId,
+        diffThreshold,
+        diffPixelThreshold,
+        save: false,
+        exitOnMismatch: false,
+        padTime,
+        networkStubbing,
+        ...options,
+    });
+    const result = await replayPromise
+        .then((replay) => ({
+        ...testCase,
+        headReplayId: replay.id,
+        result: "pass",
+    }))
+        .catch((error) => {
+        if (error instanceof screenshot_diff_command_1.DiffError && error.extras) {
+            return {
+                ...testCase,
+                headReplayId: error.extras.headReplayId,
+                result: "fail",
+            };
+        }
+        logger.error(error);
+        return { ...testCase, headReplayId: "", result: "fail" };
+    });
+    const resultMessage = {
+        kind: "result",
+        data: {
+            result,
+        },
+    };
+    process.send(resultMessage);
+    process.disconnect();
+};
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});