@appium/base-driver 10.3.0 → 10.4.0

package/lib/protocol/errors.ts

@@ -41,10 +41,10 @@ class BaseError extends Error {
 
 // base error class for all of our errors
 export class ProtocolError extends BaseError {
-  protected _stacktrace: string | undefined;
   public jsonwpCode: number;
   public error: string;
   public w3cStatus: number;
+  protected _stacktrace: string | undefined;
 
   constructor(
     msg: string,
@@ -93,17 +93,6 @@ export class ProtocolError extends BaseError {
 // https://w3c.github.io/webdriver/webdriver-spec.html#dfn-error-code
 
 export class NoSuchDriverError extends ProtocolError {
-  static code() {
-    return 6;
-  }
-  // W3C Error is called InvalidSessionID
-  static w3cStatus() {
-    return HTTPStatusCodes.NOT_FOUND;
-  }
-  static error() {
-    return 'invalid session id';
-  }
-
   constructor(message: string = '', cause?: Error) {
     super(
       message || 'A session is either terminated or not started',
@@ -113,19 +102,21 @@ export class NoSuchDriverError extends ProtocolError {
       cause,
     );
   }
-}
 
-export class NoSuchElementError extends ProtocolError {
   static code() {
-    return 7;
+    return 6;
   }
+  // W3C Error is called InvalidSessionID
   static w3cStatus() {
     return HTTPStatusCodes.NOT_FOUND;
   }
   static error() {
-    return 'no such element';
+    return 'invalid session id';
   }
 
+}
+
+export class NoSuchElementError extends ProtocolError {
   constructor(message: string = '', cause?: Error) {
     super(
       message ||
@@ -136,19 +127,20 @@ export class NoSuchElementError extends ProtocolError {
       cause,
     );
   }
-}
 
-export class NoSuchFrameError extends ProtocolError {
   static code() {
-    return 8;
-  }
-  static error() {
-    return 'no such frame';
+    return 7;
   }
   static w3cStatus() {
     return HTTPStatusCodes.NOT_FOUND;
   }
+  static error() {
+    return 'no such element';
+  }
+
+}
 
+export class NoSuchFrameError extends ProtocolError {
   constructor(message: string = '', cause?: Error) {
     super(
       message ||
@@ -160,19 +152,20 @@ export class NoSuchFrameError extends ProtocolError {
       cause,
     );
   }
-}
 
-export class UnknownCommandError extends ProtocolError {
   static code() {
-    return 9;
+    return 8;
+  }
+  static error() {
+    return 'no such frame';
   }
   static w3cStatus() {
     return HTTPStatusCodes.NOT_FOUND;
   }
-  static error() {
-    return 'unknown command';
-  }
 
+}
+
+export class UnknownCommandError extends ProtocolError {
   constructor(message: string = '', cause?: Error) {
     super(
       message ||
@@ -185,19 +178,20 @@ export class UnknownCommandError extends ProtocolError {
       cause,
     );
   }
-}
 
-export class StaleElementReferenceError extends ProtocolError {
   static code() {
-    return 10;
+    return 9;
   }
   static w3cStatus() {
     return HTTPStatusCodes.NOT_FOUND;
   }
   static error() {
-    return 'stale element reference';
+    return 'unknown command';
   }
 
+}
+
+export class StaleElementReferenceError extends ProtocolError {
   constructor(message: string = '', cause?: Error) {
     super(
       message ||
@@ -209,19 +203,20 @@ export class StaleElementReferenceError extends ProtocolError {
       cause,
     );
   }
-}
 
-export class ElementNotVisibleError extends ProtocolError {
   static code() {
-    return 11;
+    return 10;
   }
   static w3cStatus() {
-    return HTTPStatusCodes.BAD_REQUEST;
+    return HTTPStatusCodes.NOT_FOUND;
   }
   static error() {
-    return 'element not visible';
+    return 'stale element reference';
   }
 
+}
+
+export class ElementNotVisibleError extends ProtocolError {
   constructor(message: string = '', cause?: Error) {
     super(
       message ||
@@ -233,19 +228,20 @@ export class ElementNotVisibleError extends ProtocolError {
       cause,
     );
   }
-}
 
-export class InvalidElementStateError extends ProtocolError {
   static code() {
-    return 12;
+    return 11;
   }
   static w3cStatus() {
     return HTTPStatusCodes.BAD_REQUEST;
   }
   static error() {
-    return 'invalid element state';
+    return 'element not visible';
   }
 
+}
+
+export class InvalidElementStateError extends ProtocolError {
   constructor(message: string = '', cause?: Error) {
     super(
       message ||
@@ -257,19 +253,20 @@ export class InvalidElementStateError extends ProtocolError {
       cause,
     );
   }
-}
 
-export class UnknownError extends ProtocolError {
   static code() {
-    return 13;
+    return 12;
   }
   static w3cStatus() {
-    return HTTPStatusCodes.INTERNAL_SERVER_ERROR;
+    return HTTPStatusCodes.BAD_REQUEST;
   }
   static error() {
-    return 'unknown error';
+    return 'invalid element state';
   }
 
+}
+
+export class UnknownError extends ProtocolError {
   constructor(message: string = '', cause?: Error) {
     super(
       message || 'An unknown server-side error occurred while processing the command.',
@@ -279,19 +276,20 @@ export class UnknownError extends ProtocolError {
       cause,
     );
   }
-}
 
-export class UnknownMethodError extends ProtocolError {
   static code() {
-    return 405;
+    return 13;
   }
   static w3cStatus() {
-    return HTTPStatusCodes.METHOD_NOT_ALLOWED;
+    return HTTPStatusCodes.INTERNAL_SERVER_ERROR;
   }
   static error() {
-    return 'unknown method';
+    return 'unknown error';
   }
 
+}
+
+export class UnknownMethodError extends ProtocolError {
   constructor(message: string = '', cause?: Error) {
     super(
       message ||
@@ -302,19 +300,20 @@ export class UnknownMethodError extends ProtocolError {
       cause,
     );
   }
-}
 
-export class UnsupportedOperationError extends ProtocolError {
   static code() {
     return 405;
   }
   static w3cStatus() {
-    return HTTPStatusCodes.INTERNAL_SERVER_ERROR;
+    return HTTPStatusCodes.METHOD_NOT_ALLOWED;
   }
   static error() {
-    return 'unsupported operation';
+    return 'unknown method';
   }
 
+}
+
+export class UnsupportedOperationError extends ProtocolError {
   constructor(message: string = '', cause?: Error) {
     super(
       message || 'A server-side error occurred. Command cannot be supported.',
@@ -324,19 +323,20 @@ export class UnsupportedOperationError extends ProtocolError {
       cause,
     );
   }
-}
 
-export class ElementIsNotSelectableError extends ProtocolError {
   static code() {
-    return 15;
-  }
-  static error() {
-    return 'element not selectable';
+    return 405;
   }
   static w3cStatus() {
-    return HTTPStatusCodes.BAD_REQUEST;
+    return HTTPStatusCodes.INTERNAL_SERVER_ERROR;
+  }
+  static error() {
+    return 'unsupported operation';
   }
 
+}
+
+export class ElementIsNotSelectableError extends ProtocolError {
   constructor(message: string = '', cause?: Error) {
     super(
       message || 'An attempt was made to select an element that cannot be selected.',
@@ -346,19 +346,20 @@ export class ElementIsNotSelectableError extends ProtocolError {
       cause,
     );
   }
-}
 
-export class ElementClickInterceptedError extends ProtocolError {
   static code() {
-    return 64;
+    return 15;
   }
   static error() {
-    return 'element click intercepted';
+    return 'element not selectable';
   }
   static w3cStatus() {
     return HTTPStatusCodes.BAD_REQUEST;
   }
 
+}
+
+export class ElementClickInterceptedError extends ProtocolError {
   constructor(message: string = '', cause?: Error) {
     super(
       message ||
@@ -370,19 +371,20 @@ export class ElementClickInterceptedError extends ProtocolError {
       cause,
     );
   }
-}
 
-export class ElementNotInteractableError extends ProtocolError {
   static code() {
-    return 60;
+    return 64;
   }
   static error() {
-    return 'element not interactable';
+    return 'element click intercepted';
   }
   static w3cStatus() {
     return HTTPStatusCodes.BAD_REQUEST;
   }
 
+}
+
+export class ElementNotInteractableError extends ProtocolError {
   constructor(message: string = '', cause?: Error) {
     super(
       message ||
@@ -393,16 +395,20 @@ export class ElementNotInteractableError extends ProtocolError {
       cause,
     );
   }
-}
 
-export class InsecureCertificateError extends ProtocolError {
+  static code() {
+    return 60;
+  }
   static error() {
-    return 'insecure certificate';
+    return 'element not interactable';
   }
   static w3cStatus() {
     return HTTPStatusCodes.BAD_REQUEST;
   }
 
+}
+
+export class InsecureCertificateError extends ProtocolError {
   constructor(message: string = '', cause?: Error) {
     super(
       message ||
@@ -413,19 +419,17 @@ export class InsecureCertificateError extends ProtocolError {
       cause,
     );
   }
-}
 
-export class JavaScriptError extends ProtocolError {
-  static code() {
-    return 17;
+  static error() {
+    return 'insecure certificate';
   }
   static w3cStatus() {
-    return HTTPStatusCodes.INTERNAL_SERVER_ERROR;
-  }
-  static error() {
-    return 'javascript error';
+    return HTTPStatusCodes.BAD_REQUEST;
   }
 
+}
+
+export class JavaScriptError extends ProtocolError {
   constructor(message: string = '', cause?: Error) {
     super(
       message || 'An error occurred while executing user supplied JavaScript.',
@@ -435,19 +439,20 @@ export class JavaScriptError extends ProtocolError {
       cause,
     );
   }
-}
 
-export class XPathLookupError extends ProtocolError {
   static code() {
-    return 19;
+    return 17;
   }
   static w3cStatus() {
-    return HTTPStatusCodes.BAD_REQUEST;
+    return HTTPStatusCodes.INTERNAL_SERVER_ERROR;
   }
   static error() {
-    return 'invalid selector';
+    return 'javascript error';
   }
 
+}
+
+export class XPathLookupError extends ProtocolError {
   constructor(message: string = '', cause?: Error) {
     super(
       message || 'An error occurred while searching for an element by XPath.',
@@ -457,19 +462,20 @@ export class XPathLookupError extends ProtocolError {
       cause,
     );
   }
-}
 
-export class TimeoutError extends ProtocolError {
   static code() {
-    return 21;
+    return 19;
   }
   static w3cStatus() {
-    return HTTPStatusCodes.REQUEST_TIMEOUT;
+    return HTTPStatusCodes.BAD_REQUEST;
   }
   static error() {
-    return 'timeout';
+    return 'invalid selector';
   }
 
+}
+
+export class TimeoutError extends ProtocolError {
   constructor(message: string = '', cause?: Error) {
     super(
       message || 'An operation did not complete before its timeout expired.',
@@ -479,19 +485,20 @@ export class TimeoutError extends ProtocolError {
       cause,
     );
   }
-}
 
-export class NoSuchWindowError extends ProtocolError {
   static code() {
-    return 23;
-  }
-  static error() {
-    return 'no such window';
+    return 21;
   }
   static w3cStatus() {
-    return HTTPStatusCodes.NOT_FOUND;
+    return HTTPStatusCodes.REQUEST_TIMEOUT;
+  }
+  static error() {
+    return 'timeout';
   }
 
+}
+
+export class NoSuchWindowError extends ProtocolError {
   constructor(message: string = '', cause?: Error) {
     super(
       message ||
@@ -503,19 +510,20 @@ export class NoSuchWindowError extends ProtocolError {
       cause,
     );
   }
-}
 
-export class InvalidArgumentError extends ProtocolError {
   static code() {
-    return 61;
+    return 23;
   }
   static error() {
-    return 'invalid argument';
+    return 'no such window';
   }
   static w3cStatus() {
-    return HTTPStatusCodes.BAD_REQUEST;
+    return HTTPStatusCodes.NOT_FOUND;
   }
 
+}
+
+export class InvalidArgumentError extends ProtocolError {
   constructor(message: string = '', cause?: Error) {
     super(
       message || 'The arguments passed to the command are either invalid or malformed',
@@ -525,19 +533,20 @@ export class InvalidArgumentError extends ProtocolError {
       cause,
     );
   }
-}
 
-export class InvalidCookieDomainError extends ProtocolError {
   static code() {
-    return 24;
+    return 61;
   }
   static error() {
-    return 'invalid cookie domain';
+    return 'invalid argument';
   }
   static w3cStatus() {
     return HTTPStatusCodes.BAD_REQUEST;
   }
 
+}
+
+export class InvalidCookieDomainError extends ProtocolError {
   constructor(message: string = '', cause?: Error) {
     super(
       message ||
@@ -549,19 +558,20 @@ export class InvalidCookieDomainError extends ProtocolError {
       cause,
     );
   }
-}
 
-export class NoSuchCookieError extends ProtocolError {
   static code() {
-    return 62;
-  }
-  static w3cStatus() {
-    return HTTPStatusCodes.NOT_FOUND;
+    return 24;
   }
   static error() {
-    return 'no such cookie';
+    return 'invalid cookie domain';
   }
+  static w3cStatus() {
+    return HTTPStatusCodes.BAD_REQUEST;
+  }
+
+}
 
+export class NoSuchCookieError extends ProtocolError {
   constructor(message: string = '', cause?: Error) {
     super(
       message ||
@@ -572,19 +582,20 @@ export class NoSuchCookieError extends ProtocolError {
       cause,
     );
   }
-}
 
-export class UnableToSetCookieError extends ProtocolError {
   static code() {
-    return 25;
+    return 62;
   }
   static w3cStatus() {
-    return HTTPStatusCodes.INTERNAL_SERVER_ERROR;
+    return HTTPStatusCodes.NOT_FOUND;
   }
   static error() {
-    return 'unable to set cookie';
+    return 'no such cookie';
   }
 
+}
+
+export class UnableToSetCookieError extends ProtocolError {
   constructor(message: string = '', cause?: Error) {
     super(
       message || "A request to set a cookie's value could not be satisfied.",
@@ -594,19 +605,21 @@ export class UnableToSetCookieError extends ProtocolError {
       cause,
     );
   }
-}
 
-export class UnexpectedAlertOpenError extends ProtocolError {
   static code() {
-    return 26;
+    return 25;
   }
   static w3cStatus() {
     return HTTPStatusCodes.INTERNAL_SERVER_ERROR;
   }
   static error() {
-    return 'unexpected alert open';
+    return 'unable to set cookie';
   }
-  constructor(message: string = '', cause?: Error) {
+
+}
+
+export class UnexpectedAlertOpenError extends ProtocolError {
+  constructor(message: string = '', cause?: Error) {
     super(
       message || 'A modal dialog was open, blocking this operation',
       UnexpectedAlertOpenError.code(),
@@ -615,19 +628,20 @@ export class UnexpectedAlertOpenError extends ProtocolError {
       cause,
     );
   }
-}
 
-export class NoAlertOpenError extends ProtocolError {
   static code() {
-    return 27;
+    return 26;
   }
   static w3cStatus() {
-    return HTTPStatusCodes.NOT_FOUND;
+    return HTTPStatusCodes.INTERNAL_SERVER_ERROR;
   }
   static error() {
-    return 'no such alert';
+    return 'unexpected alert open';
   }
 
+}
+
+export class NoAlertOpenError extends ProtocolError {
   constructor(message: string = '', cause?: Error) {
     super(
       message || 'An attempt was made to operate on a modal dialog when one was not open.',
@@ -637,21 +651,22 @@ export class NoAlertOpenError extends ProtocolError {
       cause,
     );
   }
-}
 
-export class NoSuchAlertError extends NoAlertOpenError {}
-
-export class ScriptTimeoutError extends ProtocolError {
   static code() {
-    return 28;
+    return 27;
   }
   static w3cStatus() {
-    return HTTPStatusCodes.REQUEST_TIMEOUT;
+    return HTTPStatusCodes.NOT_FOUND;
   }
   static error() {
-    return 'script timeout';
+    return 'no such alert';
   }
 
+}
+
+export class NoSuchAlertError extends NoAlertOpenError {}
+
+export class ScriptTimeoutError extends ProtocolError {
   constructor(message: string = '', cause?: Error) {
     super(
       message || 'A script did not complete before its timeout expired.',
@@ -661,19 +676,20 @@ export class ScriptTimeoutError extends ProtocolError {
       cause,
     );
   }
-}
 
-export class InvalidElementCoordinatesError extends ProtocolError {
   static code() {
-    return 29;
+    return 28;
   }
   static w3cStatus() {
-    return HTTPStatusCodes.BAD_REQUEST;
+    return HTTPStatusCodes.REQUEST_TIMEOUT;
   }
   static error() {
-    return 'invalid coordinates';
+    return 'script timeout';
   }
 
+}
+
+export class InvalidElementCoordinatesError extends ProtocolError {
   constructor(message: string = '', cause?: Error) {
     super(
       message || 'The coordinates provided to an interactions operation are invalid.',
@@ -683,21 +699,22 @@ export class InvalidElementCoordinatesError extends ProtocolError {
       cause,
     );
   }
-}
 
-export class InvalidCoordinatesError extends InvalidElementCoordinatesError {}
-
-export class IMENotAvailableError extends ProtocolError {
   static code() {
-    return 30;
+    return 29;
   }
   static w3cStatus() {
-    return HTTPStatusCodes.INTERNAL_SERVER_ERROR;
+    return HTTPStatusCodes.BAD_REQUEST;
   }
   static error() {
-    return 'unsupported operation';
+    return 'invalid coordinates';
   }
 
+}
+
+export class InvalidCoordinatesError extends InvalidElementCoordinatesError {}
+
+export class IMENotAvailableError extends ProtocolError {
   constructor(message: string = '', cause?: Error) {
     super(
       message || 'IME was not available.',
@@ -707,11 +724,9 @@ export class IMENotAvailableError extends ProtocolError {
       cause,
     );
   }
-}
 
-export class IMEEngineActivationFailedError extends ProtocolError {
   static code() {
-    return 31;
+    return 30;
   }
   static w3cStatus() {
     return HTTPStatusCodes.INTERNAL_SERVER_ERROR;
@@ -720,6 +735,9 @@ export class IMEEngineActivationFailedError extends ProtocolError {
     return 'unsupported operation';
   }
 
+}
+
+export class IMEEngineActivationFailedError extends ProtocolError {
   constructor(message: string = '', cause?: Error) {
     super(
       message || 'An IME engine could not be started.',
@@ -729,19 +747,20 @@ export class IMEEngineActivationFailedError extends ProtocolError {
       cause,
     );
   }
-}
 
-export class InvalidSelectorError extends ProtocolError {
   static code() {
-    return 32;
+    return 31;
   }
   static w3cStatus() {
-    return HTTPStatusCodes.BAD_REQUEST;
+    return HTTPStatusCodes.INTERNAL_SERVER_ERROR;
   }
   static error() {
-    return 'invalid selector';
+    return 'unsupported operation';
   }
 
+}
+
+export class InvalidSelectorError extends ProtocolError {
   constructor(message: string = '', cause?: Error) {
     super(
       message || 'Argument was an invalid selector (e.g. XPath/CSS).',
@@ -751,19 +770,20 @@ export class InvalidSelectorError extends ProtocolError {
       cause,
     );
   }
-}
 
-export class SessionNotCreatedError extends ProtocolError {
   static code() {
-    return 33;
+    return 32;
   }
   static w3cStatus() {
-    return HTTPStatusCodes.INTERNAL_SERVER_ERROR;
+    return HTTPStatusCodes.BAD_REQUEST;
   }
   static error() {
-    return 'session not created';
+    return 'invalid selector';
   }
 
+}
+
+export class SessionNotCreatedError extends ProtocolError {
   constructor(message: string = '', cause?: Error) {
     super(
       `A new session could not be created.${message ? (' Details: ' + message) : ''}`,
@@ -773,19 +793,20 @@ export class SessionNotCreatedError extends ProtocolError {
       cause,
     );
   }
-}
 
-export class MoveTargetOutOfBoundsError extends ProtocolError {
   static code() {
-    return 34;
+    return 33;
   }
   static w3cStatus() {
     return HTTPStatusCodes.INTERNAL_SERVER_ERROR;
   }
   static error() {
-    return 'move target out of bounds';
+    return 'session not created';
   }
 
+}
+
+export class MoveTargetOutOfBoundsError extends ProtocolError {
   constructor(message: string = '', cause?: Error) {
     super(
       message || 'Target provided for a move action is out of bounds.',
@@ -795,13 +816,20 @@ export class MoveTargetOutOfBoundsError extends ProtocolError {
       cause,
     );
   }
-}
 
-export class NoSuchContextError extends ProtocolError {
   static code() {
-    return 35;
+    return 34;
+  }
+  static w3cStatus() {
+    return HTTPStatusCodes.INTERNAL_SERVER_ERROR;
   }
+  static error() {
+    return 'move target out of bounds';
+  }
+
+}
 
+export class NoSuchContextError extends ProtocolError {
   constructor(message: string = '', cause?: Error) {
     super(
       message || 'No such context found.',
@@ -811,13 +839,14 @@ export class NoSuchContextError extends ProtocolError {
       cause,
     );
   }
-}
 
-export class InvalidContextError extends ProtocolError {
   static code() {
-    return 36;
+    return 35;
   }
 
+}
+
+export class InvalidContextError extends ProtocolError {
   constructor(message: string = '', cause?: Error) {
     super(
       message || 'That command could not be executed in the current context.',
@@ -827,6 +856,11 @@ export class InvalidContextError extends ProtocolError {
       cause,
     );
   }
+
+  static code() {
+    return 36;
+  }
+
 }
 
 // Aliases to UnknownMethodError
@@ -842,16 +876,6 @@ export class NotImplementedError extends UnknownMethodError {
 }
 
 export class UnableToCaptureScreen extends ProtocolError {
-  static code() {
-    return 63;
-  }
-  static w3cStatus() {
-    return HTTPStatusCodes.INTERNAL_SERVER_ERROR;
-  }
-  static error() {
-    return 'unable to capture screen';
-  }
-
   constructor(message: string = '', cause?: Error) {
     super(
       message || 'A screen capture was made impossible',
@@ -861,47 +885,17 @@ export class UnableToCaptureScreen extends ProtocolError {
       cause,
     );
   }
-}
 
-function generateBadParametersMessage(
-  paramRequirements: ParameterRequirements,
-  paramNames: string[]
-): string {
-  const toArray = function <T> (x: T | T[]): T[] {
-    if (_.isUndefined(x)) {
-      return [];
-    }
-    if (_.isArray(x)) {
-      return x;
-    }
-    return [x];
-  };
-
-  const requiredParamNames = toArray(paramRequirements.required);
-  const actualParamNames = toArray(paramNames);
-  const missingRequiredParamNames = _.difference(requiredParamNames, actualParamNames);
-  const resultLines: string[] = [];
-  resultLines.push(
-    _.isEmpty(missingRequiredParamNames)
-      ? // This should not happen
-        'Some of the provided parameters are not known'
-      : `The following required parameter${
-          missingRequiredParamNames.length === 1 ? ' is' : 's are'
-        } missing: ${JSON.stringify(missingRequiredParamNames)}`,
-  );
-  if (!_.isEmpty(requiredParamNames)) {
-    resultLines.push(`Known required parameters are: ${JSON.stringify(requiredParamNames)}`);
+  static code() {
+    return 63;
   }
-  const optionalParamNames = _.difference(toArray(paramRequirements.optional), ['sessionId', 'id']);
-  if (!_.isEmpty(optionalParamNames)) {
-    resultLines.push(`Known optional parameters are: ${JSON.stringify(optionalParamNames)}`);
+  static w3cStatus() {
+    return HTTPStatusCodes.INTERNAL_SERVER_ERROR;
   }
-  resultLines.push(
-    `You have provided${
-      _.isEmpty(actualParamNames) ? ' none' : ': ' + JSON.stringify(paramNames)
-    }`,
-  );
-  return resultLines.join('\n');
+  static error() {
+    return 'unable to capture screen';
+  }
+
 }
 
 // Equivalent to W3C InvalidArgumentError
@@ -945,6 +939,20 @@ export class ProxyRequestError extends BaseError {
     }
   }
 
+  private static _parseHttpResponse(data: any): [Record<string, any>, string] {
+    let responseErrorObj: Record<string, any> = util.safeJsonParse(data);
+    if (!_.isPlainObject(responseErrorObj)) {
+      responseErrorObj = {};
+    }
+    let errorMessage: string = _.isString(data) ? data : '';
+    if (_.isString(responseErrorObj.value)) {
+      errorMessage = responseErrorObj.value;
+    } else if (_.isString(responseErrorObj.value?.message)) {
+      errorMessage = responseErrorObj.value.message;
+    }
+    return [responseErrorObj, errorMessage];
+  }
+
   getActualError(): ProtocolError {
     if (util.hasValue(this._jwpError?.status) && util.hasValue(this._jwpError?.value)) {
       // If it's MJSONWP error, returns actual error cause for request failure based on `jsonwp.status`
@@ -959,20 +967,47 @@ export class ProxyRequestError extends BaseError {
     }
     return new UnknownError(this.message, this.cause);
   }
+}
 
-  private static _parseHttpResponse(data: any): [Record<string, any>, string] {
-    let responseErrorObj: Record<string, any> = util.safeJsonParse(data);
-    if (!_.isPlainObject(responseErrorObj)) {
-      responseErrorObj = {};
+function generateBadParametersMessage(
+  paramRequirements: ParameterRequirements,
+  paramNames: string[]
+): string {
+  const toArray = function <T> (x: T | T[]): T[] {
+    if (_.isUndefined(x)) {
+      return [];
     }
-    let errorMessage: string = _.isString(data) ? data : '';
-    if (_.isString(responseErrorObj.value)) {
-      errorMessage = responseErrorObj.value;
-    } else if (_.isString(responseErrorObj.value?.message)) {
-      errorMessage = responseErrorObj.value.message;
+    if (_.isArray(x)) {
+      return x;
     }
-    return [responseErrorObj, errorMessage];
+    return [x];
+  };
+
+  const requiredParamNames = toArray(paramRequirements.required);
+  const actualParamNames = toArray(paramNames);
+  const missingRequiredParamNames = _.difference(requiredParamNames, actualParamNames);
+  const resultLines: string[] = [];
+  resultLines.push(
+    _.isEmpty(missingRequiredParamNames)
+      ? // This should not happen
+        'Some of the provided parameters are not known'
+      : `The following required parameter${
+          missingRequiredParamNames.length === 1 ? ' is' : 's are'
+        } missing: ${JSON.stringify(missingRequiredParamNames)}`,
+  );
+  if (!_.isEmpty(requiredParamNames)) {
+    resultLines.push(`Known required parameters are: ${JSON.stringify(requiredParamNames)}`);
   }
+  const optionalParamNames = _.difference(toArray(paramRequirements.optional), ['sessionId', 'id']);
+  if (!_.isEmpty(optionalParamNames)) {
+    resultLines.push(`Known optional parameters are: ${JSON.stringify(optionalParamNames)}`);
+  }
+  resultLines.push(
+    `You have provided${
+      _.isEmpty(actualParamNames) ? ' none' : ': ' + JSON.stringify(paramNames)
+    }`,
+  );
+  return resultLines.join('\n');
 }
 
 // map of error class name to error class
@@ -1035,6 +1070,23 @@ const w3cErrorCodeMap: Record<string, Class<ProtocolError>> = _.values(errors)
   }, {});
 
 
+interface MJSONWPError {
+  status: number;
+  value?: any;
+  message?: string;
+}
+
+interface W3CError {
+  error: string;
+  message?: string;
+  stacktrace?: string;
+}
+
+interface ParameterRequirements {
+  required: string[] | string;
+  optional?: string[] | string;
+}
+
 /**
  * Type guard to check if an Error is of a specific type
  */
@@ -1102,20 +1154,3 @@ export function getResponseForW3CError(err: any): [number, { value: W3CError }]
 
   return protocolErrorToResponse(new UnknownError(err.message, err));
 }
-
-interface MJSONWPError {
-  status: number;
-  value?: any;
-  message?: string;
-}
-
-interface W3CError {
-  error: string;
-  message?: string;
-  stacktrace?: string;
-}
-
-interface ParameterRequirements {
-  required: string[] | string;
-  optional?: string[] | string;
-}