@surglogs/with-connected-handler/lib/__tests__/index.js

HOC for easy event handler creation

"use strict";

var _react = _interopRequireDefault(require("react"));

var _redux = require("redux");

var _reactRedux = require("react-redux");

var _enzyme = require("enzyme");

var _enzymeAdapterReact = _interopRequireDefault(require("enzyme-adapter-react-16"));

var _index = _interopRequireDefault(require("../index"));

var _recompose = require("recompose");

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

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { keys.push.apply(keys, Object.getOwnPropertySymbols(object)); } if (enumerableOnly) keys = keys.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

(0, _enzyme.configure)({
  adapter: new _enzymeAdapterReact["default"]()
});
describe('withConnectedHandler HOC', function () {
  it('creates connected handler correctly', function () {
    var initialState = {
      s1: 1,
      s2: 2
    };
    var store = (0, _redux.createStore)(function () {
      var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
      var action = arguments.length > 1 ? arguments[1] : undefined;
      return state;
    });
    var CONNECTED_HANDLER = 'CONNECTED_HANDLER';
    var MOCK_ACTION = 'MOCK_ACTION';
    var mockAction = jest.fn(function (s1, p1, p2) {
      return {
        type: MOCK_ACTION,
        payload: {
          s1: s1,
          p1: p1,
          p2: p2
        }
      };
    });
    var component = jest.fn(function () {
      return null;
    });
    var handlerTracker = jest.fn();

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

        handlerTracker({
          props: props,
          args: args
        });
        props.mockAction(props.s1, props.p1, props.p2);
      };
    };

    var Component = (0, _recompose.compose)((0, _recompose.withState)('localState', 'setLocalState', {
      p1: 3,
      p2: 4
    }), (0, _recompose.withProps)(function (_ref) {
      var localState = _ref.localState;
      return _objectSpread({}, localState);
    }), (0, _index["default"])({
      actions: {
        mockAction: mockAction
      },
      name: CONNECTED_HANDLER,
      handler: handler,
      args: {
        s1: function s1(state) {
          return state.s1;
        },
        p1: 'p1',
        p2: function p2(_, props) {
          return props.p2;
        }
      }
    }))(component);
    (0, _enzyme.mount)(_react["default"].createElement(_reactRedux.Provider, {
      store: store
    }, _react["default"].createElement(Component, null)));
    expect(handlerTracker).toHaveBeenCalledTimes(0);
    var _component$mock$calls = component.mock.calls[0][0],
        connectedHandler = _component$mock$calls[CONNECTED_HANDLER],
        setLocalState = _component$mock$calls.setLocalState,
        dispatch = _component$mock$calls.dispatch,
        connectedMockAction = _component$mock$calls.mockAction;
    connectedHandler('a', 'b', 'c');
    expect(handlerTracker).toHaveBeenCalledTimes(1);
    expect(handlerTracker).toHaveBeenLastCalledWith({
      args: ['a', 'b', 'c'],
      props: {
        dispatch: dispatch,
        mockAction: connectedMockAction,
        p1: 3,
        p2: 4,
        s1: 1
      }
    });
    expect(mockAction).toHaveBeenCalledTimes(1);
    expect(mockAction).toHaveLastReturnedWith({
      payload: {
        p1: 3,
        p2: 4,
        s1: 1
      },
      type: 'MOCK_ACTION'
    });
    setLocalState({
      p1: 6,
      p2: 7
    });
    expect(handlerTracker).toHaveBeenCalledTimes(1);
    expect(mockAction).toHaveBeenCalledTimes(1);
    connectedHandler('d', 'e', 'f');
    expect(handlerTracker).toHaveBeenCalledTimes(2);
    expect(handlerTracker).toHaveBeenLastCalledWith({
      args: ['d', 'e', 'f'],
      props: {
        dispatch: dispatch,
        mockAction: connectedMockAction,
        p1: 6,
        p2: 7,
        s1: 1
      }
    });
  });
});