fix: fix void spy regressions, and properly type andCallFake (ngneat#710)

* fix!: fix void spy regressions, and properly type andCallFake

BREAKING CHANGE: CompatibleSpy<T> type checks it's methods and
enables types on inherited jasmine.Spy<T> methods. Existing tests
may break at build if mocked returns are the wrong types.

* test: add additional tests for type checks

Author: Alanoll

projects/spectator/src/lib/mock.ts

@@ -3,7 +3,7 @@ import { FactoryProvider, Type, AbstractType } from '@angular/core';
 
 type Writable<T> = { -readonly [P in keyof T]: T[P] };
 
-declare type UnknownFunction = (...args: unknown[]) => unknown;
+declare type UnknownFunction = (...args: any[]) => any;
 
 /**
  * @publicApi
@@ -19,7 +19,7 @@ export interface CompatibleSpy<F extends UnknownFunction = UnknownFunction> exte
    * By chaining the spy with and.callFake, all calls to the spy will delegate to the supplied
    * function.
    */
-  andCallFake(fn: UnknownFunction): this;
+  andCallFake(fn: F): this;
 
   /**
    * removes all recorded calls

projects/spectator/test/spy-object/person.ts

@@ -6,6 +6,18 @@ export class Person {
     return 'Hi!';
   }
 
+  public saySomething(something: string): string {
+    return `You said: ${something}`;
+  }
+
+  public voidMethod(): void {
+    // Do nothing
+  }
+
+  public voidMethodWithArguments(arg1: string, arg2: number): void {
+    // Do nothing
+  }
+
   public get age(): number {
     return 2019 - this.birthYear;
   }

projects/spectator/test/spy-object/spy-object.spec.ts

@@ -6,7 +6,110 @@ describe('SpyObject', () => {
   it('should mock all public methods', () => {
     const person = createSpyObject(Person);
 
+    // Check methods without arguments but returns
     person.sayHi.andReturn('Bye!');
+
+    // Check method with different return types
+    // These shouldn not compile, but will with `@ts-expect-error` applied
+    // @ts-expect-error
+    person.sayHi.andReturn(false);
+    // @ts-expect-error
+    person.sayHi.andReturn(100);
+    // @ts-expect-error
+    person.sayHi.andReturn({ prop: true });
+    // @ts-expect-error
+    person.sayHi.andCallFake((): boolean => {
+      return false;
+    });
+    // @ts-expect-error
+    person.sayHi.andCallFake((): number => {
+      return 100;
+    });
+    // @ts-expect-error
+    person.sayHi.andCallFake((): { prop: boolean } => {
+      return { prop: true };
+    });
+
+    // Check methods with arguments
+    person.saySomething.andReturn('');
+    person.saySomething.withArgs('Testing').and.returnValue('You said: Testing');
+    person.saySomething.andCallFake((something: string) => {
+      return `You said: ${something}`;
+    });
+
+    // Check method with different return types
+    // These shouldn not compile, but will with `@ts-expect-error` applied
+    // @ts-expect-error
+    person.saySomething.andReturn(false);
+    // @ts-expect-error
+    person.saySomething.andReturn(100);
+    // @ts-expect-error
+    person.saySomething.andReturn({ prop: true });
+    // @ts-expect-error
+    person.saySomething.andCallFake((str: string): boolean => {
+      return false;
+    });
+    // @ts-expect-error
+    person.saySomething.andCallFake((str: string): number => {
+      return 100;
+    });
+    // @ts-expect-error
+    person.saySomething.andCallFake((str: string): { prop: boolean } => {
+      return { prop: true };
+    });
+    // @ts-expect-error
+    person.saySomething.andCallFake((num: number): string => {
+      return 'Wrong Argument Type';
+    });
+    // @ts-expect-error
+    person.saySomething.andCallFake((bool: boolean): string => {
+      return 'Wrong Argument Type';
+    });
+
+    // Check pure void methods
+    person.voidMethod.andCallFake(() => {});
+
+    // Check method with different return types
+    // These shouldn not compile, but will with `@ts-expect-error` applied
+    // @ts-expect-error
+    person.voidMethod.andReturn(false);
+    // @ts-expect-error
+    person.voidMethod.andReturn(100);
+    // @ts-expect-error
+    person.voidMethod.andReturn({ prop: true });
+
+    // These compile because a void method's return type isn't checked by the compiler
+    person.voidMethod.andCallFake((): boolean => {
+      return false;
+    });
+    person.voidMethod.andCallFake((): number => {
+      return 100;
+    });
+    person.voidMethod.andCallFake((): { prop: boolean } => {
+      return { prop: true };
+    });
+
+    // Check void methods with arguments
+    person.voidMethodWithArguments.andCallFake((arg1: string, arg2: number) => {
+      // Do nothing
+    });
+
+    // Check methods with different argument and return types
+    // These shouldn not compile, but will with `@ts-expect-error` applied
+    // @ts-expect-error
+    person.voidMethod.andReturn(false);
+    // @ts-expect-error
+    person.voidMethod.andReturn(100);
+    // @ts-expect-error
+    person.voidMethod.andReturn({ prop: true });
+    // @ts-expect-error
+    person.voidMethodWithArguments.andCallFake((arg1: string, arg2: string) => {});
+    // @ts-expect-error
+    person.voidMethodWithArguments.andCallFake((arg1: number, arg2: string) => {});
+
+    // These compile because an empty argument list is valid in Typescript.
+    // https://github.com/Microsoft/TypeScript/wiki/FAQ#why-are-functions-with-fewer-parameters-assignable-to-functions-that-take-more-parameters
+    person.voidMethodWithArguments.andCallFake(() => {});
   });
 
   it('should enable spying on properties', () => {