Promises (first look)

Thread dropdown
Small fixes

vendors/Q/spec/lib/jasmine-promise.js

@@ -0,0 +1,91 @@
+"use strict";
+
+/**
+ * Modifies the way that individual specs are run to easily test async
+ * code with promises.
+ *
+ * A spec may return a promise. If it does, then the spec passes if and
+ * only if that promise is fulfilled within a very short period of time.
+ * If it is rejected, or if it isn't fulfilled quickly, the spec fails.
+ *
+ * In this way, we can use promise chaining to structure our asynchronous
+ * tests. Expectations all down the chain of promises are all checked and
+ * guaranteed to be run and resolved or the test fails.
+ *
+ * This is a big win over the runs() and watches() code that jasmine
+ * supports out of the box.
+ */
+jasmine.Block.prototype.execute = function (onComplete) {
+    var spec = this.spec;
+    try {
+        var result = this.func.call(spec, onComplete);
+
+        // It seems Jasmine likes to return the suite if you pass it anything.
+        // So make sure it's a promise first.
+        if (result && typeof result.then === "function") {
+            Q.timeout(result, 500).then(function () {
+                onComplete();
+            }, function (error) {
+                spec.fail(error);
+                onComplete();
+            });
+        } else if (this.func.length === 0) {
+            onComplete();
+        }
+    } catch (error) {
+        spec.fail(error);
+        onComplete();
+    }
+};
+
+/**
+ * Tests and documents the behavior of the above extension to jasmine.
+ */
+describe('jasmine-promise', function() {
+  it('passes if the deferred resolves immediately', function() {
+    var deferred = Q.defer();
+    deferred.resolve();
+    return deferred.promise;
+  });
+  it('passes if the deferred resolves after a short delay', function() {
+    var deferred = Q.defer();
+    setTimeout(function() {deferred.resolve();}, 100);
+    return deferred.promise;
+  });
+  it('lets specs that return nothing pass', function() {
+
+  });
+  it('lets specs that return non-promises pass', function() {
+    return {'some object': 'with values'};
+  });
+  it('works ok with specs that return crappy non-Q promises', function() {
+    return {
+      'then': function(callback) {
+        callback();
+      }
+    }
+  });
+  // These are expected to fail. Remove the x from xdescribe to test that.
+  xdescribe('failure cases (expected to fail)', function() {
+    it('fails if the deferred is rejected', function() {
+      var deferred = Q.defer();
+      deferred.reject();
+      return deferred.promise;
+    });
+    it('fails if the deferred takes too long to resolve', function() {
+      var deferred = Q.defer();
+      setTimeout(function() {deferred.resolve()}, 5 * 1000);
+      return deferred.promise;
+    });
+    it('fails if a returned crappy non-Q promise is rejected', function() {
+      return {
+        'then': function(_, callback) {callback()}
+      }
+    });
+    it('fails if a returned crappy promise is never resolved', function() {
+      return {
+        'then': function() {}
+      }
+    });
+  })
+});