hon2a · March 2, 2018 15:14
diff --git a/.testingWithNightwatch.md b/.testingWithNightwatch.md
diff --git a/getPageObjects.js b/getPageObjects.js
 import _ from 'lodash';

 import * as baseCommands from '../commands';
 import { useSelectorsInContext } from './useSelectorsInContext.js';
 import { addCommandsToPageObject } from './addCommandsToPageObject.js';

 export function createPageObjectGetters({ commands = baseCommands, recursive = true } = {}) {
  const defaultEnhancer = _.flow(
    _.partial(addCommandsToPageObject, _, commands, recursive),
    _.partial(useSelectorsInContext, _, recursive)
  );

  const getters = {
    /**
     * Retrieves a requested page object or section and enhances it.
     * Default enhancer adds custom commands and h4cks the object/section to use naked
     * selectors in context of the object/section.
     */
    getPageObject(api, path, enhance = defaultEnhancer) {
      const [ pageObjectName, ...pathArray ] = _.toPath(path);
      const pageObjectFactory = api.page[pageObjectName];

      if (!_.isFunction(pageObjectFactory)) {
        throw new Error(`Can't find a page object named "${pageObjectName}"!`);
      }
      const pageObject = api.page[pageObjectName]();

      if (!pageObject) {
        throw new Error(`Page object "${pageObjectName}" doesn't exist.`);
      }

      const wantedObjectOrSection = (pathArray.length > 0)
        ? _.get(pageObject, `section.${pathArray.join('.section.')}`)
        : pageObject;

      if (!wantedObjectOrSection) {
        throw new Error(`Page object section at "${path}" doesn't exist!`);
      }

      // page objects don't have names by default; add them to help with debugging
      pageObject.name = pageObject.name || pageObjectName;

      return enhance(wantedObjectOrSection);
    },
    /**
     * Retrieves page objects or sections and returns them in a plain object with last
     * part of their paths used as keys.
     */
    getPageObjects(api, paths, enhance = defaultEnhancer) {
      return paths.reduce(
        (acc, path) => {
          return {
            ...acc,
            [_.last(_.toPath(path))]: getters.getPageObject(api, path, enhance)
          };
        },
        {}
      );
    }
  };

  return getters;
 }
diff --git a/useSelectorsInContext.js b/useSelectorsInContext.js
 import _ from 'lodash';

 import { registerElement } from './registerElement.js';
 import { isXpathSelector } from '../isXpathSelector.js';

 const NIGHTWATCH_COMMANDS = [
  'clearValue',
  'click',
  'getAttribute',
  'getCssProperty',
  'getElementSize',
  'getLocation',
  'getLocationInView',
  'getTagName',
  'getText',
  'getValue',
  'isVisible',
  'moveToElement',
  'setValue',
  'submitForm',
  'waitForElementNotPresent',
  'waitForElementNotVisible',
  'waitForElementPresent',
  'waitForElementVisible',

  'expect.element'
 ];

 function getLocateStrategy(selector) {
  return isXpathSelector(selector) ? 'xpath' : 'css selector';
 }

 const appliedFlag = '__useSelectorsInContextApplied__';

 function useSelectorInContext(method, pageObject) {
  return function(selector, ...args) {
    if (_.startsWith(selector, '@')) {
      return method.call(this, selector, ...args);
    }

    const alias = `__${selector}`;
    registerElement(pageObject, selector, getLocateStrategy(selector), alias);
    return method.call(this, `@${alias}`, ...args);
  };
 }

 /**
 * Enhances all page object's methods to apply selectors the same way the pre-defined `elements`
 * are used - in context of that page object (and not globally).
 */
 export function useSelectorsInContext(pageObject, recursive = false) {
  if (!pageObject.elements && !pageObject.section) {
    throw new Error('`useSelectorsInContext` can only be used on a page object!');
  }

  if (pageObject[appliedFlag]) {
    return pageObject;
  }

  NIGHTWATCH_COMMANDS.forEach(
    path => _.set(pageObject, path, useSelectorInContext(_.get(pageObject, path), pageObject))
  );
  pageObject[appliedFlag] = true;

  if (recursive) {
    _.forEach(pageObject.section, section => useSelectorsInContext(section, recursive));
  }

  return pageObject;
 }
diff --git a/usingXpath.js b/usingXpath.js
 export function usingXpath(...functions) {
  functions.forEach(fn => {
    this.api.useXpath();
    fn();
    this.api.useCss();
  });
  return this;
 }
diff --git a/waitForAndClick.js b/waitForAndClick.js
 export function waitForAndClick(selector) {
  this.waitForElementVisible(selector)
    .expect.element(selector).to.be.enabled;
  return this.click(selector);
 }
diff --git a/webDriverElementCommands.js b/webDriverElementCommands.js
 import _ from 'lodash';

 import { breakUpCommandArgs, handleCommandResult } from '../elementCommandUtils.js';

 const completeCommandName = shortName => `elementId${_.upperFirst(shortName)}`;

 function getElementIdRecursive(api, sections, callback, contextElementId = void 0, path = []) {
  if (!sections.length) {
    // recursion tail (empty sections means we've retrieved the leaf element ID)
    callback(contextElementId);
    return;
  }

  const { name, selector, locateStrategy } = sections[0];
  const currentPath = [ ...path, name ];
  const handleResult = ({ status, value }) => {
    if (status !== 0) {
      throw new Error(`Can't find element "${selector}" in "${currentPath.join(' > ')}"!`);
    }
    getElementIdRecursive(api, sections.slice(1), callback, value.ELEMENT, currentPath);
  };

  if (contextElementId) {
    // continue recursion (already got context, but there are still more sections in the path)
    api.elementIdElement(contextElementId, locateStrategy, selector, handleResult);
  } else {
    // recursion head (no ID means call from outside)
    api.element(locateStrategy, selector, handleResult);
  }
 }

 function useWebDriverElementCommand(commandName, ...args) {
  const fullCommandName = completeCommandName(commandName);
  if (!this.api[fullCommandName]) {
    throw new Error(`Web driver protocol command "${fullCommandName}" doesn't exist!`);
  }

  const sections = [];
  let section = this;
  // collect all page object sections in the path (not the root page object, those don't have selectors)
  while (section.parent) {
    sections.unshift(section);
    section = section.parent;
  }

  if (!sections.length) {
    // context is a root page object (not a section) -> call the non-contextual version of the command directly
    this.api[commandName](...args);
  } else {
    // context is a page object section -> find the section container and call the command on it
    getElementIdRecursive(this.api, sections, id => this.api[fullCommandName](id, ...args));
  }

  return this;
 }

 export function elementId(...args) {
  return useWebDriverElementCommand.call(this, 'element', ...args);
 }

 export function elementIds(...args) {
  return useWebDriverElementCommand.call(this, 'elements', ...args);
 }

 const commandNames = [
  'attribute',
  'cssProperty',
  'displayed',
  'enabled',
  'name',
  'selected',
  'size',
  'text',
  'value',
  'location',
  'locationInView'
 ].map(completeCommandName);

 const [
  elementAttribute,
  elementCssProperty,
  elementDisplayed,
  elementEnabled,
  elementName,
  elementSelected,
  elementSize,
  elementText,
  elementValue,
  elementLocation,
  elementLocationInView
 ] = commandNames.map(commandName =>
  function(...args) {
    const [ locateStrategy, selector, middleArgs, callback ] = breakUpCommandArgs(this, args);
    const handleResult = handleCommandResult(selector);
    return elementId.call(
      this,
      locateStrategy,
      selector,
      handleResult(({ ELEMENT }) => this.api[commandName](ELEMENT, ...middleArgs, ({ value }) => callback(value)))
    );
  }
 );

 const [
  elementsAttribute,
  elementsCssProperty,
  elementsDisplayed,
  elementsEnabled,
  elementsName,
  elementsSelected,
  elementsSize,
  elementsText,
  elementsValue,
  elementsLocation,
  elementsLocationInView
 ] = commandNames.map(commandName =>
  function(...args) {
    const [ locateStrategy, selector, middleArgs, callback ] = breakUpCommandArgs(this, args);
    const handleResult = handleCommandResult(selector);
    return elementIds.call(
      this,
      locateStrategy,
      selector,
      handleResult(elementDefs => this.api.perform(done => {
        const unresolved = _.range(elementDefs.length);
        const values = [];

        const endIfDone = () => {
          if (!unresolved.length) {
            callback(values);
            done();
          }
        };
        endIfDone();

        const handleValue = (value, idx) => {
          values[idx] = value;
          unresolved.splice(unresolved.indexOf(idx), 1);
          endIfDone();
        };
        elementDefs.forEach(
          ({ ELEMENT }, idx) => this.api[commandName](ELEMENT, ...middleArgs, ({ value }) => handleValue(value, idx))
        );
      }))
    );
  }
 );

 export {
  elementAttribute,
  elementsAttribute,
  elementCssProperty,
  elementsCssProperty,
  elementDisplayed,
  elementsDisplayed,
  elementEnabled,
  elementsEnabled,
  elementName,
  elementsName,
  elementSelected,
  elementsSelected,
  elementSize,
  elementsSize,
  elementText,
  elementsText,
  elementValue,
  elementsValue,
  elementLocation,
  elementsLocation,
  elementLocationInView,
  elementsLocationInView
 };
	import _ from 'lodash';

	import * as baseCommands from '../commands';
	import { useSelectorsInContext } from './useSelectorsInContext.js';
	import { addCommandsToPageObject } from './addCommandsToPageObject.js';

	export function createPageObjectGetters({ commands = baseCommands, recursive = true } = {}) {
	const defaultEnhancer = _.flow(
	_.partial(addCommandsToPageObject, _, commands, recursive),
	_.partial(useSelectorsInContext, _, recursive)
	);

	const getters = {
	/**
	* Retrieves a requested page object or section and enhances it.
	* Default enhancer adds custom commands and h4cks the object/section to use naked
	* selectors in context of the object/section.
	*/
	getPageObject(api, path, enhance = defaultEnhancer) {
	const [ pageObjectName, ...pathArray ] = _.toPath(path);
	const pageObjectFactory = api.page[pageObjectName];

	if (!_.isFunction(pageObjectFactory)) {
	throw new Error(`Can't find a page object named "${pageObjectName}"!`);
	}
	const pageObject = api.page[pageObjectName]();

	if (!pageObject) {
	throw new Error(`Page object "${pageObjectName}" doesn't exist.`);
	}

	const wantedObjectOrSection = (pathArray.length > 0)
	? _.get(pageObject, `section.${pathArray.join('.section.')}`)
	: pageObject;

	if (!wantedObjectOrSection) {
	throw new Error(`Page object section at "${path}" doesn't exist!`);
	}

	// page objects don't have names by default; add them to help with debugging
	pageObject.name = pageObject.name \|\| pageObjectName;

	return enhance(wantedObjectOrSection);
	},
	/**
	* Retrieves page objects or sections and returns them in a plain object with last
	* part of their paths used as keys.
	*/
	getPageObjects(api, paths, enhance = defaultEnhancer) {
	return paths.reduce(
	(acc, path) => {
	return {
	...acc,
	[_.last(_.toPath(path))]: getters.getPageObject(api, path, enhance)
	};
	},
	{}
	);
	}
	};

	return getters;
	}
	import _ from 'lodash';

	import { registerElement } from './registerElement.js';
	import { isXpathSelector } from '../isXpathSelector.js';

	const NIGHTWATCH_COMMANDS = [
	'clearValue',
	'click',
	'getAttribute',
	'getCssProperty',
	'getElementSize',
	'getLocation',
	'getLocationInView',
	'getTagName',
	'getText',
	'getValue',
	'isVisible',
	'moveToElement',
	'setValue',
	'submitForm',
	'waitForElementNotPresent',
	'waitForElementNotVisible',
	'waitForElementPresent',
	'waitForElementVisible',

	'expect.element'
	];

	function getLocateStrategy(selector) {
	return isXpathSelector(selector) ? 'xpath' : 'css selector';
	}

	const appliedFlag = '__useSelectorsInContextApplied__';

	function useSelectorInContext(method, pageObject) {
	return function(selector, ...args) {
	if (_.startsWith(selector, '@')) {
	return method.call(this, selector, ...args);
	}

	const alias = `__${selector}`;
	registerElement(pageObject, selector, getLocateStrategy(selector), alias);
	return method.call(this, `@${alias}`, ...args);
	};
	}

	/**
	* Enhances all page object's methods to apply selectors the same way the pre-defined `elements`
	* are used - in context of that page object (and not globally).
	*/
	export function useSelectorsInContext(pageObject, recursive = false) {
	if (!pageObject.elements && !pageObject.section) {
	throw new Error('`useSelectorsInContext` can only be used on a page object!');
	}

	if (pageObject[appliedFlag]) {
	return pageObject;
	}

	NIGHTWATCH_COMMANDS.forEach(
	path => _.set(pageObject, path, useSelectorInContext(_.get(pageObject, path), pageObject))
	);
	pageObject[appliedFlag] = true;

	if (recursive) {
	_.forEach(pageObject.section, section => useSelectorsInContext(section, recursive));
	}

	return pageObject;
	}
	export function usingXpath(...functions) {
	functions.forEach(fn => {
	this.api.useXpath();
	fn();
	this.api.useCss();
	});
	return this;
	}
	export function waitForAndClick(selector) {
	this.waitForElementVisible(selector)
	.expect.element(selector).to.be.enabled;
	return this.click(selector);
	}
	import _ from 'lodash';

	import { breakUpCommandArgs, handleCommandResult } from '../elementCommandUtils.js';

	const completeCommandName = shortName => `elementId${_.upperFirst(shortName)}`;

	function getElementIdRecursive(api, sections, callback, contextElementId = void 0, path = []) {
	if (!sections.length) {
	// recursion tail (empty sections means we've retrieved the leaf element ID)
	callback(contextElementId);
	return;
	}

	const { name, selector, locateStrategy } = sections[0];
	const currentPath = [ ...path, name ];
	const handleResult = ({ status, value }) => {
	if (status !== 0) {
	throw new Error(`Can't find element "${selector}" in "${currentPath.join(' > ')}"!`);
	}
	getElementIdRecursive(api, sections.slice(1), callback, value.ELEMENT, currentPath);
	};

	if (contextElementId) {
	// continue recursion (already got context, but there are still more sections in the path)
	api.elementIdElement(contextElementId, locateStrategy, selector, handleResult);
	} else {
	// recursion head (no ID means call from outside)
	api.element(locateStrategy, selector, handleResult);
	}
	}

	function useWebDriverElementCommand(commandName, ...args) {
	const fullCommandName = completeCommandName(commandName);
	if (!this.api[fullCommandName]) {
	throw new Error(`Web driver protocol command "${fullCommandName}" doesn't exist!`);
	}

	const sections = [];
	let section = this;
	// collect all page object sections in the path (not the root page object, those don't have selectors)
	while (section.parent) {
	sections.unshift(section);
	section = section.parent;
	}

	if (!sections.length) {
	// context is a root page object (not a section) -> call the non-contextual version of the command directly
	this.api[commandName](...args);
	} else {
	// context is a page object section -> find the section container and call the command on it
	getElementIdRecursive(this.api, sections, id => this.api[fullCommandName](id, ...args));
	}

	return this;
	}

	export function elementId(...args) {
	return useWebDriverElementCommand.call(this, 'element', ...args);
	}

	export function elementIds(...args) {
	return useWebDriverElementCommand.call(this, 'elements', ...args);
	}

	const commandNames = [
	'attribute',
	'cssProperty',
	'displayed',
	'enabled',
	'name',
	'selected',
	'size',
	'text',
	'value',
	'location',
	'locationInView'
	].map(completeCommandName);

	const [
	elementAttribute,
	elementCssProperty,
	elementDisplayed,
	elementEnabled,
	elementName,
	elementSelected,
	elementSize,
	elementText,
	elementValue,
	elementLocation,
	elementLocationInView
	] = commandNames.map(commandName =>
	function(...args) {
	const [ locateStrategy, selector, middleArgs, callback ] = breakUpCommandArgs(this, args);
	const handleResult = handleCommandResult(selector);
	return elementId.call(
	this,
	locateStrategy,
	selector,
	handleResult(({ ELEMENT }) => this.api[commandName](ELEMENT, ...middleArgs, ({ value }) => callback(value)))
	);
	}
	);

	const [
	elementsAttribute,
	elementsCssProperty,
	elementsDisplayed,
	elementsEnabled,
	elementsName,
	elementsSelected,
	elementsSize,
	elementsText,
	elementsValue,
	elementsLocation,
	elementsLocationInView
	] = commandNames.map(commandName =>
	function(...args) {
	const [ locateStrategy, selector, middleArgs, callback ] = breakUpCommandArgs(this, args);
	const handleResult = handleCommandResult(selector);
	return elementIds.call(
	this,
	locateStrategy,
	selector,
	handleResult(elementDefs => this.api.perform(done => {
	const unresolved = _.range(elementDefs.length);
	const values = [];

	const endIfDone = () => {
	if (!unresolved.length) {
	callback(values);
	done();
	}
	};
	endIfDone();

	const handleValue = (value, idx) => {
	values[idx] = value;
	unresolved.splice(unresolved.indexOf(idx), 1);
	endIfDone();
	};
	elementDefs.forEach(
	({ ELEMENT }, idx) => this.api[commandName](ELEMENT, ...middleArgs, ({ value }) => handleValue(value, idx))
	);
	}))
	);
	}
	);

	export {
	elementAttribute,
	elementsAttribute,
	elementCssProperty,
	elementsCssProperty,
	elementDisplayed,
	elementsDisplayed,
	elementEnabled,
	elementsEnabled,
	elementName,
	elementsName,
	elementSelected,
	elementsSelected,
	elementSize,
	elementsSize,
	elementText,
	elementsText,
	elementValue,
	elementsValue,
	elementLocation,
	elementsLocation,
	elementLocationInView,
	elementsLocationInView
	};