redux-dynamic-middlewares/lib/index.test.js

Allow add or remove redux middlewares dynamically

'use strict';

var _redux = require('redux');

var _ = require('./');

var _2 = _interopRequireDefault(_);

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

var reducer = function reducer() {
  var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  var action = arguments[1];

  if (action.type === 'foo') return { foo: 'bar' };
  return state;
};

test('redux should work without error', function () {
  // eslint-disable-next-line no-console
  console.error = jest.fn();
  var store = (0, _redux.createStore)(reducer, (0, _redux.applyMiddleware)(_2.default));
  expect(store.getState()).toEqual({});
  store.dispatch({ type: 'foo' });
  // eslint-disable-next-line no-console
  expect(console.error).not.toBeCalled();
  expect(store.getState()).toEqual({ foo: 'bar' });
});

test('middleware should be called', function () {
  var store = (0, _redux.createStore)(reducer, (0, _redux.applyMiddleware)(_2.default));
  var middlewareWork = jest.fn();
  var middleware = function middleware() {
    return function (next) {
      return function (action) {
        middlewareWork(action);
        return next(action);
      };
    };
  };
  (0, _.addMiddleware)(middleware);

  store.dispatch({ type: 'foo' });
  expect(middlewareWork).toBeCalledWith({ type: 'foo' });
});

test('all middlewares by single add should be called', function () {
  var store = (0, _redux.createStore)(reducer, (0, _redux.applyMiddleware)(_2.default));
  var firstMiddlewareWork = jest.fn();
  var firstMiddleware = function firstMiddleware() {
    return function (next) {
      return function (action) {
        firstMiddlewareWork(action);
        return next(action);
      };
    };
  };
  var secondMiddlewareWork = jest.fn();
  var secondMiddleware = function secondMiddleware() {
    return function (next) {
      return function (action) {
        secondMiddlewareWork(action);
        return next(action);
      };
    };
  };
  (0, _.addMiddleware)(firstMiddleware, secondMiddleware);

  store.dispatch({ type: 'foo' });
  expect(firstMiddlewareWork).toBeCalledWith({ type: 'foo' });
  expect(secondMiddlewareWork).toBeCalledWith({ type: 'foo' });
});

test('all middlewares by separate add should be called', function () {
  var store = (0, _redux.createStore)(reducer, (0, _redux.applyMiddleware)(_2.default));
  var firstMiddlewareWork = jest.fn();
  var firstMiddleware = function firstMiddleware() {
    return function (next) {
      return function (action) {
        firstMiddlewareWork(action);
        return next(action);
      };
    };
  };
  var secondMiddlewareWork = jest.fn();
  var secondMiddleware = function secondMiddleware() {
    return function (next) {
      return function (action) {
        secondMiddlewareWork(action);
        return next(action);
      };
    };
  };
  (0, _.addMiddleware)(firstMiddleware);
  (0, _.addMiddleware)(secondMiddleware);

  store.dispatch({ type: 'foo' });
  expect(firstMiddlewareWork).toBeCalledWith({ type: 'foo' });
  expect(secondMiddlewareWork).toBeCalledWith({ type: 'foo' });
});

test('removed middlewares should not be called', function () {
  var store = (0, _redux.createStore)(reducer, (0, _redux.applyMiddleware)(_2.default));
  var firstMiddlewareWork = jest.fn();
  var firstMiddleware = function firstMiddleware() {
    return function (next) {
      return function (action) {
        firstMiddlewareWork(action);
        return next(action);
      };
    };
  };
  var secondMiddlewareWork = jest.fn();
  var secondMiddleware = function secondMiddleware() {
    return function (next) {
      return function (action) {
        secondMiddlewareWork(action);
        return next(action);
      };
    };
  };
  (0, _.addMiddleware)(firstMiddleware, secondMiddleware);
  (0, _.removeMiddleware)(secondMiddleware);

  store.dispatch({ type: 'foo' });
  expect(firstMiddlewareWork).toBeCalledWith({ type: 'foo' });
  expect(secondMiddlewareWork).not.toBeCalled();
});

test('reset middlewares should work', function () {
  var store = (0, _redux.createStore)(reducer, (0, _redux.applyMiddleware)(_2.default));
  var firstMiddlewareWork = jest.fn();
  var firstMiddleware = function firstMiddleware() {
    return function (next) {
      return function (action) {
        firstMiddlewareWork(action);
        return next(action);
      };
    };
  };
  var secondMiddlewareWork = jest.fn();
  var secondMiddleware = function secondMiddleware() {
    return function (next) {
      return function (action) {
        secondMiddlewareWork(action);
        return next(action);
      };
    };
  };
  (0, _.addMiddleware)(firstMiddleware, secondMiddleware);
  (0, _.resetMiddlewares)();

  store.dispatch({ type: 'foo' });
  expect(firstMiddlewareWork).not.toBeCalled();
  expect(secondMiddlewareWork).not.toBeCalled();
});

test('createDynamicMiddlewares should work', function () {
  var storeGlobal = (0, _redux.createStore)(reducer, (0, _redux.applyMiddleware)(_2.default));
  var globalMiddlewareWork = jest.fn();
  var globalMiddleware = function globalMiddleware() {
    return function (next) {
      return function (action) {
        globalMiddlewareWork(action);
        return next(action);
      };
    };
  };
  (0, _.addMiddleware)(globalMiddleware);

  var dynamicMiddlewaresFirst = (0, _.createDynamicMiddlewares)();
  var storeFirst = (0, _redux.createStore)(reducer, (0, _redux.applyMiddleware)(dynamicMiddlewaresFirst.enhancer));
  var firstMiddlewareWork = jest.fn();
  var firstMiddleware = function firstMiddleware() {
    return function (next) {
      return function (action) {
        firstMiddlewareWork(action);
        return next(action);
      };
    };
  };
  dynamicMiddlewaresFirst.addMiddleware(firstMiddleware);

  var dynamicMiddlewaresSecond = (0, _.createDynamicMiddlewares)();
  var storeSecond = (0, _redux.createStore)(reducer, (0, _redux.applyMiddleware)(dynamicMiddlewaresSecond.enhancer));
  var secondMiddlewareWork = jest.fn();
  var secondMiddleware = function secondMiddleware() {
    return function (next) {
      return function (action) {
        secondMiddlewareWork(action);
        return next(action);
      };
    };
  };
  dynamicMiddlewaresSecond.addMiddleware(secondMiddleware);

  storeGlobal.dispatch({ type: 'foo' });
  expect(globalMiddlewareWork).toBeCalledWith({ type: 'foo' });
  expect(firstMiddlewareWork).not.toBeCalled();
  expect(secondMiddlewareWork).not.toBeCalled();

  globalMiddlewareWork.mockClear();

  storeFirst.dispatch({ type: 'foo' });
  expect(globalMiddlewareWork).not.toBeCalled();
  expect(firstMiddlewareWork).toBeCalledWith({ type: 'foo' });
  expect(secondMiddlewareWork).not.toBeCalled();

  firstMiddlewareWork.mockClear();

  storeSecond.dispatch({ type: 'foo' });
  expect(globalMiddlewareWork).not.toBeCalled();
  expect(firstMiddlewareWork).not.toBeCalled();
  expect(secondMiddlewareWork).toBeCalledWith({ type: 'foo' });
});