Refactor utils.

Split utils to separate files.
Add "toNotDispatchActions" and "toNotDispatchActionsWithState".

Author: dmitry-zaets

src/assertions.js

@@ -1,4 +1,12 @@
 import { toDispatchActions } from './asserts/toDispatchActions';
 import { toDispatchActionsWithState } from './asserts/toDispatchActionsWithState';
+import { toNotDispatchActions } from './asserts/toNotDispatchActions';
+import { toNotDispatchActionsWithState } from './asserts/toNotDispatchActionsWithState';
 
-export default { toDispatchActions, toDispatchActionsWithState };
+
+export default {
+  toDispatchActions,
+  toDispatchActionsWithState,
+  toNotDispatchActions,
+  toNotDispatchActionsWithState
+};

src/asserts/actionUtils.js

@@ -0,0 +1,9 @@
+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)}`
+  );
+}
+
+export { dispatchedActionError };

src/asserts/errors/dispatchedActionError.js

@@ -0,0 +1,9 @@
+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)}`
+  );
+}
+
+export { notDispatchedActionError };

src/asserts/errors/notDispatchedActionError.js

@@ -1,10 +1,10 @@
-import getInitialStoreState from '../initialState';
+import { getInitialStoreState } from '../initialState';
 import { toDispatchActionsWithState } from './toDispatchActionsWithState';
 
-function toDispatchActions(actionUnderTest, expectedActions, done, fail) {
+function toDispatchActions(action, expectedActions, done, fail) {
   return toDispatchActionsWithState(
     getInitialStoreState(),
-    actionUnderTest,
+    action,
     expectedActions,
     done, fail
   );

src/asserts/index.js

@@ -1,42 +1,8 @@
-import { isFunction, isObject } from '../utils';
-import { getDispatchedActions, unrollActions, assertDispatchedActions } from './actionUtils';
+import { performAssertion } from './utils/performAssertion';
+import { assertDispatchedActions } from './utils/assertDispatchedActions';
 
-function toDispatchActionsWithState(initialState, actionUnderTest, expectedActions, done, fail) {
-  if (!isFunction(actionUnderTest) && !isObject(actionUnderTest)) {
-    throw new Error(
-      'The "actualAction" argument must be a function or an object'
-    );
-  }
-
-  if (!isFunction(expectedActions) &&
-      !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 getDispatchedActions(initialState, actionUnderTest).then((dispatchedActions) => {
-    return unrollActions(initialState, expectedActions).then((expectedUnrolledActions) => {
-      assertDispatchedActions(dispatchedActions, expectedUnrolledActions);
-
-      if (isFunction(done)) {
-        done();
-      }
-    });
-  }).catch((err) => {
-    if (isFunction(fail)) {
-      fail(err);
-      return;
-    } else if (isFunction(done)) {
-      done(err);
-      return;
-    }
-    throw new Error(JSON.stringify(err));
-  });
+function toDispatchActionsWithState(initialState, action, expectedActions, done, fail) {
+  performAssertion(assertDispatchedActions, initialState, action, expectedActions, done, fail);
 }
 
-export {
-  toDispatchActionsWithState
-};
+export { toDispatchActionsWithState };

src/asserts/toDispatchActions.js

@@ -0,0 +1,13 @@
+import { getInitialStoreState } from '../initialState';
+import { toNotDispatchActionsWithState } from './toNotDispatchActionsWithState';
+
+function toNotDispatchActions(action, expectedActions, done, fail) {
+  return toNotDispatchActionsWithState(
+    getInitialStoreState(),
+    action,
+    expectedActions,
+    done, fail
+  );
+}
+
+export { toNotDispatchActions };

src/asserts/toDispatchActionsWithState.js

@@ -0,0 +1,8 @@
+import { performAssertion } from './utils/performAssertion';
+import { assertNotDispatchedActions } from './utils/assertNotDispatchedActions';
+
+function toNotDispatchActionsWithState(initialState, action, expectedActions, done, fail) {
+  performAssertion(assertNotDispatchedActions, initialState, action, expectedActions, done, fail);
+}
+
+export { toNotDispatchActionsWithState };

src/asserts/toNotDispatchActions.js

@@ -0,0 +1,18 @@
+import findIndex from 'lodash.findindex';
+import { notDispatchedActionError } from '../errors/notDispatchedActionError';
+
+function assertDispatchedActions(dispatched, expected) {
+  const availableActions = dispatched.slice();
+
+  for (let indexInExpected = 0; indexInExpected < expected.length; indexInExpected++) {
+    const indexInAvailable = findIndex(availableActions, expected[indexInExpected]);
+
+    if (indexInAvailable !== -1) {
+      availableActions.splice(indexInAvailable, 1);
+    } else {
+      throw notDispatchedActionError(dispatched, expected, expected[indexInExpected]);
+    }
+  }
+}
+
+export { assertDispatchedActions };