Made callsArg, returnsArg, and throwsArg more strict

lib/sinon/behavior.js

@@ -66,8 +66,24 @@ function getCallbackError(behavior, func, args) {
     return "argument at index " + behavior.callArgAt + " is not a function: " + func;
 }
 
+function ensureArgs(name, behavior, args) {
+    // map function name to internal property
+    //   callsArg => callArgAt
+    var property = name.replace(/sArg/, "ArgAt");
+    var index = behavior[property];
+
+    if (index >= args.length) {
+        throw new TypeError(
+            name + " failed: " + (index + 1)
+            + " arguments required but only " + args.length
+            + " present"
+        );
+    }
+}
+
 function callCallback(behavior, args) {
     if (typeof behavior.callArgAt === "number") {
+        ensureArgs("callsArg", behavior, args);
         var func = getCallback(behavior, args);
 
         if (typeof func !== "function") {
@@ -115,6 +131,12 @@ var proto = {
     },
 
     invoke: function invoke(context, args) {
+        /*
+         * callCallback (conditionally) calls ensureArgs
+         *
+         * Note: callCallback intentionally happens before
+         * everything else and cannot be moved lower
+         */
         var returnValue = callCallback(this, args);
 
         if (this.exception) {
@@ -124,29 +146,17 @@ var proto = {
             this.exceptionCreator = undefined;
             throw this.exception;
         } else if (typeof this.returnArgAt === "number") {
+            ensureArgs("returnsArg", this, args);
             return args[this.returnArgAt];
         } else if (this.returnThis) {
             return context;
         } else if (typeof this.throwArgAt === "number") {
-            if (args.length < this.throwArgAt) {
-                throw new TypeError(
-                    "throwArgs failed: " + this.throwArgAt
-                    + " arguments required but only " + args.length
-                    + " present"
-                );
-            }
+            ensureArgs("throwsArg", this, args);
             throw args[this.throwArgAt];
         } else if (this.fakeFn) {
             return this.fakeFn.apply(context, args);
         } else if (typeof this.resolveArgAt === "number") {
-            var len = this.resolveArgAt + 1;
-            if (args.length < len) {
-                throw new TypeError(
-                    "resolvesArg failed: " + len
-                    + " arguments required but only " + args.length
-                    + " present"
-                );
-            }
+            ensureArgs("resolvesArg", this, args);
             return (this.promiseLibrary || Promise).resolve(args[this.resolveArgAt]);
         } else if (this.resolveThis) {
             return (this.promiseLibrary || Promise).resolve(context);

test/stub-test.js

@@ -445,6 +445,21 @@ describe("stub", function () {
                 stub.returnsArg();
             }, {name: "TypeError"});
         });
+
+        it("should throw without enough arguments", function () {
+            var stub = createStub.create();
+            stub.returnsArg(3);
+
+            assert.exception(
+                function () {
+                    stub("only", "two arguments");
+                },
+                {
+                    name: "TypeError",
+                    message: "returnsArg failed: 4 arguments required but only 2 present"
+                }
+            );
+        });
     });
 
     describe(".throwsArg", function () {
@@ -482,14 +497,11 @@ describe("stub", function () {
                 function () {
                     stub("only", "two arguments");
                 },
-                function (error) {
-                    return error instanceof TypeError
-                        && error.message ===
-                        "throwArgs failed: 3 arguments required but only 2 present"
-                    ;
+                {
+                    name: "TypeError",
+                    message: "throwsArg failed: 4 arguments required but only 2 present"
                 }
             );
-
         });
 
         it("should work with call-based behavior", function () {
@@ -793,6 +805,21 @@ describe("stub", function () {
             }, {name: "TypeError"});
         });
 
+        it("should throw without enough arguments", function () {
+            var stub = createStub.create();
+            stub.callsArg(3);
+
+            assert.exception(
+                function () {
+                    stub("only", "two arguments");
+                },
+                {
+                    name: "TypeError",
+                    message: "callsArg failed: 4 arguments required but only 2 present"
+                }
+            );
+        });
+
         it("returns result of invocant", function () {
             var stub = this.stub.callsArg(0);
             var callback = createStub().returns("return value");