Add expect.js

Author: dmitry-zaets

README.md

@@ -10,8 +10,8 @@ It use [redux-mock-store](https://github.com/arnaudbenard/redux-mock-store) to m
 ## Supported Assertion Frameworks/Libraries:
 - [expect](#expect)
 - [chai](#chai)
-- [expect.js](#expectjs) [In Progress]
-- [should](#should) [In Progress]
+- [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).
@@ -222,6 +222,31 @@ var registerAssertions = require('redux-actions-assertions/expect.js').registerA
 registerAssertions();
 ```
 
+### Usage
+
+#### .dispatchActions
+
+> `expect(action).to.dispatchActions(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())
+  .to.dispatchActions({type: 'MY_ACTION_START'}, callback);
+```
+
+#### .withState
+
+> `expect(action).withState(state).to.dispatchActions(expectedActions, callback)`
+
+Asserts that store initialised with `state` before `action` is dispatched.
+
+```js
+expect(myActionCreator())
+  .withState({property: 'value'})
+  .to.dispatchActions([{type: 'MY_ACTION_START'}, finishActionCreator()], callback);
+```
+
 ## [should](https://github.com/shouldjs/should.js)
 
 ### Registration

package.json

@@ -8,8 +8,9 @@
     "test:general": "mocha --compilers js:babel-register --reporter spec test/*.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",
     "test:should": "mocha --compilers js:babel-register --reporter spec test/should/*.js",
-    "test": "npm run test:general && npm run test:chai && npm run test:expect && npm run test:should",
+    "test": "npm run test:general && npm run test:chai && npm run test:expect && npm run test:expectjs && npm run test:should",
     "prepublish": "rimraf lib && babel src --out-dir lib"
   },
   "repository": {

src/actionWithInitialState.js

@@ -0,0 +1,5 @@
+function ActionWithInitialState(action, state) {
+  this.action = action;
+  this.state = state;
+}
+export default ActionWithInitialState;

src/expect.js/index.js

@@ -0,0 +1,26 @@
+import expect from 'expect.js';
+import assertions from '../assertions';
+import ActionWithInitialState from '../ActionWithInitialState';
+
+function withState(state) {
+  return expect(new ActionWithInitialState(this.obj, state));
+}
+
+function dispatchActions(expectedActions, done) {
+  if (this.obj instanceof ActionWithInitialState) {
+    const action = this.obj.action;
+    const state = this.obj.state;
+    assertions.toDispatchActionsWithState(state, action, expectedActions, done);
+  } else {
+    assertions.toDispatchActions(this.obj, expectedActions, done);
+  }
+}
+
+function registerAssertions() {
+  expect.Assertion.prototype.withState = withState;
+  expect.Assertion.prototype.dispatchActions = dispatchActions;
+}
+
+export {
+  registerAssertions
+};

src/expect/index.js

@@ -1,19 +1,18 @@
 import expect from 'expect';
 import assertions from '../assertions';
 
+function withState(state) {
+  this.state = state;
+  return this;
+}
+
 function toDispatchActions(expectedActions, done) {
   if (this.state) {
     return assertions.toDispatchActionsWithState(this.state, this.actual, expectedActions, done);
   }
   return assertions.toDispatchActions(this.actual, expectedActions, done);
 }
 
-function withState(state) {
-  this.state = state;
-
-  return this;
-}
-
 function registerAssertions() {
   expect.extend({
     toDispatchActions,

src/should/index.js

@@ -1,10 +1,6 @@
 import should from 'should';
 import assertions from '../assertions';
-
-function ActionWithInitialState(action, state) {
-  this.action = action;
-  this.state = state;
-}
+import ActionWithInitialState from '../ActionWithInitialState';
 
 function withState(state) {
   this.obj = new ActionWithInitialState(this.obj, state);

test/expect.js/index.js

@@ -0,0 +1,44 @@
+import expect from 'expect.js';
+import thunk from 'redux-thunk';
+import { registerMiddlewares } from '../../src';
+import { registerAssertions } from '../../src/expect.js';
+import actions from '../testingData/actions';
+
+registerMiddlewares([thunk]);
+registerAssertions();
+
+describe('expect.js', () => {
+  describe('.withState', () => {
+    it('should accept object', (done) => {
+      expect(actions.actionCreatorWithGetState())
+        .withState({ property: 'value' })
+        .to.dispatchActions(actions.actionWithGetState({ property: 'value' }), done);
+    });
+
+    it('should accept function', (done) => {
+      expect(actions.actionCreatorWithGetState())
+        .withState(() => { return { property: 'value' };})
+        .to.dispatchActions(actions.actionWithGetState({ property: 'value' }), done);
+    });
+  });
+
+  describe('.dispatchActions', () => {
+    it('should accept single action', (done) => {
+      expect(actions.start()).to.dispatchActions(actions.start(), done);
+    });
+
+    it('should accept array with one action', (done) => {
+      expect(actions.start()).to.dispatchActions([actions.start()], done);
+    });
+
+    it('should accept array with multiple actions', (done) => {
+      expect(actions.asyncActionCreator())
+        .to.dispatchActions(actions.expectedActions, done);
+    });
+
+    it('should accept array with nested async action creators', (done) => {
+      expect(actions.parentAsyncActionCreator())
+        .to.dispatchActions(actions.expectedParentActions, done);
+    });
+  });
+});