enzyme-page-object/dist/components/Page.js

A library to help write enzyme tests using the page-object pattern

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _propTypes = require('prop-types');

var _propTypes2 = _interopRequireDefault(_propTypes);

var _enzyme = require('enzyme');

var _FoundElement = require('./FoundElement');

var _FoundElement2 = _interopRequireDefault(_FoundElement);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var propTypes = {
  type: _propTypes2.default.oneOf(['shallow', 'mount']).isRequired,
  component: _propTypes2.default.element.isRequired,
  options: _propTypes2.default.shape({
    dive: _propTypes2.default.number
  })
};

var objectIsEmpty = function objectIsEmpty(object) {
  return Object.keys(object).length === 0 && object.constructor === Object;
};

var Page = function () {
  function Page(type, component) {
    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};

    _classCallCheck(this, Page);

    this.validate(type, component, options);

    var dive = options.dive,
        enzymeContext = options.context;


    this.type = type;
    this.originalComponent = component;
    this.dive = dive;
    this.options = {
      context: enzymeContext
    };

    this.setup();
  }

  _createClass(Page, [{
    key: 'validate',
    value: function validate(type, component, options) {
      if (typeof type === 'undefined' || type === null || typeof type === 'string' && type.trim() === '') {
        throw TypeError('Can not setup without valid type of either `shallow` or `mount`. `' + this.type + '` given.');
      }

      if ((typeof component === 'undefined' ? 'undefined' : _typeof(component)) !== 'object' || objectIsEmpty(component)) {
        throw TypeError('Can not setup without a React component.');
      }

      if (!objectIsEmpty(options)) {
        if (options.hasOwnProperty('dive') && isNaN(options.dive)) {
          throw TypeError('The option `dive` must be a number. `' + options.dive + '` given.');
        }
      }

      _propTypes2.default.checkPropTypes(Page.propTypes, { type: type, component: component, options: options }, 'prop', 'Page');
    }
  }, {
    key: 'setup',
    value: function setup() {
      switch (this.type) {
        case 'shallow':
          this.component = (0, _enzyme.shallow)(this.originalComponent, _extends({}, this.options));
          break;
        case 'mount':
          this.component = (0, _enzyme.mount)(this.originalComponent, _extends({}, this.options));
          break;
        default:
          throw TypeError('Can not setup without valid type of either `shallow` or `mount`. `' + this.type + '` given.');
      }

      if (this.dive !== null && this.dive > 0) {
        for (var i = 0; i < this.dive; i++) {
          this.component = this.component.dive();
        }
      }

      return this;
    }
  }, {
    key: 'find',
    value: function find(selector) {
      var element = this.component.find(selector);
      var foundElement = new _FoundElement2.default(element);

      return foundElement;
    }
  }, {
    key: 'getElement',
    value: function getElement() {
      return this.component.getElement();
    }
  }, {
    key: 'element',
    get: function get() {
      return new _FoundElement2.default(this.component);
    }
  }]);

  return Page;
}();

Page.propTypes = propTypes;

exports.default = Page;