Add unexpected actions support

Author: onedesert

src/asserts/actionUtils.js

@@ -41,6 +41,14 @@ function notDispatchedError(dispatchedActions, expectedActions, expectedAction)
   );
 }
 
+function dispatchedError(dispatchedActions, unExpectedActions, unExpectedAction) {
+  return new Error(
+    `Expected action ${JSON.stringify(unExpectedAction)} was not dispatched.\n` +
+    `Expected dispatched actions: ${JSON.stringify(unExpectedActions)}\n` +
+    `Actual dispatched actions: ${JSON.stringify(dispatchedActions)}`
+  );
+}
+
 function assertDispatchedActions(dispatched, expected) {
   const availableActions = dispatched.slice();
 
@@ -55,8 +63,24 @@ function assertDispatchedActions(dispatched, expected) {
   }
 }
 
+function assertUnDispatchedActions(dispatched, unExpected) {
+  const availableActions = dispatched.slice();
+
+  for (let indexInExpected = 0; indexInExpected < unExpected.length; indexInExpected++) {
+    const indexInAvailable = findIndex(availableActions, unExpected[indexInExpected]);
+
+    if (indexInAvailable === -1) {
+      availableActions.splice(indexInAvailable, 1);
+    } else {
+      throw dispatchedError(dispatched, unExpected, unExpected[indexInExpected]);
+    }
+  }
+}
+
+
 export {
   getDispatchedActions,
   unrollActions,
-  assertDispatchedActions
+  assertDispatchedActions,
+  assertUnDispatchedActions
 };

src/asserts/toNotDispatchActions.js

@@ -0,0 +1,14 @@
+
+import getInitialStoreState from '../initialState';
+import { toDispatchActionsWithState } from './toDispatchActionsWithState';
+
+function toDispatchActions(actionUnderTest, unExpectedActions, done, fail) {
+  return toDispatchActionsWithState(
+    getInitialStoreState(),
+    actionUnderTest,
+    unExpectedActions,
+    done, fail
+  );
+}
+
+export { toDispatchActions };

src/asserts/toNotDispatchActionsWithState.js

@@ -0,0 +1,47 @@
+import { isFunction, isObject } from '../utils';
+import {
+  getDispatchedActions,
+  unrollActions,
+  assertDispatchedActions,
+  assertUnDispatchedActions
+} from './actionUtils';
+
+function toDispatchActionsWithState(initialState, actionUnderTest, unExpectedActions, done, fail) {
+  if (!isFunction(actionUnderTest) && !isObject(actionUnderTest)) {
+    throw new Error(
+      'The "actualAction" argument must be a function or an object'
+    );
+  }
+
+  if (!isFunction(unExpectedActions) &&
+      !isObject(unExpectedActions) &&
+      !Array.isArray(unExpectedActions)) {
+    throw new Error(
+      'The "unExpectedActions" argument must be ' +
+      'an action creator function, an action object, or an array of them'
+    );
+  }
+
+  return getDispatchedActions(initialState, actionUnderTest).then((dispatchedActions) => {
+    return unrollActions(initialState, unExpectedActions).then((unExpectedUnrolledActions) => {
+      assertUnDispatchedActions(dispatchedActions, unExpectedUnrolledActions);
+
+      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));
+  });
+}
+
+export {
+  toDispatchActionsWithState
+};