@appium/fake-driver 5.1.3 → 5.1.5

package/lib/commands/contexts.js

@@ -1,101 +1,92 @@
 import _ from 'lodash';
 import {errors} from 'appium/driver';
 
-/**
- *
- * @template {Class<import('../types').IFakeDriver>} T
- * @param {T} Base
- */
-export function ContextsMixin(Base) {
+export default {
   /**
-   * @implements {IContextsCommands}
+   * @this {FakeDriver}
    */
-  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;
+  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;
+  },
 
-    assertWebviewContext() {
-      if (this.curContext === 'NATIVE_APP') {
-        throw new errors.InvalidContextError();
-      }
+  /**
+   * @this {FakeDriver}
+   */
+  assertWebviewContext() {
+    if (this.curContext === 'NATIVE_APP') {
+      throw new errors.InvalidContextError();
     }
+  },
 
-    // do not add a description to this method's docstring
-    /*
-     * @returns {Promise<string>}
-     */
-    async getCurrentContext() {
-      return this.curContext;
-    }
+  /**
+   * @returns {Promise<string>}
+   * @this {FakeDriver}
+   */
+  async getCurrentContext() {
+    return this.curContext;
+  },
 
-    /**
-     * Get the list of available contexts
-     *
-     * @returns {Promise<string[]>}
-     */
-    async getContexts() {
-      return _.keys(this.getRawContexts());
-    }
+  /**
+   * Get the list of available contexts
+   *
+   * @returns {Promise<string[]>}
+   * @this {FakeDriver}
+   */
+  async getContexts() {
+    return _.keys(this.getRawContexts());
+  },
 
-    /**
-     * 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;
-        }
+  /**
+   * Set the current context
+   *
+   * @param {string} context - name of the context
+   * @returns {Promise<void>}
+   * @this {FakeDriver}
+   */
+  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 {
-        throw new errors.NoSuchContextError();
+        this.appModel.activateWebview(contexts[context]);
+        this._proxyActive = false;
       }
+    } else {
+      throw new errors.NoSuchContextError();
     }
+  },
 
-    /**
-     * 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]);
+  /**
+   * Set the active frame
+   *
+   * @param {number} frameId
+   * @returns {Promise<void>}
+   * @this {FakeDriver}
+   */
+  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]);
     }
-  }
-
-  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
+ * @typedef {import('../driver').FakeDriver} FakeDriver
  */

package/lib/commands/element.js

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

package/lib/commands/find.js

@@ -2,121 +2,117 @@ import _ from 'lodash';
 import {errors} from 'appium/driver';
 import {FakeElement} from '../fake-element';
 
-/**
- * @template {Class<import('../types').IElementCommands>} T
- * @param {T} Base
- */
-export function FindMixin(Base) {
+export default {
   /**
-   * @implements {IFindCommands}
+   * @this {FakeDriver}
    */
-  class FindCommands extends Base {
-    getExistingElementForNode(node) {
-      for (let [id, el] of _.toPairs(this.elMap)) {
-        if (el.node === node) {
-          return id;
-        }
+  getExistingElementForNode(node) {
+    for (let [id, el] of _.toPairs(this.elMap)) {
+      if (el.node === node) {
+        return id;
       }
-      return null;
     }
+    return null;
+  },
 
-    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};
-      }
+  /**
+   * @this {FakeDriver}
+   */
+  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>}
+   * @this {FakeDriver}
+   */
+  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();
     }
-    /**
-     * @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);
+    if (selector === 'badsel') {
+      throw new errors.InvalidSelectorError();
+    }
+    let els = this.appModel[qMap[strategy]](selector, context);
 
-      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]);
+    let retval;
+    if (els.length) {
+      if (mult) {
+        let allEls = [];
+        for (let el of els) {
+          allEls.push(this.wrapNewEl(el));
         }
-      } else if (mult) {
-        retval = [];
+        retval = allEls;
       } else {
-        throw new errors.NoSuchElementError();
+        retval = this.wrapNewEl(els[0]);
       }
-      return /** @type {Mult extends true ? Element[] : Element} */ (retval);
+    } else if (mult) {
+      retval = [];
+    } else {
+      throw new errors.NoSuchElementError();
     }
+    return /** @type {Mult extends true ? Element[] : Element} */ (retval);
+  },
 
-    /**
-     * This should override whatever's in ExternalDriver
-     * @param {string} strategy Strategy
-     * @param {string} selector Selector
-     */
-    async findElement(strategy, selector) {
-      return this.findElOrEls(strategy, selector, false);
-    }
-
-    async findElements(strategy, selector) {
-      return this.findElOrEls(strategy, selector, true);
-    }
+  /**
+   * This should override whatever's in ExternalDriver
+   * @param {string} strategy Strategy
+   * @param {string} selector Selector
+   * @this {FakeDriver}
+   */
+  async findElement(strategy, selector) {
+    return this.findElOrEls(strategy, selector, false);
+  },
 
-    async findElementFromElement(strategy, selector, elementId) {
-      let el = this.getElement(elementId);
-      return this.findElOrEls(strategy, selector, false, el.xmlFragment);
-    }
+  /**
+   * @this {FakeDriver}
+   */
+  async findElements(strategy, selector) {
+    return this.findElOrEls(strategy, selector, true);
+  },
 
-    async findElementsFromElement(strategy, selector, elementId) {
-      let el = this.getElement(elementId);
-      return this.findElOrEls(strategy, selector, true, el.xmlFragment);
-    }
-  }
+  /**
+   * @this {FakeDriver}
+   */
+  async findElementFromElement(strategy, selector, elementId) {
+    let el = this.getElement(elementId);
+    return this.findElOrEls(strategy, selector, false, el.xmlFragment);
+  },
 
-  return FindCommands;
-}
+  /**
+   * @this {FakeDriver}
+   */
+  async findElementsFromElement(strategy, selector, elementId) {
+    let el = this.getElement(elementId);
+    return this.findElOrEls(strategy, selector, true, el.xmlFragment);
+  },
+};
 
 /**
- * @typedef {import('../driver').FakeDriverCore} FakeDriverCore
  * @typedef {import('@appium/types').Element} Element
-
- */
-
-/**
- * @template T,[U={}],[V=Array<any>]
- * @typedef {import('@appium/types').Class<T,U,V>} Class
- */
-
-/**
- * @template [Ctx=any]
- * @typedef {import('@appium/types').IFindCommands<Ctx>} IFindCommands
+ * @typedef {import('../driver').FakeDriver} FakeDriver
  */