init

node_modules/cypress/lib/tasks/state.js

@@ -0,0 +1,226 @@
+"use strict";
+
+const _ = require('lodash');
+
+const os = require('os');
+
+const path = require('path');
+
+const untildify = require('untildify');
+
+const R = require('ramda');
+
+const debug = require('debug')('cypress:cli');
+
+const fs = require('../fs');
+
+const util = require('../util');
+
+const getPlatformExecutable = () => {
+  const platform = os.platform();
+
+  switch (platform) {
+    case 'darwin':
+      return 'Contents/MacOS/Cypress';
+
+    case 'linux':
+      return 'Cypress';
+
+    case 'win32':
+      return 'Cypress.exe';
+    // TODO handle this error using our standard
+
+    default:
+      throw new Error(`Platform: "${platform}" is not supported.`);
+  }
+};
+
+const getPlatFormBinaryFolder = () => {
+  const platform = os.platform();
+
+  switch (platform) {
+    case 'darwin':
+      return 'Cypress.app';
+
+    case 'linux':
+      return 'Cypress';
+
+    case 'win32':
+      return 'Cypress';
+    // TODO handle this error using our standard
+
+    default:
+      throw new Error(`Platform: "${platform}" is not supported.`);
+  }
+};
+
+const getBinaryPkgPath = binaryDir => {
+  const platform = os.platform();
+
+  switch (platform) {
+    case 'darwin':
+      return path.join(binaryDir, 'Contents', 'Resources', 'app', 'package.json');
+
+    case 'linux':
+      return path.join(binaryDir, 'resources', 'app', 'package.json');
+
+    case 'win32':
+      return path.join(binaryDir, 'resources', 'app', 'package.json');
+    // TODO handle this error using our standard
+
+    default:
+      throw new Error(`Platform: "${platform}" is not supported.`);
+  }
+};
+/**
+ * Get path to binary directory
+*/
+
+
+const getBinaryDir = (version = util.pkgVersion()) => {
+  return path.join(getVersionDir(version), getPlatFormBinaryFolder());
+};
+
+const getVersionDir = (version = util.pkgVersion()) => {
+  return path.join(getCacheDir(), version);
+};
+/**
+ * When executing "npm postinstall" hook, the working directory is set to
+ * "<current folder>/node_modules/cypress", which can be surprising when using relative paths.
+ */
+
+
+const isInstallingFromPostinstallHook = () => {
+  // individual folders
+  const cwdFolders = process.cwd().split(path.sep);
+  const length = cwdFolders.length;
+  return cwdFolders[length - 2] === 'node_modules' && cwdFolders[length - 1] === 'cypress';
+};
+
+const getCacheDir = () => {
+  let cache_directory = util.getCacheDir();
+
+  if (util.getEnv('CYPRESS_CACHE_FOLDER')) {
+    const envVarCacheDir = untildify(util.getEnv('CYPRESS_CACHE_FOLDER'));
+    debug('using environment variable CYPRESS_CACHE_FOLDER %s', envVarCacheDir);
+
+    if (!path.isAbsolute(envVarCacheDir) && isInstallingFromPostinstallHook()) {
+      const packageRootFolder = path.join('..', '..', envVarCacheDir);
+      cache_directory = path.resolve(packageRootFolder);
+      debug('installing from postinstall hook, original root folder is %s', packageRootFolder);
+      debug('and resolved cache directory is %s', cache_directory);
+    } else {
+      cache_directory = path.resolve(envVarCacheDir);
+    }
+  }
+
+  return cache_directory;
+};
+
+const parseRealPlatformBinaryFolderAsync = binaryPath => {
+  return fs.realpathAsync(binaryPath).then(realPath => {
+    debug('CYPRESS_RUN_BINARY has realpath:', realPath);
+
+    if (!realPath.toString().endsWith(getPlatformExecutable())) {
+      return false;
+    }
+
+    if (os.platform() === 'darwin') {
+      return path.resolve(realPath, '..', '..', '..');
+    }
+
+    return path.resolve(realPath, '..');
+  });
+};
+
+const getDistDir = () => {
+  return path.join(__dirname, '..', '..', 'dist');
+};
+/**
+ * Returns full filename to the file that keeps the Test Runner verification state as JSON text.
+ * Note: the binary state file will be stored one level up from the given binary folder.
+ * @param {string} binaryDir - full path to the folder holding the binary.
+ */
+
+
+const getBinaryStatePath = binaryDir => {
+  return path.join(binaryDir, '..', 'binary_state.json');
+};
+
+const getBinaryStateContentsAsync = binaryDir => {
+  const fullPath = getBinaryStatePath(binaryDir);
+  return fs.readJsonAsync(fullPath).catch({
+    code: 'ENOENT'
+  }, SyntaxError, () => {
+    debug('could not read binary_state.json file at "%s"', fullPath);
+    return {};
+  });
+};
+
+const getBinaryVerifiedAsync = binaryDir => {
+  return getBinaryStateContentsAsync(binaryDir).tap(debug).get('verified');
+};
+
+const clearBinaryStateAsync = binaryDir => {
+  return fs.removeAsync(getBinaryStatePath(binaryDir));
+};
+/**
+ * Writes the new binary status.
+ * @param {boolean} verified The new test runner state after smoke test
+ * @param {string} binaryDir Folder holding the binary
+ * @returns {Promise<void>} returns a promise
+ */
+
+
+const writeBinaryVerifiedAsync = (verified, binaryDir) => {
+  return getBinaryStateContentsAsync(binaryDir).then(contents => {
+    return fs.outputJsonAsync(getBinaryStatePath(binaryDir), _.extend(contents, {
+      verified
+    }), {
+      spaces: 2
+    });
+  });
+};
+
+const getPathToExecutable = binaryDir => {
+  return path.join(binaryDir, getPlatformExecutable());
+};
+/**
+ * Resolves with an object read from the binary app package.json file.
+ * If the file does not exist resolves with null
+ */
+
+
+const getBinaryPkgAsync = binaryDir => {
+  const pathToPackageJson = getBinaryPkgPath(binaryDir);
+  debug('Reading binary package.json from:', pathToPackageJson);
+  return fs.pathExistsAsync(pathToPackageJson).then(exists => {
+    if (!exists) {
+      return null;
+    }
+
+    return fs.readJsonAsync(pathToPackageJson);
+  });
+};
+
+const getBinaryPkgVersion = R.propOr(null, 'version');
+const getBinaryElectronVersion = R.propOr(null, 'electronVersion');
+const getBinaryElectronNodeVersion = R.propOr(null, 'electronNodeVersion');
+module.exports = {
+  getPathToExecutable,
+  getPlatformExecutable,
+  // those names start to sound like Java
+  getBinaryElectronNodeVersion,
+  getBinaryElectronVersion,
+  getBinaryPkgVersion,
+  getBinaryVerifiedAsync,
+  getBinaryPkgAsync,
+  getBinaryPkgPath,
+  getBinaryDir,
+  getCacheDir,
+  clearBinaryStateAsync,
+  writeBinaryVerifiedAsync,
+  parseRealPlatformBinaryFolderAsync,
+  getDistDir,
+  getVersionDir
+};