@appium/base-driver 8.2.2 → 8.2.3

package/lib/basedriver/capabilities.js

@@ -145,7 +145,10 @@ function parseCaps (caps, constraints = {}, shouldValidateCaps = true) {
   }
 
   // If an empty array as provided, we'll be forgiving and make it an array of one empty object
+  // In the future, reject 'firstMatch' argument if its array did not have one or more entries (#3.2)
   if (allFirstMatchCaps.length === 0) {
+    log.warn(`The firstMatch array in the given capabilities has no entries. Adding an empty entry fo rnow, ` +
+      `but it will require one or more entries as W3C spec.`);
     allFirstMatchCaps.push({});
   }
 

package/lib/basedriver/driver.js

@@ -1,5 +1,5 @@
 import {
-  Protocol, errors, determineProtocol
+  Protocol, errors, determineProtocol, DELETE_SESSION_COMMAND,
 } from '../protocol';
 import { fs } from '@appium/support';
 import { PROTOCOLS, DEFAULT_BASE_PATH } from '../constants';
@@ -311,7 +311,7 @@ class BaseDriver extends Protocol {
       // If creating a session determine if W3C or MJSONWP protocol was requested and remember the choice
       this.protocol = determineProtocol(...args);
       this.logEvent(EVENT_SESSION_INIT);
-    } else if (cmd === 'deleteSession') {
+    } else if (cmd === DELETE_SESSION_COMMAND) {
       this.logEvent(EVENT_SESSION_QUIT_START);
     }
 
@@ -352,7 +352,7 @@ class BaseDriver extends Protocol {
     // automatic session deletion in this.onCommandTimeout. Of course we don't
     // want to trigger the timer when the user is shutting down the session
     // intentionally
-    if (this.isCommandsQueueEnabled && cmd !== 'deleteSession') {
+    if (this.isCommandsQueueEnabled && cmd !== DELETE_SESSION_COMMAND) {
       // resetting existing timeout
       this.startNewCommandTimeout();
     }
@@ -362,7 +362,7 @@ class BaseDriver extends Protocol {
     this._eventHistory.commands.push({cmd, startTime, endTime});
     if (cmd === 'createSession') {
       this.logEvent(EVENT_SESSION_START);
-    } else if (cmd === 'deleteSession') {
+    } else if (cmd === DELETE_SESSION_COMMAND) {
       this.logEvent(EVENT_SESSION_QUIT_DONE);
     }
 

package/lib/basedriver/helpers.js

@@ -18,13 +18,14 @@ const CACHED_APPS_MAX_AGE = 1000 * 60 * 60 * 24; // ms
 const APPLICATIONS_CACHE = new LRU({
   maxAge: CACHED_APPS_MAX_AGE, // expire after 24 hours
   updateAgeOnGet: true,
-  dispose: async (app, {fullPath}) => {
-    if (!await fs.exists(fullPath)) {
-      return;
-    }
-
-    logger.info(`The application '${app}' cached at '${fullPath}' has expired`);
-    await fs.rimraf(fullPath);
+  dispose: (app, {fullPath}) => {
+    logger.info(`The application '${app}' cached at '${fullPath}' has ` +
+      `expired after ${CACHED_APPS_MAX_AGE}ms`);
+    setTimeout(async () => {
+      if (fullPath) {
+        await fs.rimraf(fullPath);
+      }
+    });
   },
   noDisposeOnSet: true,
 });
@@ -66,54 +67,57 @@ async function retrieveHeaders (link) {
   return {};
 }
 
-function getCachedApplicationPath (link, currentAppProps = {}) {
+function getCachedApplicationPath (link, currentAppProps = {}, cachedAppInfo = {}) {
   const refresh = () => {
     logger.debug(`A fresh copy of the application is going to be downloaded from ${link}`);
     return null;
   };
 
-  if (APPLICATIONS_CACHE.has(link)) {
-    const {
-      lastModified: currentModified,
-      immutable: currentImmutable,
-      // maxAge is in seconds
-      maxAge: currentMaxAge,
-    } = currentAppProps;
-    const {
-      // Date instance
-      lastModified,
-      // boolean
-      immutable,
-      // Unix time in milliseconds
-      timestamp,
-      fullPath,
-    } = APPLICATIONS_CACHE.get(link);
-    if (lastModified && currentModified) {
-      if (currentModified.getTime() <= lastModified.getTime()) {
-        logger.debug(`The application at ${link} has not been modified since ${lastModified}`);
-        return fullPath;
-      }
-      logger.debug(`The application at ${link} has been modified since ${lastModified}`);
-      return refresh();
-    }
-    if (immutable && currentImmutable) {
-      logger.debug(`The application at ${link} is immutable`);
+  if (!_.isPlainObject(cachedAppInfo) || !_.isPlainObject(currentAppProps)) {
+    // if an invalid arg is passed then assume cache miss
+    return refresh();
+  }
+
+  const {
+    lastModified: currentModified,
+    immutable: currentImmutable,
+    // maxAge is in seconds
+    maxAge: currentMaxAge,
+  } = currentAppProps;
+  const {
+    // Date instance
+    lastModified,
+    // boolean
+    immutable,
+    // Unix time in milliseconds
+    timestamp,
+    fullPath,
+  } = cachedAppInfo;
+  if (lastModified && currentModified) {
+    if (currentModified.getTime() <= lastModified.getTime()) {
+      logger.debug(`The application at ${link} has not been modified since ${lastModified}`);
       return fullPath;
     }
-    if (currentMaxAge && timestamp) {
-      const msLeft = timestamp + currentMaxAge * 1000 - Date.now();
-      if (msLeft > 0) {
-        logger.debug(`The cached application '${path.basename(fullPath)}' will expire in ${msLeft / 1000}s`);
-        return fullPath;
-      }
-      logger.debug(`The cached application '${path.basename(fullPath)}' has expired`);
+    logger.debug(`The application at ${link} has been modified since ${lastModified}`);
+    return refresh();
+  }
+  if (immutable && currentImmutable) {
+    logger.debug(`The application at ${link} is immutable`);
+    return fullPath;
+  }
+  if (currentMaxAge && timestamp) {
+    const msLeft = timestamp + currentMaxAge * 1000 - Date.now();
+    if (msLeft > 0) {
+      logger.debug(`The cached application '${path.basename(fullPath)}' will expire in ${msLeft / 1000}s`);
+      return fullPath;
     }
+    logger.debug(`The cached application '${path.basename(fullPath)}' has expired`);
   }
   return refresh();
 }
 
 function verifyAppExtension (app, supportedAppExtensions) {
-  if (supportedAppExtensions.includes(path.extname(app))) {
+  if (supportedAppExtensions.map(_.toLower).includes(_.toLower(path.extname(app)))) {
     return app;
   }
   throw new Error(`New app path '${app}' did not have ` +
@@ -121,18 +125,104 @@ function verifyAppExtension (app, supportedAppExtensions) {
     supportedAppExtensions);
 }
 
-async function configureApp (app, supportedAppExtensions) {
+async function calculateFolderIntegrity (folderPath) {
+  return (await fs.glob('**/*', {cwd: folderPath, strict: false, nosort: true})).length;
+}
+
+async function calculateFileIntegrity (filePath) {
+  return await fs.hash(filePath);
+}
+
+async function isAppIntegrityOk (currentPath, expectedIntegrity = {}) {
+  if (!await fs.exists(currentPath)) {
+    return false;
+  }
+
+  // Folder integrity check is simple:
+  // Verify the previous amount of files is not greater than the current one.
+  // We don't want to use equality comparison because of an assumption that the OS might
+  // create some unwanted service files/cached inside of that folder or its subfolders.
+  // Ofc, validating the hash sum of each file (or at least of file path) would be much
+  // more precise, but we don't need to be very precise here and also don't want to
+  // overuse RAM and have a performance drop.
+  return (await fs.stat(currentPath)).isDirectory()
+    ? await calculateFolderIntegrity(currentPath) >= expectedIntegrity?.folder
+    : await calculateFileIntegrity(currentPath) === expectedIntegrity?.file;
+}
+
+/**
+ * @typedef {Object} PostProcessOptions
+ * @property {?Object} cachedAppInfo The information about the previously cached app instance (if exists):
+ *    - packageHash: SHA1 hash of the package if it is a file and not a folder
+ *    - lastModified: Optional Date instance, the value of file's `Last-Modified` header
+ *    - immutable: Optional boolean value. Contains true if the file has an `immutable` mark
+ *                 in `Cache-control` header
+ *    - maxAge: Optional integer representation of `maxAge` parameter in `Cache-control` header
+ *    - timestamp: The timestamp this item has been added to the cache (measured in Unix epoch
+ *                 milliseconds)
+ *    - integrity: An object containing either `file` property with SHA1 hash of the file
+ *                 or `folder` property with total amount of cached files and subfolders
+ *    - fullPath: the full path to the cached app
+ * @property {boolean} isUrl Whether the app has been downloaded from a remote URL
+ * @property {?Object} headers Optional headers object. Only present if `isUrl` is true and if the server
+ * responds to HEAD requests. All header names are normalized to lowercase.
+ * @property {string} appPath A string containing full path to the preprocessed application package (either
+ * downloaded or a local one)
+ */
+
+/**
+ * @typedef {Object} PostProcessResult
+ * @property {string} appPath The full past to the post-processed application package on the
+ * local file system (might be a file or a folder path)
+ */
+
+/**
+ * @typedef {Object} ConfigureAppOptions
+ * @property {(obj: PostProcessOptions) => (Promise<PostProcessResult|undefined>|PostProcessResult|undefined)} onPostProcess
+ * Optional function, which should be applied
+ * to the application after it is downloaded/preprocessed. This function may be async
+ * and is expected to accept single object parameter.
+ * The function is expected to either return a falsy value, which means the app must not be
+ * cached and a fresh copy of it is downloaded each time. If this function returns an object
+ * containing `appPath` property then the integrity of it will be verified and stored into
+ * the cache.
+ * @property {string[]} supportedExtensions List of supported application extensions (
+ * including starting dots). This property is mandatory and must not be empty.
+ */
+
+/**
+ * Prepares an app to be used in an automated test. The app gets cached automatically
+ * if it is an archive or if it is downloaded from an URL.
+ *
+ * @param {string} app Either a full path to the app or a remote URL
+ * @param {string|string[]|ConfigureAppOptions} options
+ * @returns The full path to the resulting application bundle
+ */
+async function configureApp (app, options = {}) {
   if (!_.isString(app)) {
     // immediately shortcircuit if not given an app
     return;
   }
-  if (!_.isArray(supportedAppExtensions)) {
-    supportedAppExtensions = [supportedAppExtensions];
+
+  let supportedAppExtensions;
+  const {
+    onPostProcess,
+  } = _.isPlainObject(options) ? options : {};
+  if (_.isString(options)) {
+    supportedAppExtensions = [options];
+  } else if (_.isArray(options)) {
+    supportedAppExtensions = options;
+  } else if (_.isPlainObject(options)) {
+    supportedAppExtensions = options.supportedExtensions;
+  }
+  if (_.isEmpty(supportedAppExtensions)) {
+    throw new Error(`One or more supported app extensions must be provided`);
   }
 
   let newApp = app;
   let shouldUnzipApp = false;
-  let archiveHash = null;
+  let packageHash = null;
+  let headers = null;
   const remoteAppProps = {
     lastModified: null,
     immutable: false,
@@ -141,11 +231,13 @@ async function configureApp (app, supportedAppExtensions) {
   const {protocol, pathname} = url.parse(newApp);
   const isUrl = ['http:', 'https:'].includes(protocol);
 
+  const cachedAppInfo = APPLICATIONS_CACHE.get(app);
+
   return await APPLICATIONS_CACHE_GUARD.acquire(app, async () => {
     if (isUrl) {
       // Use the app from remote URL
       logger.info(`Using downloadable app '${newApp}'`);
-      const headers = await retrieveHeaders(newApp);
+      headers = await retrieveHeaders(newApp);
       if (!_.isEmpty(headers)) {
         if (headers['last-modified']) {
           remoteAppProps.lastModified = new Date(headers['last-modified']);
@@ -160,13 +252,14 @@ async function configureApp (app, supportedAppExtensions) {
         }
         logger.debug(`Cache-Control: ${headers['cache-control']}`);
       }
-      const cachedPath = getCachedApplicationPath(app, remoteAppProps);
+      const cachedPath = getCachedApplicationPath(app, remoteAppProps, cachedAppInfo);
       if (cachedPath) {
-        if (await fs.exists(cachedPath)) {
+        if (await isAppIntegrityOk(cachedPath, cachedAppInfo?.integrity)) {
           logger.info(`Reusing previously downloaded application at '${cachedPath}'`);
           return verifyAppExtension(cachedPath, supportedAppExtensions);
         }
-        logger.info(`The application at '${cachedPath}' does not exist anymore. Deleting it from the cache`);
+        logger.info(`The application at '${cachedPath}' does not exist anymore ` +
+          `or its integrity has been damaged. Deleting it from the internal cache`);
         APPLICATIONS_CACHE.del(app);
       }
 
@@ -234,19 +327,24 @@ async function configureApp (app, supportedAppExtensions) {
       throw new Error(errorMessage);
     }
 
-    if (shouldUnzipApp) {
+    const isPackageAFile = (await fs.stat(newApp)).isFile();
+    if (isPackageAFile) {
+      packageHash = await calculateFileIntegrity(newApp);
+    }
+
+    if (isPackageAFile && shouldUnzipApp && !_.isFunction(onPostProcess)) {
       const archivePath = newApp;
-      archiveHash = await fs.hash(archivePath);
-      if (APPLICATIONS_CACHE.has(app) && archiveHash === APPLICATIONS_CACHE.get(app).hash) {
-        const {fullPath} = APPLICATIONS_CACHE.get(app);
-        if (await fs.exists(fullPath)) {
+      if (packageHash === cachedAppInfo?.packageHash) {
+        const {fullPath} = cachedAppInfo;
+        if (await isAppIntegrityOk(fullPath, cachedAppInfo?.integrity)) {
           if (archivePath !== app) {
             await fs.rimraf(archivePath);
           }
           logger.info(`Will reuse previously cached application at '${fullPath}'`);
           return verifyAppExtension(fullPath, supportedAppExtensions);
         }
-        logger.info(`The application at '${fullPath}' does not exist anymore. Deleting it from the cache`);
+        logger.info(`The application at '${fullPath}' does not exist anymore ` +
+          `or its integrity has been damaged. Deleting it from the cache`);
         APPLICATIONS_CACHE.del(app);
       }
       const tmpRoot = await tempDir.openDir();
@@ -265,24 +363,43 @@ async function configureApp (app, supportedAppExtensions) {
       app = newApp;
     }
 
-    verifyAppExtension(newApp, supportedAppExtensions);
-
-    if (app !== newApp && (archiveHash || _.values(remoteAppProps).some(Boolean))) {
-      if (APPLICATIONS_CACHE.has(app)) {
-        const {fullPath} = APPLICATIONS_CACHE.get(app);
-        // Clean up the obsolete entry first if needed
-        if (fullPath !== newApp && await fs.exists(fullPath)) {
-          await fs.rimraf(fullPath);
-        }
+    const storeAppInCache = async (appPathToCache) => {
+      const cachedFullPath = cachedAppInfo?.fullPath;
+      if (cachedFullPath && cachedFullPath !== appPathToCache) {
+        await fs.rimraf(cachedFullPath);
+      }
+      const integrity = {};
+      if ((await fs.stat(appPathToCache)).isDirectory()) {
+        integrity.folder = await calculateFolderIntegrity(appPathToCache);
+      } else {
+        integrity.file = await calculateFileIntegrity(appPathToCache);
       }
       APPLICATIONS_CACHE.set(app, {
         ...remoteAppProps,
         timestamp: Date.now(),
-        hash: archiveHash,
-        fullPath: newApp,
+        packageHash,
+        integrity,
+        fullPath: appPathToCache,
+      });
+      return appPathToCache;
+    };
+
+    if (_.isFunction(onPostProcess)) {
+      const result = await onPostProcess({
+        cachedAppInfo: _.clone(cachedAppInfo),
+        isUrl,
+        headers: _.clone(headers),
+        appPath: newApp,
       });
+      return (!result?.appPath || app === result?.appPath || !await fs.exists(result?.appPath))
+        ? newApp
+        : await storeAppInCache(result.appPath);
     }
-    return newApp;
+
+    verifyAppExtension(newApp, supportedAppExtensions);
+    return (app !== newApp && (packageHash || _.values(remoteAppProps).some(Boolean)))
+      ? await storeAppInCache(newApp)
+      : newApp;
   });
 }
 
@@ -338,23 +455,22 @@ async function unzipApp (zipPath, dstRoot, supportedAppExtensions) {
       extractionOpts.fileNamesEncoding = 'utf8';
     }
     await zip.extractAllTo(zipPath, tmpRoot, extractionOpts);
-    const duration = timer.getDuration();
-    const allExtractedItems = await fs.glob('**', {cwd: tmpRoot});
-    logger.debug(`Extracted ${util.pluralize('item', allExtractedItems.length, true)} ` +
-      `from '${zipPath}' in ${Math.round(duration.asMilliSeconds)}ms`);
-    const allBundleItems = allExtractedItems
-      .filter((relativePath) => supportedAppExtensions.includes(path.extname(relativePath)))
-      // Get the top level match
-      .sort((a, b) => a.split(path.sep).length - b.split(path.sep).length);
-    if (_.isEmpty(allBundleItems)) {
-      throw new Error(`App zip unzipped OK, but we could not find '${supportedAppExtensions}' ` +
+    const globPattern = `**/*.+(${supportedAppExtensions.map((ext) => ext.replace(/^\./, '')).join('|')})`;
+    const sortedBundleItems = (await fs.glob(globPattern, {
+      cwd: tmpRoot,
+      strict: false,
+    // Get the top level match
+    })).sort((a, b) => a.split(path.sep).length - b.split(path.sep).length);
+    if (_.isEmpty(sortedBundleItems)) {
+      logger.errorAndThrow(`App unzipped OK, but we could not find any '${supportedAppExtensions}' ` +
         util.pluralize('bundle', supportedAppExtensions.length, false) +
         ` in it. Make sure your archive contains at least one package having ` +
         `'${supportedAppExtensions}' ${util.pluralize('extension', supportedAppExtensions.length, false)}`);
     }
-    const matchedBundle = _.first(allBundleItems);
-    logger.debug(`Matched ${util.pluralize('item', allBundleItems.length, true)} in the extracted archive. ` +
-      `Assuming '${matchedBundle}' is the correct bundle`);
+    logger.debug(`Extracted ${util.pluralize('bundle item', sortedBundleItems.length, true)} ` +
+      `from '${zipPath}' in ${Math.round(timer.getDuration().asMilliSeconds)}ms: ${sortedBundleItems}`);
+    const matchedBundle = _.first(sortedBundleItems);
+    logger.info(`Assuming '${matchedBundle}' is the correct bundle`);
     const dstPath = path.resolve(dstRoot, path.basename(matchedBundle));
     await fs.mv(path.resolve(tmpRoot, matchedBundle), dstPath, {mkdirp: true});
     return dstPath;

package/lib/express/express-logging.js

@@ -1,5 +1,5 @@
 import _ from 'lodash';
-import 'colors';
+import '@dabh/colors';
 import morgan from 'morgan';
 import log from './logger';
 import { MAX_LOG_BODY_LENGTH } from '../constants';

package/lib/index.js

@@ -21,7 +21,8 @@ const {
   Protocol, routeConfiguringFunction, errors, isErrorType,
   errorFromMJSONWPStatusCode, errorFromW3CJsonCode, ALL_COMMANDS, METHOD_MAP,
   routeToCommandName, NO_SESSION_ID_COMMANDS, isSessionCommand,
-  normalizeBasePath, determineProtocol, CREATE_SESSION_COMMAND, DELETE_SESSION_COMMAND,
+  normalizeBasePath, determineProtocol, CREATE_SESSION_COMMAND,
+  DELETE_SESSION_COMMAND, GET_STATUS_COMMAND,
 } = protocol;
 
 export {
@@ -29,7 +30,8 @@ export {
   errorFromMJSONWPStatusCode, errorFromW3CJsonCode, determineProtocol,
   errorFromMJSONWPStatusCode as errorFromCode, ALL_COMMANDS, METHOD_MAP,
   routeToCommandName, NO_SESSION_ID_COMMANDS, isSessionCommand,
-  DEFAULT_BASE_PATH, normalizeBasePath, CREATE_SESSION_COMMAND, DELETE_SESSION_COMMAND
+  DEFAULT_BASE_PATH, normalizeBasePath, CREATE_SESSION_COMMAND,
+  DELETE_SESSION_COMMAND, GET_STATUS_COMMAND,
 };
 
 // Express exports

package/lib/jsonwp-proxy/protocol-converter.js

@@ -4,7 +4,6 @@ import { duplicateKeys } from '../basedriver/helpers';
 import {
   MJSONWP_ELEMENT_KEY, W3C_ELEMENT_KEY, PROTOCOLS
 } from '../constants';
-import { formatStatus } from '../protocol/helpers';
 
 const log = logger.getLogger('Protocol Converter');
 
@@ -206,10 +205,7 @@ class ProtocolConverter {
    */
   async convertAndProxy (commandName, url, method, body) {
     if (!this.downstreamProtocol) {
-      // Patch calls with GENERIC protocol
-      // to preserve the backward compatibility
-      const [res, resBodyObj] = await this.proxyFunc(url, method, body);
-      return [res, formatStatus(resBodyObj, res.statusCode)];
+      return await this.proxyFunc(url, method, body);
     }
 
     // Same url, but different arguments

package/lib/jsonwp-proxy/proxy.js

@@ -9,7 +9,6 @@ import { routeToCommandName } from '../protocol';
 import { MAX_LOG_BODY_LENGTH, DEFAULT_BASE_PATH, PROTOCOLS } from '../constants';
 import ProtocolConverter from './protocol-converter';
 import { formatResponseValue, formatStatus } from '../protocol/helpers';
-import SESSIONS_CACHE from '../protocol/sessions-cache';
 import http from 'http';
 import https from 'https';
 
@@ -327,8 +326,7 @@ class JWProxy {
       }
     }
     resBodyObj.value = formatResponseValue(resBodyObj.value);
-    formatStatus(resBodyObj, res.statusCode, SESSIONS_CACHE.getProtocol(reqSessionId));
-    res.status(response.statusCode).send(JSON.stringify(resBodyObj));
+    res.status(response.statusCode).send(JSON.stringify(formatStatus(resBodyObj)));
   }
 }
 

package/lib/protocol/errors.js

@@ -657,7 +657,7 @@ class ProxyRequestError extends ES6Error {
 
   getActualError () {
     // If it's MJSONWP error, returns actual error cause for request failure based on `jsonwp.status`
-    if (util.hasValue(this.jsonwp) && util.hasValue(this.jsonwp.status) && util.hasValue(this.jsonwp.value)) {
+    if (util.hasValue(this.jsonwp?.status) && util.hasValue(this.jsonwp?.value)) {
       return errorFromMJSONWPStatusCode(this.jsonwp.status, this.jsonwp.value);
     } else if (util.hasValue(this.w3c) && _.isNumber(this.w3cStatus) && this.w3cStatus >= 300) {
       return errorFromW3CJsonCode(this.w3c.error, this.w3c.message || this.message, this.w3c.stacktrace);

package/lib/protocol/helpers.js

@@ -1,9 +1,6 @@
 import _ from 'lodash';
 import { duplicateKeys } from '../basedriver/helpers';
-import { MJSONWP_ELEMENT_KEY, W3C_ELEMENT_KEY, PROTOCOLS } from '../constants';
-
-const JSONWP_SUCCESS_STATUS_CODE = 0;
-const JSONWP_UNKNOWN_ERROR_STATUS_CODE = 13;
+import { MJSONWP_ELEMENT_KEY, W3C_ELEMENT_KEY } from '../constants';
 
 /**
  * Preprocesses the resulting value for API responses,
@@ -26,33 +23,16 @@ function formatResponseValue (resValue) {
 
 /**
  * Properly formats the status for API responses,
- * so they are correct for both W3C and JSONWP protocols.
- * This method DOES mutate the `responseBody` argument if needed
+ * so they are correct for the W3C protocol.
  *
  * @param {Object} responseBody
- * @param {number} responseCode the HTTP response code
- * @param {?string} protocol The name of the protocol, either
- * `PROTOCOLS.W3C` or `PROTOCOLS.MJSONWP`
  * @returns {Object} The fixed response body
  */
-function formatStatus (responseBody, responseCode = 200, protocol = null) {
-  if (!_.isPlainObject(responseBody)) {
-    return responseBody;
-  }
-  const isError = _.has(responseBody.value, 'error') || responseCode >= 400;
-  if ((protocol === PROTOCOLS.MJSONWP && !_.isInteger(responseBody.status))
-    || (!protocol && !_.has(responseBody, 'status'))) {
-    responseBody.status = isError
-      ? JSONWP_UNKNOWN_ERROR_STATUS_CODE
-      : JSONWP_SUCCESS_STATUS_CODE;
-  } else if (protocol === PROTOCOLS.W3C && _.has(responseBody, 'status')) {
-    delete responseBody.status;
-  }
-  return responseBody;
+function formatStatus (responseBody) {
+  return _.isPlainObject(responseBody) ? _.omit(responseBody, ['status']) : responseBody;
 }
 
 
 export {
-  MJSONWP_ELEMENT_KEY, W3C_ELEMENT_KEY, formatResponseValue,
-  JSONWP_SUCCESS_STATUS_CODE, formatStatus,
+  MJSONWP_ELEMENT_KEY, W3C_ELEMENT_KEY, formatResponseValue, formatStatus
 };

package/lib/protocol/protocol.js

@@ -2,7 +2,7 @@ import _ from 'lodash';
 import { util } from '@appium/support';
 import { validators } from './validators';
 import {
-  errors, isErrorType, getResponseForW3CError, getResponseForJsonwpError,
+  errors, isErrorType, getResponseForW3CError,
   errorFromMJSONWPStatusCode, errorFromW3CJsonCode,
 } from './errors';
 import { METHOD_MAP, NO_SESSION_ID_COMMANDS } from './routes';
@@ -16,6 +16,7 @@ import SESSIONS_CACHE from './sessions-cache';
 
 const CREATE_SESSION_COMMAND = 'createSession';
 const DELETE_SESSION_COMMAND = 'deleteSession';
+const GET_STATUS_COMMAND = 'getStatus';
 
 class Protocol {}
 
@@ -377,24 +378,7 @@ function buildHandler (app, method, path, spec, driver, isSessCmd) {
           .debug(`Encountered internal error running command: ${errMsg}`);
       }
 
-      if (currentProtocol === PROTOCOLS.W3C) {
-        [httpStatus, httpResBody] = getResponseForW3CError(actualErr);
-      } else if (currentProtocol === PROTOCOLS.MJSONWP) {
-        [httpStatus, httpResBody] = getResponseForJsonwpError(actualErr);
-      } else {
-        // If it's unknown what the protocol is (like if it's `getStatus` prior to `createSession`), merge the responses
-        // together to be protocol-agnostic
-        let jsonwpRes = getResponseForJsonwpError(actualErr);
-        let w3cRes = getResponseForW3CError(actualErr);
-
-        httpResBody = {
-          ...jsonwpRes[1],
-          ...w3cRes[1],
-        };
-
-        // Use the JSONWP status code (which is usually 500)
-        httpStatus = jsonwpRes[0];
-      }
+      [httpStatus, httpResBody] = getResponseForW3CError(actualErr);
     }
 
     // decode the response, which is either a string or json
@@ -415,7 +399,7 @@ function buildHandler (app, method, path, spec, driver, isSessCmd) {
         delete httpResBody.sessionId;
       }
 
-      httpResBody = formatStatus(httpResBody, httpStatus, currentProtocol);
+      httpResBody = formatStatus(httpResBody);
       res.status(httpStatus).json(httpResBody);
     }
   };
@@ -433,7 +417,7 @@ function driverShouldDoJwpProxy (driver, req, command) {
 
   // we should never proxy deleteSession because we need to give the containing
   // driver an opportunity to clean itself up
-  if (command === 'deleteSession') {
+  if (command === DELETE_SESSION_COMMAND) {
     return false;
   }
 
@@ -452,11 +436,10 @@ async function doJwpProxy (driver, req, res) {
 
   // check that the inner driver has a proxy function
   if (!driver.canProxy(req.params.sessionId)) {
-    throw new Error('Trying to proxy to a JSONWP server but driver is unable to proxy');
+    throw new Error('Trying to proxy to a server but the driver is unable to proxy');
   }
   try {
-    const proxiedRes = await driver.executeCommand('proxyReqRes', req, res, req.params.sessionId);
-    if (proxiedRes && proxiedRes.error) throw proxiedRes.error; // eslint-disable-line curly
+    await driver.executeCommand('proxyReqRes', req, res, req.params.sessionId);
   } catch (err) {
     if (isErrorType(err, errors.ProxyRequestError)) {
       throw err;
@@ -469,5 +452,6 @@ async function doJwpProxy (driver, req, res) {
 
 export {
   Protocol, routeConfiguringFunction, isSessionCommand,
-  driverShouldDoJwpProxy, determineProtocol, CREATE_SESSION_COMMAND, DELETE_SESSION_COMMAND,
+  driverShouldDoJwpProxy, determineProtocol, CREATE_SESSION_COMMAND,
+  DELETE_SESSION_COMMAND, GET_STATUS_COMMAND,
 };