Add should support for "not" statements

Author: dmitry-zaets

src/should.js

@@ -6,20 +6,41 @@ function withState(state) {
   this.obj = new ActionWithInitialState(this.obj, state);
 }
 
-function dispatchActions(expectedActions, done) {
+function dispatchActionsFunction(assert, assertWithState, expectedActions, done) {
   if (this.obj instanceof ActionWithInitialState) {
     const action = this.obj.action;
     const state = this.obj.state;
-    assertions.toDispatchActionsWithState(state, action, expectedActions, done);
+    assertWithState(state, action, expectedActions, done);
   } else {
-    assertions.toDispatchActions(this.obj, expectedActions, done);
+    assert(this.obj, expectedActions, done);
   }
 }
 
+function dispatchActions(expectedActions, done) {
+  dispatchActionsFunction.call(
+    this,
+    assertions.toDispatchActions,
+    assertions.toDispatchActionsWithState,
+    expectedActions,
+    done
+  );
+}
+
+function notDispatchActions(expectedActions, done) {
+  dispatchActionsFunction.call(
+    this,
+    assertions.toNotDispatchActions,
+    assertions.toNotDispatchActionsWithState,
+    expectedActions,
+    done
+  );
+}
+
 function registerAssertions() {
   should.Assertion.add('withState', withState);
   should.Assertion.alias('withState', 'state');
   should.Assertion.add('dispatchActions', dispatchActions);
+  should.Assertion.add('notDispatchActions', notDispatchActions);
 }
 
 export {

test/should/index.js

@@ -58,4 +58,29 @@ describe('should', () => {
         .dispatchActions(actions.expectedParentActions, done);
     });
   });
+
+  describe('.notDispatchActions', () => {
+    it('should accept single action', (done) => {
+      should(actions.start()).notDispatchActions(actions.anotherStart(), done);
+    });
+
+    it('should accept array with one action', (done) => {
+      should(actions.start()).notDispatchActions([actions.anotherStart()], done);
+    });
+
+    it('should accept array with multiple actions', (done) => {
+      should(actions.asyncActionCreator())
+        .notDispatchActions(actions.anotherExpectedActions, done);
+    });
+
+    it('should accept array with nested async action creators', (done) => {
+      should(actions.parentAsyncActionCreator())
+        .notDispatchActions(actions.anotherParentExpectedActions, done);
+    });
+
+    it('should work with .should', (done) => {
+      actions.parentAsyncActionCreator().should
+        .notDispatchActions(actions.anotherParentExpectedActions, done);
+    });
+  });
 });