@appium/fake-driver 6.0.1 → 6.1.0

package/lib/driver.js

@@ -1,356 +0,0 @@
-import B from 'bluebird';
-import {BaseDriver, errors} from 'appium/driver';
-import {FakeApp} from './fake-app';
-
-const FAKE_DRIVER_CONSTRAINTS = /** @type {const} */ ({
-  app: {
-    presence: true,
-    isString: true,
-  },
-  uniqueApp: {
-    isBoolean: true,
-  },
-  runClock: {
-    isBoolean: true,
-  },
-});
-
-/**
- * Constraints for {@linkcode FakeDriver}'s capabilities
- * @typedef {typeof FAKE_DRIVER_CONSTRAINTS} FakeDriverConstraints
- */
-
-/**
- * @template [Thing=any]
- * @extends {BaseDriver<FakeDriverConstraints>}
- * @implements {ExternalDriver<FakeDriverConstraints>}
- */
-export class FakeDriver extends BaseDriver {
-  /**
-   * @type {FakeDriverConstraints}
-   * @readonly
-   */
-  desiredCapConstraints;
-
-  /** @type {string} */
-  curContext;
-
-  /** @type {FakeApp} */
-  appModel;
-
-  /** @type {boolean} */
-  _proxyActive;
-
-  /** @type {boolean} */
-  shook;
-
-  /** @type {string?} */
-  focusedElId;
-
-  /** @type {Thing?} */
-  fakeThing;
-
-  /** @type {number} */
-  maxElId;
-
-  /** @type {Record<string,import('./fake-element').FakeElement>} */
-  elMap;
-
-  /** @type {string|null} */
-  _bidiProxyUrl;
-
-  /** @type {boolean} */
-  _clockRunning = false;
-
-
-  constructor(
-    opts = /** @type {import('@appium/types').InitialOpts} */ ({}),
-    shouldValidateCaps = true,
-  ) {
-    super(opts, shouldValidateCaps);
-    this.curContext = 'NATIVE_APP';
-    this.elMap = {};
-    this.focusedElId = null;
-    this.maxElId = 0;
-    this.fakeThing = null;
-    this._proxyActive = false;
-    this.shook = false;
-    this.appModel = new FakeApp();
-    this.desiredCapConstraints = FAKE_DRIVER_CONSTRAINTS;
-    this._bidiProxyUrl = null;
-  }
-
-  proxyActive() {
-    return this._proxyActive;
-  }
-
-  canProxy() {
-    return true;
-  }
-
-  get bidiProxyUrl() {
-    return this._bidiProxyUrl;
-  }
-
-  proxyReqRes(req, res) {
-    // fake implementation of jwp proxy req res
-    res.set('content-type', 'application/json');
-    const resBodyObj = {value: 'proxied via proxyReqRes'};
-    const match = req.originalUrl.match(/\/session\/([^/]+)/);
-    resBodyObj.sessionId = match ? match[1] : null;
-    res.status(200).send(JSON.stringify(resBodyObj));
-  }
-
-  /**
-   * @template [T=any]
-   * @returns {Promise<T>}
-   */
-  async proxyCommand(/*url, method, body*/) {
-    return /** @type {T} */ (/** @type {unknown} */ ('proxied via proxyCommand'));
-  }
-
-  /**
-   * Comment for `createSession` in `FakeDriver`
-   * @param {W3CFakeDriverCaps} w3cCapabilities1 W3C Capabilities
-   * @param {W3CFakeDriverCaps} [w3cCapabilities2] W3C Capabilities
-   * @param {W3CFakeDriverCaps} [w3cCapabilities3] W3C Capabilities
-   * @param {import('@appium/types').DriverData[]} [driverData] Other session data
-   * @override
-   * @returns {Promise<[string,FakeDriverCaps]>}
-   */
-  async createSession(w3cCapabilities1, w3cCapabilities2, w3cCapabilities3, driverData = []) {
-    // BaseDriver automatically validates capabilities using desiredCapConstraints
-
-    // check to see if any other sessions have set uniqueApp. If so, emulate
-    // not being able to start a session because of system resources
-    for (let d of driverData) {
-      if (d.isUnique) {
-        throw new errors.SessionNotCreatedError(
-          'Cannot start session; another ' +
-            'unique session is in progress that requires all resources',
-        );
-      }
-    }
-
-    let [sessionId, caps] = /** @type {[string, FakeDriverCaps]} */ (
-      await super.createSession(w3cCapabilities1, w3cCapabilities2, w3cCapabilities3, driverData)
-    );
-    this.caps = caps;
-    await this.appModel.loadApp(caps.app);
-    if (this.caps.runClock) {
-      this.startClock();
-    }
-    return [sessionId, caps];
-  }
-
-  /**
-   * @param {string} [sessionId]
-   * @returns {Promise<void>}
-   */
-  async deleteSession(sessionId) {
-    this.stopClock();
-    return await super.deleteSession(sessionId);
-  }
-
-  /**
-   * @returns {Promise<string>}
-   */
-  async getWindowHandle() {
-    return '1';
-  }
-
-  /**
-   * @returns {Promise<string[]>}
-   */
-  async getWindowHandles() {
-    return ['1'];
-  }
-
-  get driverData() {
-    return {
-      isUnique: !!this.caps.uniqueApp,
-    };
-  }
-
-  async getFakeThing() {
-    await B.delay(1);
-    return this.fakeThing;
-  }
-
-  async startClock() {
-    this._clockRunning = true;
-    while (this._clockRunning) {
-      await B.delay(500);
-      this.eventEmitter.emit('bidiEvent', {
-        method: 'appium:clock.currentTime',
-        params: {time: Date.now()},
-      });
-    }
-  }
-
-  stopClock() {
-    this._clockRunning = false;
-  }
-
-  /**
-   * Set the 'thing' value (so that it can be retrieved later)
-   *
-   * @param {Thing} thing
-   * @returns {Promise<null>}
-   */
-  async setFakeThing(thing) {
-    await B.delay(1);
-    this.fakeThing = thing;
-    return null;
-  }
-
-  /**
-   * Get the driver args that were sent in via the CLI
-   *
-   * @returns {Promise<typeof this.cliArgs>}
-   */
-  async getFakeDriverArgs() {
-    await B.delay(1);
-    return this.cliArgs;
-  }
-
-  /**
-   * This is a command that will return a list of deprecated command names called
-   *
-   * @returns {Promise<string[]>}
-   */
-  async getDeprecatedCommandsCalled() {
-    await B.delay(1);
-    // TODO: Properly get deprecatedCommandsLogged list from the base-driver
-    return [];
-  }
-
-  /**
-   * This is a command that exists just to be an example of a deprecated command
-   *
-   * @returns {Promise<void>}
-   */
-  async callDeprecatedCommand() {
-    await B.delay(1);
-  }
-
-  /**
-   * @param {number} num1
-   * @param {number} num2
-   */
-  async doSomeMath(num1, num2) {
-    await B.delay(1);
-    return num1 + num2;
-  }
-
-  /**
-   * @param {number} num1
-   * @param {number} num2
-   */
-  async doSomeMath2(num1, num2) {
-    await B.delay(1);
-    return num1 + num2;
-  }
-
-  static newBidiCommands = /** @type {const} */({
-    'appium:fake': {
-      getFakeThing: {
-        command: 'getFakeThing',
-      },
-      setFakeThing: {
-        command: 'setFakeThing',
-        params: {
-          required: ['thing'],
-        },
-      },
-      doSomeMath: {
-        command: 'doSomeMath',
-        params: {
-          required: ['num1', 'num2'],
-        },
-      },
-      doSomeMath2: {
-        command: 'doSomeMath2',
-        params: {
-          required: ['num1', 'num2'],
-        },
-      },
-    }
-  });
-
-  static newMethodMap = /** @type {const} */ ({
-    '/session/:sessionId/fakedriver': {
-      GET: {command: 'getFakeThing'},
-      /**
-       * Sets a fake thing
-       */
-      POST: {command: 'setFakeThing', payloadParams: {required: ['thing']}},
-    },
-    '/session/:sessionId/fakedriverargs': {
-      GET: {command: 'getFakeDriverArgs'},
-    },
-    '/session/:sessionId/deprecated': {
-      POST: {command: 'callDeprecatedCommand', deprecated: true},
-    },
-    // this next one exists to override a deprecated method
-    '/session/:sessionId/doubleclick': {
-      POST: {command: 'doubleClick'},
-    },
-  });
-
-  static executeMethodMap = /** @type {const} */ ({
-    'fake: addition': {
-      command: 'fakeAddition',
-      params: {required: ['num1', 'num2'], optional: ['num3']},
-    },
-    /**
-     * Gets a thing (a fake thing)
-     */
-    'fake: getThing': {
-      command: 'getFakeThing',
-    },
-    'fake: setThing': {
-      command: 'setFakeThing',
-      params: {required: ['thing']},
-    },
-    'fake: getDeprecatedCommandsCalled': {
-      command: 'getDeprecatedCommandsCalled',
-    },
-  });
-
-  static fakeRoute(req, res) {
-    res.send(JSON.stringify({fakedriver: 'fakeResponse'}));
-  }
-
-  static async updateServer(expressApp, httpServer, cliArgs) {
-
-    expressApp.all('/fakedriver', FakeDriver.fakeRoute);
-    expressApp.all('/fakedriverCliArgs', (req, res) => {
-      res.send(JSON.stringify(cliArgs));
-    });
-  }
-}
-
-import './commands';
-
-export default FakeDriver;
-
-/**
- * @typedef {import('./types').FakeDriverCaps} FakeDriverCaps
- * @typedef {import('./types').W3CFakeDriverCaps} W3CFakeDriverCaps
- * @typedef {import('@appium/types').Element} Element
- */
-
-/**
- * @template {import('@appium/types').Driver} D
- * @typedef {import('@appium/types').DriverClass<D>} DriverClass
- */
-
-/**
- * @template {import('@appium/types').Constraints} C
- * @typedef {import('@appium/types').ExternalDriver<C>} ExternalDriver
- */
-
-/**
- * @typedef {import('@appium/types').Orientation} Orientation
- */

package/lib/fake-app.js

@@ -1,190 +0,0 @@
-import {fs} from 'appium/support';
-import {readFileSync} from 'fs';
-import path from 'path';
-import XMLDom from '@xmldom/xmldom';
-import * as xpath from 'xpath';
-import log from './logger';
-import _ from 'lodash';
-import {FakeElement} from './fake-element';
-
-const SCREENSHOT = path.join(__dirname, 'screen.png');
-
-export class FakeApp {
-  constructor() {
-    this.dom = null;
-    this.activeDom = null;
-    this.activeWebview = null;
-    this.activeFrame = null;
-    this.activeAlert = null;
-    this.lat = 0;
-    this.long = 0;
-    this._width = null;
-    this._height = null;
-    this.rawXml = '';
-    /** @type {import('./driver').Orientation} */
-    this.currentOrientation = 'PORTRAIT';
-    /** @type {import('@appium/types').ActionSequence[][]} */
-    this.actionLog = [];
-  }
-
-  get title() {
-    let nodes = this.xpathQuery('//title');
-    if (!_.isArray(nodes) || nodes.length < 1) {
-      throw new Error('No title!');
-    }
-    const node = /** @type {Node} */ (nodes[0]);
-    return /** @type {ElementWithData} */ (node.firstChild).data;
-  }
-
-  /**
-   * @type {import('@appium/types').Location}
-   */
-  get currentGeoLocation() {
-    return {
-      latitude: this.lat,
-      longitude: this.long,
-    };
-  }
-
-  get orientation() {
-    return this.currentOrientation;
-  }
-
-  set orientation(o) {
-    this.currentOrientation = o;
-  }
-
-  /**
-   * @type {number}
-   */
-  get width() {
-    if (this._width === null) {
-      this.setDims();
-    }
-    return /** @type {number} */ (this._width);
-  }
-
-  /**
-   * @type {number}
-   */
-  get height() {
-    if (this._width === null) {
-      this.setDims();
-    }
-    return /** @type {number} */ (this._width);
-  }
-
-  setDims() {
-    const nodes = this.xpathQuery('//app');
-    if (!_.isArray(nodes)) {
-      throw new Error(
-        'Cannot fetch app dimensions because no corresponding node has benn found in the source'
-      );
-    }
-    const app = new FakeElement(nodes[0], this);
-    this._width = parseInt(app.nodeAttrs.width, 10);
-    this._height = parseInt(app.nodeAttrs.height, 10);
-  }
-
-  async loadApp(appPath) {
-    log.info(`Loading Mock app model at ${appPath}`);
-    let data = await fs.readFile(appPath);
-    log.info('Parsing Mock app XML');
-    this.rawXml = data.toString();
-    this.rawXml = this.rawXml.replace('<app ', '<AppiumAUT><app ');
-    this.rawXml = this.rawXml.replace('<app>', '<AppiumAUT><app>');
-    this.rawXml = this.rawXml.replace('</app>', '</app></AppiumAUT>');
-    this.dom = new XMLDom.DOMParser().parseFromString(this.rawXml, XMLDom.MIME_TYPE.XML_TEXT);
-    this.activeDom = this.dom;
-  }
-
-  getWebviews() {
-    const nodes = this.xpathQuery('//MockWebView/*[1]');
-    return _.isArray(nodes) ? nodes.map((n) => new FakeWebView(n)) : [];
-  }
-
-  activateWebview(wv) {
-    this.activeWebview = wv;
-    let fragment = new XMLDom.XMLSerializer().serializeToString(wv.node);
-    this.activeDom = new XMLDom.DOMParser().parseFromString(fragment, XMLDom.MIME_TYPE.XML_TEXT);
-  }
-
-  deactivateWebview() {
-    this.activeWebview = null;
-    this.activeDom = this.dom;
-  }
-
-  activateFrame(frame) {
-    this.activeFrame = frame;
-    let fragment = new XMLDom.XMLSerializer().serializeToString(frame);
-    this.activeDom = new XMLDom.DOMParser().parseFromString(fragment, XMLDom.MIME_TYPE.XML_TEXT);
-  }
-
-  deactivateFrame() {
-    this.activeFrame = null;
-    this.activateWebview(this.activeWebview);
-  }
-
-  xpathQuery(sel, ctx) {
-    return xpath.select(sel, ctx || this.activeDom);
-  }
-
-  idQuery(id, ctx) {
-    return this.xpathQuery(`//*[@id="${id}"]`, ctx);
-  }
-
-  classQuery(className, ctx) {
-    return this.xpathQuery(`//${className}`, ctx);
-  }
-
-  cssQuery(css, ctx) {
-    if (css.startsWith('#')) {
-      return this.idQuery(css.slice(1), ctx);
-    }
-    if (css.startsWith('.')) {
-      return this.classQuery(css.slice(1), ctx);
-    }
-    return this.classQuery(css, ctx);
-  }
-
-  hasAlert() {
-    return this.activeAlert !== null;
-  }
-
-  setAlertText(text) {
-    if (!this.activeAlert?.hasPrompt()) {
-      throw new Error('No prompt to set text of');
-    }
-    this.activeAlert?.setAttr('prompt', text);
-  }
-
-  showAlert(alertId) {
-    let nodes = this.xpathQuery(`//alert[@id="${alertId}"]`);
-    if (!_.isArray(nodes) || _.isEmpty(nodes)) {
-      throw new Error(`Alert ${alertId} doesn't exist!`);
-    }
-    this.activeAlert = new FakeElement(nodes[0], this);
-  }
-
-  alertText() {
-    return this.activeAlert?.getAttr('prompt') || this.activeAlert?.nodeAttrs.text;
-  }
-
-  handleAlert() {
-    this.activeAlert = null;
-  }
-
-  getScreenshot() {
-    return readFileSync(SCREENSHOT, 'base64');
-  }
-}
-
-class FakeWebView {
-  constructor(node) {
-    this.node = node;
-  }
-}
-
-/**
- * @typedef {Element & {data: any}} ElementWithData
- */

package/lib/fake-driver-schema.js

@@ -1,35 +0,0 @@
-// this could be a .json file, too:
-// {
-//   "$schema": "http://json-schema.org/draft-07/schema",
-//   "$id": "https://appium.io/fake-driver.json",
-//   "type": "object",
-//   "title": "Fake Driver Configuration",
-//   "description": "A schema for Fake Driver arguments",
-//   "properties": {
-//     "answer": {
-//       "type": "number",
-//       "description": "The answer to life, the universe, and everything",
-//       "default": 42
-//     }
-//   }
-// }
-
-export default {
-  type: 'object',
-  title: 'Fake Driver Configuration',
-  description: 'A schema for Fake Driver arguments',
-  properties: {
-    // the prop name will always be normalized to camelCase
-    'silly-web-server-port': {
-      type: 'integer',
-      minimum: 1,
-      maximum: 65535,
-      description: 'The port to use for the fake web server',
-    },
-    sillyWebServerHost: {
-      type: 'string',
-      description: 'The host to use for the fake web server',
-      default: 'sillyhost',
-    },
-  },
-};

package/lib/fake-element.js

@@ -1,117 +0,0 @@
-import _ from 'lodash';
-import XMLDom from '@xmldom/xmldom';
-
-export class FakeElement {
-  /** @type {FakeApp} */
-  app;
-
-  /** @type {string} */
-  type;
-
-  /** @type {Record<string,string>} */
-  nodeAttrs;
-
-  /**
-   * @param {any} xmlNode
-   * @param {FakeApp} app
-   */
-  constructor(xmlNode, app) {
-    this.app = app;
-    this.node = xmlNode;
-    this.nodeAttrs = {};
-    this.type = this.node.tagName;
-    this.attrs = {};
-    this.css = {};
-    for (let {name, value} of _.values(this.node.attributes)) {
-      this.nodeAttrs[name] = value;
-    }
-    this.parseCss();
-  }
-
-  parseCss() {
-    if (this.nodeAttrs.style) {
-      let segments = this.nodeAttrs.style.split(';');
-      for (let s of segments) {
-        let [prop, val] = s.split(':');
-        prop = prop.trim();
-        val = val.trim();
-        this.css[prop] = val;
-      }
-    }
-  }
-
-  get tagName() {
-    return this.node.tagName;
-  }
-
-  setAttr(k, v) {
-    this.attrs[k] = v;
-  }
-
-  getAttr(k) {
-    return this.attrs[k] || '';
-  }
-
-  isVisible() {
-    return this.nodeAttrs.visible !== 'false';
-  }
-
-  isEnabled() {
-    return this.nodeAttrs.enabled !== 'false';
-  }
-
-  isSelected() {
-    return this.nodeAttrs.selected === 'true';
-  }
-
-  getLocation() {
-    return {
-      x: parseFloat(this.nodeAttrs.left || '0'),
-      y: parseFloat(this.nodeAttrs.top || '0'),
-    };
-  }
-
-  getElementRect() {
-    return {...this.getLocation(), ...this.getSize()};
-  }
-
-  getSize() {
-    return {
-      width: parseFloat(this.nodeAttrs.width || '0'),
-      height: parseFloat(this.nodeAttrs.height || '0'),
-    };
-  }
-
-  click() {
-    let curClicks = this.getAttr('clicks') || 0;
-    this.setAttr('clicks', curClicks + 1);
-    let alertId = this.nodeAttrs.showAlert;
-    if (alertId) {
-      this.app.showAlert(alertId);
-    }
-  }
-
-  equals(other) {
-    return this.node === other.node;
-  }
-
-  hasPrompt() {
-    return this.nodeAttrs.hasPrompt === 'true';
-  }
-
-  getCss(prop) {
-    if (_.has(this.css, prop)) {
-      return this.css[prop];
-    }
-    return null;
-  }
-
-  get xmlFragment() {
-    let frag = new XMLDom.XMLSerializer().serializeToString(this.node);
-    return new XMLDom.DOMParser().parseFromString(frag, XMLDom.MIME_TYPE.XML_TEXT);
-  }
-}
-
-/**
- * @typedef {import('./fake-app').FakeApp} FakeApp
- */

package/lib/logger.js

@@ -1,5 +0,0 @@
-import {logger} from 'appium/support';
-
-const log = logger.getLogger('FakeDriver');
-
-export default log;