cypress 15.1.0 → 15.2.0

package/lib/exec/shared.js

@@ -1,62 +1,55 @@
 "use strict";
-
-const {
-  errors
-} = require('../errors');
-
+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.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;
+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 throwInvalidOptionError(errors.incompatibleTestTypeFlags);
-  }
-  if (options.testingType && (options.component || options.e2e)) {
-    return throwInvalidOptionError(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 throwInvalidOptionError(errors.invalidTestingType);
-  }
-  return [];
+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) {
-    throwInvalidOptionError(errors.invalidConfigFile);
-  }
+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);
+    }
 };
-module.exports = {
-  throwInvalidOptionError,
-  processTestingType,
-  checkConfigFile
-};
+exports.checkConfigFile = checkConfigFile;

package/lib/exec/spawn.js

@@ -1,247 +1,285 @@
 "use strict";
-
-const _ = require('lodash');
-const os = require('os');
-const cp = require('child_process');
-const path = require('path');
-const Promise = require('bluebird');
-const debug = require('debug')('cypress:cli');
-const util = require('../util');
-const state = require('../tasks/state');
-const xvfb = require('./xvfb');
-const verify = require('../tasks/verify');
-const errors = require('../errors');
-const readline = require('readline');
+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 = __importDefault(require("../tasks/verify"));
+const errors_1 = require("../errors");
+const readline_1 = __importDefault(require("readline"));
+const debug = (0, debug_1.default)('cypress:cli');
 function isPlatform(platform) {
-  return os.platform() === platform;
+    return os_1.default.platform() === platform;
 }
 function needsStderrPiped(needsXvfb) {
-  return _.some([isPlatform('darwin'), needsXvfb && isPlatform('linux'), util.isPossibleLinuxWithIncorrectDisplay()]);
+    return lodash_1.default.some([
+        isPlatform('darwin'),
+        (needsXvfb && isPlatform('linux')),
+        util_1.default.isPossibleLinuxWithIncorrectDisplay(),
+    ]);
 }
 function needsEverythingPipedDirectly() {
-  return isPlatform('win32');
+    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';
-}
-module.exports = {
-  start(args, options = {}) {
-    const needsXvfb = xvfb.isNeeded();
-    let executable = state.getPathToExecutable(state.getBinaryDir());
-    if (util.getEnv('CYPRESS_RUN_BINARY')) {
-      executable = path.resolve(util.getEnv('CYPRESS_RUN_BINARY'));
+    if (needsEverythingPipedDirectly()) {
+        return 'pipe';
     }
-    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];
+    // 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'];
     }
-    args = [...args, '--cwd', process.cwd(), '--userNodePath', process.execPath, '--userNodeVersion', process.versions.node];
-    _.defaults(options, {
-      dev: false,
-      env: process.env,
-      detached: false,
-      stdio: getStdio(needsXvfb)
-    });
-    const spawn = (overrides = {}) => {
-      return new Promise((resolve, reject) => {
-        _.defaults(overrides, {
-          onStderrData: false
-        });
-        const {
-          onStderrData
-        } = overrides;
-        const envOverrides = util.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.resolve(__dirname, '..', '..', '..', 'scripts', 'start.js'), debug('in dev mode the args became %o', args);
-        }
-        if (!options.dev && verify.needsSandbox()) {
-          electronArgs.push('--no-sandbox');
-        }
-
-        // strip dev out of child process options
-        /**
-         * @type {import('child_process').ForkOptions}
-         */
-        let stdioOptions = _.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 = _.extend({}, stdioOptions.env, envOverrides);
-        if (node11WindowsFix) {
-          stdioOptions = _.extend({}, stdioOptions, {
-            windowsHide: false
-          });
-        }
-        if (util.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.join(state.getBinaryPkgPath(path.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, _.omit(stdioOptions, 'env'));
-        debug('spawning Cypress with executable: %s', executable);
-        const child = cp.spawn(executable, args, stdioOptions);
-        function resolveOn(event) {
-          return function (code, signal) {
-            debug('child event fired %o', {
-              event,
-              code,
-              signal
-            });
-            if (code === null) {
-              const errorObject = errors.errors.childProcessKilled(event, signal);
-              return errors.getError(errorObject).then(reject);
-            }
-            resolve(code);
-          };
-        }
-        child.on('close', resolveOn('close'));
-        child.on('exit', resolveOn('exit'));
-        child.on('error', reject);
-        if (isPlatform('win32')) {
-          const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.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 () {
-            let kill = require('tree-kill');
-            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.stdin.pipe(child.stdin);
-        }
-        if (child.stdout) {
-          debug('piping child STDOUT to process STDOUT');
-          child.stdout.pipe(process.stdout);
+    return 'inherit';
+}
+const spawnModule = {
+    start(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'));
         }
-
-        // 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.stderr.write(data);
-          });
+        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];
         }
-
-        // 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.stdin.on('error', err => {
-          if (['EPIPE', 'ENOTCONN'].includes(err.code)) {
-            return;
-          }
-          throw err;
+        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),
         });
-        if (stdioOptions.detached) {
-          child.unref();
-        }
-      });
-    };
-    const spawnInXvfb = () => {
-      return xvfb.start().then(userFriendlySpawn).finally(xvfb.stop);
-    };
-    const userFriendlySpawn = linuxWithDisplayEnv => {
-      debug('spawning, should retry on display problem?', Boolean(linuxWithDisplayEnv));
-      let brokenGtkDisplay;
-      const overrides = {};
-      if (linuxWithDisplayEnv) {
-        _.extend(overrides, {
-          electronLogging: true,
-          onStderrData(str) {
-            // if we receive a broken pipe anywhere
-            // then we know that's why cypress exited early
-            if (util.isBrokenGtkDisplay(str)) {
-              brokenGtkDisplay = true;
+        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 && verify_1.default.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) {
+                        debug('child event fired %o', { event, code, signal });
+                        if (code === null) {
+                            const errorObject = errors_1.errors.childProcessKilled(event, signal);
+                            return (0, errors_1.getError)(errorObject).then(reject);
+                        }
+                        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.stdin,
+                        output: process.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.stdin.pipe(child.stdin);
+                }
+                if (child.stdout) {
+                    debug('piping child STDOUT to process STDOUT');
+                    child.stdout.pipe(process.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.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.stdin.on('error', (err) => {
+                    if (['EPIPE', 'ENOTCONN'].includes(err.code)) {
+                        return;
+                    }
+                    throw err;
+                });
+                if (stdioOptions.detached) {
+                    child.unref();
+                }
+            });
+        };
+        const spawnInXvfb = () => {
+            return xvfb_1.default
+                .start()
+                .then(userFriendlySpawn)
+                .finally(xvfb_1.default.stop);
+        };
+        const userFriendlySpawn = (linuxWithDisplayEnv) => {
+            debug('spawning, should retry on display problem?', Boolean(linuxWithDisplayEnv));
+            let brokenGtkDisplay;
+            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;
+                        }
+                    },
+                });
             }
-          }
-        });
-      }
-      return spawn(overrides).then(code => {
-        if (code !== 0 && brokenGtkDisplay) {
-          util.logBrokenGtkDisplayWarning();
-          return spawnInXvfb();
+            return spawn(overrides)
+                .then((code) => {
+                if (code !== 0 && brokenGtkDisplay) {
+                    util_1.default.logBrokenGtkDisplayWarning();
+                    return spawnInXvfb();
+                }
+                return code;
+            })
+                // we can format and handle an error message from the code above
+                // prevent wrapping error again by using "known: undefined" filter
+                .catch({ known: undefined }, (0, errors_1.throwFormErrorText)(errors_1.errors.unexpected));
+        };
+        if (needsXvfb) {
+            return spawnInXvfb();
         }
-        return code;
-      })
-      // we can format and handle an error message from the code above
-      // prevent wrapping error again by using "known: undefined" filter
-      .catch({
-        known: undefined
-      }, errors.throwFormErrorText(errors.errors.unexpected));
-    };
-    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.isPossibleLinuxWithIncorrectDisplay();
-    return userFriendlySpawn(linuxWithDisplayEnv);
-  }
-};
+        // 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;