appium-remote-debugger 5.3.0 → 5.7.0

package/lib/remote-debugger.js

@@ -1,16 +1,18 @@
 import events from 'events';
 import log from './logger';
-import { errorFromCode } from 'appium-base-driver';
+import { errors } from 'appium-base-driver';
 import RpcClientSimulator from './rpc-client-simulator';
 import messageHandlers from './message-handlers';
 import { appInfoFromDict, pageArrayFromDict, getDebuggerAppKey,
          getPossibleDebuggerAppKeys, checkParams, getScriptForAtom,
-         simpleStringify, deferredPromise, getElapsedTime } from './helpers';
+         simpleStringify, deferredPromise, getElapsedTime, convertResult,
+         RESPONSE_LOG_LENGTH } from './helpers';
 import { util } from 'appium-support';
 import { retryInterval } from 'asyncbox';
 import _ from 'lodash';
 import B from 'bluebird';
 import path from 'path';
+import UUID from 'uuid-js';
 
 
 let VERSION;
@@ -29,8 +31,6 @@ const RPC_RESPONSE_TIMEOUT_MS = 5000;
 
 const PAGE_READY_TIMEOUT = 5000;
 
-const RESPONSE_LOG_LENGTH = 100;
-
 const GARBAGE_COLLECT_TIMEOUT = 5000;
 
 class RemoteDebugger extends events.EventEmitter {
@@ -134,6 +134,7 @@ class RemoteDebugger extends events.EventEmitter {
 
     // initialize the rpc client
     this.rpcClient = new RpcClientSimulator({
+      bundleId: this.bundleId,
       platformVersion: this.platformVersion,
       isSafari: this.isSafari,
       host: this.host,
@@ -302,6 +303,7 @@ class RemoteDebugger extends events.EventEmitter {
           }
         }
       }
+
       log.debug(`Selected app after ${getElapsedTime(startTime)}ms`);
       return fullPageArray;
     } finally {
@@ -310,7 +312,7 @@ class RemoteDebugger extends events.EventEmitter {
   }
 
   async searchForApp (currentUrl, maxTries, ignoreAboutBlankUrl) {
-    const bundleIds = this.includeSafari
+    const bundleIds = this.includeSafari && !this.isSafari
       ? [this.bundleId, SAFARI_BUNDLE_ID]
       : [this.bundleId];
     try {
@@ -401,13 +403,71 @@ class RemoteDebugger extends events.EventEmitter {
     return value;
   }
 
-  async executeAtomAsync (atom, args, frames, responseUrl) {
-    let asyncCallBack = `function (res) { xmlHttp = new XMLHttpRequest(); ` +
-                        `xmlHttp.open('POST', '${responseUrl}', true);` +
-                        `xmlHttp.setRequestHeader('Content-type','application/json'); ` +
-                        `xmlHttp.send(res); }`;
-    let script = await getScriptForAtom(atom, args, frames, asyncCallBack);
-    await this.execute(script);
+  async executeAtomAsync (atom, args, frames) {
+    // first create a Promise on the page, saving the resolve/reject functions
+    // as properties
+    const promiseName = `appiumAsyncExecutePromise${UUID.create().toString().replace(/-/g, '')}`;
+    let script = `var res, rej;` +
+                 `window.${promiseName} = new Promise(function (resolve, reject) {` +
+                 `  res = resolve;` +
+                 `  rej = reject;` +
+                 `});` +
+                 `window.${promiseName}.resolve = res;` +
+                 `window.${promiseName}.reject = rej;` +
+                 `window.${promiseName};`;
+    const obj = await this.rpcClient.send('sendJSCommand', {
+      command: script,
+      appIdKey: this.appIdKey,
+      pageIdKey: this.pageIdKey,
+      returnByValue: false,
+    });
+    const promiseObjectId = obj.result.objectId;
+
+    // execute the atom, calling back to the resolve function
+    const asyncCallBack = `function (res) {` +
+                          `  window.${promiseName}.resolve(res);` +
+                          `  window.${promiseName}Value = res;` +
+                          `}`;
+    await this.execute(await getScriptForAtom(atom, args, frames, asyncCallBack));
+
+    // wait for the promise to be resolved
+    let res;
+    const subcommandTimeout = 1000; // timeout on individual commands
+    try {
+      res = await this.rpcClient.send('awaitPromise', {
+        promiseObjectId,
+        appIdKey: this.appIdKey,
+        pageIdKey: this.pageIdKey,
+      });
+    } catch (err) {
+      if (!err.message.includes(`'Runtime.awaitPromise' was not found`)) {
+        throw err;
+      }
+
+      // 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 retries = parseInt(timeout / retryWait, 10);
+      const startTime = process.hrtime();
+      res = await retryInterval(retries, retryWait, async () => {
+        // the atom _will_ return, either because it finished or an error
+        // including a timeout error
+        if (await this.executeAtom('execute_script', [`return window.hasOwnProperty('${promiseName}Value');`, [null, null], subcommandTimeout], frames)) {
+          // we only put the property on `window` when the callback is called,
+          // so if it is there, everything is done
+          return await this.executeAtom('execute_script', [`return window.${promiseName}Value;`, [null, null], subcommandTimeout], frames);
+        }
+        // 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 ${getElapsedTime(startTime)} ms'));`);
+      });
+    } finally {
+      try {
+        // try to get rid of the promise
+        await this.executeAtom('execute_script', [`delete window.${promiseName};`, [null, null], subcommandTimeout], frames);
+      } catch (ign) {}
+    }
+    return convertResult(res);
   }
 
   frameDetached () {
@@ -631,14 +691,14 @@ class RemoteDebugger extends events.EventEmitter {
       await this.garbageCollect();
     }
 
-    log.debug(`Sending javascript command ${_.truncate(command, {length: 50})}`);
+    log.debug(`Sending javascript command: '${_.truncate(command, {length: 50})}'`);
     let res = await this.rpcClient.send('sendJSCommand', {
       command,
       appIdKey: this.appIdKey,
       pageIdKey: this.pageIdKey,
     });
 
-    return this.convertResult(res);
+    return convertResult(res);
   }
 
   async callFunction (objId, fn, args) {
@@ -658,31 +718,7 @@ class RemoteDebugger extends events.EventEmitter {
       pageIdKey: this.pageIdKey,
     });
 
-    return this.convertResult(res);
-  }
-
-  convertResult (res) {
-    if (_.isUndefined(res)) {
-      throw new Error(`Did not get OK result from remote debugger. Result was: ${_.truncate(simpleStringify(res), {length: RESPONSE_LOG_LENGTH})}`);
-    } else if (_.isString(res)) {
-      try {
-        res = JSON.parse(res);
-      } catch (err) {
-        // we might get a serialized object, but we might not
-        // if we get here, it is just a value
-      }
-    } else if (!_.isObject(res)) {
-      throw new Error(`Result has unexpected type: (${typeof res}).`);
-    }
-
-    if (res.status && res.status !== 0) {
-      // we got some form of error.
-      throw errorFromCode(res.status, res.value.message || res.value);
-    }
-
-    // with either have an object with a `value` property (even if `null`),
-    // or a plain object
-    return res.hasOwnProperty('value') ? res.value : res;
+    return convertResult(res);
   }
 
   allowNavigationWithoutReload (allow = true) {

package/lib/remote-messages.js

@@ -83,7 +83,7 @@ class RemoteMessages {
     const method = 'Runtime.evaluate';
     const params = {
       expression: opts.command,
-      returnByValue: true,
+      returnByValue: _.isBoolean(opts.returnByValue) ? opts.returnByValue : true,
     };
     return this.getFullCommand(connId, senderId, appIdKey, pageIdKey, method, params);
   }
@@ -173,6 +173,17 @@ class RemoteMessages {
     return this.getFullCommand(connId, senderId, appIdKey, pageIdKey, method, params);
   }
 
+  awaitPromise (connId, senderId, appIdKey, pageIdKey, opts) {
+    const method = 'Runtime.awaitPromise';
+    const params = {
+      promiseObjectId: opts.promiseObjectId,
+      returnByValue: true,
+      generatePreview: true,
+      saveResult: true,
+    };
+    return this.getFullCommand(connId, senderId, appIdKey, pageIdKey, method, params);
+  }
+
 
   /*
    * Internal functions
@@ -249,6 +260,8 @@ class RemoteMessages {
         return this.deleteCookie(connId, senderId, appIdKey, pageIdKey, opts);
       case 'garbageCollect':
         return this.garbageCollect(connId, senderId, appIdKey, pageIdKey);
+      case 'awaitPromise':
+        return this.awaitPromise(connId, senderId, appIdKey, pageIdKey, opts);
       default:
         throw new Error(`Unknown command: ${command}`);
     }

package/lib/rpc-client-real-device.js

@@ -37,6 +37,9 @@ export default class RpcClientRealDevice extends RpcClient {
   }
 
   async receive (data) { // eslint-disable-line require-await
+    if (!this.isConnected()) {
+      return;
+    }
     this.messageHandler.handleMessage(data);
   }
 }

package/lib/rpc-client-simulator.js

@@ -133,6 +133,10 @@ export default class RpcClientSimulator extends RpcClient {
   }
 
   async receive (data) {
+    if (!this.isConnected()) {
+      return;
+    }
+
     if (!data) {
       return;
     }

package/lib/rpc-client.js

@@ -6,6 +6,7 @@ import B from 'bluebird';
 import UUID from 'uuid-js';
 import RpcMessageHandler from './remote-debugger-message-handler';
 import { isTargetBased, getElapsedTime } from './helpers';
+import { util } from 'appium-support';
 
 
 const DATA_LOG_LENGTH = {length: 200};
@@ -13,24 +14,30 @@ const DATA_LOG_LENGTH = {length: 200};
 const WAIT_FOR_TARGET_RETRIES = 10;
 const WAIT_FOR_TARGET_INTERVAL = 1000;
 
+const GENERIC_TARGET_ID = 'page-6';
+
 export default class RpcClient {
   constructor (opts = {}) {
     this._targets = [];
     this._shouldCheckForTarget = !!opts.shouldCheckForTarget;
 
     const {
+      bundleId,
       platformVersion = {},
       isSafari = true,
       specialMessageHandlers = {},
       logFullResponse = false,
     } = opts;
 
+    this.isSafari = isSafari;
+
     this.connected = false;
     this.connId = UUID.create().toString();
     this.senderId = UUID.create().toString();
     this.msgId = 0;
     this.logFullResponse = logFullResponse;
 
+    this.bundleId = bundleId;
     this.platformVersion = platformVersion;
 
     // message handlers
@@ -68,17 +75,33 @@ export default class RpcClient {
 
     // on iOS less than 13 have targets that can be computed easily
     // and sometimes is not reported by the Web Inspector
-    if (parseInt(this.platformVersion, 10) < 13 && _.isEmpty(this.getTarget(appIdKey, pageIdKey))) {
-      this.addTarget({targetId: `page-${pageIdKey}`});
+    if (util.compareVersions(this.platformVersion, '<', '13.0') && _.isEmpty(this.getTarget(appIdKey, pageIdKey))) {
+      if (this.isSafari) {
+        this.addTarget({targetId: `page-${pageIdKey}`});
+      } else {
+        const targets = this.targets[appIdKey];
+        const targetIds = _.values(targets)
+          .map((targetId) => targetId.replace('page-', ''))
+          .sort();
+        const lastTargetId = _.last(targetIds) || 0;
+        this.addTarget({targetId: `page-${lastTargetId + 1}`});
+      }
       return;
     }
 
     // otherwise waiting is necessary to see what the target is
-    await retryInterval(WAIT_FOR_TARGET_RETRIES, WAIT_FOR_TARGET_INTERVAL, () => {
-      if (_.isEmpty(this.getTarget(appIdKey, pageIdKey))) {
-        throw new Error('No targets found, unable to communicate with device');
-      }
-    });
+    try {
+      await retryInterval(WAIT_FOR_TARGET_RETRIES, WAIT_FOR_TARGET_INTERVAL, () => {
+        if (_.isEmpty(this.getTarget(appIdKey, pageIdKey))) {
+          throw new Error('No targets found, unable to communicate with device');
+        }
+      });
+    } catch (err) {
+      // on some systems sometimes the Web Inspector never sends the target event
+      // though the target is available
+      log.debug(`No target found. Trying '${GENERIC_TARGET_ID}', which seems to work`);
+      this.addTarget({targetId: GENERIC_TARGET_ID});
+    }
   }
 
   async send (command, opts = {}) {

package/package.json

@@ -4,7 +4,7 @@
   "keywords": [
     "appium"
   ],
-  "version": "5.3.0",
+  "version": "5.7.0",
   "author": "appium",
   "license": "Apache-2.0",
   "repository": {