appium 2.0.0-beta.7 → 2.0.0-beta.71

package/lib/cli/npm.js

@@ -1,175 +0,0 @@
-import path from 'path';
-import semver from 'semver';
-import { exec } from 'teen_process';
-import { mkdirp, util, system } from 'appium-support';
-
-const INSTALL_LOCKFILE = '.appium.install.lock';
-const LINK_LOCKFILE = '.appium.link.lock';
-
-export default class NPM {
-
-  constructor (appiumHome) {
-    this.appiumHome = appiumHome;
-  }
-
-  async exec (cmd, args, opts, execOpts = {}) {
-    let { cwd, json, lockFile } = opts;
-    if (!cwd) {
-      cwd = this.appiumHome;
-    }
-    // ensure the directory we want to install inside of exists
-    await mkdirp(cwd);
-
-    // make sure we perform the current operation in cwd
-    execOpts = {...execOpts, cwd};
-
-    args.unshift(cmd);
-    if (json) {
-      args.push('-json');
-    }
-    const npmCmd = system.isWindows() ? 'npm.cmd' : 'npm';
-    let runner = async () => await exec(npmCmd, args, execOpts);
-    if (lockFile) {
-      const acquireLock = util.getLockFileGuard(path.resolve(cwd, lockFile));
-      const _runner = runner;
-      runner = async () => await acquireLock(_runner);
-    }
-    const {stdout, stderr, code} = await runner();
-    const ret = {stdout, stderr, code, json: null};
-
-    if (json) {
-      // if possible, parse NPM's json output. During NPM install 3rd-party
-      // packages can write to stdout, so sometimes the json output can't be
-      // guaranteed to be parseable
-      try {
-        ret.json = JSON.parse(stdout);
-      } catch (ign) {}
-    }
-
-    return ret;
-  }
-
-  async getLatestVersion (pkg) {
-    return (await this.exec('view', [pkg, 'dist-tags'], {
-      json: true
-    })).json.latest;
-  }
-
-  async getLatestSafeUpgradeVersion (pkg, curVersion) {
-    const allVersions = (await this.exec('view', [pkg, 'versions'], {
-      json: true
-    })).json;
-    return this.getLatestSafeUpgradeFromVersions(curVersion, allVersions);
-  }
-
-  /**
-   * Given a current version and a list of all versions for a package, return the version which is
-   * the highest safely-upgradable version (meaning not crossing any major revision boundaries, and
-   * not including any alpha/beta/rc versions)
-   *
-   * @param {string} curVersion - the current version of a package
-   * @param {Array<string>} allVersions - a list of version strings
-   *
-   * @return {string|null} - the highest safely-upgradable version, or null if there isn't one
-   */
-  getLatestSafeUpgradeFromVersions (curVersion, allVersions) {
-    let safeUpgradeVer = null;
-    const curSemver = semver.parse(curVersion);
-    if (curSemver === null) {
-      throw new Error(`Could not parse current version '${curVersion}'`);
-    }
-    for (const testVer of allVersions) {
-      const testSemver = semver.parse(testVer);
-      if (testSemver === null) {
-        throw new Error(`Could not parse version to test against: '${testVer}'`);
-      }
-      // if the test version is a prerelease, ignore it
-      if (testSemver.prerelease.length > 0) {
-        continue;
-      }
-      // if the current version is later than the test version, skip this test version
-      if (curSemver.compare(testSemver) === 1) {
-        continue;
-      }
-      // if the test version is newer, but crosses a major revision boundary, also skip it
-      if (testSemver.major > curSemver.major) {
-        continue;
-      }
-      // otherwise this version is safe to upgrade to. But there might be multiple ones of this
-      // kind, so keep iterating and keeping the highest
-      if (safeUpgradeVer === null || testSemver.compare(safeUpgradeVer) === 1) {
-        safeUpgradeVer = testSemver;
-      }
-    }
-    if (safeUpgradeVer) {
-      safeUpgradeVer = safeUpgradeVer.format();
-    }
-    return safeUpgradeVer;
-  }
-
-  async installPackage ({pkgDir, pkgName, pkgVer}) {
-    const res = await this.exec('install', [
-      '--no-save',
-      '--no-package-lock',
-      pkgVer ? `${pkgName}@${pkgVer}` : pkgName
-    ], {
-      cwd: pkgDir,
-      json: true,
-      lockFile: INSTALL_LOCKFILE
-    });
-
-    if (res.json) {
-      // we parsed a valid json response, so if we got an error here, return that
-      // message straightaway
-      if (res.json.error) {
-        throw new Error(res.json.error);
-      }
-    }
-
-    // Now read package data from the installed package to return, and make sure
-    // everything got installed ok. Remember, pkgName might end up with a / in it due to an npm
-    // org, so if so, that will get correctly exploded into multiple directories, by path.resolve here
-    // (even on Windows!)
-    const pkgJson = path.resolve(pkgDir, 'node_modules', pkgName, 'package.json');
-    try {
-      return require(pkgJson);
-    } catch {
-      throw new Error('The package was not downloaded correctly; its package.json ' +
-                      'did not exist or was unreadable. We looked for it at ' +
-                      pkgJson);
-    }
-  }
-
-  async linkPackage (pkgPath) {
-    // from the path alone we don't know the npm package name, so we need to
-    // look in package.json
-    let pkgName;
-    try {
-      pkgName = require(path.resolve(pkgPath, 'package.json')).name;
-    } catch {
-      throw new Error('Could not find package.json inside the package path ' +
-                      `provided: ${pkgPath}`);
-    }
-
-    const pkgHome = path.resolve(this.appiumHome, pkgName);
-    const res = await this.exec('link', [pkgPath], {cwd: pkgHome, lockFile: LINK_LOCKFILE});
-    if (res.json && res.json.error) {
-      throw new Error(res.json.error);
-    }
-
-    // now ensure it was linked to the correct place
-    try {
-      return require(path.resolve(pkgHome, 'node_modules', pkgName, 'package.json'));
-    } catch {
-      throw new Error('The package was not linked correctly; its package.json ' +
-                      'did not exist or was unreadable');
-    }
-  }
-
-  async uninstallPackage (pkgDir, pkg) {
-    await this.exec('uninstall', [pkg], {
-      cwd: pkgDir,
-      lockFile: INSTALL_LOCKFILE
-    });
-  }
-}

package/lib/cli/parser-helpers.js

@@ -1,91 +0,0 @@
-import fs from 'fs';
-import _ from 'lodash';
-import { INSTALL_TYPES } from '../extension-config';
-
-// serverArgs will be added to the `server` (default) subcommand
-function parseSecurityFeatures (features) {
-  const splitter = (splitOn, str) => `${str}`.split(splitOn)
-    .map((s) => s.trim())
-    .filter(Boolean);
-  let parsedFeatures;
-  try {
-    parsedFeatures = splitter(',', features);
-  } catch (err) {
-    throw new TypeError('Could not parse value of --allow/deny-insecure. Should be ' +
-      'a list of strings separated by commas, or a path to a file ' +
-      'listing one feature name per line.');
-  }
-
-  if (parsedFeatures.length === 1 && fs.existsSync(parsedFeatures[0])) {
-    // we might have a file which is a list of features
-    try {
-      const fileFeatures = fs.readFileSync(parsedFeatures[0], 'utf8');
-      parsedFeatures = splitter('\n', fileFeatures);
-    } catch (err) {
-      throw new TypeError(`Attempted to read --allow/deny-insecure feature names ` +
-        `from file ${parsedFeatures[0]} but got error: ${err.message}`);
-    }
-  }
-
-  return parsedFeatures;
-}
-
-function parsePluginNames (names) {
-  if (!_.isString(names)) {
-    throw new TypeError('To parse plugin names, names must be a CSV string');
-  }
-
-  try {
-    return names.split(',').map((s) => s.trim()).filter(Boolean);
-  } catch (err) {
-    throw new TypeError('Could not parse value of --plugins. Should be a list of plugin names ' +
-                    'separated by commas. Plugin names are those found when running `appium ' +
-                    'plugin list`');
-  }
-}
-
-function parseDefaultCaps (capsOrPath) {
-  let caps = capsOrPath;
-  let loadedFromFile = false;
-  try {
-    // use synchronous file access, as `argparse` provides no way of either
-    // awaiting or using callbacks. This step happens in startup, in what is
-    // effectively command-line code, so nothing is blocked in terms of
-    // sessions, so holding up the event loop does not incur the usual
-    // drawbacks.
-    if (_.isString(capsOrPath) && fs.statSync(capsOrPath).isFile()) {
-      caps = fs.readFileSync(capsOrPath, 'utf8');
-      loadedFromFile = true;
-    }
-  } catch (err) {
-    // not a file, or not readable
-  }
-  try {
-    const result = JSON.parse(caps);
-    if (!_.isPlainObject(result)) {
-      throw new Error(`'${_.truncate(result, {length: 100})}' is not an object`);
-    }
-    return result;
-  } catch (e) {
-    const msg = loadedFromFile
-      ? `Default capabilities in '${capsOrPath}' must be a valid JSON`
-      : `Default capabilities must be a valid JSON`;
-    throw new TypeError(`${msg}. Original error: ${e.message}`);
-  }
-}
-
-function parseInstallTypes (source) {
-  if (!_.includes(INSTALL_TYPES, source)) {
-    throw `Argument to --source was '${source}', which is not a valid ` +
-          `driver source type. It must be one of ${JSON.stringify(INSTALL_TYPES)}`;
-  }
-
-  return source;
-}
-
-export {
-  parseSecurityFeatures,
-  parseDefaultCaps,
-  parseInstallTypes,
-  parsePluginNames,
-};

package/lib/driver-config.js

@@ -1,46 +0,0 @@
-import _ from 'lodash';
-import ExtensionConfig, { DRIVER_TYPE } from './extension-config';
-
-export default class DriverConfig extends ExtensionConfig {
-  constructor (appiumHome, logFn = null) {
-    super(appiumHome, DRIVER_TYPE, logFn);
-  }
-
-  getConfigProblems (driver) {
-    const problems = [];
-    const automationNames = [];
-    const {platformNames, automationName} = driver;
-
-    if (!_.isArray(platformNames)) {
-      problems.push({
-        err: 'Missing or incorrect supported platformName list.',
-        val: platformNames
-      });
-    } else {
-      for (const pName of platformNames) {
-        if (!_.isString(pName)) {
-          problems.push({err: 'Incorrectly formatted platformName.', val: pName});
-        }
-      }
-    }
-
-    if (!_.isString(automationName)) {
-      problems.push({err: 'Missing or incorrect automationName', val: automationName});
-    }
-
-    if (_.includes(automationNames, automationName)) {
-      problems.push({
-        err: 'Multiple drivers claim support for the same automationName',
-        val: automationName
-      });
-    }
-    automationNames.push(automationName);
-
-    return problems;
-  }
-
-  extensionDesc (driverName, {version, automationName}) {
-    return `${driverName}@${version} (automationName '${automationName}')`;
-  }
-}
-

package/lib/drivers.js

@@ -1,84 +0,0 @@
-import _ from 'lodash';
-import log from './logger';
-
-
-// This is a map of driver names to npm packages representing those drivers.
-// The drivers in this list will be available to the CLI so users can just
-// type 'appium driver install 'name'', rather than having to specify the full
-// npm package. I.e., these are the officially recognized drivers.
-const KNOWN_DRIVERS = {
-  uiautomator2: 'appium-uiautomator2-driver',
-  xcuitest: 'appium-xcuitest-driver',
-  youiengine: 'appium-youiengine-driver',
-  windows: 'appium-windows-driver',
-  mac: 'appium-mac-driver',
-  mac2: 'appium-mac2-driver',
-  espresso: 'appium-espresso-driver',
-  tizen: 'appium-tizen-driver',
-  flutter: 'appium-flutter-driver',
-  safari: 'appium-safari-driver',
-  gecko: 'appium-geckodriver',
-};
-
-function getDriverBySupport (drivers, matchAutomationName, matchPlatformName) {
-  for (const [driverName, driverData] of _.toPairs(drivers)) {
-    const {automationName, platformNames} = driverData;
-    const aNameMatches = automationName.toLowerCase() === matchAutomationName.toLowerCase();
-    const pNameMatches = _.includes(platformNames.map(_.toLower),
-                                    matchPlatformName.toLowerCase());
-
-    if (aNameMatches && pNameMatches) {
-      return {driverName, ...driverData};
-    }
-
-    if (aNameMatches) {
-      throw new Error(`Driver '${driverName}' supports automationName ` +
-                      `'${automationName}', but Appium could not find ` +
-                      `support for platformName '${matchPlatformName}'. Supported ` +
-                      `platformNames are: ` +
-                      JSON.stringify(platformNames));
-    }
-  }
-
-  throw new Error(`Could not find installed driver to support given caps`);
-}
-
-function findMatchingDriver (config, {automationName, platformName}) {
-  if (!_.isString(platformName)) {
-    throw new Error('You must include a platformName capability');
-  }
-
-  if (!_.isString(automationName)) {
-    throw new Error('You must include an automationName capability');
-  }
-
-  log.info(`Attempting to find matching driver for automationName ` +
-           `'${automationName}' and platformName '${platformName}'`);
-
-  try {
-    const {
-      driverName,
-      mainClass,
-      version,
-    } = getDriverBySupport(config.installedExtensions, automationName, platformName);
-    log.info(`The '${driverName}' driver was installed and matched caps.`);
-    log.info(`Will require it at ${config.getExtensionRequirePath(driverName)}`);
-    const driver = config.require(driverName);
-    if (!driver) {
-      throw new Error(`MainClass ${mainClass} did not result in a driver object`);
-    }
-    return {driver, version};
-  } catch (err) {
-    const msg = `Could not find a driver for automationName ` +
-                `'${automationName}' and platformName ${platformName}'. ` +
-                `Have you installed a driver that supports those ` +
-                `capabilities? Run 'appium driver list --installed' to see. ` +
-                `(Lower-level error: ${err.message})`;
-    throw new Error(msg);
-  }
-}
-
-export {
-  findMatchingDriver,
-  KNOWN_DRIVERS,
-};

package/lib/extension-config.js

@@ -1,209 +0,0 @@
-import _ from 'lodash';
-import log from './logger';
-import { fs, mkdirp } from 'appium-support';
-import path from 'path';
-import os from 'os';
-import YAML from 'yaml';
-
-const DRIVER_TYPE = 'driver';
-const PLUGIN_TYPE = 'plugin';
-const DEFAULT_APPIUM_HOME = path.resolve(os.homedir(), '.appium');
-
-const CONFIG_FILE_NAME = 'extensions.yaml';
-const CONFIG_SCHEMA_REV = 2;
-
-const INSTALL_TYPE_NPM = 'npm';
-const INSTALL_TYPE_LOCAL = 'local';
-const INSTALL_TYPE_GITHUB = 'github';
-const INSTALL_TYPE_GIT = 'git';
-const INSTALL_TYPES = [
-  INSTALL_TYPE_GIT,
-  INSTALL_TYPE_GITHUB,
-  INSTALL_TYPE_LOCAL,
-  INSTALL_TYPE_NPM
-];
-
-
-export default class ExtensionConfig {
-  constructor (appiumHome, extensionType, logFn = null) {
-    if (logFn === null) {
-      logFn = log.error.bind(log);
-    }
-    this.appiumHome = appiumHome;
-    this.configFile = path.resolve(this.appiumHome, CONFIG_FILE_NAME);
-    this.installedExtensions = {};
-    this.extensionType = extensionType;
-    this.configKey = `${extensionType}s`;
-    this.yamlData = {[`${DRIVER_TYPE}s`]: {}, [`${PLUGIN_TYPE}s`]: {}};
-    this.log = logFn;
-  }
-
-  validate (exts) {
-    const foundProblems = {};
-    for (const [extName, extData] of _.toPairs(exts)) {
-      foundProblems[extName] = [
-        ...this.getGenericConfigProblems(extData),
-        ...this.getConfigProblems(extData)
-      ];
-    }
-
-    const problemSummaries = [];
-    for (const [extName, problems] of _.toPairs(foundProblems)) {
-      if (_.isEmpty(problems)) {
-        continue;
-      }
-      // remove this extension from the list since it's not valid
-      delete exts[extName];
-      problemSummaries.push(`${this.extensionType} ${extName} had errors and will not ` +
-                            `be available. Errors:`);
-      for (const problem of problems) {
-        problemSummaries.push(`  - ${problem.err} (Actual value: ` +
-                              `${JSON.stringify(problem.val)})`);
-      }
-    }
-
-    if (!_.isEmpty(problemSummaries)) {
-      this.log(`Appium encountered one or more errors while validating ` +
-               `the ${this.configKey} extension file (${this.configFile}):`);
-      for (const summary of problemSummaries) {
-        this.log(summary);
-      }
-    }
-
-    return exts;
-  }
-
-  getGenericConfigProblems (ext) {
-    const {version, pkgName, installSpec, installType, installPath, mainClass} = ext;
-    const problems = [];
-
-    if (!_.isString(version)) {
-      problems.push({err: 'Missing or incorrect version', val: version});
-    }
-
-    if (!_.isString(pkgName)) {
-      problems.push({err: 'Missing or incorrect NPM package name', val: pkgName});
-    }
-
-    if (!_.isString(installSpec)) {
-      problems.push({err: 'Missing or incorrect installation spec', val: installSpec});
-    }
-
-    if (!_.includes(INSTALL_TYPES, installType)) {
-      problems.push({err: 'Missing or incorrect install type', val: installType});
-    }
-
-    if (!_.isString(installPath)) {
-      problems.push({err: 'Missing or incorrect installation path', val: installPath});
-    }
-
-    if (!_.isString(mainClass)) {
-      problems.push({err: 'Missing or incorrect driver class name', val: mainClass});
-    }
-
-    return problems;
-  }
-
-  getConfigProblems (/*ext*/) {
-    // shoud override this method if special validation is necessary for this extension type
-    return [];
-  }
-
-  applySchemaMigrations () {
-    if (this.yamlData.schemaRev < 2 && _.isUndefined(this.yamlData[PLUGIN_TYPE])) {
-      // at schema revision 2, we started including plugins as well as drivers in the file,
-      // so make sure we at least have an empty section for it
-      this.yamlData[PLUGIN_TYPE] = {};
-    }
-  }
-
-  async read () {
-    await mkdirp(this.appiumHome); // ensure appium home exists
-    try {
-      this.yamlData = YAML.parse(await fs.readFile(this.configFile, 'utf8'));
-      this.applySchemaMigrations();
-
-      // set the list of drivers the user has installed
-      this.installedExtensions = this.validate(this.yamlData[this.configKey]);
-    } catch (err) {
-      if (await fs.exists(this.configFile)) {
-        // if the file exists and we couldn't parse it, that's a problem
-        throw new Error(`Appium had trouble loading the extension installation ` +
-                        `cache file (${this.configFile}). Ensure it exists and is ` +
-                        `readable. Specific error: ${err.message}`);
-      }
-
-      // if the config file doesn't exist, try to write an empty one, to make
-      // sure we actually have write privileges, and complain if we don't
-      try {
-        await this.write();
-      } catch {
-        throw new Error(`Appium could not read or write from the Appium Home directory ` +
-                        `(${this.appiumHome}). Please ensure it is writable.`);
-      }
-    }
-    return this.installedExtensions;
-  }
-
-
-  async write () {
-    const newYamlData = {
-      ...this.yamlData,
-      schemaRev: CONFIG_SCHEMA_REV,
-      [this.configKey]: this.installedExtensions
-    };
-    await fs.writeFile(this.configFile, YAML.stringify(newYamlData), 'utf8');
-  }
-
-  async addExtension (extName, extData) {
-    this.installedExtensions[extName] = extData;
-    await this.write();
-  }
-
-  async removeExtension (extName) {
-    delete this.installedExtensions[extName];
-    await this.write();
-  }
-
-  print () {
-    const extNames = Object.keys(this.installedExtensions);
-    if (_.isEmpty(extNames)) {
-      log.info(`No ${this.configKey} have been installed. Use the "appium ${this.extensionType}" ` +
-               'command to install the one(s) you want to use.');
-      return;
-    }
-
-    log.info(`Available ${this.configKey}:`);
-    for (const [extName, extData] of _.toPairs(this.installedExtensions)) {
-      log.info(`  - ${this.extensionDesc(extName, extData)}`);
-    }
-  }
-
-  extensionDesc () {
-    throw new Error('This must be implemented in a final class');
-  }
-
-  getExtensionRequirePath (extName) {
-    const {pkgName, installPath} = this.installedExtensions[extName];
-    return path.resolve(this.appiumHome, installPath, 'node_modules', pkgName);
-  }
-
-  getInstallPath (extName) {
-    const {installPath} = this.installedExtensions[extName];
-    return path.resolve(this.appiumHome, installPath);
-  }
-
-  require (extName) {
-    const {mainClass} = this.installedExtensions[extName];
-    return require(this.getExtensionRequirePath(extName))[mainClass];
-  }
-
-  isInstalled (extName) {
-    return _.includes(Object.keys(this.installedExtensions), extName);
-  }
-}
-
-export {
-  INSTALL_TYPE_NPM, INSTALL_TYPE_GIT, INSTALL_TYPE_LOCAL, INSTALL_TYPE_GITHUB,
-  INSTALL_TYPES, DEFAULT_APPIUM_HOME, DRIVER_TYPE, PLUGIN_TYPE,
-};

package/lib/plugin-config.js

@@ -1,34 +0,0 @@
-import _ from 'lodash';
-import ExtensionConfig, { PLUGIN_TYPE } from './extension-config';
-import log from './logger';
-
-export default class PluginConfig extends ExtensionConfig {
-  constructor (appiumHome, logFn = null) {
-    super(appiumHome, PLUGIN_TYPE, logFn);
-  }
-
-  extensionDesc (pluginName, {version}) {
-    return `${pluginName}@${version}`;
-  }
-
-  print (activePlugins) {
-    const pluginNames = Object.keys(this.installedExtensions);
-    const activeNames = activePlugins.map((p) => p.name);
-
-    if (_.isEmpty(pluginNames)) {
-      log.info(`No plugins have been installed. Use the "appium plugin" ` +
-               'command to install the one(s) you want to use.');
-      return;
-    }
-
-    log.info(`Available plugins:`);
-    for (const [pluginName, pluginData] of _.toPairs(this.installedExtensions)) {
-      const activeTxt = _.includes(activeNames, pluginName) ? ' (ACTIVE)' : '';
-      log.info(`  - ${this.extensionDesc(pluginName, pluginData)}${activeTxt}`);
-    }
-
-    if (_.isEmpty(activePlugins)) {
-      log.info('No plugins activated. Use the --plugins flag with names of plugins to activate');
-    }
-  }
-}

package/lib/plugins.js

@@ -1,10 +0,0 @@
-// This is a map of plugin names to npm packages representing those plugins.
-// The plugins in this list will be available to the CLI so users can just
-// type 'appium plugin install 'name'', rather than having to specify the full
-// npm package. I.e., these are the officially recognized plugins.
-const KNOWN_PLUGINS = {
-};
-
-export {
-  KNOWN_PLUGINS,
-};