@appium/base-driver 8.3.0 → 8.4.1

package/build/test/unit/jsonwp-proxy/protocol-converter.spec.js

@@ -0,0 +1,171 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("source-map-support/register");
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _constants = require("../../../lib/constants");
+
+var _protocolConverter = _interopRequireWildcard(require("../../../lib/jsonwp-proxy/protocol-converter"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const {
+  MJSONWP,
+  W3C
+} = _constants.PROTOCOLS;
+describe('Protocol Converter', function () {
+  describe('getTimeoutRequestObjects', function () {
+    let converter;
+    before(function () {
+      converter = new _protocolConverter.default(_lodash.default.noop);
+    });
+    it('should take W3C inputs and produce MJSONWP compatible objects', function () {
+      converter.downstreamProtocol = MJSONWP;
+      let timeoutObjects = converter.getTimeoutRequestObjects({
+        script: 100
+      });
+      timeoutObjects.length.should.equal(1);
+      timeoutObjects[0].should.eql({
+        type: 'script',
+        ms: 100
+      });
+    });
+    it('should ignore invalid entries while converting from W3C', function () {
+      converter.downstreamProtocol = MJSONWP;
+      let timeoutObjects = converter.getTimeoutRequestObjects({
+        script: 100,
+        sessionId: '5432a4f3-cd89-4781-8905-ea9d3150840c',
+        bar: -1,
+        baz: undefined
+      });
+      timeoutObjects.length.should.equal(1);
+      timeoutObjects[0].should.eql({
+        type: 'script',
+        ms: 100
+      });
+    });
+    it('should take multiple W3C timeouts and produce multiple MJSONWP compatible objects', function () {
+      converter.downstreamProtocol = MJSONWP;
+      let [scriptTimeout, pageLoadTimeout, implicitTimeout] = converter.getTimeoutRequestObjects({
+        script: 100,
+        pageLoad: 200,
+        implicit: 300
+      });
+      scriptTimeout.should.eql({
+        type: 'script',
+        ms: 100
+      });
+      pageLoadTimeout.should.eql({
+        type: 'page load',
+        ms: 200
+      });
+      implicitTimeout.should.eql({
+        type: 'implicit',
+        ms: 300
+      });
+    });
+    it('should take MJSONWP input and produce W3C compatible object', function () {
+      converter.downstreamProtocol = W3C;
+      let timeoutObjects = converter.getTimeoutRequestObjects({
+        type: 'implicit',
+        ms: 300
+      });
+      timeoutObjects.length.should.equal(1);
+      timeoutObjects[0].should.eql({
+        implicit: 300
+      });
+    });
+    it('should not change the input if protocol name is unknown', function () {
+      converter.downstreamProtocol = null;
+      let timeoutObjects = converter.getTimeoutRequestObjects({
+        type: 'implicit',
+        ms: 300
+      });
+      timeoutObjects.length.should.equal(1);
+      timeoutObjects[0].should.eql({
+        type: 'implicit',
+        ms: 300
+      });
+    });
+    it('should not change the input if protocol name is unchanged', function () {
+      converter.downstreamProtocol = MJSONWP;
+      let timeoutObjects = converter.getTimeoutRequestObjects({
+        type: 'implicit',
+        ms: 300
+      });
+      timeoutObjects.length.should.equal(1);
+      timeoutObjects[0].should.eql({
+        type: 'implicit',
+        ms: 300
+      });
+    });
+  });
+  describe('setValue', function () {
+    let converter;
+    let responseBody;
+    before(function () {
+      responseBody = null;
+      converter = new _protocolConverter.default((url, method, body) => {
+        responseBody = body;
+      });
+    });
+    beforeEach(function () {
+      responseBody = {};
+    });
+    it('should calculate value if not present', async function () {
+      await converter.proxySetValue('', '', {
+        text: 'bla'
+      });
+      responseBody.should.eql({
+        text: 'bla',
+        value: ['b', 'l', 'a']
+      });
+    });
+    it('should calculate text if not present', async function () {
+      await converter.proxySetValue('', '', {
+        value: ['b', 'l', 'a']
+      });
+      responseBody.should.eql({
+        text: 'bla',
+        value: ['b', 'l', 'a']
+      });
+    });
+    it('should keep the response body unchanged if both value and text are present', async function () {
+      await converter.proxySetValue('', '', {
+        text: 'bla',
+        value: ['b', 'l', 'a']
+      });
+      responseBody.should.eql({
+        text: 'bla',
+        value: ['b', 'l', 'a']
+      });
+    });
+  });
+  describe('getProperty', function () {
+    let jsonwpConverter, w3cConverter;
+    before(function () {
+      for (let command of _protocolConverter.COMMAND_URLS_CONFLICTS) {
+        if (command.commandNames.includes('getProperty')) {
+          jsonwpConverter = command.jsonwpConverter;
+          w3cConverter = command.w3cConverter;
+        }
+      }
+    });
+    it('should convert "property/value" to "attribute/value"', function () {
+      jsonwpConverter('/session/123/element/456/property/value').should.equal('/session/123/element/456/attribute/value');
+    });
+    it('should convert "property/:somePropName" to "attribute/:somePropName"', function () {
+      jsonwpConverter('/session/123/element/456/property/somePropName').should.equal('/session/123/element/456/attribute/somePropName');
+    });
+    it('should not convert from JSONWP to W3C', function () {
+      w3cConverter('/session/123/element/456/attribute/someAttr').should.equal('/session/123/element/456/attribute/someAttr');
+      w3cConverter('/session/123/element/456/property/someProp').should.equal('/session/123/element/456/property/someProp');
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../test/unit/jsonwp-proxy/protocol-converter.spec.js"],"names":["MJSONWP","W3C","PROTOCOLS","describe","converter","before","ProtocolConverter","_","noop","it","downstreamProtocol","timeoutObjects","getTimeoutRequestObjects","script","length","should","equal","eql","type","ms","sessionId","bar","baz","undefined","scriptTimeout","pageLoadTimeout","implicitTimeout","pageLoad","implicit","responseBody","url","method","body","beforeEach","proxySetValue","text","value","jsonwpConverter","w3cConverter","command","COMMAND_URLS_CONFLICTS","commandNames","includes"],"mappings":"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","sourcesContent":["import _ from 'lodash';\nimport { PROTOCOLS } from '../../../lib/constants';\nimport ProtocolConverter, {COMMAND_URLS_CONFLICTS} from '../../../lib/jsonwp-proxy/protocol-converter';\n\nconst {MJSONWP, W3C} = PROTOCOLS;\n\n\ndescribe('Protocol Converter', function () {\n  describe('getTimeoutRequestObjects', function () {\n    let converter;\n    before(function () {\n      converter = new ProtocolConverter(_.noop);\n    });\n    it('should take W3C inputs and produce MJSONWP compatible objects', function () {\n      converter.downstreamProtocol = MJSONWP;\n      let timeoutObjects = converter.getTimeoutRequestObjects({script: 100});\n      timeoutObjects.length.should.equal(1);\n      timeoutObjects[0].should.eql({type: 'script', ms: 100});\n    });\n    it('should ignore invalid entries while converting from W3C', function () {\n      converter.downstreamProtocol = MJSONWP;\n      let timeoutObjects = converter.getTimeoutRequestObjects({\n        script: 100,\n        sessionId: '5432a4f3-cd89-4781-8905-ea9d3150840c',\n        bar: -1,\n        baz: undefined,\n      });\n      timeoutObjects.length.should.equal(1);\n      timeoutObjects[0].should.eql({type: 'script', ms: 100});\n    });\n    it('should take multiple W3C timeouts and produce multiple MJSONWP compatible objects', function () {\n      converter.downstreamProtocol = MJSONWP;\n      let [scriptTimeout, pageLoadTimeout, implicitTimeout] = converter.getTimeoutRequestObjects({script: 100, pageLoad: 200, implicit: 300});\n      scriptTimeout.should.eql({\n        type: 'script',\n        ms: 100,\n      });\n      pageLoadTimeout.should.eql({\n        type: 'page load',\n        ms: 200,\n      });\n      implicitTimeout.should.eql({\n        type: 'implicit',\n        ms: 300,\n      });\n    });\n    it('should take MJSONWP input and produce W3C compatible object', function () {\n      converter.downstreamProtocol = W3C;\n      let timeoutObjects = converter.getTimeoutRequestObjects({type: 'implicit', ms: 300});\n      timeoutObjects.length.should.equal(1);\n      timeoutObjects[0].should.eql({implicit: 300});\n    });\n    it('should not change the input if protocol name is unknown', function () {\n      converter.downstreamProtocol = null;\n      let timeoutObjects = converter.getTimeoutRequestObjects({type: 'implicit', ms: 300});\n      timeoutObjects.length.should.equal(1);\n      timeoutObjects[0].should.eql({type: 'implicit', ms: 300});\n    });\n    it('should not change the input if protocol name is unchanged', function () {\n      converter.downstreamProtocol = MJSONWP;\n      let timeoutObjects = converter.getTimeoutRequestObjects({type: 'implicit', ms: 300});\n      timeoutObjects.length.should.equal(1);\n      timeoutObjects[0].should.eql({type: 'implicit', ms: 300});\n    });\n  });\n\n  describe('setValue', function () {\n    let converter;\n    let responseBody;\n    before(function () {\n      responseBody = null;\n      converter = new ProtocolConverter((url, method, body) => {\n        responseBody = body;\n      });\n    });\n    beforeEach(function () {\n      responseBody = {};\n    });\n\n    it('should calculate value if not present', async function () {\n      await converter.proxySetValue('', '', {\n        text: 'bla',\n      });\n      responseBody.should.eql({\n        text: 'bla',\n        value: ['b', 'l', 'a'],\n      });\n    });\n    it('should calculate text if not present', async function () {\n      await converter.proxySetValue('', '', {\n        value: ['b', 'l', 'a'],\n      });\n      responseBody.should.eql({\n        text: 'bla',\n        value: ['b', 'l', 'a'],\n      });\n    });\n    it('should keep the response body unchanged if both value and text are present', async function () {\n      await converter.proxySetValue('', '', {\n        text: 'bla',\n        value: ['b', 'l', 'a'],\n      });\n      responseBody.should.eql({\n        text: 'bla',\n        value: ['b', 'l', 'a'],\n      });\n    });\n  });\n  describe('getProperty', function () {\n    let jsonwpConverter, w3cConverter;\n    before(function () {\n      for (let command of COMMAND_URLS_CONFLICTS) {\n        if (command.commandNames.includes('getProperty')) {\n          jsonwpConverter = command.jsonwpConverter;\n          w3cConverter = command.w3cConverter;\n        }\n      }\n    });\n    it('should convert \"property/value\" to \"attribute/value\"', function () {\n      jsonwpConverter('/session/123/element/456/property/value').should.equal('/session/123/element/456/attribute/value');\n    });\n    it('should convert \"property/:somePropName\" to \"attribute/:somePropName\"', function () {\n      jsonwpConverter('/session/123/element/456/property/somePropName').should.equal('/session/123/element/456/attribute/somePropName');\n    });\n    it('should not convert from JSONWP to W3C', function () {\n      w3cConverter('/session/123/element/456/attribute/someAttr').should.equal('/session/123/element/456/attribute/someAttr');\n      w3cConverter('/session/123/element/456/property/someProp').should.equal('/session/123/element/456/property/someProp');\n    });\n  });\n});\n"]}

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

@@ -0,0 +1,292 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("source-map-support/register");
+
+var _lib = require("../../../lib");
+
+var _mockRequest = _interopRequireDefault(require("./mock-request"));
+
+var _errors = require("../../../lib/protocol/errors");
+
+var _helpers = require("../../helpers");
+
+function buildReqRes(url, method, body) {
+  let req = {
+    originalUrl: url,
+    method,
+    body
+  };
+  let res = {};
+  res.headers = {};
+
+  res.set = (k, v) => {
+    res[k] = v;
+  };
+
+  res.status = code => {
+    res.sentCode = code;
+    return res;
+  };
+
+  res.send = body => {
+    try {
+      body = JSON.parse(body);
+    } catch (e) {}
+
+    res.sentBody = body;
+  };
+
+  return [req, res];
+}
+
+describe('proxy', function () {
+  let port;
+
+  function mockProxy(opts = {}) {
+    opts = {
+      server: _helpers.TEST_HOST,
+      port,
+      ...opts
+    };
+    let proxy = new _lib.JWProxy(opts);
+
+    proxy.request = async function (...args) {
+      return await (0, _mockRequest.default)(...args);
+    };
+
+    return proxy;
+  }
+
+  before(async function () {
+    port = await (0, _helpers.getTestPort)();
+  });
+  it('should override default params', function () {
+    let j = mockProxy({
+      server: '127.0.0.2',
+      port
+    });
+    j.server.should.equal('127.0.0.2');
+    j.port.should.equal(port);
+  });
+  it('should save session id on session creation', async function () {
+    let j = mockProxy();
+    let [res, body] = await j.proxy('/session', 'POST', {
+      desiredCapabilities: {}
+    });
+    res.statusCode.should.equal(200);
+    body.should.eql({
+      status: 0,
+      sessionId: '123',
+      value: {
+        browserName: 'boo'
+      }
+    });
+    j.sessionId.should.equal('123');
+  });
+  describe('getUrlForProxy', function () {
+    it('should modify session id, host, and port', function () {
+      let j = mockProxy({
+        sessionId: '123'
+      });
+      j.getUrlForProxy('http://host.com:1234/session/456/element/200/value').should.eql(`http://${_helpers.TEST_HOST}:${port}/session/123/element/200/value`);
+    });
+    it('should prepend scheme, host and port if not provided', function () {
+      let j = mockProxy({
+        sessionId: '123'
+      });
+      j.getUrlForProxy('/session/456/element/200/value').should.eql(`http://${_helpers.TEST_HOST}:${port}/session/123/element/200/value`);
+    });
+    it('should respect nonstandard incoming request base path', function () {
+      let j = mockProxy({
+        sessionId: '123',
+        reqBasePath: ''
+      });
+      j.getUrlForProxy('/session/456/element/200/value').should.eql(`http://${_helpers.TEST_HOST}:${port}/session/123/element/200/value`);
+      j = mockProxy({
+        sessionId: '123',
+        reqBasePath: '/my/base/path'
+      });
+      j.getUrlForProxy('/my/base/path/session/456/element/200/value').should.eql(`http://${_helpers.TEST_HOST}:${port}/session/123/element/200/value`);
+    });
+    it('should work with urls which do not have session ids', function () {
+      let j = mockProxy({
+        sessionId: '123'
+      });
+      j.getUrlForProxy('http://host.com:1234/session').should.eql(`http://${_helpers.TEST_HOST}:${port}/session`);
+      let newUrl = j.getUrlForProxy('/session');
+      newUrl.should.eql(`http://${_helpers.TEST_HOST}:${port}/session`);
+    });
+    it('should throw an error if url requires a sessionId but its null', function () {
+      let j = mockProxy();
+      let e;
+
+      try {
+        j.getUrlForProxy('/session/456/element/200/value');
+      } catch (err) {
+        e = err;
+      }
+
+      should.exist(e);
+      e.message.should.contain('without session id');
+    });
+    it('should not throw an error if url does not require a session id and its null', function () {
+      let j = mockProxy();
+      let newUrl = j.getUrlForProxy('/status');
+      should.exist(newUrl);
+    });
+  });
+  describe('straight proxy', function () {
+    it('should successfully proxy straight', async function () {
+      let j = mockProxy();
+      let [res, body] = await j.proxy('/status', 'GET');
+      res.statusCode.should.equal(200);
+      body.should.eql({
+        status: 0,
+        value: {
+          foo: 'bar'
+        }
+      });
+    });
+    it('should pass along request errors', function () {
+      let j = mockProxy({
+        sessionId: '123'
+      });
+      j.proxy('/badurl', 'GET').should.eventually.be.rejectedWith('Could not proxy');
+    });
+    it('should proxy error responses and codes', async function () {
+      let j = mockProxy({
+        sessionId: '123'
+      });
+
+      try {
+        await j.proxy('/element/bad/text', 'GET');
+      } catch (e) {
+        (0, _errors.isErrorType)(e.getActualError(), _errors.errors.ElementNotVisibleError).should.be.true;
+      }
+    });
+  });
+  describe('command proxy', function () {
+    it('should successfully proxy command', async function () {
+      let j = mockProxy();
+      let res = await j.command('/status', 'GET');
+      res.should.eql({
+        foo: 'bar'
+      });
+    });
+    it('should pass along request errors', function () {
+      let j = mockProxy({
+        sessionId: '123'
+      });
+      j.command('/badurl', 'GET').should.eventually.be.rejectedWith('Could not proxy');
+    });
+    it('should throw when a command fails', async function () {
+      let j = mockProxy({
+        sessionId: '123'
+      });
+      let e = null;
+
+      try {
+        await j.command('/element/bad/text', 'GET');
+      } catch (err) {
+        e = err;
+      }
+
+      should.exist(e);
+      e.message.should.contain('Invisible element');
+    });
+    it('should throw when a command fails with a 200 because the status is not 0', async function () {
+      let j = mockProxy({
+        sessionId: '123'
+      });
+      let e = null;
+
+      try {
+        await j.command('/element/200/text', 'GET');
+      } catch (err) {
+        e = err;
+      }
+
+      should.exist(e);
+      e.error.should.eql('element not visible');
+    });
+    it('should throw when a command fails with a 100', async function () {
+      let j = mockProxy({
+        sessionId: '123'
+      });
+      let e = null;
+
+      try {
+        await j.command('/session/badchrome/nochrome', 'GET');
+      } catch (err) {
+        e = err;
+      }
+
+      should.exist(e);
+      e.message.should.contain('chrome not reachable');
+    });
+  });
+  describe('req/res proxy', function () {
+    it('should successfully proxy via req and send to res', async function () {
+      let j = mockProxy();
+      let [req, res] = buildReqRes('/status', 'GET');
+      await j.proxyReqRes(req, res);
+      res.headers['content-type'].should.equal('application/json; charset=utf-8');
+      res.sentCode.should.equal(200);
+      res.sentBody.should.eql({
+        value: {
+          foo: 'bar'
+        }
+      });
+    });
+    it('should rewrite the inner session id so it doesnt change', async function () {
+      let j = mockProxy({
+        sessionId: '123'
+      });
+      let [req, res] = buildReqRes('/element/200/value', 'GET');
+      await j.proxyReqRes(req, res);
+      res.sentBody.should.eql({
+        value: 'foobar',
+        sessionId: '123'
+      });
+    });
+    it('should rewrite the inner session id with sessionId in url', async function () {
+      let j = mockProxy({
+        sessionId: '123'
+      });
+      let [req, res] = buildReqRes('/session/456/element/200/value', 'POST');
+      await j.proxyReqRes(req, res);
+      res.sentBody.should.eql({
+        value: 'foobar',
+        sessionId: '456'
+      });
+    });
+    it('should pass through urls that do not require session IDs', async function () {
+      let j = mockProxy({
+        sessionId: '123'
+      });
+      let [req, res] = buildReqRes('/status', 'GET');
+      await j.proxyReqRes(req, res);
+      res.sentBody.should.eql({
+        value: {
+          'foo': 'bar'
+        }
+      });
+    });
+    it('should proxy strange responses', async function () {
+      let j = mockProxy({
+        sessionId: '123'
+      });
+      let [req, res] = buildReqRes('/nochrome', 'GET');
+      await j.proxyReqRes(req, res);
+      res.sentCode.should.equal(100);
+      res.sentBody.should.eql({
+        value: {
+          message: 'chrome not reachable'
+        }
+      });
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../test/unit/jsonwp-proxy/proxy.spec.js"],"names":["buildReqRes","url","method","body","req","originalUrl","res","headers","set","k","v","status","code","sentCode","send","JSON","parse","e","sentBody","describe","port","mockProxy","opts","server","TEST_HOST","proxy","JWProxy","request","args","before","it","j","should","equal","desiredCapabilities","statusCode","eql","sessionId","value","browserName","getUrlForProxy","reqBasePath","newUrl","err","exist","message","contain","foo","eventually","be","rejectedWith","getActualError","errors","ElementNotVisibleError","true","command","error","proxyReqRes"],"mappings":"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","sourcesContent":["// transpile:mocha\n\nimport { JWProxy } from '../../../lib';\nimport request from './mock-request';\nimport { isErrorType, errors } from '../../../lib/protocol/errors';\nimport { getTestPort, TEST_HOST } from '../../helpers';\n\nfunction buildReqRes (url, method, body) {\n  let req = {originalUrl: url, method, body};\n  let res = {};\n  res.headers = {};\n  res.set = (k, v) => { res[k] = v; };\n  res.status = (code) => {\n    res.sentCode = code;\n    return res;\n  };\n  res.send = (body) => {\n    try {\n      body = JSON.parse(body);\n    } catch (e) {}\n    res.sentBody = body;\n  };\n  return [req, res];\n}\n\ndescribe('proxy', function () {\n  let port;\n\n  function mockProxy (opts = {}) {\n    // sets default server/port\n    opts = {server: TEST_HOST, port, ...opts};\n    let proxy = new JWProxy(opts);\n    proxy.request = async function (...args) {\n      return await request(...args);\n    };\n    return proxy;\n  }\n\n  before(async function () {\n    port = await getTestPort();\n  });\n\n  it('should override default params', function () {\n    let j = mockProxy({server: '127.0.0.2', port});\n    j.server.should.equal('127.0.0.2');\n    j.port.should.equal(port);\n  });\n  it('should save session id on session creation', async function () {\n    let j = mockProxy();\n    let [res, body] = await j.proxy('/session', 'POST', {desiredCapabilities: {}});\n    res.statusCode.should.equal(200);\n    body.should.eql({status: 0, sessionId: '123', value: {browserName: 'boo'}});\n    j.sessionId.should.equal('123');\n  });\n  describe('getUrlForProxy', function () {\n    it('should modify session id, host, and port', function () {\n      let j = mockProxy({sessionId: '123'});\n      j.getUrlForProxy('http://host.com:1234/session/456/element/200/value')\n       .should.eql(`http://${TEST_HOST}:${port}/session/123/element/200/value`);\n    });\n    it('should prepend scheme, host and port if not provided', function () {\n      let j = mockProxy({sessionId: '123'});\n      j.getUrlForProxy('/session/456/element/200/value')\n       .should.eql(`http://${TEST_HOST}:${port}/session/123/element/200/value`);\n    });\n    it('should respect nonstandard incoming request base path', function () {\n      let j = mockProxy({sessionId: '123', reqBasePath: ''});\n      j.getUrlForProxy('/session/456/element/200/value')\n       .should.eql(`http://${TEST_HOST}:${port}/session/123/element/200/value`);\n\n      j = mockProxy({sessionId: '123', reqBasePath: '/my/base/path'});\n      j.getUrlForProxy('/my/base/path/session/456/element/200/value')\n       .should.eql(`http://${TEST_HOST}:${port}/session/123/element/200/value`);\n    });\n    it('should work with urls which do not have session ids', function () {\n      let j = mockProxy({sessionId: '123'});\n      j.getUrlForProxy('http://host.com:1234/session')\n       .should.eql(`http://${TEST_HOST}:${port}/session`);\n\n      let newUrl = j.getUrlForProxy('/session');\n      newUrl.should.eql(`http://${TEST_HOST}:${port}/session`);\n    });\n    it('should throw an error if url requires a sessionId but its null', function () {\n      let j = mockProxy();\n      let e;\n      try {\n        j.getUrlForProxy('/session/456/element/200/value');\n      } catch (err) {\n        e = err;\n      }\n      should.exist(e);\n      e.message.should.contain('without session id');\n    });\n    it('should not throw an error if url does not require a session id and its null', function () {\n      let j = mockProxy();\n      let newUrl = j.getUrlForProxy('/status');\n\n      should.exist(newUrl);\n    });\n  });\n  describe('straight proxy', function () {\n    it('should successfully proxy straight', async function () {\n      let j = mockProxy();\n      let [res, body] = await j.proxy('/status', 'GET');\n      res.statusCode.should.equal(200);\n      body.should.eql({status: 0, value: {foo: 'bar'}});\n    });\n    it('should pass along request errors', function () {\n      let j = mockProxy({sessionId: '123'});\n      j.proxy('/badurl', 'GET').should.eventually.be.rejectedWith('Could not proxy');\n    });\n    it('should proxy error responses and codes', async function () {\n      let j = mockProxy({sessionId: '123'});\n      try {\n        await j.proxy('/element/bad/text', 'GET');\n      } catch (e) {\n        isErrorType(e.getActualError(), errors.ElementNotVisibleError).should.be.true;\n      }\n    });\n  });\n  describe('command proxy', function () {\n    it('should successfully proxy command', async function () {\n      let j = mockProxy();\n      let res = await j.command('/status', 'GET');\n      res.should.eql({foo: 'bar'});\n    });\n    it('should pass along request errors', function () {\n      let j = mockProxy({sessionId: '123'});\n      j.command('/badurl', 'GET').should.eventually.be.rejectedWith('Could not proxy');\n    });\n    it('should throw when a command fails', async function () {\n      let j = mockProxy({sessionId: '123'});\n      let e = null;\n      try {\n        await j.command('/element/bad/text', 'GET');\n      } catch (err) {\n        e = err;\n      }\n      should.exist(e);\n      e.message.should.contain('Invisible element');\n    });\n    it('should throw when a command fails with a 200 because the status is not 0', async function () {\n      let j = mockProxy({sessionId: '123'});\n      let e = null;\n      try {\n        await j.command('/element/200/text', 'GET');\n      } catch (err) {\n        e = err;\n      }\n      should.exist(e);\n      e.error.should.eql('element not visible');\n    });\n    it('should throw when a command fails with a 100', async function () {\n      let j = mockProxy({sessionId: '123'});\n      let e = null;\n      try {\n        await j.command('/session/badchrome/nochrome', 'GET');\n      } catch (err) {\n        e = err;\n      }\n      should.exist(e);\n      e.message.should.contain('chrome not reachable');\n    });\n  });\n  describe('req/res proxy', function () {\n    it('should successfully proxy via req and send to res', async function () {\n      let j = mockProxy();\n      let [req, res] = buildReqRes('/status', 'GET');\n      await j.proxyReqRes(req, res);\n      res.headers['content-type'].should.equal('application/json; charset=utf-8');\n      res.sentCode.should.equal(200);\n      res.sentBody.should.eql({value: {foo: 'bar'}});\n    });\n    it('should rewrite the inner session id so it doesnt change', async function () {\n      let j = mockProxy({sessionId: '123'});\n      let [req, res] = buildReqRes('/element/200/value', 'GET');\n      await j.proxyReqRes(req, res);\n      res.sentBody.should.eql({value: 'foobar', sessionId: '123'});\n    });\n    it('should rewrite the inner session id with sessionId in url', async function () {\n      let j = mockProxy({sessionId: '123'});\n      let [req, res] = buildReqRes('/session/456/element/200/value', 'POST');\n      await j.proxyReqRes(req, res);\n      res.sentBody.should.eql({value: 'foobar', sessionId: '456'});\n    });\n    it('should pass through urls that do not require session IDs', async function () {\n      let j = mockProxy({sessionId: '123'});\n      let [req, res] = buildReqRes('/status', 'GET');\n      await j.proxyReqRes(req, res);\n      res.sentBody.should.eql({value: {'foo': 'bar'}});\n    });\n    it('should proxy strange responses', async function () {\n      let j = mockProxy({sessionId: '123'});\n      let [req, res] = buildReqRes('/nochrome', 'GET');\n      await j.proxyReqRes(req, res);\n      res.sentCode.should.equal(100);\n      res.sentBody.should.eql({value: {message: 'chrome not reachable'}});\n    });\n  });\n});\n"]}