Matchers types

package.json

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

src/matcher/type/AnyFunctionMatcher.ts

@@ -1,12 +1,12 @@
 import * as _ from "lodash";
 import {Matcher} from "./Matcher";
 
-export class AnyFunctionMatcher extends Matcher {
+export class AnyFunctionMatcher<T extends Function> extends Matcher<T> {
     constructor() {
         super();
     }
 
-    public match(value: any): boolean {
+    public match(value: T): boolean {
         return _.isFunction(value);
     }
 

src/matcher/type/AnyNumberMatcher.ts

@@ -1,12 +1,12 @@
 import * as _ from "lodash";
 import {Matcher} from "./Matcher";
 
-export class AnyNumberMatcher extends Matcher {
+export class AnyNumberMatcher extends Matcher<number> {
     constructor() {
         super();
     }
 
-    public match(value: any): boolean {
+    public match(value: number): boolean {
         return _.isNumber(value);
     }
 

src/matcher/type/AnyOfClassMatcher.ts

@@ -1,14 +1,14 @@
 import {Matcher} from "./Matcher";
 
-export class AnyOfClassMatcher<T> extends Matcher {
+export class AnyOfClassMatcher<T> extends Matcher<T> {
     constructor(private expectedClass: new (...args: any[]) => T) {
         super();
         if (expectedClass === null) {
             throw new Error("The expected class cannot be null.");
         }
     }
 
-    public match(value: any): boolean {
+    public match(value: T): boolean {
         return value instanceof this.expectedClass;
     }
 

src/matcher/type/AnyStringMatcher.ts

@@ -1,12 +1,12 @@
 import * as _ from "lodash";
 import {Matcher} from "./Matcher";
 
-export class AnyStringMatcher extends Matcher {
+export class AnyStringMatcher extends Matcher<string> {
     constructor() {
         super();
     }
 
-    public match(value: any): boolean {
+    public match(value: string): boolean {
         return _.isString(value);
     }
 

src/matcher/type/BetweenMatcher.ts

@@ -1,6 +1,6 @@
 import {Matcher} from "./Matcher";
 
-export class BetweenMatcher extends Matcher {
+export class BetweenMatcher extends Matcher<number> {
     constructor(private min: number, private max: number) {
         super();
 
@@ -9,7 +9,7 @@ export class BetweenMatcher extends Matcher {
         }
     }
 
-    public match(value: any): boolean {
+    public match(value: number): boolean {
         return value >= this.min && value <= this.max;
     }
 

src/matcher/type/DeepEqualMatcher.ts

@@ -1,14 +1,14 @@
 import * as _ from "lodash";
 import {Matcher} from "./Matcher";
 import * as safeJsonStringify from "safe-json-stringify";
-export class DeepEqualMatcher<T> extends Matcher {
+export class DeepEqualMatcher<T> extends Matcher<T> {
     constructor(private expectedValue: T) {
         super();
     }
 
-    public match(value: any): boolean {
+    public match(value: T): boolean {
         return _.isEqualWith(this.expectedValue, value,
-            (expected: any, actual: any): boolean => {
+            (expected: any, actual: any) => {
                 if (expected instanceof Matcher) {
                     return expected.match(actual);
                 }

src/matcher/type/Matcher.ts

@@ -1,5 +1,5 @@
-export class Matcher {
-    public match(value: any): boolean {
+export class Matcher<T = unknown> {
+    public match(value: T): boolean {
         return false;
     }
 

src/matcher/type/MatchingStringMatcher.ts

@@ -1,12 +1,12 @@
 import {Matcher} from "./Matcher";
 
-export class MatchingStringMatcher extends Matcher {
-    constructor(private expectedValue: any) {
+export class MatchingStringMatcher extends Matcher<string> {
+    constructor(private expectedValue: RegExp | string) {
         super();
     }
 
-    public match(value: any): boolean {
-        return value.match(this.expectedValue);
+    public match(value: string): boolean {
+        return Boolean(value.match(this.expectedValue));
     }
 
     public toString(): string {

src/matcher/type/ObjectContainingMatcher.ts

@@ -1,12 +1,12 @@
 import * as _ from "lodash";
 import {Matcher} from "./Matcher";
 
-export class ObjectContainingMatcher extends Matcher {
+export class ObjectContainingMatcher<T extends Object> extends Matcher<T> {
     constructor(private expectedValue: any) {
         super();
     }
 
-    public match(value: Object): boolean {
+    public match(value: T): boolean {
         return _.isMatch(value, this.expectedValue);
     }
 

src/matcher/type/StrictEqualMatcher.ts

@@ -1,11 +1,11 @@
 import {Matcher} from "./Matcher";
 
-export class StrictEqualMatcher extends Matcher {
+export class StrictEqualMatcher<T> extends Matcher<T> {
     constructor(private expectedValue: any) {
         super();
     }
 
-    public match(value: any): boolean {
+    public match(value: T): boolean {
         return this.expectedValue === value;
     }
 

src/ts-mockito.ts

@@ -27,43 +27,44 @@ import {MethodStubVerificator} from "./MethodStubVerificator";
 import {MethodToStub} from "./MethodToStub";
 import {Mocker} from "./Mock";
 import {Spy} from "./Spy";
+import {Mocked, MockedProp} from "./utils/types";
 
-export function spy<T>(instanceToSpy: T): T {
+export function spy<T>(instanceToSpy: T): Mocked<T> {
     return new Spy(instanceToSpy).getMock();
 }
 
-export function mock<T>(clazz: (new(...args: any[]) => T) | (Function & { prototype: T }) ): T;
-export function mock<T>(clazz?: any): T;
-export function mock<T>(clazz?: any): T {
+export function mock<T>(clazz: (new(...args: any[]) => T) | (Function & { prototype: T }) ): Mocked<T>;
+export function mock<T>(clazz?: any): Mocked<T>;
+export function mock<T>(clazz?: any): Mocked<T> {
     return new Mocker(clazz).getMock();
 }
 
-export function verify<T>(method: T): MethodStubVerificator<T> {
+export function verify<T>(method: MockedProp<T>): MethodStubVerificator<T> {
     return new MethodStubVerificator(method as any);
 }
 
-export function when<T>(method: Promise<T>): MethodStubSetter<Promise<T>, T, Error>;
-export function when<T>(method: T): MethodStubSetter<T>;
+export function when<T>(method: Promise<MockedProp<T>>): MethodStubSetter<Promise<T>, T, Error>;
+export function when<T>(method: MockedProp<T>): MethodStubSetter<T>;
 export function when<T>(method: any): any {
     return new MethodStubSetter(method);
 }
 
-export function instance<T>(mockedValue: T): T {
+export function instance<T>(mockedValue: Mocked<T>): T {
     const tsmockitoInstance = (mockedValue as any).__tsmockitoInstance as T;
     return tsmockitoInstance;
 }
 
-export function capture<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(method: (a: T0, b: T1, c: T2, d: T3, e: T4, f: T5, g: T6, h: T7, i: T8, j: T9) => any): ArgCaptor10<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>;
-export function capture<T0, T1, T2, T3, T4, T5, T6, T7, T8>(method: (a: T0, b: T1, c: T2, d: T3, e: T4, f: T5, g: T6, h: T7, i: T8) => any): ArgCaptor9<T0, T1, T2, T3, T4, T5, T6, T7, T8>;
-export function capture<T0, T1, T2, T3, T4, T5, T6, T7>(method: (a: T0, b: T1, c: T2, d: T3, e: T4, f: T5, g: T6, h: T7) => any): ArgCaptor8<T0, T1, T2, T3, T4, T5, T6, T7>;
-export function capture<T0, T1, T2, T3, T4, T5, T6>(method: (a: T0, b: T1, c: T2, d: T3, e: T4, f: T5, g: T6) => any): ArgCaptor7<T0, T1, T2, T3, T4, T5, T6>;
-export function capture<T0, T1, T2, T3, T4, T5>(method: (a: T0, b: T1, c: T2, d: T3, e: T4, f: T5) => any): ArgCaptor6<T0, T1, T2, T3, T4, T5>;
-export function capture<T0, T1, T2, T3, T4>(method: (a: T0, b: T1, c: T2, d: T3, e: T4) => any): ArgCaptor5<T0, T1, T2, T3, T4>;
-export function capture<T0, T1, T2, T3>(method: (a: T0, b: T1, c: T2, d: T3) => any): ArgCaptor4<T0, T1, T2, T3>;
-export function capture<T0, T1, T2>(method: (a: T0, b: T1, c: T2) => any): ArgCaptor3<T0, T1, T2>;
-export function capture<T0, T1>(method: (a: T0, b: T1) => any): ArgCaptor2<T0, T1>;
-export function capture<T0>(method: (a: T0) => any): ArgCaptor1<T0>;
-export function capture(method: (...args: any[]) => any): ArgCaptor {
+export function capture<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(method: MockedProp<(a: T0, b: T1, c: T2, d: T3, e: T4, f: T5, g: T6, h: T7, i: T8, j: T9) => any>): ArgCaptor10<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>;
+export function capture<T0, T1, T2, T3, T4, T5, T6, T7, T8>(method: MockedProp<(a: T0, b: T1, c: T2, d: T3, e: T4, f: T5, g: T6, h: T7, i: T8) => any>): ArgCaptor9<T0, T1, T2, T3, T4, T5, T6, T7, T8>;
+export function capture<T0, T1, T2, T3, T4, T5, T6, T7>(method: MockedProp<(a: T0, b: T1, c: T2, d: T3, e: T4, f: T5, g: T6, h: T7) => any>): ArgCaptor8<T0, T1, T2, T3, T4, T5, T6, T7>;
+export function capture<T0, T1, T2, T3, T4, T5, T6>(method: MockedProp<(a: T0, b: T1, c: T2, d: T3, e: T4, f: T5, g: T6) => any>): ArgCaptor7<T0, T1, T2, T3, T4, T5, T6>;
+export function capture<T0, T1, T2, T3, T4, T5>(method: MockedProp<(a: T0, b: T1, c: T2, d: T3, e: T4, f: T5) => any>): ArgCaptor6<T0, T1, T2, T3, T4, T5>;
+export function capture<T0, T1, T2, T3, T4>(method: MockedProp<(a: T0, b: T1, c: T2, d: T3, e: T4) => any>): ArgCaptor5<T0, T1, T2, T3, T4>;
+export function capture<T0, T1, T2, T3>(method: MockedProp<(a: T0, b: T1, c: T2, d: T3) => any>): ArgCaptor4<T0, T1, T2, T3>;
+export function capture<T0, T1, T2>(method: MockedProp<(a: T0, b: T1, c: T2) => any>): ArgCaptor3<T0, T1, T2>;
+export function capture<T0, T1>(method: MockedProp<(a: T0, b: T1) => any>): ArgCaptor2<T0, T1>;
+export function capture<T0>(method: MockedProp<(a: T0) => any>): ArgCaptor1<T0>;
+export function capture(method: MockedProp<(...args: any[]) => any>): ArgCaptor {
     const methodStub: MethodToStub = method();
     if (methodStub instanceof MethodToStub) {
         const actions = methodStub.mocker.getActionsByName(methodStub.name);
@@ -73,56 +74,56 @@ export function capture(method: (...args: any[]) => any): ArgCaptor {
     }
 }
 
-export function reset<T>(...mockedValues: T[]): void {
+export function reset<T>(...mockedValues: Mocked<T>[]): void {
     mockedValues.forEach(mockedValue => (mockedValue as any).__tsmockitoMocker.reset());
 }
 
-export function resetCalls<T>(...mockedValues: T[]): void {
+export function resetCalls<T>(...mockedValues: Mocked<T>[]): void {
     mockedValues.forEach(mockedValue => (mockedValue as any).__tsmockitoMocker.resetCalls());
 }
 
-export function anyOfClass<T>(expectedClass: new (...args: any[]) => T): any {
-    return new AnyOfClassMatcher(expectedClass) as any;
+export function anyOfClass<T>(expectedClass: new (...args: any[]) => T) {
+    return new AnyOfClassMatcher<T>(expectedClass);
 }
 
-export function anyFunction(): any {
-    return new AnyFunctionMatcher() as any;
+export function anyFunction() {
+    return new AnyFunctionMatcher();
 }
 
-export function anyNumber(): any {
-    return new AnyNumberMatcher() as any;
+export function anyNumber() {
+    return new AnyNumberMatcher();
 }
 
-export function anyString(): any {
-    return new AnyStringMatcher() as any;
+export function anyString() {
+    return new AnyStringMatcher();
 }
 
-export function anything(): any {
-    return new AnythingMatcher() as any;
+export function anything() {
+    return new AnythingMatcher();
 }
 
-export function between(min: number, max: number): any {
-    return new BetweenMatcher(min, max) as any;
+export function between(min: number, max: number) {
+    return new BetweenMatcher(min, max) ;
 }
 
-export function deepEqual<T>(expectedValue: T): T {
-    return new DeepEqualMatcher<T>(expectedValue) as any;
+export function deepEqual<T>(expectedValue: T) {
+    return new DeepEqualMatcher<T>(expectedValue);
 }
 
-export function notNull(): any {
-    return new NotNullMatcher() as any;
+export function notNull() {
+    return new NotNullMatcher();
 }
 
-export function strictEqual(expectedValue: any): any {
-    return new StrictEqualMatcher(expectedValue) as any;
+export function strictEqual<T>(expectedValue: T) {
+    return new StrictEqualMatcher<T>(expectedValue);
 }
 
-export function match(expectedValue: RegExp | string): any {
-    return new MatchingStringMatcher(expectedValue) as any;
+export function match(expectedValue: RegExp | string) {
+    return new MatchingStringMatcher(expectedValue);
 }
 
-export function objectContaining<T extends Object>(expectedValue: T): any {
-    return new ObjectContainingMatcher(expectedValue) as any;
+export function objectContaining<T extends Object>(expectedValue: T) {
+    return new ObjectContainingMatcher<T>(expectedValue);
 }
 
 // Export default object with all members (ember-browserify doesn't support named exports).

src/utils/types.ts

@@ -1 +1,14 @@
-export type TODO = any;
+import {Matcher} from "../matcher/type/Matcher";
+
+type MockedArgs<T extends Array<unknown>> = {
+    [I in keyof T]: Matcher<T[I]> | T[I]
+};
+
+export type MockedProp<T> =
+    T extends (...args:infer Args) => infer R ?
+        (...args:MockedArgs<Args>) => R :
+        T;
+
+export type Mocked<T> = {
+    [prop in keyof T]: MockedProp<T[prop]>
+};

test/capturing.spec.ts

@@ -1,8 +1,9 @@
 import {capture, instance, mock} from "../src/ts-mockito";
 import {Foo} from "./utils/Foo";
+import {Mocked} from "../src/utils/types";
 
 describe("capturing method arguments", () => {
-    let mockedFoo: Foo;
+    let mockedFoo: Mocked<Foo>;
     let foo: Foo;
 
     beforeEach(() => {

test/mocking.getter.spec.ts

@@ -1,8 +1,9 @@
 import {instance, mock, when} from "../src/ts-mockito";
 import {Bar} from "./utils/Bar";
+import {Mocked} from "../src/utils/types";
 
 describe("mocking", () => {
-    let mockedFoo: FooWithGetterAndSetter;
+    let mockedFoo: Mocked<FooWithGetterAndSetter>;
     let foo: FooWithGetterAndSetter;
 
     describe("mocking object with getters and setters", () => {

test/recording.multiple.behaviors.spec.ts

@@ -1,8 +1,9 @@
 import {instance, mock, when} from "../src/ts-mockito";
 import {Foo} from "./utils/Foo";
+import {Mocked} from "../src/utils/types";
 
 describe("recording multiple behaviors", () => {
-    let mockedFoo: Foo;
+    let mockedFoo: Mocked<Foo>;
     let foo: Foo;
 
     beforeEach(() => {

test/reseting.calls.spec.ts

@@ -1,9 +1,10 @@
 import { Mocker } from "../src/Mock";
 import { anything, instance, mock, resetCalls, verify } from "../src/ts-mockito";
 import {Foo} from "./utils/Foo";
+import {Mocked} from "../src/utils/types";
 
 describe("resetting mocked object", () => {
-    let mockedFoo: Foo;
+    let mockedFoo: Mocked<Foo>;
     let foo: Foo;
 
     beforeEach(() => {

test/reseting.spec.ts

@@ -1,9 +1,10 @@
 import { Mocker } from "../src/Mock";
 import {anything, instance, mock, reset, verify, when} from "../src/ts-mockito";
 import {Foo} from "./utils/Foo";
+import {Mocked} from "../src/utils/types";
 
 describe("resetting mocked object", () => {
-    let mockedFoo: Foo;
+    let mockedFoo: Mocked<Foo>;
     let foo: Foo;
 
     beforeEach(() => {