react-hold/es/__tests__/createRefiter-test.js

Hold the empty presentational components in react.js

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

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

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

import React from 'react';
import createRefiter from '../createRefiter';

describe('Component refiter', function () {
  it('refit dom component', function () {
    var component = 'div';
    var refiter = createRefiter(component);

    expect(_typeof(refiter.refit)).toBe('function');
    expect(_typeof(refiter.undo)).toBe('function');

    refiter.refit();
    expect(component).toBe(component);

    refiter.undo();
    expect(component).toBe(component);
  });

  it('refit functional component', function () {
    var component = function component() {
      return React.createElement(
        'div',
        null,
        'foo'
      );
    };
    var refiter = createRefiter(component);

    expect(_typeof(refiter.refit)).toBe('function');
    expect(_typeof(refiter.undo)).toBe('function');

    refiter.refit();
    expect(component.prototype.componentDidMount).toBeUndefined();
    expect(component.prototype.componentWillUnmount).toBeUndefined();

    refiter.undo();
    expect(component.prototype.componentDidMount).toBeUndefined();
    expect(component.prototype.componentWillUnmount).toBeUndefined();
  });

  it('refit react component', function () {
    var FooComponent = createFooComponent();
    var refiter = createRefiter(FooComponent);

    expect(_typeof(refiter.refit)).toBe('function');
    expect(_typeof(refiter.undo)).toBe('function');

    var prototype = FooComponent.prototype;
    var componentDidMount = prototype.componentDidMount;
    var componentWillUnmount = prototype.componentWillUnmount;

    refiter.refit();
    refiter.refit();
    expect(prototype.componentDidMount).toBeNull();
    expect(componentWillUnmount).not.toBe(prototype.componentWillUnmount);

    refiter.undo();
    refiter.undo();
    expect(prototype.componentDidMount).toBe(componentDidMount);
    expect(prototype.componentWillUnmount).toBe(componentWillUnmount);
  });
});

function createFooComponent() {
  return function (_React$Component) {
    _inherits(FooComponent, _React$Component);

    function FooComponent() {
      var _ref;

      _classCallCheck(this, FooComponent);

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

      var _this = _possibleConstructorReturn(this, (_ref = FooComponent.__proto__ || Object.getPrototypeOf(FooComponent)).call.apply(_ref, [this].concat(args)));

      _this.state = {
        foo: 'foo'
      };
      return _this;
    }

    _createClass(FooComponent, [{
      key: 'componentDidMount',
      value: function componentDidMount() {}
    }, {
      key: 'componentWillUnmount',
      value: function componentWillUnmount() {}
    }, {
      key: 'render',
      value: function render() {
        return React.createElement(
          'p',
          null,
          this.state.foo
        );
      }
    }]);

    return FooComponent;
  }(React.Component);
}