cypress 15.1.0 → 15.3.0

package/dist/exec/open.js

@@ -0,0 +1,103 @@
+"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 });
+exports.start = exports.processOpenOptions = void 0;
+const debug_1 = __importDefault(require("debug"));
+const util_1 = __importDefault(require("../util"));
+const spawn_1 = __importDefault(require("./spawn"));
+const verify_1 = require("../tasks/verify");
+const shared_1 = require("./shared");
+const errors_1 = require("../errors");
+const debug = (0, debug_1.default)('cypress:cli');
+/**
+ * Maps options collected by the CLI
+ * and forms list of CLI arguments to the server.
+ *
+ * Note: there is lightweight validation, with errors
+ * thrown synchronously.
+ *
+ * @returns {string[]} list of CLI arguments
+ */
+const processOpenOptions = (options = {}) => {
+    // In addition to setting the project directory, setting the project option
+    // here ultimately decides whether cypress is run in global mode or not.
+    // It's first based off whether it's installed globally by npm/yarn (-g).
+    // A global install can be overridden by the --project flag, putting Cypress
+    // in project mode. A non-global install can be overridden by the --global
+    // flag, putting it in global mode.
+    if (!util_1.default.isInstalledGlobally() && !options.global && !options.project) {
+        options.project = process.cwd();
+    }
+    const args = [];
+    if (options.config) {
+        args.push('--config', options.config);
+    }
+    if (options.configFile !== undefined) {
+        (0, shared_1.checkConfigFile)(options);
+        args.push('--config-file', options.configFile);
+    }
+    if (options.browser) {
+        args.push('--browser', options.browser);
+    }
+    if (options.env) {
+        args.push('--env', options.env);
+    }
+    if (options.port) {
+        args.push('--port', options.port);
+    }
+    if (options.project) {
+        args.push('--project', options.project);
+    }
+    if (options.global) {
+        args.push('--global', options.global);
+    }
+    if (options.inspect) {
+        args.push('--inspect');
+    }
+    if (options.inspectBrk) {
+        args.push('--inspectBrk');
+    }
+    args.push(...(0, shared_1.processTestingType)(options));
+    debug('opening from options %j', options);
+    debug('command line arguments %j', args);
+    return args;
+};
+exports.processOpenOptions = processOpenOptions;
+const start = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (options = {}) {
+    function open() {
+        try {
+            const args = (0, exports.processOpenOptions)(options);
+            return spawn_1.default.start(args, {
+                dev: options.dev,
+                detached: Boolean(options.detached),
+            });
+        }
+        catch (err) {
+            if (err.details) {
+                return (0, errors_1.exitWithError)(err.details)();
+            }
+            throw err;
+        }
+    }
+    if (options.dev) {
+        return open();
+    }
+    yield (0, verify_1.start)();
+    return open();
+});
+exports.start = start;
+exports.default = {
+    start: exports.start,
+    processOpenOptions: exports.processOpenOptions,
+};

package/dist/exec/run.js

@@ -0,0 +1,177 @@
+"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 lodash_1 = __importDefault(require("lodash"));
+const debug_1 = __importDefault(require("debug"));
+const util_1 = __importDefault(require("../util"));
+const spawn_1 = __importDefault(require("./spawn"));
+const verify_1 = require("../tasks/verify");
+const errors_1 = require("../errors");
+const shared_1 = require("./shared");
+const debug = (0, debug_1.default)('cypress:cli:run');
+/**
+ * Typically a user passes a string path to the project.
+ * But "cypress open" allows using `false` to open in global mode,
+ * and the user can accidentally execute `cypress run --project false`
+ * which should be invalid.
+ */
+const isValidProject = (v) => {
+    if (typeof v === 'boolean') {
+        return false;
+    }
+    if (v === '' || v === 'false' || v === 'true') {
+        return false;
+    }
+    return true;
+};
+/**
+ * Maps options collected by the CLI
+ * and forms list of CLI arguments to the server.
+ *
+ * Note: there is lightweight validation, with errors
+ * thrown synchronously.
+ *
+ * @returns {string[]} list of CLI arguments
+ */
+const processRunOptions = (options = {}) => {
+    debug('processing run options %o', options);
+    if (!isValidProject(options.project)) {
+        debug('invalid project option %o', { project: options.project });
+        return (0, shared_1.throwInvalidOptionError)(errors_1.errors.invalidRunProjectPath);
+    }
+    const args = ['--run-project', options.project];
+    if (options.autoCancelAfterFailures || options.autoCancelAfterFailures === 0 || options.autoCancelAfterFailures === false) {
+        args.push('--auto-cancel-after-failures', options.autoCancelAfterFailures);
+    }
+    if (options.browser) {
+        args.push('--browser', options.browser);
+    }
+    if (options.ciBuildId) {
+        args.push('--ci-build-id', options.ciBuildId);
+    }
+    if (options.config) {
+        args.push('--config', options.config);
+    }
+    if (options.configFile !== undefined) {
+        (0, shared_1.checkConfigFile)(options);
+        args.push('--config-file', options.configFile);
+    }
+    if (options.env) {
+        args.push('--env', options.env);
+    }
+    if (options.exit === false) {
+        args.push('--no-exit');
+    }
+    if (options.group) {
+        args.push('--group', options.group);
+    }
+    if (options.headed) {
+        args.push('--headed', options.headed);
+    }
+    if (options.headless) {
+        if (options.headed) {
+            return (0, shared_1.throwInvalidOptionError)(errors_1.errors.incompatibleHeadlessFlags);
+        }
+        args.push('--headed', String(!options.headless));
+    }
+    // if key is set use that - else attempt to find it by environment variable
+    if (options.key == null) {
+        debug('--key is not set, looking up environment variable CYPRESS_RECORD_KEY');
+        options.key = util_1.default.getEnv('CYPRESS_RECORD_KEY');
+    }
+    // if we have a key assume we're in record mode
+    if (options.key) {
+        args.push('--key', options.key);
+    }
+    if (options.outputPath) {
+        args.push('--output-path', options.outputPath);
+    }
+    if (options.parallel) {
+        args.push('--parallel');
+    }
+    if (options.port) {
+        args.push('--port', options.port);
+    }
+    if (options.quiet) {
+        args.push('--quiet');
+    }
+    // if record is defined and we're not
+    // already in ci mode, then send it up
+    if (options.record != null) {
+        args.push('--record', options.record);
+    }
+    // if we have a specific reporter push that into the args
+    if (options.reporter) {
+        args.push('--reporter', options.reporter);
+    }
+    // if we have a specific reporter push that into the args
+    if (options.reporterOptions) {
+        args.push('--reporter-options', options.reporterOptions);
+    }
+    if (options.runnerUi != null) {
+        args.push('--runner-ui', options.runnerUi);
+    }
+    // if we have specific spec(s) push that into the args
+    if (options.spec) {
+        args.push('--spec', options.spec);
+    }
+    if (options.tag) {
+        args.push('--tag', options.tag);
+    }
+    if (options.inspect) {
+        args.push('--inspect');
+    }
+    if (options.inspectBrk) {
+        args.push('--inspectBrk');
+    }
+    args.push(...(0, shared_1.processTestingType)(options));
+    return args;
+};
+const runModule = {
+    processRunOptions,
+    isValidProject,
+    // resolves with the number of failed tests
+    start() {
+        return __awaiter(this, arguments, void 0, function* (options = {}) {
+            lodash_1.default.defaults(options, {
+                key: null,
+                spec: null,
+                reporter: null,
+                reporterOptions: null,
+                project: process.cwd(),
+            });
+            function run() {
+                try {
+                    const args = processRunOptions(options);
+                    debug('run to spawn.start args %j', args);
+                    return spawn_1.default.start(args, {
+                        dev: options.dev,
+                    });
+                }
+                catch (err) {
+                    if (err.details) {
+                        return (0, errors_1.exitWithError)(err.details)();
+                    }
+                    throw err;
+                }
+            }
+            if (options.dev) {
+                return run();
+            }
+            yield (0, verify_1.start)();
+            return run();
+        });
+    },
+};
+exports.default = runModule;

package/dist/exec/shared.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkConfigFile = exports.processTestingType = exports.throwInvalidOptionError = void 0;
+const errors_1 = require("../errors");
+/**
+ * Throws an error with "details" property from
+ * "errors" object.
+ * @param {Object} details - Error details
+ */
+const throwInvalidOptionError = (details) => {
+    if (!details) {
+        details = errors_1.errors.unknownError;
+    }
+    // throw this error synchronously, it will be caught later on and
+    // the details will be propagated to the promise chain
+    const err = new Error();
+    err.details = details;
+    throw err;
+};
+exports.throwInvalidOptionError = throwInvalidOptionError;
+/**
+ * Selects exec args based on the configured `testingType`
+ * @param {string} testingType The type of tests being executed
+ * @returns {string[]} The array of new exec arguments
+ */
+const processTestingType = (options) => {
+    if (options.e2e && options.component) {
+        return (0, exports.throwInvalidOptionError)(errors_1.errors.incompatibleTestTypeFlags);
+    }
+    if (options.testingType && (options.component || options.e2e)) {
+        return (0, exports.throwInvalidOptionError)(errors_1.errors.incompatibleTestTypeFlags);
+    }
+    if (options.testingType === 'component' || options.component || options.ct) {
+        return ['--testing-type', 'component'];
+    }
+    if (options.testingType === 'e2e' || options.e2e) {
+        return ['--testing-type', 'e2e'];
+    }
+    if (options.testingType) {
+        return (0, exports.throwInvalidOptionError)(errors_1.errors.invalidTestingType);
+    }
+    return [];
+};
+exports.processTestingType = processTestingType;
+/**
+ * Throws an error if configFile is string 'false' or boolean false
+ * @param {*} options
+ */
+const checkConfigFile = (options) => {
+    // CLI will parse as string, module API can pass in boolean
+    if (options.configFile === 'false' || options.configFile === false) {
+        (0, exports.throwInvalidOptionError)(errors_1.errors.invalidConfigFile);
+    }
+};
+exports.checkConfigFile = checkConfigFile;

package/dist/exec/spawn.js

@@ -0,0 +1,301 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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 lodash_1 = __importDefault(require("lodash"));
+const os_1 = __importDefault(require("os"));
+const child_process_1 = __importDefault(require("child_process"));
+const path_1 = __importDefault(require("path"));
+const bluebird_1 = __importDefault(require("bluebird"));
+const debug_1 = __importDefault(require("debug"));
+const util_1 = __importDefault(require("../util"));
+const state_1 = __importDefault(require("../tasks/state"));
+const xvfb_1 = __importDefault(require("./xvfb"));
+const verify_1 = require("../tasks/verify");
+const errors_1 = require("../errors");
+const readline_1 = __importDefault(require("readline"));
+const process_1 = require("process");
+const debug = (0, debug_1.default)('cypress:cli');
+function isPlatform(platform) {
+    return os_1.default.platform() === platform;
+}
+function needsStderrPiped(needsXvfb) {
+    return lodash_1.default.some([
+        isPlatform('darwin'),
+        (needsXvfb && isPlatform('linux')),
+        util_1.default.isPossibleLinuxWithIncorrectDisplay(),
+    ]);
+}
+function needsEverythingPipedDirectly() {
+    return isPlatform('win32');
+}
+function getStdio(needsXvfb) {
+    if (needsEverythingPipedDirectly()) {
+        return 'pipe';
+    }
+    // https://github.com/cypress-io/cypress/issues/921
+    // https://github.com/cypress-io/cypress/issues/1143
+    // https://github.com/cypress-io/cypress/issues/1745
+    if (needsStderrPiped(needsXvfb)) {
+        // returning pipe here so we can massage stderr
+        // and remove garbage from Xlib and libuv
+        // due to starting the Xvfb process on linux
+        return ['inherit', 'inherit', 'pipe'];
+    }
+    return 'inherit';
+}
+const spawnModule = {
+    start(args_1) {
+        return __awaiter(this, arguments, void 0, function* (args, options = {}) {
+            const needsXvfb = xvfb_1.default.isNeeded();
+            let executable = state_1.default.getPathToExecutable(state_1.default.getBinaryDir());
+            if (util_1.default.getEnv('CYPRESS_RUN_BINARY')) {
+                executable = path_1.default.resolve(util_1.default.getEnv('CYPRESS_RUN_BINARY'));
+            }
+            debug('needs to start own Xvfb?', needsXvfb);
+            // Always push cwd into the args
+            // which additionally acts as a signal to the
+            // binary that it was invoked through the NPM module
+            args = args || [];
+            if (typeof args === 'string') {
+                args = [args];
+            }
+            args = [...args, '--cwd', process.cwd(), '--userNodePath', process.execPath, '--userNodeVersion', process.versions.node];
+            lodash_1.default.defaults(options, {
+                dev: false,
+                env: process.env,
+                detached: false,
+                stdio: getStdio(needsXvfb),
+            });
+            const spawn = (overrides = {}) => {
+                return new bluebird_1.default((resolve, reject) => {
+                    lodash_1.default.defaults(overrides, {
+                        onStderrData: false,
+                    });
+                    const { onStderrData } = overrides;
+                    const envOverrides = util_1.default.getEnvOverrides(options);
+                    const electronArgs = [];
+                    const node11WindowsFix = isPlatform('win32');
+                    let startScriptPath;
+                    if (options.dev) {
+                        executable = 'node';
+                        // if we're in dev then reset
+                        // the launch cmd to be 'npm run dev'
+                        startScriptPath = path_1.default.resolve(__dirname, '..', '..', '..', 'scripts', 'start.js');
+                        debug('in dev mode the args became %o', args);
+                    }
+                    if (!options.dev && (0, verify_1.needsSandbox)()) {
+                        electronArgs.push('--no-sandbox');
+                    }
+                    // strip dev out of child process options
+                    /**
+                     * @type {import('child_process').ForkOptions}
+                     */
+                    let stdioOptions = lodash_1.default.pick(options, 'env', 'detached', 'stdio');
+                    // figure out if we're going to be force enabling or disabling colors.
+                    // also figure out whether we should force stdout and stderr into thinking
+                    // it is a tty as opposed to a pipe.
+                    stdioOptions.env = lodash_1.default.extend({}, stdioOptions.env, envOverrides);
+                    if (node11WindowsFix) {
+                        stdioOptions = lodash_1.default.extend({}, stdioOptions, { windowsHide: false });
+                    }
+                    if (util_1.default.isPossibleLinuxWithIncorrectDisplay()) {
+                        // make sure we use the latest DISPLAY variable if any
+                        debug('passing DISPLAY', process.env.DISPLAY);
+                        stdioOptions.env.DISPLAY = process.env.DISPLAY;
+                    }
+                    if (stdioOptions.env.ELECTRON_RUN_AS_NODE) {
+                        // Since we are running electron as node, we need to add an entry point file.
+                        startScriptPath = path_1.default.join(state_1.default.getBinaryPkgPath(path_1.default.dirname(executable)), '..', 'index.js');
+                    }
+                    else {
+                        // Start arguments with "--" so Electron knows these are OUR
+                        // arguments and does not try to sanitize them. Otherwise on Windows
+                        // an url in one of the arguments crashes it :(
+                        // https://github.com/cypress-io/cypress/issues/5466
+                        args = [...electronArgs, '--', ...args];
+                    }
+                    if (startScriptPath) {
+                        args.unshift(startScriptPath);
+                    }
+                    if (process.env.CYPRESS_INTERNAL_DEV_DEBUG) {
+                        args.unshift(process.env.CYPRESS_INTERNAL_DEV_DEBUG);
+                    }
+                    debug('spawn args %o %o', args, lodash_1.default.omit(stdioOptions, 'env'));
+                    debug('spawning Cypress with executable: %s', executable);
+                    const child = child_process_1.default.spawn(executable, args, stdioOptions);
+                    function resolveOn(event) {
+                        return function (code, signal) {
+                            return __awaiter(this, void 0, void 0, function* () {
+                                debug('child event fired %o', { event, code, signal });
+                                if (code === null) {
+                                    const errorObject = errors_1.errors.childProcessKilled(event, signal);
+                                    const err = yield (0, errors_1.getError)(errorObject);
+                                    return reject(err);
+                                }
+                                resolve(code);
+                            });
+                        };
+                    }
+                    child.on('close', resolveOn('close'));
+                    child.on('exit', resolveOn('exit'));
+                    child.on('error', reject);
+                    if (isPlatform('win32')) {
+                        const rl = readline_1.default.createInterface({
+                            input: process_1.stdin,
+                            output: process_1.stdout,
+                        });
+                        // on windows, SIGINT does not propagate to the child process when ctrl+c is pressed
+                        // this makes sure all nested processes are closed(ex: firefox inside the server)
+                        rl.on('SIGINT', function () {
+                            return __awaiter(this, void 0, void 0, function* () {
+                                const kill = (yield Promise.resolve().then(() => __importStar(require('tree-kill')))).default;
+                                kill(child.pid, 'SIGINT');
+                            });
+                        });
+                    }
+                    // if stdio options is set to 'pipe', then
+                    //   we should set up pipes:
+                    //  process STDIN (read stream) => child STDIN (writeable)
+                    //  child STDOUT => process STDOUT
+                    //  child STDERR => process STDERR with additional filtering
+                    if (child.stdin) {
+                        debug('piping process STDIN into child STDIN');
+                        process_1.stdin.pipe(child.stdin);
+                    }
+                    if (child.stdout) {
+                        debug('piping child STDOUT to process STDOUT');
+                        child.stdout.pipe(process_1.stdout);
+                    }
+                    // if this is defined then we are manually piping for linux
+                    // to filter out the garbage
+                    if (child.stderr) {
+                        debug('piping child STDERR to process STDERR');
+                        child.stderr.on('data', (data) => {
+                            const str = data.toString();
+                            // if we have a callback and this explicitly returns
+                            // false then bail
+                            if (onStderrData && onStderrData(str)) {
+                                return;
+                            }
+                            // else pass it along!
+                            process_1.stderr.write(data);
+                        });
+                    }
+                    // https://github.com/cypress-io/cypress/issues/1841
+                    // https://github.com/cypress-io/cypress/issues/5241
+                    // In some versions of node, it will throw on windows
+                    // when you close the parent process after piping
+                    // into the child process. unpiping does not seem
+                    // to have any effect. so we're just catching the
+                    // error here and not doing anything.
+                    process_1.stdin.on('error', (err) => {
+                        if (['EPIPE', 'ENOTCONN'].includes(err.code)) {
+                            return;
+                        }
+                        throw err;
+                    });
+                    if (stdioOptions.detached) {
+                        child.unref();
+                    }
+                });
+            };
+            const spawnInXvfb = () => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    yield xvfb_1.default.start();
+                    const code = yield userFriendlySpawn();
+                    return code;
+                }
+                finally {
+                    yield xvfb_1.default.stop();
+                }
+            });
+            const userFriendlySpawn = (linuxWithDisplayEnv) => __awaiter(this, void 0, void 0, function* () {
+                debug('spawning, should retry on display problem?', Boolean(linuxWithDisplayEnv));
+                let brokenGtkDisplay = false;
+                const overrides = {};
+                if (linuxWithDisplayEnv) {
+                    lodash_1.default.extend(overrides, {
+                        electronLogging: true,
+                        onStderrData(str) {
+                            // if we receive a broken pipe anywhere
+                            // then we know that's why cypress exited early
+                            if (util_1.default.isBrokenGtkDisplay(str)) {
+                                brokenGtkDisplay = true;
+                            }
+                        },
+                    });
+                }
+                try {
+                    const code = yield spawn(overrides);
+                    if (code !== 0 && brokenGtkDisplay) {
+                        util_1.default.logBrokenGtkDisplayWarning();
+                        return spawnInXvfb();
+                    }
+                    return code;
+                }
+                catch (error) {
+                    // we can format and handle an error message from the code above
+                    // prevent wrapping error again by using "known: undefined" filter
+                    if (error.known === undefined) {
+                        const raiseErrorFn = (0, errors_1.throwFormErrorText)(errors_1.errors.unexpected);
+                        yield raiseErrorFn(error.message);
+                    }
+                    throw error;
+                }
+            });
+            if (needsXvfb) {
+                return spawnInXvfb();
+            }
+            // if we are on linux and there's already a DISPLAY
+            // set, then we may need to rerun cypress after
+            // spawning our own Xvfb server
+            const linuxWithDisplayEnv = util_1.default.isPossibleLinuxWithIncorrectDisplay();
+            return userFriendlySpawn(linuxWithDisplayEnv);
+        });
+    },
+};
+exports.default = spawnModule;