redux-logic-test/build-es/createMockStore.js

redux-logic test utilities to facilitate the testing of logic. Create mock store

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

import { createStore, applyMiddleware } from 'redux';
import { createLogicMiddleware } from 'redux-logic';

/*
  // specify as much as necessary for your particular test
  const store = createMockStore({
    initialState: optionalObject,
    reducer: optionalFn, // default: identity reducer
    logic: optionalLogic, // default: []
    injectedDeps: optionalObject, // default {}
    middleware: optionalArr // other mw, exclude logicMiddleware
  });
  store.dispatch(...) // use as necessary for your test
  // when all inflight logic has all completed calls fn + returns promise
  store.whenComplete(fn) - shorthand for store.logicMiddleware.whenComplete(fn)
  store.actions - the actions dispatched, use store.resetActions() to clear
  store.resetActions() - clear store.actions
  // access the logicMiddleware created for logic/injectedDeps props
  // use addLogic, mergeNewLogic, replaceLogic, whenComplete, monitor$
  store.logicMiddleware
 */

var defaultMockStoreOptions = {
  initialState: undefined,
  reducer: function reducer(state /* , action */) {
    return state;
  },
  // identity reducer
  logic: [], // used for the logicMiddleware that is created
  injectedDeps: {}, // used for the logicMiddleware that is created
  middleware: [] // other mw, exclude logicMiddleware from this array
};

var ALLOWED_OPTIONS = Object.keys(defaultMockStoreOptions);

function checkOptions(obj) {
  Object.keys(obj).forEach(function (k) {
    // check keys
    if (ALLOWED_OPTIONS.indexOf(k) === -1) {
      // no match
      throw new Error('invalid option: ' + k);
    }
  });
  if (obj.reducer && typeof obj.reducer !== 'function') {
    throw new Error('reducer should be a function');
  }
  if (obj.middleware && !Array.isArray(obj.middleware)) {
    throw new Error('middleware should be an array');
  }
}

export default function createMockStore() {
  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

  checkOptions(options); // throws if any problems
  var opts = _extends({}, defaultMockStoreOptions, options);
  var initialState = opts.initialState,
      reducer = opts.reducer,
      logic = opts.logic,
      injectedDeps = opts.injectedDeps,
      middleware = opts.middleware;

  // track the actions dispatched using a custom mw added last

  var actions = [];
  var trackActionsMW = function trackActionsMW() {
    return (/* store */function (next) {
        return function (action) {
          actions.push(action);
          return next(action);
        };
      }
    );
  };

  var logicMiddleware = createLogicMiddleware(logic, injectedDeps);
  var enhancer = applyMiddleware.apply(undefined, [logicMiddleware].concat(middleware, [trackActionsMW]));
  var store = createStore(reducer, initialState, enhancer);
  Object.defineProperty(store, 'actions', { // create store.actions getter
    enumerable: true,
    get: function get() {
      return actions;
    }
  });
  store.resetActions = function () {
    actions.length = 0;
  }; // truncate
  store.logicMiddleware = logicMiddleware;
  store.whenComplete = function (fn) {
    return logicMiddleware.whenComplete(fn);
  };
  return store;
}