appium 2.0.0-beta.26 → 2.0.0-beta.29

package/lib/appium.js

@@ -1,6 +1,7 @@
+/* eslint-disable no-unused-vars */
 import _ from 'lodash';
 import { getBuildInfo, updateBuildInfo, APPIUM_VER } from './config';
-import { BaseDriver, errors, isSessionCommand,
+import { BaseDriver, DriverCore, errors, isSessionCommand,
          CREATE_SESSION_COMMAND, DELETE_SESSION_COMMAND, GET_STATUS_COMMAND
 } from '@appium/base-driver';
 import AsyncLock from 'async-lock';
@@ -8,7 +9,11 @@ import { parseCapsForInnerDriver, pullSettings } from './utils';
 import { util, node, logger } from '@appium/support';
 import { getDefaultsForExtension } from './schema';
 
-const desiredCapabilityConstraints = {
+/**
+ * Invariant set of base constraints
+ * @type {Readonly<Constraints>}
+ */
+const desiredCapabilityConstraints = Object.freeze({
   automationName: {
     presence: true,
     isString: true,
@@ -17,67 +22,99 @@ const desiredCapabilityConstraints = {
     presence: true,
     isString: true,
   },
-};
+});
 
 const sessionsListGuard = new AsyncLock();
 const pendingDriversGuard = new AsyncLock();
 
-class AppiumDriver extends BaseDriver {
-  constructor (args) {
+/**
+ * @implements {SessionHandler}
+ */
+class AppiumDriver extends DriverCore {
+  /**
+   * Access to sessions list must be guarded with a Semaphore, because
+   * it might be changed by other async calls at any time
+   * It is not recommended to access this property directly from the outside
+   * @type {Record<string,ExternalDriver>}
+   */
+  sessions = {};
+
+  /**
+   * Access to pending drivers list must be guarded with a Semaphore, because
+   * it might be changed by other async calls at any time
+   * It is not recommended to access this property directly from the outside
+   * @type {Record<string,ExternalDriver[]>}
+   */
+  pendingDrivers = {};
+
+  /**
+   * Note that {@linkcode AppiumDriver} has no `newCommandTimeout` method.
+   * `AppiumDriver` does not set and observe its own timeouts; individual
+   * sessions (managed drivers) do instead.
+   */
+  newCommandTimeoutMs = 0;
+
+  /**
+   * List of active plugins
+   * @type {PluginClass[]}
+   */
+  pluginClasses = [];
+
+  /**
+   * map of sessions to actual plugin instances per session
+   * @type {Record<string,InstanceType<PluginClass>[]>}
+   */
+  sessionPlugins = {};
+
+  /**
+   * some commands are sessionless, so we need a set of plugins for them
+   * @type {InstanceType<PluginClass>[]}
+   */
+  sessionlessPlugins = [];;
+
+  /** @type {DriverConfig} */
+  driverConfig;
+
+  /** @type {AppiumServer} */
+  server;
+
+  /**
+   * @param {DriverOpts} opts
+   */
+  constructor (opts) {
     // It is necessary to set `--tmp` here since it should be set to
     // process.env.APPIUM_TMP_DIR once at an initial point in the Appium lifecycle.
     // The process argument will be referenced by BaseDriver.
     // Please call @appium/support.tempDir module to apply this benefit.
-    if (args.tmpDir) {
-      process.env.APPIUM_TMP_DIR = args.tmpDir;
+    if (opts.tmpDir) {
+      process.env.APPIUM_TMP_DIR = opts.tmpDir;
     }
 
-    super(args);
+    super(opts);
 
     this.desiredCapConstraints = desiredCapabilityConstraints;
 
-    // the main Appium Driver has no new command timeout
-    this.newCommandTimeoutMs = 0;
-
-    this.args = {...args};
-
-    // Access to sessions list must be guarded with a Semaphore, because
-    // it might be changed by other async calls at any time
-    // It is not recommended to access this property directly from the outside
-    this.sessions = {};
-
-    // Access to pending drivers list must be guarded with a Semaphore, because
-    // it might be changed by other async calls at any time
-    // It is not recommended to access this property directly from the outside
-    this.pendingDrivers = {};
-
-    /** @type {PluginExtensionClass[]} */
-    this.pluginClasses = []; // list of which plugins are active
-    this.sessionPlugins = {}; // map of sessions to actual plugin instances per session
-    this.sessionlessPlugins = []; // some commands are sessionless, so we need a set of plugins for them
+    this.args = {...opts};
 
     // allow this to happen in the background, so no `await`
-    updateBuildInfo();
+    // catch this to avoid an unhandled rejection
+    // eslint-disable-next-line promise/prefer-await-to-then,promise/prefer-await-to-callbacks
+    updateBuildInfo().catch((err) => {
+      this.log.debug(err);
+    });
   }
 
   /**
    * Retrieves logger instance for the current umbrella driver instance
-   * @override
    */
   get log () {
     if (!this._log) {
-      const instanceName = `${this.constructor.name}@${node.getObjectId(this).substring(0, 8)}`;
+      const instanceName = `${this.constructor.name}@${node.getObjectId(this).substring(0, 4)}`;
       this._log = logger.getLogger(instanceName);
     }
     return this._log;
   }
 
-  /** @type {import('./extension/driver-config').DriverConfig|undefined} */
-  driverConfig;
-
-  /** @type {import('express').Express|undefined} */
-  server;
-
   /**
    * Cancel commands queueing for the umbrella Appium driver
    */
@@ -100,9 +137,8 @@ class AppiumDriver extends BaseDriver {
     };
   }
 
-  async getSessions () {
-    const sessions = await sessionsListGuard.acquire(AppiumDriver.name, () => this.sessions);
-    return _.toPairs(sessions)
+  async getSessions () { // eslint-disable-line require-await
+    return _.toPairs(this.sessions)
       .map(([id, driver]) => ({id, capabilities: driver.caps}));
   }
 
@@ -128,12 +164,12 @@ class AppiumDriver extends BaseDriver {
    * If the extension has provided a schema, validation has already happened.
    *
    * Any arg which is equal to its default value will not be assigned to the extension.
-   * @param {import('./manifest').ExtensionType} extType 'driver' or 'plugin'
+   * @param {ExtensionType} extType 'driver' or 'plugin'
    * @param {string} extName the name of the extension
    * @param {Object} extInstance the driver or plugin instance
    */
   assignCliArgsToExtension (extType, extName, extInstance) {
-    const allCliArgsForExt = this.args[extType]?.[extName];
+    const allCliArgsForExt = /** @type {Record<string,unknown>|undefined} */(this.args[extType]?.[extName]);
     if (!_.isEmpty(allCliArgsForExt)) {
       const defaults = getDefaultsForExtension(extType, extName);
       const cliArgs = _.isEmpty(defaults)
@@ -147,24 +183,26 @@ class AppiumDriver extends BaseDriver {
 
   /**
    * Create a new session
-   * @param {Object} jsonwpCaps JSONWP formatted desired capabilities
-   * @param {Object} reqCaps Required capabilities (JSONWP standard)
-   * @param {Object} w3cCapabilities W3C capabilities
-   * @return {Array} Unique session ID and capabilities
+   * @param {W3CCapabilities} jsonwpCaps JSONWP formatted desired capabilities
+   * @param {W3CCapabilities} reqCaps Required capabilities (JSONWP standard)
+   * @param {W3CCapabilities} w3cCapabilities W3C capabilities
+   * @param {import('@appium/types').DriverData[]} [driverData]
    */
-  async createSession (jsonwpCaps, reqCaps, w3cCapabilities) {
+  async createSession (jsonwpCaps, reqCaps, w3cCapabilities, driverData) {
     const defaultCapabilities = _.cloneDeep(this.args.defaultCapabilities);
     const defaultSettings = pullSettings(defaultCapabilities);
     jsonwpCaps = _.cloneDeep(jsonwpCaps);
-    const jwpSettings = Object.assign({}, defaultSettings, pullSettings(jsonwpCaps));
+    const jwpSettings = {...defaultSettings, ...pullSettings(jsonwpCaps)};
     w3cCapabilities = _.cloneDeep(w3cCapabilities);
     // It is possible that the client only provides caps using JSONWP standard,
     // although firstMatch/alwaysMatch properties are still present.
     // In such case we assume the client understands W3C protocol and merge the given
     // JSONWP caps to W3C caps
-    const w3cSettings = Object.assign({}, jwpSettings);
-    Object.assign(w3cSettings, pullSettings((w3cCapabilities || {}).alwaysMatch || {}));
-    for (const firstMatchEntry of ((w3cCapabilities || {}).firstMatch || [])) {
+    const w3cSettings = {
+      ...jwpSettings,
+      ...pullSettings((w3cCapabilities ?? {}).alwaysMatch ?? {})
+    };
+    for (const firstMatchEntry of ((w3cCapabilities ?? {}).firstMatch ?? [])) {
       Object.assign(w3cSettings, pullSettings(firstMatchEntry));
     }
 
@@ -179,9 +217,9 @@ class AppiumDriver extends BaseDriver {
         defaultCapabilities
       );
 
-      const {desiredCaps, processedJsonwpCapabilities, processedW3CCapabilities, error} = parsedCaps;
+      const {desiredCaps, processedJsonwpCapabilities, processedW3CCapabilities} = /** @type {import('./utils').ParsedDriverCaps} */(parsedCaps);
       protocol = parsedCaps.protocol;
-
+      const error = /** @type {import('./utils').InvalidCaps} */(parsedCaps).error;
       // If the parsing of the caps produced an error, throw it in here
       if (error) {
         throw error;
@@ -198,7 +236,14 @@ class AppiumDriver extends BaseDriver {
         await this.deleteAllSessions();
       }
 
-      let runningDriversData, otherPendingDriversData;
+      /**
+       * @type {DriverData[]}
+       */
+      let runningDriversData = [];
+      /**
+       * @type {DriverData[]}
+       */
+      let otherPendingDriversData = [];
 
       const driverInstance = new InnerDriver(this.args, true);
 
@@ -231,21 +276,17 @@ class AppiumDriver extends BaseDriver {
 
 
       // This assignment is required for correct web sockets functionality inside the driver
-      driverInstance.server = this.server;
-
       // Drivers/plugins might also want to know where they are hosted
-      driverInstance.serverHost = this.args.address;
-      driverInstance.serverPort = this.args.port;
-      driverInstance.serverPath = this.args.basePath;
+      driverInstance.assignServer(this.server, this.args.address, this.args.port, this.args.basePath);
 
       try {
-        runningDriversData = await this.curSessionDataForDriver(InnerDriver);
+        runningDriversData = await this.curSessionDataForDriver(InnerDriver) ?? [];
       } catch (e) {
         throw new errors.SessionNotCreatedError(e.message);
       }
       await pendingDriversGuard.acquire(AppiumDriver.name, () => {
         this.pendingDrivers[InnerDriver.name] = this.pendingDrivers[InnerDriver.name] || [];
-        otherPendingDriversData = this.pendingDrivers[InnerDriver.name].map((drv) => drv.driverData);
+        otherPendingDriversData = _.compact(this.pendingDrivers[InnerDriver.name].map((drv) => drv.driverData));
         this.pendingDrivers[InnerDriver.name].push(driverInstance);
       });
 
@@ -257,9 +298,7 @@ class AppiumDriver extends BaseDriver {
           [...runningDriversData, ...otherPendingDriversData]
         );
         protocol = driverInstance.protocol;
-        await sessionsListGuard.acquire(AppiumDriver.name, () => {
-          this.sessions[innerSessionId] = driverInstance;
-        });
+        this.sessions[innerSessionId] = driverInstance;
       } finally {
         await pendingDriversGuard.acquire(AppiumDriver.name, () => {
           _.pull(this.pendingDrivers[InnerDriver.name], driverInstance);
@@ -329,27 +368,32 @@ class AppiumDriver extends BaseDriver {
     }
   }
 
-  async curSessionDataForDriver (InnerDriver) {
-    const sessions = await sessionsListGuard.acquire(AppiumDriver.name, () => this.sessions);
-    const data = _.values(sessions)
-                   .filter((s) => s.constructor.name === InnerDriver.name)
-                   .map((s) => s.driverData);
-    for (let datum of data) {
+  /**
+   *
+   * @param {import('../types/extension').DriverClass} InnerDriver
+   * @returns {Promise<DriverData[]>}}
+   */
+  async curSessionDataForDriver (InnerDriver) { // eslint-disable-line require-await
+    const data = _.compact(_.values(this.sessions)
+      .filter((s) => s.constructor.name === InnerDriver.name)
+      .map((s) => s.driverData));
+    for (const datum of data) {
       if (!datum) {
         throw new Error(`Problem getting session data for driver type ` +
-                        `${InnerDriver.name}; does it implement 'get ` +
-                        `driverData'?`);
+          `${InnerDriver.name}; does it implement 'get driverData'?`);
       }
     }
     return data;
   }
 
+  /**
+   * @param {string} sessionId
+   */
   async deleteSession (sessionId) {
     let protocol;
     try {
-      let otherSessionsData = null;
-      let dstSession = null;
-      await sessionsListGuard.acquire(AppiumDriver.name, () => {
+      let otherSessionsData;
+      const dstSession = await sessionsListGuard.acquire(AppiumDriver.name, () => {
         if (!this.sessions[sessionId]) {
           return;
         }
@@ -357,7 +401,7 @@ class AppiumDriver extends BaseDriver {
         otherSessionsData = _.toPairs(this.sessions)
               .filter(([key, value]) => value.constructor.name === curConstructorName && key !== sessionId)
               .map(([, value]) => value.driverData);
-        dstSession = this.sessions[sessionId];
+        const dstSession = this.sessions[sessionId];
         protocol = dstSession.protocol;
         this.log.info(`Removing session ${sessionId} from our master session list`);
         // regardless of whether the deleteSession completes successfully or not
@@ -365,7 +409,13 @@ class AppiumDriver extends BaseDriver {
         // be in otherwise
         delete this.sessions[sessionId];
         delete this.sessionPlugins[sessionId];
+        return dstSession;
       });
+      // this may not be correct, but if `dstSession` was falsy, the call to `deleteSession()` would
+      // throw anyway.
+      if (!dstSession) {
+        throw new Error('Session not found');
+      }
       return {
         protocol,
         value: await dstSession.deleteSession(sessionId, otherSessionsData),
@@ -449,6 +499,12 @@ class AppiumDriver extends BaseDriver {
     });
   }
 
+  /**
+   *
+   * @param {string} cmd
+   * @param  {...any} args
+   * @returns {Promise<{value: any, error?: Error, protocol: string} | import('type-fest').AsyncReturnType<import('@appium/types').Driver['executeCommand']>>}
+   */
   async executeCommand (cmd, ...args) {
     // We have basically three cases for how to handle commands:
     // 1. handle getStatus (we do this as a special out of band case so it doesn't get added to an
@@ -460,9 +516,8 @@ class AppiumDriver extends BaseDriver {
     // cases with plugin handling.
 
     const isGetStatus = cmd === GET_STATUS_COMMAND;
-    const isDeleteSession = cmd === DELETE_SESSION_COMMAND;
-    const isUmbrellaCmd = !isGetStatus && isAppiumDriverCommand(cmd);
-    const isSessionCmd = !isUmbrellaCmd || isDeleteSession;
+    const isUmbrellaCmd = isAppiumDriverCommand(cmd);
+    const isSessionCmd = isSessionCommand(cmd);
 
     // if a plugin override proxying for this command and that is why we are here instead of just
     // letting the protocol proxy the command entirely, determine that, get the request object for
@@ -478,10 +533,11 @@ class AppiumDriver extends BaseDriver {
     let sessionId = null;
     let dstSession = null;
     let protocol = null;
+    /** @type {this | ExternalDriver} */
     let driver = this;
     if (isSessionCmd) {
       sessionId = _.last(args);
-      dstSession = await sessionsListGuard.acquire(AppiumDriver.name, () => this.sessions[sessionId]);
+      dstSession = this.sessions[sessionId];
       if (!dstSession) {
         throw new Error(`The session with id '${sessionId}' does not exist`);
       }
@@ -535,7 +591,7 @@ class AppiumDriver extends BaseDriver {
       if (isUmbrellaCmd) {
         // some commands, like deleteSession, we want to make sure to handle on *this* driver,
         // not the platform driver
-        return await super.executeCommand(cmd, ...args);
+        return await BaseDriver.prototype.executeCommand.call(this, cmd, ...args);
       }
 
       // here we know that we are executing a session command, and have a valid session driver
@@ -654,7 +710,7 @@ class AppiumDriver extends BaseDriver {
 // help decide which commands should be proxied to sub-drivers and which
 // should be handled by this, our umbrella driver
 function isAppiumDriverCommand (cmd) {
-  return !isSessionCommand(cmd) || cmd === 'deleteSession';
+  return !isSessionCommand(cmd) || cmd === DELETE_SESSION_COMMAND;
 }
 
 /**
@@ -676,3 +732,29 @@ export class NoDriverProxyCommandError extends Error {
 }
 
 export { AppiumDriver };
+
+/**
+ * @typedef {import('@appium/types').ExternalDriver} ExternalDriver
+ * @typedef {import('@appium/types').W3CCapabilities} W3CCapabilities
+ * @typedef {import('@appium/types').DriverData} DriverData
+ * @typedef {import('@appium/types').DriverOpts} DriverOpts
+ * @typedef {import('@appium/types').Constraints} Constraints
+ * @typedef {import('@appium/types').AppiumServer} AppiumServer
+ * @typedef {import('../types').ExtensionType} ExtensionType
+ * @typedef {import('../types/extension').PluginClass} PluginClass
+ * @typedef {import('./extension/driver-config').DriverConfig} DriverConfig
+ */
+
+/**
+ * Used by {@linkcode AppiumDriver.createSession} and {@linkcode AppiumDriver.deleteSession} to describe
+ * result.
+ * @template V
+ * @typedef SessionHandlerResult
+ * @property {V} [value]
+ * @property {Error} [error]
+ * @property {string} [protocol]
+ */
+
+/**
+ * @typedef {import('@appium/types').SessionHandler<SessionHandlerResult<any[]>,SessionHandlerResult<void>>} SessionHandler
+ */

package/lib/cli/args.js

@@ -1,4 +1,3 @@
-// @ts-check
 
 // @ts-ignore
 import _ from 'lodash';
@@ -43,7 +42,7 @@ const getExtensionArgs = _.memoize(function getExtensionArgs () {
       [EXT_SUBCOMMAND_RUN]: makeRunArgs(type),
     };
   }
-  return /** @type {Record<ExtensionType, Record<import('../../types/types').CliExtensionSubcommand,ArgumentDefinitions>>} */(extensionArgs);
+  return /** @type {Record<ExtensionType, Record<import('../../types/cli').CliExtensionSubcommand,ArgumentDefinitions>>} */(extensionArgs);
 });
 
 /**

package/lib/cli/driver-command.js

@@ -1,33 +1,36 @@
 import _ from 'lodash';
 import ExtensionCommand from './extension-command';
-import { DRIVER_TYPE, KNOWN_DRIVERS } from '../constants';
+import { KNOWN_DRIVERS } from '../constants';
+import '@colors/colors';
 
 const REQ_DRIVER_FIELDS = ['driverName', 'automationName', 'platformNames', 'mainClass'];
-
+/**
+ * @extends {ExtensionCommand<import('../extension/manifest').DriverType>}
+ */
 export default class DriverCommand extends ExtensionCommand {
 
   /**
    * @param {DriverCommandOptions} opts
    */
   constructor ({config, json}) {
-    super({config, json, type: DRIVER_TYPE});
+    super({config, json});
     this.knownExtensions = KNOWN_DRIVERS;
   }
 
   async install ({driver, installType, packageName}) {
-    return await super.install({ext: driver, installType, packageName});
+    return await super._install({ext: driver, installType, packageName});
   }
 
   async uninstall ({driver}) {
-    return await super.uninstall({ext: driver});
+    return await super._uninstall({ext: driver});
   }
 
   async update ({driver, unsafe}) {
-    return await super.update({ext: driver, unsafe});
+    return await super._update({ext: driver, unsafe});
   }
 
   async run ({driver, scriptName}) {
-    return await super.run({ext: driver, scriptName});
+    return await super._run({ext: driver, scriptName});
   }
 
   getPostInstallText ({extName, extData}) {
@@ -52,6 +55,6 @@ export default class DriverCommand extends ExtensionCommand {
 
 /**
  * @typedef DriverCommandOptions
- * @property {import('../extension/driver-config').DriverConfig} config
+ * @property {import('../extension/extension-config').ExtensionConfig<import('../extension/manifest').DriverType>} config
  * @property {boolean} json
  */