common: allow promises to resolve with a single arg

packages/common/src/util.js

@@ -687,13 +687,18 @@ util.getUserAgentFromPackageJson = getUserAgentFromPackageJson;
  * Wraps a callback style function to conditionally return a promise.
  *
  * @param {function} originalMethod - The method to promisify.
+ * @param {object=} options - Promise options.
+ * @param {boolean} options.singular - Resolve the promise with single arg
+ *     instead of an array.
  * @return {function} wrapped
  */
-function promisify(originalMethod) {
+function promisify(originalMethod, options) {
   if (originalMethod.promisified_) {
     return originalMethod;
   }
 
+  options = options || {};
+
   var slice = Array.prototype.slice;
 
   var wrapper = function() {
@@ -723,7 +728,11 @@ function promisify(originalMethod) {
           return reject(err);
         }
 
-        resolve(callbackArgs);
+        if (options.singular && callbackArgs.length === 1) {
+          resolve(callbackArgs[0]);
+        } else {
+          resolve(callbackArgs);
+        }
       });
 
       originalMethod.apply(context, args);
@@ -758,7 +767,7 @@ function promisifyAll(Class, options) {
     var originalMethod = Class.prototype[methodName];
 
     if (!originalMethod.promisified_) {
-      Class.prototype[methodName] = util.promisify(originalMethod);
+      Class.prototype[methodName] = util.promisify(originalMethod, options);
     }
   });
 }

packages/common/test/util.js

@@ -1578,6 +1578,25 @@ describe('common/util', function() {
       assert(FakeClass2.prototype.method.promisified_);
     });
 
+    it('should pass the options object to promisify', function(done) {
+      var promisify = util.promisify;
+      var fakeOptions = {
+        a: 'a'
+      };
+
+      util.promisify = function(method, options) {
+        assert.strictEqual(method, FakeClass2.prototype.method);
+        assert.strictEqual(options, fakeOptions);
+        util.promisify = promisify;
+        done();
+      };
+
+      function FakeClass2() {}
+      FakeClass2.prototype.method = function() {};
+
+      util.promisifyAll(FakeClass2, fakeOptions);
+    });
+
     it('should not re-promisify methods', function() {
       var method = FakeClass.prototype.methodName;
 
@@ -1643,5 +1662,33 @@ describe('common/util', function() {
 
       assert(promise instanceof FakePromise);
     });
+
+    it('should resolve singular arguments', function() {
+      var fakeArg = 'hi';
+
+      func = util.promisify(function(callback) {
+        callback.apply(this, [null, fakeArg]);
+      }, {
+        singular: true
+      });
+
+      return func().then(function(arg) {
+        assert.strictEqual(arg, fakeArg);
+      });
+    });
+
+    it('should ignore singular when multiple args are present', function() {
+      var fakeArgs = ['a', 'b'];
+
+      func = util.promisify(function(callback) {
+        callback.apply(this, [null].concat(fakeArgs));
+      }, {
+        singular: true
+      });
+
+      return func().then(function(args) {
+        assert.deepEqual(args, fakeArgs);
+      });
+    });
   });
 });