appium 2.0.0-beta.21 → 2.0.0-beta.25

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

@@ -0,0 +1,316 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("source-map-support/register");
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _bluebird = _interopRequireDefault(require("bluebird"));
+
+var _webdriverio = require("webdriverio");
+
+var _axios = _interopRequireDefault(require("axios"));
+
+var _main = require("../lib/main");
+
+var _extensionConfig = require("../lib/extension-config");
+
+var _helpers = require("./helpers");
+
+var _extension = require("../lib/cli/extension");
+
+const FAKE_ARGS = {
+  sillyWebServerPort: 1234,
+  host: 'hey'
+};
+const FAKE_PLUGIN_ARGS = {
+  fake: FAKE_ARGS
+};
+const wdOpts = {
+  hostname: _helpers.TEST_HOST,
+  port: null,
+  connectionRetryCount: 0,
+  capabilities: _helpers.W3C_PREFIXED_CAPS
+};
+describe('FakePlugin', function () {
+  const fakePluginDir = _path.default.join(_helpers.PROJECT_ROOT, 'node_modules', '@appium', 'fake-plugin');
+
+  const fakeDriverDir = _path.default.join(_helpers.PROJECT_ROOT, 'packages', 'fake-driver');
+
+  const appiumHome = _extensionConfig.DEFAULT_APPIUM_HOME;
+  let baseArgs;
+  let testServer;
+  let testPort;
+  let baseUrl;
+  before(async function () {
+    wdOpts.port = testPort = await (0, _helpers.getTestPort)();
+    testServer = `http://${_helpers.TEST_HOST}:${testPort}`;
+    baseUrl = `${testServer}/session`;
+    const driverList = await (0, _extension.runExtensionCommand)({
+      appiumHome,
+      driverCommand: 'list',
+      showInstalled: true
+    }, _extensionConfig.DRIVER_TYPE);
+
+    if (!_lodash.default.has(driverList, 'fake')) {
+      await (0, _extension.runExtensionCommand)({
+        appiumHome,
+        driverCommand: 'install',
+        driver: fakeDriverDir,
+        installType: _extensionConfig.INSTALL_TYPE_LOCAL
+      }, _extensionConfig.DRIVER_TYPE);
+    }
+
+    const pluginList = await (0, _extension.runExtensionCommand)({
+      appiumHome,
+      pluginCommand: 'list',
+      showInstalled: true
+    }, _extensionConfig.PLUGIN_TYPE);
+
+    if (!_lodash.default.has(pluginList, 'fake')) {
+      await (0, _extension.runExtensionCommand)({
+        appiumHome,
+        pluginCommand: 'install',
+        plugin: fakePluginDir,
+        installType: _extensionConfig.INSTALL_TYPE_LOCAL
+      }, _extensionConfig.PLUGIN_TYPE);
+    }
+
+    baseArgs = {
+      port: testPort,
+      host: _helpers.TEST_HOST,
+      appiumHome,
+      usePlugins: ['fake'],
+      useDrivers: ['fake']
+    };
+  });
+  describe('without plugin registered', function () {
+    let server = null;
+    before(async function () {
+      const args = {
+        port: testPort,
+        host: _helpers.TEST_HOST,
+        appiumHome,
+        usePlugins: ['other1', 'other2']
+      };
+      server = await (0, _main.main)(args);
+    });
+    after(async function () {
+      if (server) {
+        await server.close();
+      }
+    });
+    it('should not update the server if plugin is not activated', async function () {
+      await _axios.default.post(`http://${_helpers.TEST_HOST}:${testPort}/fake`).should.eventually.be.rejectedWith(/404/);
+    });
+    it('should not update method map if plugin is not activated', async function () {
+      const driver = await (0, _webdriverio.remote)(wdOpts);
+      const {
+        sessionId
+      } = driver;
+
+      try {
+        await _axios.default.post(`${baseUrl}/${sessionId}/fake_data`, {
+          data: {
+            fake: 'data'
+          }
+        }).should.eventually.be.rejectedWith(/404/);
+      } finally {
+        await driver.deleteSession();
+      }
+    });
+    it('should not handle commands if plugin is not activated', async function () {
+      const driver = await (0, _webdriverio.remote)(wdOpts);
+      const {
+        sessionId
+      } = driver;
+
+      try {
+        const el = (await _axios.default.post(`${baseUrl}/${sessionId}/element`, {
+          using: 'xpath',
+          value: '//MockWebView'
+        })).data.value;
+        el.should.not.have.property('fake');
+      } finally {
+        await driver.deleteSession();
+      }
+    });
+  });
+
+  for (const registrationType of ['explicit', 'all']) {
+    describe(`with plugin registered via type ${registrationType}`, function () {
+      let server = null;
+      before(async function () {
+        const usePlugins = registrationType === 'explicit' ? ['fake', 'p2', 'p3'] : ['all'];
+        const args = {
+          port: testPort,
+          host: _helpers.TEST_HOST,
+          appiumHome,
+          usePlugins,
+          useDrivers: ['fake']
+        };
+        server = await (0, _main.main)(args);
+      });
+      after(async function () {
+        if (server) {
+          await server.close();
+        }
+      });
+      it('should update the server', async function () {
+        const res = {
+          fake: 'fakeResponse'
+        };
+        (await _axios.default.post(`http://${_helpers.TEST_HOST}:${testPort}/fake`)).data.should.eql(res);
+      });
+      it('should modify the method map with new commands', async function () {
+        const driver = await (0, _webdriverio.remote)(wdOpts);
+        const {
+          sessionId
+        } = driver;
+
+        try {
+          await _axios.default.post(`${baseUrl}/${sessionId}/fake_data`, {
+            data: {
+              fake: 'data'
+            }
+          });
+          (await _axios.default.get(`${baseUrl}/${sessionId}/fake_data`)).data.value.should.eql({
+            fake: 'data'
+          });
+        } finally {
+          await driver.deleteSession();
+        }
+      });
+      it('should handle commands and not call the original', async function () {
+        const driver = await (0, _webdriverio.remote)(wdOpts);
+        const {
+          sessionId
+        } = driver;
+
+        try {
+          await driver.getPageSource().should.eventually.eql(`<Fake>${JSON.stringify([sessionId])}</Fake>`);
+        } finally {
+          await driver.deleteSession();
+        }
+      });
+      it('should handle commands and call the original if designed', async function () {
+        const driver = await (0, _webdriverio.remote)(wdOpts);
+        const {
+          sessionId
+        } = driver;
+
+        try {
+          const el = (await _axios.default.post(`${baseUrl}/${sessionId}/element`, {
+            using: 'xpath',
+            value: '//MockWebView'
+          })).data.value;
+          el.should.have.property('fake');
+        } finally {
+          await driver.deleteSession();
+        }
+      });
+      it('should allow original command to be proxied if supported', async function () {
+        const driver = await (0, _webdriverio.remote)(wdOpts);
+        const {
+          sessionId
+        } = driver;
+
+        try {
+          await _axios.default.post(`${baseUrl}/${sessionId}/context`, {
+            name: 'PROXY'
+          });
+          const handle = (await _axios.default.get(`${baseUrl}/${sessionId}/window/handle`)).data.value;
+          handle.should.eql('<<proxied via proxyCommand>>');
+        } finally {
+          await _axios.default.post(`${baseUrl}/${sessionId}/context`, {
+            name: 'NATIVE_APP'
+          });
+          await driver.deleteSession();
+        }
+      });
+      it('should handle unexpected driver shutdown', async function () {
+        const newOpts = { ...wdOpts
+        };
+        newOpts.capabilities['appium:newCommandTimeout'] = 1;
+        const driver = await (0, _webdriverio.remote)(wdOpts);
+        let shutdownErr;
+
+        try {
+          let res = await _axios.default.get(`http://${_helpers.TEST_HOST}:${testPort}/unexpected`);
+          should.not.exist(res.data);
+          await _bluebird.default.delay(1500);
+          res = await _axios.default.get(`http://${_helpers.TEST_HOST}:${testPort}/unexpected`);
+          res.data.should.match(/Session ended/);
+          res.data.should.match(/timeout/);
+          await driver.deleteSession();
+        } catch (e) {
+          shutdownErr = e;
+        }
+
+        shutdownErr.message.should.match(/either terminated or not started/);
+      });
+    });
+  }
+
+  describe('cli args handling for plugin args', function () {
+    let server = null;
+    before(async function () {
+      const args = { ...baseArgs,
+        plugin: FAKE_PLUGIN_ARGS
+      };
+      server = await (0, _main.main)(args);
+    });
+    after(async function () {
+      if (server) {
+        await server.close();
+      }
+    });
+    it('should receive user cli args for plugin if passed in', async function () {
+      const driver = await (0, _webdriverio.remote)(wdOpts);
+      const {
+        sessionId
+      } = driver;
+
+      try {
+        const {
+          data
+        } = await _axios.default.get(`${baseUrl}/${sessionId}/fakepluginargs`);
+        data.value.should.eql(FAKE_ARGS);
+      } finally {
+        await driver.deleteSession();
+      }
+    });
+  });
+  describe('cli args handling for empty plugin args', function () {
+    let server = null;
+    before(async function () {
+      server = await (0, _main.main)(baseArgs);
+    });
+    after(async function () {
+      if (server) {
+        await server.close();
+      }
+    });
+    it('should not receive user cli args for plugin if none were passed in', async function () {
+      const driver = await (0, _webdriverio.remote)(wdOpts);
+      const {
+        sessionId
+      } = driver;
+
+      try {
+        const {
+          data
+        } = await _axios.default.get(`${baseUrl}/${sessionId}/fakepluginargs`);
+        should.not.exist(data.value);
+      } finally {
+        await driver.deleteSession();
+      }
+    });
+  });
+});require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["test/plugin-e2e-specs.js"],"names":["FAKE_ARGS","sillyWebServerPort","host","FAKE_PLUGIN_ARGS","fake","wdOpts","hostname","TEST_HOST","port","connectionRetryCount","capabilities","W3C_PREFIXED_CAPS","describe","fakePluginDir","path","join","PROJECT_ROOT","fakeDriverDir","appiumHome","DEFAULT_APPIUM_HOME","baseArgs","testServer","testPort","baseUrl","before","driverList","driverCommand","showInstalled","DRIVER_TYPE","_","has","driver","installType","INSTALL_TYPE_LOCAL","pluginList","pluginCommand","PLUGIN_TYPE","plugin","usePlugins","useDrivers","server","args","after","close","it","axios","post","should","eventually","be","rejectedWith","sessionId","data","deleteSession","el","using","value","not","have","property","registrationType","res","eql","get","getPageSource","JSON","stringify","name","handle","newOpts","shutdownErr","exist","B","delay","match","e","message"],"mappings":"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","sourcesContent":["// transpile:mocha\nimport _ from 'lodash';\nimport path from 'path';\nimport B from 'bluebird';\nimport { remote as wdio } from 'webdriverio';\nimport axios from 'axios';\nimport { main as appiumServer } from '../lib/main';\nimport { DEFAULT_APPIUM_HOME, INSTALL_TYPE_LOCAL, DRIVER_TYPE, PLUGIN_TYPE } from '../lib/extension-config';\nimport { W3C_PREFIXED_CAPS, TEST_HOST, getTestPort, PROJECT_ROOT } from './helpers';\nimport { runExtensionCommand } from '../lib/cli/extension';\n\n\nconst FAKE_ARGS = {sillyWebServerPort: 1234, host: 'hey'};\nconst FAKE_PLUGIN_ARGS = {fake: FAKE_ARGS};\n\nconst wdOpts = {\n  hostname: TEST_HOST,\n  port: null,\n  connectionRetryCount: 0,\n  capabilities: W3C_PREFIXED_CAPS,\n};\n\ndescribe('FakePlugin', function () {\n  const fakePluginDir = path.join(PROJECT_ROOT, 'node_modules', '@appium', 'fake-plugin');\n  const fakeDriverDir = path.join(PROJECT_ROOT, 'packages', 'fake-driver');\n  const appiumHome = DEFAULT_APPIUM_HOME;\n  let baseArgs;\n  let testServer;\n  let testPort;\n  let baseUrl;\n\n  before(async function () {\n    wdOpts.port = testPort = await getTestPort();\n    testServer = `http://${TEST_HOST}:${testPort}`;\n    baseUrl = `${testServer}/session`;\n    // first ensure we have fakedriver installed\n    const driverList = await runExtensionCommand({\n      appiumHome,\n      driverCommand: 'list',\n      showInstalled: true,\n    }, DRIVER_TYPE);\n    if (!_.has(driverList, 'fake')) {\n      await runExtensionCommand({\n        appiumHome,\n        driverCommand: 'install',\n        driver: fakeDriverDir,\n        installType: INSTALL_TYPE_LOCAL,\n      }, DRIVER_TYPE);\n    }\n\n    const pluginList = await runExtensionCommand({\n      appiumHome,\n      pluginCommand: 'list',\n      showInstalled: true,\n    }, PLUGIN_TYPE);\n    if (!_.has(pluginList, 'fake')) {\n      await runExtensionCommand({\n        appiumHome,\n        pluginCommand: 'install',\n        plugin: fakePluginDir,\n        installType: INSTALL_TYPE_LOCAL,\n      }, PLUGIN_TYPE);\n    }\n    baseArgs = {port: testPort, host: TEST_HOST, appiumHome, usePlugins: ['fake'], useDrivers: ['fake']};\n  });\n\n  describe('without plugin registered', function () {\n    let server = null;\n    before(async function () {\n      // then start server if we need to\n      const args = {port: testPort, host: TEST_HOST, appiumHome, usePlugins: ['other1', 'other2']};\n      server = await appiumServer(args);\n    });\n    after(async function () {\n      if (server) {\n        await server.close();\n      }\n    });\n    it('should not update the server if plugin is not activated', async function () {\n      await axios.post(`http://${TEST_HOST}:${testPort}/fake`).should.eventually.be.rejectedWith(/404/);\n    });\n    it('should not update method map if plugin is not activated', async function () {\n      const driver = await wdio(wdOpts);\n      const {sessionId} = driver;\n      try {\n        await axios.post(`${baseUrl}/${sessionId}/fake_data`, {data: {fake: 'data'}}).should.eventually.be.rejectedWith(/404/);\n      } finally {\n        await driver.deleteSession();\n      }\n    });\n    it('should not handle commands if plugin is not activated', async function () {\n      const driver = await wdio(wdOpts);\n      const {sessionId} = driver;\n      try {\n        const el = (await axios.post(`${baseUrl}/${sessionId}/element`, {using: 'xpath', value: '//MockWebView'})).data.value;\n        el.should.not.have.property('fake');\n      } finally {\n        await driver.deleteSession();\n      }\n    });\n  });\n\n  for (const registrationType of ['explicit', 'all']) {\n    describe(`with plugin registered via type ${registrationType}`, function () {\n      let server = null;\n      before(async function () {\n        // then start server if we need to\n        const usePlugins = registrationType === 'explicit' ? ['fake', 'p2', 'p3'] : ['all'];\n        const args = {port: testPort, host: TEST_HOST, appiumHome, usePlugins, useDrivers: ['fake']};\n        server = await appiumServer(args);\n      });\n      after(async function () {\n        if (server) {\n          await server.close();\n        }\n      });\n      it('should update the server', async function () {\n        const res = {fake: 'fakeResponse'};\n        (await axios.post(`http://${TEST_HOST}:${testPort}/fake`)).data.should.eql(res);\n      });\n\n      it('should modify the method map with new commands', async function () {\n        const driver = await wdio(wdOpts);\n        const {sessionId} = driver;\n        try {\n          await axios.post(`${baseUrl}/${sessionId}/fake_data`, {data: {fake: 'data'}});\n          (await axios.get(`${baseUrl}/${sessionId}/fake_data`)).data.value.should.eql({fake: 'data'});\n        } finally {\n          await driver.deleteSession();\n        }\n      });\n\n      it('should handle commands and not call the original', async function () {\n        const driver = await wdio(wdOpts);\n        const {sessionId} = driver;\n        try {\n          await driver.getPageSource().should.eventually.eql(`<Fake>${JSON.stringify([sessionId])}</Fake>`);\n        } finally {\n          await driver.deleteSession();\n        }\n      });\n\n      it('should handle commands and call the original if designed', async function () {\n        const driver = await wdio(wdOpts);\n        const {sessionId} = driver;\n        try {\n          const el = (await axios.post(`${baseUrl}/${sessionId}/element`, {using: 'xpath', value: '//MockWebView'})).data.value;\n          el.should.have.property('fake');\n        } finally {\n          await driver.deleteSession();\n        }\n      });\n\n      it('should allow original command to be proxied if supported', async function () {\n        const driver = await wdio(wdOpts);\n        const {sessionId} = driver;\n        try {\n          await axios.post(`${baseUrl}/${sessionId}/context`, {name: 'PROXY'});\n          const handle = (await axios.get(`${baseUrl}/${sessionId}/window/handle`)).data.value;\n          handle.should.eql('<<proxied via proxyCommand>>');\n        } finally {\n          await axios.post(`${baseUrl}/${sessionId}/context`, {name: 'NATIVE_APP'});\n          await driver.deleteSession();\n        }\n      });\n\n      it('should handle unexpected driver shutdown', async function () {\n        const newOpts = {...wdOpts};\n        newOpts.capabilities['appium:newCommandTimeout'] = 1;\n        const driver = await wdio(wdOpts);\n        let shutdownErr;\n        try {\n          let res = await axios.get(`http://${TEST_HOST}:${testPort}/unexpected`);\n          should.not.exist(res.data);\n          await B.delay(1500);\n          res = await axios.get(`http://${TEST_HOST}:${testPort}/unexpected`);\n          res.data.should.match(/Session ended/);\n          res.data.should.match(/timeout/);\n          await driver.deleteSession();\n        } catch (e) {\n          shutdownErr = e;\n        }\n        shutdownErr.message.should.match(/either terminated or not started/);\n      });\n    });\n  }\n  describe('cli args handling for plugin args', function () {\n    let server = null;\n    before(async function () {\n      // then start server if we need to\n      const args = {...baseArgs, plugin: FAKE_PLUGIN_ARGS};\n      server = await appiumServer(args);\n    });\n    after(async function () {\n      if (server) {\n        await server.close();\n      }\n    });\n\n    it('should receive user cli args for plugin if passed in', async function () {\n      const driver = await wdio(wdOpts);\n      const {sessionId} = driver;\n      try {\n        const {data} = await axios.get(`${baseUrl}/${sessionId}/fakepluginargs`);\n        data.value.should.eql(FAKE_ARGS);\n      } finally {\n        await driver.deleteSession();\n      }\n    });\n  });\n  describe('cli args handling for empty plugin args', function () {\n    let server = null;\n    before(async function () {\n      // then start server if we need to\n      server = await appiumServer(baseArgs);\n    });\n    after(async function () {\n      if (server) {\n        await server.close();\n      }\n    });\n\n    it('should not receive user cli args for plugin if none were passed in', async function () {\n      const driver = await wdio(wdOpts);\n      const {sessionId} = driver;\n      try {\n        const {data} = await axios.get(`${baseUrl}/${sessionId}/fakepluginargs`);\n        should.not.exist(data.value);\n      } finally {\n        await driver.deleteSession();\n      }\n    });\n  });\n});\n"],"file":"test/plugin-e2e-specs.js","sourceRoot":"../.."}

package/build/test/schema/arg-spec-specs.js

@@ -0,0 +1,70 @@
+"use strict";
+
+require("source-map-support/register");
+
+var _argSpec = require("../../lib/schema/arg-spec");
+
+const {
+  expect
+} = chai;
+describe('ArgSpec', function () {
+  describe('class method', function () {
+    describe('create()', function () {
+      it('should return a new ArgSpec', function () {
+        expect(_argSpec.ArgSpec.create('foo')).to.be.an.instanceof(_argSpec.ArgSpec);
+      });
+    });
+    describe('toSchemaRef()', function () {
+      describe('when provided no extension information', function () {
+        it('should return a schema ID for a specific argument', function () {
+          expect(_argSpec.ArgSpec.toSchemaRef('foo')).to.equal('appium.json#/properties/server/properties/foo');
+        });
+      });
+      describe('when provided extension information', function () {
+        it('should return a schema ID for a specific argument within an extension schema', function () {
+          expect(_argSpec.ArgSpec.toSchemaRef('bar', 'driver', 'stuff')).to.equal('driver-stuff.json#/properties/bar');
+        });
+      });
+    });
+    describe('toSchemaBaseRef()', function () {
+      describe('when provided no extension information', function () {
+        it('should return the base schema ID', function () {
+          expect(_argSpec.ArgSpec.toSchemaBaseRef()).to.equal('appium.json');
+        });
+      });
+      describe('when provided extension information', function () {
+        it('should return a schema ID for an extension', function () {
+          expect(_argSpec.ArgSpec.toSchemaBaseRef('driver', 'stuff')).to.equal('driver-stuff.json');
+        });
+      });
+    });
+    describe('toArg()', function () {
+      describe('when provided no extension information', function () {
+        it('should return a bare arg name', function () {
+          expect(_argSpec.ArgSpec.toArg('foo')).to.equal('foo');
+        });
+      });
+      describe('when provided extension information', function () {
+        it('should return an extension-specific arg name', function () {
+          expect(_argSpec.ArgSpec.toArg('no-oats', 'driver', 'bad-donkey')).to.equal('driver-bad-donkey-no-oats');
+        });
+      });
+    });
+    describe('extensionInfoFromRootSchemaId()', function () {
+      describe('when provided the base schema ID', function () {
+        it('should return an empty object', function () {
+          expect(_argSpec.ArgSpec.extensionInfoFromRootSchemaId('appium.json')).to.be.empty;
+        });
+      });
+      describe('when provided the schema ID of an extension schema', function () {
+        expect(_argSpec.ArgSpec.extensionInfoFromRootSchemaId('driver-stuff.json')).to.eql({
+          extType: 'driver',
+          normalizedExtName: 'stuff'
+        });
+      });
+    });
+  });
+});require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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