@appium/base-driver 8.2.2 → 8.3.0

package/lib/basedriver/helpers.js

@@ -15,16 +15,17 @@ const ZIP_MIME_TYPES = [
   'multipart/x-zip',
 ];
 const CACHED_APPS_MAX_AGE = 1000 * 60 * 60 * 24; // ms
+const MAX_CACHED_APPS = 1024;
 const APPLICATIONS_CACHE = new LRU({
-  maxAge: CACHED_APPS_MAX_AGE, // expire after 24 hours
+  max: MAX_CACHED_APPS,
+  ttl: CACHED_APPS_MAX_AGE, // expire after 24 hours
   updateAgeOnGet: true,
-  dispose: async (app, {fullPath}) => {
-    if (!await fs.exists(fullPath)) {
-      return;
+  dispose: (app, {fullPath}) => {
+    logger.info(`The application '${app}' cached at '${fullPath}' has ` +
+      `expired after ${CACHED_APPS_MAX_AGE}ms`);
+    if (fullPath) {
+      fs.rimraf(fullPath);
     }
-
-    logger.info(`The application '${app}' cached at '${fullPath}' has expired`);
-    await fs.rimraf(fullPath);
   },
   noDisposeOnSet: true,
 });
@@ -34,11 +35,11 @@ const DEFAULT_BASENAME = 'appium-app';
 const APP_DOWNLOAD_TIMEOUT_MS = 120 * 1000;
 
 process.on('exit', () => {
-  if (APPLICATIONS_CACHE.itemCount === 0) {
+  if (APPLICATIONS_CACHE.size === 0) {
     return;
   }
 
-  const appPaths = APPLICATIONS_CACHE.values()
+  const appPaths = [...APPLICATIONS_CACHE.values()]
     .map(({fullPath}) => fullPath);
   logger.debug(`Performing cleanup of ${appPaths.length} cached ` +
     util.pluralize('application', appPaths.length));
@@ -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,106 @@ 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 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 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 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.
+ * If the downloaded app has `.zip` extension, this method will unzip it.
+ * The unzip does not work when `onPostProcess` is provided.
+ *
+ * @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 +233,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 +254,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 +329,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 +365,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 +457,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 '@colors/colors';
 import morgan from 'morgan';
 import log from './logger';
 import { MAX_LOG_BODY_LENGTH } from '../constants';

package/lib/express/idempotency.js

@@ -20,7 +20,7 @@ const MONITORED_METHODS = ['POST', 'PATCH'];
 const IDEMPOTENCY_KEY_HEADER = 'x-idempotency-key';
 
 process.on('exit', () => {
-  const resPaths = IDEMPOTENT_RESPONSES.values()
+  const resPaths = [...IDEMPOTENT_RESPONSES.values()]
     .map(({response}) => response)
     .filter(Boolean);
   for (const resPath of resPaths) {

package/lib/helpers/capabilities.js

@@ -0,0 +1,25 @@
+import _ from 'lodash';
+
+function isW3cCaps (caps) {
+  if (!_.isPlainObject(caps)) {
+    return false;
+  }
+
+  const isFirstMatchValid = () => _.isArray(caps.firstMatch)
+    && !_.isEmpty(caps.firstMatch) && _.every(caps.firstMatch, _.isPlainObject);
+  const isAlwaysMatchValid = () => _.isPlainObject(caps.alwaysMatch);
+  if (_.has(caps, 'firstMatch') && _.has(caps, 'alwaysMatch')) {
+    return isFirstMatchValid() && isAlwaysMatchValid();
+  }
+  if (_.has(caps, 'firstMatch')) {
+    return isFirstMatchValid();
+  }
+  if (_.has(caps, 'alwaysMatch')) {
+    return isAlwaysMatchValid();
+  }
+  return false;
+}
+
+export {
+  isW3cCaps,
+};

package/lib/index.js

@@ -5,9 +5,9 @@ import * as driver from './basedriver/driver';
 import * as deviceSettings from './basedriver/device-settings';
 
 const { BaseDriver } = driver;
-const { DeviceSettings, BASEDRIVER_HANDLED_SETTINGS } = deviceSettings;
+const { DeviceSettings } = deviceSettings;
 
-export { BaseDriver, DeviceSettings, BASEDRIVER_HANDLED_SETTINGS };
+export { BaseDriver, DeviceSettings };
 export default BaseDriver;
 
 
@@ -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,10 +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');
-
 
 export const COMMAND_URLS_CONFLICTS = [
   {
@@ -42,20 +38,24 @@ export const COMMAND_URLS_CONFLICTS = [
     jsonwpConverter: (w3cUrl) => {
       const w3cPropertyRegex = /\/element\/([^/]+)\/property\/([^/]+)/;
       const jsonwpUrl = w3cUrl.replace(w3cPropertyRegex, '/element/$1/attribute/$2');
-      log.info(`Converting W3C '${w3cUrl}' to '${jsonwpUrl}'`);
       return jsonwpUrl;
     },
     w3cConverter: (jsonwpUrl) => jsonwpUrl // Don't convert JSONWP URL to W3C. W3C accepts /attribute and /property
   }
 ];
-
 const {MJSONWP, W3C} = PROTOCOLS;
+const DEFAULT_LOG = logger.getLogger('Protocol Converter');
 
 
 class ProtocolConverter {
-  constructor (proxyFunc) {
+  constructor (proxyFunc, log = null) {
     this.proxyFunc = proxyFunc;
     this._downstreamProtocol = null;
+    this._log = log;
+  }
+
+  get log () {
+    return this._log ?? DEFAULT_LOG;
   }
 
   set downstreamProtocol (value) {
@@ -108,7 +108,7 @@ class ProtocolConverter {
     let response, resBody;
 
     const timeoutRequestObjects = this.getTimeoutRequestObjects(body);
-    log.debug(`Will send the following request bodies to /timeouts: ${JSON.stringify(timeoutRequestObjects)}`);
+    this.log.debug(`Will send the following request bodies to /timeouts: ${JSON.stringify(timeoutRequestObjects)}`);
     for (const timeoutObj of timeoutRequestObjects) {
       [response, resBody] = await this.proxyFunc(url, method, timeoutObj);
 
@@ -131,14 +131,14 @@ class ProtocolConverter {
     const bodyObj = util.safeJsonParse(body);
     if (_.isPlainObject(bodyObj)) {
       if (this.downstreamProtocol === W3C && _.has(bodyObj, 'name') && !_.has(bodyObj, 'handle')) {
-        log.debug(`Copied 'name' value '${bodyObj.name}' to 'handle' as per W3C spec`);
+        this.log.debug(`Copied 'name' value '${bodyObj.name}' to 'handle' as per W3C spec`);
         return await this.proxyFunc(url, method, {
           ...bodyObj,
           handle: bodyObj.name,
         });
       }
       if (this.downstreamProtocol === MJSONWP && _.has(bodyObj, 'handle') && !_.has(bodyObj, 'name')) {
-        log.debug(`Copied 'handle' value '${bodyObj.handle}' to 'name' as per JSONWP spec`);
+        this.log.debug(`Copied 'handle' value '${bodyObj.handle}' to 'name' as per JSONWP spec`);
         return await this.proxyFunc(url, method, {
           ...bodyObj,
           name: bodyObj.handle,
@@ -157,12 +157,12 @@ class ProtocolConverter {
         value = _.isString(text)
           ? [...text]
           : (_.isArray(text) ? text : []);
-        log.debug(`Added 'value' property ${JSON.stringify(value)} to 'setValue' request body`);
+        this.log.debug(`Added 'value' property ${JSON.stringify(value)} to 'setValue' request body`);
       } else if (!util.hasValue(text) && util.hasValue(value)) {
         text = _.isArray(value)
           ? value.join('')
           : (_.isString(value) ? value : '');
-        log.debug(`Added 'text' property ${JSON.stringify(text)} to 'setValue' request body`);
+        this.log.debug(`Added 'text' property ${JSON.stringify(text)} to 'setValue' request body`);
       }
       return await this.proxyFunc(url, method, Object.assign({}, bodyObj, {
         text,
@@ -206,10 +206,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
@@ -240,11 +237,11 @@ class ProtocolConverter {
         ? jsonwpConverter(url)
         : w3cConverter(url);
       if (rewrittenUrl === url) {
-        log.debug(`Did not know how to rewrite the original URL '${url}' ` +
+        this.log.debug(`Did not know how to rewrite the original URL '${url}' ` +
           `for ${this.downstreamProtocol} protocol`);
         break;
       }
-      log.info(`Rewrote the original URL '${url}' to '${rewrittenUrl}' ` +
+      this.log.info(`Rewrote the original URL '${url}' to '${rewrittenUrl}' ` +
         `for ${this.downstreamProtocol} protocol`);
       return await this.proxyFunc(rewrittenUrl, method, body);
     }