toHaveNoOtherSpyInteractions implementation

spec/core/integration/MatchersSpec.js

@@ -675,6 +675,23 @@ describe('Matchers (Integration)', function() {
     });
   });
 
+  describe('toHaveNoOtherSpyInteractions', function() {
+    let spyObj;
+
+    beforeEach(function() {
+      spyObj = env.createSpyObj('NewClass', ['spyA', 'spyB']);
+    });
+
+    verifyPasses(function(env) {
+      env.expect(spyObj).toHaveNoOtherSpyInteractions();
+    });
+
+    verifyFails(function(env) {
+      spyObj.spyA();
+      env.expect(spyObj).toHaveNoOtherSpyInteractions();
+    });
+  });
+
   describe('toMatch', function() {
     verifyPasses(function(env) {
       env.expect('foo').toMatch(/oo$/);

spec/core/matchers/toHaveBeenCalledBeforeSpec.js

@@ -112,4 +112,20 @@ describe('toHaveBeenCalledBefore', function() {
       'Expected spy first spy to not have been called before spy second spy, but it was'
     );
   });
+
+  it('set the correct calls as verified when passing', function() {
+    const matcher = jasmineUnderTest.matchers.toHaveBeenCalledBefore(),
+      firstSpy = new jasmineUnderTest.Spy('first spy'),
+      secondSpy = new jasmineUnderTest.Spy('second spy');
+
+    firstSpy();
+    secondSpy();
+
+    matcher.compare(firstSpy, secondSpy);
+
+    expect(firstSpy.calls.count()).toBe(1);
+    expect(firstSpy.calls.unverifiedCount()).toBe(0);
+    expect(secondSpy.calls.count()).toBe(1);
+    expect(secondSpy.calls.unverifiedCount()).toBe(0);
+  });
 });

spec/core/matchers/toHaveBeenCalledOnceWithSpec.js

@@ -105,4 +105,18 @@ describe('toHaveBeenCalledOnceWith', function() {
       matcher.compare(fn);
     }).toThrowError(/Expected a spy, but got Function./);
   });
+
+  it('set the correct calls as verified when passing', function() {
+    const pp = jasmineUnderTest.makePrettyPrinter(),
+      util = new jasmineUnderTest.MatchersUtil({ pp: pp }),
+      matcher = jasmineUnderTest.matchers.toHaveBeenCalledOnceWith(util),
+      calledSpy = new jasmineUnderTest.Spy('called-spy');
+
+    calledSpy('x');
+
+    matcher.compare(calledSpy, 'x');
+
+    expect(calledSpy.calls.count()).toBe(1);
+    expect(calledSpy.calls.unverifiedCount()).toBe(0);
+  });
 });

spec/core/matchers/toHaveBeenCalledSpec.js

@@ -50,4 +50,16 @@ describe('toHaveBeenCalled', function() {
       'Expected spy sample-spy to have been called.'
     );
   });
+
+  it('set the correct calls as verified when passing', function() {
+    const matcher = jasmineUnderTest.matchers.toHaveBeenCalled(),
+      spy = new jasmineUnderTest.Spy('sample-spy');
+
+    spy();
+
+    matcher.compare(spy);
+
+    expect(spy.calls.count()).toBe(1);
+    expect(spy.calls.unverifiedCount()).toBe(0);
+  });
 });

spec/core/matchers/toHaveBeenCalledTimesSpec.js

@@ -87,4 +87,17 @@ describe('toHaveBeenCalledTimes', function() {
         ' times.'
     );
   });
+
+  it('set the correct calls as verified when passing', function() {
+    const matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
+      spy = new jasmineUnderTest.Spy('sample-spy');
+
+    spy();
+    spy();
+
+    matcher.compare(spy, 2);
+
+    expect(spy.calls.count()).toBe(2);
+    expect(spy.calls.unverifiedCount()).toBe(0);
+  });
 });

spec/core/matchers/toHaveBeenCalledWithSpec.js

@@ -92,4 +92,19 @@ describe('toHaveBeenCalledWith', function() {
       matcher.compare(fn);
     }).toThrowError(/Expected a spy, but got Function./);
   });
+
+  it('set the correct calls as verified when passing', function() {
+    const matchersUtil = {
+        contains: jasmine.createSpy('interaction-check').and.returnValue(true),
+        pp: jasmineUnderTest.makePrettyPrinter()
+      },
+      matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(matchersUtil),
+      calledSpy = new jasmineUnderTest.Spy('called-spy');
+
+    calledSpy('a', 'b');
+    matcher.compare(calledSpy, 'a', 'b');
+
+    expect(calledSpy.calls.count()).toBe(1);
+    expect(calledSpy.calls.unverifiedCount()).toBe(0);
+  });
 });

spec/core/matchers/toHaveNoOtherSpyInteractionsSpec.js

@@ -0,0 +1,137 @@
+describe('toHaveNoOtherSpyInteractions', function() {
+  it('passes when there are no spy interactions', function() {
+    let matcher = jasmineUnderTest.matchers.toHaveNoOtherSpyInteractions();
+    let spyObj = jasmineUnderTest
+      .getEnv()
+      .createSpyObj('NewClass', ['spyA', 'spyB']);
+
+    let result = matcher.compare(spyObj);
+    expect(result.pass).toBeTrue();
+  });
+
+  it('passes when there are multiple spy interactions where checked by toHaveBeenCalled', function() {
+    let matcher = jasmineUnderTest.matchers.toHaveNoOtherSpyInteractions();
+    let toHaveBeenCalledMatcher = jasmineUnderTest.matchers.toHaveBeenCalled();
+    let spyObj = jasmineUnderTest
+      .getEnv()
+      .createSpyObj('NewClass', ['spyA', 'spyB']);
+
+    spyObj.spyA();
+    spyObj.spyB();
+    spyObj.spyA();
+    toHaveBeenCalledMatcher.compare(spyObj.spyA);
+    toHaveBeenCalledMatcher.compare(spyObj.spyB);
+    let result = matcher.compare(spyObj);
+    expect(result.pass).toBeTrue();
+  });
+
+  it('fails when there are spy interactions', function() {
+    let matcher = jasmineUnderTest.matchers.toHaveNoOtherSpyInteractions();
+    let spyObj = jasmineUnderTest
+      .getEnv()
+      .createSpyObj('NewClass', ['spyA', 'spyB']);
+
+    spyObj.spyA();
+
+    let result = matcher.compare(spyObj);
+    expect(result.pass).toBeFalse();
+    expect(result.message).toContain(
+      "Unverified spies' calls have been found in:"
+    );
+  });
+
+  it('shows the right message is negated', function() {
+    let matcher = jasmineUnderTest.matchers.toHaveNoOtherSpyInteractions();
+    let spyObj = jasmineUnderTest
+      .getEnv()
+      .createSpyObj('NewClass', ['spyA', 'spyB']);
+
+    spyObj.spyA();
+    spyObj.spyB();
+
+    let result = matcher.compare(spyObj);
+    expect(result.pass).toBeFalse(),
+      expect(result.message).toContain(
+        "Unverified spies' calls have been found in:"
+      );
+  });
+
+  it('passes when only non-observed spy object interactions are interacted', function() {
+    let matcher = jasmineUnderTest.matchers.toHaveNoOtherSpyInteractions();
+    let spyObj = jasmineUnderTest
+      .getEnv()
+      .createSpyObj('NewClass', ['spyA', 'spyB']);
+    spyObj.otherMethod = function() {};
+
+    spyObj.otherMethod();
+
+    let result = matcher.compare(spyObj);
+    expect(result.pass).toBeTrue();
+    expect(result.message).toContain("Spies' calls are all verified.");
+  });
+
+  it(`throws an error if a non-object is passed`, function() {
+    let matcher = jasmineUnderTest.matchers.toHaveNoOtherSpyInteractions();
+
+    expect(function() {
+      matcher.compare(true);
+    }).toThrowError(Error, /Expected an object, but got/);
+
+    expect(function() {
+      matcher.compare(123);
+    }).toThrowError(Error, /Expected an object, but got/);
+
+    expect(function() {
+      matcher.compare('string');
+    }).toThrowError(Error, /Expected an object, but got/);
+  });
+
+  it('throws an error if arguments are passed', function() {
+    let matcher = jasmineUnderTest.matchers.toHaveNoOtherSpyInteractions();
+    let spyObj = jasmineUnderTest
+      .getEnv()
+      .createSpyObj('NewClass', ['spyA', 'spyB']);
+
+    expect(function() {
+      matcher.compare(spyObj, 'an argument');
+    }).toThrowError(Error, /Does not take arguments/);
+  });
+
+  it('throws an error if the spy object has no spies', function() {
+    let matcher = jasmineUnderTest.matchers.toHaveNoOtherSpyInteractions();
+    const spyObj = jasmineUnderTest
+      .getEnv()
+      .createSpyObj('NewClass', ['notSpy']);
+    // Removing spy since spy objects cannot be created without spies.
+    spyObj.notSpy = function() {};
+
+    expect(function() {
+      matcher.compare(spyObj);
+    }).toThrowError(
+      Error,
+      /Expected an object with spies, but object has no spies/
+    );
+  });
+
+  it('handles multiple interactions with a single spy', function() {
+    const matchersUtil = new jasmineUnderTest.MatchersUtil({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      matcher = jasmineUnderTest.matchers.toHaveNoOtherSpyInteractions(),
+      toHaveBeenCalledWithMatcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(
+        matchersUtil
+      ),
+      spyObj = jasmineUnderTest
+        .getEnv()
+        .createSpyObj('NewClass', ['spyA', 'spyB']);
+
+    spyObj.spyA('x');
+    spyObj.spyA('y');
+
+    toHaveBeenCalledWithMatcher.compare(spyObj.spyA, 'x');
+
+    let result = matcher.compare(spyObj);
+
+    expect(result.pass).toBeFalse();
+  });
+});