appium 2.0.0-beta.20 → 2.0.0-beta.24

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 * @typedef {import('../../lib/cli/npm').TeenProcessExecResult} TeenProcessExecResult\n */\n\n/**\n * @typedef {import('../../lib/cli/npm').TeenProcessExecError} TeenProcessExecError\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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

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

@@ -0,0 +1,112 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("source-map-support/register");
+
+var _sinon = _interopRequireDefault(require("sinon"));
+
+var _config = require("../lib/config");
+
+var _axios = _interopRequireDefault(require("axios"));
+
+var _support = require("@appium/support");
+
+describe('Config', function () {
+  describe('getGitRev', function () {
+    it('should get a reasonable git revision', async function () {
+      let rev = await (0, _config.getGitRev)();
+      rev.should.be.a('string');
+      rev.length.should.be.equal(40);
+      rev.match(/[0-9a-f]+/i)[0].should.eql(rev);
+    });
+  });
+  describe('getBuildInfo', function () {
+    async function verifyBuildInfoUpdate(useLocalGit) {
+      const buildInfo = (0, _config.getBuildInfo)();
+      mockFs.expects('exists').atLeast(1).returns(useLocalGit);
+      buildInfo['git-sha'] = undefined;
+      buildInfo.built = undefined;
+      await (0, _config.updateBuildInfo)(true);
+      buildInfo.should.be.an('object');
+      should.exist(buildInfo['git-sha']);
+      should.exist(buildInfo.built);
+      should.exist(buildInfo.version);
+    }
+
+    let mockFs;
+    let getStub;
+    beforeEach(function () {
+      mockFs = _sinon.default.mock(_support.fs);
+      getStub = _sinon.default.stub(_axios.default, 'get');
+    });
+    afterEach(function () {
+      getStub.restore();
+      mockFs.restore();
+    });
+    it('should get a configuration object if the local git metadata is present', async function () {
+      await verifyBuildInfoUpdate(true);
+    });
+    it('should get a configuration object if the local git metadata is not present', async function () {
+      getStub.onCall(0).returns({
+        data: [{
+          name: `v${_config.APPIUM_VER}`,
+          zipball_url: 'https://api.github.com/repos/appium/appium/zipball/v1.9.0-beta.1',
+          tarball_url: 'https://api.github.com/repos/appium/appium/tarball/v1.9.0-beta.1',
+          commit: {
+            sha: '3c2752f9f9c56000705a4ae15b3ba68a5d2e644c',
+            url: 'https://api.github.com/repos/appium/appium/commits/3c2752f9f9c56000705a4ae15b3ba68a5d2e644c'
+          },
+          node_id: 'MDM6UmVmNzUzMDU3MDp2MS45LjAtYmV0YS4x'
+        }, {
+          name: 'v1.8.2-beta',
+          zipball_url: 'https://api.github.com/repos/appium/appium/zipball/v1.8.2-beta',
+          tarball_url: 'https://api.github.com/repos/appium/appium/tarball/v1.8.2-beta',
+          commit: {
+            sha: '5b98b9197e75aa85e7507d21d3126c1a63d1ce8f',
+            url: 'https://api.github.com/repos/appium/appium/commits/5b98b9197e75aa85e7507d21d3126c1a63d1ce8f'
+          },
+          node_id: 'MDM6UmVmNzUzMDU3MDp2MS44LjItYmV0YQ=='
+        }]
+      });
+      getStub.onCall(1).returns({
+        data: {
+          sha: '3c2752f9f9c56000705a4ae15b3ba68a5d2e644c',
+          node_id: 'MDY6Q29tbWl0NzUzMDU3MDozYzI3NTJmOWY5YzU2MDAwNzA1YTRhZTE1YjNiYTY4YTVkMmU2NDRj',
+          commit: {
+            author: {
+              name: 'Isaac Murchie',
+              email: 'isaac@saucelabs.com',
+              date: '2018-08-17T19:48:00Z'
+            },
+            committer: {
+              name: 'Isaac Murchie',
+              email: 'isaac@saucelabs.com',
+              date: '2018-08-17T19:48:00Z'
+            },
+            message: 'v1.9.0-beta.1',
+            tree: {
+              sha: '2c0974727470eba419ea0b9951c52f72f8036b18',
+              url: 'https://api.github.com/repos/appium/appium/git/trees/2c0974727470eba419ea0b9951c52f72f8036b18'
+            },
+            url: 'https://api.github.com/repos/appium/appium/git/commits/3c2752f9f9c56000705a4ae15b3ba68a5d2e644c',
+            comment_count: 0,
+            verification: {
+              verified: false,
+              reason: 'unsigned',
+              signature: null,
+              payload: null
+            }
+          },
+          url: 'https://api.github.com/repos/appium/appium/commits/3c2752f9f9c56000705a4ae15b3ba68a5d2e644c',
+          html_url: 'https://github.com/appium/appium/commit/3c2752f9f9c56000705a4ae15b3ba68a5d2e644c',
+          comments_url: 'https://api.github.com/repos/appium/appium/commits/3c2752f9f9c56000705a4ae15b3ba68a5d2e644c/comments'
+        }
+      });
+      await verifyBuildInfoUpdate(false);
+    });
+  });
+});require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["test/config-e2e-specs.js"],"names":["describe","it","rev","should","be","a","length","equal","match","eql","verifyBuildInfoUpdate","useLocalGit","buildInfo","mockFs","expects","atLeast","returns","undefined","built","an","exist","version","getStub","beforeEach","sinon","mock","fs","stub","axios","afterEach","restore","onCall","data","name","APPIUM_VER","zipball_url","tarball_url","commit","sha","url","node_id","author","email","date","committer","message","tree","comment_count","verification","verified","reason","signature","payload","html_url","comments_url"],"mappings":"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","sourcesContent":["import sinon from 'sinon';\nimport {\n  getGitRev,\n  getBuildInfo,\n  updateBuildInfo,\n  APPIUM_VER,\n} from '../lib/config';\nimport axios from 'axios';\nimport { fs } from '@appium/support';\n\n\ndescribe('Config', function () {\n  describe('getGitRev', function () {\n    it('should get a reasonable git revision', async function () {\n      let rev = await getGitRev();\n      rev.should.be.a('string');\n      rev.length.should.be.equal(40);\n      rev.match(/[0-9a-f]+/i)[0].should.eql(rev);\n    });\n  });\n  describe('getBuildInfo', function () {\n    async function verifyBuildInfoUpdate (useLocalGit) {\n      const buildInfo = getBuildInfo();\n      mockFs.expects('exists').atLeast(1).returns(useLocalGit);\n      buildInfo['git-sha'] = undefined;\n      buildInfo.built = undefined;\n      await updateBuildInfo(true);\n      buildInfo.should.be.an('object');\n      should.exist(buildInfo['git-sha']);\n      should.exist(buildInfo.built);\n      should.exist(buildInfo.version);\n    }\n\n    let mockFs;\n    let getStub;\n    beforeEach(function () {\n      mockFs = sinon.mock(fs);\n      getStub = sinon.stub(axios, 'get');\n    });\n    afterEach(function () {\n      getStub.restore();\n      mockFs.restore();\n    });\n\n    it('should get a configuration object if the local git metadata is present', async function () {\n      await verifyBuildInfoUpdate(true);\n    });\n    it('should get a configuration object if the local git metadata is not present', async function () {\n      getStub.onCall(0).returns({\n        data: [\n          {\n            name: `v${APPIUM_VER}`,\n            zipball_url:\n              'https://api.github.com/repos/appium/appium/zipball/v1.9.0-beta.1',\n            tarball_url:\n              'https://api.github.com/repos/appium/appium/tarball/v1.9.0-beta.1',\n            commit: {\n              sha: '3c2752f9f9c56000705a4ae15b3ba68a5d2e644c',\n              url: 'https://api.github.com/repos/appium/appium/commits/3c2752f9f9c56000705a4ae15b3ba68a5d2e644c',\n            },\n            node_id: 'MDM6UmVmNzUzMDU3MDp2MS45LjAtYmV0YS4x',\n          },\n          {\n            name: 'v1.8.2-beta',\n            zipball_url:\n              'https://api.github.com/repos/appium/appium/zipball/v1.8.2-beta',\n            tarball_url:\n              'https://api.github.com/repos/appium/appium/tarball/v1.8.2-beta',\n            commit: {\n              sha: '5b98b9197e75aa85e7507d21d3126c1a63d1ce8f',\n              url: 'https://api.github.com/repos/appium/appium/commits/5b98b9197e75aa85e7507d21d3126c1a63d1ce8f',\n            },\n            node_id: 'MDM6UmVmNzUzMDU3MDp2MS44LjItYmV0YQ==',\n          },\n        ],\n      });\n      getStub.onCall(1).returns({\n        data: {\n          sha: '3c2752f9f9c56000705a4ae15b3ba68a5d2e644c',\n          node_id:\n            'MDY6Q29tbWl0NzUzMDU3MDozYzI3NTJmOWY5YzU2MDAwNzA1YTRhZTE1YjNiYTY4YTVkMmU2NDRj',\n          commit: {\n            author: {\n              name: 'Isaac Murchie',\n              email: 'isaac@saucelabs.com',\n              date: '2018-08-17T19:48:00Z',\n            },\n            committer: {\n              name: 'Isaac Murchie',\n              email: 'isaac@saucelabs.com',\n              date: '2018-08-17T19:48:00Z',\n            },\n            message: 'v1.9.0-beta.1',\n            tree: {\n              sha: '2c0974727470eba419ea0b9951c52f72f8036b18',\n              url: 'https://api.github.com/repos/appium/appium/git/trees/2c0974727470eba419ea0b9951c52f72f8036b18',\n            },\n            url: 'https://api.github.com/repos/appium/appium/git/commits/3c2752f9f9c56000705a4ae15b3ba68a5d2e644c',\n            comment_count: 0,\n            verification: {\n              verified: false,\n              reason: 'unsigned',\n              signature: null,\n              payload: null,\n            },\n          },\n          url: 'https://api.github.com/repos/appium/appium/commits/3c2752f9f9c56000705a4ae15b3ba68a5d2e644c',\n          html_url:\n            'https://github.com/appium/appium/commit/3c2752f9f9c56000705a4ae15b3ba68a5d2e644c',\n          comments_url:\n            'https://api.github.com/repos/appium/appium/commits/3c2752f9f9c56000705a4ae15b3ba68a5d2e644c/comments',\n        },\n      });\n      await verifyBuildInfoUpdate(false);\n    });\n  });\n});\n"],"file":"test/config-e2e-specs.js","sourceRoot":"../.."}