cypress 15.1.0 → 15.3.0

package/dist/exec/versions.js

@@ -0,0 +1,67 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const debug_1 = __importDefault(require("debug"));
+const path_1 = __importDefault(require("path"));
+const util_1 = __importDefault(require("../util"));
+const state_1 = __importDefault(require("../tasks/state"));
+const errors_1 = require("../errors");
+const debug = (0, debug_1.default)('cypress:cli');
+const getBinaryDirectory = () => __awaiter(void 0, void 0, void 0, function* () {
+    if (util_1.default.getEnv('CYPRESS_RUN_BINARY')) {
+        let envBinaryPath = path_1.default.resolve(util_1.default.getEnv('CYPRESS_RUN_BINARY'));
+        try {
+            const envBinaryDir = yield state_1.default.parseRealPlatformBinaryFolderAsync(envBinaryPath);
+            if (!envBinaryDir) {
+                const raiseErrorFn = (0, errors_1.throwFormErrorText)(errors_1.errors.CYPRESS_RUN_BINARY.notValid(envBinaryPath));
+                yield raiseErrorFn();
+            }
+            debug('CYPRESS_RUN_BINARY has binaryDir:', envBinaryDir);
+            return envBinaryDir;
+        }
+        catch (err) {
+            const raiseErrorFn = (0, errors_1.throwFormErrorText)(errors_1.errors.CYPRESS_RUN_BINARY.notValid(envBinaryPath));
+            yield raiseErrorFn(err.message);
+        }
+    }
+    return state_1.default.getBinaryDir();
+});
+const getVersions = () => __awaiter(void 0, void 0, void 0, function* () {
+    const binDir = yield getBinaryDirectory();
+    const pkg = yield state_1.default.getBinaryPkgAsync(binDir);
+    const versions = {
+        binary: state_1.default.getBinaryPkgVersion(pkg),
+        electronVersion: state_1.default.getBinaryElectronVersion(pkg),
+        electronNodeVersion: state_1.default.getBinaryElectronNodeVersion(pkg),
+    };
+    debug('binary versions %o', versions);
+    const buildInfo = util_1.default.pkgBuildInfo();
+    let packageVersion = util_1.default.pkgVersion();
+    if (!buildInfo)
+        packageVersion += ' (development)';
+    else if (!buildInfo.stable)
+        packageVersion += ' (pre-release)';
+    const versionsFinal = {
+        package: packageVersion,
+        binary: versions.binary || 'not installed',
+        electronVersion: versions.electronVersion || 'not found',
+        electronNodeVersion: versions.electronNodeVersion || 'not found',
+    };
+    debug('combined versions %o', versions);
+    return versionsFinal;
+});
+const versionsModule = {
+    getVersions,
+};
+exports.default = versionsModule;

package/dist/exec/xvfb.js

@@ -0,0 +1,118 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const os_1 = __importDefault(require("os"));
+const bluebird_1 = __importDefault(require("bluebird"));
+const xvfb_1 = __importDefault(require("@cypress/xvfb"));
+const common_tags_1 = require("common-tags");
+const debug_1 = __importDefault(require("debug"));
+const errors_1 = require("../errors");
+const util_1 = __importDefault(require("../util"));
+const debug = (0, debug_1.default)('cypress:cli');
+const debugXvfb = (0, debug_1.default)('cypress:xvfb');
+debug.Debug = debugXvfb.Debug = debug_1.default;
+const xvfbOptions = {
+    displayNum: process.env.XVFB_DISPLAY_NUM,
+    timeout: 30000, // milliseconds
+    // need to explicitly define screen otherwise electron will crash
+    // https://github.com/cypress-io/cypress/issues/6184
+    xvfb_args: ['-screen', '0', '1280x1024x24'],
+    onStderrData(data) {
+        if (debugXvfb.enabled) {
+            debugXvfb(data.toString());
+        }
+    },
+};
+const xvfb = bluebird_1.default.promisifyAll(new xvfb_1.default(xvfbOptions));
+const xvfbModule = {
+    _debugXvfb: debugXvfb, // expose for testing
+    _xvfb: xvfb, // expose for testing
+    _xvfbOptions: xvfbOptions, // expose for testing
+    start() {
+        return __awaiter(this, void 0, void 0, function* () {
+            debug('Starting Xvfb');
+            try {
+                yield xvfb.startAsync();
+                return null;
+            }
+            catch (e) {
+                if (e.nonZeroExitCode === true) {
+                    const raiseErrorFn = (0, errors_1.throwFormErrorText)(errors_1.errors.nonZeroExitCodeXvfb);
+                    yield raiseErrorFn(e);
+                }
+                if (e.known) {
+                    throw e;
+                }
+                const raiseErrorFn = (0, errors_1.throwFormErrorText)(errors_1.errors.missingXvfb);
+                yield raiseErrorFn(e);
+            }
+        });
+    },
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            debug('Stopping Xvfb');
+            try {
+                yield xvfb.stopAsync();
+                return null;
+            }
+            catch (e) {
+                return null;
+            }
+        });
+    },
+    isNeeded() {
+        if (process.env.ELECTRON_RUN_AS_NODE) {
+            debug('Environment variable ELECTRON_RUN_AS_NODE detected, xvfb is not needed');
+            return false; // xvfb required for electron processes only.
+        }
+        if (os_1.default.platform() !== 'linux') {
+            return false;
+        }
+        if (process.env.DISPLAY) {
+            const issueUrl = util_1.default.getGitHubIssueUrl(4034);
+            const message = (0, common_tags_1.stripIndent) `
+        DISPLAY environment variable is set to ${process.env.DISPLAY} on Linux
+        Assuming this DISPLAY points at working X11 server,
+        Cypress will not spawn own Xvfb
+
+        NOTE: if the X11 server is NOT working, Cypress will exit without explanation,
+          see ${issueUrl}
+        Solution: Unset the DISPLAY variable and try again:
+          DISPLAY= npx cypress run ...
+      `;
+            debug(message);
+            return false;
+        }
+        debug('undefined DISPLAY environment variable');
+        debug('Cypress will spawn its own Xvfb');
+        return true;
+    },
+    // async method, resolved with Boolean
+    verify() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield xvfb.startAsync();
+                return true;
+            }
+            catch (err) {
+                debug('Could not verify xvfb: %s', err.message);
+                return false;
+            }
+            finally {
+                yield xvfb.stopAsync();
+            }
+        });
+    },
+};
+exports.default = xvfbModule;

package/dist/index.js

@@ -0,0 +1,52 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const minimist_1 = __importDefault(require("minimist"));
+const debug_1 = __importDefault(require("debug"));
+const util_1 = __importDefault(require("./util"));
+const cypress_1 = __importDefault(require("./cypress"));
+const install_1 = __importDefault(require("./tasks/install"));
+const verify_1 = require("./tasks/verify");
+const debugCli = (0, debug_1.default)('cypress:cli');
+const args = (0, minimist_1.default)(process.argv.slice(2));
+// we're being used from the command line
+function handleExec() {
+    return __awaiter(this, void 0, void 0, function* () {
+        switch (args.exec) {
+            case 'install': {
+                debugCli('installing Cypress from NPM');
+                install_1.default.start({ force: args.force })
+                    .catch(util_1.default.logErrorExit1);
+                break;
+            }
+            case 'verify': {
+                // for simple testing in the monorepo
+                debugCli('verifying Cypress');
+                (0, verify_1.start)({ force: true }) // always force verification
+                    .catch(util_1.default.logErrorExit1);
+                break;
+            }
+            default: {
+                break;
+            }
+        }
+    });
+}
+// Execute the async function
+if (args.exec) {
+    handleExec().catch(util_1.default.logErrorExit1);
+}
+else {
+    debugCli('exporting Cypress module interface');
+}
+module.exports = cypress_1.default;

package/dist/index.mjs

@@ -0,0 +1,9 @@
+import module from 'module';
+const require = module.createRequire(import.meta.url);
+const cypress = require('./cypress');
+export default cypress;
+export const defineConfig = cypress.defineConfig;
+export const defineComponentFramework = cypress.defineComponentFramework;
+export const run = cypress.run;
+export const open = cypress.open;
+export const cli = cypress.cli;

package/dist/logger.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk_1 = __importDefault(require("chalk"));
+let logs = [];
+const logLevel = () => {
+    return (process.env.npm_config_loglevel || 'notice');
+};
+const error = (...messages) => {
+    logs.push(messages.join(' '));
+    console.log(chalk_1.default.red(...messages)); // eslint-disable-line no-console
+};
+const warn = (...messages) => {
+    if (logLevel() === 'silent')
+        return;
+    logs.push(messages.join(' '));
+    console.log(chalk_1.default.yellow(...messages)); // eslint-disable-line no-console
+};
+const log = (...messages) => {
+    if (logLevel() === 'silent' || logLevel() === 'warn')
+        return;
+    logs.push(messages.join(' '));
+    console.log(...messages); // eslint-disable-line no-console
+};
+const always = (...messages) => {
+    logs.push(messages.join(' '));
+    console.log(...messages); // eslint-disable-line no-console
+};
+// splits long text into lines and calls log()
+// on each one to allow easy unit testing for specific message
+const logLines = (text) => {
+    const lines = text.split('\n');
+    for (const line of lines) {
+        log(line);
+    }
+};
+const print = () => {
+    return logs.join('\n');
+};
+const reset = () => {
+    logs = [];
+};
+const loggerModule = {
+    log,
+    warn,
+    error,
+    always,
+    logLines,
+    print,
+    reset,
+    logLevel,
+};
+exports.default = loggerModule;

package/dist/tasks/cache.js

@@ -0,0 +1,144 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const state_1 = __importDefault(require("./state"));
+const logger_1 = __importDefault(require("../logger"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const util_1 = __importDefault(require("../util"));
+const path_1 = require("path");
+const cli_table3_1 = __importDefault(require("cli-table3"));
+const dayjs_1 = __importDefault(require("dayjs"));
+const relativeTime_1 = __importDefault(require("dayjs/plugin/relativeTime"));
+const chalk_1 = __importDefault(require("chalk"));
+const lodash_1 = __importDefault(require("lodash"));
+const get_folder_size_1 = __importDefault(require("./get-folder-size"));
+dayjs_1.default.extend(relativeTime_1.default);
+// output colors for the table
+const colors = {
+    titles: chalk_1.default.white,
+    dates: chalk_1.default.cyan,
+    values: chalk_1.default.green,
+    size: chalk_1.default.gray,
+};
+const logCachePath = () => {
+    logger_1.default.always(state_1.default.getCacheDir());
+    return undefined;
+};
+const clear = () => {
+    return fs_extra_1.default.remove(state_1.default.getCacheDir());
+};
+const prune = () => __awaiter(void 0, void 0, void 0, function* () {
+    const cacheDir = state_1.default.getCacheDir();
+    const checkedInBinaryVersion = util_1.default.pkgVersion();
+    let deletedBinary = false;
+    try {
+        const versions = yield fs_extra_1.default.readdir(cacheDir);
+        for (const version of versions) {
+            if (version !== checkedInBinaryVersion) {
+                deletedBinary = true;
+                const versionDir = (0, path_1.join)(cacheDir, version);
+                yield fs_extra_1.default.remove(versionDir);
+            }
+        }
+        if (deletedBinary) {
+            logger_1.default.always(`Deleted all binary caches except for the ${checkedInBinaryVersion} binary cache.`);
+        }
+        else {
+            logger_1.default.always(`No binary caches found to prune.`);
+        }
+    }
+    catch (e) {
+        if (e.code === 'ENOENT') {
+            logger_1.default.always(`No Cypress cache was found at ${cacheDir}. Nothing to prune.`);
+            return;
+        }
+        throw e;
+    }
+});
+const fileSizeInMB = (size) => {
+    return `${(size / 1024 / 1024).toFixed(1)}MB`;
+};
+/**
+ * Collects all cached versions, finds when each was used
+ * and prints a table with results to the terminal
+ */
+const list = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (showSize = false) {
+    const binaries = yield getCachedVersions(showSize);
+    const head = [colors.titles('version'), colors.titles('last used')];
+    if (showSize) {
+        head.push(colors.titles('size'));
+    }
+    const table = new cli_table3_1.default({
+        head,
+    });
+    binaries.forEach((binary) => {
+        const versionString = colors.values(binary.version);
+        const lastUsed = binary.accessed ? colors.dates(binary.accessed) : 'unknown';
+        const row = [versionString, lastUsed];
+        if (showSize) {
+            const size = colors.size(fileSizeInMB(binary.size));
+            row.push(size);
+        }
+        return table.push(row);
+    });
+    logger_1.default.always(table.toString());
+});
+const getCachedVersions = (showSize) => __awaiter(void 0, void 0, void 0, function* () {
+    const cacheDir = state_1.default.getCacheDir();
+    const versions = yield fs_extra_1.default.readdir(cacheDir);
+    const filteredVersions = versions.filter(util_1.default.isSemver).map((version) => {
+        return {
+            version,
+            folderPath: (0, path_1.join)(cacheDir, version),
+        };
+    });
+    const binaries = [];
+    for (const binary of filteredVersions) {
+        const binaryDir = state_1.default.getBinaryDir(binary.version);
+        const executable = state_1.default.getPathToExecutable(binaryDir);
+        try {
+            const stat = yield fs_extra_1.default.stat(executable);
+            const lastAccessedTime = lodash_1.default.get(stat, 'atime');
+            if (lastAccessedTime) {
+                const accessed = (0, dayjs_1.default)(lastAccessedTime).fromNow();
+                // @ts-expect-error - accessed is not defined in the type
+                binary.accessed = accessed;
+            }
+            // if no lastAccessedTime
+            // the test runner has never been opened
+            // or could be a test simulating missing timestamp
+        }
+        catch (e) {
+            // could not find the binary or gets its stats
+            // no-op
+        }
+        if (showSize) {
+            const binaryDir = state_1.default.getBinaryDir(binary.version);
+            const size = yield (0, get_folder_size_1.default)(binaryDir);
+            binaries.push(Object.assign(Object.assign({}, binary), { size }));
+        }
+        else {
+            binaries.push(binary);
+        }
+    }
+    return binaries;
+});
+const cacheModule = {
+    path: logCachePath,
+    clear,
+    prune,
+    list,
+    getCachedVersions,
+};
+exports.default = cacheModule;