Add tests for assertions

Author: dmitry-zaets

README.md

@@ -1,20 +1,19 @@
-# redux-actions-assertions [![Build Status](https://travis-ci.org/dmitry-zaets/redux-actions-assertions.svg?branch=master)](https://travis-ci.org/dmitry-zaets/redux-actions-assertions)
-
+# redux-actions-assertions 
 Assertions for redux actions testing
 
 This library add assertions for [redux actions](http://redux.js.org/docs/advanced/AsyncActions.html) testing.  
 It use [redux-mock-store](https://github.com/arnaudbenard/redux-mock-store) to mock redux store.
 
-
+[![build status](https://img.shields.io/travis/dmitry-zaets/redux-actions-assertions/master.svg?style=flat-square)](https://travis-ci.org/dmitry-zaets/redux-actions-assertions)
+[![npm version](https://img.shields.io/npm/v/redux-actions-assertions.svg?style=flat-square)](https://www.npmjs.com/package/redux-actions-assertions)
 
 ## Supported Assertion Frameworks/Libraries:
-- [expect](#expect)
 - [chai](#chai)
+- [expect](#expect)
 - [expect.js](#expectjs)
 - [should](#should)
-- [jasmine and jest](#jasmine-and-jest) [In Progress]
 
-If you have not found assertion framework/library that you are using - you still can use [pure assertion function](#javascript).
+If you have not found assertion framework/library that you are using - you can use [pure javascript assertion](#javascript) or create an issue.
 
 ## Installation
 
@@ -103,45 +102,6 @@ Same as `toDispatchActions` + asserts that store initialised with `state` before
 toDispatchActions({property: 'value'}, testActionCreator(), [{type: 'MY_ACTION_START'}], callback);
 ```
 
-## [expect](https://github.com/mjackson/expect)
-
-### Registration
-
-```js
-// using ES6 modules
-import { registerAssertions } from 'redux-actions-assertions/expect';
-
-// using CommonJS modules
-var registerAssertions = require('redux-actions-assertions/expect').registerAssertions;
-
-// registration
-registerAssertions();
-```
-### Usage
-
-#### .toDispatchActions
-
-> `expect(action).toDispatchActions(expectedActions, callback)`
-
-Asserts that when given `action` is dispatched it will dispatch `expectedActions`. `action` can be plain object (action) or function (action creator). `expectedActions` can be can be plain object (action) or function (action creator) or array of objects/functions.
-
-```js
-expect(myActionCreator())
-  .toDispatchActions({type: 'MY_ACTION_START'}, callback);
-```
-
-#### .withState
-
-> `expect(action).withState(state).toDispatchActions(expectedActions, callback)`
-
-Asserts that store initialised with `state` before `action` is dispatched.
-
-```js
-expect(myActionCreator())
-  .withState({property: 'value'})
-  .toDispatchActions([{type: 'MY_ACTION_START'}, finishActionCreator()], callback);
-```
-
 ## [chai](https://github.com/chaijs/chai)
 
 ### Registration
@@ -207,6 +167,45 @@ assert.isDispatchingWithState(
 );
 ```
 
+## [expect](https://github.com/mjackson/expect)
+
+### Registration
+
+```js
+// using ES6 modules
+import { registerAssertions } from 'redux-actions-assertions/expect';
+
+// using CommonJS modules
+var registerAssertions = require('redux-actions-assertions/expect').registerAssertions;
+
+// registration
+registerAssertions();
+```
+### Usage
+
+#### .toDispatchActions
+
+> `expect(action).toDispatchActions(expectedActions, callback)`
+
+Asserts that when given `action` is dispatched it will dispatch `expectedActions`. `action` can be plain object (action) or function (action creator). `expectedActions` can be can be plain object (action) or function (action creator) or array of objects/functions.
+
+```js
+expect(myActionCreator())
+  .toDispatchActions({type: 'MY_ACTION_START'}, callback);
+```
+
+#### .withState
+
+> `expect(action).withState(state).toDispatchActions(expectedActions, callback)`
+
+Asserts that store initialised with `state` before `action` is dispatched.
+
+```js
+expect(myActionCreator())
+  .withState({property: 'value'})
+  .toDispatchActions([{type: 'MY_ACTION_START'}, finishActionCreator()], callback);
+```
+
 ## [expect.js](https://github.com/Automattic/expect.js)
 
 ### Registration
@@ -305,18 +304,4 @@ myActionCreator().should
 myActionCreator().should
   .with.state({property: 'value'})
   .dispatchActions({type: 'MY_ACTION_START'}, callback);
-```
-## [jasmine](https://github.com/jasmine/jasmine) and [jest](https://github.com/facebook/jest)
-
-### Registration
-
-```js
-// using ES6 modules
-import { registerAssertions } from 'redux-actions-assertions/jasmine';
-
-// using CommonJS modules
-var registerAssertions = require('redux-actions-assertions/jasmine').registerAssertions;
-
-// registration
-registerAssertions();
-```
+```

package.json

@@ -5,7 +5,7 @@
   "main": "lib/index.js",
   "scripts": {
     "lint": "eslint src test",
-    "test:general": "mocha --compilers js:babel-register --reporter spec test/*.js",
+    "test:general": "mocha --compilers js:babel-register --reporter spec test/general/*.js test/assertions/*.js",
     "test:chai": "mocha --compilers js:babel-register --reporter spec test/chai/*.js",
     "test:expect": "mocha --compilers js:babel-register --reporter spec test/expect/*.js",
     "test:expectjs": "mocha --compilers js:babel-register --reporter spec test/expect.js/*.js",
@@ -36,7 +36,6 @@
     "eslint-plugin-babel": "^3.1.0",
     "expect": "^1.16.0",
     "expect.js": "^0.3.1",
-    "jasmine": "^2.4.1",
     "mocha": "^2.4.5",
     "redux-thunk": "^2.0.1",
     "rimraf": "^2.5.2",

src/assertions/actionUtils.js

@@ -0,0 +1,51 @@
+import find from 'lodash.find';
+import flattenDeep from 'lodash.flattendeep';
+import { toArray } from '../utils';
+import getMockStore from '../mockStore';
+
+function getDispatchedActions(initialState, action) {
+  return new Promise((resolve, reject) => {
+    const store = getMockStore()(initialState);
+    const dispatchResult = store.dispatch(action);
+
+    if (dispatchResult instanceof Promise) {
+      dispatchResult.then(() => {
+        resolve(store.getActions());
+      }).catch((result) => {
+        reject(result);
+      });
+    } else {
+      resolve(store.getActions());
+    }
+  });
+}
+
+function unrollActions(initialState, expectedActions) {
+  const promises = [];
+  const actions = toArray(expectedActions);
+
+  for (let index = 0; index < actions.length; index++) {
+    promises.push(getDispatchedActions(initialState, actions[index]));
+  }
+
+  return Promise.all(promises).then((resultActions) => {
+    return flattenDeep(resultActions);
+  });
+}
+
+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)}`
+      );
+    }
+  }
+}
+
+export {
+  getDispatchedActions,
+  unrollActions,
+  assertDispatchedActions
+};

src/assertions/index.js

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

src/assertions/toDispatchActions.js

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

src/assertions/toDispatchActionsWithState.js

@@ -1,37 +1,5 @@
-import flattenDeep from 'lodash.flattendeep';
-import find from 'lodash.find';
-import { isFunction, isObject, toArray } from '../utils';
-import getMockStore from '../mockStore';
-
-function getDispatchedActions(initialState, action) {
-  return new Promise((resolve, reject) => {
-    const store = getMockStore()(initialState);
-    const dispatchResult = store.dispatch(action);
-
-    if (dispatchResult instanceof Promise) {
-      dispatchResult.then(() => {
-        resolve(store.getActions());
-      }).catch((result) => {
-        reject(result);
-      });
-    } else {
-      resolve(store.getActions());
-    }
-  });
-}
-
-function unrollActions(initialState, expectedActions) {
-  const promises = [];
-  const actions = toArray(expectedActions);
-
-  for (let index = 0; index < actions.length; index++) {
-    promises.push(getDispatchedActions(initialState, actions[index]));
-  }
-
-  return Promise.all(promises).then((resultActions) => {
-    return flattenDeep(resultActions);
-  });
-}
+import { isFunction, isObject } from '../utils';
+import { getDispatchedActions, unrollActions, assertDispatchedActions } from './actionUtils';
 
 function toDispatchActionsWithState(initialState, actionUnderTest, expectedActions, done, fail) {
   if (!isFunction(actionUnderTest) && !isObject(actionUnderTest)) {
@@ -40,7 +8,9 @@ function toDispatchActionsWithState(initialState, actionUnderTest, expectedActio
     );
   }
 
-  if (!isFunction(expectedActions) && !isObject(expectedActions)) {
+  if (!isFunction(expectedActions) &&
+      !isObject(expectedActions) &&
+      !Array.isArray(expectedActions)) {
     throw new Error(
       'The "expectedActions" argument must be ' +
       'an action creator function or an action object or an array of them'
@@ -49,28 +19,24 @@ function toDispatchActionsWithState(initialState, actionUnderTest, expectedActio
 
   return getDispatchedActions(initialState, actionUnderTest).then((dispatchedActions) => {
     return unrollActions(initialState, expectedActions).then((expectedUnrolledActions) => {
-      for (let index = 0; index < expectedUnrolledActions.length; index++) {
-        if (!find(dispatchedActions, expectedUnrolledActions[index])) {
-          throw new Error(
-            `Expected action ${JSON.stringify(expectedUnrolledActions[index])} was not dispatched.`
-            + `\nActual dispatched actions: ${JSON.stringify(dispatchedActions)}`
-          );
-        }
-      }
+      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(err);
     });
+  }).catch((err) => {
+    if (isFunction(fail)) {
+      fail(err);
+      return;
+    } else if (isFunction(done)) {
+      done(err);
+      return;
+    }
+    throw new Error(JSON.stringify(err));
   });
 }
 
-export default toDispatchActionsWithState;
+export {
+  toDispatchActionsWithState
+};

src/jasmine/index.js

@@ -0,0 +1,71 @@
+import expect from 'expect';
+import {
+  getDispatchedActions,
+  unrollActions,
+  assertDispatchedActions
+} from '../../src/assertions/actionUtils';
+
+describe('assertions', () => {
+  describe('action utils', () => {
+    describe('getDispatchedActions', () => {
+      it('should be function', () => { expect(getDispatchedActions).toBeA('function');});
+
+      it('should return a Promise', () => {
+        const result = getDispatchedActions({}, { type: '' });
+        expect(result).toBeA(Promise);
+      });
+    });
+
+    describe('unrollActions', () => {
+      function asyncActionCreator() {
+        return dispatch => {
+          dispatch({ type: '0-0' });
+          dispatch({ type: '0-1' });
+          return Promise.resolve().then(() => {
+            dispatch({ type: '1-0' });
+            dispatch({ type: '1-1' });
+            return Promise.resolve().then(() => {
+              dispatch({ type: '2-0' });
+              dispatch({ type: '2-1' });
+            });
+          });
+        };
+      }
+
+      it('should be function', () => { expect(unrollActions).toBeA('function');});
+
+      it('should return flat array with all actions', () => {
+        unrollActions({}, asyncActionCreator()).then((result) => {
+          const expectedActions = [
+            { type: '0-0' },
+            { type: '0-1' },
+            { type: '1-0' },
+            { type: '1-1' },
+            { type: '2-0' },
+            { type: '2-1' }
+          ];
+          expect(result).toBe(expectedActions);
+        });
+      });
+    });
+
+    describe('assertDispatchedActions', () => {
+      it('should be function', () => { expect(assertDispatchedActions).toBeA('function');});
+
+      it('should throw error if expected action was not dispatched', () => {
+        const dispatchedActions = [
+          { type: '0-0' },
+          { type: '0-1' }
+        ];
+        const expectedActions = [
+          { type: '0-0' },
+          { type: '10-0' }
+        ];
+
+        expect(assertDispatchedActions)
+          .withArgs([dispatchedActions, expectedActions])
+          .toThrow();
+      });
+    });
+  });
+});