@appium/base-driver 8.3.0 → 8.4.1

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

@@ -0,0 +1,192 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("source-map-support/register");
+
+var _path = _interopRequireDefault(require("path"));
+
+var _url = _interopRequireDefault(require("url"));
+
+var _support = require("@appium/support");
+
+var _helpers = require("../../../lib/basedriver/helpers");
+
+var _http = _interopRequireDefault(require("http"));
+
+var _finalhandler = _interopRequireDefault(require("finalhandler"));
+
+var _serveStatic = _interopRequireDefault(require("serve-static"));
+
+var _contentDisposition = _interopRequireDefault(require("content-disposition"));
+
+var _bluebird = _interopRequireDefault(require("bluebird"));
+
+var _helpers2 = require("../../helpers");
+
+function getFixture(file) {
+  return _path.default.resolve(__dirname, '..', 'fixtures', file);
+}
+
+describe('app download and configuration', function () {
+  describe('configureApp', function () {
+    it('should get the path for a local .app', async function () {
+      let newAppPath = await (0, _helpers.configureApp)(getFixture('FakeIOSApp.app'), '.app');
+      newAppPath.should.contain('FakeIOSApp.app');
+      let contents = await _support.fs.readFile(newAppPath, 'utf8');
+      contents.should.eql('this is not really an app\n');
+    });
+    it('should get the path for a local .apk', async function () {
+      let newAppPath = await (0, _helpers.configureApp)(getFixture('FakeAndroidApp.apk'), '.apk');
+      newAppPath.should.contain('FakeAndroidApp.apk');
+      let contents = await _support.fs.readFile(newAppPath, 'utf8');
+      contents.should.eql('this is not really an apk\n');
+    });
+    it('should unzip and get the path for a local .app.zip', async function () {
+      let newAppPath = await (0, _helpers.configureApp)(getFixture('FakeIOSApp.app.zip'), '.app');
+      newAppPath.should.contain('FakeIOSApp.app');
+      let contents = await _support.fs.readFile(newAppPath, 'utf8');
+      contents.should.eql('this is not really an app\n');
+    });
+    it('should unzip and get the path for a local .ipa', async function () {
+      let newAppPath = await (0, _helpers.configureApp)(getFixture('FakeIOSApp.ipa'), '.app');
+      newAppPath.should.contain('FakeIOSApp.app');
+      let contents = await _support.fs.readFile(newAppPath, 'utf8');
+      contents.should.eql('this is not really an app\n');
+    });
+    it('should fail for a bad zip file', async function () {
+      await (0, _helpers.configureApp)(getFixture('BadZippedApp.zip'), '.app').should.be.rejectedWith(/PK/);
+    });
+    it('should fail if extensions do not match', async function () {
+      await (0, _helpers.configureApp)(getFixture('FakeIOSApp.app'), '.wrong').should.be.rejectedWith(/did not have extension/);
+    });
+    it('should fail if zip file does not contain an app whose extension matches', async function () {
+      await (0, _helpers.configureApp)(getFixture('FakeIOSApp.app.zip'), '.wrong').should.be.rejectedWith(/did not have extension/);
+    });
+    describe('should download an app from the web', function () {
+      let port;
+      let serverUrl;
+      before(async function () {
+        port = await (0, _helpers2.getTestPort)(true);
+        serverUrl = `http://${_helpers2.TEST_HOST}:${port}`;
+      });
+      describe('server not available', function () {
+        it('should handle server not available', async function () {
+          await (0, _helpers.configureApp)(`${serverUrl}/FakeIOSApp.app.zip`, '.app').should.eventually.be.rejectedWith(/ECONNREFUSED/);
+        });
+      });
+      describe('server available', function () {
+        let server;
+        before(function () {
+          const dir = _path.default.resolve(__dirname, '..', 'fixtures');
+
+          const serve = (0, _serveStatic.default)(dir, {
+            index: false,
+            setHeaders: (res, path) => {
+              res.setHeader('Content-Disposition', (0, _contentDisposition.default)(path));
+            }
+          });
+          server = _http.default.createServer(function (req, res) {
+            if (req.url.indexOf('missing') !== -1) {
+              res.writeHead(404);
+              res.end();
+              return;
+            }
+
+            const contentType = new URLSearchParams(_url.default.parse(req.url).search).get('content-type');
+
+            if (contentType !== null) {
+              res.setHeader('content-type', contentType);
+            }
+
+            serve(req, res, (0, _finalhandler.default)(req, res));
+          });
+          const close = server.close.bind(server);
+
+          server.close = async function () {
+            await _bluebird.default.delay(1000);
+            return await new _bluebird.default((resolve, reject) => {
+              server.on('close', resolve);
+              close(err => {
+                if (err) reject(err);
+              });
+            });
+          };
+
+          server.listen(port);
+        });
+        after(async function () {
+          await server.close();
+        });
+        it('should download zip file', async function () {
+          let newAppPath = await (0, _helpers.configureApp)(`${serverUrl}/FakeIOSApp.app.zip`, '.app');
+          newAppPath.should.contain('FakeIOSApp.app');
+          let contents = await _support.fs.readFile(newAppPath, 'utf8');
+          contents.should.eql('this is not really an app\n');
+        });
+        it('should download zip file with query string', async function () {
+          let newAppPath = await (0, _helpers.configureApp)(`${serverUrl}/FakeIOSApp.app.zip?sv=abc&sr=def`, '.app');
+          newAppPath.should.contain('.app');
+          let contents = await _support.fs.readFile(newAppPath, 'utf8');
+          contents.should.eql('this is not really an app\n');
+        });
+        it('should download an app file', async function () {
+          let newAppPath = await (0, _helpers.configureApp)(`${serverUrl}/FakeIOSApp.app`, '.app');
+          newAppPath.should.contain('.app');
+          let contents = await _support.fs.readFile(newAppPath, 'utf8');
+          contents.should.eql('this is not really an app\n');
+        });
+        it('should accept multiple extensions', async function () {
+          let newAppPath = await (0, _helpers.configureApp)(`${serverUrl}/FakeIOSApp.app.zip`, ['.app', '.aab']);
+          newAppPath.should.contain('FakeIOSApp.app');
+          let contents = await _support.fs.readFile(newAppPath, 'utf8');
+          contents.should.eql('this is not really an app\n');
+        });
+        it('should download an apk file', async function () {
+          let newAppPath = await (0, _helpers.configureApp)(`${serverUrl}/FakeAndroidApp.apk`, '.apk');
+          newAppPath.should.contain('.apk');
+          let contents = await _support.fs.readFile(newAppPath, 'utf8');
+          contents.should.eql('this is not really an apk\n');
+        });
+        it('should handle zip file that cannot be downloaded', async function () {
+          await (0, _helpers.configureApp)(`${serverUrl}/missing/FakeIOSApp.app.zip`, '.app').should.eventually.be.rejected;
+        });
+        it('should handle invalid protocol', async function () {
+          await (0, _helpers.configureApp)('file://C:/missing/FakeIOSApp.app.zip', '.app').should.eventually.be.rejectedWith(/is not supported/);
+          await (0, _helpers.configureApp)(`ftp://${_helpers2.TEST_HOST}:${port}/missing/FakeIOSApp.app.zip`, '.app').should.eventually.be.rejectedWith(/is not supported/);
+        });
+        it('should handle missing file in Windows path format', async function () {
+          await (0, _helpers.configureApp)('C:\\missing\\FakeIOSApp.app.zip', '.app').should.eventually.be.rejectedWith(/does not exist or is not accessible/);
+        });
+        it('should recognize zip mime types and unzip the downloaded file', async function () {
+          let newAppPath = await (0, _helpers.configureApp)(`${serverUrl}/FakeAndroidApp.asd?content-type=${encodeURIComponent('application/zip')}`, '.apk');
+          newAppPath.should.contain('FakeAndroidApp.apk');
+          newAppPath.should.not.contain('.asd');
+          let contents = await _support.fs.readFile(newAppPath, 'utf8');
+          contents.should.eql('this is not really an apk\n');
+        });
+        it('should recognize zip mime types with parameter and unzip the downloaded file', async function () {
+          let newAppPath = await (0, _helpers.configureApp)(`${serverUrl}/FakeAndroidApp.asd?content-type=${encodeURIComponent('application/zip; parameter=value')}`, '.apk');
+          newAppPath.should.contain('FakeAndroidApp.apk');
+          newAppPath.should.not.contain('.asd');
+          let contents = await _support.fs.readFile(newAppPath, 'utf8');
+          contents.should.eql('this is not really an apk\n');
+        });
+        it('should recognize zip mime types and unzip the downloaded file with query string', async function () {
+          let newAppPath = await (0, _helpers.configureApp)(`${serverUrl}/FakeAndroidApp.asd?content-type=${encodeURIComponent('application/zip')}&sv=abc&sr=def`, '.apk');
+          newAppPath.should.contain('FakeAndroidApp.apk');
+          newAppPath.should.not.contain('.asd');
+          let contents = await _support.fs.readFile(newAppPath, 'utf8');
+          contents.should.eql('this is not really an apk\n');
+        });
+        it('should treat an unknown mime type as an app', async function () {
+          let newAppPath = await (0, _helpers.configureApp)(`${serverUrl}/FakeAndroidApp.apk?content-type=${encodeURIComponent('application/bip')}`, '.apk');
+          newAppPath.should.contain('.apk');
+          let contents = await _support.fs.readFile(newAppPath, 'utf8');
+          contents.should.eql('this is not really an apk\n');
+        });
+      });
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../test/e2e/basedriver/helpers.e2e.spec.js"],"names":["getFixture","file","path","resolve","__dirname","describe","it","newAppPath","should","contain","contents","fs","readFile","eql","be","rejectedWith","port","serverUrl","before","TEST_HOST","eventually","server","dir","serve","index","setHeaders","res","setHeader","http","createServer","req","url","indexOf","writeHead","end","contentType","URLSearchParams","parse","search","get","close","bind","B","delay","reject","on","err","listen","after","rejected","encodeURIComponent","not"],"mappings":"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","sourcesContent":["import path from 'path';\nimport url from 'url';\nimport { fs } from '@appium/support';\nimport { configureApp } from '../../../lib/basedriver/helpers';\nimport http from 'http';\nimport finalhandler from 'finalhandler';\nimport serveStatic from 'serve-static';\nimport contentDisposition from 'content-disposition';\nimport B from 'bluebird';\nimport { TEST_HOST, getTestPort } from '../../helpers';\n\n\nfunction getFixture (file) {\n  // XXX: __dirname disallowed in native ESM\n  return path.resolve(__dirname, '..', 'fixtures', file);\n}\n\ndescribe('app download and configuration', function () {\n  describe('configureApp', function () {\n    it('should get the path for a local .app', async function () {\n      let newAppPath = await configureApp(getFixture('FakeIOSApp.app'), '.app');\n      newAppPath.should.contain('FakeIOSApp.app');\n      let contents = await fs.readFile(newAppPath, 'utf8');\n      contents.should.eql('this is not really an app\\n');\n    });\n    it('should get the path for a local .apk', async function () {\n      let newAppPath = await configureApp(getFixture('FakeAndroidApp.apk'), '.apk');\n      newAppPath.should.contain('FakeAndroidApp.apk');\n      let contents = await fs.readFile(newAppPath, 'utf8');\n      contents.should.eql('this is not really an apk\\n');\n    });\n    it('should unzip and get the path for a local .app.zip', async function () {\n      let newAppPath = await configureApp(getFixture('FakeIOSApp.app.zip'), '.app');\n      newAppPath.should.contain('FakeIOSApp.app');\n      let contents = await fs.readFile(newAppPath, 'utf8');\n      contents.should.eql('this is not really an app\\n');\n    });\n    it('should unzip and get the path for a local .ipa', async function () {\n      let newAppPath = await configureApp(getFixture('FakeIOSApp.ipa'), '.app');\n      newAppPath.should.contain('FakeIOSApp.app');\n      let contents = await fs.readFile(newAppPath, 'utf8');\n      contents.should.eql('this is not really an app\\n');\n    });\n    it('should fail for a bad zip file', async function () {\n      await configureApp(getFixture('BadZippedApp.zip'), '.app')\n        .should.be.rejectedWith(/PK/);\n    });\n    it('should fail if extensions do not match', async function () {\n      await configureApp(getFixture('FakeIOSApp.app'), '.wrong')\n        .should.be.rejectedWith(/did not have extension/);\n    });\n    it('should fail if zip file does not contain an app whose extension matches', async function () {\n      await configureApp(getFixture('FakeIOSApp.app.zip'), '.wrong')\n        .should.be.rejectedWith(/did not have extension/);\n    });\n    describe('should download an app from the web', function () {\n      let port;\n      let serverUrl;\n\n      before(async function () {\n        port = await getTestPort(true);\n        serverUrl = `http://${TEST_HOST}:${port}`;\n      });\n\n      describe('server not available', function () {\n        it('should handle server not available', async function () {\n          await configureApp(`${serverUrl}/FakeIOSApp.app.zip`, '.app')\n            .should.eventually.be.rejectedWith(/ECONNREFUSED/);\n        });\n      });\n      describe('server available', function () {\n        // use a local server so there is no dependency on the internet\n        let server;\n        before(function () {\n          const dir = path.resolve(__dirname, '..', 'fixtures');\n          const serve = serveStatic(dir, {\n            index: false,\n            setHeaders: (res, path) => {\n              res.setHeader('Content-Disposition', contentDisposition(path));\n            },\n          });\n\n          server = http.createServer(function (req, res) {\n            if (req.url.indexOf('missing') !== -1) {\n              res.writeHead(404);\n              res.end();\n              return;\n            }\n            // for testing zip file content types\n            const contentType = new URLSearchParams(url.parse(req.url).search).get('content-type');\n            if (contentType !== null) {\n              res.setHeader('content-type', contentType);\n            }\n            serve(req, res, finalhandler(req, res));\n          });\n          const close = server.close.bind(server);\n          server.close = async function () {\n            // pause a moment or we get ECONRESET errors\n            await B.delay(1000);\n            return await new B((resolve, reject) => {\n              server.on('close', resolve);\n              close((err) => {\n                if (err) reject(err); // eslint-disable-line curly\n              });\n            });\n          };\n          server.listen(port);\n        });\n        after(async function () {\n          await server.close();\n        });\n\n        it('should download zip file', async function () {\n          let newAppPath = await configureApp(`${serverUrl}/FakeIOSApp.app.zip`, '.app');\n          newAppPath.should.contain('FakeIOSApp.app');\n          let contents = await fs.readFile(newAppPath, 'utf8');\n          contents.should.eql('this is not really an app\\n');\n        });\n        it('should download zip file with query string', async function () {\n          let newAppPath = await configureApp(`${serverUrl}/FakeIOSApp.app.zip?sv=abc&sr=def`, '.app');\n          newAppPath.should.contain('.app');\n          let contents = await fs.readFile(newAppPath, 'utf8');\n          contents.should.eql('this is not really an app\\n');\n        });\n        it('should download an app file', async function () {\n          let newAppPath = await configureApp(`${serverUrl}/FakeIOSApp.app`, '.app');\n          newAppPath.should.contain('.app');\n          let contents = await fs.readFile(newAppPath, 'utf8');\n          contents.should.eql('this is not really an app\\n');\n        });\n        it('should accept multiple extensions', async function () {\n          let newAppPath = await configureApp(`${serverUrl}/FakeIOSApp.app.zip`, ['.app', '.aab']);\n          newAppPath.should.contain('FakeIOSApp.app');\n          let contents = await fs.readFile(newAppPath, 'utf8');\n          contents.should.eql('this is not really an app\\n');\n        });\n        it('should download an apk file', async function () {\n          let newAppPath = await configureApp(`${serverUrl}/FakeAndroidApp.apk`, '.apk');\n          newAppPath.should.contain('.apk');\n          let contents = await fs.readFile(newAppPath, 'utf8');\n          contents.should.eql('this is not really an apk\\n');\n        });\n        it('should handle zip file that cannot be downloaded', async function () {\n          await configureApp(`${serverUrl}/missing/FakeIOSApp.app.zip`, '.app')\n            .should.eventually.be.rejected;\n        });\n        it('should handle invalid protocol', async function () {\n          await configureApp('file://C:/missing/FakeIOSApp.app.zip', '.app')\n            .should.eventually.be.rejectedWith(/is not supported/);\n          await configureApp(`ftp://${TEST_HOST}:${port}/missing/FakeIOSApp.app.zip`, '.app')\n            .should.eventually.be.rejectedWith(/is not supported/);\n        });\n        it('should handle missing file in Windows path format', async function () {\n          await configureApp('C:\\\\missing\\\\FakeIOSApp.app.zip', '.app')\n            .should.eventually.be.rejectedWith(/does not exist or is not accessible/);\n        });\n        it('should recognize zip mime types and unzip the downloaded file', async function () {\n          let newAppPath = await configureApp(`${serverUrl}/FakeAndroidApp.asd?content-type=${encodeURIComponent('application/zip')}`, '.apk');\n          newAppPath.should.contain('FakeAndroidApp.apk');\n          newAppPath.should.not.contain('.asd');\n          let contents = await fs.readFile(newAppPath, 'utf8');\n          contents.should.eql('this is not really an apk\\n');\n        });\n        it('should recognize zip mime types with parameter and unzip the downloaded file', async function () {\n          let newAppPath = await configureApp(`${serverUrl}/FakeAndroidApp.asd?content-type=${encodeURIComponent('application/zip; parameter=value')}`, '.apk');\n          newAppPath.should.contain('FakeAndroidApp.apk');\n          newAppPath.should.not.contain('.asd');\n          let contents = await fs.readFile(newAppPath, 'utf8');\n          contents.should.eql('this is not really an apk\\n');\n        });\n        it('should recognize zip mime types and unzip the downloaded file with query string', async function () {\n          let newAppPath = await configureApp(`${serverUrl}/FakeAndroidApp.asd?content-type=${encodeURIComponent('application/zip')}&sv=abc&sr=def`, '.apk');\n          newAppPath.should.contain('FakeAndroidApp.apk');\n          newAppPath.should.not.contain('.asd');\n          let contents = await fs.readFile(newAppPath, 'utf8');\n          contents.should.eql('this is not really an apk\\n');\n        });\n        it('should treat an unknown mime type as an app', async function () {\n          let newAppPath = await configureApp(`${serverUrl}/FakeAndroidApp.apk?content-type=${encodeURIComponent('application/bip')}`, '.apk');\n          newAppPath.should.contain('.apk');\n          let contents = await fs.readFile(newAppPath, 'utf8');\n          contents.should.eql('this is not really an apk\\n');\n        });\n      });\n    });\n  });\n});\n"]}

package/build/test/e2e/basedriver/websockets.e2e.spec.js

@@ -0,0 +1,87 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("source-map-support/register");
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _lib = require("../../../lib");
+
+var _fakeDriver = require("../protocol/fake-driver");
+
+var _ws = _interopRequireDefault(require("ws"));
+
+var _bluebird = _interopRequireDefault(require("bluebird"));
+
+var _helpers = require("../../helpers");
+
+describe('Websockets (e2e)', function () {
+  let baseServer;
+  let driver;
+  let port;
+  const SESSION_ID = 'foo';
+  const WS_DATA = 'Hello';
+  before(async function () {
+    driver = new _fakeDriver.FakeDriver();
+    driver.sessionId = SESSION_ID;
+    port = await (0, _helpers.getTestPort)();
+    baseServer = await (0, _lib.server)({
+      routeConfiguringFunction: (0, _lib.routeConfiguringFunction)(driver),
+      port
+    });
+  });
+  after(async function () {
+    await baseServer.close();
+  });
+  describe('web sockets support', function () {
+    it('should be able to add websocket handler and remove it', async function () {
+      const wss = new _ws.default.Server({
+        noServer: true
+      });
+      wss.on('connection', ws => {
+        if (ws && ws.readyState === _ws.default.OPEN) {
+          ws.send(WS_DATA);
+        }
+      });
+      const previousListenerCount = baseServer.listenerCount('upgrade');
+      const endpoint = `${_lib.DEFAULT_WS_PATHNAME_PREFIX}/hello`;
+      const timeout = 5000;
+      await baseServer.addWebSocketHandler(endpoint, wss);
+      baseServer.listenerCount('upgrade').should.be.above(previousListenerCount);
+
+      _lodash.default.keys(await baseServer.getWebSocketHandlers()).length.should.eql(1);
+
+      await new _bluebird.default((resolve, reject) => {
+        const client = new _ws.default(`ws://${_helpers.TEST_HOST}:${port}${endpoint}`);
+        client.once('connection', (ws, req) => {
+          try {
+            ws.should.not.be.empty;
+            req.connection.remoteAddress.should.not.be.empty;
+          } catch (e) {
+            reject(e);
+          }
+        });
+        client.once('message', data => {
+          const dataStr = _lodash.default.isString(data) ? data : data.toString();
+          dataStr.should.eql(WS_DATA);
+          resolve();
+        });
+        client.once('error', reject);
+        setTimeout(() => reject(new Error('No websocket messages have been received after the timeout')), timeout);
+      });
+      (await baseServer.removeWebSocketHandler(endpoint)).should.be.true;
+
+      _lodash.default.keys(await baseServer.getWebSocketHandlers()).length.should.eql(0);
+
+      await new _bluebird.default((resolve, reject) => {
+        const client = new _ws.default(`ws://${_helpers.TEST_HOST}:${port}${endpoint}`);
+        client.on('message', data => reject(new Error(`No websocket messages are expected after the handler ` + `has been removed. '${data}' is received instead. `)));
+        client.on('error', resolve);
+        setTimeout(resolve, timeout);
+      });
+      baseServer.listenerCount('upgrade').should.be.above(previousListenerCount);
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../test/e2e/basedriver/websockets.e2e.spec.js"],"names":["describe","baseServer","driver","port","SESSION_ID","WS_DATA","before","FakeDriver","sessionId","routeConfiguringFunction","after","close","it","wss","WebSocket","Server","noServer","on","ws","readyState","OPEN","send","previousListenerCount","listenerCount","endpoint","DEFAULT_WS_PATHNAME_PREFIX","timeout","addWebSocketHandler","should","be","above","_","keys","getWebSocketHandlers","length","eql","B","resolve","reject","client","TEST_HOST","once","req","not","empty","connection","remoteAddress","e","data","dataStr","isString","toString","setTimeout","Error","removeWebSocketHandler","true"],"mappings":"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","sourcesContent":["import _ from 'lodash';\nimport {\n  server, routeConfiguringFunction, DEFAULT_WS_PATHNAME_PREFIX\n} from '../../../lib';\nimport { FakeDriver } from '../protocol/fake-driver';\nimport WebSocket from 'ws';\nimport B from 'bluebird';\nimport {TEST_HOST, getTestPort} from '../../helpers';\n\n\ndescribe('Websockets (e2e)', function () {\n  let baseServer;\n  let driver;\n  let port;\n  const SESSION_ID = 'foo';\n  const WS_DATA = 'Hello';\n\n  before(async function () {\n    driver = new FakeDriver();\n    driver.sessionId = SESSION_ID;\n    port = await getTestPort();\n    baseServer = await server({\n      routeConfiguringFunction: routeConfiguringFunction(driver),\n      port,\n    });\n  });\n  after(async function () {\n    await baseServer.close();\n  });\n\n  describe('web sockets support', function () {\n    it('should be able to add websocket handler and remove it', async function () {\n      const wss = new WebSocket.Server({\n        noServer: true,\n      });\n      wss.on('connection', (ws) => {\n        if (ws && ws.readyState === WebSocket.OPEN) {\n          ws.send(WS_DATA);\n        }\n      });\n      const previousListenerCount = baseServer.listenerCount('upgrade');\n      const endpoint = `${DEFAULT_WS_PATHNAME_PREFIX}/hello`;\n      const timeout = 5000;\n      await baseServer.addWebSocketHandler(endpoint, wss);\n      baseServer.listenerCount('upgrade').should.be.above(previousListenerCount);\n      _.keys(await baseServer.getWebSocketHandlers()).length.should.eql(1);\n      await new B((resolve, reject) => {\n        const client = new WebSocket(`ws://${TEST_HOST}:${port}${endpoint}`);\n        client.once('connection', (ws, req) => {\n          try {\n            ws.should.not.be.empty;\n            req.connection.remoteAddress.should.not.be.empty;\n          } catch (e) {\n            reject(e);\n          }\n        });\n        client.once('message', (data) => {\n          const dataStr = _.isString(data) ? data : data.toString();\n          dataStr.should.eql(WS_DATA);\n          resolve();\n        });\n        client.once('error', reject);\n        setTimeout(() => reject(new Error('No websocket messages have been received after the timeout')),\n          timeout);\n      });\n\n      (await baseServer.removeWebSocketHandler(endpoint)).should.be.true;\n      _.keys(await baseServer.getWebSocketHandlers()).length.should.eql(0);\n      await new B((resolve, reject) => {\n        const client = new WebSocket(`ws://${TEST_HOST}:${port}${endpoint}`);\n        client.on('message', (data) =>\n          reject(new Error(`No websocket messages are expected after the handler ` +\n            `has been removed. '${data}' is received instead. `))\n        );\n        client.on('error', resolve);\n        setTimeout(resolve, timeout);\n      });\n      baseServer.listenerCount('upgrade').should.be.above(previousListenerCount);\n    });\n  });\n});\n"]}

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

@@ -0,0 +1,159 @@
+"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 = require("sinon");
+
+var _bluebird = _interopRequireDefault(require("bluebird"));
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _helpers = require("../../helpers");
+
+describe('server', function () {
+  let hwServer;
+  let port;
+  let sandbox;
+  before(async function () {
+    port = await (0, _helpers.getTestPort)(true);
+
+    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
+    });
+  });
+  beforeEach(function () {
+    sandbox = (0, _sinon.createSandbox)();
+    sandbox.stub(console, 'error');
+  });
+  after(async function () {
+    await hwServer.close();
+  });
+  afterEach(function () {
+    sandbox.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/);
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../test/e2e/express/server.e2e.spec.js"],"names":["describe","hwServer","port","sandbox","before","configureRoutes","app","get","req","res","header","status","send","headers","Error","B","delay","routeConfiguringFunction","beforeEach","stub","console","after","close","afterEach","restore","it","data","axios","TEST_HOST","should","eql","url","be","rejected","rejectedWith","bodyPromise","catch","Date","now","not","above","timeout","_","noop","hostname","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 { createSandbox } 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 port;\n  let sandbox;\n  before(async function () {\n    port = await getTestPort(true);\n\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  beforeEach(function () {\n    sandbox = createSandbox();\n    sandbox.stub(console, 'error');\n  });\n  after(async function () {\n    await hwServer.close();\n  });\n  afterEach(function () {\n    sandbox.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"]}

package/build/test/e2e/jsonwp-proxy/proxy.e2e.spec.js

@@ -0,0 +1,59 @@
+"use strict";
+
+require("source-map-support/register");
+
+var _lib = require("../../../lib");
+
+var _fakeDriver = require("../protocol/fake-driver");
+
+describe('proxy', function () {
+  const jwproxy = new _lib.JWProxy();
+  let baseServer;
+  before(async function () {
+    baseServer = await (0, _lib.server)({
+      routeConfiguringFunction: (0, _lib.routeConfiguringFunction)(new _fakeDriver.FakeDriver()),
+      port: 4444
+    });
+  });
+  after(async function () {
+    await baseServer.close();
+  });
+  it('should proxy status straight', async function () {
+    let [res, resBody] = await jwproxy.proxy('/status', 'GET');
+    res.statusCode.should.equal(200);
+    resBody.value.should.equal(`I'm fine`);
+  });
+  it('should proxy status as command', async function () {
+    const res = await jwproxy.command('/status', 'GET');
+    res.should.eql(`I'm fine`);
+  });
+  describe('new session', function () {
+    afterEach(async function () {
+      await jwproxy.command('', 'DELETE');
+    });
+    it('should start a new session', async function () {
+      const caps = {
+        browserName: 'fake'
+      };
+      const res = await jwproxy.command('/session', 'POST', {
+        capabilities: {
+          alwaysMatch: caps
+        }
+      });
+      res.capabilities.alwaysMatch.should.have.property('browserName');
+      jwproxy.sessionId.should.have.length(48);
+    });
+  });
+  describe('delete session', function () {
+    beforeEach(async function () {
+      await jwproxy.command('/session', 'POST', {
+        desiredCapabilities: {}
+      });
+    });
+    it('should quit a session', async function () {
+      const res = await jwproxy.command('', 'DELETE');
+      should.not.exist(res);
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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