@appium/base-driver 8.1.1 → 8.2.2

package/build/test/protocol/protocol-e2e-specs.js

@@ -0,0 +1,1242 @@
+"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 = _interopRequireDefault(require("sinon"));
+
+var _httpStatusCodes = require("http-status-codes");
+
+var _helpers = require("./helpers");
+
+var _constants = require("../../lib/constants");
+
+var _querystring = _interopRequireDefault(require("querystring"));
+
+var _helpers2 = require("../helpers");
+
+let port;
+let baseUrl;
+describe('Protocol', function () {
+  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({
+        status: 0,
+        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({
+        status: 0,
+        value: 'Navigated to: http://google.com',
+        sessionId: 'foo'
+      });
+    });
+    it('should respond to x-www-form-urlencoded as well as json requests', async function () {
+      const {
+        data
+      } = await (0, _axios.default)({
+        url: `${baseUrl}/session/foo/url`,
+        headers: {
+          'Content-Type': 'application/x-www-form-urlencoded'
+        },
+        method: 'POST',
+        data: _querystring.default.stringify({
+          url: 'http://google.com'
+        })
+      });
+      data.should.eql({
+        status: 0,
+        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({
+        status: 0,
+        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.status.should.equal(0);
+      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.status.should.equal(0);
+      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({
+        status: 0,
+        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(501);
+      data.should.eql({
+        status: 405,
+        value: {
+          message: 'Method has not yet been implemented'
+        },
+        sessionId: '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(501);
+      data.should.eql({
+        status: 405,
+        value: {
+          message: 'Method has not yet been implemented'
+        },
+        sessionId: '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.should.eql({
+        status: 13,
+        value: {
+          message: 'An unknown server-side error occurred while processing ' + 'the command. Original error: Mishandled Driver Error'
+        },
+        sessionId: '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.status.should.equal(0);
+        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.status.should.equal(0);
+        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.status.should.equal(0);
+        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.status.should.equal(0);
+          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.status.should.equal(0);
+          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.status.should.equal(0);
+          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.status.should.equal(0);
+          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 = {
+          'appium:e': 'f'
+        };
+        const {
+          data
+        } = await (0, _axios.default)({
+          url: `${baseUrl}/session`,
+          method: 'POST',
+          data: {
+            capabilities: w3cCapabilities
+          }
+        });
+        sessionId = data.sessionId;
+        should.not.exist(data.status);
+        should.not.exist(data.sessionId);
+        data.value.capabilities.should.eql(w3cCapabilities);
+        data.value.sessionId.should.exist;
+      });
+      it('should raise an error if the driver does not support W3C yet', async function () {
+        const createSessionStub = _sinon.default.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 = _sinon.default.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 = _sinon.default.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({
+        status: 0,
+        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({
+        status: 0,
+        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.should.eql({
+        status: 13,
+        value: {
+          message: 'An unknown server-side error occurred while processing ' + 'the command. Original error: Too Fresh!'
+        },
+        sessionId: '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.should.eql({
+        status: 6,
+        value: {
+          message: 'A session is either terminated or not started'
+        },
+        sessionId: '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.status.should.equal(6);
+      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.status.should.equal(6);
+      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.should.eql({
+        status: 13,
+        value: {
+          message: 'An unknown server-side error occurred while processing ' + 'the command. Original error: Too Fresh!'
+        },
+        sessionId
+      });
+    });
+    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.should.eql({
+        status: 13,
+        value: {
+          message: 'An unknown server-side error occurred while processing ' + 'the command. Original error: Trying to proxy to a JSONWP ' + 'server but driver is unable to proxy'
+        },
+        sessionId
+      });
+    });
+    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.should.eql({
+        status: 13,
+        value: {
+          message: 'An unknown server-side error occurred while processing ' + 'the command. Original error: Could not proxy. Proxy ' + 'error: foo'
+        },
+        sessionId
+      });
+    });
+    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(500);
+      data.should.eql({
+        status: 35,
+        value: {
+          message: 'No such context found.'
+        },
+        sessionId: '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({
+        status: 0,
+        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.status.should.equal(13);
+        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({
+        status: 0,
+        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({
+        status: 0,
+        value: 'This was not proxied',
+        sessionId
+      });
+    });
+  });
+});require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["test/protocol/protocol-e2e-specs.js"],"names":["port","baseUrl","describe","before","TEST_HOST","d","FakeDriver","it","setUrl","should","contain","mjsonwpServer","driver","sessionId","routeConfiguringFunction","after","close","data","url","method","eql","status","value","headers","qs","stringify","equal","validateStatus","JSON","eventually","be","rejected","rejectedWith","include","message","id","response","text","element","xoffset","yoffset","appId","bundleId","deep","actions","beforeEach","afterEach","axios","delete","desiredCapabilities","a","w3cCapabilities","capabilities","not","exist","createSessionStub","sinon","stub","callsFake","BaseDriver","prototype","createSession","call","alwaysMatch","platformName","firstMatch","restore","sessionUrl","bad","error","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","set","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 sinon 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 qs from 'querystring';\nimport {TEST_HOST, getTestPort} from '../helpers';\n\nlet port;\nlet baseUrl;\n\ndescribe('Protocol', function () {\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        status: 0,\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        status: 0,\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 {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: qs.stringify({\n          url: 'http://google.com',\n        }),\n      });\n      data.should.eql({\n        status: 0,\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        status: 0,\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.status.should.equal(0);\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.status.should.equal(0);\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        status: 0,\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(501);\n      data.should.eql({\n        status: 405,\n        value: {\n          message: 'Method has not yet been implemented'\n        },\n        sessionId: 'foo'\n      });\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(501);\n      data.should.eql({\n        status: 405,\n        value: {\n          message: 'Method has not yet been implemented'\n        },\n        sessionId: 'foo'\n      });\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.should.eql({\n        status: 13,\n        value: {\n          message: 'An unknown server-side error occurred while processing ' +\n                   'the command. Original error: Mishandled Driver Error'\n        },\n        sessionId: 'foo'\n      });\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.status.should.equal(0);\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.status.should.equal(0);\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.status.should.equal(0);\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.status.should.equal(0);\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.status.should.equal(0);\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.status.should.equal(0);\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.status.should.equal(0);\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 = {'appium:e': 'f'};\n        const {data} = await axios({\n          url: `${baseUrl}/session`,\n          method: 'POST',\n          data: {capabilities: w3cCapabilities}\n        });\n        sessionId = data.sessionId;\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      });\n      it('should raise an error if the driver does not support W3C yet', async function () {\n        const createSessionStub = sinon.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 = sinon.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 = sinon.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        status: 0,\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        status: 0,\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.should.eql({\n        status: 13,\n        value: {\n          message: 'An unknown server-side error occurred while processing ' +\n                   'the command. Original error: Too Fresh!'\n        },\n        sessionId: 'foo'\n      });\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.should.eql({\n        status: 6,\n        value: {\n          message: 'A session is either terminated or not started'\n        },\n        sessionId: 'foo'\n      });\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.status.should.equal(6);\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.status.should.equal(6);\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.should.eql({\n        status: 13,\n        value: {\n          message: 'An unknown server-side error occurred while processing ' +\n                   'the command. Original error: Too Fresh!'\n        },\n        sessionId\n      });\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.should.eql({\n        status: 13,\n        value: {\n          message: 'An unknown server-side error occurred while processing ' +\n                   'the command. Original error: Trying to proxy to a JSONWP ' +\n                   'server but driver is unable to proxy'\n        },\n        sessionId\n      });\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.should.eql({\n        status: 13,\n        value: {\n          message: 'An unknown server-side error occurred while processing ' +\n                   'the command. Original error: Could not proxy. Proxy ' +\n                   'error: foo'\n        },\n        sessionId\n      });\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(500);\n      data.should.eql({\n        status: 35,\n        value: {\n          message: 'No such context found.'\n        },\n        sessionId: 'foo'\n      });\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        status: 0,\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.status.should.equal(13);\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        status: 0,\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        status: 0,\n        value: 'This was not proxied',\n        sessionId\n      });\n    });\n\n  });\n});\n"],"file":"test/protocol/protocol-e2e-specs.js","sourceRoot":"../../.."}