How to use this.findElOrEls method in Appium Android Driver

1import _ from 'lodash';
2import { errors } from 'appium-base-driver';
3import { FakeElement } from '../fake-element';
4
5let commands = {}, helpers = {}, extensions = {};
6
7helpers.getExistingElementForNode = function getExistingElementForNode (node) {
8  for (let [id, el] of _.toPairs(this.elMap)) {
9    if (el.node === node) {
10      return id;
11    }
12  }
13  return null;
14};
15
16helpers.wrapNewEl = function wrapNewEl (obj) {
17  // first check and see if we already have a ref to this element
18  let existingElId = this.getExistingElementForNode(obj);
19  if (existingElId) {
20    return {ELEMENT: existingElId};
21  }
22
23  // otherwise add the element to the map
24  this.maxElId++;
25  this.elMap[this.maxElId.toString()] = new FakeElement(obj, this.appModel);
26  return {ELEMENT: this.maxElId.toString()};
27};
28
29helpers.findElOrEls = async function findElOrEls (strategy, selector, mult, ctx) {
30  let qMap = {
31    'xpath': 'xpathQuery',
32    'id': 'idQuery',
33    'accessibility id': 'idQuery',
34    'class name': 'classQuery',
35    'tag name': 'classQuery'
36  };
37  // TODO this error checking should probably be part of MJSONWP?
38  if (!_.includes(_.keys(qMap), strategy)) {
39    throw new errors.UnknownCommandError();
40  }
41  if (selector === 'badsel') {
42    throw new errors.InvalidSelectorError();
43  }
44  let els = this.appModel[qMap[strategy]](selector, ctx);
45  if (els.length) {
46    if (mult) {
47      let allEls = [];
48      for (let el of els) {
49        allEls.push(this.wrapNewEl(el));
50      }
51      return allEls;
52    } else {
53      return this.wrapNewEl(els[0]);
54    }
55  } else if (mult) {
56    return [];
57  } else {
58    throw new errors.NoSuchElementError();
59  }
60};
61
62commands.findElement = async function findElement (strategy, selector) {
63  return this.findElOrEls(strategy, selector, false);
64};
65
66commands.findElements = async function findElements (strategy, selector) {
67  return this.findElOrEls(strategy, selector, true);
68};
69
70commands.findElementFromElement = async function findElementFromElement (strategy, selector, elementId) {
71  let el = this.getElement(elementId);
72  return this.findElOrEls(strategy, selector, false, el.xmlFragment);
73};
74
75commands.findElementsFromElement = async function findElementsFromElement (strategy, selector, elementId) {
76  let el = this.getElement(elementId);
77  return this.findElOrEls(strategy, selector, true, el.xmlFragment);
78};
79
80Object.assign(extensions, commands, helpers);
81export { commands, helpers};
82export default extensions;
83

Source: find.js

import _ from 'lodash';
import { errors } from 'appium-base-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;
    }
  }
  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};
  }

  // otherwise add the element to the map
  this.maxElId++;
  this.elMap[this.maxElId.toString()] = new FakeElement(obj, this.appModel);
  return {ELEMENT: this.maxElId.toString()};
};

helpers.findElOrEls = async function findElOrEls (strategy, selector, mult, ctx) {
  let qMap = {
    'xpath': 'xpathQuery',
    'id': 'idQuery',
    'accessibility id': 'idQuery',
    'class name': 'classQuery',
    'tag name': 'classQuery'
  };
  // 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));
      }
      return allEls;
    } else {
      return this.wrapNewEl(els[0]);
    }
  } else if (mult) {
    return [];
  } else {
    throw new errors.NoSuchElementError();
  }
};

commands.findElement = async function findElement (strategy, selector) {
  return this.findElOrEls(strategy, selector, false);
};

commands.findElements = async function findElements (strategy, selector) {
  return this.findElOrEls(strategy, selector, true);
};

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);
};

Object.assign(extensions, commands, helpers);
export { commands, helpers};
export default extensions;

1
2import { errors } from 'appium-base-driver';
3import strategies from './strategies';
4import log from '../logger';
5
6let commands = {};
7let extensions = {};
8
9commands.getAttribute = async function getAttribute (elementId, attribute) {
10  const element = await this.findElOrEls(strategies.ELEMENT_ID, elementId);
11  return element.attributes[attribute];
12};
13
14commands.getName = async function getName (elementId) {
15  const element = await this.findElOrEls(strategies.ELEMENT_ID, elementId);
16  return element.tag;
17};
18
19commands.elementDisplayed = async function elementDisplayed (elementId) {
20  const element = await this.findElOrEls(strategies.ELEMENT_ID, elementId);
21  return element.isDisplayed;
22};
23
24commands.elementEnabled = async function elementEnabled (elementId) {
25  return await this.elementDisplayed(elementId);
26};
27
28commands.elementSelected = async function elementSelected (elementId) {
29  const element = await this.findElOrEls(strategies.ELEMENT_ID, elementId);
30  return element.isFocused;
31};
32
33commands.setValue = async function setValue (keys, elementId) {
34  const element = await this.findElOrEls(strategies.ELEMENT_ID, elementId);
35  await element.append(keys);
36};
37
38commands.replaceValue = async function replaceValue (keys, elementId) {
39  const element = await this.findElOrEls(strategies.ELEMENT_ID, elementId);
40  await element.type(keys);
41};
42
43commands.setValueImmediate = async function setValueImmediate (keys, elementId) {
44  await this.replaceValue(keys, elementId);
45};
46
47commands.getText = async function getText (elementId) {
48  const element = await this.findElOrEls(strategies.ELEMENT_ID, elementId);
49  return element.text;
50};
51
52commands.getSize = async function getSize (elementId) {
53  const element = await this.findElOrEls(strategies.ELEMENT_ID, elementId);
54
55  if (!element.bounds) {
56    return log.errorAndThrow(new errors.ElementNotVisibleError());
57  }
58  return { width: element.bounds.width, height: element.bounds.height };
59};
60
61commands.getLocation = async function getLocation (elementId) {
62  const node = await this.findElOrEls(strategies.ELEMENT_ID, elementId);
63  if (!node) {
64    return log.errorAndThrow(new errors.ElementNotVisibleError());
65  }
66  return { x: node.bounds.x, y: node.bounds.y };
67};
68
69commands.getElementRect = async function getElementRect (elementId) {
70  const element = await this.findElOrEls(strategies.ELEMENT_ID, elementId);
71
72  if (!element.bounds) {
73    return log.errorAndThrow(new errors.ElementNotVisibleError());
74  }
75  return element.bounds;
76};
77
78commands.click = async function click (elementId) {
79  const element = await this.findElOrEls(strategies.ELEMENT_ID, elementId);
80  await element.select(this.ecp);
81};
82
83commands.clear = async function clear (elementId) {
84  await this.replaceValue('', elementId);
85};
86
87commands.active = async function active () {
88  return await this.findElOrEls(strategies.CSS_SELECTOR, '[focused="true"]:not(:has([focused="true"]))');
89};
90
91Object.assign(extensions, commands);
92export {commands};
93export default extensions;
94

Source: element.js

import { errors } from 'appium-base-driver';
import strategies from './strategies';
import log from '../logger';

let commands = {};
let extensions = {};

commands.getAttribute = async function getAttribute (elementId, attribute) {
  const element = await this.findElOrEls(strategies.ELEMENT_ID, elementId);
  return element.attributes[attribute];
};

commands.getName = async function getName (elementId) {
  const element = await this.findElOrEls(strategies.ELEMENT_ID, elementId);
  return element.tag;
};

commands.elementDisplayed = async function elementDisplayed (elementId) {
  const element = await this.findElOrEls(strategies.ELEMENT_ID, elementId);
  return element.isDisplayed;
};

commands.elementEnabled = async function elementEnabled (elementId) {
  return await this.elementDisplayed(elementId);
};

commands.elementSelected = async function elementSelected (elementId) {
  const element = await this.findElOrEls(strategies.ELEMENT_ID, elementId);
  return element.isFocused;
};

commands.setValue = async function setValue (keys, elementId) {
  const element = await this.findElOrEls(strategies.ELEMENT_ID, elementId);
  await element.append(keys);
};

commands.replaceValue = async function replaceValue (keys, elementId) {
  const element = await this.findElOrEls(strategies.ELEMENT_ID, elementId);
  await element.type(keys);
};

commands.setValueImmediate = async function setValueImmediate (keys, elementId) {
  await this.replaceValue(keys, elementId);
};

commands.getText = async function getText (elementId) {
  const element = await this.findElOrEls(strategies.ELEMENT_ID, elementId);
  return element.text;
};

commands.getSize = async function getSize (elementId) {
  const element = await this.findElOrEls(strategies.ELEMENT_ID, elementId);

  if (!element.bounds) {
    return log.errorAndThrow(new errors.ElementNotVisibleError());
  }
  return { width: element.bounds.width, height: element.bounds.height };
};

commands.getLocation = async function getLocation (elementId) {
  const node = await this.findElOrEls(strategies.ELEMENT_ID, elementId);
  if (!node) {
    return log.errorAndThrow(new errors.ElementNotVisibleError());
  }
  return { x: node.bounds.x, y: node.bounds.y };
};

commands.getElementRect = async function getElementRect (elementId) {
  const element = await this.findElOrEls(strategies.ELEMENT_ID, elementId);

  if (!element.bounds) {
    return log.errorAndThrow(new errors.ElementNotVisibleError());
  }
  return element.bounds;
};

commands.click = async function click (elementId) {
  const element = await this.findElOrEls(strategies.ELEMENT_ID, elementId);
  await element.select(this.ecp);
};

commands.clear = async function clear (elementId) {
  await this.replaceValue('', elementId);
};

commands.active = async function active () {
  return await this.findElOrEls(strategies.CSS_SELECTOR, '[focused="true"]:not(:has([focused="true"]))');
};

Object.assign(extensions, commands);
export {commands};
export default extensions;