chore: DRYing verifiers

mod.ts

@@ -1,4 +1,4 @@
-import type { Callable, Constructor, MethodOf, StubReturnValue } from "./src/types.ts";
+import type { Constructor, MethodOf } from "./src/types.ts";
 import { MockBuilder } from "./src/mock/mock_builder.ts";
 import { FakeBuilder } from "./src/fake/fake_builder.ts";
 import { SpyBuilder } from "./src/spy/spy_builder.ts";
@@ -76,9 +76,11 @@ export function Mock<T>(constructorFn: Constructor<T>): MockBuilder<T> {
 ////////////////////////////////////////////////////////////////////////////////
 
 export function Spy<ReturnValue>(
-  fn: (...args: unknown[]) => ReturnValue,
+  // deno-lint-ignore no-explicit-any
+  fn: (...args: any[]) => ReturnValue,
   returnValue?: ReturnValue
-): Interfaces.ISpyStubFunctionExpression & Callable<ReturnValue>;
+  // deno-lint-ignore no-explicit-any
+): Interfaces.ISpyStubFunctionExpression & ((...args: any[]) => ReturnValue);
 
 /**
  * Create spy out of a class. Example:
@@ -203,7 +205,7 @@ export function Stub<OriginalObject, ReturnValue>(
   obj: OriginalObject,
   dataMember: keyof OriginalObject,
   returnValue?: ReturnValue,
-): StubReturnValue<OriginalObject, ReturnValue>;
+): void;
 /**
  * Take the given object and stub its given data member to return the given
  * return value.

src/interfaces.ts

@@ -1,4 +1,4 @@
-import type { MethodCalls, MethodOf } from "./types.ts";
+import type { MethodOf, MockMethodCalls } from "./types.ts";
 
 export interface IMethodExpectation {
   toBeCalled(expectedCalls: number): void;
@@ -18,7 +18,7 @@ export interface IMethodVerification {
    * @returns `this` To allow method chaining.
    */
   toBeCalled(expectedCalls?: number): this;
-  toBeCalledWithArgs(...args: unknown[]): this;
+  toBeCalledWithArgs(firstArg: unknown, ...restOfArgs: unknown[]): this;
   toBeCalledWithoutArgs(): this;
 }
 
@@ -60,7 +60,14 @@ export interface IFake<OriginalObject> {
 }
 
 export interface IMock<OriginalObject> {
-  calls: MethodCalls<OriginalObject>;
+  /**
+   * Property to track method calls.
+   */
+  calls: MockMethodCalls<OriginalObject>;
+
+  /**
+   * Helper property to see that this is a mock object and not the original.
+   */
   is_mock: boolean;
 
   /**

src/mock/mock_mixin.ts

@@ -1,7 +1,7 @@
 import type { IMock } from "../interfaces.ts";
-import type { Constructor, MethodCalls, MethodOf } from "../types.ts";
+import type { Constructor, MethodOf, MockMethodCalls } from "../types.ts";
 
-import { MethodVerifier } from "../method_verifier.ts";
+import { MethodVerifier } from "../verifiers/method_verifier.ts";
 import { MockError } from "../errors.ts";
 import { PreProgrammedMethod } from "../pre_programmed_method.ts";
 
@@ -12,7 +12,7 @@ class MethodExpectation<OriginalObject> {
   /**
    * Property to hold the number of expected calls this method should receive.
    */
-  #expected_calls = 0;
+  #expected_calls?: number | undefined;
 
   /**
    * See `MethodVerifier#method_name`.
@@ -55,7 +55,7 @@ class MethodExpectation<OriginalObject> {
    * to -1 to tell `MethodVerifier` to "just check that the method was called".
    */
   public toBeCalled(expectedCalls?: number): void {
-    this.#expected_calls = expectedCalls ?? -1;
+    this.#expected_calls = expectedCalls;
   }
 
   // public verify(actualCalls: number, actualArgs: unknown[]): void {
@@ -68,24 +68,9 @@ class MethodExpectation<OriginalObject> {
    * @param actualCalls - The number of actual calls.
    */
   public verifyCalls(actualCalls: number): void {
-    // If the expected calls is -1, then we do not show anything in the third
-    // argument to `this.#verifier.toBeCalled()`. Reason being we want to show
-    // this in the error stack trace ...
-    //
-    //     .expects("someMethod").toBeCalled()
-    //
-    // ... and not this ...
-    //
-    //     .expects("someMethod").toBeCalled(-1)
-    //
-    const expectedCalls = this.#expected_calls !== -1
-      ? ""
-      : `${this.#expected_calls}`;
-
     this.#verifier.toBeCalled(
       actualCalls,
       this.#expected_calls,
-      `.expects("${this.#method_name}").toBeCalled(${expectedCalls})`,
     );
   }
 }
@@ -106,14 +91,14 @@ export function createMock<OriginalConstructor, OriginalObject>(
   >;
   return new class MockExtension extends Original {
     /**
-     * Helper property to see that this is a mock object and not the original.
+     * See `IMock#is_mock`.
      */
     is_mock = true;
 
     /**
-     * Property to track method calls.
+     * See `IMock#calls`.
      */
-    #calls!: MethodCalls<OriginalObject>;
+    #calls!: MockMethodCalls<OriginalObject>;
 
     /**
      * An array of expectations to verify (if any).
@@ -129,7 +114,7 @@ export function createMock<OriginalConstructor, OriginalObject>(
     // FILE MARKER - GETTERS / SETTERS /////////////////////////////////////////
     ////////////////////////////////////////////////////////////////////////////
 
-    get calls(): MethodCalls<OriginalObject> {
+    get calls(): MockMethodCalls<OriginalObject> {
       return this.#calls;
     }
 

src/spy/spy_mixin.ts

@@ -81,7 +81,7 @@ export function createSpy<OriginalConstructor, OriginalObject>(
       methodsToTrack.forEach((method: string) => {
         const spyMethod = new SpyStubBuilder(this)
           .method(method as MethodOf<this>)
-          .returnValue("stubbed")
+          .returnValue("spy-stubbed")
           .createForObjectMethod();
         stubbedMethods[method as MethodOf<OriginalObject>] = spyMethod;
       });