appium 2.0.0-beta.2 → 2.0.0-beta.23

package/build/test/cli/cli-e2e-specs.js

@@ -0,0 +1,221 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("source-map-support/register");
+
+var _path = _interopRequireDefault(require("path"));
+
+var _support = require("@appium/support");
+
+var _drivers = require("../../lib/drivers");
+
+var _helpers = require("../helpers");
+
+var _cliHelpers = require("./cli-helpers");
+
+describe('CLI', function () {
+  let appiumHome;
+  let run;
+  before(async function () {
+    appiumHome = await _support.tempDir.openDir();
+    const runner = (0, _cliHelpers.runAppium)(appiumHome);
+
+    run = async (extCommand, args = [], raw = false, ext = 'driver') => await runner([ext, extCommand, ...args], {
+      raw
+    });
+  });
+  after(async function () {
+    await _support.fs.rimraf(appiumHome);
+  });
+
+  async function clear() {
+    await _support.fs.rimraf(appiumHome);
+    await (0, _support.mkdirp)(appiumHome);
+  }
+
+  describe('Driver CLI', function () {
+    const localFakeDriverPath = _path.default.join(_helpers.PROJECT_ROOT, 'packages', 'fake-driver');
+
+    describe('list', function () {
+      it('should list available drivers', async function () {
+        const stdout = await run('list');
+
+        for (const d of Object.keys(_drivers.KNOWN_DRIVERS)) {
+          stdout.should.match(new RegExp(`${d}.+[not installed]`));
+        }
+      });
+      it('should list available drivers in json format', async function () {
+        const driverData = JSON.parse(await run('list', ['--json']));
+
+        for (const d of Object.keys(_drivers.KNOWN_DRIVERS)) {
+          driverData[d].should.eql({
+            installed: false,
+            pkgName: _drivers.KNOWN_DRIVERS[d]
+          });
+        }
+      });
+      it('should allow filtering by installed drivers', async function () {
+        const out = await run('list', ['--installed', '--json']);
+        JSON.parse(out).should.eql({});
+      });
+      it('should show updates for installed drivers with --updates', async function () {
+        const penultimateFakeDriverVersionAsOfRightNow = '3.0.4';
+        await clear();
+        await run('install', [`@appium/fake-driver@${penultimateFakeDriverVersionAsOfRightNow}`, '--source', 'npm', '--json']);
+        const {
+          fake
+        } = JSON.parse(await run('list', ['--updates', '--json']));
+        _support.util.compareVersions(fake.updateVersion, '>', penultimateFakeDriverVersionAsOfRightNow).should.be.true;
+        const stdout = await run('list', ['--updates']);
+        stdout.should.match(new RegExp(`fake.+[${fake.updateVersion} available]`));
+      });
+    });
+    describe('install', function () {
+      it('should install a driver from the list of known drivers', async function () {
+        await clear();
+        const ret = JSON.parse(await run('install', ['uiautomator2', '--json']));
+        ret.uiautomator2.pkgName.should.eql('appium-uiautomator2-driver');
+        ret.uiautomator2.installType.should.eql('npm');
+        ret.uiautomator2.installSpec.should.eql('uiautomator2');
+        const list = JSON.parse(await run('list', ['--installed', '--json']));
+        delete list.uiautomator2.installed;
+        list.should.eql(ret);
+      });
+      it('should install a driver from npm', async function () {
+        await clear();
+        const ret = JSON.parse(await run('install', ['@appium/fake-driver', '--source', 'npm', '--json']));
+        ret.fake.pkgName.should.eql('@appium/fake-driver');
+        ret.fake.installType.should.eql('npm');
+        ret.fake.installSpec.should.eql('@appium/fake-driver');
+        const list = JSON.parse(await run('list', ['--installed', '--json']));
+        delete list.fake.installed;
+        list.should.eql(ret);
+      });
+      it('should install a driver from npm with a specific version/tag', async function () {
+        const currentFakeDriverVersionAsOfRightNow = '3.0.5';
+        await clear();
+        const installSpec = `@appium/fake-driver@${currentFakeDriverVersionAsOfRightNow}`;
+        const ret = JSON.parse(await run('install', [installSpec, '--source', 'npm', '--json']));
+        ret.fake.pkgName.should.eql('@appium/fake-driver');
+        ret.fake.installType.should.eql('npm');
+        ret.fake.installSpec.should.eql(installSpec);
+        const list = JSON.parse(await run('list', ['--installed', '--json']));
+        delete list.fake.installed;
+        list.should.eql(ret);
+      });
+      it('should install a driver from github', async function () {
+        await clear();
+        const ret = JSON.parse(await run('install', ['appium/appium-fake-driver', '--source', 'github', '--package', 'appium-fake-driver', '--json']));
+        ret.fake.pkgName.should.eql('appium-fake-driver');
+        ret.fake.installType.should.eql('github');
+        ret.fake.installSpec.should.eql('appium/appium-fake-driver');
+        const list = JSON.parse(await run('list', ['--installed', '--json']));
+        delete list.fake.installed;
+        list.should.eql(ret);
+      });
+      it('should install a driver from a local git repo', async function () {
+        await clear();
+        const ret = JSON.parse(await run('install', [localFakeDriverPath, '--source', 'git', '--package', '@appium/fake-driver', '--json']));
+        ret.fake.pkgName.should.eql('@appium/fake-driver');
+        ret.fake.installType.should.eql('git');
+        ret.fake.installSpec.should.eql(localFakeDriverPath);
+        const list = JSON.parse(await run('list', ['--installed', '--json']));
+        delete list.fake.installed;
+        list.should.eql(ret);
+      });
+      it('should install a driver from a remote git repo', async function () {
+        await clear();
+        const ret = JSON.parse(await run('install', ['git+https://github.com/appium/appium-fake-driver.git', '--source', 'git', '--package', 'appium-fake-driver', '--json']));
+        ret.fake.pkgName.should.eql('appium-fake-driver');
+        ret.fake.installType.should.eql('git');
+        ret.fake.installSpec.should.eql('git+https://github.com/appium/appium-fake-driver');
+        const list = JSON.parse(await run('list', ['--installed', '--json']));
+        delete list.fake.installed;
+        list.should.eql(ret);
+      });
+      it('should install a driver from a local npm module', async function () {
+        await clear();
+        const ret = JSON.parse(await run('install', [localFakeDriverPath, '--source', 'local', '--json']));
+        ret.fake.pkgName.should.eql('@appium/fake-driver');
+        ret.fake.installType.should.eql('local');
+        ret.fake.installSpec.should.eql(localFakeDriverPath);
+        const list = JSON.parse(await run('list', ['--installed', '--json']));
+        delete list.fake.installed;
+        list.should.eql(ret);
+      });
+    });
+    describe('uninstall', function () {
+      it('should uninstall a driver based on its driver name', async function () {
+        await clear();
+        const ret = JSON.parse(await run('install', ['@appium/fake-driver', '--source', 'npm', '--json']));
+
+        const installPath = _path.default.resolve(appiumHome, ret.fake.installPath);
+
+        await _support.fs.exists(installPath).should.eventually.be.true;
+        let list = JSON.parse(await run('list', ['--installed', '--json']));
+        list.fake.installed.should.be.true;
+        const uninstall = JSON.parse(await run('uninstall', ['fake', '--json']));
+        uninstall.should.not.have.key('fake');
+        await _support.fs.exists(installPath).should.eventually.be.false;
+      });
+    });
+    describe('run', function () {
+      before(async function () {
+        await clear();
+        await run('install', [localFakeDriverPath, '--source', 'local', '--json']);
+      });
+      it('should run a valid driver, valid script, and result in success', async function () {
+        const driverName = 'fake';
+        const scriptName = 'fake-success';
+        const out = JSON.parse(await run('run', [driverName, scriptName, '--json']));
+        out.should.not.include.key('error');
+      });
+      it('should run a valid driver, valid error prone script, and return error in json', async function () {
+        const driverName = 'fake';
+        const out = JSON.parse(await run('run', [driverName, 'fake-error', '--json']));
+        out.should.include.key('error');
+      });
+      it('should take a valid driver, invalid script, and throw an error', async function () {
+        const driverName = 'fake';
+        await chai.expect(run('run', [driverName, 'foo', '--json'])).to.eventually.be.rejectedWith(Error);
+      });
+      it('should take an invalid driver, invalid script, and throw an error', async function () {
+        const driverName = 'foo';
+        await chai.expect(run('run', [driverName, 'bar', '--json'])).to.eventually.be.rejectedWith(Error);
+      });
+    });
+  });
+  describe('Plugin CLI', function () {
+    const fakePluginDir = _path.default.dirname(require.resolve('@appium/fake-plugin/package.json'));
+
+    const ext = 'plugin';
+    describe('run', function () {
+      before(async function () {
+        await clear();
+        await run('install', [fakePluginDir, '--source', 'local', '--json'], false, ext);
+      });
+      it('should run a valid plugin, valid script, and result in success', async function () {
+        const pluginName = 'fake';
+        const scriptName = 'fake-success';
+        const out = JSON.parse(await run('run', [pluginName, scriptName, '--json'], false, ext));
+        out.should.not.include.key('error');
+      });
+      it('should run a valid plugin, valid error prone script, and return error in json', async function () {
+        const pluginName = 'fake';
+        const out = JSON.parse(await run('run', [pluginName, 'fake-error', '--json'], false, ext));
+        out.should.include.key('error');
+      });
+      it('should take a valid plugin, invalid script, and throw an error', async function () {
+        const pluginName = 'fake';
+        await chai.expect(run('run', [pluginName, 'foo', '--json'], false, ext)).to.eventually.be.rejectedWith(Error);
+      });
+      it('should take an invalid plugin, invalid script, and throw an error', async function () {
+        await chai.expect(run('run', ['foo', 'bar', '--json'], false, ext)).to.eventually.be.rejectedWith(Error);
+      });
+    });
+  });
+});require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["test/cli/cli-e2e-specs.js"],"names":["describe","appiumHome","run","before","tempDir","openDir","runner","extCommand","args","raw","ext","after","fs","rimraf","clear","localFakeDriverPath","path","join","PROJECT_ROOT","it","stdout","d","Object","keys","KNOWN_DRIVERS","should","match","RegExp","driverData","JSON","parse","eql","installed","pkgName","out","penultimateFakeDriverVersionAsOfRightNow","fake","util","compareVersions","updateVersion","be","true","ret","uiautomator2","installType","installSpec","list","currentFakeDriverVersionAsOfRightNow","installPath","resolve","exists","eventually","uninstall","not","have","key","false","driverName","scriptName","include","chai","expect","to","rejectedWith","Error","fakePluginDir","dirname","require","pluginName"],"mappings":"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","sourcesContent":["\nimport path from 'path';\nimport { tempDir, fs, mkdirp, util } from '@appium/support';\nimport { KNOWN_DRIVERS } from '../../lib/drivers';\nimport { PROJECT_ROOT } from '../helpers';\nimport { runAppium } from './cli-helpers';\n\ndescribe('CLI', function () {\n  /**\n   * @type {string}\n   */\n  let appiumHome;\n\n  /**\n   * @type {(extCommand: string, args?: string[], raw?: boolean, ext?: ExtensionType) => Promise<string|import('./cli-helpers').TeenProcessExecResult>}\n   */\n  let run;\n\n  before(async function () {\n    appiumHome = await tempDir.openDir();\n    const runner = runAppium(appiumHome);\n    run = async (extCommand, args = [], raw = false, ext = 'driver') => await runner([ext, extCommand, ...args], {raw});\n  });\n\n  after(async function () {\n    await fs.rimraf(appiumHome);\n  });\n\n  async function clear () {\n    await fs.rimraf(appiumHome);\n    await mkdirp(appiumHome);\n  }\n\n  describe('Driver CLI', function () {\n    const localFakeDriverPath = path.join(PROJECT_ROOT, 'packages', 'fake-driver');\n    describe('list', function () {\n      it('should list available drivers', async function () {\n        const stdout = await run('list');\n        for (const d of Object.keys(KNOWN_DRIVERS)) {\n          stdout.should.match(new RegExp(`${d}.+[not installed]`));\n        }\n      });\n      it('should list available drivers in json format', async function () {\n        const driverData = JSON.parse(await run('list', ['--json']));\n        for (const d of Object.keys(KNOWN_DRIVERS)) {\n          driverData[d].should.eql({installed: false, pkgName: KNOWN_DRIVERS[d]});\n        }\n      });\n      it('should allow filtering by installed drivers', async function () {\n        const out = await run('list', ['--installed', '--json']);\n        JSON.parse(out).should.eql({});\n      });\n      it('should show updates for installed drivers with --updates', async function () {\n        const penultimateFakeDriverVersionAsOfRightNow = '3.0.4';\n        await clear();\n        await run('install', [`@appium/fake-driver@${penultimateFakeDriverVersionAsOfRightNow}`, '--source', 'npm', '--json']);\n        const {fake} = JSON.parse(await run('list', ['--updates', '--json']));\n        util.compareVersions(fake.updateVersion, '>', penultimateFakeDriverVersionAsOfRightNow).should.be.true;\n        const stdout = await run('list', ['--updates']);\n        stdout.should.match(new RegExp(`fake.+[${fake.updateVersion} available]`));\n      });\n    });\n\n    describe('install', function () {\n      it('should install a driver from the list of known drivers', async function () {\n        await clear();\n        const ret = JSON.parse(await run('install', ['uiautomator2', '--json']));\n        ret.uiautomator2.pkgName.should.eql('appium-uiautomator2-driver');\n        ret.uiautomator2.installType.should.eql('npm');\n        ret.uiautomator2.installSpec.should.eql('uiautomator2');\n        const list = JSON.parse(await run('list', ['--installed', '--json']));\n        delete list.uiautomator2.installed;\n        list.should.eql(ret);\n      });\n      it('should install a driver from npm', async function () {\n        await clear();\n        const ret = JSON.parse(await run('install', ['@appium/fake-driver', '--source', 'npm', '--json']));\n        ret.fake.pkgName.should.eql('@appium/fake-driver');\n        ret.fake.installType.should.eql('npm');\n        ret.fake.installSpec.should.eql('@appium/fake-driver');\n        const list = JSON.parse(await run('list', ['--installed', '--json']));\n        delete list.fake.installed;\n        list.should.eql(ret);\n      });\n      it('should install a driver from npm with a specific version/tag', async function () {\n        const currentFakeDriverVersionAsOfRightNow = '3.0.5';\n        await clear();\n        const installSpec = `@appium/fake-driver@${currentFakeDriverVersionAsOfRightNow}`;\n        const ret = JSON.parse(await run('install', [installSpec, '--source', 'npm', '--json']));\n        ret.fake.pkgName.should.eql('@appium/fake-driver');\n        ret.fake.installType.should.eql('npm');\n        ret.fake.installSpec.should.eql(installSpec);\n        const list = JSON.parse(await run('list', ['--installed', '--json']));\n        delete list.fake.installed;\n        list.should.eql(ret);\n      });\n      it('should install a driver from github', async function () {\n        await clear();\n        const ret = JSON.parse(await run('install', ['appium/appium-fake-driver', '--source',\n          'github', '--package', 'appium-fake-driver', '--json']));\n        ret.fake.pkgName.should.eql('appium-fake-driver');\n        ret.fake.installType.should.eql('github');\n        ret.fake.installSpec.should.eql('appium/appium-fake-driver');\n        const list = JSON.parse(await run('list', ['--installed', '--json']));\n        delete list.fake.installed;\n        list.should.eql(ret);\n      });\n      it('should install a driver from a local git repo', async function () {\n        await clear();\n        const ret = JSON.parse(await run('install', [localFakeDriverPath,\n          '--source', 'git', '--package', '@appium/fake-driver', '--json']));\n        ret.fake.pkgName.should.eql('@appium/fake-driver');\n        ret.fake.installType.should.eql('git');\n        ret.fake.installSpec.should.eql(localFakeDriverPath);\n        const list = JSON.parse(await run('list', ['--installed', '--json']));\n        delete list.fake.installed;\n        list.should.eql(ret);\n      });\n      it('should install a driver from a remote git repo', async function () {\n        await clear();\n        const ret = JSON.parse(await run('install', ['git+https://github.com/appium/appium-fake-driver.git',\n          '--source', 'git', '--package', 'appium-fake-driver', '--json']));\n        ret.fake.pkgName.should.eql('appium-fake-driver');\n        ret.fake.installType.should.eql('git');\n        ret.fake.installSpec.should.eql('git+https://github.com/appium/appium-fake-driver');\n        const list = JSON.parse(await run('list', ['--installed', '--json']));\n        delete list.fake.installed;\n        list.should.eql(ret);\n      });\n      it('should install a driver from a local npm module', async function () {\n        await clear();\n        // take advantage of the fact that we know we have fake driver installed as a dependency in\n        // this module, so we know its local path on disk\n        const ret = JSON.parse(await run('install', [localFakeDriverPath, '--source', 'local', '--json']));\n        ret.fake.pkgName.should.eql('@appium/fake-driver');\n        ret.fake.installType.should.eql('local');\n        ret.fake.installSpec.should.eql(localFakeDriverPath);\n        const list = JSON.parse(await run('list', ['--installed', '--json']));\n        delete list.fake.installed;\n        list.should.eql(ret);\n      });\n    });\n\n    describe('uninstall', function () {\n      it('should uninstall a driver based on its driver name', async function () {\n        await clear();\n        const ret = JSON.parse(await run('install', ['@appium/fake-driver', '--source', 'npm', '--json']));\n        const installPath = path.resolve(appiumHome, ret.fake.installPath);\n        await fs.exists(installPath).should.eventually.be.true;\n        let list = JSON.parse(await run('list', ['--installed', '--json']));\n        list.fake.installed.should.be.true;\n        const uninstall = JSON.parse(await run('uninstall', ['fake', '--json']));\n        uninstall.should.not.have.key('fake');\n        await fs.exists(installPath).should.eventually.be.false;\n      });\n    });\n\n    describe('run', function () {\n      before(async function () {\n        await clear();\n        await run('install', [localFakeDriverPath, '--source', 'local', '--json']);\n      });\n      it('should run a valid driver, valid script, and result in success', async function () {\n        const driverName = 'fake';\n        const scriptName = 'fake-success';\n        const out = JSON.parse(await run('run', [driverName, scriptName, '--json']));\n        out.should.not.include.key('error');\n      });\n      it('should run a valid driver, valid error prone script, and return error in json', async function () {\n        const driverName = 'fake';\n        const out = JSON.parse(await run('run', [driverName, 'fake-error', '--json']));\n        out.should.include.key('error');\n      });\n      it('should take a valid driver, invalid script, and throw an error', async function () {\n        const driverName = 'fake';\n        await chai.expect(run('run', [driverName, 'foo', '--json'])).to.eventually.be.rejectedWith(Error);\n      });\n      it('should take an invalid driver, invalid script, and throw an error', async function () {\n        const driverName = 'foo';\n        await chai.expect(run('run', [driverName, 'bar', '--json'])).to.eventually.be.rejectedWith(Error);\n      });\n    });\n  });\n\n  describe('Plugin CLI', function () {\n    const fakePluginDir = path.dirname(require.resolve('@appium/fake-plugin/package.json'));\n    const ext = 'plugin';\n    describe('run', function () {\n      before(async function () {\n        await clear();\n        await run('install', [fakePluginDir, '--source', 'local', '--json'], false, ext);\n      });\n      it('should run a valid plugin, valid script, and result in success', async function () {\n        const pluginName = 'fake';\n        const scriptName = 'fake-success';\n        const out = JSON.parse(await run('run', [pluginName, scriptName, '--json'], false, ext));\n        out.should.not.include.key('error');\n      });\n      it('should run a valid plugin, valid error prone script, and return error in json', async function () {\n        const pluginName = 'fake';\n        const out = JSON.parse(await run('run', [pluginName, 'fake-error', '--json'], false, ext));\n        out.should.include.key('error');\n      });\n      it('should take a valid plugin, invalid script, and throw an error', async function () {\n        const pluginName = 'fake';\n        await chai.expect(run('run', [pluginName, 'foo', '--json'], false, ext)).to.eventually.be.rejectedWith(Error);\n      });\n      it('should take an invalid plugin, invalid script, and throw an error', async function () {\n        await chai.expect(run('run', ['foo', 'bar', '--json'], false, ext)).to.eventually.be.rejectedWith(Error);\n      });\n    });\n  });\n});\n\n\n/**\n * @typedef {import('../../lib/ext-config-io').ExtensionType} ExtensionType\n */\n"],"file":"test/cli/cli-e2e-specs.js","sourceRoot":"../../.."}

package/build/test/cli/cli-helpers.js

@@ -0,0 +1,86 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.runAppiumRaw = exports.runAppiumJson = exports.runAppium = exports.installLocalExtension = exports.EXECUTABLE = void 0;
+
+require("source-map-support/register");
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _teen_process = require("teen_process");
+
+var _helpers = require("../helpers");
+
+var _path = _interopRequireDefault(require("path"));
+
+const EXECUTABLE = _path.default.join(_helpers.PROJECT_ROOT, 'packages', 'appium', 'build', 'lib', 'main.js');
+
+exports.EXECUTABLE = EXECUTABLE;
+
+async function run(appiumHome, args) {
+  const env = {
+    APPIUM_HOME: appiumHome,
+    PATH: process.env.PATH
+  };
+
+  try {
+    return await (0, _teen_process.exec)(process.execPath, [EXECUTABLE, ...args], {
+      cwd: _helpers.PROJECT_ROOT,
+      env
+    });
+  } catch (err) {
+    const {
+      stdout,
+      stderr
+    } = err;
+    const runErr = Object.assign(err, {
+      originalMessage: err.message,
+      message: `${stdout.trim()}\n\n${stderr.trim()}`,
+      command: `${process.execPath} ${EXECUTABLE} ${args.join(' ')}`,
+      env,
+      cwd: _helpers.PROJECT_ROOT
+    });
+    throw runErr;
+  }
+}
+
+const runAppium = _lodash.default.curry(async (appiumHome, args) => {
+  const {
+    stdout
+  } = await run(appiumHome, args);
+  return stdout;
+});
+
+exports.runAppium = runAppium;
+
+const runAppiumRaw = _lodash.default.curry(async (appiumHome, args) => await run(appiumHome, args));
+
+exports.runAppiumRaw = runAppiumRaw;
+
+const runAppiumJson = _lodash.default.curry(async (appiumHome, args) => {
+  if (!args.includes('--json')) {
+    args.push('--json');
+  }
+
+  const result = await runAppium(appiumHome, args);
+
+  try {
+    return JSON.parse(result);
+  } catch (err) {
+    err.message = `Error parsing JSON. Contents of STDOUT: ${result}`;
+    throw err;
+  }
+});
+
+exports.runAppiumJson = runAppiumJson;
+
+const installLocalExtension = _lodash.default.curry(async (appiumHome, type, pathToExtension) => await runAppiumJson(appiumHome, [type, 'install', '--source', 'local', pathToExtension]));
+
+exports.installLocalExtension = installLocalExtension;require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["test/cli/cli-helpers.js"],"names":["EXECUTABLE","path","join","PROJECT_ROOT","run","appiumHome","args","env","APPIUM_HOME","PATH","process","execPath","cwd","err","stdout","stderr","runErr","Object","assign","originalMessage","message","trim","command","runAppium","_","curry","runAppiumRaw","runAppiumJson","includes","push","result","JSON","parse","installLocalExtension","type","pathToExtension"],"mappings":";;;;;;;;;;;AAEA;;AACA;;AACA;;AACA;;AAKO,MAAMA,UAAU,GAAGC,cAAKC,IAAL,CACxBC,qBADwB,EAExB,UAFwB,EAGxB,QAHwB,EAIxB,OAJwB,EAKxB,KALwB,EAMxB,SANwB,CAAnB;;;;AAiBP,eAAeC,GAAf,CAAoBC,UAApB,EAAgCC,IAAhC,EAAsC;AACpC,QAAMC,GAAG,GAAG;AACVC,IAAAA,WAAW,EAAEH,UADH;AAEVI,IAAAA,IAAI,EAAEC,OAAO,CAACH,GAAR,CAAYE;AAFR,GAAZ;;AAIA,MAAI;AAIF,WAAO,MAAM,wBAAKC,OAAO,CAACC,QAAb,EAAuB,CAACX,UAAD,EAAa,GAAGM,IAAhB,CAAvB,EAA8C;AACzDM,MAAAA,GAAG,EAAET,qBADoD;AAEzDI,MAAAA;AAFyD,KAA9C,CAAb;AAID,GARD,CAQE,OAAOM,GAAP,EAAY;AACZ,UAAM;AAACC,MAAAA,MAAD;AAASC,MAAAA;AAAT,QAAuDF,GAA7D;AAIA,UAAMG,MAAM,GAAGC,MAAM,CAACC,MAAP,CACbL,GADa,EAEb;AACEM,MAAAA,eAAe,EAAEN,GAAG,CAACO,OADvB;AAEEA,MAAAA,OAAO,EAAG,GAAEN,MAAM,CAACO,IAAP,EAAc,OAAMN,MAAM,CAACM,IAAP,EAAc,EAFhD;AAGEC,MAAAA,OAAO,EAAG,GAAEZ,OAAO,CAACC,QAAS,IAAGX,UAAW,IAAGM,IAAI,CAACJ,IAAL,CAAU,GAAV,CAAe,EAH/D;AAIEK,MAAAA,GAJF;AAKEK,MAAAA,GAAG,EAAET;AALP,KAFa,CAAf;AASA,UAAMa,MAAN;AACD;AACF;;AAOM,MAAMO,SAAS,GAAGC,gBAAEC,KAAF,CAMvB,OAAOpB,UAAP,EAAmBC,IAAnB,KAA4B;AAC1B,QAAM;AAACQ,IAAAA;AAAD,MAAW,MAAMV,GAAG,CAACC,UAAD,EAAaC,IAAb,CAA1B;AACA,SAAOQ,MAAP;AACD,CATsB,CAAlB;;;;AAgBA,MAAMY,YAAY,GAAGF,gBAAEC,KAAF,CAM1B,OAAOpB,UAAP,EAAmBC,IAAnB,KAA4B,MAAMF,GAAG,CAACC,UAAD,EAAaC,IAAb,CANX,CAArB;;;;AAaA,MAAMqB,aAAa,GAAGH,gBAAEC,KAAF,CAM3B,OAAOpB,UAAP,EAAmBC,IAAnB,KAA4B;AAC1B,MAAI,CAACA,IAAI,CAACsB,QAAL,CAAc,QAAd,CAAL,EAA8B;AAC5BtB,IAAAA,IAAI,CAACuB,IAAL,CAAU,QAAV;AACD;;AACD,QAAMC,MAAM,GAAG,MAAMP,SAAS,CAAClB,UAAD,EAAaC,IAAb,CAA9B;;AACA,MAAI;AACF,WAAOyB,IAAI,CAACC,KAAL,CAAWF,MAAX,CAAP;AACD,GAFD,CAEE,OAAOjB,GAAP,EAAY;AACZA,IAAAA,GAAG,CAACO,OAAJ,GAAe,2CAA0CU,MAAO,EAAhE;AACA,UAAMjB,GAAN;AACD;AACF,CAjB0B,CAAtB;;;;AAuBA,MAAMoB,qBAAqB,GAAGT,gBAAEC,KAAF,CAOnC,OAAOpB,UAAP,EAAmB6B,IAAnB,EAAyBC,eAAzB,KACE,MAAMR,aAAa,CAACtB,UAAD,EAAa,CAC9B6B,IAD8B,EAE9B,SAF8B,EAG9B,UAH8B,EAI9B,OAJ8B,EAK9BC,eAL8B,CAAb,CARc,CAA9B","sourcesContent":["// @ts-check\n\nimport _ from 'lodash';\nimport {exec} from 'teen_process';\nimport {PROJECT_ROOT} from '../helpers';\nimport path from 'path';\n\n/**\n * Path to the `appium` executable. Sort of.\n */\nexport const EXECUTABLE = path.join(\n  PROJECT_ROOT,\n  'packages',\n  'appium',\n  'build',\n  'lib',\n  'main.js',\n);\n\n/**\n * Runs the `appium` executable with the given args.\n *\n * If the process exits with a nonzero code, the error will be a\n * @param {string} appiumHome - Path to `APPIUM_HOME`\n * @param {string[]} args - Args, including commands\n * @returns {Promise<TeenProcessExecResult>}\n */\nasync function run (appiumHome, args) {\n  const env = {\n    APPIUM_HOME: appiumHome,\n    PATH: process.env.PATH,\n  };\n  try {\n    /**\n     * @type {TeenProcessExecResult}\n     */\n    return await exec(process.execPath, [EXECUTABLE, ...args], {\n      cwd: PROJECT_ROOT,\n      env,\n    });\n  } catch (err) {\n    const {stdout, stderr} = /** @type {TeenProcessExecError} */(err);\n    /**\n     * @type {AppiumRunError}\n     */\n    const runErr = Object.assign(\n      err,\n      {\n        originalMessage: err.message,\n        message: `${stdout.trim()}\\n\\n${stderr.trim()}`,\n        command: `${process.execPath} ${EXECUTABLE} ${args.join(' ')}`,\n        env,\n        cwd: PROJECT_ROOT,\n      });\n    throw runErr;\n  }\n}\n\n/**\n * Runs the `appium` executable with the given args and returns contents of `STDOUT`.\n *\n * Do not use this when testing error output, as it will likely be in `STDERR`. Use {@link runAppiumRaw} instead.\n */\nexport const runAppium = _.curry(\n  /**\n   * @param {string} appiumHome - Path to `APPIUM_HOME`\n   * @param {string[]} args - Args, including commands\n   * @returns {Promise<string>} Contents of ``STDOUT``\n   */\n  async (appiumHome, args) => {\n    const {stdout} = await run(appiumHome, args);\n    return stdout;\n  },\n);\n\n/**\n * Runs the `appium` executable with the given args and returns the entire\n * {@link TeenProcessExecResult} object.\n */\nexport const runAppiumRaw = _.curry(\n  /**\n   * @param {string} appiumHome - Path to `APPIUM_HOME`\n   * @param {string[]} args - Args, including commands\n   * @returns {Promise<TeenProcessExecResult>} Raw result of `exec`\n   */\n  async (appiumHome, args) => await run(appiumHome, args),\n);\n\n/**\n * Runs the `appium` executable with the given args in JSON mode.\n * Will reject with the contents of `STDOUT` (which were to be pasred) if parsing into JSON fails.\n */\nexport const runAppiumJson = _.curry(\n  /**\n   * @param {string} appiumHome - Path to `APPIUM_HOME`\n   * @param {string[]} args - Args, including commands\n   * @returns {Promise<TeenProcessExecResult>} Raw result of `exec`\n   */\n  async (appiumHome, args) => {\n    if (!args.includes('--json')) {\n      args.push('--json');\n    }\n    const result = await runAppium(appiumHome, args);\n    try {\n      return JSON.parse(result);\n    } catch (err) {\n      err.message = `Error parsing JSON. Contents of STDOUT: ${result}`;\n      throw err;\n    }\n  },\n);\n\n/**\n * Given a path to a local extension, install it into `APPIUM_HOME` via CLI.\n */\nexport const installLocalExtension = _.curry(\n  /**\n   * @param {string} appiumHome\n   * @param {import('../../lib/ext-config-io').ExtensionType} type\n   * @param {string} pathToExtension\n   * @returns {Promise<object>}\n   */\n  async (appiumHome, type, pathToExtension) =>\n    await runAppiumJson(appiumHome, [\n      type,\n      'install',\n      '--source',\n      'local',\n      pathToExtension,\n    ]),\n);\n\n/**\n * Options for {@link runAppium}.\n * @private\n * @typedef {Object} RunAppiumOptions\n * @property {boolean} [raw] - Whether to return the raw output from `teen_process`\n */\n\n\n/**\n * Error thrown by all of the functions in this file which execute `appium`.\n * @typedef {Error & AppiumRunErrorProps & import('../../lib/cli/npm').TeenProcessExecErrorProps} AppiumRunError\n */\n\n/**\n * Wraps the error returned by {@link exec}.\n * @typedef {Object} AppiumRunErrorProps\n * @property {string} originalMessage - Original error message\n * @property {string} command - Command that was run\n * @property {string} env - Environment variables\n * @property {string} cwd - Current working directory\n */\n"],"file":"test/cli/cli-helpers.js","sourceRoot":"../../.."}

package/build/test/cli/cli-specs.js

@@ -0,0 +1,71 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("source-map-support/register");
+
+var _extensionConfig = require("../../lib/extension-config");
+
+var _driverConfig = _interopRequireDefault(require("../../lib/driver-config"));
+
+var _driverCommand = _interopRequireDefault(require("../../lib/cli/driver-command"));
+
+var _sinon = _interopRequireDefault(require("sinon"));
+
+describe('DriverCommand', function () {
+  const config = new _driverConfig.default(_extensionConfig.DEFAULT_APPIUM_HOME);
+  const driver = 'fake';
+  const pkgName = '@appium/fake-driver';
+  config.installedExtensions = {
+    [driver]: {
+      version: '1.0.0',
+      pkgName
+    }
+  };
+  const dc = new _driverCommand.default({
+    config,
+    json: true
+  });
+  describe('#checkForExtensionUpdate', function () {
+    let npmMock;
+    beforeEach(function () {
+      npmMock = _sinon.default.mock(dc.npm);
+    });
+
+    function setupDriverUpdate(curVersion, latestVersion, latestSafeVersion) {
+      npmMock.expects('getLatestVersion').once().withExactArgs(pkgName).returns(latestVersion);
+      npmMock.expects('getLatestSafeUpgradeVersion').once().withExactArgs(pkgName, curVersion).returns(latestSafeVersion);
+    }
+
+    it('should not return an unsafe update if it is same as safe update', async function () {
+      setupDriverUpdate('1.0.0', '1.1.0', '1.1.0');
+      await dc.checkForExtensionUpdate('fake').should.eventually.eql({
+        current: '1.0.0',
+        safeUpdate: '1.1.0',
+        unsafeUpdate: null
+      });
+      npmMock.verify();
+    });
+    it('should not return a safe update if there is not one', async function () {
+      setupDriverUpdate('1.0.0', '2.0.0', null);
+      await dc.checkForExtensionUpdate('fake').should.eventually.eql({
+        current: '1.0.0',
+        safeUpdate: null,
+        unsafeUpdate: '2.0.0'
+      });
+      npmMock.verify();
+    });
+    it('should return both safe and unsafe update', async function () {
+      setupDriverUpdate('1.0.0', '2.0.0', '1.5.3');
+      await dc.checkForExtensionUpdate('fake').should.eventually.eql({
+        current: '1.0.0',
+        safeUpdate: '1.5.3',
+        unsafeUpdate: '2.0.0'
+      });
+      npmMock.verify();
+    });
+  });
+});require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/build/test/cli/fixtures/test-driver/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "test-driver",
+  "version": "1.0",
+  "private": true,
+  "appium": {
+    "driverName": "test",
+    "automationName": "Test",
+    "platformNames": [
+      "Test"
+    ],
+    "mainClass": "TestDriver",
+    "schema": {
+      "type": "object",
+      "properties": {
+        "mcmonkey-mcbean": {
+          "type": "string",
+          "appiumCliIgnored": true
+        },
+        "oliver-boliver": {
+          "type": "number",
+          "appiumDeprecated": true,
+          "description": "funkytelechy"
+        }
+      }
+    }
+  }
+}

package/build/test/cli/schema-args-specs.js

@@ -0,0 +1,48 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("source-map-support/register");
+
+var _helpers = require("../helpers");
+
+var _sinon = _interopRequireDefault(require("sinon"));
+
+var _schema = require("../../lib/schema/schema");
+
+const expect = chai.expect;
+describe('cli/schema-args', function () {
+  let schemaArgs;
+  let sandbox;
+  beforeEach(function () {
+    sandbox = _sinon.default.createSandbox();
+    schemaArgs = _helpers.rewiremock.proxy(() => require('../../lib/schema/cli-args'));
+  });
+  afterEach(function () {
+    sandbox.restore();
+  });
+  describe('toParserArgs()', function () {
+    describe('when called with no parameters', function () {
+      beforeEach(_schema.finalizeSchema);
+      afterEach(_schema.resetSchema);
+      it('should return a Map', function () {
+        expect(schemaArgs.toParserArgs()).to.be.an.instanceof(Map).and.have.property('size').that.is.above(0);
+      });
+      it('should generate metavars in SCREAMING_SNAKE_CASE', function () {
+        const argDefs = schemaArgs.toParserArgs();
+        const argDefsWithMetavar = [...argDefs].filter(arg => arg[1].metavar);
+        expect(argDefsWithMetavar).not.to.be.empty;
+        expect(argDefsWithMetavar.every(arg => /[A-Z_]+/.test(arg[1].metavar))).to.be.true;
+      });
+    });
+    describe('when schema has not yet been compiled', function () {
+      it('should throw', function () {
+        (0, _schema.resetSchema)();
+        expect(() => schemaArgs.toParserArgs()).to.throw(_schema.SchemaFinalizationError);
+      });
+    });
+  });
+});require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/build/test/cli/schema-e2e-specs.js

@@ -0,0 +1,47 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("source-map-support/register");
+
+var _path = _interopRequireDefault(require("path"));
+
+var _support = require("@appium/support");
+
+var _cliHelpers = require("./cli-helpers");
+
+const {
+  expect
+} = chai;
+describe('CLI behavior controlled by schema', function () {
+  let appiumHome;
+  before(async function () {
+    appiumHome = await _support.tempDir.openDir();
+  });
+  after(async function () {
+    await _support.fs.rimraf(appiumHome);
+  });
+  describe('keyword', function () {
+    let help;
+    before(async function () {
+      await (0, _cliHelpers.installLocalExtension)(appiumHome, 'driver', _path.default.join(__dirname, 'fixtures', 'test-driver'));
+      help = await (0, _cliHelpers.runAppium)(appiumHome, ['server', '--help']);
+    });
+    describe('appiumCliIgnored', function () {
+      it('should still support arguments without this keyword', function () {
+        expect(help).to.match(/oliver-boliver/);
+      });
+      it('should cause the argument to be suppressed', function () {
+        expect(help).not.to.match(/mcmonkey-mcbean/);
+      });
+    });
+    describe('appiumDeprecated', function () {
+      it('should mark the argument as deprecated', function () {
+        expect(help).to.match(/\[DEPRECATED\] funkytelechy/);
+      });
+    });
+  });
+});require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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