Get rid of implicit digest() (see #41)

Instead wrap each promise object so the resolved value or error is exposed on the promise

Author: ksperling

test/stateSpec.js

@@ -17,36 +17,40 @@ describe('state', function () {
       expect($state.$current).toBeDefined();
     }));
 
-    it('.$current wraps the raw state object', inject(function ($state) {
-      resolvedValue($state.transitionTo(A, {}));
+    it('.$current wraps the raw state object', inject(function ($state, $q) {
+      $state.transitionTo(A, {});
+      $q.flush();
       expect($state.$current.data).toBe(A.data); // 'data' is reserved for app use
     }));
 
-    it('.transitionTo() returns a promise for the target state', inject(function ($state) {
+    it('.transitionTo() returns a promise for the target state', inject(function ($state, $q) {
       var trans = $state.transitionTo(A, {});
+      $q.flush();
       expect(resolvedValue(trans)).toBe(A);
     }));
 
-    it('.current updates asynchronously as the transitionTo() promise is resolved', inject(function ($state) {
+    it('.current updates asynchronously as the transitionTo() promise is resolved', inject(function ($state, $q) {
       var trans = $state.transitionTo(A, {});
       expect($state.current).not.toBe(A);
-      resolvedValue(trans);
+      $q.flush();
       expect($state.current).toBe(A);
     }));
 
-    it('.$transition is always the current or last transition', inject(function ($state) {
+    it('.$transition is always the current or last transition', inject(function ($state, $q) {
       expect($state.$transition).toBeDefined();
+      $q.flush();
       expect(resolvedValue($state.$transition)).toBe($state.current);
       var trans = $state.transitionTo(A, {});
       expect($state.$transition).toBeDefined();
       expect($state.$transition).toBe(trans);
-      resolvedValue(trans);
+      $q.flush();
       expect($state.$transition).toBe(trans);
     }));
 
-    it('.transition is null when no transition is taking place', inject(function ($state) {
+    it('.transition is null when no transition is taking place', inject(function ($state, $q) {
       expect($state.transition).toBeNull();
-      resolvedValue($state.transitionTo(A, {}));
+      $state.transitionTo(A, {});
+      $q.flush();
       expect($state.transition).toBeNull();
     }));
   });

test/testUtils.js

@@ -1,26 +1,67 @@
-function resolvePromise(promise) {
-  if (!promise.then) throw new Error('Expected a promise, but got ' + jasmine.pp(promise) + '.');
-  
-  var result;
-  promise.then(function (value) {
-    result = { success: true, value: value };
-  }, function (error) {
-    result = { success: false, error: error };
+angular.module('ngMock')
+  .config(function ($provide) {
+    $provide.decorator('$q', function ($delegate, $rootScope) {
+      $delegate.flush = function() {
+        $rootScope.$digest();
+      };
+
+      // Add callbacks to the promise that expose the resolved value/error
+      function expose(promise) {
+        // Don't add hooks to the same promise twice (shouldn't happen anyway)
+        if (!promise.hasOwnProperty('$$resolved')) {
+          promise.$$resolved = false;
+          promise.then(function (value) {
+            promise.$$resolved = { success: true, value: value };
+          }, function (error) {
+            promise.$$resolved = { success: false, error: error };
+          });
+
+          // We need to expose() any then()ed promises recursively
+          var qThen = promise.then;
+          promise.then = function () {
+            return expose(qThen.apply(this, arguments));
+          };
+        }
+        return promise;
+      }
+
+      // Wrap functions that return a promise
+      angular.forEach([ 'when', 'all', 'reject'], function (name) {
+        var qFunc = $delegate[name];
+        $delegate[name] = function () {
+          return expose(qFunc.apply(this, arguments));
+        };
+      });
+
+      // Wrap defer()
+      var qDefer = $delegate.defer;
+      $delegate.defer = function () {
+        var deferred = qDefer();
+        expose(deferred.promise);
+        return deferred;
+      }
+
+      return $delegate;
+    });
   });
 
-  jasmine.getEnv().currentSpec.$injector.get('$rootScope').$digest();
-  if (!result) throw new Error('Promise is still pending');
+
+function resolvedPromise(promise) {
+  if (!promise.then) throw new Error('Expected a promise, but got ' + jasmine.pp(promise) + '.');
+  var result = promise.$$resolved;
+  if (!isDefined(result)) throw new Error('Promise has not been augmented by ngMock');
+  if (!result) throw new Error('Promise is not resolved yet');
   return result;
 }
 
 function resolvedValue(promise) {
-  var result = resolvePromise(promise);
+  var result = resolvedPromise(promise);
   if (!result.success) throw result.error;
   return result.value;
 }
 
 function resolvedError(promise) {
-  var result = resolvePromise(promise);
+  var result = resolvedPromise(promise);
   if (result.success) throw new Error('Promise was expected to fail but returned ' + jasmin.pp(res.value) + '.');
   return result.error;
 }