appium-remote-debugger 15.3.3 → 15.3.5

package/lib/mixins/execute.ts

@@ -1,21 +1,17 @@
-import { errors } from '@appium/base-driver';
+import {errors} from '@appium/base-driver';
 import {
   checkParams,
   simpleStringify,
   convertJavascriptEvaluationResult,
   RESPONSE_LOG_LENGTH,
 } from '../utils';
-import { getScriptForAtom } from '../atoms';
-import { util, timing } from '@appium/support';
-import { retryInterval } from 'asyncbox';
+import {getScriptForAtom} from '../atoms';
+import {util, timing} from '@appium/support';
+import {retryInterval} from 'asyncbox';
 import _ from 'lodash';
-import {
-  getAppIdKey,
-  getPageIdKey,
-  getGarbageCollectOnExecute,
-} from './property-accessors';
-import type { RemoteDebugger } from '../remote-debugger';
-import type { AppIdKey, PageIdKey } from '../types';
+import {getAppIdKey, getPageIdKey, getGarbageCollectOnExecute} from './property-accessors';
+import type {RemoteDebugger} from '../remote-debugger';
+import type {AppIdKey, PageIdKey} from '../types';
 
 /* How many milliseconds to wait for webkit to return a response before timing out */
 const RPC_RESPONSE_TIMEOUT_MS = 5000;
@@ -33,14 +29,16 @@ export async function executeAtom(
   this: RemoteDebugger,
   atom: string,
   args: any[] = [],
-  frames: string[] = []
+  frames: string[] = [],
 ): Promise<any> {
   this.log.debug(`Executing atom '${atom}' with 'args=${JSON.stringify(args)}; frames=${frames}'`);
   const script = await getScriptForAtom(atom, args, frames);
   const value = await this.execute(script);
-  this.log.debug(`Received result for atom '${atom}' execution: ${_.truncate(simpleStringify(value), {
-    length: RESPONSE_LOG_LENGTH
-  })}`);
+  this.log.debug(
+    `Received result for atom '${atom}' execution: ${_.truncate(simpleStringify(value), {
+      length: RESPONSE_LOG_LENGTH,
+    })}`,
+  );
   return value;
 }
 
@@ -59,20 +57,26 @@ export async function executeAtomAsync(
   this: RemoteDebugger,
   atom: string,
   args: any[] = [],
-  frames: string[] = []
+  frames: string[] = [],
 ): Promise<any> {
   // helper to send directly to the web inspector
-  const evaluate = async (method: string, opts: any) => await this.requireRpcClient(true).send(method, Object.assign({
-    appIdKey: getAppIdKey(this),
-    pageIdKey: getPageIdKey(this),
-    returnByValue: false,
-  }, opts));
+  const evaluate = async (method: string, opts: any) =>
+    await this.requireRpcClient(true).send(
+      method,
+      Object.assign(
+        {
+          appIdKey: getAppIdKey(this),
+          pageIdKey: getPageIdKey(this),
+          returnByValue: false,
+        },
+        opts,
+      ),
+    );
 
   // first create a Promise on the page, saving the resolve/reject functions
   // as properties
   const promiseName = `appiumAsyncExecutePromise${util.uuidV4().replace(/-/g, '')}`;
-  const script =
-    `var res, rej;
+  const script = `var res, rej;
     window.${promiseName} = new Promise(function (resolve, reject) {
       res = resolve;
       rej = reject;
@@ -86,8 +90,7 @@ export async function executeAtomAsync(
   const promiseObjectId = obj.result.objectId;
 
   // execute the atom, calling back to the resolve function
-  const asyncCallBack =
-    `function (res) {
+  const asyncCallBack = `function (res) {
       window.${promiseName}.resolve(res);
       window.${promiseName}Value = res;
     }`;
@@ -109,7 +112,7 @@ export async function executeAtomAsync(
     }
     // awaitPromise is not always available, so simulate it with poll
     const retryWait = 100;
-    const timeout = (args.length >= 3) ? args[2] : RPC_RESPONSE_TIMEOUT_MS;
+    const timeout = args.length >= 3 ? args[2] : RPC_RESPONSE_TIMEOUT_MS;
     // if the timeout math turns up 0 retries, make sure it happens once
     const retries = parseInt(`${timeout / retryWait}`, 10) || 1;
     const timer = new timing.Timer().start();
@@ -130,14 +133,18 @@ export async function executeAtomAsync(
         });
       }
       // throw a TimeoutError, or else it needs to be caught and re-thrown
-      throw new errors.TimeoutError(`Timed out waiting for asynchronous script ` +
-                                    `result after ${timer.getDuration().asMilliSeconds.toFixed(0)}ms'));`);
+      throw new errors.TimeoutError(
+        `Timed out waiting for asynchronous script ` +
+          `result after ${timer.getDuration().asMilliSeconds.toFixed(0)}ms'));`,
+      );
     });
   } finally {
     try {
       // try to get rid of the promise
       await this.executeAtom(
-        'execute_script', [`delete window.${promiseName};`, [null, null], subcommandTimeout], frames
+        'execute_script',
+        [`delete window.${promiseName};`, [null, null], subcommandTimeout],
+        frames,
       );
     } catch {}
   }
@@ -154,7 +161,11 @@ export async function executeAtomAsync(
  *          converted to a usable format.
  */
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-export async function execute(this: RemoteDebugger, command: string, override?: boolean): Promise<any> {
+export async function execute(
+  this: RemoteDebugger,
+  command: string,
+  override?: boolean,
+): Promise<any> {
   const {appIdKey, pageIdKey} = checkParams({
     appIdKey: getAppIdKey(this),
     pageIdKey: getPageIdKey(this),
@@ -165,10 +176,7 @@ export async function execute(this: RemoteDebugger, command: string, override?:
   }
 
   const rpcClient = this.requireRpcClient(true);
-  await rpcClient.waitForPage(
-    appIdKey as AppIdKey,
-    pageIdKey as PageIdKey
-  );
+  await rpcClient.waitForPage(appIdKey as AppIdKey, pageIdKey as PageIdKey);
   this.log.debug(`Sending javascript command: '${_.truncate(command, {length: 50})}'`);
   const res = await rpcClient.send('Runtime.evaluate', {
     expression: command,
@@ -193,7 +201,7 @@ export async function callFunction(
   this: RemoteDebugger,
   objectId: string,
   fn: string,
-  args?: any[]
+  args?: any[],
 ): Promise<any> {
   const {appIdKey, pageIdKey} = checkParams({
     appIdKey: getAppIdKey(this),

package/lib/mixins/message-handlers.ts

@@ -1,8 +1,5 @@
-import { events } from './events';
-import {
-  pageArrayFromDict,
-  appInfoFromDict,
-} from '../utils';
+import {events} from './events';
+import {pageArrayFromDict, appInfoFromDict} from '../utils';
 import _ from 'lodash';
 import {
   setAppIdKey,
@@ -14,9 +11,9 @@ import {
   setConnectedDrivers,
   getSkippedApps,
 } from './property-accessors';
-import type { RemoteDebugger } from '../remote-debugger';
-import type { StringRecord } from '@appium/types';
-import type { AppDict } from '../types';
+import type {RemoteDebugger} from '../remote-debugger';
+import type {StringRecord} from '@appium/types';
+import type {AppDict} from '../types';
 
 /*
  * Generic callbacks used throughout the lifecycle of the Remote Debugger.
@@ -36,7 +33,7 @@ export async function onPageChange(
   this: RemoteDebugger,
   err: Error | null | undefined,
   appIdKey: string,
-  pageDict: StringRecord
+  pageDict: StringRecord,
 ): Promise<void> {
   if (_.isEmpty(pageDict)) {
     return;
@@ -50,14 +47,14 @@ export async function onPageChange(
     if (previousPages && _.isEqual(previousPages, currentPages)) {
       this.log.debug(
         `Received page change notice for app '${appIdKey}' ` +
-        `but the listing has not changed. Ignoring.`
+          `but the listing has not changed. Ignoring.`,
       );
       return;
     }
     // keep track of the page dictionary
     getAppDict(this)[appIdKey].pageArray = currentPages;
     this.log.debug(
-      `Pages changed for ${appIdKey}: ${JSON.stringify(previousPages)} -> ${JSON.stringify(currentPages)}`
+      `Pages changed for ${appIdKey}: ${JSON.stringify(previousPages)} -> ${JSON.stringify(currentPages)}`,
     );
   }
 
@@ -83,7 +80,7 @@ export async function onPageChange(
 export async function onAppConnect(
   this: RemoteDebugger,
   err: Error | null | undefined,
-  dict: StringRecord
+  dict: StringRecord,
 ): Promise<void> {
   const appIdKey = dict.WIRApplicationIdentifierKey;
   this.log.debug(`Notified that new application '${appIdKey}' has connected`);
@@ -103,7 +100,7 @@ export async function onAppConnect(
 export function onAppDisconnect(
   this: RemoteDebugger,
   err: Error | null | undefined,
-  dict: StringRecord
+  dict: StringRecord,
 ): void {
   const appIdKey = dict.WIRApplicationIdentifierKey;
   this.log.debug(`Application '${appIdKey}' disconnected. Removing from app dictionary.`);
@@ -137,7 +134,7 @@ export function onAppDisconnect(
 export async function onAppUpdate(
   this: RemoteDebugger,
   err: Error | null | undefined,
-  dict: StringRecord
+  dict: StringRecord,
 ): Promise<void> {
   this.log.debug(`Notified that an application has been updated`);
   updateAppsWithDict.bind(this)(dict);
@@ -154,7 +151,7 @@ export async function onAppUpdate(
 export function onConnectedDriverList(
   this: RemoteDebugger,
   err: Error | null | undefined,
-  drivers: StringRecord
+  drivers: StringRecord,
 ): void {
   setConnectedDrivers(this, drivers.WIRDriverDictionaryKey);
   this.log.debug(`Received connected driver list: ${JSON.stringify(this.connectedDrivers)}`);
@@ -173,12 +170,14 @@ export function onConnectedDriverList(
 export function onCurrentState(
   this: RemoteDebugger,
   err: Error | null | undefined,
-  state: StringRecord
+  state: StringRecord,
 ): void {
   setCurrentState(this, state.WIRAutomationAvailabilityKey);
   // This state changes when 'Remote Automation' in 'Settings app' > 'Safari' > 'Advanced' > 'Remote Automation' changes
   // WIRAutomationAvailabilityAvailable or WIRAutomationAvailabilityNotAvailable
-  this.log.debug(`Received connected automation availability state: ${JSON.stringify(this.currentState)}`);
+  this.log.debug(
+    `Received connected automation availability state: ${JSON.stringify(this.currentState)}`,
+  );
 }
 
 /**
@@ -192,7 +191,7 @@ export function onCurrentState(
 export async function onConnectedApplicationList(
   this: RemoteDebugger,
   err: Error | null | undefined,
-  apps: StringRecord
+  apps: StringRecord,
 ): Promise<void> {
   this.log.debug(`Received connected applications list: ${_.keys(apps).join(', ')}`);
 
@@ -233,8 +232,10 @@ export function getDebuggerAppKey(this: RemoteDebugger, bundleId: string): strin
     let proxyAppId: string | undefined;
     for (const [key, data] of _.toPairs(getAppDict(this))) {
       if (data.isProxy && data.hostId === appId) {
-        this.log.debug(`Found separate bundleId '${data.bundleId}' ` +
-                  `acting as proxy for '${bundleId}', with app id '${key}'`);
+        this.log.debug(
+          `Found separate bundleId '${data.bundleId}' ` +
+            `acting as proxy for '${bundleId}', with app id '${key}'`,
+        );
         // set the app id... the last one will be used, so just keep re-assigning
         proxyAppId = key;
       }

package/lib/mixins/misc.ts

@@ -1,10 +1,7 @@
-import { checkParams } from '../utils';
-import B, { TimeoutError as BTimeoutError } from 'bluebird';
-import {
-  getAppIdKey,
-  getPageIdKey,
-} from './property-accessors';
-import type { RemoteDebugger } from '../remote-debugger';
+import {checkParams} from '../utils';
+import B, {TimeoutError as BTimeoutError} from 'bluebird';
+import {getAppIdKey, getPageIdKey} from './property-accessors';
+import type {RemoteDebugger} from '../remote-debugger';
 
 const SAFARI_BUNDLE_ID = 'com.apple.mobilesafari';
 const GARBAGE_COLLECT_TIMEOUT_MS = 5000;
@@ -15,7 +12,7 @@ const GARBAGE_COLLECT_TIMEOUT_MS = 5000;
  */
 export async function launchSafari(this: RemoteDebugger): Promise<void> {
   await this.requireRpcClient().send('launchApplication', {
-    bundleId: SAFARI_BUNDLE_ID
+    bundleId: SAFARI_BUNDLE_ID,
   });
 }
 
@@ -28,7 +25,7 @@ export async function launchSafari(this: RemoteDebugger): Promise<void> {
  */
 export async function startTimeline(
   this: RemoteDebugger,
-  fn: import('../types').EventListener
+  fn: import('../types').EventListener,
 ): Promise<any> {
   this.log.debug('Starting to record the timeline');
   this.requireRpcClient().on('Timeline.eventRecorded', fn);
@@ -77,7 +74,7 @@ export async function overrideUserAgent(this: RemoteDebugger, value: string): Pr
  */
 export async function isJavascriptExecutionBlocked(
   this: RemoteDebugger,
-  timeoutMs: number = 1000
+  timeoutMs: number = 1000,
 ): Promise<boolean> {
   try {
     await B.resolve(
@@ -86,7 +83,7 @@ export async function isJavascriptExecutionBlocked(
         returnByValue: true,
         appIdKey: getAppIdKey(this),
         pageIdKey: getPageIdKey(this),
-      })
+      }),
     ).timeout(timeoutMs);
     return false;
   } catch {
@@ -104,7 +101,7 @@ export async function isJavascriptExecutionBlocked(
  */
 export async function garbageCollect(
   this: RemoteDebugger,
-  timeoutMs: number = GARBAGE_COLLECT_TIMEOUT_MS
+  timeoutMs: number = GARBAGE_COLLECT_TIMEOUT_MS,
 ): Promise<void> {
   this.log.debug(`Garbage collecting with ${timeoutMs}ms timeout`);
 
@@ -119,11 +116,11 @@ export async function garbageCollect(
   }
 
   try {
-    await B.resolve(this.requireRpcClient().send(
-      'Heap.gc', {
+    await B.resolve(
+      this.requireRpcClient().send('Heap.gc', {
         appIdKey: getAppIdKey(this),
         pageIdKey: getPageIdKey(this),
-      })
+      }),
     ).timeout(timeoutMs);
     this.log.debug(`Garbage collection successful`);
   } catch (e: any) {

package/lib/mixins/navigate.ts

@@ -1,8 +1,8 @@
-import { checkParams } from '../utils';
-import { events } from './events';
-import { timing, util } from '@appium/support';
+import {checkParams} from '../utils';
+import {events} from './events';
+import {timing, util} from '@appium/support';
 import _ from 'lodash';
-import B, { TimeoutError as BTimeoutError } from 'bluebird';
+import B, {TimeoutError as BTimeoutError} from 'bluebird';
 import {
   getAppIdKey,
   setPageLoading,
@@ -13,8 +13,8 @@ import {
   getPageIdKey,
   setNavigatingToPage,
 } from './property-accessors';
-import type { RemoteDebugger } from '../remote-debugger';
-import type { AppIdKey, PageIdKey } from '../types';
+import type {RemoteDebugger} from '../remote-debugger';
+import type {AppIdKey, PageIdKey} from '../types';
 
 export const DEFAULT_PAGE_READINESS_TIMEOUT_MS = 20 * 1000;
 const PAGE_READINESS_CHECK_INTERVAL_MS = 50;
@@ -25,7 +25,7 @@ const PAGE_READINESS_CHECK_INTERVAL_MS = 50;
 const PAGE_LOAD_STRATEGY = Object.freeze({
   EAGER: 'eager',
   NONE: 'none',
-  NORMAL: 'normal'
+  NORMAL: 'normal',
 });
 
 /**
@@ -78,7 +78,10 @@ export function isPageLoadingCompleted(this: RemoteDebugger, readyState: string)
  * @param startPageLoadTimer - Optional timer instance to use for tracking elapsed time.
  *                             If not provided, a new timer will be created and started.
  */
-export async function waitForDom(this: RemoteDebugger, startPageLoadTimer?: timing.Timer): Promise<void> {
+export async function waitForDom(
+  this: RemoteDebugger,
+  startPageLoadTimer?: timing.Timer,
+): Promise<void> {
   const readinessTimeoutMs = this.pageLoadMs;
   this.log.debug(`Waiting up to ${readinessTimeoutMs}ms for the page to be ready`);
   const timer = startPageLoadTimer ?? new timing.Timer().start();
@@ -86,49 +89,53 @@ export async function waitForDom(this: RemoteDebugger, startPageLoadTimer?: timi
   let isPageLoading = true;
   setPageLoading(this, true);
   setPageLoadDelay(this, util.cancellableDelay(readinessTimeoutMs));
-  const pageReadinessPromise = B.resolve((async () => {
-    let retry = 0;
-    while (isPageLoading) {
-      // if we are ready, or we've spend too much time on this
-      const elapsedMs = timer.getDuration().asMilliSeconds;
-      // exponential retry
-      const intervalMs = Math.min(
-        PAGE_READINESS_CHECK_INTERVAL_MS * Math.pow(2, retry),
-        readinessTimeoutMs - elapsedMs
-      );
-      await B.delay(intervalMs);
-      // we can get this called in the middle of trying to find a new app
-      if (!getAppIdKey(this)) {
-        this.log.debug('Not connected to an application. Ignoring page readiess check');
-        return;
-      }
-      if (!isPageLoading) {
-        return;
-      }
+  const pageReadinessPromise = B.resolve(
+    (async () => {
+      let retry = 0;
+      while (isPageLoading) {
+        // if we are ready, or we've spend too much time on this
+        const elapsedMs = timer.getDuration().asMilliSeconds;
+        // exponential retry
+        const intervalMs = Math.min(
+          PAGE_READINESS_CHECK_INTERVAL_MS * Math.pow(2, retry),
+          readinessTimeoutMs - elapsedMs,
+        );
+        await B.delay(intervalMs);
+        // we can get this called in the middle of trying to find a new app
+        if (!getAppIdKey(this)) {
+          this.log.debug('Not connected to an application. Ignoring page readiess check');
+          return;
+        }
+        if (!isPageLoading) {
+          return;
+        }
 
-      const maxWaitMs = (readinessTimeoutMs - elapsedMs) * 0.95;
-      if (await this.checkPageIsReady(maxWaitMs)) {
-        if (isPageLoading) {
-          this.log.debug(`Page is ready in ${elapsedMs}ms`);
+        const maxWaitMs = (readinessTimeoutMs - elapsedMs) * 0.95;
+        if (await this.checkPageIsReady(maxWaitMs)) {
+          if (isPageLoading) {
+            this.log.debug(`Page is ready in ${elapsedMs}ms`);
+            isPageLoading = false;
+          }
+          return;
+        }
+        if (elapsedMs > readinessTimeoutMs) {
+          this.log.info(
+            `Timed out after ${readinessTimeoutMs}ms of waiting for the page readiness. Continuing anyway`,
+          );
           isPageLoading = false;
+          return;
         }
-        return;
-      }
-      if (elapsedMs > readinessTimeoutMs) {
-        this.log.info(
-          `Timed out after ${readinessTimeoutMs}ms of waiting for the page readiness. Continuing anyway`
-        );
-        isPageLoading = false;
-        return;
+        retry++;
       }
-      retry++;
-    }
-  })());
-  const cancellationPromise = B.resolve((async () => {
-    try {
-      await getPageLoadDelay(this);
-    } catch {}
-  })());
+    })(),
+  );
+  const cancellationPromise = B.resolve(
+    (async () => {
+      try {
+        await getPageLoadDelay(this);
+      } catch {}
+    })(),
+  );
 
   try {
     await B.any([cancellationPromise, pageReadinessPromise]);
@@ -152,13 +159,12 @@ export async function checkPageIsReady(this: RemoteDebugger, timeoutMs?: number)
   const readyCmd = 'document.readyState;';
   const actualTimeoutMs = timeoutMs ?? getPageReadyTimeout(this);
   try {
-    const readyState = await B.resolve(this.execute(readyCmd))
-      .timeout(actualTimeoutMs);
+    const readyState = await B.resolve(this.execute(readyCmd)).timeout(actualTimeoutMs);
     this.log.debug(
       JSON.stringify({
         readyState,
         pageLoadStrategy: getPageLoadStartegy(this) ?? PAGE_LOAD_STRATEGY.NORMAL,
-      })
+      }),
     );
     return this.isPageLoadingCompleted(readyState);
   } catch (err: any) {
@@ -194,10 +200,7 @@ export async function navToUrl(this: RemoteDebugger, url: string): Promise<void>
 
   this.log.debug(`Navigating to new URL: '${url}'`);
   setNavigatingToPage(this, true);
-  await rpcClient.waitForPage(
-    appIdKey as AppIdKey,
-    pageIdKey as PageIdKey
-  );
+  await rpcClient.waitForPage(appIdKey as AppIdKey, pageIdKey as PageIdKey);
   const readinessTimeoutMs = this.pageLoadMs;
   let onPageLoaded: (() => void) | undefined;
   let onPageLoadedTimeout: NodeJS.Timeout | undefined | null;
@@ -212,7 +215,7 @@ export async function navToUrl(this: RemoteDebugger, url: string): Promise<void>
         isPageLoading = false;
         this.log.info(
           `Timed out after ${start.getDuration().asMilliSeconds.toFixed(0)}ms of waiting ` +
-          `for the ${url} page readiness. Continuing anyway`
+            `for the ${url} page readiness. Continuing anyway`,
         );
       }
       return resolve();
@@ -221,7 +224,9 @@ export async function navToUrl(this: RemoteDebugger, url: string): Promise<void>
     onPageLoaded = () => {
       if (isPageLoading) {
         isPageLoading = false;
-        this.log.debug(`The page ${url} is ready in ${start.getDuration().asMilliSeconds.toFixed(0)}ms`);
+        this.log.debug(
+          `The page ${url} is ready in ${start.getDuration().asMilliSeconds.toFixed(0)}ms`,
+        );
       }
       if (onPageLoadedTimeout) {
         clearTimeout(onPageLoadedTimeout);
@@ -239,11 +244,13 @@ export async function navToUrl(this: RemoteDebugger, url: string): Promise<void>
       pageIdKey,
     });
   });
-  const cancellationPromise = B.resolve((async () => {
-    try {
-      await getPageLoadDelay(this);
-    } catch {}
-  })());
+  const cancellationPromise = B.resolve(
+    (async () => {
+      try {
+        await getPageLoadDelay(this);
+      } catch {}
+    })(),
+  );
 
   try {
     await B.any([cancellationPromise, pageReadinessPromise]);