@openveo/test/lib/e2e/fields/Field.js

Test API for OpenVeo unit tests

'use strict';

/**
 * @module e2e/fields/Field
 */

/**
 * Defines a form field to help writing end to end tests.
 *
 * Help manipulate form fields in a Page.
 * Use [Field.get]{@link module:e2e/fields/Field~Field.get} method to get a Field instance.
 *
 * @class Field
 * @constructor
 * @param {Object} conf A field configuration object
 */
function Field(conf) {
  Object.defineProperties(this,

    /** @lends module:e2e/fields/Field~Field */
    {

      /**
       * Field label.
       *
       * @type {String}
       * @instance
       * @readonly
       */
      name: {value: conf.name},

      /**
       * Element from where to look for the field (typically the form element).
       *
       * @type {Object}
       * @instance
       * @readonly
       */
      baseElement: {value: conf.baseElement}

    }

  );

  if (!this.name)
    throw new Error('Missing field name');
}

module.exports = Field;

/**
 * Gets an instance of a Field.
 *
 * @example
 * var Field = require('@openveo/test').e2e.fields.Field;
 *
 * var myTextField = Field.get({
 *   type: 'text',
 *   name: 'My field',
 *   baseElement: element(by.css('form'))
 * });
 *
 * @method get
 * @static
 * @memberof module:e2e/fields/Field~Field
 * @param {Object} conf A field configuration object
 * @return {Field} An instance of a Field sub object
 */
Field.get = function(conf) {
  switch (conf.type) {
    case 'text':
      var TextField = process.requireTest('lib/e2e/fields/TextField.js');
      return new TextField(conf);

    case 'textarea':
      var TextareaField = process.requireTest('lib/e2e/fields/TextareaField.js');
      return new TextareaField(conf);

    case 'tinymce':
      var TinymceField = process.requireTest('lib/e2e/fields/TinyMCEField.js');
      return new TinymceField(conf);

    case 'select':
      var SelectField = process.requireTest('lib/e2e/fields/SelectField.js');
      return new SelectField(conf);

    case 'date':
      var DateField = process.requireTest('lib/e2e/fields/DateField.js');
      return new DateField(conf);

    case 'dateTime':
      var DateTimeField = process.requireTest('lib/e2e/fields/DateTimeField.js');
      return new DateTimeField(conf);

    case 'checkbox':
      var CheckboxField = process.requireTest('lib/e2e/fields/CheckboxField.js');
      return new CheckboxField(conf);

    case 'checkboxes':
      var CheckboxesField = process.requireTest('lib/e2e/fields/CheckboxesField.js');
      return new CheckboxesField(conf);

    case 'time':
      var TimeField = process.requireTest('lib/e2e/fields/TimeField.js');
      return new TimeField(conf);

    case 'tags':
      var TagsField = process.requireTest('lib/e2e/fields/TagsField.js');
      return new TagsField(conf);

    case 'fake':
      var FakeField = process.requireTest('lib/e2e/fields/FakeField.js');
      return new FakeField(conf);

    case 'match':
      var MatchField = process.requireTest('lib/e2e/fields/MatchField.js');
      return new MatchField(conf);

    case 'autoComplete':
      var AutoCompleteField = process.requireTest('lib/e2e/fields/AutoCompleteField.js');
      return new AutoCompleteField(conf);

    default:
      throw new Error('Unknown field type');
  }
};

/**
 * Sets an input value.
 *
 * @method setInputValue
 * @static
 * @memberof module:e2e/fields/Field~Field
 * @param {Object} inputElement Input element finder
 * @param {String} value The input value
 * @return {Promise} Promise resolving when value has been set
 */
Field.setInputValue = function(inputElement, value) {
  return browser.executeScript(
    'arguments[0].focus(); ' +
    'var fieldElement = angular.element(arguments[0]); ' +
    'fieldElement.val(arguments[1]); ' +
    'fieldElement.triggerHandler("input");' +
    'arguments[0].blur();',
    inputElement.getWebElement(),
    value
  );
};

/**
 * Gets field description.
 *
 * @example
 * myField.getDescription().then(function(description) {
 *   console.log('Field description is : ' + description);
 * });
 *
 * @return {Promise} Promise resolving with the description
 */
Field.prototype.getDescription = function() {
  return this.getElement().then(function(elementFinder) {
    var description = elementFinder.element(by.css('p'));
    return description.getText();
  });
};

/**
 * Gets field label.
 *
 * @example
 * myField.getLabel().then(function(label) {
 *   console.log('Field label is : ' + label);
 * });
 *
 * @return {Promise} Promise resolving with the label
 */
Field.prototype.getLabel = function() {
  return this.getElement().then(function(elementFinder) {
    var label = elementFinder.element(by.xpath('./label'));
    return label.getText();
  }).then(function(text) {
    return protractor.promise.fulfilled(text.replace(/ ?[*:]?$/, ''));
  });
};

/**
 * Gets field element wrapper.
 *
 * Look for a form element label and return its parent.
 *
 * @return {Promise} Promise resolving with the element
 */
Field.prototype.getElement = function() {
  var self = this;
  var fieldElement;
  var deferred = protractor.promise.defer();

  // Get all labels
  this.baseElement.all(by.css('label')).each(function(label, index) {

    // Get label text
    label.getText().then(function(text) {

      // Label text corresponds to the searched text
      // Return parent element
      if (text.replace(/ ?[*:]?$/, '') === self.name)
        fieldElement = label.element(by.xpath('..'));

    });
  }).then(function() {
    if (fieldElement)
      deferred.fulfill(fieldElement);
    else
      deferred.reject(new Error('"' + self.name + '" field not found'));
  }, function(error) {
    deferred.reject(new Error('"' + self.name + '" field not found (' + error.message + ')'));
  });

  return deferred.promise;
};

/**
 * Gets field error message.
 *
 * @example
 * myField.getErrorMessage().then(function(errorMessage) {
 *   console.log('Error message : ' + errorMessage);
 * });
 *
 * @return {Promise} Promise resolving with the error message
 */
Field.prototype.getErrorMessage = function() {
  return this.getElement().then(function(elementFinder) {
    var errorElement = elementFinder.element(by.binding('$error'));
    return errorElement.getText();
  }).then(function(errorMessage) {
    return protractor.promise.fulfilled(errorMessage);
  });
};

/**
 * Gets field text representation in case of an inline editable field.
 *
 * @example
 * myField.getText().then(function(text) {
 *   console.log(text);
 * });
 *
 * @return {Promise} Promise resolving with field text representation
 */
Field.prototype.getText = function() {
  return this.getElement().then(function(elementFinder) {
    var textElement = elementFinder.all(by.css('div > div')).first();
    return textElement.getText();
  }).then(function(text) {
    return protractor.promise.fulfilled(text);
  });
};

/**
 * Gets field value.
 *
 * @example
 * myField.getValue().then(function(value) {
 *   console.log(value);
 * });
 *
 * @return {Promise} Promise resolving with field value
 */
Field.prototype.getValue = function() {
  throw new Error('Method getValue not implemented for this Field');
};

/**
 * Sets field value.
 *
 * @example
 * myField.setValue('new value').then(function() {
 *   console.log('Value set');
 * });
 *
 * @param {(String|Object|Number|Boolean)} [value] Field's value depending on its type
 * @return {Promise} Promise resolving when the value is set
 */
Field.prototype.setValue = function(value) {
  throw new Error('Method setValue not implemented for this Field');
};

/**
 * Clears field value.
 *
 * @example
 * myField.clear().then(function() {
 *   console.log('Field cleared');
 * });
 *
 * @return {Promise} Promise resolving when the field is cleared
 */
Field.prototype.clear = function() {
  throw new Error('Method clear not implemented for this Field');
};

/**
 * Tests if a field is considered as on error.
 *
 * @example
 * myField.isOnError().then(function(isOnError) {
 *   console.log('Is field on error ? ' + isOnError);
 * });
 *
 * @return {Promise} Promise resolving with a boolean indicating if the field is on error
 */
Field.prototype.isOnError = function() {
  throw new Error('Method isOnError not implemented for this Field');
};