appium-remote-debugger 11.5.4 → 11.5.5

package/lib/mixins/connect.js

@@ -1,14 +1,12 @@
 import {
   pageArrayFromDict,
   getPossibleDebuggerAppKeys,
-  simpleStringify,
 } from '../utils';
 import events from './events';
 import { timing } from '@appium/support';
 import { retryInterval, waitForCondition } from 'asyncbox';
 import _ from 'lodash';
 
-
 const APP_CONNECT_TIMEOUT_MS = 0;
 const APP_CONNECT_INTERVAL_MS = 100;
 const SELECT_APP_RETRIES = 20;
@@ -16,19 +14,6 @@ const SELECT_APP_RETRY_SLEEP_MS = 500;
 const SAFARI_BUNDLE_ID = 'com.apple.mobilesafari';
 const BLANK_PAGE_URL = 'about:blank';
 
-/**
- * @typedef {Object} AppPages
- * @property {string} appIdKey
- * @property {Record<string, any>} pageDict
- */
-
-/**
- * @typedef {Object} App
- * @property {string} id
- * @property {string} bundleId
- */
-
-
 /**
  *
  * @this {import('../remote-debugger').RemoteDebugger}
@@ -104,21 +89,12 @@ export async function disconnect () {
   this.teardown();
 }
 
-/**
- * @typedef {Object} Page
- * @property {string} url
- * @property {string} title
- * @property {number} id
- * @property {boolean} isKey
- * @property {string} [bundleId]
- */
-
 /**
  *
  * @this {import('../remote-debugger').RemoteDebugger}
- * @param {string?} currentUrl
- * @param {number} [maxTries]
- * @param {boolean} [ignoreAboutBlankUrl]
+ * @param {string?} [currentUrl=null]
+ * @param {number} [maxTries=SELECT_APP_RETRIES]
+ * @param {boolean} [ignoreAboutBlankUrl=false]
  * @returns {Promise<Page[]>}
  */
 export async function selectApp (currentUrl = null, maxTries = SELECT_APP_RETRIES, ignoreAboutBlankUrl = false) {
@@ -134,25 +110,14 @@ export async function selectApp (currentUrl = null, maxTries = SELECT_APP_RETRIE
       return [];
     }
 
-    const {appIdKey, pageDict} = await this.searchForApp(currentUrl, maxTries, ignoreAboutBlankUrl) ?? {};
-
-    // if, after all this, we have no dictionary, we have failed
-    if (!appIdKey || !pageDict) {
-      throw this.log.errorWithException(`Could not connect to a valid app after ${maxTries} tries.`);
-    }
-
+    const { appIdKey } = await this.searchForApp(currentUrl, maxTries, ignoreAboutBlankUrl);
     if (this.appIdKey !== appIdKey) {
       this.log.debug(`Received altered app id, updating from '${this.appIdKey}' to '${appIdKey}'`);
       this.appIdKey = appIdKey;
     }
-
-    logApplicationDictionary.bind(this)(this.appDict);
-
+    logApplicationDictionary.bind(this)();
     // translate the dictionary into a useful form, and return to sender
-    const pageArray = _.isEmpty(this.appDict[appIdKey].pageArray)
-      ? pageArrayFromDict(pageDict)
-      : this.appDict[appIdKey].pageArray;
-    this.log.debug(`Finally selecting app ${this.appIdKey}: ${simpleStringify(pageArray)}`);
+    this.log.debug(`Finally selecting app ${this.appIdKey}`);
 
     /** @type {Page[]} */
     const fullPageArray = [];
@@ -184,80 +149,85 @@ export async function selectApp (currentUrl = null, maxTries = SELECT_APP_RETRIE
  * @param {string?} currentUrl
  * @param {number} maxTries
  * @param {boolean} ignoreAboutBlankUrl
- * @returns {Promise<AppPages?>}
+ * @returns {Promise<AppPage>}
  */
 export async function searchForApp (currentUrl, maxTries, ignoreAboutBlankUrl) {
   const bundleIds = this.includeSafari && !this.isSafari
     ? [this.bundleId, ...this.additionalBundleIds, SAFARI_BUNDLE_ID]
     : [this.bundleId, ...this.additionalBundleIds];
   let retryCount = 0;
-  try {
-    return await retryInterval(maxTries, SELECT_APP_RETRY_SLEEP_MS, async () => {
-      logApplicationDictionary.bind(this)(this.appDict);
-      const possibleAppIds = getPossibleDebuggerAppKeys(/** @type {string[]} */ (bundleIds), this.appDict);
-      this.log.debug(`Trying out the possible app ids: ${possibleAppIds.join(', ')} (try #${retryCount + 1} of ${maxTries})`);
-      for (const attemptedAppIdKey of possibleAppIds) {
+  return /** @type {AppPage} */ (await retryInterval(maxTries, SELECT_APP_RETRY_SLEEP_MS, async () => {
+    logApplicationDictionary.bind(this)();
+    const possibleAppIds = getPossibleDebuggerAppKeys(/** @type {string[]} */ (bundleIds), this.appDict);
+    this.log.debug(`Trying out the possible app ids: ${possibleAppIds.join(', ')} (try #${retryCount + 1} of ${maxTries})`);
+    for (const attemptedAppIdKey of possibleAppIds) {
+      try {
+        if (!this.appDict[attemptedAppIdKey].isActive) {
+          this.log.debug(`Skipping app '${attemptedAppIdKey}' because it is not active`);
+          continue;
+        }
+
+        this.log.debug(`Attempting app '${attemptedAppIdKey}'`);
+        /** @type {string} */
+        let appIdKey;
+        /** @type {import('@appium/types').StringRecord} */
+        let pageDict;
         try {
-          if (!this.appDict[attemptedAppIdKey].isActive) {
-            this.log.debug(`Skipping app '${attemptedAppIdKey}' because it is not active`);
-            continue;
-          }
-          this.log.debug(`Attempting app '${attemptedAppIdKey}'`);
-          const [appIdKey, pageDict] = await this.requireRpcClient().selectApp(attemptedAppIdKey);
-          // in iOS 8.2 the connect logic happens, but with an empty dictionary
-          // which leads to the remote debugger getting disconnected, and into a loop
-          if (_.isEmpty(pageDict)) {
-            this.log.debug('Empty page dictionary received. Trying again.');
-            continue;
-          }
+          [appIdKey, pageDict] = await this.requireRpcClient().selectApp(attemptedAppIdKey);
+        } catch (e) {
+          this.log.info(`Skipping app '${attemptedAppIdKey}'. Original error: ${e.message}`);
+          continue;
+        }
 
-          // save the page array for this app
-          this.appDict[appIdKey].pageArray = pageArrayFromDict(pageDict);
+        // save the page array for this app
+        this.appDict[appIdKey].pageArray = pageArrayFromDict(pageDict);
 
-          // if we are looking for a particular url, make sure we
-          // have the right page. Ignore empty or undefined urls.
-          // Ignore about:blank if requested.
-          const result = this.searchForPage(this.appDict, currentUrl, ignoreAboutBlankUrl);
-          if (result) {
-            return result;
-          }
+        // if we are looking for a particular url, make sure we
+        // have the right page. Ignore empty or undefined urls.
+        // Ignore about:blank if requested.
+        const result = this.searchForPage(this.appDict, currentUrl, ignoreAboutBlankUrl);
+        if (result) {
+          return result;
+        }
 
-          if (currentUrl) {
-            this.log.debug(`Received app, but expected url ('${currentUrl}') was not found. Trying again.`);
-          } else {
-            this.log.debug('Received app, but no match was found. Trying again.');
-          }
-        } catch (err) {
-          this.log.debug(`Error checking application: '${err.message}'. Retrying connection`);
+        if (currentUrl) {
+          this.log.debug(`Received app, but expected url ('${currentUrl}') was not found. Trying again.`);
+        } else {
+          this.log.debug('Received app, but no match was found. Trying again.');
         }
+      } catch (err) {
+        this.log.debug(err.stack);
+        this.log.warn(`Error checking application ${attemptedAppIdKey}: '${err.message}'`);
       }
-      retryCount++;
-      throw new Error('Failed to find an app to select');
-    });
-  } catch (ign) {
-    this.log.errorAndThrow(`Could not connect to a valid app after ${maxTries} tries.`);
-  }
-  return null;
+    }
+    retryCount++;
+    throw new Error(
+      `Could not connect to a valid webapp. Make sure it is debuggable and has at least one active page.`
+    );
+  }));
 }
 
 /**
  *
  * @this {import('../remote-debugger').RemoteDebugger}
- * @param {Record<string, any>} appsDict
+ * @param {Record<string, import('../utils').AppInfo>} appsDict
  * @param {string?} currentUrl
  * @param {boolean} [ignoreAboutBlankUrl]
- * @returns {AppPages?}
+ * @returns {AppPage?}
  */
 export function searchForPage (appsDict, currentUrl = null, ignoreAboutBlankUrl = false) {
   for (const appDict of _.values(appsDict)) {
-    if (!appDict || !appDict.isActive || !appDict.pageArray || appDict.pageArray.promise) {
+    if (!appDict || !appDict.isActive || !appDict.pageArray || _.isEmpty(appDict.pageArray)) {
       continue;
     }
 
-    for (const dict of appDict.pageArray) {
-      if ((!ignoreAboutBlankUrl || dict.url !== BLANK_PAGE_URL) &&
-          (!currentUrl || dict.url === currentUrl || dict.url === `${currentUrl}/`)) {
-        return { appIdKey: appDict.id, pageDict: dict };
+    for (const page of appDict.pageArray) {
+      if ((!ignoreAboutBlankUrl || page.url !== BLANK_PAGE_URL) &&
+          (!currentUrl || page.url === currentUrl || page.url === `${currentUrl}/`)) {
+        return {
+          appIdKey: appDict.id,
+          pageDict: page
+        };
       }
     }
   }
@@ -292,23 +262,11 @@ export async function selectPage (appIdKey, pageIdKey, skipReadyCheck = false) {
 
 /**
  * @this {import('../remote-debugger').RemoteDebugger}
- * @param {Record<string, any>} apps
  * @returns {void}
  */
-function logApplicationDictionary (apps) {
-
-  function getValueString (key, value) {
-    if (_.isFunction(value)) {
-      return '[Function]';
-    }
-    if (key === 'pageArray' && !_.isArray(value)) {
-      return `"Waiting for data"`;
-    }
-    return JSON.stringify(value);
-  }
-
+function logApplicationDictionary () {
   this.log.debug('Current applications available:');
-  for (const [app, info] of _.toPairs(apps)) {
+  for (const [app, info] of _.toPairs(this.appDict)) {
     this.log.debug(`    Application: "${app}"`);
     for (const [key, value] of _.toPairs(info)) {
       if (key === 'pageArray' && Array.isArray(value) && value.length) {
@@ -321,9 +279,30 @@ function logApplicationDictionary (apps) {
           }
         }
       } else {
-        const valueString = getValueString(key, value);
+        const valueString = _.isFunction(value) ? '[Function]' : JSON.stringify(value);
         this.log.debug(`        ${key}: ${valueString}`);
       }
     }
   }
 }
+
+/**
+ * @typedef {Object} AppPage
+ * @property {string} appIdKey
+ * @property {Page} pageDict
+ */
+
+/**
+ * @typedef {Object} App
+ * @property {string} id
+ * @property {string} bundleId
+ */
+
+/**
+ * @typedef {Object} Page
+ * @property {string} url
+ * @property {string} title
+ * @property {number} id
+ * @property {boolean} isKey
+ * @property {string} [bundleId]
+ */

package/lib/mixins/message-handlers.js

@@ -2,9 +2,7 @@ import events from './events';
 import {
   pageArrayFromDict,
   getDebuggerAppKey,
-  simpleStringify,
   appInfoFromDict,
-  deferredPromise,
 } from '../utils';
 import _ from 'lodash';
 
@@ -21,48 +19,39 @@ import _ from 'lodash';
  * @param {Record<string, any>} pageDict
  * @returns {Promise<void>}
  */
+// eslint-disable-next-line require-await
 export async function onPageChange (err, appIdKey, pageDict) {
   if (_.isEmpty(pageDict)) {
     return;
   }
 
-  const pageArray = pageArrayFromDict(pageDict);
-
-  await useAppDictLock.bind(this)((/** @type {() => void} */ done) => {
-    try {
-      // save the page dict for this app
-      if (this.appDict[appIdKey]) {
-        if (this.appDict[appIdKey].pageArray) {
-          if (this.appDict[appIdKey].pageArray.resolve) {
-            // pageDict is a pending promise, so resolve
-            this.appDict[appIdKey].pageArray.resolve();
-          } else {
-            // we have a pre-existing pageDict
-            if (_.isEqual(this.appDict[appIdKey].pageArray, pageArray)) {
-              this.log.debug(`Received page change notice for app '${appIdKey}' ` +
-                        `but the listing has not changed. Ignoring.`);
-              return done();
-            }
-          }
-        }
-        // keep track of the page dictionary
-        this.appDict[appIdKey].pageArray = pageArray;
-      }
-    } finally {
-      done();
+  const currentPages = pageArrayFromDict(pageDict);
+  // save the page dict for this app
+  if (this.appDict[appIdKey]) {
+    const previousPages = this.appDict[appIdKey].pageArray;
+    // we have a pre-existing pageDict
+    if (previousPages && _.isEqual(previousPages, currentPages)) {
+      this.log.debug(
+        `Received page change notice for app '${appIdKey}' ` +
+        `but the listing has not changed. Ignoring.`
+      );
+      return;
     }
-  });
+    // keep track of the page dictionary
+    this.appDict[appIdKey].pageArray = currentPages;
+    this.log.debug(
+      `Pages changed for ${appIdKey}: ${JSON.stringify(previousPages)} -> ${JSON.stringify(currentPages)}`
+    );
+  }
 
   if (this._navigatingToPage) {
     // in the middle of navigating, so reporting a page change will cause problems
     return;
   }
 
-  this.log.debug(`Page changed: ${simpleStringify(pageDict, true)}`);
-
   this.emit(events.EVENT_PAGE_CHANGE, {
     appIdKey: appIdKey.replace('PID:', ''),
-    pageArray,
+    pageArray: currentPages,
   });
 }
 
@@ -72,28 +61,23 @@ export async function onPageChange (err, appIdKey, pageDict) {
  * @param {Record<string, any>} dict
  * @returns {Promise<void>}
  */
+// eslint-disable-next-line require-await
 export async function onAppConnect (err, dict) {
   const appIdKey = dict.WIRApplicationIdentifierKey;
   this.log.debug(`Notified that new application '${appIdKey}' has connected`);
-  await useAppDictLock.bind(this)((/** @type {() => void} */ done) => {
-    try {
-      updateAppsWithDict.bind(this)(dict);
-    } finally {
-      done();
-    }
-  });
+  updateAppsWithDict.bind(this)(dict);
 }
 
 /**
  * @this {import('../remote-debugger').RemoteDebugger}
  * @param {Error?} err
- * @param {Record<string, any>} dict
+ * @param {import('@appium/types').StringRecord} dict
  * @returns {void}
  */
 export function onAppDisconnect (err, dict) {
   const appIdKey = dict.WIRApplicationIdentifierKey;
   this.log.debug(`Application '${appIdKey}' disconnected. Removing from app dictionary.`);
- this.log.debug(`Current app is '${this.appIdKey}'`);
+  this.log.debug(`Current app is '${this.appIdKey}'`);
 
   // get rid of the entry in our app dictionary,
   // since it is no longer available
@@ -119,14 +103,10 @@ export function onAppDisconnect (err, dict) {
  * @param {Record<string, any>} dict
  * @returns {Promise<void>}
  */
+// eslint-disable-next-line require-await
 export async function onAppUpdate (err, dict) {
-  await useAppDictLock.bind(this)((/** @type {() => void} */ done) => {
-    try {
-      updateAppsWithDict.bind(this)(dict);
-    } finally {
-      done();
-    }
-  });
+  this.log.debug(`Notified that an application has been updated`);
+  updateAppsWithDict.bind(this)(dict);
 }
 
 /**
@@ -159,6 +139,7 @@ export function onCurrentState (err, state) {
  * @param {Record<string, any>} apps
  * @returns {Promise<void>}
  */
+// eslint-disable-next-line require-await
 export async function onConnectedApplicationList (err, apps) {
   this.log.debug(`Received connected applications list: ${_.keys(apps).join(', ')}`);
 
@@ -173,25 +154,9 @@ export async function onConnectedApplicationList (err, apps) {
     newDict[id] = entry;
   }
   // update the object's list of apps
-  await useAppDictLock.bind(this)((/** @type {() => void} */ done) => {
-    try {
-      _.defaults(this.appDict, newDict);
-    } finally {
-      done();
-    }
-  });
+  _.defaults(this.appDict, newDict);
 }
 
-/**
- * @this {import('../remote-debugger').RemoteDebugger}
- * @param {(done: () => any) => any} fn
- * @returns {Promise<any>}
- */
-async function useAppDictLock (fn) {
-  return await this._lock.acquire('appDict', fn);
-}
-
-
 /**
  *
  * @this {import('../remote-debugger').RemoteDebugger}
@@ -201,19 +166,14 @@ async function useAppDictLock (fn) {
 function updateAppsWithDict (dict) {
   // get the dictionary entry into a nice form, and add it to the
   // application dictionary
-  this.appDict = this.appDict || {};
-  let [id, entry] = appInfoFromDict(dict);
+  this.appDict ??= {};
+  const [id, entry] = appInfoFromDict(dict);
   if (this.appDict[id]) {
     // preserve the page dictionary for this entry
     entry.pageArray = this.appDict[id].pageArray;
   }
   this.appDict[id] = entry;
 
-  // add a promise to get the page dictionary
-  if (_.isUndefined(entry.pageArray)) {
-    entry.pageArray = deferredPromise();
-  }
-
   // try to get the app id from our connected apps
   if (!this.appIdKey) {
     this.appIdKey = getDebuggerAppKey(/** @type {string} */ (this.bundleId), this.appDict);

package/lib/remote-debugger.js

@@ -11,7 +11,7 @@ import * as screenshotMixins from './mixins/screenshot';
 import * as eventMixins from './mixins/events';
 import * as miscellaneousMixins from './mixins/misc';
 import _ from 'lodash';
-import AsyncLock from 'async-lock';
+
 
 export const REMOTE_DEBUGGER_PORT = 27753;
 /* How many milliseconds to wait for webkit to return a response before timing out */
@@ -160,8 +160,6 @@ export class RemoteDebugger extends EventEmitter {
     this.fullPageInitialization = fullPageInitialization;
 
     this.pageLoadStrategy = pageLoadStrategy;
-
-    this._lock = new AsyncLock();
   }
 
   /**

package/lib/rpc/rpc-client.js

@@ -745,29 +745,24 @@ export class RpcClient {
 
         reject(new Error('New application has connected'));
       };
-      // @ts-ignore messageHandler must be defined
-      this.messageHandler.prependOnceListener('_rpc_applicationConnected:', onAppChange);
+      this.messageHandler?.prependOnceListener('_rpc_applicationConnected:', onAppChange);
 
       // do the actual connecting to the app
-      return (async () => {
-        let pageDict, connectedAppIdKey;
+      (async () => {
         try {
-          ([connectedAppIdKey, pageDict] = await this.send('connectToApp', {
-            appIdKey
-          }));
+          const [connectedAppIdKey, pageDict] = await this.send('connectToApp', {appIdKey});
+          // sometimes the connect logic happens, but with an empty dictionary
+          // which leads to the remote debugger getting disconnected, and into a loop
+          if (_.isEmpty(pageDict)) {
+            reject(new Error('Empty page dictionary received'));
+          } else {
+            resolve([connectedAppIdKey, pageDict]);
+          }
         } catch (err) {
-          log.warn(`Unable to connect to app: ${err.message}`);
+          log.warn(`Unable to connect to the app: ${err.message}`);
           reject(err);
-        }
-
-        // sometimes the connect logic happens, but with an empty dictionary
-        // which leads to the remote debugger getting disconnected, and into a loop
-        if (_.isEmpty(pageDict)) {
-          let msg = 'Empty page dictionary received';
-          log.debug(msg);
-          reject(new Error(msg));
-        } else {
-          resolve([connectedAppIdKey, pageDict]);
+        } finally {
+          this.messageHandler?.off('_rpc_applicationConnected:', onAppChange);
         }
       })();
     });

package/lib/utils.js

@@ -38,10 +38,10 @@ export const RESPONSE_LOG_LENGTH = 100;
  * @property {boolean} isProxy
  * @property {string} name
  * @property {string} bundleId
- * @property {string} hostId
+ * @property {string} [hostId]
  * @property {boolean} isActive
  * @property {boolean|string} isAutomationEnabled
- * @property {any[]|undefined|DeferredPromise} [pageArray]
+ * @property {import('./mixins/connect').Page[]} [pageArray]
  */
 
 /**
@@ -83,28 +83,23 @@ export function appInfoFromDict (dict) {
   return [id, entry];
 }
 
-/*
+/**
  * Take a dictionary from the remote debugger and makes a more manageable
  * dictionary of pages available.
+ *
+ * @param {import('@appium/types').StringRecord} pageDict
+ * @returns {import('./mixins/connect').Page[]}
  */
 export function pageArrayFromDict (pageDict) {
-  if (pageDict.id) {
-    // the page is already translated, so wrap in an array and pass back
-    return [pageDict];
-  }
-  let newPageArray = [];
-  for (const dict of _.values(pageDict)) {
+  return _.values(pageDict)
     // count only WIRTypeWeb pages and ignore all others (WIRTypeJavaScript etc)
-    if (_.isUndefined(dict.WIRTypeKey) || ACCEPTED_PAGE_TYPES.includes(dict.WIRTypeKey)) {
-      newPageArray.push({
-        id: dict.WIRPageIdentifierKey,
-        title: dict.WIRTitleKey,
-        url: dict.WIRURLKey,
-        isKey: !_.isUndefined(dict.WIRConnectionIdentifierKey),
-      });
-    }
-  }
-  return newPageArray;
+    .filter((dict) => _.isUndefined(dict.WIRTypeKey) || ACCEPTED_PAGE_TYPES.includes(dict.WIRTypeKey))
+    .map((dict) => ({
+      id: dict.WIRPageIdentifierKey,
+      title: dict.WIRTitleKey,
+      url: dict.WIRURLKey,
+      isKey: !_.isUndefined(dict.WIRConnectionIdentifierKey),
+    }));
 }
 
 /**
@@ -147,7 +142,7 @@ export function getDebuggerAppKey (bundleId, appDict) {
  * Find app keys based on assigned bundleIds from appDict
  * When bundleIds includes a wildcard ('*'), returns all appKeys in appDict.
  * @param {string[]} bundleIds
- * @param {Record<string, any>} appDict
+ * @param {Record<string, AppInfo>} appDict
  * @returns {string[]}
  */
 export function getPossibleDebuggerAppKeys(bundleIds, appDict) {

package/package.json

@@ -4,7 +4,7 @@
   "keywords": [
     "appium"
   ],
-  "version": "11.5.4",
+  "version": "11.5.5",
   "author": "Appium Contributors",
   "license": "Apache-2.0",
   "repository": {
@@ -36,7 +36,6 @@
     "@appium/base-driver": "^9.0.0",
     "@appium/support": "^5.0.3",
     "appium-ios-device": "^2.0.0",
-    "async-lock": "^1.2.2",
     "asyncbox": "^3.0.0",
     "bluebird": "^3.4.7",
     "fancy-log": "^2.0.0",