Accept function as initial state for assertion

Author: dmitry-zaets

src/asserts/toDispatchActionsWithState.js

@@ -1,7 +1,10 @@
+import { getInitialStoreState } from '../initialState';
+import { isFunction } from '../utils';
 import { performAssertion } from './utils/performAssertion';
 import { assertDispatchedActions } from './utils/assertDispatchedActions';
 
-function toDispatchActionsWithState(initialState, action, expectedActions, done, fail) {
+function toDispatchActionsWithState(state, action, expectedActions, done, fail) {
+  const initialState = isFunction(state) ? state(getInitialStoreState()) : state;
   return performAssertion(
     assertDispatchedActions,
     initialState,

src/asserts/toNotDispatchActionsWithState.js

@@ -1,7 +1,10 @@
+import { getInitialStoreState } from '../initialState';
+import { isFunction } from '../utils';
 import { performAssertion } from './utils/performAssertion';
 import { assertNotDispatchedActions } from './utils/assertNotDispatchedActions';
 
-function toNotDispatchActionsWithState(initialState, action, expectedActions, done, fail) {
+function toNotDispatchActionsWithState(state, action, expectedActions, done, fail) {
+  const initialState = isFunction(state) ? state(getInitialStoreState()) : state;
   return performAssertion(
     assertNotDispatchedActions,
     initialState,

test/asserts/toDispatchActionsWithState.js

@@ -2,23 +2,26 @@ import expect from 'expect';
 import * as performAssertionObj from '../../src/asserts/utils/performAssertion';
 import * as assertDispatchedActionsObj from '../../src/asserts/utils/assertDispatchedActions';
 import { toDispatchActionsWithState } from '../../src/asserts/toDispatchActionsWithState';
-import { getInitialStoreState } from '../../src/initialState';
+import { registerInitialStoreState, getInitialStoreState } from '../../src/initialState';
 
 describe('toDispatchActionsWithState', () => {
-  const initialState = getInitialStoreState();
+  let initialState;
   const actualAction = { actualAction: 'actualAction' };
   const expectedAction = { expectedAction: 'expectedAction' };
   const spyDone = expect.createSpy();
   const spyFail = expect.createSpy();
   const performAssertionResult = { result: 'result' };
 
   beforeEach(() => {
+    registerInitialStoreState({ result: 'result' });
+    initialState = getInitialStoreState();
     expect.spyOn(performAssertionObj, 'performAssertion')
           .andReturn(performAssertionResult);
     expect.spyOn(assertDispatchedActionsObj, 'assertDispatchedActions');
   });
 
   afterEach(() => {
+    registerInitialStoreState(null);
     expect.restoreSpies();
   });
 
@@ -47,4 +50,42 @@ describe('toDispatchActionsWithState', () => {
 
     expect(result).toBe(performAssertionResult);
   });
+
+  describe('when state is a function', () => {
+    const stateFunctionResult = { newResult: 'newResult' };
+    let stateFunction;
+
+    beforeEach(() => {
+      stateFunction = expect.createSpy().andReturn(stateFunctionResult);
+    });
+
+    it('should execute it with initial state as argument', () => {
+      toDispatchActionsWithState(
+        stateFunction,
+        actualAction,
+        expectedAction,
+        spyDone, spyFail
+      );
+
+      expect(stateFunction).toHaveBeenCalledWith(initialState);
+    });
+
+    it('should call performAssertion with result of state function as initial state', () => {
+      toDispatchActionsWithState(
+        stateFunction,
+        actualAction,
+        expectedAction,
+        spyDone, spyFail
+      );
+
+      expect(performAssertionObj.performAssertion).toHaveBeenCalledWith(
+        assertDispatchedActionsObj.assertDispatchedActions,
+        stateFunctionResult,
+        actualAction,
+        expectedAction,
+        spyDone,
+        spyFail
+      );
+    });
+  });
 });

test/asserts/toNotDispatchActionsWithState.js

@@ -47,4 +47,42 @@ describe('toNotDispatchActionsWithState', () => {
 
     expect(result).toBe(performAssertionResult);
   });
+
+  describe('when state is a function', () => {
+    const stateFunctionResult = { newResult: 'newResult' };
+    let stateFunction;
+
+    beforeEach(() => {
+      stateFunction = expect.createSpy().andReturn(stateFunctionResult);
+    });
+
+    it('should execute it with initial state as argument', () => {
+      toNotDispatchActionsWithState(
+        stateFunction,
+        actualAction,
+        expectedAction,
+        spyDone, spyFail
+      );
+
+      expect(stateFunction).toHaveBeenCalledWith(initialState);
+    });
+
+    it('should call performAssertion with result from state function as initial state', () => {
+      toNotDispatchActionsWithState(
+        stateFunction,
+        actualAction,
+        expectedAction,
+        spyDone, spyFail
+      );
+
+      expect(performAssertionObj.performAssertion).toHaveBeenCalledWith(
+        assertNotDispatchedActionsObj.assertNotDispatchedActions,
+        stateFunctionResult,
+        actualAction,
+        expectedAction,
+        spyDone,
+        spyFail
+      );
+    });
+  });
 });