Add chai support for "not" statements

Author: dmitry-zaets

src/chai.js

@@ -18,27 +18,46 @@ function registerAssertions() {
 
       const state = utils.flag(this, 'state');
       if (state) {
+        if (utils.flag(this, 'negate')) {
+          return assertions.toNotDispatchActionsWithState(state, this._obj, expectedActions, done);
+        }
         return assertions.toDispatchActionsWithState(state, this._obj, expectedActions, done);
       }
+      if (utils.flag(this, 'negate')) {
+        return assertions.toNotDispatchActions(this._obj, expectedActions, done);
+      }
       return assertions.toDispatchActions(this._obj, expectedActions, done);
     }
 
+    function isDispatching(actualAction, expectedActions, done) {
+      new _chai.Assertion(actualAction)
+        .to.dispatch.actions(expectedActions, done);
+    }
+
     function isDispatchingWithState(actualAction, expectedActions, state, done) {
       new _chai.Assertion(actualAction)
         .with.state(state)
         .to.dispatch.actions(expectedActions, done);
     }
 
-    function isDispatching(actualAction, expectedActions, done) {
+    function isNotDispatching(actualAction, expectedActions, done) {
       new _chai.Assertion(actualAction)
-        .to.dispatch.actions(expectedActions, done);
+        .to.not.dispatch.actions(expectedActions, done);
+    }
+
+    function isNotDispatchingWithState(actualAction, expectedActions, state, done) {
+      new _chai.Assertion(actualAction)
+        .with.state(state)
+        .to.not.dispatch.actions(expectedActions, done);
     }
 
     _chai.Assertion.addChainableMethod('state', stateMethod);
     _chai.Assertion.addProperty('dispatch', dispatchProperty);
     _chai.Assertion.addMethod('actions', dispatchActionsMethod);
     _chai.assert.isDispatching = isDispatching;
     _chai.assert.isDispatchingWithState = isDispatchingWithState;
+    _chai.assert.isNotDispatching = isNotDispatching;
+    _chai.assert.isNotDispatchingWithState = isNotDispatchingWithState;
   });
 }
 

test/chai/index.js

@@ -45,6 +45,28 @@ describe('chai', () => {
           .to.dispatch.actions(actions.expectedParentActions, done);
       });
     });
+
+    describe('.not.dispatch.actions', () => {
+      it('should accept single action', (done) => {
+        expect(actions.start())
+          .to.not.dispatch.actions(actions.anotherStart(), done);
+      });
+
+      it('should accept array with one action', (done) => {
+        expect(actions.start())
+          .to.not.dispatch.actions([actions.anotherStart()], done);
+      });
+
+      it('should accept array with multiple actions', (done) => {
+        expect(actions.asyncActionCreator())
+          .to.not.dispatch.actions(actions.anotherExpectedActions, done);
+      });
+
+      it('should accept array with nested async action creators', (done) => {
+        expect(actions.parentAsyncActionCreator())
+          .to.not.dispatch.actions(actions.anotherParentExpectedActions, done);
+      });
+    });
   });
 
   describe('should', () => {
@@ -83,6 +105,28 @@ describe('chai', () => {
           .dispatch.actions(actions.expectedParentActions, done);
       });
     });
+
+    describe('.not.dispath.actions', () => {
+      it('should accept single action', (done) => {
+        actions.start().should
+          .not.dispatch.actions(actions.anotherStart(), done);
+      });
+
+      it('should accept array with one action', (done) => {
+        actions.start().should
+          .not.dispatch.actions([actions.anotherStart()], done);
+      });
+
+      it('should accept array with multiple actions', (done) => {
+        actions.asyncActionCreator().should
+          .not.dispatch.actions(actions.anotherExpectedActions, done);
+      });
+
+      it('should accept array with nested async action creators', (done) => {
+        actions.parentAsyncActionCreator().should
+          .not.dispatch.actions(actions.anotherParentExpectedActions, done);
+      });
+    });
   });
 
   describe('assert', () => {
@@ -106,6 +150,26 @@ describe('chai', () => {
       });
     });
 
+    describe('isNotDispatchingWithState', () => {
+      it('should accept object as third argument', (done) => {
+        assert.isNotDispatchingWithState(
+          actions.actionCreatorWithGetState(),
+          actions.actionWithGetState({ property: 'anotherParentAsyncActionCreator' }),
+          { property: 'value' },
+          done
+        );
+      });
+
+      it('should accept function as third argument', (done) => {
+        assert.isNotDispatchingWithState(
+          actions.actionCreatorWithGetState(),
+          actions.actionWithGetState({ property: 'anotherValue' }),
+          () => { return { property: 'value' }; },
+          done
+        );
+      });
+    });
+
     describe('isDispatching', () => {
       it('should accept single action', (done) => {
         assert.isDispatching(
@@ -139,5 +203,39 @@ describe('chai', () => {
         );
       });
     });
+
+    describe('isNotDispatching', () => {
+      it('should accept single action', (done) => {
+        assert.isNotDispatching(
+          actions.start(),
+          actions.anotherStart(),
+          done
+        );
+      });
+
+      it('should accept array with one action', (done) => {
+        assert.isNotDispatching(
+          actions.start(),
+          [actions.anotherStart()],
+          done
+        );
+      });
+
+      it('should accept array with multiple actions', (done) => {
+        assert.isNotDispatching(
+          actions.asyncActionCreator(),
+          actions.anotherExpectedActions,
+          done
+        );
+      });
+
+      it('should accept array with nested async action creators', (done) => {
+        assert.isNotDispatching(
+          actions.parentAsyncActionCreator(),
+          actions.anotherParentExpectedActions,
+          done
+        );
+      });
+    });
   });
 });