Add should assertions

Author: dmitry-zaets

package.json

@@ -6,8 +6,10 @@
   "scripts": {
     "lint": "eslint src test",
     "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": "npm run test:general && npm run test:expect",
+    "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",
     "prepublish": "rimraf lib && babel src --out-dir lib"
   },
   "repository": {

src/chai/index.js

@@ -3,16 +3,7 @@ import assertions from '../assertions';
 
 function registerAssertions() {
   chai.use((_chai, utils) => {
-    _chai.Assertion.addProperty('with');
-
-    function withProperty() {
-      utils.flag(this, 'with', true);
-    }
-
     function stateMethod(stateValue) {
-      if (!utils.flag(this, 'with')) {
-        throw new Error('"state" should be used after "with"');
-      }
       utils.flag(this, 'state', stateValue);
     }
 
@@ -24,6 +15,7 @@ function registerAssertions() {
       if (!utils.flag(this, 'dispatch')) {
         throw new Error('"actions" should be used after "dispatch"');
       }
+
       const state = utils.flag(this, 'state');
       if (state) {
         assertions.toDispatchActionsWithState(state, this._obj, expectedActions, done);
@@ -43,7 +35,6 @@ function registerAssertions() {
         .to.dispatch.actions(expectedActions, done);
     }
 
-    _chai.Assertion.addProperty('with', withProperty);
     _chai.Assertion.addChainableMethod('state', stateMethod);
     _chai.Assertion.addProperty('dispatch', dispatchProperty);
     _chai.Assertion.addMethod('actions', dispatchActionsMethod);

src/should/index.js

@@ -0,0 +1,30 @@
+import should from 'should';
+import assertions from '../assertions';
+
+function ActionWithInitialState(action, state) {
+  this.action = action;
+  this.state = state;
+}
+
+function withState(state) {
+  this.obj = 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);
+  }
+  assertions.toDispatchActions(this.obj, expectedActions, done);
+}
+
+function registerAssertions() {
+  should.Assertion.add('withState', withState);
+  should.Assertion.alias('withState', 'state');
+  should.Assertion.add('dispatchActions', dispatchActions);
+}
+
+export {
+  registerAssertions
+};

test/expect/index.js

@@ -8,28 +8,14 @@ registerMiddlewares([thunk]);
 registerAssertions();
 
 describe('expect', () => {
-  describe('with initial state', () => {
-    it('should accept object and setup getState', (done) => {
-      expect(actions.actionCreatorWithGetState())
-        .withState({ property: 'value' })
-        .toDispatchActions(actions.actionWithGetState({ property: 'value' }), done);
-    });
-
-    it('should accept function and setup getState', (done) => {
-      expect(actions.actionCreatorWithGetState())
-        .withState(() => { return { property: 'value' };})
-        .toDispatchActions(actions.actionWithGetState({ property: 'value' }), done);
-    });
-  });
-
   describe('.withState', () => {
-    it('should accept object and setup getState', (done) => {
+    it('should accept object', (done) => {
       expect(actions.actionCreatorWithGetState())
         .withState({ property: 'value' })
         .toDispatchActions(actions.actionWithGetState({ property: 'value' }), done);
     });
 
-    it('should accept function and setup getState', (done) => {
+    it('should accept function', (done) => {
       expect(actions.actionCreatorWithGetState())
         .withState(() => { return { property: 'value' };})
         .toDispatchActions(actions.actionWithGetState({ property: 'value' }), done);

test/should/index.js

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