Allow adding custom spy strategies

[#37288941]

spec/core/SpyStrategySpec.js

@@ -110,6 +110,49 @@ describe("SpyStrategy", function() {
     })
   });
 
+  it("allows a custom strategy to be used", function() {
+    var customStrategy = jasmine.createSpy('custom strategy')
+        .and.returnValue('custom strategy result'),
+      factory = jasmine.createSpy('custom strategy factory')
+        .and.returnValue(customStrategy),
+      originalFn = jasmine.createSpy('original'),
+      spyStrategy = new jasmineUnderTest.SpyStrategy({
+        fn: originalFn,
+        customStrategies: {
+          doSomething: factory
+        }
+      });
+
+    spyStrategy.doSomething(1, 2, 3);
+    expect(factory).toHaveBeenCalledWith(1, 2, 3);
+    expect(spyStrategy.exec(null, ['some', 'args']))
+      .toEqual('custom strategy result');
+    expect(customStrategy).toHaveBeenCalledWith('some', 'args');
+  });
+
+  it("throws an error if a custom strategy doesn't return a function", function() {
+    var originalFn = jasmine.createSpy('original'),
+      spyStrategy = new jasmineUnderTest.SpyStrategy({
+        fn: originalFn,
+        customStrategies: {
+          doSomething: function() { return 'not a function' }
+        }
+      });
+
+    expect(function() { spyStrategy.doSomething(1, 2, 3) }).toThrowError('Spy strategy must return a function');
+  });
+
+  it("does not allow custom strategies to overwrite existing methods", function() {
+    var spyStrategy = new jasmineUnderTest.SpyStrategy({
+        fn: function() {},
+        customStrategies: {
+          exec: function() {}
+        }
+       });
+
+    expect(spyStrategy.exec).toBe(jasmineUnderTest.SpyStrategy.prototype.exec);
+  });
+
   it('throws an error when a non-function is passed to callFake strategy', function() {
     var originalFn = jasmine.createSpy('original'),
         spyStrategy = new jasmineUnderTest.SpyStrategy({fn: originalFn}),

spec/core/integration/CustomSpyStrategiesSpec.js

@@ -0,0 +1,98 @@
+describe('Custom Spy Strategies (Integration)', function() {
+  var env;
+
+  beforeEach(function() {
+    env = new jasmineUnderTest.Env();
+    env.randomizeTests(false);
+  });
+
+  it('allows adding more strategies local to a suite', function(done) {
+    var strategyInstance = jasmine.createSpy('custom strategy instance')
+      .and.returnValue(42);
+    var strategyFactory = jasmine.createSpy('custom strategy factory')
+      .and.returnValue(strategyInstance);
+
+    env.describe('suite defining a custom spy strategy', function() {
+      env.beforeEach(function() {
+        env.addSpyStrategy('frobnicate', strategyFactory);
+      });
+
+      env.it('spec in the suite', function() {
+        var spy = env.createSpy('something').and.frobnicate(17);
+        expect(spy(1, 2, 3)).toEqual(42);
+        expect(strategyFactory).toHaveBeenCalledWith(17);
+        expect(strategyInstance).toHaveBeenCalledWith(1, 2, 3);
+      });
+    });
+
+    env.it('spec without custom strategy defined', function() {
+      expect(env.createSpy('something').and.frobnicate).toBeUndefined();
+    });
+
+    function jasmineDone(result) {
+      expect(result.overallStatus).toEqual('passed');
+      done();
+    }
+
+    env.addReporter({ jasmineDone: jasmineDone });
+    env.execute();
+  });
+
+  it('allows adding more strategies local to a spec', function(done) {
+    var strategyInstance = jasmine.createSpy('custom strategy instance')
+      .and.returnValue(42);
+    var strategyFactory = jasmine.createSpy('custom strategy factory')
+      .and.returnValue(strategyInstance);
+
+    env.it('spec defining a custom spy strategy', function() {
+      env.addSpyStrategy('frobnicate', strategyFactory);
+      var spy = env.createSpy('something').and.frobnicate(17);
+      expect(spy(1, 2, 3)).toEqual(42);
+      expect(strategyFactory).toHaveBeenCalledWith(17);
+      expect(strategyInstance).toHaveBeenCalledWith(1, 2, 3);
+    });
+
+    env.it('spec without custom strategy defined', function() {
+      expect(env.createSpy('something').and.frobnicate).toBeUndefined();
+    });
+
+    function jasmineDone(result) {
+      expect(result.overallStatus).toEqual('passed');
+      done();
+    }
+
+    env.addReporter({ jasmineDone: jasmineDone });
+    env.execute();
+  });
+
+  it('allows using custom strategies on a per-argument basis', function(done) {
+    var strategyInstance = jasmine.createSpy('custom strategy instance')
+      .and.returnValue(42);
+    var strategyFactory = jasmine.createSpy('custom strategy factory')
+      .and.returnValue(strategyInstance);
+
+    env.it('spec defining a custom spy strategy', function() {
+      env.addSpyStrategy('frobnicate', strategyFactory);
+      var spy = env.createSpy('something')
+        .and.returnValue('no args return')
+        .withArgs(1, 2, 3).and.frobnicate(17);
+
+      expect(spy()).toEqual('no args return');
+      expect(strategyInstance).not.toHaveBeenCalled();
+      expect(spy(1, 2, 3)).toEqual(42);
+      expect(strategyInstance).toHaveBeenCalledWith(1, 2, 3);
+    });
+
+    env.it('spec without custom strategy defined', function() {
+      expect(env.createSpy('something').and.frobnicate).toBeUndefined();
+    });
+
+    function jasmineDone(result) {
+      expect(result.overallStatus).toEqual('passed');
+      done();
+    }
+
+    env.addReporter({ jasmineDone: jasmineDone });
+    env.execute();
+  });
+});