@appium/base-driver 9.6.0 → 9.8.0

package/lib/basedriver/helpers.js

@@ -13,8 +13,8 @@ export const {version: BASEDRIVER_VER} = fs.readPackageJsonFrom(__dirname);
 const IPA_EXT = '.ipa';
 const ZIP_EXTS = new Set(['.zip', IPA_EXT]);
 const ZIP_MIME_TYPES = ['application/zip', 'application/x-zip-compressed', 'multipart/x-zip'];
-const CACHED_APPS_MAX_AGE = 1000 * 60 * 60 * 24; // ms
-const MAX_CACHED_APPS = 1024;
+const CACHED_APPS_MAX_AGE_MS = 1000 * 60 * toNaturalNumber(60 * 24, 'APPIUM_APPS_CACHE_MAX_AGE');
+const MAX_CACHED_APPS = toNaturalNumber(1024, 'APPIUM_APPS_CACHE_MAX_ITEMS');
 const HTTP_STATUS_NOT_MODIFIED = 304;
 const DEFAULT_REQ_HEADERS = Object.freeze({
   'user-agent': `Appium (BaseDriver v${BASEDRIVER_VER})`,
@@ -23,12 +23,12 @@ const AVG_DOWNLOAD_SPEED_MEASUREMENT_THRESHOLD_SEC = 2;
 /** @type {LRUCache<string, import('@appium/types').CachedAppInfo>} */
 const APPLICATIONS_CACHE = new LRUCache({
   max: MAX_CACHED_APPS,
-  ttl: CACHED_APPS_MAX_AGE, // expire after 24 hours
+  ttl: CACHED_APPS_MAX_AGE_MS, // expire after 24 hours
   updateAgeOnGet: true,
   dispose: ({fullPath}, app) => {
     logger.info(
       `The application '${app}' cached at '${fullPath}' has ` +
-        `expired after ${CACHED_APPS_MAX_AGE}ms`
+        `expired after ${CACHED_APPS_MAX_AGE_MS}ms`
     );
     if (fullPath) {
       fs.rimraf(fullPath);
@@ -61,60 +61,6 @@ process.on('exit', () => {
   }
 });
 
-/**
- * @param {string} app
- * @param {string[]} supportedAppExtensions
- * @returns {string}
- */
-function verifyAppExtension(app, supportedAppExtensions) {
-  if (supportedAppExtensions.map(_.toLower).includes(_.toLower(path.extname(app)))) {
-    return app;
-  }
-  throw new Error(
-    `New app path '${app}' did not have ` +
-      `${util.pluralize('extension', supportedAppExtensions.length, false)}: ` +
-      supportedAppExtensions
-  );
-}
-
-/**
- * @param {string} folderPath
- * @returns {Promise<number>}
- */
-async function calculateFolderIntegrity(folderPath) {
-  return (await fs.glob('**/*', {cwd: folderPath})).length;
-}
-
-/**
- * @param {string} filePath
- * @returns {Promise<string>}
- */
-async function calculateFileIntegrity(filePath) {
-  return await fs.hash(filePath);
-}
-
-/**
- * @param {string} currentPath
- * @param {import('@appium/types').StringRecord} expectedIntegrity
- * @returns {Promise<boolean>}
- */
-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;
-}
-
 /**
  *
  * @param {string} app
@@ -145,6 +91,7 @@ export async function configureApp(
   }
 
   let newApp = app;
+  const originalAppLink = app;
   let shouldUnzipApp = false;
   let packageHash = null;
   /** @type {import('axios').AxiosResponse['headers']|undefined} */
@@ -156,15 +103,16 @@ export async function configureApp(
     maxAge: null,
     etag: null,
   };
-  const {protocol, pathname} = url.parse(newApp);
-  const isUrl = protocol === null ? false : ['http:', 'https:'].includes(protocol);
+  const {protocol, pathname} = parseAppLink(app);
+  const isUrl = isSupportedUrl(app);
+  const appCacheKey = toCacheKey(app);
 
-  const cachedAppInfo = APPLICATIONS_CACHE.get(app);
+  const cachedAppInfo = APPLICATIONS_CACHE.get(appCacheKey);
   if (cachedAppInfo) {
     logger.debug(`Cached app data: ${JSON.stringify(cachedAppInfo, null, 2)}`);
   }
 
-  return await APPLICATIONS_CACHE_GUARD.acquire(app, async () => {
+  return await APPLICATIONS_CACHE_GUARD.acquire(appCacheKey, async () => {
     if (isUrl) {
       // Use the app from remote URL
       logger.info(`Using downloadable app '${newApp}'`);
@@ -208,7 +156,7 @@ export async function configureApp(
             `The application at '${cachedAppInfo.fullPath}' does not exist anymore ` +
               `or its integrity has been damaged. Deleting it from the internal cache`
           );
-          APPLICATIONS_CACHE.delete(app);
+          APPLICATIONS_CACHE.delete(appCacheKey);
 
           if (!stream.closed) {
             stream.destroy();
@@ -269,6 +217,7 @@ export async function configureApp(
         }
         newApp = onDownload
           ? await onDownload({
+            url: originalAppLink,
             headers: /** @type {import('@appium/types').HTTPHeaders} */ (_.clone(headers)),
             stream,
           })
@@ -316,7 +265,7 @@ export async function configureApp(
           `The application at '${fullPath}' does not exist anymore ` +
             `or its integrity has been damaged. Deleting it from the cache`
         );
-        APPLICATIONS_CACHE.delete(app);
+        APPLICATIONS_CACHE.delete(appCacheKey);
       }
       const tmpRoot = await tempDir.openDir();
       try {
@@ -347,7 +296,7 @@ export async function configureApp(
       } else {
         integrity.file = await calculateFileIntegrity(appPathToCache);
       }
-      APPLICATIONS_CACHE.set(app, {
+      APPLICATIONS_CACHE.set(appCacheKey, {
         ...remoteAppProps,
         timestamp: Date.now(),
         packageHash,
@@ -362,6 +311,7 @@ export async function configureApp(
         /** @type {import('@appium/types').PostProcessOptions<import('axios').AxiosResponseHeaders>} */ ({
           cachedAppInfo: _.clone(cachedAppInfo),
           isUrl,
+          originalAppLink,
           headers: _.clone(headers),
           appPath: newApp,
         })
@@ -372,12 +322,94 @@ export async function configureApp(
     }
 
     verifyAppExtension(newApp, supportedAppExtensions);
-    return app !== newApp && (packageHash || _.values(remoteAppProps).some(Boolean))
+    return appCacheKey !== toCacheKey(newApp) && (packageHash || _.values(remoteAppProps).some(Boolean))
       ? await storeAppInCache(newApp)
       : newApp;
   });
 }
 
+/**
+ * @param {string} app
+ * @returns {boolean}
+ */
+export function isPackageOrBundle(app) {
+  return /^([a-zA-Z0-9\-_]+\.[a-zA-Z0-9\-_]+)+$/.test(app);
+}
+
+/**
+ * Finds all instances 'firstKey' and create a duplicate with the key 'secondKey',
+ * Do the same thing in reverse. If we find 'secondKey', create a duplicate with the key 'firstKey'.
+ *
+ * This will cause keys to be overwritten if the object contains 'firstKey' and 'secondKey'.
+
+ * @param {*} input Any type of input
+ * @param {String} firstKey The first key to duplicate
+ * @param {String} secondKey The second key to duplicate
+ */
+export function duplicateKeys(input, firstKey, secondKey) {
+  // If array provided, recursively call on all elements
+  if (_.isArray(input)) {
+    return input.map((item) => duplicateKeys(item, firstKey, secondKey));
+  }
+
+  // If object, create duplicates for keys and then recursively call on values
+  if (_.isPlainObject(input)) {
+    const resultObj = {};
+    for (let [key, value] of _.toPairs(input)) {
+      const recursivelyCalledValue = duplicateKeys(value, firstKey, secondKey);
+      if (key === firstKey) {
+        resultObj[secondKey] = recursivelyCalledValue;
+      } else if (key === secondKey) {
+        resultObj[firstKey] = recursivelyCalledValue;
+      }
+      resultObj[key] = recursivelyCalledValue;
+    }
+    return resultObj;
+  }
+
+  // Base case. Return primitives without doing anything.
+  return input;
+}
+
+/**
+ * Takes a desired capability and tries to JSON.parse it as an array,
+ * and either returns the parsed array or a singleton array.
+ *
+ * @param {string|Array<String>} cap A desired capability
+ */
+export function parseCapsArray(cap) {
+  if (_.isArray(cap)) {
+    return cap;
+  }
+
+  let parsedCaps;
+  try {
+    parsedCaps = JSON.parse(cap);
+    if (_.isArray(parsedCaps)) {
+      return parsedCaps;
+    }
+  } catch (ign) {
+    logger.warn(`Failed to parse capability as JSON array`);
+  }
+  if (_.isString(cap)) {
+    return [cap];
+  }
+  throw new Error(`must provide a string or JSON Array; received ${cap}`);
+}
+
+/**
+ * Generate a string that uniquely describes driver instance
+ *
+ * @param {import('@appium/types').Core} obj driver instance
+ * @param {string?} sessionId session identifier (if exists)
+ * @returns {string}
+ */
+export function generateDriverLogPrefix(obj, sessionId = null) {
+  const instanceName = `${obj.constructor.name}@${node.getObjectId(obj).substring(0, 4)}`;
+  return sessionId ? `${instanceName} (${sessionId.substring(0, 8)})` : instanceName;
+}
+
+
 /**
  * Sends a HTTP GET query to fetch the app with caching enabled.
  * Follows https://developer.mozilla.org/en-US/docs/Web/HTTP/Caching
@@ -483,9 +515,7 @@ async function unzipApp(zipPath, dstRoot, supportedAppExtensions) {
   try {
     logger.debug(`Unzipping '${zipPath}'`);
     const timer = new timing.Timer().start();
-    const useSystemUnzipEnv = process.env.APPIUM_PREFER_SYSTEM_UNZIP;
-    const useSystemUnzip =
-      _.isEmpty(useSystemUnzipEnv) || !['0', 'false'].includes(_.toLower(useSystemUnzipEnv));
+    const useSystemUnzip = isEnvOptionEnabled('APPIUM_PREFER_SYSTEM_UNZIP', true);
     /**
      * Attempt to use use the system `unzip` (e.g., `/usr/bin/unzip`) due
      * to the significant performance improvement it provides over the native
@@ -539,84 +569,144 @@ async function unzipApp(zipPath, dstRoot, supportedAppExtensions) {
 }
 
 /**
- * @param {string} app
- * @returns {boolean}
+ * Transforms the given app link to the cache key.
+ * This is necessary to properly cache apps
+ * having the same address, but different query strings,
+ * for example ones stored in S3 using presigned URLs.
+ *
+ * @param {string} app App link.
+ * @returns {string} Transformed app link or the original arg if
+ * no transfromation is needed.
  */
-export function isPackageOrBundle(app) {
-  return /^([a-zA-Z0-9\-_]+\.[a-zA-Z0-9\-_]+)+$/.test(app);
+function toCacheKey(app) {
+  if (!isEnvOptionEnabled('APPIUM_APPS_CACHE_IGNORE_URL_QUERY') || !isSupportedUrl(app)) {
+    return app;
+  }
+  try {
+    const {href, search} = parseAppLink(app);
+    if (href && search) {
+      return href.replace(search, '');
+    }
+    if (href) {
+      return href;
+    }
+  } catch {}
+  return app;
 }
 
 /**
- * Finds all instances 'firstKey' and create a duplicate with the key 'secondKey',
- * Do the same thing in reverse. If we find 'secondKey', create a duplicate with the key 'firstKey'.
+ * Safely parses the given app link to a URL object
  *
- * This will cause keys to be overwritten if the object contains 'firstKey' and 'secondKey'.
-
- * @param {*} input Any type of input
- * @param {String} firstKey The first key to duplicate
- * @param {String} secondKey The second key to duplicate
+ * @param {string} appLink
+ * @returns {URL|import('@appium/types').StringRecord} Parsed URL object
+ * or an empty object if the parsing has failed
  */
-export function duplicateKeys(input, firstKey, secondKey) {
-  // If array provided, recursively call on all elements
-  if (_.isArray(input)) {
-    return input.map((item) => duplicateKeys(item, firstKey, secondKey));
+function parseAppLink(appLink) {
+  try {
+    return new URL(appLink);
+  } catch {
+    return {};
   }
+}
 
-  // If object, create duplicates for keys and then recursively call on values
-  if (_.isPlainObject(input)) {
-    const resultObj = {};
-    for (let [key, value] of _.toPairs(input)) {
-      const recursivelyCalledValue = duplicateKeys(value, firstKey, secondKey);
-      if (key === firstKey) {
-        resultObj[secondKey] = recursivelyCalledValue;
-      } else if (key === secondKey) {
-        resultObj[firstKey] = recursivelyCalledValue;
-      }
-      resultObj[key] = recursivelyCalledValue;
-    }
-    return resultObj;
+/**
+ * Checks whether we can threat the given app link
+ * as a URL,
+ *
+ * @param {string} app
+ * @returns {boolean} True if app is a supported URL
+ */
+function isSupportedUrl(app) {
+  try {
+    const {protocol} = parseAppLink(app);
+    return ['http:', 'https:'].includes(protocol);
+  } catch {
+    return false;
   }
-
-  // Base case. Return primitives without doing anything.
-  return input;
 }
 
 /**
- * Takes a desired capability and tries to JSON.parse it as an array,
- * and either returns the parsed array or a singleton array.
+ * Check if the given environment option is enabled
  *
- * @param {string|Array<String>} cap A desired capability
+ * @param {string} optionName Option name
+ * @param {boolean|null} [defaultValue=null] The value to return if the given env value
+ * is not set explcitly
+ * @returns {boolean} True if the option is enabled
  */
-export function parseCapsArray(cap) {
-  if (_.isArray(cap)) {
-    return cap;
+function isEnvOptionEnabled(optionName, defaultValue = null) {
+  const value = process.env[optionName];
+  if (!_.isNull(defaultValue) && _.isEmpty(value)) {
+    return defaultValue;
   }
+  return !_.isEmpty(value) && !['0', 'false', 'no'].includes(_.toLower(value));
+}
 
-  let parsedCaps;
-  try {
-    parsedCaps = JSON.parse(cap);
-    if (_.isArray(parsedCaps)) {
-      return parsedCaps;
-    }
-  } catch (ign) {
-    logger.warn(`Failed to parse capability as JSON array`);
-  }
-  if (_.isString(cap)) {
-    return [cap];
+/**
+ *
+ * @param {string} [envVarName]
+ * @param {number} defaultValue
+ * @returns {number}
+ */
+function toNaturalNumber(defaultValue, envVarName) {
+  if (!envVarName || _.isUndefined(process.env[envVarName])) {
+    return defaultValue;
   }
-  throw new Error(`must provide a string or JSON Array; received ${cap}`);
+  const num = parseInt(`${process.env[envVarName]}`, 10);
+  return num > 0 ? num : defaultValue;
 }
 
 /**
- * Generate a string that uniquely describes driver instance
- *
- * @param {import('@appium/types').Core} obj driver instance
- * @param {string?} sessionId session identifier (if exists)
+ * @param {string} app
+ * @param {string[]} supportedAppExtensions
  * @returns {string}
  */
-export function generateDriverLogPrefix(obj, sessionId = null) {
-  const instanceName = `${obj.constructor.name}@${node.getObjectId(obj).substring(0, 4)}`;
-  return sessionId ? `${instanceName} (${sessionId.substring(0, 8)})` : instanceName;
+function verifyAppExtension(app, supportedAppExtensions) {
+  if (supportedAppExtensions.map(_.toLower).includes(_.toLower(path.extname(app)))) {
+    return app;
+  }
+  throw new Error(
+    `New app path '${app}' did not have ` +
+      `${util.pluralize('extension', supportedAppExtensions.length, false)}: ` +
+      supportedAppExtensions
+  );
+}
+
+/**
+ * @param {string} folderPath
+ * @returns {Promise<number>}
+ */
+async function calculateFolderIntegrity(folderPath) {
+  return (await fs.glob('**/*', {cwd: folderPath})).length;
+}
+
+/**
+ * @param {string} filePath
+ * @returns {Promise<string>}
+ */
+async function calculateFileIntegrity(filePath) {
+  return await fs.hash(filePath);
+}
+
+/**
+ * @param {string} currentPath
+ * @param {import('@appium/types').StringRecord} expectedIntegrity
+ * @returns {Promise<boolean>}
+ */
+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;
 }
 
 /** @type {import('@appium/types').DriverHelpers} */

package/lib/express/middleware.js

@@ -2,8 +2,16 @@ import _ from 'lodash';
 import log from './logger';
 import {errors} from '../protocol';
 import {handleIdempotency} from './idempotency';
+import {pathToRegexp} from 'path-to-regexp';
 
-function allowCrossDomain(req, res, next) {
+/**
+ *
+ * @param {import('express').Request} req
+ * @param {import('express').Response} res
+ * @param {import('express').NextFunction} next
+ * @returns {any}
+ */
+export function allowCrossDomain(req, res, next) {
   try {
     res.header('Access-Control-Allow-Origin', '*');
     res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, OPTIONS, DELETE');
@@ -22,7 +30,11 @@ function allowCrossDomain(req, res, next) {
   next();
 }
 
-function allowCrossDomainAsyncExecute(basePath) {
+/**
+ * @param {string} basePath
+ * @returns {import('express').RequestHandler}
+ */
+export function allowCrossDomainAsyncExecute(basePath) {
   return (req, res, next) => {
     // there are two paths for async responses, so cover both
     // https://regex101.com/r/txYiEz/1
@@ -36,12 +48,17 @@ function allowCrossDomainAsyncExecute(basePath) {
   };
 }
 
-function fixPythonContentType(basePath) {
+/**
+ *
+ * @param {string} basePath
+ * @returns {import('express').RequestHandler}
+ */
+export function fixPythonContentType(basePath) {
   return (req, res, next) => {
     // hack because python client library gives us wrong content-type
     if (
       new RegExp(`^${_.escapeRegExp(basePath)}`).test(req.path) &&
-      /^Python/.test(req.headers['user-agent'])
+      /^Python/.test(req.headers['user-agent'] ?? '')
     ) {
       if (req.headers['content-type'] === 'application/x-www-form-urlencoded') {
         req.headers['content-type'] = 'application/json; charset=utf-8';
@@ -51,14 +68,55 @@ function fixPythonContentType(basePath) {
   };
 }
 
-function defaultToJSONContentType(req, res, next) {
+/**
+ *
+ * @param {import('express').Request} req
+ * @param {import('express').Response} res
+ * @param {import('express').NextFunction} next
+ * @returns {any}
+ */
+export function defaultToJSONContentType(req, res, next) {
   if (!req.headers['content-type']) {
     req.headers['content-type'] = 'application/json; charset=utf-8';
   }
   next();
 }
 
-function catchAllHandler(err, req, res, next) {
+/**
+ *
+ * @param {import('@appium/types').StringRecord<import('@appium/types').WSServer>} webSocketsMapping
+ * @returns {import('express').RequestHandler}
+ */
+export function handleUpgrade(webSocketsMapping) {
+  return (req, res, next) => {
+    if (!req.headers?.upgrade || _.toLower(req.headers.upgrade) !== 'websocket') {
+      return next();
+    }
+    let currentPathname;
+    try {
+      currentPathname = new URL(req.url ?? '').pathname;
+    } catch {
+      currentPathname = req.url ?? '';
+    }
+    for (const [pathname, wsServer] of _.toPairs(webSocketsMapping)) {
+      if (pathToRegexp(pathname).test(currentPathname)) {
+        return wsServer.handleUpgrade(req, req.socket, Buffer.from(''), (ws) => {
+          wsServer.emit('connection', ws, req);
+        });
+      }
+    }
+    log.info(`Did not match the websocket upgrade request at ${currentPathname} to any known route`);
+    next();
+  };
+}
+
+/**
+ * @param {Error} err
+ * @param {import('express').Request} req
+ * @param {import('express').Response} res
+ * @param {import('express').NextFunction} next
+ */
+export function catchAllHandler(err, req, res, next) {
   if (res.headersSent) {
     return next(err);
   }
@@ -79,7 +137,11 @@ function catchAllHandler(err, req, res, next) {
   log.error(err);
 }
 
-function catch404Handler(req, res) {
+/**
+ * @param {import('express').Request} req
+ * @param {import('express').Response} res
+ */
+export function catch404Handler(req, res) {
   log.debug(`No route found for ${req.url}`);
   const error = errors.UnknownCommandError;
   res.status(error.w3cStatus()).json(
@@ -107,12 +169,4 @@ function patchWithSessionId(req, body) {
   return body;
 }
 
-export {
-  allowCrossDomain,
-  fixPythonContentType,
-  defaultToJSONContentType,
-  catchAllHandler,
-  allowCrossDomainAsyncExecute,
-  handleIdempotency,
-  catch404Handler,
-};
+export { handleIdempotency };

package/lib/express/server.js

@@ -14,6 +14,7 @@ import {
   catchAllHandler,
   allowCrossDomainAsyncExecute,
   handleIdempotency,
+  handleUpgrade,
   catch404Handler,
 } from './middleware';
 import {guineaPig, guineaPigScrollable, guineaPigAppBanner, welcome, STATIC_DIR} from './static';
@@ -109,6 +110,7 @@ async function server(opts) {
         allowCors,
         basePath,
         extraMethodMap,
+        webSocketsMapping: appiumServer.webSocketsMapping,
       });
       // allow extensions to update the app and http server objects
       for (const updater of serverUpdaters) {
@@ -139,6 +141,7 @@ function configureServer({
   allowCors = true,
   basePath = DEFAULT_BASE_PATH,
   extraMethodMap = {},
+  webSocketsMapping = {},
 }) {
   basePath = normalizeBasePath(basePath);
 
@@ -152,7 +155,7 @@ function configureServer({
   app.use(`${basePath}/produce_error`, produceError);
   app.use(`${basePath}/crash`, produceCrash);
 
-  // add middlewares
+  app.use(handleUpgrade(webSocketsMapping));
   if (allowCors) {
     app.use(allowCrossDomain);
   } else {
@@ -195,6 +198,7 @@ function configureHttp({httpServer, reject, keepAliveTimeout}) {
    * @type {AppiumServer}
    */
   const appiumServer = /** @type {any} */ (httpServer);
+  appiumServer.webSocketsMapping = {};
   appiumServer.addWebSocketHandler = addWebSocketHandler;
   appiumServer.removeWebSocketHandler = removeWebSocketHandler;
   appiumServer.removeAllWebSocketHandlers = removeAllWebSocketHandlers;
@@ -370,4 +374,5 @@ export {server, configureServer, normalizeBasePath};
  * @property {boolean} [allowCors]
  * @property {string} [basePath]
  * @property {MethodMap} [extraMethodMap]
+ * @property {import('@appium/types').StringRecord} [webSocketsMapping={}]
  */

package/lib/express/websocket.js

@@ -1,8 +1,6 @@
 /* eslint-disable require-await */
 import _ from 'lodash';
-import {URL} from 'url';
 import B from 'bluebird';
-import { pathToRegexp } from 'path-to-regexp';
 
 const DEFAULT_WS_PATHNAME_PREFIX = '/ws';
 
@@ -11,27 +9,6 @@ const DEFAULT_WS_PATHNAME_PREFIX = '/ws';
  * @type {AppiumServer['addWebSocketHandler']}
  */
 async function addWebSocketHandler(handlerPathname, handlerServer) {
-  if (_.isUndefined(this.webSocketsMapping)) {
-    this.webSocketsMapping = {};
-    // https://github.com/websockets/ws/pull/885
-    this.on('upgrade', (request, socket, head) => {
-      let currentPathname;
-      try {
-        currentPathname = new URL(request.url ?? '').pathname;
-      } catch {
-        currentPathname = request.url ?? '';
-      }
-      for (const [pathname, wsServer] of _.toPairs(this.webSocketsMapping)) {
-        if (pathToRegexp(pathname).test(currentPathname)) {
-          wsServer.handleUpgrade(request, socket, head, (ws) => {
-            wsServer.emit('connection', ws, request);
-          });
-          return;
-        }
-      }
-      socket.destroy();
-    });
-  }
   this.webSocketsMapping[handlerPathname] = handlerServer;
 }
 
@@ -40,10 +17,6 @@ async function addWebSocketHandler(handlerPathname, handlerServer) {
  * @type {AppiumServer['getWebSocketHandlers']}
  */
 async function getWebSocketHandlers(keysFilter = null) {
-  if (_.isEmpty(this.webSocketsMapping)) {
-    return {};
-  }
-
   return _.toPairs(this.webSocketsMapping).reduce((acc, [pathname, wsServer]) => {
     if (!_.isString(keysFilter) || pathname.includes(keysFilter)) {
       acc[pathname] = wsServer;