Update the async assertions. Removed outdated docs and tests (to be rewritten).

Author: amasad

jquery.expect.js

@@ -279,6 +279,7 @@
   }
 
   AssertionError.prototype = new Error();
+  AssertionError.prototype.constructor = AssertionError;
 
   global.$expect = $expect;
   $expect.Assertion = Assertion;
@@ -299,7 +300,7 @@
     if ($.isFunction(msg)) {
       error = msg = msg.call(this, !ok);
     }
-	
+  
     msg = this.flags.not ? error : msg;
 
     if (!ok) {
@@ -392,7 +393,7 @@
         return $.inArray(el, b) > -1 ? true : null;
       }).length === a.length;
     };
-	
+  
     // Arrays are equal if every element in this.obj 
     // appears in $el, and vice-versa.
     var eq = injSurj(this.obj, $el) && injSurj($el, this.obj);
@@ -825,13 +826,23 @@
   };
 
   /**
-   * Async testing signals. Meant to be overridden.
+   * Async testing signals.
    * 
-   * @param {String} evt
-   * @param {Deferred} dfd
+   * @param {String} event
+   * @param {Deferred} deferred
    */
-  Assertion.asyncWait = function (/*evt, dfd*/) {};
-  Assertion.asyncDone = function (/*evt, dfd*/) {};
+  function DeferredSignal (deferred, event, args) {
+    this.deferred = deferred;
+    this.event = event;
+    this.args = args;
+  }
+
+  DeferredSignal.prototype = new Error();
+  $expect.DeferredSignal = DeferredSignal;
+
+  function signal (deferred, event /* args... */) {
+    throw new DeferredSignal(deferred, event, [].slice.call(arguments, 2));
+  }
 
   /**
    * Attaches a *once* callback to an event.
@@ -856,13 +867,11 @@
           } catch (e) {
             dfd.rejectWith(obj, [e, ret]);
           }
-
-          Assertion.asyncDone(evt, dfd);
           return ret;
         };
 
     this.obj.on(evt, callback);
-    Assertion.asyncWait(evt, dfd);
+    return signal(dfd, evt, String(i(this.obj)));
   };
 
   /**
@@ -880,11 +889,37 @@
       } catch (e) {
         dfd.reject(e);
       }
-      Assertion.asyncDone(null, dfd);
     }, delay);
-    Assertion.asyncWait(null, dfd);
+
+    return signal(dfd, 'wait', delay);
    };
 
+   /**
+    * Wait for a callback to call our done callback to reject or resolve a
+    * deferred with a string that would be made an assertion error.
+    * @api public
+    * @param {Function} cb
+    */
+   $expect.async = function (cb) {
+     var dfd = $.Deferred();
+     var done = function (res) {
+      if (res) {
+        var err = new AssertionError(String(res));
+        dfd.reject(err);
+      } else {
+        dfd.resolve();
+      }
+    };
+    setTimeout(function () {
+      try {
+        cb(done);
+      } catch (e) {
+        dfd.reject(e);
+      }
+    }, 0);
+    return signal(dfd, 'async');
+  };
+
   /**
    * Shorthand methods for event binding. Just like jQuery!
    *
@@ -938,4 +973,4 @@
           };
         });
 
-})(this);
+})(this);

readme.md

@@ -211,47 +211,6 @@ $expect('div.container').to.have.siblings('.pane').that.has.css('float', 'left')
 				   end().to.be('.loading');
 ```
 
-### Testing events
-$expect defines two static methods on its exposed `Assertion` class that works as asynchronous signals  
-for testing events:  
-
- * `asyncWait`: is called when we start waiting for an async event to happen. Called with two arguments   
-                a) event type string b) a deferred object that is resolved when the event is fired.
- * `asyncDone`: is called when the event is fired and passed a) event type string b) a deferred object  
-                that is either rejected with the an error if the async callback threw one or resolved  
-                with the return value from it.  
-
-
-```javascript
-it('should test for setting the navigation to position fixed after scrolling the page'
-  , function (next) {
-		  // Assign the fail and pass handlers of the deferred object to be the mocha next function.
-		  // Incase of an error it would be passed and caught by mocha.
-		  $expect.Assertion.asyncWait = function (evt, dfd) {
-		    dfd.then(next, next);
-		  };
-		
-		  // Called after the event has fired. 
-		  $expect.Assertion.asyncDone = function (evt, dfd) 
-		    // Here we are using the expect.js library to check the state of the deferred object.
-		    // If everything went as expected it should be resolved.
-		    expect(dfd.state()).to.be('resolved');
-		  };
-		
-		  // The actual call to the async event. Expect the window to scroll.
-		  // And when that happens expect the nav-bar to become position fixed.
-		  $expect(window).to.scroll(function () {
-		    $expect('.nav-bar').to.have.css('position', 'fixed');
-		  });
-		
-		  // Now emulate the actual scrolling.
-		  setTimeout(function () {
-		    $(window).scrollTop(500);
-		  }, 100);
-	}
-);
-```     
-
 ## License
 MIT License.  
 Copyright (c) 2012 Amjad Masad <amjad@codecademy.com> Ryzac, Inc.

test/test.js

@@ -315,36 +315,36 @@ describe('$expect', function () {
     }, 'bar the foo');
   });
 
-  it('should test event tests', function (n) {
-    var s = 0;
-    $(window).on('scroll.once', function () {
-      $(window).off('scroll.once');
-      $('body').append('<div class="after-scroll" />');
-      $(window).scrollTop(s);
-    });
-
-    $expect.Assertion.asyncWait = function (evt, dfd) {
-      dfd.then(n, n);
-    };
-
-    $expect.Assertion.asyncDone = function (evt, dfd) {
-      expect(dfd.state()).to.be('resolved');
-    };
-
-    $expect(window).to.scroll(function () {
-      $expect('body').to.have('.after-scroll');
-
-      err(function () {
-        // Old api. contain used to alias find.
-        $expect('body').to.contain('.after-scroll');
-      }, 'expected body to contain ".after-scroll"');
-    });
-
-    setTimeout(function () {
-      s = $(window).scrollTop();
-      $(window).scrollTop(500);
-    });
-  });
+  // it('should test event tests', function (n) {
+  //   var s = 0;
+  //   $(window).on('scroll.once', function () {
+  //     $(window).off('scroll.once');
+  //     $('body').append('<div class="after-scroll" />');
+  //     $(window).scrollTop(s);
+  //   });
+
+  //   $expect.Assertion.asyncWait = function (evt, dfd) {
+  //     dfd.then(n, n);
+  //   };
+
+  //   $expect.Assertion.asyncDone = function (evt, dfd) {
+  //     expect(dfd.state()).to.be('resolved');
+  //   };
+
+  //   $expect(window).to.scroll(function () {
+  //     $expect('body').to.have('.after-scroll');
+
+  //     err(function () {
+  //       // Old api. contain used to alias find.
+  //       $expect('body').to.contain('.after-scroll');
+  //     }, 'expected body to contain ".after-scroll"');
+  //   });
+
+  //   setTimeout(function () {
+  //     s = $(window).scrollTop();
+  //     $(window).scrollTop(500);
+  //   });
+  // });
 
   it('should test for a', function () {
     $expect('div').to.be.a('div');
@@ -413,33 +413,33 @@ describe('$expect', function () {
     }, 'foo bar error');
   });
 
-  it('should test wait', function (next) {
-    $expect.Assertion.asyncWait = function (evt, dfd) {
-      dfd.then(next, next);
-    };
-
-    $expect.Assertion.asyncDone = function (evt, dfd) {
-      expect(dfd.state()).to.be('resolved');
-    };
-
-    $expect.wait(200, function () {
-      // noop
-    });
-  });
-
-  it('should test wait with a callback throwing an error', function (next) {
-    $expect.Assertion.asyncWait = function (evt, dfd) {
-      dfd.then(function () {}, function () {next();});
-    };
-
-    $expect.Assertion.asyncDone = function (evt, dfd) {
-      expect(dfd.state()).to.be('rejected');
-    };
-
-    $expect.wait(200, function () {
-      foobar;
-    });
-  });
+  // it('should test wait', function (next) {
+  //   $expect.Assertion.asyncWait = function (evt, dfd) {
+  //     dfd.then(next, next);
+  //   };
+
+  //   $expect.Assertion.asyncDone = function (evt, dfd) {
+  //     expect(dfd.state()).to.be('resolved');
+  //   };
+
+  //   $expect.wait(200, function () {
+  //     // noop
+  //   });
+  // });
+
+  // it('should test wait with a callback throwing an error', function (next) {
+  //   $expect.Assertion.asyncWait = function (evt, dfd) {
+  //     dfd.then(function () {}, function () {next();});
+  //   };
+
+  //   $expect.Assertion.asyncDone = function (evt, dfd) {
+  //     expect(dfd.state()).to.be('rejected');
+  //   };
+
+  //   $expect.wait(200, function () {
+  //     foobar;
+  //   });
+  // });
 
   it('should correctly test shorthand border-radius', function () {
     $expect('.radius').to.have.css('border-radius', '10px');