legit-tests/tests.js

a chainable testing library for React

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

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

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; return arr2; } else { return Array.from(arr); } }

var _reactAddonsTestUtils = require('react-addons-test-utils');

var _reactAddonsTestUtils2 = _interopRequireDefault(_reactAddonsTestUtils);

var _reactDomServer = require('react-dom/server');

var _reactDomServer2 = _interopRequireDefault(_reactDomServer);

var _reactDom = require('react-dom');

var _reactDom2 = _interopRequireDefault(_reactDom);

var _react = require('react');

var _react2 = _interopRequireDefault(_react);

var _middleware = require('./middleware');

global.React = _react2['default'];

function Test(component, config) {

  var instance = undefined;
  if (config && config.shallow === true) {
    var shallowRenderer = _reactAddonsTestUtils2['default'].createRenderer();
    shallowRenderer.render(component);
    instance = shallowRenderer.getRenderOutput();
  } else if (config && config.fullDOM && global.window) {
    var div = global.window.document.createElement('div');
    global.window.document.body.appendChild(div);
    instance = _reactDom2['default'].render(component, div);
  } else {
    instance = _reactAddonsTestUtils2['default'].renderIntoDocument(component);
  }

  var testComponent = {
    instance: instance,
    component: component,
    elements: {},
    element: function element(select, callback) {
      var _this = this;

      var element = undefined;
      if (typeof select === 'string') {
        element = this.elements[select];
        callback.call(this, element);
        return this;
      }

      if (Array.isArray(select)) {
        var args = select.map(function (elem) {
          return _this.elements[elem];
        });
        callback.call.apply(callback, [this].concat(_toConsumableArray(args)));
        return this;
      }

      if (Object.keys(this.elements).length === 1) {
        select.call(this, this.elements[Object.keys(this.elements)[0]]);
      } else {
        throw new Error("There are multiple elements select one");
      }
      return this;
    },
    use: function use(callback, data) {
      callback.call(this, data);
      return this;
    },
    mixin: function mixin(spec) {
      var _this2 = this;

      Object.keys(spec).forEach(function (key) {
        _this2[key] = function () {
          var _spec$key;

          for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
            args[_key] = arguments[_key];
          }

          (_spec$key = spec[key]).call.apply(_spec$key, [_this2].concat(args));
          return _this2;
        };
      });
      return this;
    },
    test: function test(callback) {
      var param = _extends({}, this, this.elements);
      callback.call(param, param);
      return this;
    },
    renderToString: function renderToString(callback) {
      var componentString = _reactDomServer2['default'].renderToStaticMarkup(component);
      callback.call(null, componentString);
      return this;
    }
  };

  return testComponent.mixin({
    find: _middleware.Find,
    setState: _middleware.SetState,
    simulate: _middleware.Simulate,
    clean: _middleware.Clean
  });
}

exports['default'] = Test;
module.exports = exports['default'];