@appium/base-driver 8.3.0 → 8.3.1

package/build/test/unit/basedriver/helpers.spec.js

@@ -0,0 +1,151 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("source-map-support/register");
+
+var _support = require("@appium/support");
+
+var _helpers = require("../../../lib/basedriver/helpers");
+
+var _sinon = _interopRequireDefault(require("sinon"));
+
+describe('helpers', function () {
+  describe('#isPackageOrBundle', function () {
+    it('should accept packages and bundles', function () {
+      (0, _helpers.isPackageOrBundle)('io.appium.testapp').should.be.true;
+    });
+    it('should not accept non-packages or non-bundles', function () {
+      (0, _helpers.isPackageOrBundle)('foo').should.be.false;
+      (0, _helpers.isPackageOrBundle)('/path/to/an.app').should.be.false;
+      (0, _helpers.isPackageOrBundle)('/path/to/an.apk').should.be.false;
+    });
+  });
+  describe('#duplicateKeys', function () {
+    it('should translate key in an object', function () {
+      (0, _helpers.duplicateKeys)({
+        'foo': 'hello world'
+      }, 'foo', 'bar').should.eql({
+        'foo': 'hello world',
+        'bar': 'hello world'
+      });
+    });
+    it('should translate key in an object within an object', function () {
+      (0, _helpers.duplicateKeys)({
+        'key': {
+          'foo': 'hello world'
+        }
+      }, 'foo', 'bar').should.eql({
+        'key': {
+          'foo': 'hello world',
+          'bar': 'hello world'
+        }
+      });
+    });
+    it('should translate key in an object with an array', function () {
+      (0, _helpers.duplicateKeys)([{
+        'key': {
+          'foo': 'hello world'
+        }
+      }, {
+        'foo': 'HELLO WORLD'
+      }], 'foo', 'bar').should.eql([{
+        'key': {
+          'foo': 'hello world',
+          'bar': 'hello world'
+        }
+      }, {
+        'foo': 'HELLO WORLD',
+        'bar': 'HELLO WORLD'
+      }]);
+    });
+    it('should duplicate both keys', function () {
+      (0, _helpers.duplicateKeys)({
+        'keyOne': {
+          'foo': 'hello world'
+        },
+        'keyTwo': {
+          'bar': 'HELLO WORLD'
+        }
+      }, 'foo', 'bar').should.eql({
+        'keyOne': {
+          'foo': 'hello world',
+          'bar': 'hello world'
+        },
+        'keyTwo': {
+          'bar': 'HELLO WORLD',
+          'foo': 'HELLO WORLD'
+        }
+      });
+    });
+    it('should not do anything to primitives', function () {
+      [0, 1, -1, true, false, null, undefined, '', 'Hello World'].forEach(item => {
+        should.equal((0, _helpers.duplicateKeys)(item), item);
+      });
+    });
+    it('should rename keys on big complex objects', function () {
+      const input = [{
+        'foo': 'bar'
+      }, {
+        hello: {
+          world: {
+            'foo': 'BAR'
+          }
+        },
+        foo: 'bahr'
+      }, 'foo', null, 0];
+      const expectedOutput = [{
+        'foo': 'bar',
+        'FOO': 'bar'
+      }, {
+        hello: {
+          world: {
+            'foo': 'BAR',
+            'FOO': 'BAR'
+          }
+        },
+        foo: 'bahr',
+        FOO: 'bahr'
+      }, 'foo', null, 0];
+      (0, _helpers.duplicateKeys)(input, 'foo', 'FOO').should.deep.equal(expectedOutput);
+    });
+  });
+  describe('#configureApp', function () {
+    let sandbox;
+    beforeEach(function () {
+      sandbox = _sinon.default.createSandbox();
+      sandbox.stub(_support.zip, 'extractAllTo').resolves();
+      sandbox.stub(_support.zip, 'assertValidZip').resolves();
+      sandbox.stub(_support.fs, 'mv').resolves();
+      sandbox.stub(_support.fs, 'stat').resolves({
+        isFile: () => true,
+        isDirectory: () => false
+      });
+      sandbox.stub(_support.fs, 'exists').resolves(true);
+      sandbox.stub(_support.fs, 'hash').resolves('0xDEADBEEF');
+      sandbox.stub(_support.fs, 'glob').resolves(['/path/to/an.apk']);
+      sandbox.stub(_support.fs, 'rimraf').resolves();
+      sandbox.stub(_support.tempDir, 'openDir').resolves('/some/dir');
+    });
+    afterEach(function () {
+      sandbox.restore();
+    });
+    it('should pass "useSystemUnzip" flag through to @appium/support', async function () {
+      await (0, _helpers.configureApp)('/path/to/an.apk.zip', '.apk');
+      _support.zip.extractAllTo.getCall(0).lastArg.useSystemUnzip.should.be.true;
+    });
+  });
+});
+describe('parseCapsArray', function () {
+  it('should parse string into array', function () {
+    (0, _helpers.parseCapsArray)('/tmp/my/app.zip').should.eql(['/tmp/my/app.zip']);
+  });
+  it('should parse array as string into array', function () {
+    (0, _helpers.parseCapsArray)('["/tmp/my/app.zip"]').should.eql(['/tmp/my/app.zip']);
+    (0, _helpers.parseCapsArray)('["/tmp/my/app.zip","/tmp/my/app2.zip"]').should.eql(['/tmp/my/app.zip', '/tmp/my/app2.zip']);
+  });
+  it('should return an array without change', function () {
+    (0, _helpers.parseCapsArray)(['a', 'b']).should.eql(['a', 'b']);
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../test/unit/basedriver/helpers.spec.js"],"names":["describe","it","should","be","true","false","eql","undefined","forEach","item","equal","input","hello","world","foo","expectedOutput","FOO","deep","sandbox","beforeEach","sinon","createSandbox","stub","zip","resolves","fs","isFile","isDirectory","tempDir","afterEach","restore","extractAllTo","getCall","lastArg","useSystemUnzip"],"mappings":"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","sourcesContent":["import { zip, fs, tempDir } from '@appium/support';\nimport { configureApp, isPackageOrBundle, duplicateKeys, parseCapsArray } from '../../../lib/basedriver/helpers';\nimport sinon from 'sinon';\n\n\ndescribe('helpers', function () {\n  describe('#isPackageOrBundle', function () {\n    it('should accept packages and bundles', function () {\n      isPackageOrBundle('io.appium.testapp').should.be.true;\n    });\n    it('should not accept non-packages or non-bundles', function () {\n      isPackageOrBundle('foo').should.be.false;\n      isPackageOrBundle('/path/to/an.app').should.be.false;\n      isPackageOrBundle('/path/to/an.apk').should.be.false;\n    });\n  });\n\n  describe('#duplicateKeys', function () {\n    it('should translate key in an object', function () {\n      duplicateKeys({'foo': 'hello world'}, 'foo', 'bar').should.eql({'foo': 'hello world', 'bar': 'hello world'});\n    });\n    it('should translate key in an object within an object', function () {\n      duplicateKeys({'key': {'foo': 'hello world'}}, 'foo', 'bar').should.eql({'key': {'foo': 'hello world', 'bar': 'hello world'}});\n    });\n    it('should translate key in an object with an array', function () {\n      duplicateKeys([\n        {'key': {'foo': 'hello world'}},\n        {'foo': 'HELLO WORLD'}\n      ], 'foo', 'bar').should.eql([\n        {'key': {'foo': 'hello world', 'bar': 'hello world'}},\n        {'foo': 'HELLO WORLD', 'bar': 'HELLO WORLD'}\n      ]);\n    });\n    it('should duplicate both keys', function () {\n      duplicateKeys({\n        'keyOne': {\n          'foo': 'hello world',\n        },\n        'keyTwo': {\n          'bar': 'HELLO WORLD',\n        },\n      }, 'foo', 'bar').should.eql({\n        'keyOne': {\n          'foo': 'hello world',\n          'bar': 'hello world',\n        },\n        'keyTwo': {\n          'bar': 'HELLO WORLD',\n          'foo': 'HELLO WORLD',\n        }\n      });\n    });\n    it('should not do anything to primitives', function () {\n      [0, 1, -1, true, false, null, undefined, '', 'Hello World'].forEach((item) => {\n        should.equal(duplicateKeys(item), item);\n      });\n    });\n    it('should rename keys on big complex objects', function () {\n      const input = [\n        {'foo': 'bar'},\n        {\n          hello: {\n            world: {\n              'foo': 'BAR',\n            }\n          },\n          foo: 'bahr'\n        },\n        'foo',\n        null,\n        0\n      ];\n      const expectedOutput = [\n        {'foo': 'bar', 'FOO': 'bar'},\n        {\n          hello: {\n            world: {\n              'foo': 'BAR',\n              'FOO': 'BAR',\n            }\n          },\n          foo: 'bahr',\n          FOO: 'bahr'\n        },\n        'foo',\n        null,\n        0\n      ];\n      duplicateKeys(input, 'foo', 'FOO').should.deep.equal(expectedOutput);\n    });\n  });\n\n  describe('#configureApp', function () {\n    let sandbox;\n\n    beforeEach(function () {\n      sandbox = sinon.createSandbox();\n      sandbox.stub(zip, 'extractAllTo').resolves();\n      sandbox.stub(zip, 'assertValidZip').resolves();\n      sandbox.stub(fs, 'mv').resolves();\n      sandbox.stub(fs, 'stat').resolves({\n        isFile: () => true,\n        isDirectory: () => false,\n      });\n      sandbox.stub(fs, 'exists').resolves(true);\n      sandbox.stub(fs, 'hash').resolves('0xDEADBEEF');\n      sandbox.stub(fs, 'glob').resolves(['/path/to/an.apk']);\n      sandbox.stub(fs, 'rimraf').resolves();\n      sandbox.stub(tempDir, 'openDir').resolves('/some/dir');\n    });\n\n    afterEach(function () {\n      sandbox.restore();\n    });\n\n    it('should pass \"useSystemUnzip\" flag through to @appium/support', async function () {\n      await configureApp('/path/to/an.apk.zip', '.apk');\n      zip.extractAllTo.getCall(0).lastArg.useSystemUnzip.should.be.true;\n    });\n  });\n});\n\ndescribe('parseCapsArray', function () {\n  it('should parse string into array', function () {\n    parseCapsArray('/tmp/my/app.zip').should.eql(['/tmp/my/app.zip']);\n  });\n  it('should parse array as string into array', function () {\n    parseCapsArray('[\"/tmp/my/app.zip\"]').should.eql(['/tmp/my/app.zip']);\n    parseCapsArray('[\"/tmp/my/app.zip\",\"/tmp/my/app2.zip\"]').should.eql([\n      '/tmp/my/app.zip',\n      '/tmp/my/app2.zip'\n    ]);\n  });\n  it('should return an array without change', function () {\n    parseCapsArray(['a', 'b']).should.eql(['a', 'b']);\n  });\n});\n"]}

package/build/test/unit/basedriver/timeout.spec.js

@@ -0,0 +1,135 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("source-map-support/register");
+
+var _lib = _interopRequireDefault(require("../../../lib"));
+
+var _sinon = require("sinon");
+
+describe('timeout', function () {
+  let driver = new _lib.default();
+  let implicitWaitSpy;
+  let sandbox;
+  beforeEach(function () {
+    sandbox = (0, _sinon.createSandbox)();
+    driver.implicitWaitMs = 0;
+    implicitWaitSpy = sandbox.spy(driver, 'setImplicitWait');
+  });
+  afterEach(function () {
+    sandbox.restore();
+  });
+  describe('timeouts', function () {
+    describe('errors', function () {
+      it('should throw an error if something random is sent', async function () {
+        await driver.timeouts('random timeout', 'howdy').should.eventually.be.rejected;
+      });
+      it('should throw an error if timeout is negative', async function () {
+        await driver.timeouts('random timeout', -42).should.eventually.be.rejected;
+      });
+      it('should throw an errors if timeout type is unknown', async function () {
+        await driver.timeouts('random timeout', 42).should.eventually.be.rejected;
+      });
+      it('should throw an error if something random is sent to scriptDuration', async function () {
+        await driver.timeouts(undefined, undefined, 123, undefined, undefined).should.eventually.be.rejected;
+      });
+      it('should throw an error if something random is sent to pageLoadDuration', async function () {
+        await driver.timeouts(undefined, undefined, undefined, 123, undefined).should.eventually.be.rejected;
+      });
+    });
+    describe('implicit wait', function () {
+      it('should call setImplicitWait when given an integer', async function () {
+        await driver.timeouts('implicit', 42);
+        implicitWaitSpy.calledOnce.should.be.true;
+        implicitWaitSpy.firstCall.args[0].should.equal(42);
+        driver.implicitWaitMs.should.eql(42);
+      });
+      it('should call setImplicitWait when given a string', async function () {
+        await driver.timeouts('implicit', '42');
+        implicitWaitSpy.calledOnce.should.be.true;
+        implicitWaitSpy.firstCall.args[0].should.equal(42);
+        driver.implicitWaitMs.should.eql(42);
+      });
+      it('should call setImplicitWait when given an integer to implicitDuration', async function () {
+        await driver.timeouts(undefined, undefined, undefined, undefined, 42);
+        implicitWaitSpy.calledOnce.should.be.true;
+        implicitWaitSpy.firstCall.args[0].should.equal(42);
+        driver.implicitWaitMs.should.eql(42);
+      });
+      it('should call setImplicitWait when given a string to implicitDuration', async function () {
+        await driver.timeouts(undefined, undefined, undefined, undefined, '42');
+        implicitWaitSpy.calledOnce.should.be.true;
+        implicitWaitSpy.firstCall.args[0].should.equal(42);
+        driver.implicitWaitMs.should.eql(42);
+      });
+    });
+  });
+  describe('implicitWait', function () {
+    it('should call setImplicitWait when given an integer', async function () {
+      await driver.implicitWait(42);
+      implicitWaitSpy.calledOnce.should.be.true;
+      implicitWaitSpy.firstCall.args[0].should.equal(42);
+      driver.implicitWaitMs.should.eql(42);
+    });
+    it('should call setImplicitWait when given a string', async function () {
+      await driver.implicitWait('42');
+      implicitWaitSpy.calledOnce.should.be.true;
+      implicitWaitSpy.firstCall.args[0].should.equal(42);
+      driver.implicitWaitMs.should.eql(42);
+    });
+    it('should throw an error if something random is sent', async function () {
+      await driver.implicitWait('howdy').should.eventually.be.rejected;
+    });
+    it('should throw an error if timeout is negative', async function () {
+      await driver.implicitWait(-42).should.eventually.be.rejected;
+    });
+  });
+  describe('set implicit wait', function () {
+    it('should set the implicit wait with an integer', function () {
+      driver.setImplicitWait(42);
+      driver.implicitWaitMs.should.eql(42);
+    });
+    describe('with managed driver', function () {
+      let managedDriver1 = new _lib.default();
+      let managedDriver2 = new _lib.default();
+      before(function () {
+        driver.addManagedDriver(managedDriver1);
+        driver.addManagedDriver(managedDriver2);
+      });
+      after(function () {
+        driver.managedDrivers = [];
+      });
+      it('should set the implicit wait on managed drivers', function () {
+        driver.setImplicitWait(42);
+        driver.implicitWaitMs.should.eql(42);
+        managedDriver1.implicitWaitMs.should.eql(42);
+        managedDriver2.implicitWaitMs.should.eql(42);
+      });
+    });
+  });
+  describe('set new command timeout', function () {
+    it('should set the new command timeout with an integer', function () {
+      driver.setNewCommandTimeout(42);
+      driver.newCommandTimeoutMs.should.eql(42);
+    });
+    describe('with managed driver', function () {
+      let managedDriver1 = new _lib.default();
+      let managedDriver2 = new _lib.default();
+      before(function () {
+        driver.addManagedDriver(managedDriver1);
+        driver.addManagedDriver(managedDriver2);
+      });
+      after(function () {
+        driver.managedDrivers = [];
+      });
+      it('should set the new command timeout on managed drivers', function () {
+        driver.setNewCommandTimeout(42);
+        driver.newCommandTimeoutMs.should.eql(42);
+        managedDriver1.newCommandTimeoutMs.should.eql(42);
+        managedDriver2.newCommandTimeoutMs.should.eql(42);
+      });
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../test/unit/basedriver/timeout.spec.js"],"names":["describe","driver","BaseDriver","implicitWaitSpy","sandbox","beforeEach","implicitWaitMs","spy","afterEach","restore","it","timeouts","should","eventually","be","rejected","undefined","calledOnce","true","firstCall","args","equal","eql","implicitWait","setImplicitWait","managedDriver1","managedDriver2","before","addManagedDriver","after","managedDrivers","setNewCommandTimeout","newCommandTimeoutMs"],"mappings":"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","sourcesContent":["import BaseDriver from '../../../lib';\nimport { createSandbox } from 'sinon';\n\ndescribe('timeout', function () {\n  let driver = new BaseDriver();\n  let implicitWaitSpy;\n  let sandbox;\n  beforeEach(function () {\n    sandbox = createSandbox();\n    driver.implicitWaitMs = 0;\n    implicitWaitSpy = sandbox.spy(driver, 'setImplicitWait');\n  });\n  afterEach(function () {\n    sandbox.restore();\n  });\n  describe('timeouts', function () {\n    describe('errors', function () {\n      it('should throw an error if something random is sent', async function () {\n        await driver.timeouts('random timeout', 'howdy').should.eventually.be.rejected;\n      });\n      it('should throw an error if timeout is negative', async function () {\n        await driver.timeouts('random timeout', -42).should.eventually.be.rejected;\n      });\n      it('should throw an errors if timeout type is unknown', async function () {\n        await driver.timeouts('random timeout', 42).should.eventually.be.rejected;\n      });\n      it('should throw an error if something random is sent to scriptDuration', async function () {\n        await driver.timeouts(undefined, undefined, 123, undefined, undefined).should.eventually.be.rejected;\n      });\n      it('should throw an error if something random is sent to pageLoadDuration', async function () {\n        await driver.timeouts(undefined, undefined, undefined, 123, undefined).should.eventually.be.rejected;\n      });\n    });\n    describe('implicit wait', function () {\n      it('should call setImplicitWait when given an integer', async function () {\n        await driver.timeouts('implicit', 42);\n        implicitWaitSpy.calledOnce.should.be.true;\n        implicitWaitSpy.firstCall.args[0].should.equal(42);\n        driver.implicitWaitMs.should.eql(42);\n      });\n      it('should call setImplicitWait when given a string', async function () {\n        await driver.timeouts('implicit', '42');\n        implicitWaitSpy.calledOnce.should.be.true;\n        implicitWaitSpy.firstCall.args[0].should.equal(42);\n        driver.implicitWaitMs.should.eql(42);\n      });\n      it('should call setImplicitWait when given an integer to implicitDuration', async function () {\n        await driver.timeouts(undefined, undefined, undefined, undefined, 42);\n        implicitWaitSpy.calledOnce.should.be.true;\n        implicitWaitSpy.firstCall.args[0].should.equal(42);\n        driver.implicitWaitMs.should.eql(42);\n      });\n      it('should call setImplicitWait when given a string to implicitDuration', async function () {\n        await driver.timeouts(undefined, undefined, undefined, undefined, '42');\n        implicitWaitSpy.calledOnce.should.be.true;\n        implicitWaitSpy.firstCall.args[0].should.equal(42);\n        driver.implicitWaitMs.should.eql(42);\n      });\n    });\n  });\n  describe('implicitWait', function () {\n    it('should call setImplicitWait when given an integer', async function () {\n      await driver.implicitWait(42);\n      implicitWaitSpy.calledOnce.should.be.true;\n      implicitWaitSpy.firstCall.args[0].should.equal(42);\n      driver.implicitWaitMs.should.eql(42);\n    });\n    it('should call setImplicitWait when given a string', async function () {\n      await driver.implicitWait('42');\n      implicitWaitSpy.calledOnce.should.be.true;\n      implicitWaitSpy.firstCall.args[0].should.equal(42);\n      driver.implicitWaitMs.should.eql(42);\n    });\n    it('should throw an error if something random is sent', async function () {\n      await driver.implicitWait('howdy').should.eventually.be.rejected;\n    });\n    it('should throw an error if timeout is negative', async function () {\n      await driver.implicitWait(-42).should.eventually.be.rejected;\n    });\n  });\n\n  describe('set implicit wait', function () {\n    it('should set the implicit wait with an integer', function () {\n      driver.setImplicitWait(42);\n      driver.implicitWaitMs.should.eql(42);\n    });\n    describe('with managed driver', function () {\n      let managedDriver1 = new BaseDriver();\n      let managedDriver2 = new BaseDriver();\n      before(function () {\n        driver.addManagedDriver(managedDriver1);\n        driver.addManagedDriver(managedDriver2);\n      });\n      after(function () {\n        driver.managedDrivers = [];\n      });\n      it('should set the implicit wait on managed drivers', function () {\n        driver.setImplicitWait(42);\n        driver.implicitWaitMs.should.eql(42);\n        managedDriver1.implicitWaitMs.should.eql(42);\n        managedDriver2.implicitWaitMs.should.eql(42);\n      });\n    });\n  });\n  describe('set new command timeout', function () {\n    it('should set the new command timeout with an integer', function () {\n      driver.setNewCommandTimeout(42);\n      driver.newCommandTimeoutMs.should.eql(42);\n    });\n    describe('with managed driver', function () {\n      let managedDriver1 = new BaseDriver();\n      let managedDriver2 = new BaseDriver();\n      before(function () {\n        driver.addManagedDriver(managedDriver1);\n        driver.addManagedDriver(managedDriver2);\n      });\n      after(function () {\n        driver.managedDrivers = [];\n      });\n      it('should set the new command timeout on managed drivers', function () {\n        driver.setNewCommandTimeout(42);\n        driver.newCommandTimeoutMs.should.eql(42);\n        managedDriver1.newCommandTimeoutMs.should.eql(42);\n        managedDriver2.newCommandTimeoutMs.should.eql(42);\n      });\n    });\n  });\n});\n"]}

package/build/test/unit/express/server.spec.js

@@ -0,0 +1,155 @@
+"use strict";
+
+require("source-map-support/register");
+
+var _lib = require("../../../lib");
+
+var _server2 = require("../../../lib/express/server");
+
+var _sinon = require("sinon");
+
+var _helpers = require("../../helpers");
+
+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;
+  let sandbox;
+
+  function fakeApp() {
+    const app = {
+      use: sandbox.spy(),
+      all: sandbox.spy(),
+      get: sandbox.spy(),
+      post: sandbox.spy(),
+      delete: sandbox.spy(),
+      totalCount: () => app.use.callCount + app.all.callCount + app.get.callCount + app.post.callCount + app.delete.callCount
+    };
+    return app;
+  }
+
+  before(async function () {
+    port = await (0, _helpers.getTestPort)(true);
+  });
+  beforeEach(function () {
+    sandbox = (0, _sinon.createSandbox)();
+  });
+  afterEach(function () {
+    sandbox.restore();
+  });
+  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');
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../test/unit/express/server.spec.js"],"names":["newMethodMap","GET","command","POST","payloadParams","required","updateServer","app","httpServer","updated","fakeDriver","sessionExists","executeCommand","describe","port","sandbox","fakeApp","use","spy","all","get","post","delete","totalCount","callCount","before","beforeEach","afterEach","restore","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 { createSandbox } from 'sinon';\nimport { getTestPort } from '../../helpers';\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  let sandbox;\n\n  function fakeApp () {\n    const app = {\n      use: sandbox.spy(),\n      all: sandbox.spy(),\n      get: sandbox.spy(),\n      post: sandbox.spy(),\n      delete: sandbox.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\n  before(async function () {\n    port = await getTestPort(true);\n  });\n\n  beforeEach(function () {\n    sandbox = createSandbox();\n  });\n\n  afterEach(function () {\n    sandbox.restore();\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"]}

package/build/test/unit/express/static.spec.js

@@ -0,0 +1,26 @@
+"use strict";
+
+require("source-map-support/register");
+
+var _static = require("../../../lib/express/static");
+
+var _sinon = require("sinon");
+
+describe('welcome', function () {
+  let sandbox;
+  beforeEach(function () {
+    sandbox = (0, _sinon.createSandbox)();
+  });
+  afterEach(function () {
+    sandbox.restore();
+  });
+  it('should fill the template', async function () {
+    let res = {
+      send: sandbox.stub()
+    };
+    await (0, _static.welcome)({}, res);
+    res.send.calledOnce.should.be.true;
+    res.send.args[0][0].should.include('Let\'s browse!');
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Rlc3QvdW5pdC9leHByZXNzL3N0YXRpYy5zcGVjLmpzIl0sIm5hbWVzIjpbImRlc2NyaWJlIiwic2FuZGJveCIsImJlZm9yZUVhY2giLCJhZnRlckVhY2giLCJyZXN0b3JlIiwiaXQiLCJyZXMiLCJzZW5kIiwic3R1YiIsImNhbGxlZE9uY2UiLCJzaG91bGQiLCJiZSIsInRydWUiLCJhcmdzIiwiaW5jbHVkZSJdLCJtYXBwaW5ncyI6Ijs7OztBQUVBOztBQUNBOztBQUVBQSxRQUFRLENBQUMsU0FBRCxFQUFZLFlBQVk7QUFDOUIsTUFBSUMsT0FBSjtBQUVBQyxFQUFBQSxVQUFVLENBQUMsWUFBWTtBQUNyQkQsSUFBQUEsT0FBTyxHQUFHLDJCQUFWO0FBQ0QsR0FGUyxDQUFWO0FBSUFFLEVBQUFBLFNBQVMsQ0FBQyxZQUFZO0FBQ3BCRixJQUFBQSxPQUFPLENBQUNHLE9BQVI7QUFDRCxHQUZRLENBQVQ7QUFJQUMsRUFBQUEsRUFBRSxDQUFDLDBCQUFELEVBQTZCLGtCQUFrQjtBQUMvQyxRQUFJQyxHQUFHLEdBQUc7QUFDUkMsTUFBQUEsSUFBSSxFQUFFTixPQUFPLENBQUNPLElBQVI7QUFERSxLQUFWO0FBR0EsVUFBTSxxQkFBUSxFQUFSLEVBQVlGLEdBQVosQ0FBTjtBQUVBQSxJQUFBQSxHQUFHLENBQUNDLElBQUosQ0FBU0UsVUFBVCxDQUFvQkMsTUFBcEIsQ0FBMkJDLEVBQTNCLENBQThCQyxJQUE5QjtBQUNBTixJQUFBQSxHQUFHLENBQUNDLElBQUosQ0FBU00sSUFBVCxDQUFjLENBQWQsRUFBaUIsQ0FBakIsRUFBb0JILE1BQXBCLENBQTJCSSxPQUEzQixDQUFtQyxnQkFBbkM7QUFDRCxHQVJDLENBQUY7QUFTRCxDQXBCTyxDQUFSIiwic291cmNlc0NvbnRlbnQiOlsiLy8gdHJhbnNwaWxlOm1vY2hhXG5cbmltcG9ydCB7IHdlbGNvbWUgfSBmcm9tICcuLi8uLi8uLi9saWIvZXhwcmVzcy9zdGF0aWMnO1xuaW1wb3J0IHsgY3JlYXRlU2FuZGJveCB9IGZyb20gJ3Npbm9uJztcblxuZGVzY3JpYmUoJ3dlbGNvbWUnLCBmdW5jdGlvbiAoKSB7XG4gIGxldCBzYW5kYm94O1xuXG4gIGJlZm9yZUVhY2goZnVuY3Rpb24gKCkge1xuICAgIHNhbmRib3ggPSBjcmVhdGVTYW5kYm94KCk7XG4gIH0pO1xuXG4gIGFmdGVyRWFjaChmdW5jdGlvbiAoKSB7XG4gICAgc2FuZGJveC5yZXN0b3JlKCk7XG4gIH0pO1xuXG4gIGl0KCdzaG91bGQgZmlsbCB0aGUgdGVtcGxhdGUnLCBhc3luYyBmdW5jdGlvbiAoKSB7XG4gICAgbGV0IHJlcyA9IHtcbiAgICAgIHNlbmQ6IHNhbmRib3guc3R1YigpXG4gICAgfTtcbiAgICBhd2FpdCB3ZWxjb21lKHt9LCByZXMpO1xuXG4gICAgcmVzLnNlbmQuY2FsbGVkT25jZS5zaG91bGQuYmUudHJ1ZTtcbiAgICByZXMuc2VuZC5hcmdzWzBdWzBdLnNob3VsZC5pbmNsdWRlKCdMZXRcXCdzIGJyb3dzZSEnKTtcbiAgfSk7XG59KTtcbiJdfQ==

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

@@ -0,0 +1,91 @@
+"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;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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