Add warning when forgetting to get instance of a mock

johanblumenberg · Jun 21, 2019 · e2b52a7 · e2b52a7
1 parent 6a4bccb
commit e2b52a7
Show file tree

Hide file tree

Showing 10 changed files with 104 additions and 33 deletions.
diff --git a/src/MethodStubSetter.ts b/src/MethodStubSetter.ts
@@ -10,6 +10,7 @@ export class MethodStubSetter<T, ResolveType = void, RejectType = void> {
     private groupIndex: number;
 
     constructor(private methodToStub: MethodToStub) {
+        methodToStub.watcher.invoked();
         this.groupIndex = ++MethodStubSetter.globalGroupIndex;
     }
 

diff --git a/src/MethodStubVerificator.ts b/src/MethodStubVerificator.ts
@@ -8,7 +8,7 @@ export class MethodStubVerificator<T> {
     private methodCallToStringConverter: MethodCallToStringConverter = new MethodCallToStringConverter();
 
     constructor(private methodToVerify: MethodToStub) {
-
+        methodToVerify.watcher.invoked();
     }
 
     public called(): void {
@@ -56,6 +56,8 @@ export class MethodStubVerificator<T> {
     }
 
     public calledBefore(method: any): void {
+        method.watcher.invoked();
+
         const firstMethodAction = this.methodToVerify.mocker.getFirstMatchingAction(this.methodToVerify.methodName, this.methodToVerify.matchers);
         const secondMethodAction = method.mocker.getFirstMatchingAction(method.methodName, method.matchers);
         const mainMethodToVerifyAsString = this.methodCallToStringConverter.convert(this.methodToVerify);
@@ -76,6 +78,8 @@ export class MethodStubVerificator<T> {
     }
 
     public calledAfter(method: any): void {
+        method.watcher.invoked();
+
         const firstMethodAction = this.methodToVerify.mocker.getFirstMatchingAction(this.methodToVerify.methodName  , this.methodToVerify.matchers);
         const secondMethodAction = method.mocker.getFirstMatchingAction(method.methodName, method.matchers);
         const mainMethodToVerifyAsString = this.methodCallToStringConverter.convert(this.methodToVerify);

diff --git a/src/MethodToStub.ts b/src/MethodToStub.ts
@@ -2,10 +2,33 @@ import {Matcher} from "./matcher/type/Matcher";
 import {MethodStubCollection} from "./MethodStubCollection";
 import {Mocker} from "./Mock";
 
+class Watcher {
+    private _invoked = false;
+
+    constructor(private _err: Error) {
+        setTimeout(this.nextTick, 0);
+    }
+
+    public invoked() {
+        this._invoked = true;
+    }
+
+    private nextTick = () => {
+        if (!this._invoked) {
+            throw this._err;
+        }
+    };
+}
+
 export class MethodToStub {
-    constructor(public methodStubCollection: MethodStubCollection,
-                public matchers: Matcher[],
-                public mocker: Mocker,
-                public methodName: string) {
+    public watcher: Watcher;
+
+    constructor(
+        public methodStubCollection: MethodStubCollection,
+        public matchers: Matcher[],
+        public mocker: Mocker,
+        public methodName: string)
+    {
+        this.watcher = new Watcher(new Error(`Unmatched call to ${methodName} on a mock object, did you mean to use instance()?`));
     }
 }
diff --git a/src/Mock.ts b/src/Mock.ts
@@ -197,29 +197,21 @@ export class Mocker {
             },
         });
 
-        const methodMock = (...args) => {
-            isProperty = false;
-
-            const matchers: Matcher[] = [];
-
-            for (const arg of args) {
-                if (!(arg instanceof Matcher)) {
-                    matchers.push(strictEqual(arg));
-                } else {
-                    matchers.push(arg);
-                }
-            }
-
-            return new MethodToStub(this.methodStubCollections[key], matchers, this, key);
-        };
-
         const propertyMock = () => {
             if (!this.methodStubCollections[key]) {
                 this.methodStubCollections[key] = new MethodStubCollection();
             }
 
+            const methodToMock = new MethodToStub(this.methodStubCollections[key], [], this, key);
+
+            const methodMock = (...args) => {
+                isProperty = false;
+                methodToMock.matchers = args.map(arg => (arg instanceof Matcher) ? arg : strictEqual(arg));
+                return methodToMock;
+            };
+
             // Return a mix of a method stub and a property invocation, which works as both
-            return Object.assign(methodMock, new MethodToStub(this.methodStubCollections[key], [], this, key));
+            return Object.assign(methodMock, methodToMock);
         };
 
         Object.defineProperty(this.mock, key, {

diff --git a/src/ts-mockito.ts b/src/ts-mockito.ts
@@ -90,6 +90,8 @@ export function capture<T0>(method: (a: T0) => any): ArgCaptor1<T0>;
 export function capture(method: (...args: any[]) => any): ArgCaptor {
     const methodStub: MethodToStub = method();
     if (methodStub instanceof MethodToStub) {
+        methodStub.watcher.invoked();
+
         const actions = methodStub.mocker.getActionsByName(methodStub.methodName);
         return new ArgCaptor(actions);
     } else {
@@ -173,6 +175,10 @@ export function defer<T>(): Deferred<T> {
     return Object.assign(d, { resolve, reject });
 }
 
+export function nextTick(): Promise<void> {
+    return new Promise(resolve => setTimeout(resolve, 0));
+}
+
 // Export default object with all members (ember-browserify doesn't support named exports).
 export default {
     spy,
@@ -200,4 +206,5 @@ export default {
     objectContaining,
     MockPropertyPolicy,
     defer,
+    nextTick,
 };
diff --git a/src/utils/MethodCallToStringConverter.ts b/src/utils/MethodCallToStringConverter.ts
@@ -3,6 +3,8 @@ import {MethodToStub} from "../MethodToStub";
 
 export class MethodCallToStringConverter {
     public convert(method: MethodToStub): string {
+        method.watcher.invoked();
+
         const stringifiedMatchers = method.matchers.map((matcher: Matcher) => matcher.toString()).join(", ");
         return `${method.methodName}(${stringifiedMatchers})" `;
     }

diff --git a/test/instance.spec.ts b/test/instance.spec.ts
@@ -1,4 +1,4 @@
-import {instance, mock} from "../src/ts-mockito";
+import {instance, mock, nextTick} from "../src/ts-mockito";
 import {Foo} from "./utils/Foo";
 
 describe("instance", () => {
@@ -17,4 +17,18 @@ describe("instance", () => {
             expect(firstFooInstance).toBe(secondFooInstance);
         });
     });
+
+    xdescribe("forgetting to get instance of mock", () => {
+        let mockedFoo: Foo;
+
+        it("throws an exception if not taking instance before calling a method", async () => {
+            // given
+            mockedFoo = mock(Foo);
+
+            mockedFoo.getBar();
+            await nextTick();
+
+            // Expected to fail with "Unmatched call to getBar, did you forget to use instance()?"
+        });
+    });
 });
diff --git a/test/mocking.getter.spec.ts b/test/mocking.getter.spec.ts
@@ -25,7 +25,11 @@ describe("mocking", () => {
             mockedFoo = mock(FooWithGetterAndSetter);
 
             // then
-            expect((mockedFoo.twoPlusTwo as any) instanceof MethodToStub).toBe(true);
+            const twoPlusTwo: any = mockedFoo.twoPlusTwo;
+            expect(twoPlusTwo instanceof MethodToStub).toBe(true);
+
+            // cleanup, make sure to use twoPlusTwo
+            when(twoPlusTwo).thenReturn(4);
         });
 
         it("does create own property descriptors on instance", () => {
@@ -48,7 +52,11 @@ describe("mocking", () => {
             // when
 
             // then
-            expect((mockedFoo.sampleString as any) instanceof MethodToStub).toBe(true);
+            const sampleString: any = mockedFoo.sampleString;
+            expect(sampleString instanceof MethodToStub).toBe(true);
+
+            // cleanup, make sure to use twoPlusTwo
+            when(sampleString).thenReturn("x");
         });
 
         it("does create inherited property descriptors on instance", () => {

diff --git a/test/mocking.properties.spec.ts b/test/mocking.properties.spec.ts
@@ -18,10 +18,14 @@ describe("mocking", () => {
             when(mockedFoo.sampleNumber).thenReturn(42);
 
             // then
-            expect((mockedFoo.sampleNumber as any).methodStubCollection).toBeDefined();
-            expect((mockedFoo.sampleNumber as any).matchers).toBeDefined();
-            expect((mockedFoo.sampleNumber as any).mocker).toBeDefined();
-            expect((mockedFoo.sampleNumber as any).methodName).toBeDefined();
+            const sampleNumber: any = mockedFoo.sampleNumber;
+            expect(sampleNumber.methodStubCollection).toBeDefined();
+            expect(sampleNumber.matchers).toBeDefined();
+            expect(sampleNumber.mocker).toBeDefined();
+            expect(sampleNumber.methodName).toBeDefined();
+
+            // cleanup, make sure to use sampleNumber
+            when(sampleNumber).thenReturn(0);
         });
 
         it("does create own property descriptors on instance", () => {

diff --git a/test/mocking.types.spec.ts b/test/mocking.types.spec.ts
@@ -25,7 +25,11 @@ describe("mocking", () => {
             mockedFoo = mock(SampleAbstractClass);
 
             // then
-            expect((mockedFoo.twoPlusTwo as any) instanceof MethodToStub).toBe(true);
+            const twoPlusTwo: any = mockedFoo.twoPlusTwo;
+            expect(twoPlusTwo instanceof MethodToStub).toBe(true);
+
+            // cleanup, make sure to use twoPlusTwo
+            when(twoPlusTwo).thenReturn(4);
         });
 
         it("does create own property descriptors on instance", () => {
@@ -48,7 +52,11 @@ describe("mocking", () => {
             // when
 
             // then
-            expect((mockedFoo.sampleString as any) instanceof MethodToStub).toBe(true);
+            const sampleString: any = mockedFoo.sampleString;
+            expect(sampleString instanceof MethodToStub).toBe(true);
+
+            // cleanup, make sure to use sampleString
+            when(sampleString).thenReturn("x");
         });
 
         it("does create inherited property descriptors on instance", () => {
@@ -100,7 +108,11 @@ describe("mocking", () => {
             mockedFoo = mock(SampleGeneric);
 
             // then
-            expect((mockedFoo.twoPlusTwo as any) instanceof MethodToStub).toBe(true);
+            const twoPlusTwo: any = mockedFoo.twoPlusTwo;
+            expect(twoPlusTwo instanceof MethodToStub).toBe(true);
+
+            // cleanup, make sure to use twoPlusTwo
+            when(twoPlusTwo).thenReturn(4);
         });
 
         it("allows to mock method with generic return type value (with IDE completion)", () => {
@@ -137,7 +149,11 @@ describe("mocking", () => {
             // when
 
             // then
-            expect((mockedFoo.sampleString as any) instanceof MethodToStub).toBe(true);
+            const sampleString: any = mockedFoo.sampleString;
+            expect(sampleString instanceof MethodToStub).toBe(true);
+
+            // cleanup, make sure to use twoPlusTwo
+            when(sampleString).thenReturn("x");
         });
 
         it("does create inherited property descriptors on instance", () => {