cypress 5.4.0 → 5.5.0

package/lib/tasks/verify.js

@@ -1,119 +1,71 @@
 "use strict";
 
-function _templateObject5() {
-  var data = _taggedTemplateLiteral(["\n\n\n      ", " Warning: Binary version ", " does not match the expected package version ", "\n\n        These versions may not work properly together.\n      "]);
+const _ = require('lodash');
 
-  _templateObject5 = function _templateObject5() {
-    return data;
-  };
+const chalk = require('chalk');
 
-  return data;
-}
+const Listr = require('listr');
 
-function _templateObject4() {
-  var data = _taggedTemplateLiteral(["\n          The supplied binary path is not executable\n          "]);
+const debug = require('debug')('cypress:cli');
 
-  _templateObject4 = function _templateObject4() {
-    return data;
-  };
-
-  return data;
-}
+const verbose = require('@cypress/listr-verbose-renderer');
 
-function _templateObject3() {
-  var data = _taggedTemplateLiteral(["\n      ", " You have set the environment variable:\n\n      ", "", "\n\n      This overrides the default Cypress binary path used.\n    "]);
-
-  _templateObject3 = function _templateObject3() {
-    return data;
-  };
-
-  return data;
-}
+const {
+  stripIndent
+} = require('common-tags');
 
-function _templateObject2() {
-  var data = _taggedTemplateLiteral(["\n    It looks like this is your first time using Cypress: ", "\n    "]);
+const Promise = require('bluebird');
 
-  _templateObject2 = function _templateObject2() {
-    return data;
-  };
-
-  return data;
-}
-
-function _templateObject() {
-  var data = _taggedTemplateLiteral(["\n      Cypress executable not found at: ", "\n    "]);
-
-  _templateObject = function _templateObject() {
-    return data;
-  };
-
-  return data;
-}
+const logSymbols = require('log-symbols');
 
-function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
+const path = require('path');
 
-var _ = require('lodash');
+const os = require('os');
 
-var chalk = require('chalk');
+const {
+  throwFormErrorText,
+  errors
+} = require('../errors');
 
-var Listr = require('listr');
+const util = require('../util');
 
-var debug = require('debug')('cypress:cli');
+const logger = require('../logger');
 
-var verbose = require('@cypress/listr-verbose-renderer');
+const xvfb = require('../exec/xvfb');
 
-var _require = require('common-tags'),
-    stripIndent = _require.stripIndent;
+const state = require('./state');
 
-var Promise = require('bluebird');
+const VERIFY_TEST_RUNNER_TIMEOUT_MS = 30000;
 
-var logSymbols = require('log-symbols');
-
-var path = require('path');
-
-var os = require('os');
-
-var _require2 = require('../errors'),
-    throwFormErrorText = _require2.throwFormErrorText,
-    errors = _require2.errors;
-
-var util = require('../util');
-
-var logger = require('../logger');
-
-var xvfb = require('../exec/xvfb');
-
-var state = require('./state');
-
-var VERIFY_TEST_RUNNER_TIMEOUT_MS = 30000;
-
-var checkExecutable = function checkExecutable(binaryDir) {
-  var executable = state.getPathToExecutable(binaryDir);
+const checkExecutable = binaryDir => {
+  const executable = state.getPathToExecutable(binaryDir);
   debug('checking if executable exists', executable);
-  return util.isExecutableAsync(executable).then(function (isExecutable) {
+  return util.isExecutableAsync(executable).then(isExecutable => {
     debug('Binary is executable? :', isExecutable);
 
     if (!isExecutable) {
       return throwFormErrorText(errors.binaryNotExecutable(executable))();
     }
-  })["catch"]({
+  }).catch({
     code: 'ENOENT'
-  }, function () {
+  }, () => {
     if (util.isCi()) {
       return throwFormErrorText(errors.notInstalledCI(executable))();
     }
 
-    return throwFormErrorText(errors.missingApp(binaryDir))(stripIndent(_templateObject(), chalk.cyan(executable)));
+    return throwFormErrorText(errors.missingApp(binaryDir))(stripIndent`
+      Cypress executable not found at: ${chalk.cyan(executable)}
+    `);
   });
 };
 
-var runSmokeTest = function runSmokeTest(binaryDir, options) {
-  var executable = state.getPathToExecutable(binaryDir);
+const runSmokeTest = (binaryDir, options) => {
+  let executable = state.getPathToExecutable(binaryDir);
 
-  var onSmokeTestError = function onSmokeTestError(smokeTestCommand, linuxWithDisplayEnv) {
-    return function (err) {
+  const onSmokeTestError = (smokeTestCommand, linuxWithDisplayEnv) => {
+    return err => {
       debug('Smoke test failed:', err);
-      var errMessage = err.stderr || err.message;
+      let errMessage = err.stderr || err.message;
       debug('error message:', errMessage);
 
       if (err.timedOut) {
@@ -130,17 +82,17 @@ var runSmokeTest = function runSmokeTest(binaryDir, options) {
     };
   };
 
-  var needsXvfb = xvfb.isNeeded();
+  const needsXvfb = xvfb.isNeeded();
   debug('needs Xvfb?', needsXvfb);
   /**
    * Spawn Cypress running smoke test to check if all operating system
    * dependencies are good.
    */
 
-  var spawn = function spawn(linuxWithDisplayEnv) {
-    var random = _.random(0, 1000);
+  const spawn = linuxWithDisplayEnv => {
+    const random = _.random(0, 1000);
 
-    var args = ['--smoke-test', "--ping=".concat(random)];
+    const args = ['--smoke-test', `--ping=${random}`];
 
     if (needsSandbox()) {
       // electron requires --no-sandbox to run as root
@@ -153,51 +105,51 @@ var runSmokeTest = function runSmokeTest(binaryDir, options) {
       args.unshift(path.resolve(__dirname, '..', '..', '..', 'scripts', 'start.js'));
     }
 
-    var smokeTestCommand = "".concat(executable, " ").concat(args.join(' '));
+    const smokeTestCommand = `${executable} ${args.join(' ')}`;
     debug('running smoke test');
     debug('using Cypress executable %s', executable);
     debug('smoke test command:', smokeTestCommand);
     debug('smoke test timeout %d ms', options.smokeTestTimeout);
 
-    var env = _.extend({}, process.env, {
+    const env = _.extend({}, process.env, {
       ELECTRON_ENABLE_LOGGING: true
     });
 
-    var stdioOptions = _.extend({}, {
-      env: env,
+    const stdioOptions = _.extend({}, {
+      env,
       timeout: options.smokeTestTimeout
     });
 
-    return Promise.resolve(util.exec(executable, args, stdioOptions))["catch"](onSmokeTestError(smokeTestCommand, linuxWithDisplayEnv)).then(function (result) {
+    return Promise.resolve(util.exec(executable, args, stdioOptions)).catch(onSmokeTestError(smokeTestCommand, linuxWithDisplayEnv)).then(result => {
       // TODO: when execa > 1.1 is released
       // change this to `result.all` for both stderr and stdout
       // use lodash to be robust during tests against null result or missing stdout
-      var smokeTestStdout = _.get(result, 'stdout', '');
+      const smokeTestStdout = _.get(result, 'stdout', '');
 
       debug('smoke test stdout "%s"', smokeTestStdout);
 
       if (!util.stdoutLineMatches(String(random), smokeTestStdout)) {
         debug('Smoke test failed because could not find %d in:', random, result);
 
-        var smokeTestStderr = _.get(result, 'stderr', '');
+        const smokeTestStderr = _.get(result, 'stderr', '');
 
-        var errorText = smokeTestStderr || smokeTestStdout;
+        const errorText = smokeTestStderr || smokeTestStdout;
         return throwFormErrorText(errors.smokeTestFailure(smokeTestCommand, false))(errorText);
       }
     });
   };
 
-  var spawnInXvfb = function spawnInXvfb(linuxWithDisplayEnv) {
-    return xvfb.start().then(function () {
+  const spawnInXvfb = linuxWithDisplayEnv => {
+    return xvfb.start().then(() => {
       return spawn(linuxWithDisplayEnv);
-    })["finally"](xvfb.stop);
+    }).finally(xvfb.stop);
   };
 
-  var userFriendlySpawn = function userFriendlySpawn(linuxWithDisplayEnv) {
+  const userFriendlySpawn = linuxWithDisplayEnv => {
     debug('spawning, should retry on display problem?', Boolean(linuxWithDisplayEnv));
-    return spawn(linuxWithDisplayEnv)["catch"]({
+    return spawn(linuxWithDisplayEnv).catch({
       code: 'INVALID_SMOKE_TEST_DISPLAY_ERROR'
-    }, function () {
+    }, () => {
       return spawnInXvfb(linuxWithDisplayEnv);
     });
   };
@@ -209,7 +161,7 @@ var runSmokeTest = function runSmokeTest(binaryDir, options) {
   // spawning our own Xvfb server
 
 
-  var linuxWithDisplayEnv = util.isPossibleLinuxWithIncorrectDisplay();
+  const linuxWithDisplayEnv = util.isPossibleLinuxWithIncorrectDisplay();
   return userFriendlySpawn(linuxWithDisplayEnv);
 };
 
@@ -217,40 +169,42 @@ function testBinary(version, binaryDir, options) {
   debug('running binary verification check', version); // if running from 'cypress verify', don't print this message
 
   if (!options.force) {
-    logger.log(stripIndent(_templateObject2(), chalk.cyan(version)));
+    logger.log(stripIndent`
+    It looks like this is your first time using Cypress: ${chalk.cyan(version)}
+    `);
   }
 
   logger.log(); // if we are running in CI then use
   // the verbose renderer else use
   // the default
 
-  var renderer = util.isCi() ? verbose : 'default';
+  let renderer = util.isCi() ? verbose : 'default';
   if (logger.logLevel() === 'silent') renderer = 'silent';
-  var rendererOptions = {
-    renderer: renderer
+  const rendererOptions = {
+    renderer
   };
-  var tasks = new Listr([{
+  const tasks = new Listr([{
     title: util.titleize('Verifying Cypress can run', chalk.gray(binaryDir)),
-    task: function task(ctx, _task) {
+    task: (ctx, task) => {
       debug('clearing out the verified version');
-      return state.clearBinaryStateAsync(binaryDir).then(function () {
+      return state.clearBinaryStateAsync(binaryDir).then(() => {
         return Promise.all([runSmokeTest(binaryDir, options), Promise.resolve().delay(1500) // good user experience
         ]);
-      }).then(function () {
+      }).then(() => {
         debug('write verified: true');
         return state.writeBinaryVerifiedAsync(true, binaryDir);
-      }).then(function () {
-        util.setTaskTitle(_task, util.titleize(chalk.green('Verified Cypress!'), chalk.gray(binaryDir)), rendererOptions.renderer);
+      }).then(() => {
+        util.setTaskTitle(task, util.titleize(chalk.green('Verified Cypress!'), chalk.gray(binaryDir)), rendererOptions.renderer);
       });
     }
   }], rendererOptions);
   return tasks.run();
 }
 
-var maybeVerify = function maybeVerify(installedVersion, binaryDir, options) {
-  return state.getBinaryVerifiedAsync(binaryDir).then(function (isVerified) {
+const maybeVerify = (installedVersion, binaryDir, options) => {
+  return state.getBinaryVerifiedAsync(binaryDir).then(isVerified => {
     debug('is Verified ?', isVerified);
-    var shouldVerify = !isVerified; // force verify if options.force
+    let shouldVerify = !isVerified; // force verify if options.force
 
     if (options.force) {
       debug('force verify');
@@ -258,7 +212,7 @@ var maybeVerify = function maybeVerify(installedVersion, binaryDir, options) {
     }
 
     if (shouldVerify) {
-      return testBinary(installedVersion, binaryDir, options).then(function () {
+      return testBinary(installedVersion, binaryDir, options).then(() => {
         if (options.welcomeMessage) {
           logger.log();
           logger.log('Opening Cypress...');
@@ -268,11 +222,10 @@ var maybeVerify = function maybeVerify(installedVersion, binaryDir, options) {
   });
 };
 
-var start = function start() {
-  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+const start = (options = {}) => {
   debug('verifying Cypress app');
-  var packageVersion = util.pkgVersion();
-  var binaryDir = state.getBinaryDir(packageVersion);
+  const packageVersion = util.pkgVersion();
+  let binaryDir = state.getBinaryDir(packageVersion);
 
   _.defaults(options, {
     dev: false,
@@ -285,64 +238,80 @@ var start = function start() {
     return runSmokeTest('', options);
   }
 
-  var parseBinaryEnvVar = function parseBinaryEnvVar() {
-    var envBinaryPath = util.getEnv('CYPRESS_RUN_BINARY');
+  const parseBinaryEnvVar = () => {
+    const envBinaryPath = util.getEnv('CYPRESS_RUN_BINARY');
     debug('CYPRESS_RUN_BINARY exists, =', envBinaryPath);
-    logger.log(stripIndent(_templateObject3(), chalk.yellow('Note:'), chalk.white('CYPRESS_RUN_BINARY='), chalk.cyan(envBinaryPath)));
+    logger.log(stripIndent`
+      ${chalk.yellow('Note:')} You have set the environment variable:
+
+      ${chalk.white('CYPRESS_RUN_BINARY=')}${chalk.cyan(envBinaryPath)}
+
+      This overrides the default Cypress binary path used.
+    `);
     logger.log();
-    return util.isExecutableAsync(envBinaryPath).then(function (isExecutable) {
+    return util.isExecutableAsync(envBinaryPath).then(isExecutable => {
       debug('CYPRESS_RUN_BINARY is executable? :', isExecutable);
 
       if (!isExecutable) {
-        return throwFormErrorText(errors.CYPRESS_RUN_BINARY.notValid(envBinaryPath))(stripIndent(_templateObject4()));
+        return throwFormErrorText(errors.CYPRESS_RUN_BINARY.notValid(envBinaryPath))(stripIndent`
+          The supplied binary path is not executable
+          `);
       }
-    }).then(function () {
+    }).then(() => {
       return state.parseRealPlatformBinaryFolderAsync(envBinaryPath);
-    }).then(function (envBinaryDir) {
+    }).then(envBinaryDir => {
       if (!envBinaryDir) {
         return throwFormErrorText(errors.CYPRESS_RUN_BINARY.notValid(envBinaryPath))();
       }
 
       debug('CYPRESS_RUN_BINARY has binaryDir:', envBinaryDir);
       binaryDir = envBinaryDir;
-    })["catch"]({
+    }).catch({
       code: 'ENOENT'
-    }, function (err) {
+    }, err => {
       return throwFormErrorText(errors.CYPRESS_RUN_BINARY.notValid(envBinaryPath))(err.message);
     });
   };
 
-  return Promise["try"](function () {
+  return Promise.try(() => {
     debug('checking environment variables');
 
     if (util.getEnv('CYPRESS_RUN_BINARY')) {
       return parseBinaryEnvVar();
     }
-  }).then(function () {
+  }).then(() => {
     return checkExecutable(binaryDir);
-  }).tap(function () {
+  }).tap(() => {
     return debug('binaryDir is ', binaryDir);
-  }).then(function () {
+  }).then(() => {
     return state.getBinaryPkgVersionAsync(binaryDir);
-  }).then(function (binaryVersion) {
+  }).then(binaryVersion => {
     if (!binaryVersion) {
       debug('no Cypress binary found for cli version ', packageVersion);
-      return throwFormErrorText(errors.missingApp(binaryDir))("\n      Cannot read binary version from: ".concat(chalk.cyan(state.getBinaryPkgPath(binaryDir)), "\n    "));
+      return throwFormErrorText(errors.missingApp(binaryDir))(`
+      Cannot read binary version from: ${chalk.cyan(state.getBinaryPkgPath(binaryDir))}
+    `);
     }
 
-    debug("Found binary version ".concat(chalk.green(binaryVersion), " installed in: ").concat(chalk.cyan(binaryDir)));
+    debug(`Found binary version ${chalk.green(binaryVersion)} installed in: ${chalk.cyan(binaryDir)}`);
 
     if (binaryVersion !== packageVersion) {
       // warn if we installed with CYPRESS_INSTALL_BINARY or changed version
       // in the package.json
-      logger.log("Found binary version ".concat(chalk.green(binaryVersion), " installed in: ").concat(chalk.cyan(binaryDir)));
+      logger.log(`Found binary version ${chalk.green(binaryVersion)} installed in: ${chalk.cyan(binaryDir)}`);
       logger.log();
-      logger.warn(stripIndent(_templateObject5(), logSymbols.warning, chalk.green(binaryVersion), chalk.green(packageVersion)));
+      logger.warn(stripIndent`
+
+
+      ${logSymbols.warning} Warning: Binary version ${chalk.green(binaryVersion)} does not match the expected package version ${chalk.green(packageVersion)}
+
+        These versions may not work properly together.
+      `);
       logger.log();
     }
 
     return maybeVerify(binaryVersion, binaryDir, options);
-  })["catch"](function (err) {
+  }).catch(err => {
     if (err.known) {
       throw err;
     }
@@ -351,9 +320,7 @@ var start = function start() {
   });
 };
 
-var isLinuxLike = function isLinuxLike() {
-  return os.platform() !== 'win32';
-};
+const isLinuxLike = () => os.platform() !== 'win32';
 /**
  * Returns true if running on a system where Electron needs "--no-sandbox" flag.
  * @see https://crbug.com/638180
@@ -365,12 +332,10 @@ var isLinuxLike = function isLinuxLike() {
 */
 
 
-var needsSandbox = function needsSandbox() {
-  return isLinuxLike();
-};
+const needsSandbox = () => isLinuxLike();
 
 module.exports = {
-  start: start,
-  VERIFY_TEST_RUNNER_TIMEOUT_MS: VERIFY_TEST_RUNNER_TIMEOUT_MS,
-  needsSandbox: needsSandbox
+  start,
+  VERIFY_TEST_RUNNER_TIMEOUT_MS,
+  needsSandbox
 };