Custom error message to verify

README.md

@@ -52,6 +52,13 @@ verify(mockedFoo.getBar(3)).called();
 verify(mockedFoo.getBar(anything())).called();
 ```
 
+#### Throwing custom test error message
+The verify assertion will throw a test error with predefined error template.
+If you need to throw a different error message in the test you can supply the ```verify``` command with an optional error message parameter:
+``` typescript
+verify(mockedFoo.getBar(), 'getBar should have been called, but didnt!').called();
+```
+
 ### Stubbing method calls
 
 ``` typescript

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typestrong/ts-mockito",
-  "version": "2.6.7",
+  "version": "2.6.8",
   "description": "Mocking library for TypeScript",
   "main": "lib/ts-mockito.js",
   "typings": "lib/ts-mockito",

src/MethodStubVerificator.ts

@@ -4,7 +4,7 @@ import {MethodCallToStringConverter} from "./utils/MethodCallToStringConverter";
 export class MethodStubVerificator<T> {
     private methodCallToStringConverter: MethodCallToStringConverter = new MethodCallToStringConverter();
 
-    constructor(private methodToVerify: MethodToStub) {
+    constructor(private methodToVerify: MethodToStub, private errorMessage?: string) {
 
     }
 
@@ -33,7 +33,7 @@ export class MethodStubVerificator<T> {
         if (value !== allMatchingActions.length) {
             const methodToVerifyAsString = this.methodCallToStringConverter.convert(this.methodToVerify);
             const msg = `Expected "${methodToVerifyAsString}to be called ${value} time(s). But has been called ${allMatchingActions.length} time(s).`;
-            throw new Error(`${msg}
+            this.throw(`${msg}
 ${this.actualCalls()}`);
         }
     }
@@ -42,15 +42,15 @@ ${this.actualCalls()}`);
         const allMatchingActions = this.methodToVerify.mocker.getAllMatchingActions(this.methodToVerify.name, this.methodToVerify.matchers);
         if (value > allMatchingActions.length) {
             const methodToVerifyAsString = this.methodCallToStringConverter.convert(this.methodToVerify);
-            throw new Error(`Expected "${methodToVerifyAsString}to be called at least ${value} time(s). But has been called ${allMatchingActions.length} time(s).`);
+            this.throw(`Expected "${methodToVerifyAsString}to be called at least ${value} time(s). But has been called ${allMatchingActions.length} time(s).`);
         }
     }
 
     public atMost(value: number): void {
         const allMatchingActions = this.methodToVerify.mocker.getAllMatchingActions(this.methodToVerify.name, this.methodToVerify.matchers);
         if (value < allMatchingActions.length) {
             const methodToVerifyAsString = this.methodCallToStringConverter.convert(this.methodToVerify);
-            throw new Error(`Expected "${methodToVerifyAsString}to be called at least ${value} time(s). But has been called ${allMatchingActions.length} time(s).`);
+            this.throw(`Expected "${methodToVerifyAsString}to be called at least ${value} time(s). But has been called ${allMatchingActions.length} time(s).`);
         }
     }
 
@@ -63,14 +63,14 @@ ${this.actualCalls()}`);
 
         if (firstMethodAction && secondMethodAction) {
             if (!firstMethodAction.hasBeenCalledBefore(secondMethodAction)) {
-                throw new Error(`${errorBeginning}but has been called after.`);
+                this.throw(`${errorBeginning}but has been called after.`);
             }
         } else if (firstMethodAction && !secondMethodAction) {
-            throw new Error(`${errorBeginning}but ${secondMethodAsString}has never been called.`);
+            this.throw(`${errorBeginning}but ${secondMethodAsString}has never been called.`);
         } else if (!firstMethodAction && secondMethodAction) {
-            throw new Error(`${errorBeginning}but ${mainMethodToVerifyAsString}has never been called.`);
+            this.throw(`${errorBeginning}but ${mainMethodToVerifyAsString}has never been called.`);
         } else {
-            throw new Error(`${errorBeginning}but none of them has been called.`);
+            this.throw(`${errorBeginning}but none of them has been called.`);
         }
     }
 
@@ -83,14 +83,14 @@ ${this.actualCalls()}`);
 
         if (firstMethodAction && secondMethodAction) {
             if (firstMethodAction.hasBeenCalledBefore(secondMethodAction)) {
-                throw new Error(`${errorBeginning}but has been called before.`);
+                this.throw(`${errorBeginning}but has been called before.`);
             }
         } else if (firstMethodAction && !secondMethodAction) {
-            throw new Error(`${errorBeginning}but ${secondMethodAsString}has never been called.`);
+            this.throw(`${errorBeginning}but ${secondMethodAsString}has never been called.`);
         } else if (!firstMethodAction && secondMethodAction) {
-            throw new Error(`${errorBeginning}but ${mainMethodToVerifyAsString}has never been called.`);
+            this.throw(`${errorBeginning}but ${mainMethodToVerifyAsString}has never been called.`);
         } else {
-            throw new Error(`${errorBeginning}but none of them has been called.`);
+            this.throw(`${errorBeginning}but none of them has been called.`);
         }
     }
 
@@ -99,4 +99,8 @@ ${this.actualCalls()}`);
         return `Actual calls:
   ${this.methodCallToStringConverter.convertActualCalls(calls).join("\n  ")}`;
     }
+
+    private throw(message: string) {
+        throw new Error(this.errorMessage ?? message);
+    }
 }

src/ts-mockito.ts

@@ -38,8 +38,8 @@ export function mock<T>(clazz?: any): T {
     return new Mocker(clazz).getMock();
 }
 
-export function verify<T>(method: T): MethodStubVerificator<T> {
-    return new MethodStubVerificator(method as any);
+export function verify<T>(method: T, errorMessage?:string): MethodStubVerificator<T> {
+    return new MethodStubVerificator(method as any, errorMessage);
 }
 
 export function when<T>(method: Promise<T>): MethodStubSetter<Promise<T>, T, Error>;

test/verification.spec.ts

@@ -817,6 +817,23 @@ cases.forEach(testData => {
                     expect(e.message).toContain(`sampleMethodWithObjectArguments({\"foo\":\"baz\"})`);
                 }
             });
+
+            it("should describe error with the supplied error message", () => {
+                instance(mockedFoo).sampleMethodWithObjectArguments({foo: 'baz'});
+
+                try {
+                    // when
+                    verify(
+                        mockedFoo.sampleMethodWithObjectArguments(deepEqual({foo: 'bar'})),
+                        'sampleMethodWithObjectArguments should return baz!',
+                    ).once();
+
+                    expect(true).toBe(false); // Above call should throw an exception
+                } catch (e) {
+                    // then
+                    expect(e.message).toContain('sampleMethodWithObjectArguments should return baz!');
+                }
+            });
         });
     });
 });