Add resetStubs()

Author: Johan Blumenberg

src/Mock.ts

@@ -83,6 +83,10 @@ export class Mocker {
         this.methodActions = [];
     }
 
+    public resetStubs(): void {
+      this.methodStubCollections = {};
+    }
+
     public resetCalls(): void {
         this.methodActions = [];
     }

src/ts-mockito.ts

@@ -125,6 +125,10 @@ export function reset<T>(mockedValue: T): void {
     (mockedValue as any).__tsmockitoMocker.reset();
 }
 
+export function resetStubs<T>(mockedValue: T): void {
+  (mockedValue as any).__tsmockitoMocker.resetStubs();
+}
+
 export function resetCalls<T>(mockedValue: T): void {
     (mockedValue as any).__tsmockitoMocker.resetCalls();
 }
@@ -254,6 +258,7 @@ export default {
     instance,
     capture,
     reset,
+    resetStubs,
     resetCalls,
     anyOfClass,
     anyFunction,

test/reseting.spec.ts

@@ -1,4 +1,4 @@
-import {anything, instance, mock, reset, verify, when} from "../src/ts-mockito";
+import {anything, instance, mock, reset, resetStubs, verify, when} from "../src/ts-mockito";
 import {Foo} from "./utils/Foo";
 
 describe("resetting mocked object", () => {
@@ -163,3 +163,101 @@ describe("resetting mocked object", () => {
         });
     });
 });
+
+describe("resetting mocked object stubs", () => {
+  let mockedFoo: Foo;
+  let foo: Foo;
+
+  beforeEach(() => {
+      mockedFoo = mock(Foo);
+      foo = instance(mockedFoo);
+  });
+
+  describe("when method has been called once", () => {
+      describe("but later stub has been reset", () => {
+          it("shows that still been called", () => {
+              // given
+              foo.getBar();
+              verify(mockedFoo.getBar()).once();
+
+              // when
+              resetStubs(mockedFoo);
+
+              // then
+              verify(mockedFoo.getBar()).once();
+          });
+      });
+  });
+
+  describe("when two different methods has been called twice", () => {
+      describe("but later stub has been reset", () => {
+          it("shows that still been called", () => {
+              // given
+              foo.getBar();
+              foo.getBar();
+              foo.sumTwoNumbers(2, 3);
+              foo.sumTwoNumbers(2, 3);
+              verify(mockedFoo.getBar()).twice();
+              verify(mockedFoo.sumTwoNumbers(2, 3)).twice();
+
+              // when
+              resetStubs(mockedFoo);
+
+              // then
+              verify(mockedFoo.getBar()).twice();
+              verify(mockedFoo.sumTwoNumbers(2, 3)).twice();
+              verify(mockedFoo.sumTwoNumbers(anything(), anything())).twice();
+          });
+      });
+  });
+
+  describe("when two different methods has been called", () => {
+      describe("but later stub has been reset", () => {
+          it("throws exception with information that methods has still been called", () => {
+              // given
+              foo.getBar();
+              foo.sumTwoNumbers(2, 3);
+              verify(mockedFoo.getBar()).calledBefore(mockedFoo.sumTwoNumbers(2, 3));
+
+              // when
+              resetStubs(mockedFoo);
+
+              // then
+              verify(mockedFoo.getBar()).calledBefore(mockedFoo.sumTwoNumbers(2, 3));
+          });
+      });
+  });
+
+  describe("when object has been stubbed", () => {
+      describe("but later stub has been reset", () => {
+          it("should reset configured stubs", () => {
+              // given
+              when(mockedFoo.convertNumberToString(3)).thenReturn("three");
+              resetStubs(mockedFoo);
+
+              // when
+              const result: string = foo.convertNumberToString(3);
+
+              // then
+              expect(result).toBeNull();
+          });
+      });
+  });
+
+  describe("when object has been stubbed", () => {
+      describe("but later stub has been reset", () => {
+          it("should be able to setup new stubs", () => {
+              // given
+              when(mockedFoo.convertNumberToString(3)).thenReturn("three");
+              resetStubs(mockedFoo);
+              when(mockedFoo.convertNumberToString(3)).thenReturn("newStubbedValue");
+
+              // when
+              const result: string = foo.convertNumberToString(3);
+
+              // then
+              expect(result).toEqual("newStubbedValue");
+          });
+      });
+  });
+});

test/spy.spec.ts

@@ -1,4 +1,4 @@
-import {capture, reset, spy, verify, when} from "../src/ts-mockito";
+import {capture, reset, resetStubs, spy, verify, when} from "../src/ts-mockito";
 
 describe("spying on a real object", () => {
     class Real {
@@ -223,6 +223,62 @@ describe("spying on a real object", () => {
         });
     });
 
+    describe("resetting stubs", () => {
+      it("restores a call to the real method", () => {
+          // given
+          const foo = new Real();
+          const spiedFoo = spy(foo);
+
+          // when
+          when(spiedFoo.bar()).thenReturn(3);
+          resetStubs(spiedFoo);
+
+          // then
+          expect(foo.bar()).toBe(2);
+      });
+
+      it("set new stub calls to the real method", () => {
+        // given
+        const foo = new Real();
+        const spiedFoo = spy(foo);
+
+        // when
+        when(spiedFoo.bar()).thenReturn(3);
+        resetStubs(spiedFoo);
+        when(spiedFoo.bar()).thenReturn(4);
+
+        // then
+        expect(foo.bar()).toBe(4);
+    });
+
+    it("restores getter properties", () => {
+          // given
+          const foo = new Real();
+          const spiedFoo = spy(foo);
+
+          // when
+          when(spiedFoo.baz).thenReturn(42);
+          resetStubs(spiedFoo);
+
+          // then
+          expect(foo.baz).toBe(3);
+      });
+
+      it("set new stub properties", () => {
+        // given
+        const foo = new Real();
+        const spiedFoo = spy(foo);
+
+        // when
+        when(spiedFoo.baz).thenReturn(42);
+        resetStubs(spiedFoo);
+        when(spiedFoo.baz).thenReturn(43);
+
+        // then
+        expect(foo.baz).toBe(43);
+    });
+  });
+
     describe("spying on object which doesn't inherit from anything", () => {
         let bareObject;