Server Request Tests and Mock Promise Enhancements

chrome/browser/resources/google_now/common_test_util.js

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Common test utilities.
 
 /**
  * Allows console.log output.
  */
 var showConsoleLogOutput = false;
@@ skipping 63 matching lines @@
 
 /**
  * MockPromise
  * The JS test harness expects all calls to complete synchronously.
  * As a result, we can't use built-in JS promises since they run asynchronously.
  * Instead of mocking all possible calls to promises, a skeleton
  * implementation is provided to get the tests to pass.
  */
 var Promise = function() {
   function PromisePrototypeObject(asyncTask) {
-    var result;
-    var resolved = false;
-    asyncTask(
-        function(asyncResult) {
-          result = asyncResult;
-          resolved = true;
-        },
-        function(asyncFailureResult) {
-          result = asyncFailureResult;
-          resolved = false;
-        });
+    function isThenable(value) {
+      return (typeof value === 'object') && isCallable(value.then);
+    }
 
-    function then(callback) {
-      if (resolved) {
-        callback.call(null, result);
+    function isCallable(value) {
+      return typeof value === 'function';
+    }
+
+    function callResolveRejectFunc(func) {
+      var funcResult;
+      var funcResolved = false;
+      func(
+          function(resolveResult) {
+            funcResult = resolveResult;
+            funcResolved = true;
+          },
+          function(rejectResult) {
+            funcResult = rejectResult;
+            funcResolved = false;
+          });
+      return { result: funcResult, resolved: funcResolved };
+    }
+
+    function then(onResolve, onReject) {
+      var resolutionHandler =
+          isCallable(onResolve) ? onResolve : function() { return result; };
+      var rejectionHandler =
+          isCallable(onReject) ? onReject : function() { return result; };
+      var handlerResult =
+          resolved ? resolutionHandler(result) : rejectionHandler(result);
+      var promiseResolved = resolved;
+      if (isThenable(handlerResult)) {
+        var resolveReject = callResolveRejectFunc(handlerResult.then);
+        handlerResult = resolveReject.result;
+        promiseResolved = resolveReject.resolved;
       }
-      return this;
+
+      if (promiseResolved) {
+        return Promise.resolve(handlerResult);
+      } else {
+        return Promise.reject(handlerResult);
+      }
     }
 
     // Promises use the function name "catch" to call back error handlers.
     // We can't use "catch" since function or variable names cannot use the word
     // "catch".
-    function catchFunc(callback) {
-      if (!resolved) {
-        callback.call(null, result);
-      }
-      return this;
+    function catchFunc(onRejected) {
+      return this.then(undefined, onRejected);
+    }
+
+    var resolveReject = callResolveRejectFunc(asyncTask);
+    var result = resolveReject.result;
+    var resolved = resolveReject.resolved;
+
+    if (isThenable(result)) {

[rgustafson, 2014/03/19 00:24:31]

I don't quite understand why this is here (and above). I'm guessing that you've
run these tests and they work, but this is a pretty hard read.

[robliao, 2014/03/19 00:43:39]

This code is indeed crazy. This implementation is adapted from the ECMAScript 6
spec
(http://wiki.ecmascript.org/lib/exe/fetch.php?id=harmony%3Aspecification_draft...)
with me adding synchronicity to it.

The craziness stems from Section 25.4.1.8 - UpdatePromiseFromPotentialThenable,
which is used during reaction and resolution.

Page 490 (PDF Page 508, Section 25.4) discusses Promises in all its detail.
On 2014/03/19 00:24:31, rgustafson wrote:

[rgustafson, 2014/03/19 23:02:25]

I'll take your word on this since that's just taking a small part of a more
complex larger spec. Maybe consider linking to that in comment for the whole
promise implementation, so some future person having to edit this has some idea
what's happening?

[robliao, 2014/03/19 23:34:39]

Links will change, so I've added a comment about this on the top.
On 2014/03/19 23:02:25, rgustafson wrote:

+      var thenResolveReject = callResolveRejectFunc(result.then);
+      result = thenResolveReject.result;
+      resolved = thenResolveReject.resolved;
     }
 
     return {then: then, catch: catchFunc, isPromise: true};
   }
 
   function all(arrayOfPromises) {
     var results = [];
     for (i = 0; i < arrayOfPromises.length; i++) {
       if (arrayOfPromises[i].isPromise) {
         arrayOfPromises[i].then(function(result) {
           results[i] = result;
         });
       } else {
         results[i] = arrayOfPromises[i];
       }
     }
     var promise = new PromisePrototypeObject(function(resolve) {
       resolve(results);
     });
     return promise;
   }
 
   function resolve(value) {
     var promise = new PromisePrototypeObject(function(resolve) {
       resolve(value);
     });
     return promise;
   }
 
+  function reject(value) {
+    var promise = new PromisePrototypeObject(function(resolve, reject) {
+      reject(value);
+    });
+    return promise;
+  }
+
   PromisePrototypeObject.all = all;
   PromisePrototypeObject.resolve = resolve;

[skare_, 2014/03/19 23:20:23]

this is in the scope of a prior cl, so maybe I/we asked earlier :)

can these be placed inside the class definition above and then returned
alongside then/catch/isPromise?

[robliao, 2014/03/19 23:34:39]

What do you mean?

Are you asking for direct declarations like this?
PromisePrototypeObject.prototype.all = function(arrayOfPromises) {...}
On 2014/03/19 23:20:23, Travis Skare wrote:

[skare_, 2014/03/20 00:27:27]

moving all the callable functions/'api' to one place: 
return {then: then, ..., all: all}
and moving functions if necessary, though I don't think that's needed since they
should be in the closure.

but I'm not sure it's a net readability gain, so it was pre-lgtm'ed


On 2014/03/19 23:34:39, robliao wrote:

[robliao, 2014/03/20 00:31:55]

Ah. That wouldn't work. We actually need a constructor for this.
new Promise(...) is used by the code, which is why you see this sort of
initialization.

then, catch, and isPromise require instances. all, resolve, and reject are
"statics" and do not exist off of the global Promise object.

On 2014/03/20 00:27:27, Travis Skare wrote:

[robliao, 2014/03/20 00:32:49]

s/do not exist/exist/
On 2014/03/20 00:31:55, robliao wrote:

+  PromisePrototypeObject.reject = reject;
   return PromisePrototypeObject;
 }();
 
-
 /**
  * Sets up the test to expect a Chrome Local Storage call.
  * @param {Object} fixture Mock JS Test Object.
  * @param {Object} defaultObject Storage request default object.
  * @param {Object} result Storage result.
  * @param {boolean=} opt_AllowRejection Allow Promise Rejection
  */
 function expectChromeLocalStorageGet(
     fixture, defaultObject, result, opt_AllowRejection) {
   if (opt_AllowRejection === undefined) {
     fixture.mockApis.expects(once()).
       fillFromChromeLocalStorage(eqJSON(defaultObject)).
       will(returnValue(Promise.resolve(result)));
   } else {
     fixture.mockApis.expects(once()).
       fillFromChromeLocalStorage(eqJSON(defaultObject), opt_AllowRejection).
       will(returnValue(Promise.resolve(result)));
   }
 }