Extract Javascript part of redux-actions-assertions

Author: dmitry-zaets

.babelrc

@@ -0,0 +1,5 @@
+{
+  "presets": [
+    "es2015"
+  ]
+}

.eslintrc

@@ -0,0 +1,23 @@
+{
+  "extends": "airbnb-base",
+  "parserOptions": {
+    "ecmaVersion": 6,
+    "sourceType": "module",
+    "ecmaFeatures": {
+    },
+  },
+  "env": {
+    "es6": true,
+    "mocha": true
+  },
+  "rules": {
+    "arrow-body-style": ["error", "always"],
+    "prefer-const": 1,
+    "no-param-reassign": 0,
+    "new-cap": 0,
+    "comma-dangle": [2, "never"],
+    "spaced-comment": [2, "always", { exceptions: ["*", "-"] }],
+    "quote-props": [2, "consistent"],
+    "no-underscore-dangle": ["error", { "allowAfterThis": true }]
+  }
+}

.gitignore

@@ -0,0 +1,4 @@
+logs
+*.log
+node_modules
+lib

.travis.yml

@@ -0,0 +1,10 @@
+sudo: false
+language: node_js
+node_js:
+  - stable
+script:
+  - npm run test
+  - npm run prepublish
+branches:
+  only:
+    - master

lib/assertions.js

@@ -0,0 +1,20 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _toDispatchActions = require('./asserts/toDispatchActions');
+
+var _toDispatchActionsWithState = require('./asserts/toDispatchActionsWithState');
+
+var _toNotDispatchActions = require('./asserts/toNotDispatchActions');
+
+var _toNotDispatchActionsWithState = require('./asserts/toNotDispatchActionsWithState');
+
+exports.default = {
+  toDispatchActions: _toDispatchActions.toDispatchActions,
+  toDispatchActionsWithState: _toDispatchActionsWithState.toDispatchActionsWithState,
+  toNotDispatchActions: _toNotDispatchActions.toNotDispatchActions,
+  toNotDispatchActionsWithState: _toNotDispatchActionsWithState.toNotDispatchActionsWithState
+};

lib/asserts/errors/dispatchedActionError.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+function dispatchedActionError(dispatchedActions, expectedActions, action) {
+  return new Error("Action " + JSON.stringify(action) + " was dispatched when it was unexpected.\n" + ("Actions expected to be not dispatched: " + JSON.stringify(expectedActions) + "\n") + ("Actual dispatched actions: " + JSON.stringify(dispatchedActions)));
+}
+
+exports.dispatchedActionError = dispatchedActionError;

lib/asserts/errors/notDispatchedActionError.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+function notDispatchedActionError(dispatchedActions, expectedActions, action) {
+  return new Error("Action " + JSON.stringify(action) + " was not dispatched when it was expected.\n" + ("Actions expected to be dispatched: " + JSON.stringify(expectedActions) + "\n") + ("Actual dispatched actions: " + JSON.stringify(dispatchedActions)));
+}
+
+exports.notDispatchedActionError = notDispatchedActionError;

lib/asserts/toDispatchActions.js

@@ -0,0 +1,16 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toDispatchActions = undefined;
+
+var _initialState = require('../initialState');
+
+var _toDispatchActionsWithState = require('./toDispatchActionsWithState');
+
+function toDispatchActions(action, expectedActions, done, fail) {
+  return (0, _toDispatchActionsWithState.toDispatchActionsWithState)((0, _initialState.getInitialStoreState)(), action, expectedActions, done, fail);
+}
+
+exports.toDispatchActions = toDispatchActions;

lib/asserts/toDispatchActionsWithState.js

@@ -0,0 +1,16 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toDispatchActionsWithState = undefined;
+
+var _performAssertion = require('./utils/performAssertion');
+
+var _assertDispatchedActions = require('./utils/assertDispatchedActions');
+
+function toDispatchActionsWithState(initialState, action, expectedActions, done, fail) {
+  (0, _performAssertion.performAssertion)(_assertDispatchedActions.assertDispatchedActions, initialState, action, expectedActions, done, fail);
+}
+
+exports.toDispatchActionsWithState = toDispatchActionsWithState;

lib/asserts/toNotDispatchActions.js

@@ -0,0 +1,16 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toNotDispatchActions = undefined;
+
+var _initialState = require('../initialState');
+
+var _toNotDispatchActionsWithState = require('./toNotDispatchActionsWithState');
+
+function toNotDispatchActions(action, expectedActions, done, fail) {
+  return (0, _toNotDispatchActionsWithState.toNotDispatchActionsWithState)((0, _initialState.getInitialStoreState)(), action, expectedActions, done, fail);
+}
+
+exports.toNotDispatchActions = toNotDispatchActions;

lib/asserts/toNotDispatchActionsWithState.js

@@ -0,0 +1,16 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toNotDispatchActionsWithState = undefined;
+
+var _performAssertion = require('./utils/performAssertion');
+
+var _assertNotDispatchedActions = require('./utils/assertNotDispatchedActions');
+
+function toNotDispatchActionsWithState(initialState, action, expectedActions, done, fail) {
+  (0, _performAssertion.performAssertion)(_assertNotDispatchedActions.assertNotDispatchedActions, initialState, action, expectedActions, done, fail);
+}
+
+exports.toNotDispatchActionsWithState = toNotDispatchActionsWithState;

lib/asserts/utils/assertDispatchedActions.js

@@ -0,0 +1,30 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assertDispatchedActions = undefined;
+
+var _lodash = require('lodash.findindex');
+
+var _lodash2 = _interopRequireDefault(_lodash);
+
+var _notDispatchedActionError = require('../errors/notDispatchedActionError');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function assertDispatchedActions(dispatched, expected) {
+  var availableActions = dispatched.slice();
+
+  for (var indexInExpected = 0; indexInExpected < expected.length; indexInExpected++) {
+    var indexInAvailable = (0, _lodash2.default)(availableActions, expected[indexInExpected]);
+
+    if (indexInAvailable !== -1) {
+      availableActions.splice(indexInAvailable, 1);
+    } else {
+      throw (0, _notDispatchedActionError.notDispatchedActionError)(dispatched, expected, expected[indexInExpected]);
+    }
+  }
+}
+
+exports.assertDispatchedActions = assertDispatchedActions;

lib/asserts/utils/assertNotDispatchedActions.js

@@ -0,0 +1,24 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assertNotDispatchedActions = undefined;
+
+var _lodash = require('lodash.findindex');
+
+var _lodash2 = _interopRequireDefault(_lodash);
+
+var _dispatchedActionError = require('../errors/dispatchedActionError');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function assertNotDispatchedActions(dispatched, expected) {
+  for (var indexInExpected = 0; indexInExpected < expected.length; indexInExpected++) {
+    if ((0, _lodash2.default)(dispatched, expected[indexInExpected]) !== -1) {
+      throw (0, _dispatchedActionError.dispatchedActionError)(dispatched, expected, expected[indexInExpected]);
+    }
+  }
+}
+
+exports.assertNotDispatchedActions = assertNotDispatchedActions;

lib/asserts/utils/getDispatchedActions.js

@@ -0,0 +1,31 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getDispatchedActions = undefined;
+
+var _mockStore = require('../../mockStore');
+
+var _mockStore2 = _interopRequireDefault(_mockStore);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function getDispatchedActions(initialState, action) {
+  return new Promise(function (resolve, reject) {
+    var store = (0, _mockStore2.default)()(initialState);
+    var dispatchResult = store.dispatch(action);
+
+    if (dispatchResult instanceof Promise) {
+      dispatchResult.then(function () {
+        resolve(store.getActions());
+      }).catch(function (result) {
+        reject(result);
+      });
+    } else {
+      resolve(store.getActions());
+    }
+  });
+}
+
+exports.getDispatchedActions = getDispatchedActions;

lib/asserts/utils/performAssertion.js

@@ -0,0 +1,43 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.performAssertion = undefined;
+
+var _utils = require('../../utils');
+
+var _getDispatchedActions = require('./getDispatchedActions');
+
+var _unrollActions = require('./unrollActions');
+
+function performAssertion(assertFunction, initialState, action, expectedActions, done, fail) {
+  if (!(0, _utils.isFunction)(action) && !(0, _utils.isObject)(action)) {
+    throw new Error('The "action" argument must be a function or an object');
+  }
+
+  if (!(0, _utils.isFunction)(expectedActions) && !(0, _utils.isObject)(expectedActions) && !Array.isArray(expectedActions)) {
+    throw new Error('The "expectedActions" argument must be ' + 'an action creator function, an action object, or an array of them');
+  }
+
+  return (0, _getDispatchedActions.getDispatchedActions)(initialState, action).then(function (dispatchedActions) {
+    return (0, _unrollActions.unrollActions)(initialState, expectedActions).then(function (expectedUnrolledActions) {
+      assertFunction(dispatchedActions, expectedUnrolledActions);
+
+      if ((0, _utils.isFunction)(done)) {
+        done();
+      }
+    });
+  }).catch(function (err) {
+    if ((0, _utils.isFunction)(fail)) {
+      fail(err);
+      return;
+    } else if ((0, _utils.isFunction)(done)) {
+      done(err);
+      return;
+    }
+    throw new Error(JSON.stringify(err));
+  });
+}
+
+exports.performAssertion = performAssertion;

lib/asserts/utils/unrollActions.js

@@ -0,0 +1,31 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.unrollActions = undefined;
+
+var _lodash = require('lodash.flattendeep');
+
+var _lodash2 = _interopRequireDefault(_lodash);
+
+var _utils = require('../../utils');
+
+var _getDispatchedActions = require('./getDispatchedActions');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function unrollActions(initialState, expectedActions) {
+  var promises = [];
+  var actions = (0, _utils.toArray)(expectedActions);
+
+  for (var index = 0; index < actions.length; index++) {
+    promises.push((0, _getDispatchedActions.getDispatchedActions)(initialState, actions[index]));
+  }
+
+  return Promise.all(promises).then(function (resultActions) {
+    return (0, _lodash2.default)(resultActions);
+  });
+}
+
+exports.unrollActions = unrollActions;

lib/index.js

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assertions = exports.buildInitialStoreState = exports.registerInitialStoreState = exports.registerMiddlewares = undefined;
+
+var _mockStore = require('./mockStore');
+
+var _initialState = require('./initialState');
+
+var _assertions = require('./assertions');
+
+var _assertions2 = _interopRequireDefault(_assertions);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.registerMiddlewares = _mockStore.registerMiddlewares;
+exports.registerInitialStoreState = _initialState.registerInitialStoreState;
+exports.buildInitialStoreState = _initialState.buildInitialStoreState;
+exports.assertions = _assertions2.default;

lib/initialState.js

@@ -0,0 +1,27 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getInitialStoreState = exports.registerInitialStoreState = exports.buildInitialStoreState = undefined;
+
+var _redux = require('redux');
+
+var state = null;
+
+function registerInitialStoreState(newState) {
+  state = newState;
+}
+
+function buildInitialStoreState(reducer) {
+  var store = (0, _redux.createStore)(reducer);
+  return store.getState();
+}
+
+function getInitialStoreState() {
+  return state;
+}
+
+exports.buildInitialStoreState = buildInitialStoreState;
+exports.registerInitialStoreState = registerInitialStoreState;
+exports.getInitialStoreState = getInitialStoreState;