@appium/fake-driver 4.2.1 → 5.0.0

package/lib/commands/contexts.js

@@ -1,64 +1,102 @@
 import _ from 'lodash';
 import {errors} from 'appium/driver';
 
-let commands = {},
-  helpers = {},
-  extensions = {};
-
-helpers.getRawContexts = function getRawContexts() {
-  let contexts = {NATIVE_APP: null, PROXY: null};
-  let wvs = this.appModel.getWebviews();
-  for (let i = 1; i < wvs.length + 1; i++) {
-    contexts[`WEBVIEW_${i}`] = wvs[i - 1];
-  }
-  return contexts;
-};
+/**
+ *
+ * @template {Class<import('../types').IFakeDriver>} T
+ * @param {T} Base
+ */
+export function ContextsMixin(Base) {
+  /**
+   * @implements {IContextsCommands}
+   */
+  class ContextsCommands extends Base {
+    getRawContexts() {
+      let contexts = {NATIVE_APP: null, PROXY: null};
+      let wvs = this.appModel?.getWebviews() ?? [];
+      for (let i = 1; i < wvs.length + 1; i++) {
+        contexts[`WEBVIEW_${i}`] = wvs[i - 1];
+      }
+      return contexts;
+    }
 
-helpers.assertWebviewContext = function assertWebviewContext() {
-  if (this.curContext === 'NATIVE_APP') {
-    throw new errors.InvalidContextError();
-  }
-};
+    assertWebviewContext() {
+      if (this.curContext === 'NATIVE_APP') {
+        throw new errors.InvalidContextError();
+      }
+    }
 
-commands.getCurrentContext = async function getCurrentContext() {
-  return this.curContext;
-};
+    /**
+     * Get the current appium context
+     *
+     * @returns {Promise<string>}
+     */
+    async getCurrentContext() {
+      return this.curContext;
+    }
 
-commands.getContexts = async function getContexts() {
-  return _.keys(this.getRawContexts());
-};
+    /**
+     * Get the list of available contexts
+     *
+     * @returns {Promise<string[]>}
+     */
+    async getContexts() {
+      return _.keys(this.getRawContexts());
+    }
 
-commands.setContext = async function setContext(context) {
-  let contexts = this.getRawContexts();
-  if (_.includes(_.keys(contexts), context)) {
-    this.curContext = context;
-    if (context === 'NATIVE_APP') {
-      this.appModel.deactivateWebview();
-      this._proxyActive = false;
-    } else if (context === 'PROXY') {
-      this._proxyActive = true;
-    } else {
-      this.appModel.activateWebview(contexts[context]);
-      this._proxyActive = false;
+    /**
+     * Set the current context
+     *
+     * @param {string} context - name of the context
+     * @returns {Promise<void>}
+     */
+    async setContext(context) {
+      let contexts = this.getRawContexts();
+      if (context in contexts) {
+        this.curContext = context;
+        if (context === 'NATIVE_APP') {
+          this.appModel.deactivateWebview();
+          this._proxyActive = false;
+        } else if (context === 'PROXY') {
+          this._proxyActive = true;
+        } else {
+          this.appModel.activateWebview(contexts[context]);
+          this._proxyActive = false;
+        }
+      } else {
+        throw new errors.NoSuchContextError();
+      }
     }
-  } else {
-    throw new errors.NoSuchContextError();
-  }
-};
 
-commands.setFrame = async function setFrame(frameId) {
-  this.assertWebviewContext();
-  if (frameId === null) {
-    this.appModel.deactivateFrame();
-  } else {
-    let nodes = this.appModel.xpathQuery(`//iframe[@id="${frameId}"]`);
-    if (!nodes.length) {
-      throw new errors.NoSuchFrameError();
+    /**
+     * Set the active frame
+     *
+     * @param {number} frameId
+     * @returns {Promise<void>}
+     */
+    async setFrame(frameId) {
+      this.assertWebviewContext();
+      if (frameId === null) {
+        this.appModel.deactivateFrame();
+      } else {
+        let nodes = this.appModel.xpathQuery(`//iframe[@id="${frameId}"]`);
+        if (!nodes.length) {
+          throw new errors.NoSuchFrameError();
+        }
+        this.appModel.activateFrame(nodes[0]);
+      }
     }
-    this.appModel.activateFrame(nodes[0]);
   }
-};
 
-Object.assign(extensions, commands, helpers);
-export {commands, helpers};
-export default extensions;
+  return ContextsCommands;
+}
+
+/**
+ * @typedef {import('../driver').FakeDriverCore} FakeDriverCore
+ * @typedef {import('../types').IContextsCommands} IContextsCommands
+ */
+
+/**
+ * @template T,[U={}],[V=Array<any>]
+ * @typedef {import('@appium/types').Class<T,U,V>} Class
+ */

package/lib/commands/element.js

@@ -1,103 +1,116 @@
 import _ from 'lodash';
 import {errors} from 'appium/driver';
 
-let commands = {},
-  helpers = {},
-  extensions = {};
-
-helpers.getElements = function getElements(elIds) {
-  for (let elId of elIds) {
-    if (!_.has(this.elMap, elId)) {
-      throw new errors.StaleElementReferenceError();
+/**
+ * @template {Class<import('../types').IContextsCommands & import('../types').IAlertCommands>} T
+ * @param {T} Base
+ */
+export function ElementMixin(Base) {
+  /**
+   * @implements {IElementCommands}
+   */
+  class ElementCommands extends Base {
+    getElements(elIds) {
+      for (let elId of elIds) {
+        if (!_.has(this.elMap, elId)) {
+          throw new errors.StaleElementReferenceError();
+        }
+      }
+      return elIds.map((e) => this.elMap[e]);
     }
+
+    getElement(elId) {
+      return this.getElements([elId])[0];
+    }
+
+    async getName(elementId) {
+      let el = this.getElement(elementId);
+      return el.tagName;
+    }
+
+    async elementDisplayed(elementId) {
+      let el = this.getElement(elementId);
+      return el.isVisible();
+    }
+
+    async elementEnabled(elementId) {
+      let el = this.getElement(elementId);
+      return el.isEnabled();
+    }
+
+    async elementSelected(elementId) {
+      let el = this.getElement(elementId);
+      return el.isSelected();
+    }
+
+    async setValue(keys, elementId) {
+      let value = keys;
+      if (keys instanceof Array) {
+        value = keys.join('');
+      }
+      let el = this.getElement(elementId);
+      if (el.type !== 'MockInputField') {
+        throw new errors.InvalidElementStateError();
+      }
+      el.setAttr('value', value);
+    }
+
+    async getText(elementId) {
+      let el = this.getElement(elementId);
+      return el.getAttr('value');
+    }
+
+    async clear(elementId) {
+      await this.setValue('', elementId);
+    }
+
+    async click(elementId) {
+      this.assertNoAlert();
+      let el = this.getElement(elementId);
+      if (!el.isVisible()) {
+        throw new errors.InvalidElementStateError();
+      }
+      el.click();
+      this.focusedElId = elementId;
+    }
+
+    async getAttribute(attr, elementId) {
+      let el = this.getElement(elementId);
+      return el.getAttr(attr);
+    }
+    getElementRect(elementId) {
+      let el = this.getElement(elementId);
+      return el.getElementRect();
+    }
+    getSize(elementId) {
+      let el = this.getElement(elementId);
+      return el.getSize();
+    }
+
+    equalsElement(el1Id, el2Id) {
+      let el1 = this.getElement(el1Id);
+      let el2 = this.getElement(el2Id);
+      return el1.equals(el2);
+    }
+
+    async getCssProperty(prop, elementId) {
+      this.assertWebviewContext();
+      let el = this.getElement(elementId);
+      return el.getCss(prop);
+    }
+
+    getLocationInView = this.getLocation;
   }
-  return elIds.map((e) => this.elMap[e]);
-};
-
-helpers.getElement = function getElement(elId) {
-  return this.getElements([elId])[0];
-};
-
-commands.getName = async function getName(elementId) {
-  let el = this.getElement(elementId);
-  return el.tagName;
-};
-
-commands.elementDisplayed = async function elementDisplayed(elementId) {
-  let el = this.getElement(elementId);
-  return el.isVisible();
-};
-
-commands.elementEnabled = async function elementEnabled(elementId) {
-  let el = this.getElement(elementId);
-  return el.isEnabled();
-};
-
-commands.elementSelected = async function elementSelected(elementId) {
-  let el = this.getElement(elementId);
-  return el.isSelected();
-};
-
-commands.setValue = async function setValue(keys, elementId) {
-  let value = keys;
-  if (keys instanceof Array) {
-    value = keys.join('');
-  }
-  let el = this.getElement(elementId);
-  if (el.type !== 'MockInputField') {
-    throw new errors.InvalidElementStateError();
-  }
-  el.setAttr('value', value);
-};
-
-commands.getText = async function getText(elementId) {
-  let el = this.getElement(elementId);
-  return el.getAttr('value');
-};
-
-commands.clear = async function clear(elementId) {
-  await this.setValue('', elementId);
-};
-
-commands.click = async function click(elementId) {
-  this.assertNoAlert();
-  let el = this.getElement(elementId);
-  if (!el.isVisible()) {
-    throw new errors.InvalidElementStateError();
-  }
-  el.click();
-  this.focusedElId = elementId;
-};
-
-commands.getAttribute = async function getAttribute(attr, elementId) {
-  let el = this.getElement(elementId);
-  return el.getAttr(attr);
-};
-
-commands.getElementRect = function getElementRect(elementId) {
-  let el = this.getElement(elementId);
-  return el.getElementRect();
-};
-
-commands.getSize = function getSize(elementId) {
-  let el = this.getElement(elementId);
-  return el.getSize();
-};
-
-commands.equalsElement = function equalsElement(el1Id, el2Id) {
-  let el1 = this.getElement(el1Id);
-  let el2 = this.getElement(el2Id);
-  return el1.equals(el2);
-};
-
-commands.getLocationInView = commands.getLocation;
-
-commands.getCssProperty = async function getCssProperty(prop, elementId) {
-  this.assertWebviewContext();
-  let el = this.getElement(elementId);
-  return el.getCss(prop);
-};
-
-Object.assign(extensions, commands, helpers);
-export {commands, helpers};
-export default extensions;
+
+  return ElementCommands;
+}
+
+/**
+ * @typedef {import('../driver').FakeDriverCore} FakeDriverCore
+ * @typedef {import('../types').IElementCommands} IElementCommands
+ */
+
+/**
+ * @template T,[U={}],[V=Array<any>]
+ * @typedef {import('@appium/types').Class<T,U,V>} Class
+ */

package/lib/commands/find.js

@@ -2,92 +2,116 @@ import _ from 'lodash';
 import {errors} from 'appium/driver';
 import {FakeElement} from '../fake-element';
 
-let commands = {},
-  helpers = {},
-  extensions = {};
-
-helpers.getExistingElementForNode = function getExistingElementForNode(node) {
-  for (let [id, el] of _.toPairs(this.elMap)) {
-    if (el.node === node) {
-      return id;
+/**
+ * @template {Class<import('../types').IElementCommands>} T
+ * @param {T} Base
+ */
+export function FindMixin(Base) {
+  /**
+   * @implements {IFindCommands}
+   */
+  class FindCommands extends Base {
+    getExistingElementForNode(node) {
+      for (let [id, el] of _.toPairs(this.elMap)) {
+        if (el.node === node) {
+          return id;
+        }
+      }
+      return null;
     }
-  }
-  return null;
-};
 
-helpers.wrapNewEl = function wrapNewEl(obj) {
-  // first check and see if we already have a ref to this element
-  let existingElId = this.getExistingElementForNode(obj);
-  if (existingElId) {
-    return {ELEMENT: existingElId};
-  }
+    wrapNewEl(obj) {
+      // first check and see if we already have a ref to this element
+      let existingElId = this.getExistingElementForNode(obj);
+      if (existingElId) {
+        return {ELEMENT: existingElId};
+      }
 
-  // otherwise add the element to the map
-  this.maxElId++;
-  this.elMap[this.maxElId.toString()] = new FakeElement(obj, this.appModel);
-  return {ELEMENT: this.maxElId.toString()};
-};
+      // otherwise add the element to the map
+      this.maxElId++;
+      this.elMap[this.maxElId.toString()] = new FakeElement(obj, this.appModel);
+      return {ELEMENT: this.maxElId.toString()};
+    }
+    /**
+     * @template {boolean} Mult
+     * @template [Ctx=any]
+     * @param {string} strategy
+     * @param {string} selector
+     * @param {Mult} mult
+     * @param {Ctx} [context]
+     * @returns {Promise<Mult extends true ? Element[] : Element>}
+     */
+    async findElOrEls(strategy, selector, mult, context) {
+      let qMap = {
+        xpath: 'xpathQuery',
+        id: 'idQuery',
+        'accessibility id': 'idQuery',
+        'class name': 'classQuery',
+        'tag name': 'classQuery',
+        'css selector': 'cssQuery',
+      };
+      // TODO this error checking should probably be part of MJSONWP?
+      if (!_.includes(_.keys(qMap), strategy)) {
+        throw new errors.UnknownCommandError();
+      }
+      if (selector === 'badsel') {
+        throw new errors.InvalidSelectorError();
+      }
+      let els = this.appModel[qMap[strategy]](selector, context);
 
-helpers.findElOrEls = async function findElOrEls(strategy, selector, mult, ctx) {
-  let qMap = {
-    xpath: 'xpathQuery',
-    id: 'idQuery',
-    'accessibility id': 'idQuery',
-    'class name': 'classQuery',
-    'tag name': 'classQuery',
-    'css selector': 'cssQuery',
-  };
-  // TODO this error checking should probably be part of MJSONWP?
-  if (!_.includes(_.keys(qMap), strategy)) {
-    throw new errors.UnknownCommandError();
-  }
-  if (selector === 'badsel') {
-    throw new errors.InvalidSelectorError();
-  }
-  let els = this.appModel[qMap[strategy]](selector, ctx);
-  if (els.length) {
-    if (mult) {
-      let allEls = [];
-      for (let el of els) {
-        allEls.push(this.wrapNewEl(el));
+      let retval;
+      if (els.length) {
+        if (mult) {
+          let allEls = [];
+          for (let el of els) {
+            allEls.push(this.wrapNewEl(el));
+          }
+          retval = allEls;
+        } else {
+          retval = this.wrapNewEl(els[0]);
+        }
+      } else if (mult) {
+        retval = [];
+      } else {
+        throw new errors.NoSuchElementError();
       }
-      return allEls;
-    } else {
-      return this.wrapNewEl(els[0]);
+      return /** @type {Mult extends true ? Element[] : Element} */ (retval);
+    }
+
+    async findElement(strategy, selector) {
+      return this.findElOrEls(strategy, selector, false);
+    }
+
+    async findElements(strategy, selector) {
+      return this.findElOrEls(strategy, selector, true);
+    }
+
+    async findElementFromElement(strategy, selector, elementId) {
+      let el = this.getElement(elementId);
+      return this.findElOrEls(strategy, selector, false, el.xmlFragment);
+    }
+
+    async findElementsFromElement(strategy, selector, elementId) {
+      let el = this.getElement(elementId);
+      return this.findElOrEls(strategy, selector, true, el.xmlFragment);
     }
-  } else if (mult) {
-    return [];
-  } else {
-    throw new errors.NoSuchElementError();
   }
-};
 
-commands.findElement = async function findElement(strategy, selector) {
-  return this.findElOrEls(strategy, selector, false);
-};
+  return FindCommands;
+}
 
-commands.findElements = async function findElements(strategy, selector) {
-  return this.findElOrEls(strategy, selector, true);
-};
+/**
+ * @typedef {import('../driver').FakeDriverCore} FakeDriverCore
+ * @typedef {import('@appium/types').Element} Element
 
-commands.findElementFromElement = async function findElementFromElement(
-  strategy,
-  selector,
-  elementId
-) {
-  let el = this.getElement(elementId);
-  return this.findElOrEls(strategy, selector, false, el.xmlFragment);
-};
+ */
 
-commands.findElementsFromElement = async function findElementsFromElement(
-  strategy,
-  selector,
-  elementId
-) {
-  let el = this.getElement(elementId);
-  return this.findElOrEls(strategy, selector, true, el.xmlFragment);
-};
+/**
+ * @template T,[U={}],[V=Array<any>]
+ * @typedef {import('@appium/types').Class<T,U,V>} Class
+ */
 
-Object.assign(extensions, commands, helpers);
-export {commands, helpers};
-export default extensions;
+/**
+ * @template [Ctx=any]
+ * @typedef {import('@appium/types').IFindCommands<Ctx>} IFindCommands
+ */