údržba

CyLukTs/lukan/node_modules/cypress/lib/exec/info.js

@@ -0,0 +1,92 @@
+"use strict";
+
+/* eslint-disable no-console */
+const spawn = require('./spawn');
+const util = require('../util');
+const state = require('../tasks/state');
+const os = require('os');
+const chalk = require('chalk');
+const prettyBytes = require('pretty-bytes');
+const _ = require('lodash');
+
+// color for numbers and show values
+const g = chalk.green;
+// color for paths
+const p = chalk.cyan;
+const red = chalk.red;
+// urls
+const link = chalk.blue.underline;
+
+// to be exported
+const methods = {};
+methods.findProxyEnvironmentVariables = () => {
+  return _.pick(process.env, ['HTTP_PROXY', 'HTTPS_PROXY', 'NO_PROXY']);
+};
+const maskSensitiveVariables = obj => {
+  const masked = {
+    ...obj
+  };
+  if (masked.CYPRESS_RECORD_KEY) {
+    masked.CYPRESS_RECORD_KEY = '<redacted>';
+  }
+  return masked;
+};
+methods.findCypressEnvironmentVariables = () => {
+  const isCyVariable = (val, key) => key.startsWith('CYPRESS_');
+  return _.pickBy(process.env, isCyVariable);
+};
+const formatCypressVariables = () => {
+  const vars = methods.findCypressEnvironmentVariables();
+  return maskSensitiveVariables(vars);
+};
+methods.start = async (options = {}) => {
+  const args = ['--mode=info'];
+  await spawn.start(args, {
+    dev: options.dev
+  });
+  console.log();
+  const proxyVars = methods.findProxyEnvironmentVariables();
+  if (_.isEmpty(proxyVars)) {
+    console.log('Proxy Settings: none detected');
+  } else {
+    console.log('Proxy Settings:');
+    _.forEach(proxyVars, (value, key) => {
+      console.log('%s: %s', key, g(value));
+    });
+    console.log();
+    console.log('Learn More: %s', link('https://on.cypress.io/proxy-configuration'));
+    console.log();
+  }
+  const cyVars = formatCypressVariables();
+  if (_.isEmpty(cyVars)) {
+    console.log('Environment Variables: none detected');
+  } else {
+    console.log('Environment Variables:');
+    _.forEach(cyVars, (value, key) => {
+      console.log('%s: %s', key, g(value));
+    });
+  }
+  console.log();
+  console.log('Application Data:', p(util.getApplicationDataFolder()));
+  console.log('Browser Profiles:', p(util.getApplicationDataFolder('browsers')));
+  console.log('Binary Caches: %s', p(state.getCacheDir()));
+  console.log();
+  const osVersion = await util.getOsVersionAsync();
+  const buildInfo = util.pkgBuildInfo();
+  const isStable = buildInfo && buildInfo.stable;
+  console.log('Cypress Version: %s', g(util.pkgVersion()), isStable ? g('(stable)') : red('(pre-release)'));
+  console.log('System Platform: %s (%s)', g(os.platform()), g(osVersion));
+  console.log('System Memory: %s free %s', g(prettyBytes(os.totalmem())), g(prettyBytes(os.freemem())));
+  if (!buildInfo) {
+    console.log();
+    console.log('This is the', red('development'), '(un-built) Cypress CLI.');
+  } else if (!isStable) {
+    console.log();
+    console.log('This is a', red('pre-release'), 'build of Cypress.');
+    console.log('Build info:');
+    console.log('  Commit SHA:', g(buildInfo.commitSha));
+    console.log('  Commit Branch:', g(buildInfo.commitBranch));
+    console.log('  Commit Date:', g(buildInfo.commitDate));
+  }
+};
+module.exports = methods;

CyLukTs/lukan/node_modules/cypress/lib/exec/open.js

@@ -0,0 +1,90 @@
+"use strict";
+
+const debug = require('debug')('cypress:cli');
+const util = require('../util');
+const spawn = require('./spawn');
+const verify = require('../tasks/verify');
+const {
+  processTestingType,
+  checkConfigFile
+} = require('./shared');
+const {
+  exitWithError
+} = require('../errors');
+
+/**
+ * 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.isInstalledGlobally() && !options.global && !options.project) {
+    options.project = process.cwd();
+  }
+  const args = [];
+  if (options.config) {
+    args.push('--config', options.config);
+  }
+  if (options.configFile !== undefined) {
+    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(...processTestingType(options));
+  debug('opening from options %j', options);
+  debug('command line arguments %j', args);
+  return args;
+};
+module.exports = {
+  processOpenOptions,
+  start(options = {}) {
+    function open() {
+      try {
+        const args = processOpenOptions(options);
+        return spawn.start(args, {
+          dev: options.dev,
+          detached: Boolean(options.detached)
+        });
+      } catch (err) {
+        if (err.details) {
+          return exitWithError(err.details)();
+        }
+        throw err;
+      }
+    }
+    if (options.dev) {
+      return open();
+    }
+    return verify.start().then(open);
+  }
+};

CyLukTs/lukan/node_modules/cypress/lib/exec/run.js

@@ -0,0 +1,173 @@
+"use strict";
+
+const _ = require('lodash');
+const debug = require('debug')('cypress:cli:run');
+const util = require('../util');
+const spawn = require('./spawn');
+const verify = require('../tasks/verify');
+const {
+  exitWithError,
+  errors
+} = require('../errors');
+const {
+  processTestingType,
+  throwInvalidOptionError,
+  checkConfigFile
+} = require('./shared');
+
+/**
+ * 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 throwInvalidOptionError(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) {
+    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 throwInvalidOptionError(errors.incompatibleHeadlessFlags);
+    }
+    args.push('--headed', !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.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 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(...processTestingType(options));
+  return args;
+};
+module.exports = {
+  processRunOptions,
+  isValidProject,
+  // resolves with the number of failed tests
+  start(options = {}) {
+    _.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.start(args, {
+          dev: options.dev
+        });
+      } catch (err) {
+        if (err.details) {
+          return exitWithError(err.details)();
+        }
+        throw err;
+      }
+    }
+    if (options.dev) {
+      return run();
+    }
+    return verify.start().then(run);
+  }
+};

CyLukTs/lukan/node_modules/cypress/lib/exec/shared.js

@@ -0,0 +1,62 @@
+"use strict";
+
+const {
+  errors
+} = 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;
+};
+
+/**
+ * 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 [];
+};
+
+/**
+ * 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);
+  }
+};
+module.exports = {
+  throwInvalidOptionError,
+  processTestingType,
+  checkConfigFile
+};

CyLukTs/lukan/node_modules/cypress/lib/exec/spawn.js

@@ -0,0 +1,289 @@
+"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 debugElectron = require('debug')('cypress:electron');
+const util = require('../util');
+const state = require('../tasks/state');
+const xvfb = require('./xvfb');
+const verify = require('../tasks/verify');
+const errors = require('../errors');
+const isXlibOrLibudevRe = /^(?:Xlib|libudev)/;
+const isHighSierraWarningRe = /\*\*\* WARNING/;
+const isRenderWorkerRe = /\.RenderWorker-/;
+
+// Chromium (which Electron uses) always makes several attempts to connect to the system dbus.
+// This works fine in most desktop environments, but in a docker container, there is no dbus service
+// and Chromium emits several error lines, similar to these:
+
+// [1957:0406/160550.146820:ERROR:bus.cc(392)] Failed to connect to the bus: Failed to connect to socket /var/run/dbus/system_bus_socket: No such file or directory
+// [1957:0406/160550.147994:ERROR:bus.cc(392)] Failed to connect to the bus: Address does not contain a colon
+
+// These warnings are absolutely harmless. Failure to connect to dbus means that electron won't be able to access the user's
+// credential wallet (none exists in a docker container) and won't show up in the system tray (again, none exists).
+// Failure to connect is expected and normal here, but users frequently misidentify these errors as the cause of their problems.
+
+// https://github.com/cypress-io/cypress/issues/19299
+const isDbusWarning = /Failed to connect to the bus:/;
+
+// Electron began logging these on self-signed certs with 17.0.0-alpha.4.
+// Once this is fixed upstream this regex can be removed: https://github.com/electron/electron/issues/34583
+// Sample:
+// [3801:0606/152837.383892:ERROR:cert_verify_proc_builtin.cc(681)] CertVerifyProcBuiltin for www.googletagmanager.com failed:
+// ----- Certificate i=0 (OU=Cypress Proxy Server Certificate,O=Cypress Proxy CA,L=Internet,ST=Internet,C=Internet,CN=www.googletagmanager.com) -----
+// ERROR: No matching issuer found
+const isCertVerifyProcBuiltin = /(^\[.*ERROR:cert_verify_proc_builtin\.cc|^----- Certificate i=0 \(OU=Cypress Proxy|^ERROR: No matching issuer found$)/;
+
+// Electron logs a benign warning about WebSwapCGLLayer on MacOS v12 and Electron v18 due to a naming collision in shared libraries.
+// Once this is fixed upstream this regex can be removed: https://github.com/electron/electron/issues/33685
+// Sample:
+// objc[60540]: Class WebSwapCGLLayer is implemented in both /System/Library/Frameworks/WebKit.framework/Versions/A/Frameworks/WebCore.framework/Versions/A/Frameworks/libANGLE-shared.dylib (0x7ffa5a006318) and /{path/to/app}/node_modules/electron/dist/Electron.app/Contents/Frameworks/Electron Framework.framework/Versions/A/Libraries/libGLESv2.dylib (0x10f8a89c8). One of the two will be used. Which one is undefined.
+const isMacOSElectronWebSwapCGLLayerWarning = /^objc\[\d+\]: Class WebSwapCGLLayer is implemented in both.*Which one is undefined\./;
+const GARBAGE_WARNINGS = [isXlibOrLibudevRe, isHighSierraWarningRe, isRenderWorkerRe, isDbusWarning, isCertVerifyProcBuiltin, isMacOSElectronWebSwapCGLLayerWarning];
+const isGarbageLineWarning = str => {
+  return _.some(GARBAGE_WARNINGS, re => {
+    return re.test(str);
+  });
+};
+function isPlatform(platform) {
+  return os.platform() === platform;
+}
+function needsStderrPiped(needsXvfb) {
+  return _.some([isPlatform('darwin'), needsXvfb && isPlatform('linux'), util.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';
+}
+module.exports = {
+  isGarbageLineWarning,
+  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'));
+    }
+    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];
+    _.defaults(options, {
+      dev: false,
+      env: process.env,
+      detached: false,
+      stdio: getStdio(needsXvfb)
+    });
+    const spawn = (overrides = {}) => {
+      return new Promise((resolve, reject) => {
+        _.defaults(overrides, {
+          onStderrData: false,
+          electronLogging: false
+        });
+        const {
+          onStderrData,
+          electronLogging
+        } = 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 (electronLogging) {
+          stdioOptions.env.ELECTRON_ENABLE_LOGGING = true;
+        }
+        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 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();
+
+            // bail if this is warning line garbage
+            if (isGarbageLineWarning(str)) {
+              return;
+            }
+
+            // if we have a callback and this explictly returns
+            // false then bail
+            if (onStderrData && onStderrData(str) === false) {
+              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.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;
+            }
+
+            // we should attempt to always slurp up
+            // the stderr logs unless we've explicitly
+            // enabled the electron debug logging
+            if (!debugElectron.enabled) {
+              return false;
+            }
+          }
+        });
+      }
+      return spawn(overrides).then(code => {
+        if (code !== 0 && brokenGtkDisplay) {
+          util.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
+      }, 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);
+  }
+};

CyLukTs/lukan/node_modules/cypress/lib/exec/versions.js

@@ -0,0 +1,53 @@
+"use strict";
+
+const Promise = require('bluebird');
+const debug = require('debug')('cypress:cli');
+const path = require('path');
+const util = require('../util');
+const state = require('../tasks/state');
+const {
+  throwFormErrorText,
+  errors
+} = require('../errors');
+const getVersions = () => {
+  return Promise.try(() => {
+    if (util.getEnv('CYPRESS_RUN_BINARY')) {
+      let envBinaryPath = path.resolve(util.getEnv('CYPRESS_RUN_BINARY'));
+      return state.parseRealPlatformBinaryFolderAsync(envBinaryPath).then(envBinaryDir => {
+        if (!envBinaryDir) {
+          return throwFormErrorText(errors.CYPRESS_RUN_BINARY.notValid(envBinaryPath))();
+        }
+        debug('CYPRESS_RUN_BINARY has binaryDir:', envBinaryDir);
+        return envBinaryDir;
+      }).catch({
+        code: 'ENOENT'
+      }, err => {
+        return throwFormErrorText(errors.CYPRESS_RUN_BINARY.notValid(envBinaryPath))(err.message);
+      });
+    }
+    return state.getBinaryDir();
+  }).then(state.getBinaryPkgAsync).then(pkg => {
+    const versions = {
+      binary: state.getBinaryPkgVersion(pkg),
+      electronVersion: state.getBinaryElectronVersion(pkg),
+      electronNodeVersion: state.getBinaryElectronNodeVersion(pkg)
+    };
+    debug('binary versions %o', versions);
+    return versions;
+  }).then(binaryVersions => {
+    const buildInfo = util.pkgBuildInfo();
+    let packageVersion = util.pkgVersion();
+    if (!buildInfo) packageVersion += ' (development)';else if (!buildInfo.stable) packageVersion += ' (pre-release)';
+    const versions = {
+      package: packageVersion,
+      binary: binaryVersions.binary || 'not installed',
+      electronVersion: binaryVersions.electronVersion || 'not found',
+      electronNodeVersion: binaryVersions.electronNodeVersion || 'not found'
+    };
+    debug('combined versions %o', versions);
+    return versions;
+  });
+};
+module.exports = {
+  getVersions
+};

CyLukTs/lukan/node_modules/cypress/lib/exec/xvfb.js

@@ -0,0 +1,94 @@
+"use strict";
+
+const os = require('os');
+const Promise = require('bluebird');
+const Xvfb = require('@cypress/xvfb');
+const {
+  stripIndent
+} = require('common-tags');
+const Debug = require('debug');
+const {
+  throwFormErrorText,
+  errors
+} = require('../errors');
+const util = require('../util');
+const debug = Debug('cypress:cli');
+const debugXvfb = Debug('cypress:xvfb');
+debug.Debug = debugXvfb.Debug = Debug;
+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 = Promise.promisifyAll(new Xvfb(xvfbOptions));
+module.exports = {
+  _debugXvfb: debugXvfb,
+  // expose for testing
+
+  _xvfb: xvfb,
+  // expose for testing
+
+  _xvfbOptions: xvfbOptions,
+  // expose for testing
+
+  start() {
+    debug('Starting Xvfb');
+    return xvfb.startAsync().return(null).catch({
+      nonZeroExitCode: true
+    }, throwFormErrorText(errors.nonZeroExitCodeXvfb)).catch(err => {
+      if (err.known) {
+        throw err;
+      }
+      return throwFormErrorText(errors.missingXvfb)(err);
+    });
+  },
+  stop() {
+    debug('Stopping Xvfb');
+    return xvfb.stopAsync().return(null).catch(() => {
+      // noop
+    });
+  },
+  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.platform() !== 'linux') {
+      return false;
+    }
+    if (process.env.DISPLAY) {
+      const issueUrl = util.getGitHubIssueUrl(4034);
+      const message = 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 xvfb.startAsync().return(true).catch(err => {
+      debug('Could not verify xvfb: %s', err.message);
+      return false;
+    }).finally(xvfb.stopAsync);
+  }
+};