@appium/fake-driver 6.0.2 → 6.1.0

package/lib/fake-element.ts

@@ -0,0 +1,128 @@
+import _ from 'lodash';
+import XMLDom from '@xmldom/xmldom';
+import type {Document as XMLDocument, Node as XMLNode} from '@xmldom/xmldom';
+import type {FakeApp} from './fake-app';
+
+export interface XmlNodeLike {
+  tagName: string;
+  attributes: {name: string; value: string}[];
+}
+
+/** Wrapper around an XML node from the fake app DOM; supports attrs, css, visibility, click, alerts. */
+export class FakeElement {
+  readonly app: FakeApp;
+  readonly type: string;
+  readonly nodeAttrs: Record<string, string>;
+  readonly node: XmlNodeLike;
+  attrs: Record<string, string>;
+  css: Record<string, string>;
+
+  constructor(xmlNode: XmlNodeLike, app: FakeApp) {
+    this.app = app;
+    this.node = xmlNode;
+    this.nodeAttrs = {};
+    this.type = xmlNode.tagName;
+    this.attrs = {};
+    this.css = {};
+    // Support both DOM Attr (name/value) and nodeName/nodeValue (e.g. @xmldom/xmldom).
+    const attrs = this.node.attributes as unknown as Array<{
+      name?: string; nodeName?: string; value?: string; nodeValue?: string
+    }>;
+    for (const attr of _.values(attrs)) {
+      const name = attr.name ?? attr.nodeName ?? '';
+      const value = attr.value ?? attr.nodeValue ?? '';
+      if (name) {
+        this.nodeAttrs[name] = value;
+      }
+    }
+    this.parseCss();
+  }
+
+  private parseCss(): void {
+    if (this.nodeAttrs.style) {
+      const segments = this.nodeAttrs.style.split(';');
+      for (const s of segments) {
+        let [prop, val] = s.split(':');
+        prop = prop.trim();
+        val = val.trim();
+        this.css[prop] = val;
+      }
+    }
+  }
+
+  get tagName(): string {
+    return this.node.tagName;
+  }
+
+  setAttr(k: string, v: string): void {
+    this.attrs[k] = v;
+  }
+
+  getAttr(k: string): string {
+    return this.attrs[k] || '';
+  }
+
+  isVisible(): boolean {
+    return this.nodeAttrs.visible !== 'false';
+  }
+
+  isEnabled(): boolean {
+    return this.nodeAttrs.enabled !== 'false';
+  }
+
+  isSelected(): boolean {
+    return this.nodeAttrs.selected === 'true';
+  }
+
+  getLocation(): {x: number; y: number} {
+    return {
+      x: parseFloat(this.nodeAttrs.left || '0'),
+      y: parseFloat(this.nodeAttrs.top || '0'),
+    };
+  }
+
+  getElementRect(): {x: number; y: number; width: number; height: number} {
+    return {...this.getLocation(), ...this.getSize()};
+  }
+
+  getSize(): {width: number; height: number} {
+    return {
+      width: parseFloat(this.nodeAttrs.width || '0'),
+      height: parseFloat(this.nodeAttrs.height || '0'),
+    };
+  }
+
+  click(): void {
+    const curClicks = Number(this.getAttr('clicks') || 0);
+    this.setAttr('clicks', String(curClicks + 1));
+    const alertId = this.nodeAttrs.showAlert;
+    if (alertId) {
+      this.app.showAlert(alertId);
+    }
+  }
+
+  equals(other: FakeElement): boolean {
+    return this.node === other.node;
+  }
+
+  hasPrompt(): boolean {
+    return this.nodeAttrs.hasPrompt === 'true';
+  }
+
+  getCss(prop: string): string | null {
+    if (_.has(this.css, prop)) {
+      return this.css[prop];
+    }
+    return null;
+  }
+
+  get xmlFragment(): XMLDocument {
+    const frag = new XMLDom.XMLSerializer().serializeToString(
+      this.node as unknown as XMLNode
+    );
+    return new XMLDom.DOMParser().parseFromString(
+      frag,
+      XMLDom.MIME_TYPE.XML_TEXT
+    ) as XMLDocument;
+  }
+}

package/lib/{index.js → index.ts}

@@ -4,19 +4,15 @@ import {startServer} from './server';
 const DEFAULT_HOST = 'localhost';
 const DEFAULT_PORT = 4774;
 
-async function main() {
-  const getArgValue = (/** @type {string} */ argName) => {
+export async function main() {
+  const getArgValue = (argName: string): string | null => {
     const argIndex = process.argv.indexOf(argName);
-    return argIndex > 0 ? process.argv[argIndex + 1] : null;
+    return argIndex > 0 ? process.argv[argIndex + 1] ?? null : null;
   };
   const port = parseInt(String(getArgValue('--port')), 10) || DEFAULT_PORT;
   const host = getArgValue('--host') || DEFAULT_HOST;
   return await startServer(port, host);
 }
 
-export {FakeDriver, startServer, main};
-
-/**
- * @typedef {import('./types').W3CFakeDriverCaps} W3CFakeDriverCaps
- * @typedef {import('./types').FakeDriverCaps} FakeDriverCaps
- */
+export {FakeDriver, startServer};
+export type {FakeDriverCaps, W3CFakeDriverCaps} from './types';

package/lib/logger.ts

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

package/lib/scripts/{fake-success.js → fake-success.ts}

@@ -1,4 +1,4 @@
-import log from '../logger';
+import {log} from '../logger';
 
 log.info('Successfully ran the script');
 

package/lib/{server.js → server.ts}

@@ -1,8 +1,9 @@
-import log from './logger';
+import {log} from './logger';
 import {server as baseServer, routeConfiguringFunction} from 'appium/driver';
 import {FakeDriver} from './driver';
 
-async function startServer(port, hostname) {
+/** Start HTTP server with FakeDriver and default WebDriver routes. */
+export async function startServer(port: number, hostname: string) {
   const d = new FakeDriver();
   const server = await baseServer({
     routeConfiguringFunction: routeConfiguringFunction(d),
@@ -12,5 +13,3 @@ async function startServer(port, hostname) {
   log.info(`FakeDriver server listening on http://${hostname}:${port}`);
   return server;
 }
-
-export {startServer};

package/lib/types.ts

@@ -1,5 +1,5 @@
 import type {DriverCaps, W3CDriverCaps} from '@appium/types';
-import type {FakeDriverConstraints} from './driver';
+import type {FakeDriverConstraints} from './desired-caps';
 
 /**
  * W3C-style caps for {@link FakeDriver}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appium/fake-driver",
-  "version": "6.0.2",
+  "version": "6.1.0",
   "description": "Mock driver used internally by Appium for testing. Ignore",
   "keywords": [
     "automation",
@@ -28,23 +28,20 @@
   },
   "files": [
     "lib",
-    "build",
-    "test/fixtures",
-    "tsconfig.json",
-    "!build/tsconfig.tsbuildinfo",
-    "!build/test"
+    "build/lib",
+    "tsconfig.json"
   ],
   "scripts": {
     "build": "cpy lib/screen.png build",
     "clean": "npx rimraf build/lib/screen.png",
     "test": "npm run test:unit",
-    "test:e2e": "mocha --exit --timeout 20s --slow 10s \"./test/e2e/**/*.spec.js\"",
+    "test:e2e": "mocha --exit --timeout 20s --slow 10s \"./test/e2e/**/*.spec.ts\"",
     "test:smoke": "node ./build/lib/index.js",
-    "test:unit": "mocha --exit --timeout 10s --slow 5s \"./test/unit/**/*.spec.js\""
+    "test:unit": "mocha --exit --timeout 10s --slow 5s \"./test/unit/**/*.spec.ts\""
   },
   "dependencies": {
     "@xmldom/xmldom": "0.9.8",
-    "bluebird": "3.7.2",
+    "asyncbox": "6.1.0",
     "lodash": "4.17.23",
     "xpath": "0.0.34"
   },
@@ -74,12 +71,12 @@
     },
     "doctor": {
       "checks": [
-        "./doctor/fake1.js",
-        "./doctor/fake2.js"
+        "./build/lib/doctor/fake1.js",
+        "./build/lib/doctor/fake2.js"
       ]
     }
   },
   "main": "./build/lib/index.js",
   "types": "./build/lib/index.d.ts",
-  "gitHead": "f7b20335eab4022e5cbbb627ec86866a994444f8"
+  "gitHead": "980a121804ae006db879fb6860f627ac36174c15"
 }

package/tsconfig.json

@@ -3,6 +3,7 @@
   "compilerOptions": {
     "outDir": "build",
     "checkJs": true,
+    "types": ["mocha", "chai", "chai-as-promised", "node"],
     "paths": {
       "@appium/types": ["../types"],
       "appium/support": ["../appium/support"],
@@ -10,7 +11,7 @@
       "@appium/driver-test-support": ["../driver-test-support"]
     }
   },
-  "include": ["lib"],
+  "include": ["lib", "test"],
   "references": [
     {"path": "../types"},
     {"path": "../support"},

package/build/lib/commands/index.d.ts

@@ -1,14 +0,0 @@
-/**
- * Export all of the "stuff" from these mixin files.  The mixins themselves are not exported,
- * but any types/interfaces that they export (e.g., options objects for some command) are exported.
- *
- * Mixins must not use `Object.assign()` and are expected to use the `mixin` function in the sibling
- * `mixin` module.
- * @module
- */
-import './alert';
-import './contexts';
-import './element';
-import './find';
-import './general';
-//# sourceMappingURL=index.d.ts.map

package/build/lib/commands/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/commands/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,SAAS,CAAC;AACjB,OAAO,YAAY,CAAC;AACpB,OAAO,WAAW,CAAC;AACnB,OAAO,QAAQ,CAAC;AAChB,OAAO,WAAW,CAAC"}

package/build/lib/commands/index.js

@@ -1,16 +0,0 @@
-"use strict";
-/**
- * Export all of the "stuff" from these mixin files.  The mixins themselves are not exported,
- * but any types/interfaces that they export (e.g., options objects for some command) are exported.
- *
- * Mixins must not use `Object.assign()` and are expected to use the `mixin` function in the sibling
- * `mixin` module.
- * @module
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-require("./alert");
-require("./contexts");
-require("./element");
-require("./find");
-require("./general");
-//# sourceMappingURL=index.js.map

package/build/lib/commands/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../lib/commands/index.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;AAEH,mBAAiB;AACjB,sBAAoB;AACpB,qBAAmB;AACnB,kBAAgB;AAChB,qBAAmB"}

package/build/lib/commands/mixin.d.ts

@@ -1,11 +0,0 @@
-import { FakeDriver } from '../driver';
-/**
- * This function assigns a mixin `T` to the `FakeDriver` class' prototype.
- * While each mixin has its own interface which is (in isolation) unrelated to `FakeDriver`, the constraint
- * on this generic type `T` is that it must be a partial of `FakeDriver`'s interface. This enforces
- * that it does not conflict with the existing interface of `FakeDriver`.  In that way, you can
- * think of it as a type guard.
- * @param mixin Mixin implementation
- */
-export declare function mixin<T extends Partial<FakeDriver>>(mixin: T): void;
-//# sourceMappingURL=mixin.d.ts.map

package/build/lib/commands/mixin.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mixin.d.ts","sourceRoot":"","sources":["../../../lib/commands/mixin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAC,MAAM,WAAW,CAAC;AAErC;;;;;;;GAOG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,OAAO,CAAC,UAAU,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAEnE"}

package/build/lib/commands/mixin.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mixin = mixin;
-const driver_1 = require("../driver");
-/**
- * This function assigns a mixin `T` to the `FakeDriver` class' prototype.
- * While each mixin has its own interface which is (in isolation) unrelated to `FakeDriver`, the constraint
- * on this generic type `T` is that it must be a partial of `FakeDriver`'s interface. This enforces
- * that it does not conflict with the existing interface of `FakeDriver`.  In that way, you can
- * think of it as a type guard.
- * @param mixin Mixin implementation
- */
-function mixin(mixin) {
-    Object.assign(driver_1.FakeDriver.prototype, mixin);
-}
-//# sourceMappingURL=mixin.js.map

package/build/lib/commands/mixin.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"mixin.js","sourceRoot":"","sources":["../../../lib/commands/mixin.ts"],"names":[],"mappings":";;AAUA,sBAEC;AAZD,sCAAqC;AAErC;;;;;;;GAOG;AACH,SAAgB,KAAK,CAAgC,KAAQ;IAC3D,MAAM,CAAC,MAAM,CAAC,mBAAU,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;AAC7C,CAAC"}

package/lib/commands/index.ts

@@ -1,14 +0,0 @@
-/**
- * Export all of the "stuff" from these mixin files.  The mixins themselves are not exported,
- * but any types/interfaces that they export (e.g., options objects for some command) are exported.
- *
- * Mixins must not use `Object.assign()` and are expected to use the `mixin` function in the sibling
- * `mixin` module.
- * @module
- */
-
-import './alert';
-import './contexts';
-import './element';
-import './find';
-import './general';

package/lib/commands/mixin.ts

@@ -1,13 +0,0 @@
-import {FakeDriver} from '../driver';
-
-/**
- * This function assigns a mixin `T` to the `FakeDriver` class' prototype.
- * While each mixin has its own interface which is (in isolation) unrelated to `FakeDriver`, the constraint
- * on this generic type `T` is that it must be a partial of `FakeDriver`'s interface. This enforces
- * that it does not conflict with the existing interface of `FakeDriver`.  In that way, you can
- * think of it as a type guard.
- * @param mixin Mixin implementation
- */
-export function mixin<T extends Partial<FakeDriver>>(mixin: T): void {
-  Object.assign(FakeDriver.prototype, mixin);
-}