test.default.MockFunctionContext

interface MockFunctionContext<F extends Function>

• readonly calls: MockFunctionCall<F, F extends (...args: any) => T ? T : F extends new (...args: any) => T ? T : unknown, F extends (...args: Y) => any ? Y : F extends new (...args: Y) => any ? Y : unknown[]>[]

  A getter that returns a copy of the internal array used to track calls to the mock. Each entry in the array is an object with the following properties.

• callCount(): number;

  This function returns the number of times that this mock has been invoked. This function is more efficient than checking ctx.calls.length because ctx.calls is a getter that creates a copy of the internal call tracking array.

  @returns

  The number of times that this mock has been invoked.

• mockImplementation(

  implementation: F

  ): void;

  This function is used to change the behavior of an existing mock.

  The following example creates a mock function using t.mock.fn(), calls the mock function, and then changes the mock implementation to a different function.

  test('changes a mock behavior', (t) => {
    let cnt = 0;
  
    function addOne() {
      cnt++;
      return cnt;
    }
  
    function addTwo() {
      cnt += 2;
      return cnt;
    }
  
    const fn = t.mock.fn(addOne);
  
    assert.strictEqual(fn(), 1);
    fn.mock.mockImplementation(addTwo);
    assert.strictEqual(fn(), 3);
    assert.strictEqual(fn(), 5);
  });
  

  @param implementation

  The function to be used as the mock's new implementation.

• mockImplementationOnce(

  implementation: F,

  onCall?: number

  ): void;

  This function is used to change the behavior of an existing mock for a single invocation. Once invocation onCall has occurred, the mock will revert to whatever behavior it would have used had mockImplementationOnce() not been called.

  The following example creates a mock function using t.mock.fn(), calls the mock function, changes the mock implementation to a different function for the next invocation, and then resumes its previous behavior.

  test('changes a mock behavior once', (t) => {
    let cnt = 0;
  
    function addOne() {
      cnt++;
      return cnt;
    }
  
    function addTwo() {
      cnt += 2;
      return cnt;
    }
  
    const fn = t.mock.fn(addOne);
  
    assert.strictEqual(fn(), 1);
    fn.mock.mockImplementationOnce(addTwo);
    assert.strictEqual(fn(), 3);
    assert.strictEqual(fn(), 4);
  });
  

  @param implementation

  The function to be used as the mock's implementation for the invocation number specified by onCall.

  @param onCall

  The invocation number that will use implementation. If the specified invocation has already occurred then an exception is thrown.

• resetCalls(): void;

  Resets the call history of the mock function.

• restore(): void;

  Resets the implementation of the mock function to its original behavior. The mock can still be used after calling this function.