Add possibility to assert duplicate actions

Author: dmitry-zaets

package.json

@@ -41,7 +41,7 @@
     "should": "^8.3.1"
   },
   "dependencies": {
-    "lodash.find": "^4.3.0",
+    "lodash.findindex": "^4.4.0",
     "lodash.flattendeep": "^4.2.0",
     "redux": "^3.5.2",
     "redux-mock-store": "^1.0.2"

src/asserts/actionUtils.js

@@ -1,4 +1,4 @@
-import find from 'lodash.find';
+import findIndex from 'lodash.findindex';
 import flattenDeep from 'lodash.flattendeep';
 import { toArray } from '../utils';
 import getMockStore from '../mockStore';
@@ -33,13 +33,24 @@ function unrollActions(initialState, expectedActions) {
   });
 }
 
+function notDispatchedError(dispatchedActions, expectedActions, expectedAction) {
+  return new Error(
+    `Expected action ${JSON.stringify(expectedAction)} was not dispatched.\n` +
+    `Expected dispatched actions: ${JSON.stringify(expectedActions)}` +
+    `Actual dispatched actions: ${JSON.stringify(dispatchedActions)}`
+  );
+}
+
 function assertDispatchedActions(dispatched, expected) {
-  for (let index = 0; index < expected.length; index++) {
-    if (!find(dispatched, expected[index])) {
-      throw new Error(
-        `Expected action ${JSON.stringify(expected[index])} was not dispatched.\n` +
-        `Actual dispatched actions: ${JSON.stringify(dispatched)}`
-      );
+  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 notDispatchedError(dispatched, expected, expected[indexInExpected]);
     }
   }
 }

test/assertions/actionUtils.js

@@ -34,7 +34,7 @@ describe('assertions', () => {
 
       it('should be function', () => { expect(unrollActions).toBeA('function'); });
 
-      it('should return flat array with all actions', () => {
+      it('should return flat array with all the actions', () => {
         unrollActions({}, asyncActionCreator()).then((result) => {
           const expectedActions = [
             { type: '0-0' },
@@ -50,20 +50,62 @@ describe('assertions', () => {
     });
 
     describe('assertDispatchedActions', () => {
-      it('should be function', () => { expect(assertDispatchedActions).toBeA('function'); });
+      it('should be function', () => {
+        expect(assertDispatchedActions).toBeA('function');
+      });
+
+      describe('when expected action was not dispatched', () => {
+        it('should throw an error', () => {
+          const dispatchedActions = [
+            { type: '0-0' },
+            { type: '0-1' }
+          ];
+          const expectedActions = [
+            { type: '0-0' },
+            { type: '10-0' }
+          ];
+
+          expect(() => { assertDispatchedActions(dispatchedActions, expectedActions); })
+            .toThrow();
+        });
+      });
 
-      it('should throw error if expected action was not dispatched', () => {
+      it('should accept expected duplicate actions', () => {
         const dispatchedActions = [
           { type: '0-0' },
-          { type: '0-1' }
+          { type: '0-1' },
+          { type: '0-0' },
+          { type: '0-2' }
         ];
         const expectedActions = [
           { type: '0-0' },
-          { type: '10-0' }
+          { type: '0-0' },
+          { type: '0-1' },
+          { type: '0-2' }
         ];
 
         expect(() => { assertDispatchedActions(dispatchedActions, expectedActions); })
-          .toThrow();
+          .toNotThrow();
+      });
+
+      describe('when expected duplicate actions were not dispatched', () => {
+        it('should throw an error', () => {
+          const dispatchedActions = [
+            { type: '0-0' },
+            { type: '0-1' },
+            { type: '0-2' },
+            { type: '0-3' }
+          ];
+          const expectedActions = [
+            { type: '0-0' },
+            { type: '0-0' },
+            { type: '0-1' },
+            { type: '0-2' }
+          ];
+
+          expect(() => { assertDispatchedActions(dispatchedActions, expectedActions); })
+            .toThrow();
+        });
       });
     });
   });