toHaveBeenCalledBefore and toHaveBeenCalledAfter don't accept result of jest.fn()

[Lukas-Kullmann]

Bug

• package version: 3.2.3
• node version: 18.13.0
• npm (or yarn) version: 8.19.3

I want to use toHaveBeenCalledBefore (or ...After) with the result of a jest.fn(). However, I get a typescript error.

declare const myFn: (argument: string) => void;

expect(jest.fn()).toHaveBeenCalledAfter(jest.fn(myFn));
// ----- error is here -----------------^^^^^^^^^^^^^

This results in an error:

Argument of type 'Mock<void, [argument: string]>' is not assignable to parameter of type 'MockInstance<unknown, unknown[]>'.
  The types returned by 'getMockImplementation()' are incompatible between these types.
    Type '((argument: string) => void) | undefined' is not assignable to type '((...args: unknown[]) => unknown) | undefined'.
      Type '(argument: string) => void' is not assignable to type '(...args: unknown[]) => unknown'.
        Types of parameters 'argument' and 'args' are incompatible.
          Type 'unknown' is not assignable to type 'string'.(2345)

Here's a typescript playground link that basically reproduces the issue: playground link

I think the problem was introduced in #477 where the argument of toHaveBeenCalledAfter was changed from jest.MockInstance<any, any[]> to jest.MockInstance<unknown, unknown[]>.

If I change it back to the anys in my playground, I don't get the error.

Workaround

I fixed it temporarily in our project by creating my own .d.ts file with the following content.
However, it would be great if the library could fix it.

declare namespace jest {
  interface Matchers<R> {
    toHaveBeenCalledBefore(
      mock: jest.MockInstance<any, any[]>,
      failIfNoFirstInvocation?: boolean,
    ): R;
    toHaveBeenCalledAfter(
      mock: jest.MockInstance<any, any[]>,
      failIfNoFirstInvocation?: boolean,
    ): R;
  }
}

[keeganwitt]

What's interesting is this work fine

test('toHaveBeenCalledBefore and toHaveBeenCalledAfter empty', () => {
    const mock = jest.fn();
    expect(mock).not.toHaveBeenCalledAfter(mock);
    expect(mock).not.toHaveBeenCalledBefore(mock);
});

But this does not

test('toHaveBeenCalledBefore and toHaveBeenCalledAfter with mockFunction', () => {
    const myFn = (arg: string) => void {};
    expect(jest.fn()).not.toHaveBeenCalledAfter(jest.fn(myFn));
    expect(jest.fn()).not.toHaveBeenCalledBefore(jest.fn(myFn));
});