@appium/base-driver 8.3.0 → 8.4.1

package/build/test/unit/protocol/errors.spec.js

@@ -0,0 +1,390 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("source-map-support/register");
+
+var _lib = require("../../../lib");
+
+var _errors = require("../../../lib/protocol/errors");
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _httpStatusCodes = require("http-status-codes");
+
+var _path = _interopRequireDefault(require("path"));
+
+const basename = _path.default.basename(__filename);
+
+let errorsList = [{
+  errorName: 'NoSuchDriverError',
+  errorMsg: 'A session is either terminated or not started',
+  error: 'invalid session id',
+  errorCode: 6
+}, {
+  errorName: 'ElementClickInterceptedError',
+  errorMsg: 'The Element Click command could not be completed because the element receiving the events is obscuring the element that was requested clicked',
+  error: 'element click intercepted'
+}, {
+  errorName: 'ElementNotInteractableError',
+  errorMsg: 'A command could not be completed because the element is not pointer- or keyboard interactable',
+  error: 'element not interactable'
+}, {
+  errorName: 'InsecureCertificateError',
+  errorMsg: 'Navigation caused the user agent to hit a certificate warning, which is usually the result of an expired or invalid TLS certificate',
+  error: 'insecure certificate'
+}, {
+  errorName: 'InvalidArgumentError',
+  errorMsg: 'The arguments passed to the command are either invalid or malformed',
+  error: 'invalid argument'
+}, {
+  errorName: 'NoSuchElementError',
+  errorMsg: 'An element could not be located on the page using the ' + 'given search parameters.',
+  error: 'no such element',
+  errorCode: 7
+}, {
+  errorName: 'NoSuchFrameError',
+  errorMsg: 'A request to switch to a frame could not be satisfied ' + 'because the frame could not be found.',
+  error: 'no such frame',
+  errorCode: 8
+}, {
+  errorName: 'UnknownCommandError',
+  errorMsg: 'The requested resource could not be found, or a request ' + 'was received using an HTTP method that is not supported by ' + 'the mapped resource.',
+  error: 'unknown command',
+  errorCode: 9
+}, {
+  errorName: 'StaleElementReferenceError',
+  errorMsg: 'An element command failed because the referenced element is ' + 'no longer attached to the DOM.',
+  error: 'stale element reference',
+  errorCode: 10
+}, {
+  errorName: 'ElementNotVisibleError',
+  errorMsg: 'An element command could not be completed because the ' + 'element is not visible on the page.',
+  errorCode: 11
+}, {
+  errorName: 'InvalidElementStateError',
+  errorMsg: 'An element command could not be completed because the element ' + 'is in an invalid state (e.g. attempting to click a disabled ' + 'element).',
+  error: 'invalid element state',
+  errorCode: 12
+}, {
+  errorName: 'UnknownError',
+  errorMsg: 'An unknown server-side error occurred while processing the ' + 'command.',
+  error: 'unknown error',
+  errorCode: 13
+}, {
+  errorName: 'ElementIsNotSelectableError',
+  errorMsg: 'An attempt was made to select an element that cannot ' + 'be selected.',
+  error: 'element not selectable',
+  errorCode: 15
+}, {
+  errorName: 'JavaScriptError',
+  errorMsg: 'An error occurred while executing user supplied JavaScript.',
+  error: 'javascript error',
+  errorCode: 17
+}, {
+  errorName: 'XPathLookupError',
+  errorMsg: 'An error occurred while searching for an element by XPath.',
+  errorCode: 19
+}, {
+  errorName: 'TimeoutError',
+  errorMsg: 'An operation did not complete before its timeout expired.',
+  error: 'timeout',
+  errorCode: 21
+}, {
+  errorName: 'NoSuchWindowError',
+  errorMsg: 'A request to switch to a different window could not be ' + 'satisfied because the window could not be found.',
+  error: 'no such window',
+  errorCode: 23
+}, {
+  errorName: 'InvalidCookieDomainError',
+  errorMsg: 'An illegal attempt was made to set a cookie under a different ' + 'domain than the current page.',
+  error: 'invalid cookie domain',
+  errorCode: 24
+}, {
+  errorName: 'InvalidCoordinatesError',
+  errorMsg: 'The coordinates provided to an interactions operation are invalid.',
+  error: 'invalid coordinates'
+}, {
+  errorName: 'UnableToSetCookieError',
+  errorMsg: `A request to set a cookie's value could not be satisfied.`,
+  error: 'unable to set cookie',
+  errorCode: 25
+}, {
+  errorName: 'UnexpectedAlertOpenError',
+  errorMsg: 'A modal dialog was open, blocking this operation',
+  error: 'unexpected alert open',
+  errorCode: 26
+}, {
+  errorName: 'NoAlertOpenError',
+  errorMsg: 'An attempt was made to operate on a modal dialog when one was ' + 'not open.',
+  errorCode: 27
+}, {
+  errorName: 'ScriptTimeoutError',
+  errorMsg: 'A script did not complete before its timeout expired.',
+  error: 'script timeout',
+  errorCode: 28
+}, {
+  errorName: 'InvalidElementCoordinatesError',
+  errorMsg: 'The coordinates provided to an interactions operation are ' + 'invalid.',
+  errorCode: 29
+}, {
+  errorName: 'IMENotAvailableError',
+  errorMsg: 'IME was not available.',
+  errorCode: 30
+}, {
+  errorName: 'IMEEngineActivationFailedError',
+  errorMsg: 'An IME engine could not be started.',
+  errorCode: 31
+}, {
+  errorName: 'InvalidSelectorError',
+  errorMsg: 'Argument was an invalid selector (e.g. XPath/CSS).',
+  error: 'invalid selector',
+  errorCode: 32
+}, {
+  errorName: 'SessionNotCreatedError',
+  errorMsg: 'A new session could not be created.',
+  error: 'session not created',
+  errorCode: 33
+}, {
+  errorName: 'MoveTargetOutOfBoundsError',
+  errorMsg: 'Target provided for a move action is out of bounds.',
+  error: 'move target out of bounds',
+  errorCode: 34
+}, {
+  errorName: 'NoSuchAlertError',
+  errorMsg: 'An attempt was made to operate on a modal dialog when one was not open.',
+  error: 'no such alert'
+}, {
+  errorName: 'NoSuchCookieError',
+  errorMsg: 'No cookie matching the given path name was found amongst the associated cookies of the current browsing context’s active document',
+  error: 'no such cookie'
+}, {
+  errorName: 'NotYetImplementedError',
+  errorMsg: 'Method has not yet been implemented',
+  error: 'unknown method',
+  errorCode: 405
+}, {
+  errorName: 'UnknownCommandError',
+  errorMsg: 'The requested resource could not be found, or a request was received using an HTTP method that is not supported by the mapped resource.',
+  error: 'unknown command'
+}, {
+  errorName: 'UnknownMethodError',
+  errorMsg: 'The requested command matched a known URL but did not match an method for that URL',
+  error: 'unknown method'
+}, {
+  errorName: 'UnsupportedOperationError',
+  errorMsg: 'A server-side error occurred. Command cannot be supported.',
+  error: 'unsupported operation'
+}];
+describe('errors', function () {
+  for (let error of errorsList) {
+    it(error.errorName + ' should have a JSONWP code or W3C code and message', function () {
+      if (error.errorCode) {
+        new _lib.errors[error.errorName]().should.have.property('jsonwpCode', error.errorCode);
+      } else {
+        new _lib.errors[error.errorName]().should.have.property('error', error.error);
+      }
+
+      new _lib.errors[error.errorName]().should.have.property('message', error.errorMsg);
+    });
+  }
+
+  it('BadParametersError should not have code and should have messg', function () {
+    new _lib.errors.BadParametersError().should.not.have.property('jsonwpCode');
+    new _lib.errors.BadParametersError().should.have.property('message');
+  });
+  it('ProxyRequestError should have message and jsonwp', function () {
+    new _lib.errors.ProxyRequestError().should.have.property('jsonwp');
+    new _lib.errors.ProxyRequestError().should.have.property('message');
+  });
+});
+describe('errorFromMJSONWPStatusCode', function () {
+  for (let error of errorsList) {
+    if (error.errorName !== 'NotYetImplementedError') {
+      it(error.errorCode + ' should return correct error', function () {
+        if (error.errorCode) {
+          (0, _lib.errorFromMJSONWPStatusCode)(error.errorCode).should.have.property('jsonwpCode', error.errorCode);
+          (0, _lib.errorFromMJSONWPStatusCode)(error.errorCode).should.have.property('message', error.errorMsg);
+
+          if (!_lodash.default.includes([13, 33], error.errorCode)) {
+            (0, _lib.errorFromMJSONWPStatusCode)(error.errorCode, 'abcd').should.have.property('jsonwpCode', error.errorCode);
+            (0, _lib.errorFromMJSONWPStatusCode)(error.errorCode, 'abcd').should.have.property('message', 'abcd');
+          }
+        } else {
+          (0, _lib.isErrorType)((0, _lib.errorFromMJSONWPStatusCode)(error.errorCode), _lib.errors.UnknownError).should.be.true;
+        }
+      });
+    }
+  }
+
+  it('should throw unknown error for unknown code', function () {
+    (0, _lib.errorFromMJSONWPStatusCode)(99).should.have.property('jsonwpCode', 13);
+    (0, _lib.errorFromMJSONWPStatusCode)(99).should.have.property('message', 'An unknown server-side error occurred ' + 'while processing the command.');
+  });
+});
+describe('errorFromW3CJsonCode', function () {
+  for (let error of errorsList) {
+    if (error.errorName !== 'NotYetImplementedError') {
+      it(error.errorName + ' should return correct error', function () {
+        const {
+          error: w3cError
+        } = error;
+
+        if (w3cError) {
+          (0, _lib.errorFromW3CJsonCode)(w3cError).error.should.equal(error.error);
+          (0, _lib.errorFromW3CJsonCode)(w3cError).should.have.property('message', error.errorMsg);
+        } else {
+          (0, _lib.isErrorType)((0, _lib.errorFromW3CJsonCode)(w3cError), _lib.errors.UnknownError).should.be.true;
+        }
+      });
+    }
+  }
+
+  it('should parse unknown errors', function () {
+    (0, _lib.isErrorType)((0, _lib.errorFromW3CJsonCode)('not a real error code'), _lib.errors.UnknownError).should.be.true;
+    (0, _lib.errorFromW3CJsonCode)('not a real error code').message.should.match(/An unknown server-side error occurred/);
+    (0, _lib.errorFromW3CJsonCode)('not a real error code').error.should.equal('unknown error');
+  });
+});
+describe('w3c Status Codes', function () {
+  it('should match the correct error codes', function () {
+    let non400Errors = [['NoSuchDriverError', 404], ['NoSuchFrameError', 404], ['NoAlertOpenError', 404], ['NoSuchWindowError', 404], ['StaleElementReferenceError', 404], ['JavaScriptError', 500], ['MoveTargetOutOfBoundsError', 500], ['NoSuchCookieError', 404], ['NoSuchElementError', 404], ['ScriptTimeoutError', 408], ['SessionNotCreatedError', 500], ['TimeoutError', 408], ['UnableToSetCookieError', 500], ['UnableToCaptureScreen', 500], ['UnexpectedAlertOpenError', 500], ['UnknownCommandError', 404], ['UnknownError', 500], ['UnknownMethodError', 405], ['UnsupportedOperationError', 500]];
+
+    for (let [errorName, expectedErrorCode] of non400Errors) {
+      _lib.errors[errorName].should.exist;
+      new _lib.errors[errorName]().should.have.property('w3cStatus', expectedErrorCode);
+    }
+
+    new _lib.errors.ElementClickInterceptedError().should.have.property('w3cStatus', 400);
+  });
+});
+describe('.getResponseForW3CError', function () {
+  it('should return an error, message and stacktrace for just a generic exception', function () {
+    try {
+      throw new Error('Some random error');
+    } catch (e) {
+      const [httpStatus, httpResponseBody] = (0, _errors.getResponseForW3CError)(e);
+      httpStatus.should.equal(500);
+      const {
+        error,
+        message,
+        stacktrace
+      } = httpResponseBody.value;
+      message.should.match(/Some random error/);
+      error.should.equal('unknown error');
+      stacktrace.should.match(/at getResponseForW3CError/);
+      stacktrace.should.match(/Some random error/);
+      stacktrace.should.contain(basename);
+    }
+  });
+  it('should return an error, message and stacktrace for a NoSuchElementError', function () {
+    const noSuchElementError = new _lib.errors.NoSuchElementError('specific error message');
+    const [httpStatus, httpResponseBody] = (0, _errors.getResponseForW3CError)(noSuchElementError);
+    httpStatus.should.equal(404);
+    const {
+      error,
+      message,
+      stacktrace
+    } = httpResponseBody.value;
+    error.should.equal('no such element');
+    message.should.match(/specific error message/);
+    stacktrace.should.contain(basename);
+  });
+  it('should handle BadParametersError', function () {
+    const badParamsError = new _lib.errors.BadParametersError('__FOO__', '__BAR__', '__HELLO_WORLD__');
+    const [httpStatus, httpResponseBody] = (0, _errors.getResponseForW3CError)(badParamsError);
+    httpStatus.should.equal(400);
+    const {
+      error,
+      message,
+      stacktrace
+    } = httpResponseBody.value;
+    error.should.equal('invalid argument');
+    message.should.match(/__BAR__/);
+    message.should.match(/__HELLO_WORLD__/);
+    stacktrace.should.contain(basename);
+  });
+  it('should translate JSONWP errors', function () {
+    const [httpStatus, httpResponseBody] = (0, _errors.getResponseForW3CError)({
+      status: 7,
+      value: 'My custom message',
+      sessionId: 'Fake Session Id'
+    });
+    httpStatus.should.equal(404);
+    const {
+      error,
+      message,
+      stacktrace
+    } = httpResponseBody.value;
+    message.should.equal('My custom message');
+    error.should.equal('no such element');
+    stacktrace.should.exist;
+  });
+});
+describe('.getActualError', function () {
+  describe('MJSONWP', function () {
+    it('should map a status code 7 no such element error as a NoSuchElementError', function () {
+      const actualError = new _lib.errors.ProxyRequestError('Error message does not matter', {
+        value: 'does not matter',
+        status: 7
+      }).getActualError();
+      (0, _lib.isErrorType)(actualError, _lib.errors.NoSuchElementError).should.be.true;
+    });
+    it('should map a status code 10, StaleElementReferenceError', function () {
+      const actualError = new _lib.errors.ProxyRequestError('Error message does not matter', {
+        value: 'Does not matter',
+        status: 10
+      }).getActualError();
+      (0, _lib.isErrorType)(actualError, _lib.errors.StaleElementReferenceError).should.be.true;
+    });
+    it('should map an unknown error to UnknownError', function () {
+      const actualError = new _lib.errors.ProxyRequestError('Error message does not matter', {
+        value: 'Does not matter',
+        status: -100
+      }).getActualError();
+      (0, _lib.isErrorType)(actualError, _lib.errors.UnknownError).should.be.true;
+    });
+    it('should parse a JSON string', function () {
+      const actualError = new _lib.errors.ProxyRequestError('Error message does not matter', JSON.stringify({
+        value: 'Does not matter',
+        status: -100
+      })).getActualError();
+      (0, _lib.isErrorType)(actualError, _lib.errors.UnknownError).should.be.true;
+    });
+  });
+  describe('W3C', function () {
+    it('should map a 404 no such element error as a NoSuchElementError', function () {
+      const actualError = new _lib.errors.ProxyRequestError('Error message does not matter', {
+        value: {
+          error: _lib.errors.NoSuchElementError.error()
+        }
+      }, _httpStatusCodes.StatusCodes.NOT_FOUND).getActualError();
+      (0, _lib.isErrorType)(actualError, _lib.errors.NoSuchElementError).should.be.true;
+    });
+    it('should map a 400 StaleElementReferenceError', function () {
+      const actualError = new _lib.errors.ProxyRequestError('Error message does not matter', {
+        value: {
+          error: _lib.errors.StaleElementReferenceError.error()
+        }
+      }, _httpStatusCodes.StatusCodes.BAD_REQUEST).getActualError();
+      (0, _lib.isErrorType)(actualError, _lib.errors.StaleElementReferenceError).should.be.true;
+    });
+    it('should map an unknown error to UnknownError', function () {
+      const actualError = new _lib.errors.ProxyRequestError('Error message does not matter', null, {
+        value: {
+          error: 'Not a valid w3c JSON code'
+        }
+      }, 456).getActualError();
+      (0, _lib.isErrorType)(actualError, _lib.errors.UnknownError).should.be.true;
+    });
+    it('should parse a JSON string', function () {
+      const actualError = new _lib.errors.ProxyRequestError('Error message does not matter', JSON.stringify({
+        value: {
+          error: _lib.errors.StaleElementReferenceError.error()
+        }
+      }), _httpStatusCodes.StatusCodes.BAD_REQUEST).getActualError();
+      (0, _lib.isErrorType)(actualError, _lib.errors.StaleElementReferenceError).should.be.true;
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../test/unit/protocol/errors.spec.js"],"names":["basename","path","__filename","errorsList","errorName","errorMsg","error","errorCode","describe","it","errors","should","have","property","BadParametersError","not","ProxyRequestError","_","includes","UnknownError","be","true","w3cError","equal","message","match","non400Errors","expectedErrorCode","exist","ElementClickInterceptedError","Error","e","httpStatus","httpResponseBody","stacktrace","value","contain","noSuchElementError","NoSuchElementError","badParamsError","status","sessionId","actualError","getActualError","StaleElementReferenceError","JSON","stringify","HTTPStatusCodes","NOT_FOUND","BAD_REQUEST"],"mappings":"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","sourcesContent":["import {\n  errors, errorFromMJSONWPStatusCode, errorFromW3CJsonCode, isErrorType\n} from '../../../lib';\nimport { getResponseForW3CError } from '../../../lib/protocol/errors';\nimport _ from 'lodash';\nimport { StatusCodes as HTTPStatusCodes } from 'http-status-codes';\nimport path from 'path';\n\nconst basename = path.basename(__filename);\n\n\n// Error codes and messages have been added according to JsonWireProtocol see\n// https://code.google.com/p/selenium/wiki/JsonWireProtocol#Response_Status_Codes\nlet errorsList = [\n  {\n    errorName: 'NoSuchDriverError',\n    errorMsg: 'A session is either terminated or not started',\n    error: 'invalid session id',\n    errorCode: 6\n  },\n  {\n    errorName: 'ElementClickInterceptedError',\n    errorMsg: 'The Element Click command could not be completed because the element receiving the events is obscuring the element that was requested clicked',\n    error: 'element click intercepted',\n  },\n  {\n    errorName: 'ElementNotInteractableError',\n    errorMsg: 'A command could not be completed because the element is not pointer- or keyboard interactable',\n    error: 'element not interactable',\n  },\n  {\n    errorName: 'InsecureCertificateError',\n    errorMsg: 'Navigation caused the user agent to hit a certificate warning, which is usually the result of an expired or invalid TLS certificate',\n    error: 'insecure certificate',\n  },\n  {\n    errorName: 'InvalidArgumentError',\n    errorMsg: 'The arguments passed to the command are either invalid or malformed',\n    error: 'invalid argument',\n  },\n  {\n    errorName: 'NoSuchElementError',\n    errorMsg: 'An element could not be located on the page using the ' +\n        'given search parameters.',\n    error: 'no such element',\n    errorCode: 7\n  },\n  {\n    errorName: 'NoSuchFrameError',\n    errorMsg: 'A request to switch to a frame could not be satisfied ' +\n        'because the frame could not be found.',\n    error: 'no such frame',\n    errorCode: 8\n  },\n  {\n    errorName: 'UnknownCommandError',\n    errorMsg: 'The requested resource could not be found, or a request ' +\n        'was received using an HTTP method that is not supported by ' +\n        'the mapped resource.',\n    error: 'unknown command',\n    errorCode: 9\n  },\n  {\n    errorName: 'StaleElementReferenceError',\n    errorMsg: 'An element command failed because the referenced element is ' +\n        'no longer attached to the DOM.',\n    error: 'stale element reference',\n    errorCode: 10\n  },\n  {\n    errorName: 'ElementNotVisibleError',\n    errorMsg: 'An element command could not be completed because the ' +\n        'element is not visible on the page.',\n    errorCode: 11\n  },\n  {\n    errorName: 'InvalidElementStateError',\n    errorMsg: 'An element command could not be completed because the element ' +\n        'is in an invalid state (e.g. attempting to click a disabled ' +\n        'element).',\n    error: 'invalid element state',\n    errorCode: 12\n  },\n  {\n    errorName: 'UnknownError',\n    errorMsg: 'An unknown server-side error occurred while processing the ' +\n        'command.',\n    error: 'unknown error',\n    errorCode: 13\n  },\n  {\n    errorName: 'ElementIsNotSelectableError',\n    errorMsg: 'An attempt was made to select an element that cannot ' +\n        'be selected.',\n    error: 'element not selectable',\n    errorCode: 15\n  },\n  {\n    errorName: 'JavaScriptError',\n    errorMsg: 'An error occurred while executing user supplied JavaScript.',\n    error: 'javascript error',\n    errorCode: 17\n  },\n  {\n    errorName: 'XPathLookupError',\n    errorMsg: 'An error occurred while searching for an element by XPath.',\n    errorCode: 19\n  },\n  {\n    errorName: 'TimeoutError',\n    errorMsg: 'An operation did not complete before its timeout expired.',\n    error: 'timeout',\n    errorCode: 21\n  },\n  {\n    errorName: 'NoSuchWindowError',\n    errorMsg: 'A request to switch to a different window could not be ' +\n        'satisfied because the window could not be found.',\n    error: 'no such window',\n    errorCode: 23\n  },\n  {\n    errorName: 'InvalidCookieDomainError',\n    errorMsg: 'An illegal attempt was made to set a cookie under a different ' +\n        'domain than the current page.',\n    error: 'invalid cookie domain',\n    errorCode: 24\n  },\n  {\n    errorName: 'InvalidCoordinatesError',\n    errorMsg: 'The coordinates provided to an interactions operation are invalid.',\n    error: 'invalid coordinates',\n  },\n  {\n    errorName: 'UnableToSetCookieError',\n    errorMsg: `A request to set a cookie's value could not be satisfied.`,\n    error: 'unable to set cookie',\n    errorCode: 25\n  },\n  {\n    errorName: 'UnexpectedAlertOpenError',\n    errorMsg: 'A modal dialog was open, blocking this operation',\n    error: 'unexpected alert open',\n    errorCode: 26\n  },\n  {\n    errorName: 'NoAlertOpenError',\n    errorMsg: 'An attempt was made to operate on a modal dialog when one was ' +\n        'not open.',\n    errorCode: 27\n  },\n  {\n    errorName: 'ScriptTimeoutError',\n    errorMsg: 'A script did not complete before its timeout expired.',\n    error: 'script timeout',\n    errorCode: 28\n  },\n  {\n    errorName: 'InvalidElementCoordinatesError',\n    errorMsg: 'The coordinates provided to an interactions operation are ' +\n        'invalid.',\n    errorCode: 29\n  },\n  {\n    errorName: 'IMENotAvailableError',\n    errorMsg: 'IME was not available.',\n    errorCode: 30\n  },\n  {\n    errorName: 'IMEEngineActivationFailedError',\n    errorMsg: 'An IME engine could not be started.',\n    errorCode: 31\n  },\n  {\n    errorName: 'InvalidSelectorError',\n    errorMsg: 'Argument was an invalid selector (e.g. XPath/CSS).',\n    error: 'invalid selector',\n    errorCode: 32\n  },\n  {\n    errorName: 'SessionNotCreatedError',\n    errorMsg: 'A new session could not be created.',\n    error: 'session not created',\n    errorCode: 33\n  },\n  {\n    errorName: 'MoveTargetOutOfBoundsError',\n    errorMsg: 'Target provided for a move action is out of bounds.',\n    error: 'move target out of bounds',\n    errorCode: 34\n  },\n  {\n    errorName: 'NoSuchAlertError',\n    errorMsg: 'An attempt was made to operate on a modal dialog when one was not open.',\n    error: 'no such alert',\n  },\n  {\n    errorName: 'NoSuchCookieError',\n    errorMsg: 'No cookie matching the given path name was found amongst the associated cookies of the current browsing context’s active document',\n    error: 'no such cookie',\n  },\n  {\n    errorName: 'NotYetImplementedError',\n    errorMsg: 'Method has not yet been implemented',\n    error: 'unknown method',\n    errorCode: 405\n  },\n  {\n    errorName: 'UnknownCommandError',\n    errorMsg: 'The requested resource could not be found, or a request was received using an HTTP method that is not supported by the mapped resource.',\n    error: 'unknown command',\n  },\n  {\n    errorName: 'UnknownMethodError',\n    errorMsg: 'The requested command matched a known URL but did not match an method for that URL',\n    error: 'unknown method',\n  },\n  {\n    errorName: 'UnsupportedOperationError',\n    errorMsg: 'A server-side error occurred. Command cannot be supported.',\n    error: 'unsupported operation',\n  },\n];\n\ndescribe('errors', function () {\n  for (let error of errorsList) {\n    it(error.errorName + ' should have a JSONWP code or W3C code and message', function () {\n      if (error.errorCode) {\n        new errors[error.errorName]()\n          .should.have.property('jsonwpCode', error.errorCode);\n      } else {\n        new errors[error.errorName]()\n          .should.have.property('error', error.error);\n      }\n      new errors[error.errorName]()\n        .should.have.property('message', error.errorMsg);\n    });\n  }\n  it('BadParametersError should not have code and should have messg', function () {\n    new errors.BadParametersError()\n      .should.not.have.property('jsonwpCode');\n    new errors.BadParametersError()\n      .should.have.property('message');\n  });\n  it('ProxyRequestError should have message and jsonwp', function () {\n    new errors.ProxyRequestError()\n        .should.have.property('jsonwp');\n    new errors.ProxyRequestError()\n        .should.have.property('message');\n  });\n});\ndescribe('errorFromMJSONWPStatusCode', function () {\n  for (let error of errorsList) {\n    if (error.errorName !== 'NotYetImplementedError') {\n      it(error.errorCode + ' should return correct error', function () {\n        if (error.errorCode) {\n          errorFromMJSONWPStatusCode(error.errorCode)\n            .should.have.property('jsonwpCode', error.errorCode);\n          errorFromMJSONWPStatusCode(error.errorCode)\n            .should.have.property('message', error.errorMsg);\n          if (!_.includes([13, 33], error.errorCode)) {\n            errorFromMJSONWPStatusCode(error.errorCode, 'abcd')\n              .should.have.property('jsonwpCode', error.errorCode);\n            errorFromMJSONWPStatusCode(error.errorCode, 'abcd')\n              .should.have.property('message', 'abcd');\n          }\n        } else {\n          isErrorType(errorFromMJSONWPStatusCode(error.errorCode), errors.UnknownError).should.be.true;\n        }\n      });\n    }\n  }\n  it('should throw unknown error for unknown code', function () {\n    errorFromMJSONWPStatusCode(99)\n      .should.have.property('jsonwpCode', 13);\n    errorFromMJSONWPStatusCode(99)\n      .should.have.property('message', 'An unknown server-side error occurred ' +\n                                       'while processing the command.');\n  });\n});\ndescribe('errorFromW3CJsonCode', function () {\n  for (let error of errorsList) {\n    if (error.errorName !== 'NotYetImplementedError') {\n      it(error.errorName + ' should return correct error', function () {\n        const {error: w3cError} = error;\n        if (w3cError) {\n          errorFromW3CJsonCode(w3cError).error.should.equal(error.error);\n          errorFromW3CJsonCode(w3cError).should.have.property('message', error.errorMsg);\n        } else {\n          isErrorType(errorFromW3CJsonCode(w3cError), errors.UnknownError).should.be.true;\n        }\n      });\n    }\n  }\n  it('should parse unknown errors', function () {\n    isErrorType(errorFromW3CJsonCode('not a real error code'), errors.UnknownError).should.be.true;\n    errorFromW3CJsonCode('not a real error code').message.should.match(/An unknown server-side error occurred/);\n    errorFromW3CJsonCode('not a real error code').error.should.equal('unknown error');\n  });\n});\ndescribe('w3c Status Codes', function () {\n  it('should match the correct error codes', function () {\n    let non400Errors = [\n      ['NoSuchDriverError', 404],\n      ['NoSuchFrameError', 404],\n      ['NoAlertOpenError', 404],\n      ['NoSuchWindowError', 404],\n      ['StaleElementReferenceError', 404],\n      ['JavaScriptError', 500],\n      ['MoveTargetOutOfBoundsError', 500],\n      ['NoSuchCookieError', 404],\n      ['NoSuchElementError', 404],\n      ['ScriptTimeoutError', 408],\n      ['SessionNotCreatedError', 500],\n      ['TimeoutError', 408],\n      ['UnableToSetCookieError', 500],\n      ['UnableToCaptureScreen', 500],\n      ['UnexpectedAlertOpenError', 500],\n      ['UnknownCommandError', 404],\n      ['UnknownError', 500],\n      ['UnknownMethodError', 405],\n      ['UnsupportedOperationError', 500],\n    ];\n\n    // Test the errors that we don't expect to return 400 code\n    for (let [errorName, expectedErrorCode] of non400Errors) {\n      errors[errorName].should.exist;\n      (new errors[errorName]()).should.have.property('w3cStatus', expectedErrorCode);\n    }\n\n    // Test an error that we expect to return 400 code\n    (new errors.ElementClickInterceptedError()).should.have.property('w3cStatus', 400);\n  });\n});\ndescribe('.getResponseForW3CError', function () {\n  it('should return an error, message and stacktrace for just a generic exception', function () {\n    try {\n      throw new Error('Some random error');\n    } catch (e) {\n      const [httpStatus, httpResponseBody] = getResponseForW3CError(e);\n      httpStatus.should.equal(500);\n      const {error, message, stacktrace} = httpResponseBody.value;\n      message.should.match(/Some random error/);\n      error.should.equal('unknown error');\n      stacktrace.should.match(/at getResponseForW3CError/);\n      stacktrace.should.match(/Some random error/);\n      stacktrace.should.contain(basename);\n    }\n  });\n  it('should return an error, message and stacktrace for a NoSuchElementError', function () {\n    const noSuchElementError = new errors.NoSuchElementError('specific error message');\n    const [httpStatus, httpResponseBody] = getResponseForW3CError(noSuchElementError);\n    httpStatus.should.equal(404);\n    const {error, message, stacktrace} = httpResponseBody.value;\n    error.should.equal('no such element');\n    message.should.match(/specific error message/);\n    stacktrace.should.contain(basename);\n  });\n  it('should handle BadParametersError', function () {\n    const badParamsError = new errors.BadParametersError('__FOO__', '__BAR__', '__HELLO_WORLD__');\n    const [httpStatus, httpResponseBody] = getResponseForW3CError(badParamsError);\n    httpStatus.should.equal(400);\n    const {error, message, stacktrace} = httpResponseBody.value;\n    error.should.equal('invalid argument');\n    message.should.match(/__BAR__/);\n    message.should.match(/__HELLO_WORLD__/);\n    stacktrace.should.contain(basename);\n  });\n  it('should translate JSONWP errors', function () {\n    const [httpStatus, httpResponseBody] = getResponseForW3CError({\n      status: 7,\n      value: 'My custom message',\n      sessionId: 'Fake Session Id',\n    });\n    httpStatus.should.equal(404);\n    const {error, message, stacktrace} = httpResponseBody.value;\n    message.should.equal('My custom message');\n    error.should.equal('no such element');\n    stacktrace.should.exist;\n  });\n});\ndescribe('.getActualError', function () {\n  describe('MJSONWP', function () {\n    it('should map a status code 7 no such element error as a NoSuchElementError', function () {\n      const actualError = new errors.ProxyRequestError('Error message does not matter', {\n        value: 'does not matter',\n        status: 7,\n      }).getActualError();\n      isErrorType(actualError, errors.NoSuchElementError).should.be.true;\n    });\n    it('should map a status code 10, StaleElementReferenceError', function () {\n      const actualError = new errors.ProxyRequestError('Error message does not matter', {\n        value: 'Does not matter',\n        status: 10,\n      }).getActualError();\n      isErrorType(actualError, errors.StaleElementReferenceError).should.be.true;\n    });\n    it('should map an unknown error to UnknownError', function () {\n      const actualError = new errors.ProxyRequestError('Error message does not matter', {\n        value: 'Does not matter',\n        status: -100\n      }).getActualError();\n      isErrorType(actualError, errors.UnknownError).should.be.true;\n    });\n    it('should parse a JSON string', function () {\n      const actualError = new errors.ProxyRequestError('Error message does not matter', JSON.stringify({\n        value: 'Does not matter',\n        status: -100\n      })).getActualError();\n      isErrorType(actualError, errors.UnknownError).should.be.true;\n    });\n  });\n\n  describe('W3C', function () {\n    it('should map a 404 no such element error as a NoSuchElementError', function () {\n      const actualError = new errors.ProxyRequestError('Error message does not matter', {\n        value: {\n          error: errors.NoSuchElementError.error(),\n        },\n      }, HTTPStatusCodes.NOT_FOUND).getActualError();\n      isErrorType(actualError, errors.NoSuchElementError).should.be.true;\n    });\n    it('should map a 400 StaleElementReferenceError', function () {\n      const actualError = new errors.ProxyRequestError('Error message does not matter', {\n        value: {\n          error: errors.StaleElementReferenceError.error(),\n\n        },\n      }, HTTPStatusCodes.BAD_REQUEST).getActualError();\n      isErrorType(actualError, errors.StaleElementReferenceError).should.be.true;\n    });\n    it('should map an unknown error to UnknownError', function () {\n      const actualError = new errors.ProxyRequestError('Error message does not matter', null, {\n        value: {\n          error: 'Not a valid w3c JSON code'\n\n        },\n      }, 456).getActualError();\n      isErrorType(actualError, errors.UnknownError).should.be.true;\n    });\n    it('should parse a JSON string', function () {\n      const actualError = new errors.ProxyRequestError('Error message does not matter', JSON.stringify({\n        value: {\n          error: errors.StaleElementReferenceError.error(),\n\n        },\n      }), HTTPStatusCodes.BAD_REQUEST).getActualError();\n      isErrorType(actualError, errors.StaleElementReferenceError).should.be.true;\n    });\n  });\n});\n"]}

package/build/test/unit/protocol/routes.spec.js

@@ -0,0 +1,80 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("source-map-support/register");
+
+var _lodash = require("lodash");
+
+var _protocol = require("../../../lib/protocol");
+
+var _crypto = _interopRequireDefault(require("crypto"));
+
+describe('Protocol', function () {
+  describe('ensure protocol consistency', function () {
+    it('should not change protocol between patch versions', function () {
+      let shasum = _crypto.default.createHash('sha1');
+
+      for (let [url, urlMapping] of _lodash._.toPairs(_protocol.METHOD_MAP)) {
+        shasum.update(url);
+
+        for (let [method, methodMapping] of _lodash._.toPairs(urlMapping)) {
+          shasum.update(method);
+
+          if (methodMapping.command) {
+            shasum.update(methodMapping.command);
+          }
+
+          if (methodMapping.payloadParams) {
+            let allParams = _lodash._.flatten(methodMapping.payloadParams.required);
+
+            if (methodMapping.payloadParams.optional) {
+              allParams = allParams.concat(_lodash._.flatten(methodMapping.payloadParams.optional));
+            }
+
+            for (let param of allParams) {
+              shasum.update(param);
+            }
+
+            if (methodMapping.payloadParams.wrap) {
+              shasum.update('skip');
+              shasum.update(methodMapping.payloadParams.wrap);
+            }
+          }
+        }
+      }
+
+      let hash = shasum.digest('hex').substring(0, 8);
+      hash.should.equal('7d48d815');
+    });
+  });
+  describe('check route to command name conversion', function () {
+    it('should properly lookup correct command name for endpoint with session', function () {
+      const cmdName = (0, _protocol.routeToCommandName)('/timeouts', 'POST');
+      cmdName.should.equal('timeouts');
+    });
+    it('should properly lookup correct command name for endpoint with session', function () {
+      const cmdName = (0, _protocol.routeToCommandName)('/timeouts/implicit_wait', 'POST');
+      cmdName.should.equal('implicitWait');
+    });
+    it('should properly lookup correct command name for endpoint without session', function () {
+      const cmdName = (0, _protocol.routeToCommandName)('/status', 'GET');
+      cmdName.should.equal('getStatus');
+    });
+    it('should properly lookup correct command name for endpoint without leading slash', function () {
+      const cmdName = (0, _protocol.routeToCommandName)('status', 'GET');
+      cmdName.should.equal('getStatus');
+    });
+    it('should properly lookup correct command name for fully specified endpoint', function () {
+      const cmdName = (0, _protocol.routeToCommandName)('/status', 'GET');
+      cmdName.should.equal('getStatus');
+    });
+    it('should not find command name if incorrect input data has been specified', function () {
+      for (let [route, method] of [['/status', 'POST'], ['/xstatus', 'GET'], ['status', 'POST']]) {
+        const cmdName = (0, _protocol.routeToCommandName)(route, method);
+        chai.should().equal(cmdName, undefined);
+      }
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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