Merge pull request #29 from launchdarkly/ag/ch10894/fix-promise-interface

[ch1089] Fix promise interface

Author: apucacao

src/__tests__/utils-test.js

@@ -0,0 +1,52 @@
+var assert = require('assert');
+var wrapPromiseCallback = require('../utils.js').wrapPromiseCallback;
+
+describe('utils', function() {
+  describe('wrapPromiseCallback', function() {
+    it('should resolve to the value', function(done) {
+      const promise = wrapPromiseCallback(Promise.resolve('woohoo'));
+      promise.then(function(value) {
+        expect(value).to.equal('woohoo');
+        done();
+      });
+    });
+  
+    it('should reject with the error', function(done) {
+      const error = new Error('something went wrong');
+      const promise = wrapPromiseCallback(Promise.reject(error));
+      promise.catch(function(error) {
+        expect(error).to.equal(error);
+        done();
+      });
+    });
+  
+    it('should call the callback with a value if the promise resolves', function(done) {
+      const callback = sinon.spy();
+      const promise = wrapPromiseCallback(Promise.resolve('woohoo'), callback);
+  
+      promise.then(function(result) {
+        expect(result).to.equal('woohoo');
+        // callback run on next tick to maintain asynchronous expections
+        setTimeout(function() {
+          expect(callback.calledWith(null, 'woohoo')).to.be.true;
+          done();
+        }, 0);
+      });
+    });
+  
+    it('should call the callback with an error if the promise rejects', function(done) {
+      const error = new Error('something went wrong');
+      const callback = sinon.spy();
+      const promise = wrapPromiseCallback(Promise.reject(error), callback);
+      
+      promise.catch(function(v) {
+        expect(v).to.equal(error);
+        // callback run on next tick to maintain asynchronous expections
+        setTimeout(function() {
+          expect(callback.calledWith(error, null)).to.be.true;
+          done();
+        }, 0);
+      });
+    });
+  });
+});

src/index.js

@@ -34,34 +34,6 @@ var flushInterval = 2000;
 
 var seenRequests = {};
 
-/**
- * Wrap a promise to invoke an optional callback upon resolution or rejection.
- *
- * This function assumes the callback follows the Node.js callback type: (err, value) => void
- *
- * If a callback is provided:
- *   - if the promise is resolved, invoke the callback with (null, value)
- *   - if the promise is rejected, invoke the callback with (error, null)
- *
- * @param {Promise<any>} promise
- * @param {Function} callback
- * @returns Promise<any>
- */
-function wrapPromiseCallback(promise, callback) {
-  if (callback) {
-    return promise.then(
-      function(value) {
-        setTimeout(function() { callback(null, value); }, 0);
-      },
-      function(error) {
-        setTimeout(function() { callback(error, null); }, 0);
-      }
-    );
-  }
-
-  return promise;
-}
-
 function sendIdentifyEvent(user) {
   enqueueEvent({
     kind: 'identify',
@@ -116,7 +88,7 @@ function waitUntilReady() {
 }
 
 function identify(user, hash, onDone) {
-  return wrapPromiseCallback(new Promise((function(resolve, reject) {
+  return utils.wrapPromiseCallback(new Promise((function(resolve, reject) {
     ident.setUser(user);
     requestor.fetchFlagSettings(ident.getUser(), hash, function(err, settings) {
       if (err) {

src/utils.js

@@ -55,10 +55,41 @@ function merge(target, varArgs) { // .length of function is 2
   return to;
 }
 
+/**
+ * Wrap a promise to invoke an optional callback upon resolution or rejection.
+ * 
+ * This function assumes the callback follows the Node.js callback type: (err, value) => void
+ * 
+ * If a callback is provided:
+ *   - if the promise is resolved, invoke the callback with (null, value)
+ *   - if the promise is rejected, invoke the callback with (error, null)
+ * 
+ * @param {Promise<any>} promise 
+ * @param {Function} callback 
+ * @returns Promise<any>
+ */
+function wrapPromiseCallback(promise, callback) {
+  return promise.then(
+    function(value) {
+      if (callback) {
+        setTimeout(function() { callback(null, value); }, 0);
+      }
+      return value;
+    },
+    function(error) {
+      if (callback) {
+        setTimeout(function() { callback(error, null); }, 0);
+      }
+      return Promise.reject(error);
+    }
+  );
+}
+
 module.exports = {
   btoa: btoa,
   base64URLEncode: base64URLEncode,
   clone: clone,
   modifications: modifications,
-  merge: merge
+  merge: merge,
+  wrapPromiseCallback: wrapPromiseCallback
 };