@appium/base-driver 8.1.2 → 8.2.3

package/build/test/express/server-e2e-specs.js

@@ -0,0 +1,156 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("source-map-support/register");
+
+var _lib = require("../../lib");
+
+var _axios = _interopRequireDefault(require("axios"));
+
+var _sinon = _interopRequireDefault(require("sinon"));
+
+var _bluebird = _interopRequireDefault(require("bluebird"));
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _helpers = require("../helpers");
+
+describe('server', function () {
+  let hwServer;
+  let errorStub;
+  let port;
+  before(async function () {
+    port = await (0, _helpers.getTestPort)(true);
+    errorStub = _sinon.default.stub(console, 'error');
+
+    function configureRoutes(app) {
+      app.get('/', (req, res) => {
+        res.header['content-type'] = 'text/html';
+        res.status(200).send('Hello World!');
+      });
+      app.get('/python', (req, res) => {
+        res.status(200).send(req.headers['content-type']);
+      });
+      app.get('/error', () => {
+        throw new Error('hahaha');
+      });
+      app.get('/pause', async (req, res) => {
+        res.header['content-type'] = 'text/html';
+        await _bluebird.default.delay(1000);
+        res.status(200).send('We have waited!');
+      });
+    }
+
+    hwServer = await (0, _lib.server)({
+      routeConfiguringFunction: configureRoutes,
+      port
+    });
+  });
+  after(async function () {
+    await hwServer.close();
+    errorStub.restore();
+  });
+  it('should start up with our middleware', async function () {
+    const {
+      data
+    } = await _axios.default.get(`http://${_helpers.TEST_HOST}:${port}/`);
+    data.should.eql('Hello World!');
+  });
+  it('should fix broken context type', async function () {
+    const {
+      data
+    } = await (0, _axios.default)({
+      url: `http://${_helpers.TEST_HOST}:${port}/python`,
+      headers: {
+        'user-agent': 'Python',
+        'content-type': 'application/x-www-form-urlencoded'
+      }
+    });
+    data.should.eql('application/json; charset=utf-8');
+  });
+  it('should catch errors in the catchall', async function () {
+    await _axios.default.get(`http://${_helpers.TEST_HOST}:${port}/error`).should.be.rejected;
+  });
+  it('should error if we try to start again on a port that is used', async function () {
+    await (0, _lib.server)({
+      routeConfiguringFunction() {},
+
+      port
+    }).should.be.rejectedWith(/EADDRINUSE/);
+  });
+  it('should not wait for the server close connections before finishing closing', async function () {
+    let bodyPromise = _axios.default.get(`http://${_helpers.TEST_HOST}:${port}/pause`).catch(() => {});
+
+    await _bluebird.default.delay(100);
+    let before = Date.now();
+    await hwServer.close();
+    (Date.now() - before).should.not.be.above(800);
+    await bodyPromise;
+  });
+  it('should error if we try to start on a bad hostname', async function () {
+    this.timeout(60000);
+    await (0, _lib.server)({
+      routeConfiguringFunction: _lodash.default.noop,
+      port,
+      hostname: 'lolcathost'
+    }).should.be.rejectedWith(/ENOTFOUND|EADDRNOTAVAIL|EAI_AGAIN/);
+    await (0, _lib.server)({
+      routeConfiguringFunction: _lodash.default.noop,
+      port,
+      hostname: '1.1.1.1'
+    }).should.be.rejectedWith(/EADDRNOTAVAIL/);
+  });
+});
+describe('server plugins', function () {
+  let hwServer;
+  let port;
+  before(async function () {
+    port = await (0, _helpers.getTestPort)(true);
+  });
+  afterEach(async function () {
+    try {
+      await hwServer.close();
+    } catch (ign) {}
+  });
+
+  function updaterWithGetRoute(route, reply) {
+    return async (app, httpServer) => {
+      app.get(`/${route}`, (req, res) => {
+        res.header['content-type'] = 'text/html';
+        res.status(200).send(reply);
+      });
+      httpServer[`_updated_${route}`] = true;
+    };
+  }
+
+  it('should allow one or more plugins to update the server', async function () {
+    hwServer = await (0, _lib.server)({
+      routeConfiguringFunction: _lodash.default.noop,
+      port,
+      serverUpdaters: [updaterWithGetRoute('plugin1', 'res from plugin1 route'), updaterWithGetRoute('plugin2', 'res from plugin2 route')]
+    });
+    let {
+      data
+    } = await _axios.default.get(`http://${_helpers.TEST_HOST}:${port}/plugin1`);
+    data.should.eql('res from plugin1 route');
+    ({
+      data
+    } = await _axios.default.get(`http://${_helpers.TEST_HOST}:${port}/plugin2`));
+    data.should.eql('res from plugin2 route');
+    hwServer._updated_plugin1.should.be.true;
+    hwServer._updated_plugin2.should.be.true;
+  });
+  it('should pass on errors from the plugin updateServer method', async function () {
+    await (0, _lib.server)({
+      routeConfiguringFunction: _lodash.default.noop,
+      port,
+      serverUpdaters: [() => {
+        throw new Error('ugh');
+      }]
+    }).should.eventually.be.rejectedWith(/ugh/);
+  });
+});require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["test/express/server-e2e-specs.js"],"names":["describe","hwServer","errorStub","port","before","sinon","stub","console","configureRoutes","app","get","req","res","header","status","send","headers","Error","B","delay","routeConfiguringFunction","after","close","restore","it","data","axios","TEST_HOST","should","eql","url","be","rejected","rejectedWith","bodyPromise","catch","Date","now","not","above","timeout","_","noop","hostname","afterEach","ign","updaterWithGetRoute","route","reply","httpServer","serverUpdaters","_updated_plugin1","true","_updated_plugin2","eventually"],"mappings":"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","sourcesContent":["// transpile:mocha\n\nimport { server } from '../../lib';\nimport axios from 'axios';\nimport sinon from 'sinon';\nimport B from 'bluebird';\nimport _ from 'lodash';\nimport {TEST_HOST, getTestPort} from '../helpers';\n\n\ndescribe('server', function () {\n  let hwServer;\n  let errorStub;\n  let port;\n  before(async function () {\n    port = await getTestPort(true);\n    errorStub = sinon.stub(console, 'error');\n    function configureRoutes (app) {\n      app.get('/', (req, res) => {\n        res.header['content-type'] = 'text/html';\n        res.status(200).send('Hello World!');\n      });\n      app.get('/python', (req, res) => {\n        res.status(200).send(req.headers['content-type']);\n      });\n      app.get('/error', () => {\n        throw new Error('hahaha');\n      });\n      app.get('/pause', async (req, res) => {\n        res.header['content-type'] = 'text/html';\n        await B.delay(1000);\n        res.status(200).send('We have waited!');\n      });\n    }\n    hwServer = await server({\n      routeConfiguringFunction: configureRoutes,\n      port,\n    });\n  });\n  after(async function () {\n    await hwServer.close();\n    errorStub.restore();\n  });\n\n  it('should start up with our middleware', async function () {\n    const {data} = await axios.get(`http://${TEST_HOST}:${port}/`);\n    data.should.eql('Hello World!');\n  });\n  it('should fix broken context type', async function () {\n    const {data} = await axios({\n      url: `http://${TEST_HOST}:${port}/python`,\n      headers: {\n        'user-agent': 'Python',\n        'content-type': 'application/x-www-form-urlencoded'\n      }\n    });\n    data.should.eql('application/json; charset=utf-8');\n  });\n  it('should catch errors in the catchall', async function () {\n    await axios.get(`http://${TEST_HOST}:${port}/error`).should.be.rejected;\n  });\n  it('should error if we try to start again on a port that is used', async function () {\n    await server({\n      routeConfiguringFunction () {},\n      port,\n    }).should.be.rejectedWith(/EADDRINUSE/);\n  });\n  it('should not wait for the server close connections before finishing closing', async function () {\n    let bodyPromise = axios.get(`http://${TEST_HOST}:${port}/pause`).catch(() => {});\n\n    // relinquish control so that we don't close before the request is received\n    await B.delay(100);\n\n    let before = Date.now();\n    await hwServer.close();\n    // expect slightly less than the request waited, since we paused above\n    (Date.now() - before).should.not.be.above(800);\n\n    await bodyPromise;\n  });\n  it('should error if we try to start on a bad hostname', async function () {\n    this.timeout(60000);\n    await server({\n      routeConfiguringFunction: _.noop,\n      port,\n      hostname: 'lolcathost',\n    }).should.be.rejectedWith(/ENOTFOUND|EADDRNOTAVAIL|EAI_AGAIN/);\n    await server({\n      routeConfiguringFunction: _.noop,\n      port,\n      hostname: '1.1.1.1',\n    }).should.be.rejectedWith(/EADDRNOTAVAIL/);\n  });\n});\n\ndescribe('server plugins', function () {\n  let hwServer;\n  let port;\n\n  before(async function () {\n    port = await getTestPort(true);\n  });\n\n  afterEach(async function () {\n    try {\n      await hwServer.close();\n    } catch (ign) {}\n  });\n\n  function updaterWithGetRoute (route, reply) {\n    return async (app, httpServer) => { // eslint-disable-line require-await\n      app.get(`/${route}`, (req, res) => {\n        res.header['content-type'] = 'text/html';\n        res.status(200).send(reply);\n      });\n      httpServer[`_updated_${route}`] = true;\n    };\n  }\n\n  it('should allow one or more plugins to update the server', async function () {\n    hwServer = await server({\n      routeConfiguringFunction: _.noop,\n      port,\n      serverUpdaters: [\n        updaterWithGetRoute('plugin1', 'res from plugin1 route'),\n        updaterWithGetRoute('plugin2', 'res from plugin2 route'),\n      ]\n    });\n    let {data} = await axios.get(`http://${TEST_HOST}:${port}/plugin1`);\n    data.should.eql('res from plugin1 route');\n    ({data} = await axios.get(`http://${TEST_HOST}:${port}/plugin2`));\n    data.should.eql('res from plugin2 route');\n    hwServer._updated_plugin1.should.be.true;\n    hwServer._updated_plugin2.should.be.true;\n  });\n  it('should pass on errors from the plugin updateServer method', async function () {\n    await server({\n      routeConfiguringFunction: _.noop,\n      port,\n      serverUpdaters: [() => { throw new Error('ugh');}]\n    }).should.eventually.be.rejectedWith(/ugh/);\n  });\n});\n"],"file":"test/express/server-e2e-specs.js","sourceRoot":"../../.."}

package/build/test/express/server-specs.js

@@ -0,0 +1,151 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("source-map-support/register");
+
+var _lib = require("../../lib");
+
+var _server2 = require("../../lib/express/server");
+
+var _sinon = _interopRequireDefault(require("sinon"));
+
+var _helpers = require("../helpers");
+
+function fakeApp() {
+  const app = {
+    use: _sinon.default.spy(),
+    all: _sinon.default.spy(),
+    get: _sinon.default.spy(),
+    post: _sinon.default.spy(),
+    delete: _sinon.default.spy(),
+    totalCount: () => app.use.callCount + app.all.callCount + app.get.callCount + app.post.callCount + app.delete.callCount
+  };
+  return app;
+}
+
+const newMethodMap = {
+  '/session/:sessionId/fake': {
+    GET: {
+      command: 'fakeGet'
+    },
+    POST: {
+      command: 'fakePost',
+      payloadParams: {
+        required: ['fakeParam']
+      }
+    }
+  }
+};
+
+const updateServer = (app, httpServer) => {
+  app.updated = true;
+  httpServer.updated = true;
+};
+
+function fakeDriver() {
+  return {
+    sessionExists: () => {},
+    executeCommand: () => {}
+  };
+}
+
+describe('server configuration', function () {
+  let port;
+  before(async function () {
+    port = await (0, _helpers.getTestPort)(true);
+  });
+  it('should actually use the middleware', function () {
+    const app = fakeApp();
+
+    const configureRoutes = () => {};
+
+    (0, _server2.configureServer)({
+      app,
+      addRoutes: configureRoutes
+    });
+    app.use.callCount.should.equal(14);
+    app.all.callCount.should.equal(4);
+  });
+  it('should apply new methods in plugins to the standard method map', function () {
+    const app1 = fakeApp();
+    const app2 = fakeApp();
+    const driver = fakeDriver();
+    const addRoutes = (0, _lib.routeConfiguringFunction)(driver);
+    (0, _server2.configureServer)({
+      app: app1,
+      addRoutes
+    });
+    (0, _server2.configureServer)({
+      app: app2,
+      addRoutes,
+      extraMethodMap: newMethodMap
+    });
+    app2.totalCount().should.eql(app1.totalCount() + 2);
+  });
+  it('should silently reject new methods in plugins if not plain objects', function () {
+    const app1 = fakeApp();
+    const app2 = fakeApp();
+    const driver = fakeDriver();
+    const addRoutes = (0, _lib.routeConfiguringFunction)(driver);
+    (0, _server2.configureServer)({
+      app: app1,
+      addRoutes
+    });
+    (0, _server2.configureServer)({
+      app: app2,
+      addRoutes,
+      extraMethodMap: []
+    });
+    app2.totalCount().should.eql(app1.totalCount());
+  });
+  it('should allow plugins to update the server', async function () {
+    const driver = fakeDriver();
+
+    const _server = await (0, _lib.server)({
+      routeConfiguringFunction: (0, _lib.routeConfiguringFunction)(driver),
+      port,
+      extraMethodMap: newMethodMap,
+      serverUpdaters: [updateServer]
+    });
+
+    try {
+      _server.updated.should.be.true;
+    } finally {
+      await _server.close();
+    }
+  });
+  it('should reject if error thrown in configureRoutes parameter', async function () {
+    const configureRoutes = () => {
+      throw new Error('I am Mr. MeeSeeks look at me!');
+    };
+
+    await (0, _lib.server)({
+      routeConfiguringFunction: configureRoutes,
+      port
+    }).should.be.rejectedWith('MeeSeeks');
+  });
+  describe('#normalizeBasePath', function () {
+    it('should throw an error for paths of the wrong type', function () {
+      should.throw(() => {
+        (0, _server2.normalizeBasePath)(null);
+      });
+      should.throw(() => {
+        (0, _server2.normalizeBasePath)(1);
+      });
+    });
+    it('should remove trailing slashes', function () {
+      (0, _server2.normalizeBasePath)('/wd/hub/').should.eql('/wd/hub');
+      (0, _server2.normalizeBasePath)('/foo/').should.eql('/foo');
+      (0, _server2.normalizeBasePath)('/').should.eql('');
+    });
+    it('should ensure a leading slash is present', function () {
+      (0, _server2.normalizeBasePath)('foo').should.eql('/foo');
+      (0, _server2.normalizeBasePath)('wd/hub').should.eql('/wd/hub');
+      (0, _server2.normalizeBasePath)('wd/hub/').should.eql('/wd/hub');
+    });
+  });
+});require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["test/express/server-specs.js"],"names":["fakeApp","app","use","sinon","spy","all","get","post","delete","totalCount","callCount","newMethodMap","GET","command","POST","payloadParams","required","updateServer","httpServer","updated","fakeDriver","sessionExists","executeCommand","describe","port","before","it","configureRoutes","addRoutes","should","equal","app1","app2","driver","extraMethodMap","eql","_server","routeConfiguringFunction","serverUpdaters","be","true","close","Error","rejectedWith","throw"],"mappings":"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","sourcesContent":["// transpile:mocha\n\nimport { server, routeConfiguringFunction } from '../../lib';\nimport { configureServer, normalizeBasePath } from '../../lib/express/server';\nimport sinon from 'sinon';\nimport {getTestPort} from '../helpers';\n\nfunction fakeApp () {\n  const app = {\n    use: sinon.spy(),\n    all: sinon.spy(),\n    get: sinon.spy(),\n    post: sinon.spy(),\n    delete: sinon.spy(),\n    totalCount: () => (\n      app.use.callCount + app.all.callCount + app.get.callCount + app.post.callCount +\n      app.delete.callCount\n    )\n  };\n  return app;\n}\n\nconst newMethodMap = {\n  '/session/:sessionId/fake': {\n    GET: {command: 'fakeGet'},\n    POST: {command: 'fakePost', payloadParams: {required: ['fakeParam']}}\n  },\n};\n\nconst updateServer = (app, httpServer) => {\n  app.updated = true;\n  httpServer.updated = true;\n};\n\nfunction fakeDriver () {\n  return {sessionExists: () => {}, executeCommand: () => {}};\n}\n\ndescribe('server configuration', function () {\n  let port;\n\n  before(async function () {\n    port = await getTestPort(true);\n  });\n\n  it('should actually use the middleware', function () {\n    const app = fakeApp();\n    const configureRoutes = () => {};\n    configureServer({app, addRoutes: configureRoutes});\n    app.use.callCount.should.equal(14);\n    app.all.callCount.should.equal(4);\n  });\n\n  it('should apply new methods in plugins to the standard method map', function () {\n    const app1 = fakeApp();\n    const app2 = fakeApp();\n    const driver = fakeDriver();\n    const addRoutes = routeConfiguringFunction(driver);\n    configureServer({app: app1, addRoutes});\n    configureServer({app: app2, addRoutes, extraMethodMap: newMethodMap});\n    app2.totalCount().should.eql(app1.totalCount() + 2);\n  });\n\n  it('should silently reject new methods in plugins if not plain objects', function () {\n    const app1 = fakeApp();\n    const app2 = fakeApp();\n    const driver = fakeDriver();\n    const addRoutes = routeConfiguringFunction(driver);\n    configureServer({app: app1, addRoutes});\n    configureServer({app: app2, addRoutes, extraMethodMap: []});\n    app2.totalCount().should.eql(app1.totalCount());\n  });\n\n  it('should allow plugins to update the server', async function () {\n    const driver = fakeDriver();\n    const _server = await server({\n      routeConfiguringFunction: routeConfiguringFunction(driver),\n      port,\n      extraMethodMap: newMethodMap,\n      serverUpdaters: [updateServer]\n    });\n    try {\n      _server.updated.should.be.true;\n    } finally {\n      await _server.close();\n    }\n  });\n\n  it('should reject if error thrown in configureRoutes parameter', async function () {\n    const configureRoutes = () => {\n      throw new Error('I am Mr. MeeSeeks look at me!');\n    };\n    await server({\n      routeConfiguringFunction: configureRoutes,\n      port,\n    }).should.be.rejectedWith('MeeSeeks');\n  });\n\n  describe('#normalizeBasePath', function () {\n    it('should throw an error for paths of the wrong type', function () {\n      should.throw(() => {\n        normalizeBasePath(null);\n      });\n      should.throw(() => {\n        normalizeBasePath(1);\n      });\n    });\n    it('should remove trailing slashes', function () {\n      normalizeBasePath('/wd/hub/').should.eql('/wd/hub');\n      normalizeBasePath('/foo/').should.eql('/foo');\n      normalizeBasePath('/').should.eql('');\n    });\n    it('should ensure a leading slash is present', function () {\n      normalizeBasePath('foo').should.eql('/foo');\n      normalizeBasePath('wd/hub').should.eql('/wd/hub');\n      normalizeBasePath('wd/hub/').should.eql('/wd/hub');\n    });\n  });\n});\n"],"file":"test/express/server-specs.js","sourceRoot":"../../.."}

package/build/test/express/static-specs.js

@@ -0,0 +1,23 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("source-map-support/register");
+
+var _static = require("../../lib/express/static");
+
+var _sinon = _interopRequireDefault(require("sinon"));
+
+describe('welcome', function () {
+  it('should fill the template', async function () {
+    let res = {
+      send: _sinon.default.spy()
+    };
+    await (0, _static.welcome)({}, res);
+    res.send.calledOnce.should.be.true;
+    res.send.args[0][0].should.include('Let\'s browse!');
+  });
+});require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRlc3QvZXhwcmVzcy9zdGF0aWMtc3BlY3MuanMiXSwibmFtZXMiOlsiZGVzY3JpYmUiLCJpdCIsInJlcyIsInNlbmQiLCJzaW5vbiIsInNweSIsImNhbGxlZE9uY2UiLCJzaG91bGQiLCJiZSIsInRydWUiLCJhcmdzIiwiaW5jbHVkZSJdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBRUE7O0FBQ0E7O0FBSUFBLFFBQVEsQ0FBQyxTQUFELEVBQVksWUFBWTtBQUM5QkMsRUFBQUEsRUFBRSxDQUFDLDBCQUFELEVBQTZCLGtCQUFrQjtBQUMvQyxRQUFJQyxHQUFHLEdBQUc7QUFDUkMsTUFBQUEsSUFBSSxFQUFFQyxlQUFNQyxHQUFOO0FBREUsS0FBVjtBQUdBLFVBQU0scUJBQVEsRUFBUixFQUFZSCxHQUFaLENBQU47QUFFQUEsSUFBQUEsR0FBRyxDQUFDQyxJQUFKLENBQVNHLFVBQVQsQ0FBb0JDLE1BQXBCLENBQTJCQyxFQUEzQixDQUE4QkMsSUFBOUI7QUFDQVAsSUFBQUEsR0FBRyxDQUFDQyxJQUFKLENBQVNPLElBQVQsQ0FBYyxDQUFkLEVBQWlCLENBQWpCLEVBQW9CSCxNQUFwQixDQUEyQkksT0FBM0IsQ0FBbUMsZ0JBQW5DO0FBQ0QsR0FSQyxDQUFGO0FBU0QsQ0FWTyxDQUFSIiwic291cmNlc0NvbnRlbnQiOlsiLy8gdHJhbnNwaWxlOm1vY2hhXG5cbmltcG9ydCB7IHdlbGNvbWUgfSBmcm9tICcuLi8uLi9saWIvZXhwcmVzcy9zdGF0aWMnO1xuaW1wb3J0IHNpbm9uIGZyb20gJ3Npbm9uJztcblxuXG5cbmRlc2NyaWJlKCd3ZWxjb21lJywgZnVuY3Rpb24gKCkge1xuICBpdCgnc2hvdWxkIGZpbGwgdGhlIHRlbXBsYXRlJywgYXN5bmMgZnVuY3Rpb24gKCkge1xuICAgIGxldCByZXMgPSB7XG4gICAgICBzZW5kOiBzaW5vbi5zcHkoKVxuICAgIH07XG4gICAgYXdhaXQgd2VsY29tZSh7fSwgcmVzKTtcblxuICAgIHJlcy5zZW5kLmNhbGxlZE9uY2Uuc2hvdWxkLmJlLnRydWU7XG4gICAgcmVzLnNlbmQuYXJnc1swXVswXS5zaG91bGQuaW5jbHVkZSgnTGV0XFwncyBicm93c2UhJyk7XG4gIH0pO1xufSk7XG4iXSwiZmlsZSI6InRlc3QvZXhwcmVzcy9zdGF0aWMtc3BlY3MuanMiLCJzb3VyY2VSb290IjoiLi4vLi4vLi4ifQ==

package/build/test/helpers.js

@@ -0,0 +1,57 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createAppiumURL = exports.TEST_HOST = exports.METHODS = void 0;
+exports.getTestPort = getTestPort;
+
+require("source-map-support/register");
+
+var _getPort = _interopRequireDefault(require("get-port"));
+
+var _lodash = require("lodash");
+
+const TEST_HOST = '127.0.0.1';
+exports.TEST_HOST = TEST_HOST;
+const METHODS = {
+  POST: 'POST',
+  DELETE: 'DELETE'
+};
+exports.METHODS = METHODS;
+let testPort;
+
+async function getTestPort(force = false) {
+  if (force || !testPort) {
+    let port = await (0, _getPort.default)();
+
+    if (!testPort) {
+      testPort = port;
+    }
+
+    return port;
+  }
+
+  return testPort;
+}
+
+const createAppiumURL = (0, _lodash.curry)((address, port, session, pathname) => {
+  if (!/^https?:\/\//.test(address)) {
+    address = `http://${address}`;
+  }
+
+  let path = session ? `session/${session}` : '';
+
+  if (pathname) {
+    path = `${path}/${pathname}`;
+  }
+
+  let url = new URL(path, `${address}:${port}`);
+  return url.href;
+}, 4);
+exports.createAppiumURL = createAppiumURL;require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/build/test/jsonwp-proxy/mock-request.js

@@ -0,0 +1,93 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+require("source-map-support/register");
+
+function resFixture(url, method) {
+  if (/\/status$/.test(url)) {
+    return [200, {
+      status: 0,
+      value: {
+        foo: 'bar'
+      }
+    }];
+  }
+
+  if (/\/element\/bad\/text$/.test(url)) {
+    return [500, {
+      status: 11,
+      value: {
+        message: 'Invisible element'
+      }
+    }];
+  }
+
+  if (/\/element\/200\/text$/.test(url)) {
+    return [200, {
+      status: 11,
+      value: {
+        message: 'Invisible element'
+      }
+    }];
+  }
+
+  if (/\/element\/200\/value$/.test(url)) {
+    return [200, {
+      status: 0,
+      sessionId: 'innersessionid',
+      value: 'foobar'
+    }];
+  }
+
+  if (/\/session$/.test(url) && method === 'POST') {
+    return [200, {
+      status: 0,
+      sessionId: '123',
+      value: {
+        browserName: 'boo'
+      }
+    }];
+  }
+
+  if (/\/nochrome$/.test(url)) {
+    return [100, {
+      status: 0,
+      value: {
+        message: 'chrome not reachable'
+      }
+    }];
+  }
+
+  throw new Error("Can't handle url " + url);
+}
+
+async function request(opts) {
+  const {
+    url,
+    method,
+    json
+  } = opts;
+
+  if (/badurl$/.test(url)) {
+    throw new Error('noworky');
+  }
+
+  const [status, data] = resFixture(url, method, json);
+  return {
+    status,
+    headers: {
+      'content-type': 'application/json; charset=utf-8'
+    },
+    data
+  };
+}
+
+var _default = request;
+exports.default = _default;require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRlc3QvanNvbndwLXByb3h5L21vY2stcmVxdWVzdC5qcyJdLCJuYW1lcyI6WyJyZXNGaXh0dXJlIiwidXJsIiwibWV0aG9kIiwidGVzdCIsInN0YXR1cyIsInZhbHVlIiwiZm9vIiwibWVzc2FnZSIsInNlc3Npb25JZCIsImJyb3dzZXJOYW1lIiwiRXJyb3IiLCJyZXF1ZXN0Iiwib3B0cyIsImpzb24iLCJkYXRhIiwiaGVhZGVycyJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7O0FBQUEsU0FBU0EsVUFBVCxDQUFxQkMsR0FBckIsRUFBMEJDLE1BQTFCLEVBQWtDO0FBQ2hDLE1BQUksWUFBWUMsSUFBWixDQUFpQkYsR0FBakIsQ0FBSixFQUEyQjtBQUN6QixXQUFPLENBQUMsR0FBRCxFQUFNO0FBQUNHLE1BQUFBLE1BQU0sRUFBRSxDQUFUO0FBQVlDLE1BQUFBLEtBQUssRUFBRTtBQUFDQyxRQUFBQSxHQUFHLEVBQUU7QUFBTjtBQUFuQixLQUFOLENBQVA7QUFDRDs7QUFDRCxNQUFJLHdCQUF3QkgsSUFBeEIsQ0FBNkJGLEdBQTdCLENBQUosRUFBdUM7QUFDckMsV0FBTyxDQUFDLEdBQUQsRUFBTTtBQUFDRyxNQUFBQSxNQUFNLEVBQUUsRUFBVDtBQUFhQyxNQUFBQSxLQUFLLEVBQUU7QUFBQ0UsUUFBQUEsT0FBTyxFQUFFO0FBQVY7QUFBcEIsS0FBTixDQUFQO0FBQ0Q7O0FBQ0QsTUFBSSx3QkFBd0JKLElBQXhCLENBQTZCRixHQUE3QixDQUFKLEVBQXVDO0FBQ3JDLFdBQU8sQ0FBQyxHQUFELEVBQU07QUFBQ0csTUFBQUEsTUFBTSxFQUFFLEVBQVQ7QUFBYUMsTUFBQUEsS0FBSyxFQUFFO0FBQUNFLFFBQUFBLE9BQU8sRUFBRTtBQUFWO0FBQXBCLEtBQU4sQ0FBUDtBQUNEOztBQUNELE1BQUkseUJBQXlCSixJQUF6QixDQUE4QkYsR0FBOUIsQ0FBSixFQUF3QztBQUN0QyxXQUFPLENBQUMsR0FBRCxFQUFNO0FBQUNHLE1BQUFBLE1BQU0sRUFBRSxDQUFUO0FBQVlJLE1BQUFBLFNBQVMsRUFBRSxnQkFBdkI7QUFBeUNILE1BQUFBLEtBQUssRUFBRTtBQUFoRCxLQUFOLENBQVA7QUFDRDs7QUFDRCxNQUFJLGFBQWFGLElBQWIsQ0FBa0JGLEdBQWxCLEtBQTBCQyxNQUFNLEtBQUssTUFBekMsRUFBaUQ7QUFDL0MsV0FBTyxDQUFDLEdBQUQsRUFBTTtBQUFDRSxNQUFBQSxNQUFNLEVBQUUsQ0FBVDtBQUFZSSxNQUFBQSxTQUFTLEVBQUUsS0FBdkI7QUFBOEJILE1BQUFBLEtBQUssRUFBRTtBQUFDSSxRQUFBQSxXQUFXLEVBQUU7QUFBZDtBQUFyQyxLQUFOLENBQVA7QUFDRDs7QUFDRCxNQUFJLGNBQWNOLElBQWQsQ0FBbUJGLEdBQW5CLENBQUosRUFBNkI7QUFDM0IsV0FBTyxDQUFDLEdBQUQsRUFBTTtBQUFDRyxNQUFBQSxNQUFNLEVBQUUsQ0FBVDtBQUFZQyxNQUFBQSxLQUFLLEVBQUU7QUFBQ0UsUUFBQUEsT0FBTyxFQUFFO0FBQVY7QUFBbkIsS0FBTixDQUFQO0FBQ0Q7O0FBQ0QsUUFBTSxJQUFJRyxLQUFKLENBQVUsc0JBQXNCVCxHQUFoQyxDQUFOO0FBQ0Q7O0FBRUQsZUFBZVUsT0FBZixDQUF3QkMsSUFBeEIsRUFBOEI7QUFDNUIsUUFBTTtBQUFDWCxJQUFBQSxHQUFEO0FBQU1DLElBQUFBLE1BQU47QUFBY1csSUFBQUE7QUFBZCxNQUFzQkQsSUFBNUI7O0FBQ0EsTUFBSSxVQUFVVCxJQUFWLENBQWVGLEdBQWYsQ0FBSixFQUF5QjtBQUN2QixVQUFNLElBQUlTLEtBQUosQ0FBVSxTQUFWLENBQU47QUFDRDs7QUFFRCxRQUFNLENBQUNOLE1BQUQsRUFBU1UsSUFBVCxJQUFpQmQsVUFBVSxDQUFDQyxHQUFELEVBQU1DLE1BQU4sRUFBY1csSUFBZCxDQUFqQztBQUNBLFNBQU87QUFDTFQsSUFBQUEsTUFESztBQUVMVyxJQUFBQSxPQUFPLEVBQUU7QUFBQyxzQkFBZ0I7QUFBakIsS0FGSjtBQUdMRCxJQUFBQTtBQUhLLEdBQVA7QUFLRDs7ZUFFY0gsTyIsInNvdXJjZXNDb250ZW50IjpbImZ1bmN0aW9uIHJlc0ZpeHR1cmUgKHVybCwgbWV0aG9kKSB7XG4gIGlmICgvXFwvc3RhdHVzJC8udGVzdCh1cmwpKSB7XG4gICAgcmV0dXJuIFsyMDAsIHtzdGF0dXM6IDAsIHZhbHVlOiB7Zm9vOiAnYmFyJ319XTtcbiAgfVxuICBpZiAoL1xcL2VsZW1lbnRcXC9iYWRcXC90ZXh0JC8udGVzdCh1cmwpKSB7XG4gICAgcmV0dXJuIFs1MDAsIHtzdGF0dXM6IDExLCB2YWx1ZToge21lc3NhZ2U6ICdJbnZpc2libGUgZWxlbWVudCd9fV07XG4gIH1cbiAgaWYgKC9cXC9lbGVtZW50XFwvMjAwXFwvdGV4dCQvLnRlc3QodXJsKSkge1xuICAgIHJldHVybiBbMjAwLCB7c3RhdHVzOiAxMSwgdmFsdWU6IHttZXNzYWdlOiAnSW52aXNpYmxlIGVsZW1lbnQnfX1dO1xuICB9XG4gIGlmICgvXFwvZWxlbWVudFxcLzIwMFxcL3ZhbHVlJC8udGVzdCh1cmwpKSB7XG4gICAgcmV0dXJuIFsyMDAsIHtzdGF0dXM6IDAsIHNlc3Npb25JZDogJ2lubmVyc2Vzc2lvbmlkJywgdmFsdWU6ICdmb29iYXInfV07XG4gIH1cbiAgaWYgKC9cXC9zZXNzaW9uJC8udGVzdCh1cmwpICYmIG1ldGhvZCA9PT0gJ1BPU1QnKSB7XG4gICAgcmV0dXJuIFsyMDAsIHtzdGF0dXM6IDAsIHNlc3Npb25JZDogJzEyMycsIHZhbHVlOiB7YnJvd3Nlck5hbWU6ICdib28nfX1dO1xuICB9XG4gIGlmICgvXFwvbm9jaHJvbWUkLy50ZXN0KHVybCkpIHtcbiAgICByZXR1cm4gWzEwMCwge3N0YXR1czogMCwgdmFsdWU6IHttZXNzYWdlOiAnY2hyb21lIG5vdCByZWFjaGFibGUnfX1dO1xuICB9XG4gIHRocm93IG5ldyBFcnJvcihcIkNhbid0IGhhbmRsZSB1cmwgXCIgKyB1cmwpO1xufVxuXG5hc3luYyBmdW5jdGlvbiByZXF1ZXN0IChvcHRzKSB7IC8vIGVzbGludC1kaXNhYmxlLWxpbmUgcmVxdWlyZS1hd2FpdFxuICBjb25zdCB7dXJsLCBtZXRob2QsIGpzb259ID0gb3B0cztcbiAgaWYgKC9iYWR1cmwkLy50ZXN0KHVybCkpIHtcbiAgICB0aHJvdyBuZXcgRXJyb3IoJ25vd29ya3knKTtcbiAgfVxuXG4gIGNvbnN0IFtzdGF0dXMsIGRhdGFdID0gcmVzRml4dHVyZSh1cmwsIG1ldGhvZCwganNvbik7XG4gIHJldHVybiB7XG4gICAgc3RhdHVzLFxuICAgIGhlYWRlcnM6IHsnY29udGVudC10eXBlJzogJ2FwcGxpY2F0aW9uL2pzb247IGNoYXJzZXQ9dXRmLTgnfSxcbiAgICBkYXRhLFxuICB9O1xufVxuXG5leHBvcnQgZGVmYXVsdCByZXF1ZXN0O1xuIl0sImZpbGUiOiJ0ZXN0L2pzb253cC1wcm94eS9tb2NrLXJlcXVlc3QuanMiLCJzb3VyY2VSb290IjoiLi4vLi4vLi4ifQ==