@appium/base-driver 8.3.0 → 8.3.1

package/build/test/e2e/protocol/protocol.e2e.spec.js

@@ -0,0 +1,1186 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("source-map-support/register");
+
+var _lib = require("../../../lib");
+
+var _fakeDriver = require("./fake-driver");
+
+var _axios = _interopRequireDefault(require("axios"));
+
+var _sinon = require("sinon");
+
+var _httpStatusCodes = require("http-status-codes");
+
+var _helpers = require("./helpers");
+
+var _constants = require("../../../lib/constants");
+
+var _helpers2 = require("../../helpers");
+
+let port;
+let baseUrl;
+describe('Protocol', function () {
+  let sandbox;
+  beforeEach(function () {
+    sandbox = (0, _sinon.createSandbox)();
+  });
+  afterEach(function () {
+    sandbox.restore();
+  });
+  before(async function () {
+    port = await (0, _helpers2.getTestPort)();
+    baseUrl = `http://${_helpers2.TEST_HOST}:${port}`;
+  });
+  describe('direct to driver', function () {
+    let d = new _fakeDriver.FakeDriver();
+    it('should return response values directly from the driver', async function () {
+      (await d.setUrl('http://google.com')).should.contain('google');
+    });
+  });
+  describe('via express router', function () {
+    let mjsonwpServer;
+    let driver;
+    before(async function () {
+      driver = new _fakeDriver.FakeDriver();
+      driver.sessionId = 'foo';
+      mjsonwpServer = await (0, _lib.server)({
+        routeConfiguringFunction: (0, _lib.routeConfiguringFunction)(driver),
+        port
+      });
+    });
+    after(async function () {
+      await mjsonwpServer.close();
+    });
+    it('should proxy to driver and return valid jsonwp response', async function () {
+      const {
+        data
+      } = await (0, _axios.default)({
+        url: `${baseUrl}/session/foo/url`,
+        method: 'POST',
+        data: {
+          url: 'http://google.com'
+        }
+      });
+      data.should.eql({
+        value: 'Navigated to: http://google.com',
+        sessionId: 'foo'
+      });
+    });
+    it('should assume requests without a Content-Type are json requests', async function () {
+      const {
+        data
+      } = await (0, _axios.default)({
+        url: `${baseUrl}/session/foo/url`,
+        method: 'POST',
+        data: {
+          url: 'http://google.com'
+        }
+      });
+      data.should.eql({
+        value: 'Navigated to: http://google.com',
+        sessionId: 'foo'
+      });
+    });
+    it('should respond to x-www-form-urlencoded as well as json requests', async function () {
+      const reqData = new URLSearchParams();
+      reqData.set('url', 'http://google.com');
+      const {
+        data
+      } = await (0, _axios.default)({
+        url: `${baseUrl}/session/foo/url`,
+        headers: {
+          'Content-Type': 'application/x-www-form-urlencoded'
+        },
+        method: 'POST',
+        data: reqData.toString()
+      });
+      data.should.eql({
+        value: 'Navigated to: http://google.com',
+        sessionId: 'foo'
+      });
+    });
+    it('should include url request parameters for methods to use - sessionid', async function () {
+      const {
+        data
+      } = await (0, _axios.default)({
+        url: `${baseUrl}/session/foo/back`,
+        method: 'POST',
+        data: {}
+      });
+      data.should.eql({
+        value: 'foo',
+        sessionId: 'foo'
+      });
+    });
+    it('should include url request parameters for methods to use - elementid', async function () {
+      const {
+        data
+      } = await (0, _axios.default)({
+        url: `${baseUrl}/session/foo/element/bar/click`,
+        method: 'POST',
+        data: {}
+      });
+      data.value.should.eql(['bar', 'foo']);
+    });
+    it('should include url req params in the order: custom, element, session', async function () {
+      const {
+        data
+      } = await (0, _axios.default)({
+        url: `${baseUrl}/session/foo/element/bar/attribute/baz`
+      });
+      data.value.should.eql(['baz', 'bar', 'foo']);
+    });
+    it('should respond with 400 Bad Request if parameters missing', async function () {
+      const {
+        data,
+        status
+      } = await (0, _axios.default)({
+        url: `${baseUrl}/session/foo/url`,
+        method: 'POST',
+        data: {},
+        validateStatus: null
+      });
+      status.should.equal(400);
+      JSON.stringify(data).should.contain('url');
+    });
+    it('should reject requests with a badly formatted body and not crash', async function () {
+      await (0, _axios.default)({
+        url: `${baseUrl}/session/foo/url`,
+        method: 'POST',
+        data: 'oh hello'
+      }).should.eventually.be.rejected;
+      const {
+        data
+      } = await (0, _axios.default)({
+        url: `${baseUrl}/session/foo/url`,
+        method: 'POST',
+        data: {
+          url: 'http://google.com'
+        }
+      });
+      data.should.eql({
+        value: 'Navigated to: http://google.com',
+        sessionId: 'foo'
+      });
+    });
+    it('should get 404 for bad routes', async function () {
+      await (0, _axios.default)({
+        url: `${baseUrl}/blargimarg`
+      }).should.eventually.be.rejectedWith(/404/);
+    });
+    it('4xx responses should have content-type of application/json', async function () {
+      const {
+        headers
+      } = await (0, _axios.default)({
+        url: `${baseUrl}/blargimargarita`,
+        validateStatus: null
+      });
+      headers['content-type'].should.include('application/json');
+    });
+    it('should throw not yet implemented for unfilledout commands', async function () {
+      const {
+        status,
+        data
+      } = await (0, _axios.default)({
+        url: `${baseUrl}/session/foo/element/bar/location`,
+        validateStatus: null
+      });
+      status.should.equal(405);
+      data.value.error.should.eql('unknown method');
+      data.value.message.should.eql('Method has not yet been implemented');
+      data.sessionId.should.eql('foo');
+    });
+    it('should throw not implemented for ignored commands', async function () {
+      const {
+        status,
+        data
+      } = await (0, _axios.default)({
+        url: `${baseUrl}/session/foo/buttonup`,
+        method: 'POST',
+        validateStatus: null,
+        data: {}
+      });
+      status.should.equal(405);
+      data.value.error.should.eql('unknown method');
+      data.value.message.should.eql('Method has not yet been implemented');
+      data.sessionId.should.eql('foo');
+    });
+    it('should get 400 for bad parameters', async function () {
+      await (0, _axios.default)({
+        url: `${baseUrl}/session/foo/url`,
+        method: 'POST',
+        data: {}
+      }).should.eventually.be.rejectedWith(/400/);
+    });
+    it('should ignore special extra payload params in the right contexts', async function () {
+      await (0, _axios.default)({
+        url: `${baseUrl}/session/foo/element/bar/value`,
+        method: 'POST',
+        data: {
+          id: 'baz',
+          sessionId: 'lol',
+          value: ['a']
+        }
+      });
+      await (0, _axios.default)({
+        url: `${baseUrl}/session/foo/element/bar/value`,
+        method: 'POST',
+        data: {
+          id: 'baz'
+        }
+      }).should.eventually.be.rejectedWith(/400/);
+      await (0, _axios.default)({
+        url: `${baseUrl}/session/foo/frame`,
+        method: 'POST',
+        data: {
+          id: 'baz'
+        }
+      });
+    });
+    it('should return the correct error even if driver does not throw', async function () {
+      const {
+        status,
+        data
+      } = await (0, _axios.default)({
+        url: `${baseUrl}/session/foo/appium/receive_async_response`,
+        method: 'POST',
+        data: {
+          response: 'baz'
+        },
+        validateStatus: null
+      });
+      status.should.equal(500);
+      data.value.error.should.eql('unknown error');
+      data.value.message.should.eql('An unknown server-side error occurred while processing ' + 'the command. Original error: Mishandled Driver Error');
+      data.sessionId.should.eql('foo');
+    });
+    describe('w3c sendkeys migration', function () {
+      it('should accept value for sendkeys', async function () {
+        const {
+          data
+        } = await (0, _axios.default)({
+          url: `${baseUrl}/session/foo/element/bar/value`,
+          method: 'POST',
+          data: {
+            value: 'text to type'
+          }
+        });
+        data.value.should.eql(['text to type', 'bar']);
+      });
+      it('should accept text for sendkeys', async function () {
+        const {
+          data
+        } = await (0, _axios.default)({
+          url: `${baseUrl}/session/foo/element/bar/value`,
+          method: 'POST',
+          data: {
+            text: 'text to type'
+          }
+        });
+        data.value.should.eql(['text to type', 'bar']);
+      });
+      it('should accept value and text for sendkeys, and use value', async function () {
+        const {
+          data
+        } = await (0, _axios.default)({
+          url: `${baseUrl}/session/foo/element/bar/value`,
+          method: 'POST',
+          data: {
+            value: 'text to type',
+            text: 'text to ignore'
+          }
+        });
+        data.value.should.eql(['text to type', 'bar']);
+      });
+    });
+    describe('multiple sets of arguments', function () {
+      describe('optional', function () {
+        it('should allow moveto with element', async function () {
+          const {
+            data
+          } = await (0, _axios.default)({
+            url: `${baseUrl}/session/foo/moveto`,
+            method: 'POST',
+            data: {
+              element: '3'
+            }
+          });
+          data.value.should.eql(['3', null, null]);
+        });
+        it('should allow moveto with xoffset/yoffset', async function () {
+          const {
+            data
+          } = await (0, _axios.default)({
+            url: `${baseUrl}/session/foo/moveto`,
+            method: 'POST',
+            data: {
+              xoffset: 42,
+              yoffset: 17
+            }
+          });
+          data.value.should.eql([null, 42, 17]);
+        });
+      });
+      describe('required', function () {
+        it('should allow removeApp with appId', async function () {
+          const {
+            data
+          } = await (0, _axios.default)({
+            url: `${baseUrl}/session/foo/appium/device/remove_app`,
+            method: 'POST',
+            data: {
+              appId: 42
+            }
+          });
+          data.value.should.eql(42);
+        });
+        it('should allow removeApp with bundleId', async function () {
+          const {
+            data
+          } = await (0, _axios.default)({
+            url: `${baseUrl}/session/foo/appium/device/remove_app`,
+            method: 'POST',
+            data: {
+              bundleId: 42
+            }
+          });
+          data.value.should.eql(42);
+        });
+      });
+    });
+    describe('default param wrap', function () {
+      it('should wrap', async function () {
+        const {
+          data
+        } = await (0, _axios.default)({
+          url: `${baseUrl}/session/foo/touch/perform`,
+          method: 'POST',
+          data: [{
+            'action': 'tap',
+            'options': {
+              'element': '3'
+            }
+          }]
+        });
+        data.value.should.deep.equal([[{
+          'action': 'tap',
+          'options': {
+            'element': '3'
+          }
+        }], 'foo']);
+      });
+      it('should not wrap twice', async function () {
+        const {
+          data
+        } = await (0, _axios.default)({
+          url: `${baseUrl}/session/foo/touch/perform`,
+          method: 'POST',
+          data: {
+            actions: [{
+              'action': 'tap',
+              'options': {
+                'element': '3'
+              }
+            }]
+          }
+        });
+        data.value.should.deep.equal([[{
+          'action': 'tap',
+          'options': {
+            'element': '3'
+          }
+        }], 'foo']);
+      });
+    });
+    describe('create sessions via HTTP endpoint', function () {
+      let sessionId;
+      beforeEach(function () {
+        sessionId = null;
+      });
+      afterEach(async function () {
+        if (sessionId) {
+          await _axios.default.delete(`${baseUrl}/session/${sessionId}`);
+        }
+      });
+      it('should not allow create session with desired caps (MJSONWP)', async function () {
+        const desiredCapabilities = {
+          a: 'b'
+        };
+        const {
+          data
+        } = await (0, _axios.default)({
+          url: `${baseUrl}/session`,
+          method: 'POST',
+          data: {
+            desiredCapabilities
+          }
+        });
+        should.equal(data.value, null);
+      });
+      it('should fail to create session without capabilities', async function () {
+        await (0, _axios.default)({
+          url: `${baseUrl}/session`,
+          method: 'POST',
+          data: {}
+        }).should.eventually.be.rejectedWith(/400/);
+      });
+      it('should allow create session with capabilities (W3C)', async function () {
+        const w3cCapabilities = {
+          alwaysMatch: {
+            'appium:e': 'f'
+          }
+        };
+        const {
+          data
+        } = await (0, _axios.default)({
+          url: `${baseUrl}/session`,
+          method: 'POST',
+          data: {
+            capabilities: w3cCapabilities
+          }
+        });
+        should.not.exist(data.status);
+        should.not.exist(data.sessionId);
+        data.value.capabilities.should.eql(w3cCapabilities);
+        data.value.sessionId.should.exist;
+        sessionId = data.value.sessionId;
+      });
+      it('should raise an error if the driver does not support W3C yet', async function () {
+        const createSessionStub = sandbox.stub(driver, 'createSession').callsFake(function (capabilities) {
+          driver.sessionId = null;
+          return _lib.BaseDriver.prototype.createSession.call(driver, capabilities);
+        });
+
+        try {
+          await (0, _axios.default)({
+            url: `${baseUrl}/session`,
+            method: 'POST',
+            data: {
+              capabilities: {
+                alwaysMatch: {
+                  platformName: 'Fake',
+                  'appium:deviceName': 'Fake'
+                },
+                firstMatch: [{}]
+              }
+            }
+          }).should.eventually.be.rejectedWith(/500/);
+        } finally {
+          createSessionStub.restore();
+        }
+      });
+      describe('w3c endpoints', function () {
+        let sessionUrl;
+        beforeEach(async function () {
+          const {
+            value
+          } = (await (0, _axios.default)({
+            url: `${baseUrl}/session`,
+            method: 'POST',
+            data: {
+              capabilities: {
+                alwaysMatch: {
+                  platformName: 'Fake',
+                  'appium:deviceName': 'Commodore 64'
+                },
+                firstMatch: [{}]
+              }
+            }
+          })).data;
+          sessionId = value.sessionId;
+          sessionUrl = `${baseUrl}/session/${sessionId}`;
+        });
+        it(`should throw 400 Bad Parameters exception if the parameters are bad`, async function () {
+          const {
+            status,
+            data
+          } = await (0, _axios.default)({
+            url: `${sessionUrl}/actions`,
+            method: 'POST',
+            validateStatus: null,
+            data: {
+              bad: 'params'
+            }
+          });
+          status.should.equal(400);
+          const {
+            error: w3cError,
+            message,
+            stacktrace
+          } = data.value;
+          message.should.match(/Parameters were incorrect/);
+          stacktrace.should.match(/protocol.js/);
+          w3cError.should.be.a.string;
+          w3cError.should.equal(_lib.errors.InvalidArgumentError.error());
+        });
+        it(`should throw 405 exception if the command hasn't been implemented yet`, async function () {
+          const {
+            status,
+            data
+          } = await (0, _axios.default)({
+            url: `${sessionUrl}/actions`,
+            method: 'POST',
+            validateStatus: null,
+            data: {
+              actions: []
+            }
+          });
+          status.should.equal(405);
+          const {
+            error: w3cError,
+            message,
+            stacktrace
+          } = data.value;
+          message.should.match(/Method has not yet been implemented/);
+          stacktrace.should.match(/protocol.js/);
+          w3cError.should.be.a.string;
+          w3cError.should.equal(_lib.errors.NotYetImplementedError.error());
+          message.should.match(/Method has not yet been implemented/);
+        });
+        it(`should throw 500 Unknown Error if the command throws an unexpected exception`, async function () {
+          driver.performActions = () => {
+            throw new Error(`Didn't work`);
+          };
+
+          const {
+            status,
+            data
+          } = await (0, _axios.default)({
+            url: `${sessionUrl}/actions`,
+            method: 'POST',
+            validateStatus: null,
+            data: {
+              actions: []
+            }
+          });
+          status.should.equal(500);
+          const {
+            error: w3cError,
+            message,
+            stacktrace
+          } = data.value;
+          stacktrace.should.match(/protocol.js/);
+          w3cError.should.be.a.string;
+          w3cError.should.equal(_lib.errors.UnknownError.error());
+          message.should.match(/Didn't work/);
+          delete driver.performActions;
+        });
+        it(`should translate element format from MJSONWP to W3C`, async function () {
+          const retValue = [{
+            something: {
+              [_constants.MJSONWP_ELEMENT_KEY]: 'fooo',
+              other: 'bar'
+            }
+          }, {
+            [_constants.MJSONWP_ELEMENT_KEY]: 'bar'
+          }, 'ignore'];
+          const expectedValue = [{
+            something: {
+              [_constants.MJSONWP_ELEMENT_KEY]: 'fooo',
+              [_constants.W3C_ELEMENT_KEY]: 'fooo',
+              other: 'bar'
+            }
+          }, {
+            [_constants.MJSONWP_ELEMENT_KEY]: 'bar',
+            [_constants.W3C_ELEMENT_KEY]: 'bar'
+          }, 'ignore'];
+          const findElementsBackup = driver.findElements;
+
+          driver.findElements = () => retValue;
+
+          const {
+            data
+          } = await _axios.default.post(`${sessionUrl}/elements`, {
+            using: 'whatever',
+            value: 'whatever'
+          });
+          data.value.should.eql(expectedValue);
+          driver.findElements = findElementsBackup;
+        });
+        it(`should fail with a 408 error if it throws a TimeoutError exception`, async function () {
+          let setUrlStub = sandbox.stub(driver, 'setUrl').callsFake(function () {
+            throw new _lib.errors.TimeoutError();
+          });
+          const {
+            status,
+            data
+          } = await (0, _axios.default)({
+            url: `${sessionUrl}/url`,
+            method: 'POST',
+            validateStatus: null,
+            data: {
+              url: 'https://example.com/'
+            }
+          });
+          status.should.equal(408);
+          const {
+            error: w3cError,
+            message,
+            stacktrace
+          } = data.value;
+          stacktrace.should.match(/protocol.js/);
+          w3cError.should.be.a.string;
+          w3cError.should.equal(_lib.errors.TimeoutError.error());
+          message.should.match(/An operation did not complete before its timeout expired/);
+          setUrlStub.restore();
+        });
+        it(`should pass with 200 HTTP status code if the command returns a value`, async function () {
+          driver.performActions = actions => 'It works ' + actions.join('');
+
+          const {
+            status,
+            value,
+            sessionId
+          } = (await _axios.default.post(`${sessionUrl}/actions`, {
+            actions: ['a', 'b', 'c']
+          })).data;
+          should.not.exist(sessionId);
+          should.not.exist(status);
+          value.should.equal('It works abc');
+          delete driver.performActions;
+        });
+        describe('jwproxy', function () {
+          let port;
+          let server, jwproxy, app;
+          before(async function () {
+            port = await (0, _helpers2.getTestPort)(true);
+          });
+          beforeEach(function () {
+            const res = (0, _helpers.createProxyServer)(sessionId, port);
+            server = res.server;
+            app = res.app;
+            jwproxy = new _lib.JWProxy({
+              host: _helpers2.TEST_HOST,
+              port
+            });
+            jwproxy.sessionId = sessionId;
+
+            driver.performActions = async actions => await jwproxy.command('/perform-actions', 'POST', actions);
+          });
+          afterEach(async function () {
+            delete driver.performActions;
+            await server.close();
+          });
+          it('should work if a proxied request returns a response with status 200', async function () {
+            app.post('/session/:sessionId/perform-actions', (req, res) => {
+              res.json({
+                sessionId: req.params.sessionId,
+                value: req.body,
+                status: 0
+              });
+            });
+            const {
+              status,
+              value,
+              sessionId
+            } = (await _axios.default.post(`${sessionUrl}/actions`, {
+              actions: [1, 2, 3]
+            })).data;
+            value.should.eql([1, 2, 3]);
+            should.not.exist(status);
+            should.not.exist(sessionId);
+          });
+          it('should return error if a proxied request returns a MJSONWP error response', async function () {
+            app.post('/session/:sessionId/perform-actions', (req, res) => {
+              res.status(500).json({
+                sessionId,
+                status: 6,
+                value: 'A problem occurred'
+              });
+            });
+            const {
+              status,
+              data
+            } = await (0, _axios.default)({
+              url: `${sessionUrl}/actions`,
+              method: 'POST',
+              validateStatus: null,
+              data: {
+                actions: [1, 2, 3]
+              }
+            });
+            status.should.equal(_httpStatusCodes.StatusCodes.NOT_FOUND);
+            JSON.stringify(data).should.match(/A problem occurred/);
+          });
+          it('should return W3C error if a proxied request returns a W3C error response', async function () {
+            const error = new Error(`Some error occurred`);
+            error.w3cStatus = 414;
+            const executeCommandStub = sandbox.stub(driver, 'executeCommand').returns({
+              protocol: 'W3C',
+              error
+            });
+            const {
+              status,
+              data
+            } = await (0, _axios.default)({
+              url: `${sessionUrl}/actions`,
+              method: 'POST',
+              validateStatus: null,
+              data: {
+                actions: [1, 2, 3]
+              }
+            });
+            status.should.equal(414);
+            const {
+              error: w3cError,
+              message: errMessage,
+              stacktrace
+            } = data.value;
+            w3cError.should.equal('unknown error');
+            stacktrace.should.match(/Some error occurred/);
+            errMessage.should.equal('Some error occurred');
+            executeCommandStub.restore();
+          });
+          it('should return error if a proxied request returns a MJSONWP error response but HTTP status code is 200', async function () {
+            app.post('/session/:sessionId/perform-actions', (req, res) => {
+              res.status(200).json({
+                sessionId: 'Fake Session Id',
+                status: 7,
+                value: 'A problem occurred'
+              });
+            });
+            const {
+              status,
+              data
+            } = await (0, _axios.default)({
+              url: `${sessionUrl}/actions`,
+              method: 'POST',
+              validateStatus: null,
+              data: {
+                actions: [1, 2, 3]
+              }
+            });
+            status.should.equal(_httpStatusCodes.StatusCodes.NOT_FOUND);
+            const {
+              error: w3cError,
+              message: errMessage,
+              stacktrace
+            } = data.value;
+            w3cError.should.equal('no such element');
+            errMessage.should.match(/A problem occurred/);
+            stacktrace.should.exist;
+          });
+          it('should return error if a proxied request returns a W3C error response', async function () {
+            app.post('/session/:sessionId/perform-actions', (req, res) => {
+              res.status(404).json({
+                value: {
+                  error: 'no such element',
+                  message: 'does not make a difference',
+                  stacktrace: 'arbitrary stacktrace'
+                }
+              });
+            });
+            const {
+              status,
+              data
+            } = await (0, _axios.default)({
+              url: `${sessionUrl}/actions`,
+              method: 'POST',
+              validateStatus: null,
+              data: {
+                actions: [1, 2, 3]
+              }
+            });
+            status.should.equal(_httpStatusCodes.StatusCodes.NOT_FOUND);
+            const {
+              error: w3cError,
+              stacktrace
+            } = data.value;
+            w3cError.should.equal('no such element');
+            stacktrace.should.match(/arbitrary stacktrace/);
+          });
+          it('should return an error if a proxied request returns a W3C error response', async function () {
+            app.post('/session/:sessionId/perform-actions', (req, res) => {
+              res.set('Connection', 'close');
+              res.status(444).json({
+                value: {
+                  error: 'bogus error code',
+                  message: 'does not make a difference',
+                  stacktrace: 'arbitrary stacktrace'
+                }
+              });
+            });
+            const {
+              status,
+              data
+            } = await (0, _axios.default)({
+              url: `${sessionUrl}/actions`,
+              method: 'POST',
+              validateStatus: null,
+              data: {
+                actions: [1, 2, 3]
+              }
+            });
+            status.should.equal(_httpStatusCodes.StatusCodes.INTERNAL_SERVER_ERROR);
+            const {
+              error: w3cError,
+              stacktrace
+            } = data.value;
+            w3cError.should.equal('unknown error');
+            stacktrace.should.match(/arbitrary stacktrace/);
+          });
+        });
+      });
+    });
+    it('should handle commands with no response values', async function () {
+      const {
+        data
+      } = await (0, _axios.default)({
+        url: `${baseUrl}/session/foo/forward`,
+        method: 'POST'
+      });
+      data.should.eql({
+        value: null,
+        sessionId: 'foo'
+      });
+    });
+    it('should allow empty string response values', async function () {
+      const {
+        data
+      } = await (0, _axios.default)({
+        url: `${baseUrl}/session/foo/element/bar/text`
+      });
+      data.should.eql({
+        value: '',
+        sessionId: 'foo'
+      });
+    });
+    it('should send 500 response and an Unknown object for rejected commands', async function () {
+      const {
+        status,
+        data
+      } = await (0, _axios.default)({
+        url: `${baseUrl}/session/foo/refresh`,
+        method: 'POST',
+        validateStatus: null
+      });
+      status.should.equal(500);
+      data.value.error.should.eql('unknown error');
+      data.value.message.should.eql('An unknown server-side error occurred while processing ' + 'the command. Original error: Too Fresh!');
+      data.sessionId.should.eql('foo');
+    });
+    it('should not throw UnknownError when known', async function () {
+      const {
+        status,
+        data
+      } = await (0, _axios.default)({
+        url: `${baseUrl}/session/foo`,
+        validateStatus: null
+      });
+      status.should.equal(404);
+      data.value.error.should.eql('invalid session id');
+      data.value.message.should.eql('A session is either terminated or not started');
+      data.sessionId.should.eql('foo');
+    });
+  });
+  describe('session Ids', function () {
+    let driver = new _fakeDriver.FakeDriver();
+    let mjsonwpServer;
+    before(async function () {
+      mjsonwpServer = await (0, _lib.server)({
+        routeConfiguringFunction: (0, _lib.routeConfiguringFunction)(driver),
+        port
+      });
+    });
+    after(async function () {
+      await mjsonwpServer.close();
+    });
+    afterEach(function () {
+      driver.sessionId = null;
+    });
+    it('should return null SessionId for commands without sessionIds', async function () {
+      const {
+        data
+      } = await (0, _axios.default)({
+        url: `${baseUrl}/status`
+      });
+      should.equal(data.sessionId, null);
+    });
+    it('responds with the same session ID in the request', async function () {
+      let sessionId = 'Vader Sessions';
+      driver.sessionId = sessionId;
+      const {
+        data
+      } = await (0, _axios.default)({
+        url: `${baseUrl}/session/${sessionId}/url`,
+        method: 'POST',
+        data: {
+          url: 'http://google.com'
+        }
+      });
+      should.exist(data.sessionId);
+      data.sessionId.should.eql(sessionId);
+    });
+    it('yells if no session exists', async function () {
+      let sessionId = 'Vader Sessions';
+      const {
+        data,
+        status
+      } = await (0, _axios.default)({
+        url: `${baseUrl}/session/${sessionId}/url`,
+        method: 'POST',
+        validateStatus: null,
+        data: {
+          url: 'http://google.com'
+        }
+      });
+      status.should.equal(404);
+      data.value.message.should.contain('session');
+    });
+    it('yells if invalid session is sent', async function () {
+      let sessionId = 'Vader Sessions';
+      driver.sessionId = 'recession';
+      const {
+        data,
+        status
+      } = await (0, _axios.default)({
+        url: `${baseUrl}/session/${sessionId}/url`,
+        method: 'POST',
+        validateStatus: null,
+        data: {
+          url: 'http://google.com'
+        }
+      });
+      status.should.equal(404);
+      data.value.message.should.contain('session');
+    });
+    it('should have session IDs in error responses', async function () {
+      let sessionId = 'Vader Sessions';
+      driver.sessionId = sessionId;
+      const {
+        data,
+        status
+      } = await (0, _axios.default)({
+        url: `${baseUrl}/session/${sessionId}/refresh`,
+        method: 'POST',
+        validateStatus: null
+      });
+      status.should.equal(500);
+      data.value.error.should.eql('unknown error');
+      data.value.message.should.eql('An unknown server-side error occurred while processing ' + 'the command. Original error: Too Fresh!');
+      data.sessionId.should.eql('Vader Sessions');
+    });
+    it('should return a new session ID on create', async function () {
+      const {
+        data
+      } = await (0, _axios.default)({
+        url: `${baseUrl}/session`,
+        method: 'POST',
+        data: {
+          capabilities: {
+            alwaysMatch: {
+              'appium:greeting': 'hello'
+            },
+            firstMatch: [{}]
+          }
+        }
+      });
+      should.exist(data.value.sessionId);
+      data.value.sessionId.indexOf('fakeSession_').should.equal(0);
+      data.value.capabilities.should.eql({
+        alwaysMatch: {
+          'appium:greeting': 'hello'
+        },
+        firstMatch: [{}]
+      });
+    });
+  });
+  describe('via drivers jsonwp proxy', function () {
+    let driver;
+    let sessionId = 'foo';
+    let mjsonwpServer;
+    beforeEach(async function () {
+      driver = new _fakeDriver.FakeDriver();
+      driver.sessionId = sessionId;
+
+      driver.proxyActive = () => true;
+
+      driver.canProxy = () => true;
+
+      mjsonwpServer = await (0, _lib.server)({
+        routeConfiguringFunction: (0, _lib.routeConfiguringFunction)(driver),
+        port,
+        extraMethodMap: _fakeDriver.FakeDriver.newMethodMap
+      });
+    });
+    afterEach(async function () {
+      await mjsonwpServer.close();
+    });
+    it('should give a nice error if proxying is set but no proxy function exists', async function () {
+      driver.canProxy = () => false;
+
+      const {
+        status,
+        data
+      } = await (0, _axios.default)({
+        url: `${baseUrl}/session/${sessionId}/url`,
+        method: 'POST',
+        validateStatus: null,
+        data: {
+          url: 'http://google.com'
+        }
+      });
+      status.should.equal(500);
+      data.value.error.should.eql('unknown error');
+      data.value.message.should.eql('An unknown server-side error occurred while processing ' + 'the command. Original error: Trying to proxy to a ' + 'server but the driver is unable to proxy');
+      data.sessionId.should.eql('foo');
+    });
+    it('should pass on any errors in proxying', async function () {
+      driver.proxyReqRes = async function () {
+        throw new Error('foo');
+      };
+
+      const {
+        status,
+        data
+      } = await (0, _axios.default)({
+        url: `${baseUrl}/session/${sessionId}/url`,
+        method: 'POST',
+        validateStatus: null,
+        data: {
+          url: 'http://google.com'
+        }
+      });
+      status.should.equal(500);
+      data.value.error.should.eql('unknown error');
+      data.value.message.should.eql('An unknown server-side error occurred while processing ' + 'the command. Original error: Could not proxy. Proxy error: foo');
+      data.sessionId.should.eql('foo');
+    });
+    it('should able to throw ProxyRequestError in proxying', async function () {
+      driver.proxyReqRes = async function () {
+        let jsonwp = {
+          status: 35,
+          value: 'No such context found.',
+          sessionId: 'foo'
+        };
+        throw new _lib.errors.ProxyRequestError(`Could not proxy command to remote server. `, jsonwp);
+      };
+
+      const {
+        status,
+        data
+      } = await (0, _axios.default)({
+        url: `${baseUrl}/session/${sessionId}/url`,
+        method: 'POST',
+        validateStatus: null,
+        data: {
+          url: 'http://google.com'
+        }
+      });
+      status.should.equal(400);
+      data.value.error.should.eql('unknown error');
+      data.value.message.should.eql('No such context found.');
+      data.sessionId.should.eql('foo');
+    });
+    it('should let the proxy handle req/res', async function () {
+      driver.proxyReqRes = async function (req, res) {
+        res.status(200).json({
+          custom: 'data'
+        });
+      };
+
+      const {
+        status,
+        data
+      } = await (0, _axios.default)({
+        url: `${baseUrl}/session/${sessionId}/url`,
+        method: 'POST',
+        data: {
+          url: 'http://google.com'
+        }
+      });
+      status.should.equal(200);
+      data.should.eql({
+        custom: 'data'
+      });
+    });
+    it('should avoid jsonwp proxying when path matches avoidance list', async function () {
+      driver.getProxyAvoidList = () => [['POST', new RegExp('^/session/[^/]+/url$')]];
+
+      const {
+        status,
+        data
+      } = await (0, _axios.default)({
+        url: `${baseUrl}/session/${sessionId}/url`,
+        method: 'POST',
+        data: {
+          url: 'http://google.com'
+        }
+      });
+      status.should.equal(200);
+      data.should.eql({
+        value: 'Navigated to: http://google.com',
+        sessionId
+      });
+    });
+    it('should fail if avoid proxy list is malformed in some way', async function () {
+      async function badProxyAvoidanceList(list) {
+        driver.getProxyAvoidList = () => list;
+
+        const {
+          status,
+          data
+        } = await (0, _axios.default)({
+          url: `${baseUrl}/session/${sessionId}/url`,
+          method: 'POST',
+          validateStatus: null,
+          data: {
+            url: 'http://google.com'
+          }
+        });
+        status.should.equal(500);
+        data.value.message.should.contain('roxy');
+      }
+
+      const lists = ['foo', [['foo']], [['BAR', /lol/]], [['GET', 'foo']]];
+
+      for (let list of lists) {
+        await badProxyAvoidanceList(list);
+      }
+    });
+    it('should avoid proxying non-session commands even if not in the list', async function () {
+      driver.getProxyAvoidList = () => [['POST', new RegExp('')]];
+
+      const {
+        status,
+        data
+      } = await (0, _axios.default)({
+        url: `${baseUrl}/status`
+      });
+      status.should.equal(200);
+      data.should.eql({
+        value: "I'm fine",
+        sessionId: null
+      });
+    });
+    it('should avoid proxying deleteSession commands', async function () {
+      driver.getProxyAvoidList = () => [['POST', new RegExp('')]];
+
+      driver.sessionId.should.equal(sessionId);
+      const {
+        status
+      } = await _axios.default.delete(`${baseUrl}/session/${sessionId}`);
+      status.should.equal(200);
+      should.not.exist(driver.sessionId);
+      driver.jwpProxyActive.should.be.false;
+    });
+    it('should avoid proxying when command spec specifies neverProxy', async function () {
+      const {
+        status,
+        data
+      } = await (0, _axios.default)({
+        url: `${baseUrl}/session/${sessionId}/noproxy`,
+        method: 'GET'
+      });
+      status.should.equal(200);
+      data.should.eql({
+        value: 'This was not proxied',
+        sessionId
+      });
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../test/e2e/protocol/protocol.e2e.spec.js"],"names":["port","baseUrl","describe","sandbox","beforeEach","afterEach","restore","before","TEST_HOST","d","FakeDriver","it","setUrl","should","contain","mjsonwpServer","driver","sessionId","routeConfiguringFunction","after","close","data","url","method","eql","value","reqData","URLSearchParams","set","headers","toString","status","validateStatus","equal","JSON","stringify","eventually","be","rejected","rejectedWith","include","error","message","id","response","text","element","xoffset","yoffset","appId","bundleId","deep","actions","axios","delete","desiredCapabilities","a","w3cCapabilities","alwaysMatch","capabilities","not","exist","createSessionStub","stub","callsFake","BaseDriver","prototype","createSession","call","platformName","firstMatch","sessionUrl","bad","w3cError","stacktrace","match","string","errors","InvalidArgumentError","NotYetImplementedError","performActions","Error","UnknownError","retValue","something","MJSONWP_ELEMENT_KEY","other","expectedValue","W3C_ELEMENT_KEY","findElementsBackup","findElements","post","using","setUrlStub","TimeoutError","join","server","jwproxy","app","res","JWProxy","host","command","req","json","params","body","HTTPStatusCodes","NOT_FOUND","w3cStatus","executeCommandStub","returns","protocol","errMessage","INTERNAL_SERVER_ERROR","indexOf","proxyActive","canProxy","extraMethodMap","newMethodMap","proxyReqRes","jsonwp","ProxyRequestError","custom","getProxyAvoidList","RegExp","badProxyAvoidanceList","list","lists","jwpProxyActive","false"],"mappings":"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","sourcesContent":["// transpile:mocha\n\nimport {\n  server, routeConfiguringFunction, errors, JWProxy, BaseDriver\n} from '../../../lib';\nimport { FakeDriver } from './fake-driver';\nimport axios from 'axios';\nimport { createSandbox } from 'sinon';\nimport { StatusCodes as HTTPStatusCodes } from 'http-status-codes';\nimport { createProxyServer } from './helpers';\nimport {\n  MJSONWP_ELEMENT_KEY, W3C_ELEMENT_KEY\n} from '../../../lib/constants';\nimport {TEST_HOST, getTestPort} from '../../helpers';\n\nlet port;\nlet baseUrl;\n\ndescribe('Protocol', function () {\n  let sandbox;\n\n  beforeEach(function () {\n    sandbox = createSandbox();\n  });\n\n  afterEach(function () {\n    sandbox.restore();\n  });\n\n  before(async function () {\n    port = await getTestPort();\n    baseUrl = `http://${TEST_HOST}:${port}`;\n  });\n\n  //TODO: more tests!:\n  // Unknown commands should return 404\n\n  describe('direct to driver', function () {\n    let d = new FakeDriver();\n    it('should return response values directly from the driver', async function () {\n      (await d.setUrl('http://google.com')).should.contain('google');\n    });\n  });\n\n  describe('via express router', function () {\n    let mjsonwpServer;\n    let driver;\n\n    before(async function () {\n      driver = new FakeDriver();\n      driver.sessionId = 'foo';\n      mjsonwpServer = await server({\n        routeConfiguringFunction: routeConfiguringFunction(driver),\n        port,\n      });\n    });\n\n    after(async function () {\n      await mjsonwpServer.close();\n    });\n\n    it('should proxy to driver and return valid jsonwp response', async function () {\n      const {data} = await axios({\n        url: `${baseUrl}/session/foo/url`,\n        method: 'POST',\n        data: {url: 'http://google.com'}\n      });\n      data.should.eql({\n        value: 'Navigated to: http://google.com',\n        sessionId: 'foo'\n      });\n    });\n\n    it('should assume requests without a Content-Type are json requests', async function () {\n      const {data} = await axios({\n        url: `${baseUrl}/session/foo/url`,\n        method: 'POST',\n        data: {url: 'http://google.com'},\n      });\n      data.should.eql({\n        value: 'Navigated to: http://google.com',\n        sessionId: 'foo'\n      });\n    });\n\n    it('should respond to x-www-form-urlencoded as well as json requests', async function () {\n      const reqData = new URLSearchParams();\n      reqData.set('url', 'http://google.com');\n      const {data} = await axios({\n        url: `${baseUrl}/session/foo/url`,\n        headers: {\n          'Content-Type': 'application/x-www-form-urlencoded',\n        },\n        method: 'POST',\n        data: reqData.toString(),\n      });\n      data.should.eql({\n        value: 'Navigated to: http://google.com',\n        sessionId: 'foo'\n      });\n    });\n\n    it('should include url request parameters for methods to use - sessionid', async function () {\n      const {data} = await axios({\n        url: `${baseUrl}/session/foo/back`,\n        method: 'POST',\n        data: {},\n      });\n      data.should.eql({\n        value: 'foo',\n        sessionId: 'foo'\n      });\n    });\n\n    it('should include url request parameters for methods to use - elementid', async function () {\n      const {data} = await axios({\n        url: `${baseUrl}/session/foo/element/bar/click`,\n        method: 'POST',\n        data: {},\n      });\n      data.value.should.eql(['bar', 'foo']);\n    });\n\n    it('should include url req params in the order: custom, element, session', async function () {\n      const {data} = await axios({\n        url: `${baseUrl}/session/foo/element/bar/attribute/baz`,\n      });\n      data.value.should.eql(['baz', 'bar', 'foo']);\n    });\n\n    it('should respond with 400 Bad Request if parameters missing', async function () {\n      const {data, status} = await axios({\n        url: `${baseUrl}/session/foo/url`,\n        method: 'POST',\n        data: {},\n        validateStatus: null,\n      });\n      status.should.equal(400);\n      JSON.stringify(data).should.contain('url');\n    });\n\n    it('should reject requests with a badly formatted body and not crash', async function () {\n      await axios({\n        url: `${baseUrl}/session/foo/url`,\n        method: 'POST',\n        data: 'oh hello'\n      }).should.eventually.be.rejected;\n\n      const {data} = await axios({\n        url: `${baseUrl}/session/foo/url`,\n        method: 'POST',\n        data: {url: 'http://google.com'}\n      });\n      data.should.eql({\n        value: 'Navigated to: http://google.com',\n        sessionId: 'foo'\n      });\n\n    });\n\n    it('should get 404 for bad routes', async function () {\n      await axios({\n        url: `${baseUrl}/blargimarg`,\n      }).should.eventually.be.rejectedWith(/404/);\n    });\n\n    it('4xx responses should have content-type of application/json', async function () {\n      const {headers} = await axios({\n        url: `${baseUrl}/blargimargarita`,\n        validateStatus: null,\n      });\n\n      headers['content-type'].should.include('application/json');\n    });\n\n    it('should throw not yet implemented for unfilledout commands', async function () {\n      const {status, data} = await axios({\n        url: `${baseUrl}/session/foo/element/bar/location`,\n        validateStatus: null,\n      });\n\n      status.should.equal(405);\n      data.value.error.should.eql('unknown method');\n      data.value.message.should.eql('Method has not yet been implemented');\n      data.sessionId.should.eql('foo');\n    });\n\n    it('should throw not implemented for ignored commands', async function () {\n      const {status, data} = await axios({\n        url: `${baseUrl}/session/foo/buttonup`,\n        method: 'POST',\n        validateStatus: null,\n        data: {},\n      });\n\n      status.should.equal(405);\n      data.value.error.should.eql('unknown method');\n      data.value.message.should.eql('Method has not yet been implemented');\n      data.sessionId.should.eql('foo');\n    });\n\n    it('should get 400 for bad parameters', async function () {\n      await axios({\n        url: `${baseUrl}/session/foo/url`,\n        method: 'POST',\n        data: {}\n      }).should.eventually.be.rejectedWith(/400/);\n    });\n\n    it('should ignore special extra payload params in the right contexts', async function () {\n      await axios({\n        url: `${baseUrl}/session/foo/element/bar/value`,\n        method: 'POST',\n        data: {id: 'baz', sessionId: 'lol', value: ['a']}\n      });\n\n      await axios({\n        url: `${baseUrl}/session/foo/element/bar/value`,\n        method: 'POST',\n        data: {id: 'baz'}\n      }).should.eventually.be.rejectedWith(/400/);\n\n      // make sure adding the optional 'id' doesn't clobber a route where we\n      // have an actual required 'id'\n      await axios({\n        url: `${baseUrl}/session/foo/frame`,\n        method: 'POST',\n        data: {id: 'baz'}\n      });\n    });\n\n    it('should return the correct error even if driver does not throw', async function () {\n      const {status, data} = await axios({\n        url: `${baseUrl}/session/foo/appium/receive_async_response`,\n        method: 'POST',\n        data: {response: 'baz'},\n        validateStatus: null,\n      });\n      status.should.equal(500);\n      data.value.error.should.eql('unknown error');\n      data.value.message.should.eql('An unknown server-side error occurred while processing ' +\n        'the command. Original error: Mishandled Driver Error');\n      data.sessionId.should.eql('foo');\n    });\n\n    describe('w3c sendkeys migration', function () {\n      it('should accept value for sendkeys', async function () {\n        const {data} = await axios({\n          url: `${baseUrl}/session/foo/element/bar/value`,\n          method: 'POST',\n          data: {value: 'text to type'}\n        });\n        data.value.should.eql(['text to type', 'bar']);\n      });\n      it('should accept text for sendkeys', async function () {\n        const {data} = await axios({\n          url: `${baseUrl}/session/foo/element/bar/value`,\n          method: 'POST',\n          data: {text: 'text to type'}\n        });\n        data.value.should.eql(['text to type', 'bar']);\n      });\n      it('should accept value and text for sendkeys, and use value', async function () {\n        const {data} = await axios({\n          url: `${baseUrl}/session/foo/element/bar/value`,\n          method: 'POST',\n          data: {value: 'text to type', text: 'text to ignore'}\n        });\n        data.value.should.eql(['text to type', 'bar']);\n      });\n    });\n\n    describe('multiple sets of arguments', function () {\n      describe('optional', function () {\n        it('should allow moveto with element', async function () {\n          const {data} = await axios({\n            url: `${baseUrl}/session/foo/moveto`,\n            method: 'POST',\n            data: {element: '3'}\n          });\n          data.value.should.eql(['3', null, null]);\n        });\n        it('should allow moveto with xoffset/yoffset', async function () {\n          const {data} = await axios({\n            url: `${baseUrl}/session/foo/moveto`,\n            method: 'POST',\n            data: {xoffset: 42, yoffset: 17}\n          });\n          data.value.should.eql([null, 42, 17]);\n        });\n      });\n      describe('required', function () {\n        it('should allow removeApp with appId', async function () {\n          const {data} = await axios({\n            url: `${baseUrl}/session/foo/appium/device/remove_app`,\n            method: 'POST',\n            data: {appId: 42}\n          });\n          data.value.should.eql(42);\n        });\n        it('should allow removeApp with bundleId', async function () {\n          const {data} = await axios({\n            url: `${baseUrl}/session/foo/appium/device/remove_app`,\n            method: 'POST',\n            data: {bundleId: 42}\n          });\n          data.value.should.eql(42);\n        });\n      });\n    });\n\n    describe('default param wrap', function () {\n      it('should wrap', async function () {\n        const {data} = await axios({\n          url: `${baseUrl}/session/foo/touch/perform`,\n          method: 'POST',\n          data: [{'action': 'tap', 'options': {'element': '3'}}]\n        });\n        data.value.should.deep.equal([[{'action': 'tap', 'options': {'element': '3'}}], 'foo']);\n      });\n\n      it('should not wrap twice', async function () {\n        const {data} = await axios({\n          url: `${baseUrl}/session/foo/touch/perform`,\n          method: 'POST',\n          data: {actions: [{'action': 'tap', 'options': {'element': '3'}}]}\n        });\n        data.value.should.deep.equal([[{'action': 'tap', 'options': {'element': '3'}}], 'foo']);\n      });\n\n    });\n\n    describe('create sessions via HTTP endpoint', function () {\n      let sessionId;\n\n      beforeEach(function () {\n        sessionId = null;\n      });\n      afterEach(async function () {\n        if (sessionId) {\n          await axios.delete(`${baseUrl}/session/${sessionId}`);\n        }\n      });\n\n      it('should not allow create session with desired caps (MJSONWP)', async function () {\n        const desiredCapabilities = {a: 'b'};\n        const {data} = await axios({\n          url: `${baseUrl}/session`,\n          method: 'POST',\n          data: {desiredCapabilities}\n        });\n        should.equal(data.value, null);\n      });\n      it('should fail to create session without capabilities', async function () {\n        await axios({\n          url: `${baseUrl}/session`,\n          method: 'POST',\n          data: {},\n        }).should.eventually.be.rejectedWith(/400/);\n      });\n      it('should allow create session with capabilities (W3C)', async function () {\n        const w3cCapabilities = {alwaysMatch: {'appium:e': 'f'}};\n        const {data} = await axios({\n          url: `${baseUrl}/session`,\n          method: 'POST',\n          data: {capabilities: w3cCapabilities}\n        });\n        should.not.exist(data.status);\n        should.not.exist(data.sessionId);\n        data.value.capabilities.should.eql(w3cCapabilities);\n        data.value.sessionId.should.exist;\n        sessionId = data.value.sessionId;\n      });\n      it('should raise an error if the driver does not support W3C yet', async function () {\n        const createSessionStub = sandbox.stub(driver, 'createSession').callsFake(function (capabilities) {\n          driver.sessionId = null;\n          return BaseDriver.prototype.createSession.call(driver, capabilities);\n        });\n        try {\n          // let {status, value, sessionId} = await request({\n          await axios({\n            url: `${baseUrl}/session`,\n            method: 'POST',\n            data: {\n              capabilities: {\n                alwaysMatch: {\n                  platformName: 'Fake',\n                  'appium:deviceName': 'Fake',\n                },\n                firstMatch: [{}],\n              },\n            }\n          }).should.eventually.be.rejectedWith(/500/);\n        } finally {\n          createSessionStub.restore();\n        }\n      });\n\n      describe('w3c endpoints', function () {\n        let sessionUrl;\n\n        beforeEach(async function () {\n          // Start a W3C session\n          const {value} = (await axios({\n            url: `${baseUrl}/session`,\n            method: 'POST',\n            data: {\n              capabilities: {\n                alwaysMatch: {\n                  platformName: 'Fake',\n                  'appium:deviceName': 'Commodore 64',\n                },\n                firstMatch: [{}],\n              },\n            },\n          })).data;\n          sessionId = value.sessionId;\n          sessionUrl = `${baseUrl}/session/${sessionId}`;\n        });\n\n        it(`should throw 400 Bad Parameters exception if the parameters are bad`, async function () {\n          const {status, data} = await axios({\n            url: `${sessionUrl}/actions`,\n            method: 'POST',\n            validateStatus: null,\n            data: {\n              bad: 'params',\n            }\n          });\n          status.should.equal(400);\n\n          const {error: w3cError, message, stacktrace} = data.value;\n          message.should.match(/Parameters were incorrect/);\n          stacktrace.should.match(/protocol.js/);\n          w3cError.should.be.a.string;\n          w3cError.should.equal(errors.InvalidArgumentError.error());\n        });\n\n        it(`should throw 405 exception if the command hasn't been implemented yet`, async function () {\n          const {status, data} = await axios({\n            url: `${sessionUrl}/actions`,\n            method: 'POST',\n            validateStatus: null,\n            data: {\n              actions: [],\n            },\n          });\n          status.should.equal(405);\n\n          const {error: w3cError, message, stacktrace} = data.value;\n          message.should.match(/Method has not yet been implemented/);\n          stacktrace.should.match(/protocol.js/);\n          w3cError.should.be.a.string;\n          w3cError.should.equal(errors.NotYetImplementedError.error());\n          message.should.match(/Method has not yet been implemented/);\n        });\n\n        it(`should throw 500 Unknown Error if the command throws an unexpected exception`, async function () {\n          driver.performActions = () => { throw new Error(`Didn't work`); };\n          const {status, data} = await axios({\n            url: `${sessionUrl}/actions`,\n            method: 'POST',\n            validateStatus: null,\n            data: {\n              actions: [],\n            }\n          });\n          status.should.equal(500);\n\n          const {error: w3cError, message, stacktrace} = data.value;\n          stacktrace.should.match(/protocol.js/);\n          w3cError.should.be.a.string;\n          w3cError.should.equal(errors.UnknownError.error());\n          message.should.match(/Didn't work/);\n\n          delete driver.performActions;\n        });\n\n        it(`should translate element format from MJSONWP to W3C`, async function () {\n          const retValue = [\n            {\n              something: {\n                [MJSONWP_ELEMENT_KEY]: 'fooo',\n                other: 'bar'\n              }\n            }, {\n              [MJSONWP_ELEMENT_KEY]: 'bar'\n            },\n            'ignore',\n          ];\n\n          const expectedValue = [\n            {\n              something: {\n                [MJSONWP_ELEMENT_KEY]: 'fooo',\n                [W3C_ELEMENT_KEY]: 'fooo',\n                other: 'bar'\n              }\n            }, {\n              [MJSONWP_ELEMENT_KEY]: 'bar',\n              [W3C_ELEMENT_KEY]: 'bar'\n            },\n            'ignore',\n          ];\n\n          const findElementsBackup = driver.findElements;\n          driver.findElements = () => retValue;\n          const {data} = await axios.post(`${sessionUrl}/elements`, {\n            using: 'whatever',\n            value: 'whatever',\n          });\n          data.value.should.eql(expectedValue);\n          driver.findElements = findElementsBackup;\n        });\n\n        it(`should fail with a 408 error if it throws a TimeoutError exception`, async function () {\n          let setUrlStub = sandbox.stub(driver, 'setUrl').callsFake(function () {\n            throw new errors.TimeoutError;\n          });\n          const {status, data} = await axios({\n            url: `${sessionUrl}/url`,\n            method: 'POST',\n            validateStatus: null,\n            data: {\n              url: 'https://example.com/',\n            }\n          });\n          status.should.equal(408);\n\n          const {error: w3cError, message, stacktrace} = data.value;\n          stacktrace.should.match(/protocol.js/);\n          w3cError.should.be.a.string;\n          w3cError.should.equal(errors.TimeoutError.error());\n          message.should.match(/An operation did not complete before its timeout expired/);\n\n          setUrlStub.restore();\n        });\n\n        it(`should pass with 200 HTTP status code if the command returns a value`, async function () {\n          driver.performActions = (actions) => 'It works ' + actions.join('');\n          const {status, value, sessionId} = (await axios.post(`${sessionUrl}/actions`, {\n            actions: ['a', 'b', 'c'],\n          })).data;\n          should.not.exist(sessionId);\n          should.not.exist(status);\n          value.should.equal('It works abc');\n          delete driver.performActions;\n        });\n\n        describe('jwproxy', function () {\n          let port;\n          let server, jwproxy, app;\n\n          before(async function () {\n            port = await getTestPort(true);\n          });\n\n          beforeEach(function () {\n            const res = createProxyServer(sessionId, port);\n            server = res.server;\n            app = res.app;\n            jwproxy = new JWProxy({host: TEST_HOST, port});\n            jwproxy.sessionId = sessionId;\n            driver.performActions = async (actions) => await jwproxy.command('/perform-actions', 'POST', actions);\n          });\n\n          afterEach(async function () {\n            delete driver.performActions;\n            await server.close();\n          });\n\n          it('should work if a proxied request returns a response with status 200', async function () {\n            app.post('/session/:sessionId/perform-actions', (req, res) => {\n              res.json({\n                sessionId: req.params.sessionId,\n                value: req.body,\n                status: 0,\n              });\n            });\n\n            const {status, value, sessionId} = (await axios.post(`${sessionUrl}/actions`, {\n              actions: [1, 2, 3],\n            })).data;\n            value.should.eql([1, 2, 3]);\n            should.not.exist(status);\n            should.not.exist(sessionId);\n          });\n\n          it('should return error if a proxied request returns a MJSONWP error response', async function () {\n            app.post('/session/:sessionId/perform-actions', (req, res) => {\n              res.status(500).json({\n                sessionId,\n                status: 6,\n                value: 'A problem occurred',\n              });\n            });\n            const {status, data} = await axios({\n              url: `${sessionUrl}/actions`,\n              method: 'POST',\n              validateStatus: null,\n              data: {\n                actions: [1, 2, 3],\n              }\n            });\n            status.should.equal(HTTPStatusCodes.NOT_FOUND);\n            JSON.stringify(data).should.match(/A problem occurred/);\n          });\n\n          it('should return W3C error if a proxied request returns a W3C error response', async function () {\n            const error = new Error(`Some error occurred`);\n            error.w3cStatus = 414;\n            const executeCommandStub = sandbox.stub(driver, 'executeCommand').returns({\n              protocol: 'W3C',\n              error,\n            });\n            const {status, data} = await axios({\n              url: `${sessionUrl}/actions`,\n              method: 'POST',\n              validateStatus: null,\n              data: {actions: [1, 2, 3]},\n            });\n            status.should.equal(414);\n            const {error: w3cError, message: errMessage, stacktrace} = data.value;\n            w3cError.should.equal('unknown error');\n            stacktrace.should.match(/Some error occurred/);\n            errMessage.should.equal('Some error occurred');\n            executeCommandStub.restore();\n          });\n\n          it('should return error if a proxied request returns a MJSONWP error response but HTTP status code is 200', async function () {\n            app.post('/session/:sessionId/perform-actions', (req, res) => {\n              res.status(200).json({\n                sessionId: 'Fake Session Id',\n                status: 7,\n                value: 'A problem occurred',\n              });\n            });\n            const {status, data} = await axios({\n              url: `${sessionUrl}/actions`,\n              method: 'POST',\n              validateStatus: null,\n              data: {\n                actions: [1, 2, 3],\n              }\n            });\n            status.should.equal(HTTPStatusCodes.NOT_FOUND);\n            const {error: w3cError, message: errMessage, stacktrace} = data.value;\n            w3cError.should.equal('no such element');\n            errMessage.should.match(/A problem occurred/);\n            stacktrace.should.exist;\n          });\n\n          it('should return error if a proxied request returns a W3C error response', async function () {\n            app.post('/session/:sessionId/perform-actions', (req, res) => {\n              res.status(404).json({\n                value: {\n                  error: 'no such element',\n                  message: 'does not make a difference',\n                  stacktrace: 'arbitrary stacktrace',\n                },\n              });\n            });\n            const {status, data} = await axios({\n              url: `${sessionUrl}/actions`,\n              method: 'POST',\n              validateStatus: null,\n              data: {\n                actions: [1, 2, 3],\n              }\n            });\n            status.should.equal(HTTPStatusCodes.NOT_FOUND);\n            const {error: w3cError, stacktrace} = data.value;\n            w3cError.should.equal('no such element');\n            stacktrace.should.match(/arbitrary stacktrace/);\n          });\n\n          it('should return an error if a proxied request returns a W3C error response', async function () {\n            app.post('/session/:sessionId/perform-actions', (req, res) => {\n              res.set('Connection', 'close');\n              res.status(444).json({\n                value: {\n                  error: 'bogus error code',\n                  message: 'does not make a difference',\n                  stacktrace: 'arbitrary stacktrace',\n                },\n              });\n            });\n            const {status, data} = await axios({\n              url: `${sessionUrl}/actions`,\n              method: 'POST',\n              validateStatus: null,\n              data: {\n                actions: [1, 2, 3],\n              }\n            });\n            status.should.equal(HTTPStatusCodes.INTERNAL_SERVER_ERROR);\n            const {error: w3cError, stacktrace} = data.value;\n            w3cError.should.equal('unknown error');\n            stacktrace.should.match(/arbitrary stacktrace/);\n          });\n\n        });\n      });\n    });\n\n    it('should handle commands with no response values', async function () {\n      const {data} = await axios({\n        url: `${baseUrl}/session/foo/forward`,\n        method: 'POST',\n      });\n      data.should.eql({\n        value: null,\n        sessionId: 'foo'\n      });\n    });\n\n    it('should allow empty string response values', async function () {\n      const {data} = await axios({\n        url: `${baseUrl}/session/foo/element/bar/text`,\n      });\n      data.should.eql({\n        value: '',\n        sessionId: 'foo'\n      });\n    });\n\n    it('should send 500 response and an Unknown object for rejected commands', async function () {\n      const {status, data} = await axios({\n        url: `${baseUrl}/session/foo/refresh`,\n        method: 'POST',\n        validateStatus: null,\n      });\n\n      status.should.equal(500);\n      data.value.error.should.eql('unknown error');\n      data.value.message.should.eql('An unknown server-side error occurred while processing ' +\n        'the command. Original error: Too Fresh!');\n      data.sessionId.should.eql('foo');\n    });\n\n    it('should not throw UnknownError when known', async function () {\n      const {status, data} = await axios({\n        url: `${baseUrl}/session/foo`,\n        validateStatus: null,\n      });\n\n      status.should.equal(404);\n      data.value.error.should.eql('invalid session id');\n      data.value.message.should.eql('A session is either terminated or not started');\n      data.sessionId.should.eql('foo');\n    });\n  });\n\n  describe('session Ids', function () {\n    let driver = new FakeDriver();\n    let mjsonwpServer;\n\n    before(async function () {\n      mjsonwpServer = await server({\n        routeConfiguringFunction: routeConfiguringFunction(driver),\n        port,\n      });\n    });\n\n    after(async function () {\n      await mjsonwpServer.close();\n    });\n\n    afterEach(function () {\n      driver.sessionId = null;\n    });\n\n    it('should return null SessionId for commands without sessionIds', async function () {\n      const {data} = await axios({\n        url: `${baseUrl}/status`,\n      });\n\n      should.equal(data.sessionId, null);\n    });\n\n    it('responds with the same session ID in the request', async function () {\n      let sessionId = 'Vader Sessions';\n      driver.sessionId = sessionId;\n\n      const {data} = await axios({\n        url: `${baseUrl}/session/${sessionId}/url`,\n        method: 'POST',\n        data: {url: 'http://google.com'}\n      });\n\n      should.exist(data.sessionId);\n      data.sessionId.should.eql(sessionId);\n    });\n\n    it('yells if no session exists', async function () {\n      let sessionId = 'Vader Sessions';\n\n      const {data, status} = await axios({\n        url: `${baseUrl}/session/${sessionId}/url`,\n        method: 'POST',\n        validateStatus: null,\n        data: {url: 'http://google.com'},\n      });\n\n      status.should.equal(404);\n      data.value.message.should.contain('session');\n    });\n\n    it('yells if invalid session is sent', async function () {\n      let sessionId = 'Vader Sessions';\n      driver.sessionId = 'recession';\n\n      const {data, status} = await axios({\n        url: `${baseUrl}/session/${sessionId}/url`,\n        method: 'POST',\n        validateStatus: null,\n        data: {url: 'http://google.com'},\n      });\n\n      status.should.equal(404);\n      data.value.message.should.contain('session');\n    });\n\n    it('should have session IDs in error responses', async function () {\n      let sessionId = 'Vader Sessions';\n      driver.sessionId = sessionId;\n\n      const {data, status} = await axios({\n        url: `${baseUrl}/session/${sessionId}/refresh`,\n        method: 'POST',\n        validateStatus: null,\n      });\n\n      status.should.equal(500);\n      data.value.error.should.eql('unknown error');\n      data.value.message.should.eql('An unknown server-side error occurred while processing ' +\n        'the command. Original error: Too Fresh!');\n      data.sessionId.should.eql('Vader Sessions');\n    });\n\n    it('should return a new session ID on create', async function () {\n      const {data} = await axios({\n        url: `${baseUrl}/session`,\n        method: 'POST',\n        data: {capabilities: {alwaysMatch: {'appium:greeting': 'hello'}, firstMatch: [{}]}}\n      });\n\n      should.exist(data.value.sessionId);\n      data.value.sessionId.indexOf('fakeSession_').should.equal(0);\n      data.value.capabilities.should.eql({alwaysMatch: {'appium:greeting': 'hello'}, firstMatch: [{}]});\n    });\n  });\n\n  describe('via drivers jsonwp proxy', function () {\n    let driver;\n    let sessionId = 'foo';\n    let mjsonwpServer;\n\n    beforeEach(async function () {\n      driver = new FakeDriver();\n      driver.sessionId = sessionId;\n      driver.proxyActive = () => true;\n      driver.canProxy = () => true;\n\n      mjsonwpServer = await server({\n        routeConfiguringFunction: routeConfiguringFunction(driver),\n        port,\n        extraMethodMap: FakeDriver.newMethodMap\n      });\n    });\n\n    afterEach(async function () {\n      await mjsonwpServer.close();\n    });\n\n    it('should give a nice error if proxying is set but no proxy function exists', async function () {\n      driver.canProxy = () => false;\n      const {status, data} = await axios({\n        url: `${baseUrl}/session/${sessionId}/url`,\n        method: 'POST',\n        validateStatus: null,\n        data: {url: 'http://google.com'},\n      });\n\n      status.should.equal(500);\n      data.value.error.should.eql('unknown error');\n      data.value.message.should.eql('An unknown server-side error occurred while processing ' +\n        'the command. Original error: Trying to proxy to a ' +\n        'server but the driver is unable to proxy');\n      data.sessionId.should.eql('foo');\n    });\n\n    it('should pass on any errors in proxying', async function () {\n      driver.proxyReqRes = async function () { // eslint-disable-line require-await\n        throw new Error('foo');\n      };\n      const {status, data} = await axios({\n        url: `${baseUrl}/session/${sessionId}/url`,\n        method: 'POST',\n        validateStatus: null,\n        data: {url: 'http://google.com'},\n      });\n\n      status.should.equal(500);\n      data.value.error.should.eql('unknown error');\n      data.value.message.should.eql('An unknown server-side error occurred while processing ' +\n        'the command. Original error: Could not proxy. Proxy error: foo');\n      data.sessionId.should.eql('foo');\n    });\n\n    it('should able to throw ProxyRequestError in proxying', async function () {\n      driver.proxyReqRes = async function () { // eslint-disable-line require-await\n        let jsonwp = {status: 35, value: 'No such context found.', sessionId: 'foo'};\n        throw new errors.ProxyRequestError(`Could not proxy command to remote server. `, jsonwp);\n      };\n      const {status, data} = await axios({\n        url: `${baseUrl}/session/${sessionId}/url`,\n        method: 'POST',\n        validateStatus: null,\n        data: {url: 'http://google.com'},\n      });\n\n      status.should.equal(400);\n      data.value.error.should.eql('unknown error');\n      data.value.message.should.eql('No such context found.');\n      data.sessionId.should.eql('foo');\n    });\n\n    it('should let the proxy handle req/res', async function () {\n      driver.proxyReqRes = async function (req, res) { // eslint-disable-line require-await\n        res.status(200).json({custom: 'data'});\n      };\n      const {status, data} = await axios({\n        url: `${baseUrl}/session/${sessionId}/url`,\n        method: 'POST',\n        data: {url: 'http://google.com'}\n      });\n\n      status.should.equal(200);\n      data.should.eql({custom: 'data'});\n    });\n\n    it('should avoid jsonwp proxying when path matches avoidance list', async function () {\n      driver.getProxyAvoidList = () => [['POST', new RegExp('^/session/[^/]+/url$')]];\n      const {status, data} = await axios({\n        url: `${baseUrl}/session/${sessionId}/url`,\n        method: 'POST',\n        data: {url: 'http://google.com'},\n      });\n\n      status.should.equal(200);\n      data.should.eql({\n        value: 'Navigated to: http://google.com',\n        sessionId\n      });\n    });\n\n    it('should fail if avoid proxy list is malformed in some way', async function () {\n      async function badProxyAvoidanceList (list) {\n        driver.getProxyAvoidList = () => list;\n        const {status, data} = await axios({\n          url: `${baseUrl}/session/${sessionId}/url`,\n          method: 'POST',\n          validateStatus: null,\n          data: {url: 'http://google.com'},\n        });\n\n        status.should.equal(500);\n        data.value.message.should.contain('roxy');\n      }\n      const lists = [\n        'foo',\n        [['foo']],\n        [['BAR', /lol/]],\n        [['GET', 'foo']]\n      ];\n      for (let list of lists) {\n        await badProxyAvoidanceList(list);\n      }\n    });\n\n    it('should avoid proxying non-session commands even if not in the list', async function () {\n      driver.getProxyAvoidList = () => [['POST', new RegExp('')]];\n\n      const {status, data} = await axios({\n        url: `${baseUrl}/status`,\n      });\n\n      status.should.equal(200);\n      data.should.eql({\n        value: \"I'm fine\",\n        sessionId: null\n      });\n    });\n\n    it('should avoid proxying deleteSession commands', async function () {\n      driver.getProxyAvoidList = () => [['POST', new RegExp('')]];\n\n      driver.sessionId.should.equal(sessionId);\n      const {status} = await axios.delete(`${baseUrl}/session/${sessionId}`);\n\n      status.should.equal(200);\n      should.not.exist(driver.sessionId);\n      driver.jwpProxyActive.should.be.false;\n    });\n\n    it('should avoid proxying when command spec specifies neverProxy', async function () {\n      const {status, data} = await axios({\n        url: `${baseUrl}/session/${sessionId}/noproxy`,\n        method: 'GET',\n      });\n\n      status.should.equal(200);\n      data.should.eql({\n        value: 'This was not proxied',\n        sessionId\n      });\n    });\n\n  });\n});\n"]}