syntax sugar for resolvesArg issue-1665

lib/sinon/behavior.js

@@ -107,6 +107,7 @@ var proto = {
                 this.exceptionCreator ||
                 typeof this.returnArgAt === "number" ||
                 this.returnThis ||
+                typeof this.resolveArgAt === "number" ||
                 this.resolveThis ||
                 typeof this.throwArgAt === "number" ||
                 this.fakeFn ||
@@ -137,6 +138,8 @@ var proto = {
             throw args[this.throwArgAt];
         } else if (this.fakeFn) {
             return this.fakeFn.apply(context, args);
+        } else if (typeof this.resolveArgAt === "number") {
+            return (this.promiseLibrary || Promise).resolve(args[this.resolveArgAt]);
         } else if (this.resolveThis) {
             return (this.promiseLibrary || Promise).resolve(context);
         } else if (this.resolve) {

lib/sinon/default-behaviors.js

@@ -165,6 +165,21 @@ module.exports = {
         fake.fakeFn = undefined;
     },
 
+    resolvesArg: function resolvesArg(fake, index) {
+        if (typeof index !== "number") {
+            throw new TypeError("argument index is not number");
+        }
+        fake.resolveArgAt = index;
+        fake.returnValue = undefined;
+        fake.resolve = true;
+        fake.resolveThis = false;
+        fake.reject = false;
+        fake.returnValueDefined = false;
+        fake.exception = undefined;
+        fake.exceptionCreator = undefined;
+        fake.fakeFn = undefined;
+    },
+
     rejects: function rejects(fake, error, message) {
         var reason;
         if (typeof error === "string") {

lib/sinon/stub.js

@@ -129,6 +129,7 @@ var proto = {
         delete this.returnValue;
         delete this.returnArgAt;
         delete this.throwArgAt;
+        delete this.resolveArgAt;
         delete this.fakeFn;
         this.returnThis = false;
         this.resolveThis = false;

test/stub-test.js

@@ -343,6 +343,64 @@ describe("stub", function () {
         });
     });
 
+    describe(".resolvesArg", function () {
+        afterEach(function () {
+            if (Promise.resolve.restore) {
+                Promise.resolve.restore();
+            }
+        });
+
+        it("returns a promise to the argument at specified index", function () {
+            var stub = createStub.create();
+            var object = {};
+            stub.resolvesArg(0);
+
+            return stub(object).then(function (actual) {
+                assert.same(actual, object);
+            });
+        });
+
+        it("returns a promise to the argument at another specified index", function () {
+            var stub = createStub.create();
+            var object = {};
+            stub.resolvesArg(2);
+
+            return stub("ignored", "ignored again", object).then(function (actual) {
+                assert.same(actual, object);
+            });
+        });
+
+        it("should return the same stub", function () {
+            var stub = createStub.create();
+
+            assert.same(stub.resolvesArg(1), stub);
+        });
+
+        it("supersedes previous throws", function () {
+            var stub = createStub.create();
+            stub.throws().resolvesArg(1);
+
+            refute.exception(function () {
+                stub();
+            });
+        });
+
+        it("supersedes previous rejects", function () {
+            var stub = createStub.create();
+            stub.rejects(Error("should be superseeded")).resolvesArg(1);
+
+            return stub().then();
+        });
+
+        it("does not invoke Promise.resolve when the behavior is added to the stub", function () {
+            var resolveSpy = createSpy(Promise, "resolve");
+            var stub = createStub.create();
+            stub.resolvesArg(2);
+
+            assert.equals(resolveSpy.callCount, 0);
+        });
+    });
+
     describe(".returnsArg", function () {
         it("returns argument at specified index", function () {
             var stub = createStub.create();