Allow users to set a default spy strategy

spec/core/integration/DefaultSpyStrategySpec.js

@@ -0,0 +1,68 @@
+describe('Default Spy Strategy (Integration)', function() {
+  var env;
+
+  beforeEach(function() {
+    env = new jasmineUnderTest.Env();
+    env.configure({random: false});
+  });
+
+  it('allows defining a default spy strategy', function(done) {
+    env.describe('suite with default strategy', function() {
+      env.beforeEach(function() {
+        env.setDefaultSpyStrategy(function (and) {
+          and.returnValue(42);
+        });
+      });
+
+      env.it('spec in suite', function() {
+        var spy = env.createSpy('something');
+        expect(spy()).toBe(42);
+      });
+    });
+
+    env.it('spec not in suite', function() {
+      var spy = env.createSpy('something');
+      expect(spy()).toBeUndefined();
+    });
+
+    function jasmineDone(result) {
+      expect(result.overallStatus).toEqual('passed');
+      done();
+    }
+
+    env.addReporter({ jasmineDone: jasmineDone });
+    env.execute();
+  });
+
+  it('uses the default spy strategy defined when the spy is created', function (done) {
+    env.it('spec', function() {
+      var a = env.createSpy('a');
+      env.setDefaultSpyStrategy(function (and) { and.returnValue(42); });
+      var b = env.createSpy('b');
+      env.setDefaultSpyStrategy(function (and) { and.stub(); });
+      var c = env.createSpy('c');
+      env.setDefaultSpyStrategy();
+      var d = env.createSpy('d');
+
+      expect(a()).toBeUndefined();
+      expect(b()).toBe(42);
+      expect(c()).toBeUndefined();
+      expect(d()).toBeUndefined();
+
+      // Check our assumptions about which spies are "configured" (this matters because
+      // spies that use withArgs() behave differently if they are not configured).
+      expect(a.and.isConfigured()).toBe(false);
+      expect(b.and.isConfigured()).toBe(true);
+      expect(c.and.isConfigured()).toBe(true);
+      expect(d.and.isConfigured()).toBe(false);
+    });
+
+    function jasmineDone(result) {
+      expect(result.overallStatus).toEqual('passed');
+      done();
+    }
+
+    env.addReporter({ jasmineDone: jasmineDone });
+    env.execute();
+  });
+});

src/core/Env.js

@@ -208,6 +208,13 @@ getJasmineRequireObj().Env = function(j$) {
       }
     });
 
+    this.setDefaultSpyStrategy = function(defaultStrategyFn) {
+      if (!currentRunnable()) {
+        throw new Error('Default spy strategy must be set in a before function or a spec');
+      }
+      runnableResources[currentRunnable().id].defaultStrategyFn = defaultStrategyFn;
+    };
+
     this.addSpyStrategy = function(name, fn) {
       if (!currentRunnable()) {
         throw new Error(
@@ -286,7 +293,8 @@ getJasmineRequireObj().Env = function(j$) {
         spies: [],
         customEqualityTesters: [],
         customMatchers: {},
-        customSpyStrategies: {}
+        customSpyStrategies: {},
+        defaultStrategyFn: undefined
       };
 
       if (runnableResources[parentRunnableId]) {
@@ -296,6 +304,7 @@ getJasmineRequireObj().Env = function(j$) {
         resources.customMatchers = j$.util.clone(
           runnableResources[parentRunnableId].customMatchers
         );
+        resources.defaultStrategyFn = runnableResources[parentRunnableId].defaultStrategyFn;
       }
 
       runnableResources[id] = resources;
@@ -720,6 +729,15 @@ getJasmineRequireObj().Env = function(j$) {
 
         return {};
       },
+      function getDefaultStrategyFn() {
+        var runnable = currentRunnable();
+
+        if (runnable) {
+          return runnableResources[runnable.id].defaultStrategyFn;
+        }
+
+        return undefined;
+      },
       function getPromise() {
         return customPromise || global.Promise;
       }

src/core/Spy.js

@@ -12,7 +12,7 @@ getJasmineRequireObj().Spy = function(j$) {
    * @constructor
    * @name Spy
    */
-  function Spy(name, originalFn, customStrategies, getPromise) {
+  function Spy(name, originalFn, customStrategies, defaultStrategyFn, getPromise) {
     var numArgs = typeof originalFn === 'function' ? originalFn.length : 0,
       wrapper = makeFunc(numArgs, function() {
         return spy.apply(this, Array.prototype.slice.call(arguments));
@@ -127,6 +127,10 @@ getJasmineRequireObj().Spy = function(j$) {
     };
     wrapper.calls = callTracker;
 
+    if (defaultStrategyFn) {
+      defaultStrategyFn(wrapper.and);
+    }
+
     return wrapper;
   }
 

src/core/SpyFactory.js

@@ -1,9 +1,9 @@
 getJasmineRequireObj().SpyFactory = function(j$) {
-  function SpyFactory(getCustomStrategies, getPromise) {
+  function SpyFactory(getCustomStrategies, getDefaultStrategyFn, getPromise) {
     var self = this;
 
     this.createSpy = function(name, originalFn) {
-      return j$.Spy(name, originalFn, getCustomStrategies(), getPromise);
+      return j$.Spy(name, originalFn, getCustomStrategies(), getDefaultStrategyFn(), getPromise);
     };
 
     this.createSpyObj = function(baseName, methodNames) {

src/core/requireInterface.js

@@ -330,5 +330,21 @@ getJasmineRequireObj().interface = function(jasmine, env) {
     return env.addSpyStrategy(name, factory);
   };
 
+  /**
+   * Set the default spy strategy for the current scope of specs.
+   *
+   * _Note:_ This is only callable from within a {@link beforeEach}, {@link it}, or {@link beforeAll}.
+   * @name jasmine.setDefaultSpyStrategy
+   * @function
+   * @param {Function} defaultStrategyFn - a function that assigns a strategy
+   * @example
+   * beforeEach(function() {
+   *   jasmine.setDefaultSpyStrategy(and => and.returnValue(true));
+   * });
+   */
+  jasmine.setDefaultSpyStrategy = function(defaultStrategyFn) {
+    return env.setDefaultSpyStrategy(defaultStrategyFn);
+  };
+
   return jasmineInterface;
 };