Comunica
    Preparing search index...

    Interface Mock<T, Y, C>

    interface Mock<T = any, Y extends any[] = any, C = any> {
        new Mock(...args: Y): T;
        arguments: any;
        caller: Function;
        length: number;
        mock: MockContext<T, Y, C>;
        name: string;
        prototype: any;
        "[hasInstance]"(value: any): boolean;
        apply(this: Function, thisArg: any, argArray?: any): any;
        bind(this: Function, thisArg: any, ...argArray: any[]): any;
        call(this: Function, thisArg: any, ...argArray: any[]): any;
        getMockImplementation(): undefined | ((...args: Y) => T);
        getMockName(): string;
        mockClear(): this;
        mockImplementation(fn?: (...args: Y) => T): this;
        mockImplementationOnce(fn: (...args: Y) => T): this;
        mockName(name: string): this;
        mockRejectedValue(value: RejectedValue<T>): this;
        mockRejectedValueOnce(value: RejectedValue<T>): this;
        mockReset(): this;
        mockResolvedValue(value: ResolvedValue<T>): this;
        mockResolvedValueOnce(value: ResolvedValue<T>): this;
        mockRestore(): void;
        mockReturnThis(): this;
        mockReturnValue(value: T): this;
        mockReturnValueOnce(value: T): this;
        toString(): string;
        withImplementation(
            fn: (...args: Y) => T,
            callback: () => Promise<unknown>,
        ): Promise<void>;
        withImplementation(fn: (...args: Y) => T, callback: () => void): void;
        (this: C, ...args: Y): T;
    }

    Type Parameters

    • T = any
    • Y extends any[] = any
    • C = any

    Hierarchy (View Summary)

    • Parameters

      • this: C
      • ...args: Y

      Returns T

    Index

    Constructors

    constructor

    Properties

    arguments caller length mock name prototype

    Methods

    [hasInstance] apply bind call getMockImplementation getMockName mockClear mockImplementation mockImplementationOnce mockName mockRejectedValue mockRejectedValueOnce mockReset mockResolvedValue mockResolvedValueOnce mockRestore mockReturnThis mockReturnValue mockReturnValueOnce toString withImplementation

    Constructors

    • Parameters

      • ...args: Y

      Returns T

    Properties

    arguments: any
    caller: Function
    length: number
    mock: MockContext<T, Y, C>

    Provides access to the mock's metadata

    name: string

    Returns the name of the function. Function names are read-only and can not be changed.

    prototype: any

    Methods

    • Determines whether the given value inherits from this function if this function was used as a constructor function.

      A constructor function can control which objects are recognized as its instances by 'instanceof' by overriding this method.

      Parameters

      • value: any

      Returns boolean

    • Calls the function, substituting the specified object for the this value of the function, and the specified array for the arguments of the function.

      Parameters

      • this: Function
      • thisArg: any

        The object to be used as the this object.

      • OptionalargArray: any

        A set of arguments to be passed to the function.

      Returns any

    • For a given function, creates a bound function that has the same body as the original function. The this object of the bound function is associated with the specified object, and has the specified initial parameters.

      Parameters

      • this: Function
      • thisArg: any

        An object to which the this keyword can refer inside the new function.

      • ...argArray: any[]

        A list of arguments to be passed to the new function.

      Returns any

    • Calls a method of an object, substituting another object for the current object.

      Parameters

      • this: Function
      • thisArg: any

        The object to be used as the current object.

      • ...argArray: any[]

        A list of arguments to be passed to the method.

      Returns any

    • Returns the function that was set as the implementation of the mock (using mockImplementation).

      Returns undefined | ((...args: Y) => T)

    • Returns the mock name string set by calling mockFn.mockName(value).

      Returns string

    • Resets all information stored in the mockFn.mock.calls and mockFn.mock.instances arrays.

      Often this is useful when you want to clean up a mock's usage data between two assertions.

      Beware that mockClear will replace mockFn.mock, not just mockFn.mock.calls and mockFn.mock.instances. You should therefore avoid assigning mockFn.mock to other variables, temporary or not, to make sure you don't access stale data.

      Returns this

    • Accepts a function that should be used as the implementation of the mock. The mock itself will still record all calls that go into and instances that come from itself – the only difference is that the implementation will also be executed when the mock is called.

      Note: jest.fn(implementation) is a shorthand for jest.fn().mockImplementation(implementation).

      Parameters

      • Optionalfn: (...args: Y) => T

      Returns this

    • Accepts a function that will be used as an implementation of the mock for one call to the mocked function. Can be chained so that multiple function calls produce different results.

      Parameters

      • fn: (...args: Y) => T

      Returns this

      const myMockFn = jest
        .fn()
         .mockImplementationOnce(cb => cb(null, true))
         .mockImplementationOnce(cb => cb(null, false));

      myMockFn((err, val) => console.log(val)); // true

      myMockFn((err, val) => console.log(val)); // false

    • Sets the name of the mock.

      Parameters

      • name: string

      Returns this

    • Simple sugar function for: jest.fn().mockImplementation(() => Promise.reject(value));

      Parameters

      Returns this

      test('async test', async () => {
        const asyncMock = jest.fn().mockRejectedValue(new Error('Async error'));

        await asyncMock(); // throws "Async error"
      });

    • Simple sugar function for: jest.fn().mockImplementationOnce(() => Promise.reject(value));

      Parameters

      Returns this

      test('async test', async () => {
       const asyncMock = jest
         .fn()
         .mockResolvedValueOnce('first call')
         .mockRejectedValueOnce(new Error('Async error'));

       await asyncMock(); // first call
       await asyncMock(); // throws "Async error"
      });

    • Resets all information stored in the mock, including any initial implementation and mock name given.

      This is useful when you want to completely restore a mock back to its initial state.

      Beware that mockReset will replace mockFn.mock, not just mockFn.mock.calls and mockFn.mock.instances. You should therefore avoid assigning mockFn.mock to other variables, temporary or not, to make sure you don't access stale data.

      Returns this

    • Simple sugar function for: jest.fn().mockImplementationOnce(() => Promise.resolve(value));

      Parameters

      Returns this

      test('async test', async () => {
       const asyncMock = jest
         .fn()
         .mockResolvedValue('default')
         .mockResolvedValueOnce('first call')
         .mockResolvedValueOnce('second call');

       await asyncMock(); // first call
       await asyncMock(); // second call
       await asyncMock(); // default
       await asyncMock(); // default
      });

    • Does everything that mockFn.mockReset() does, and also restores the original (non-mocked) implementation.

      This is useful when you want to mock functions in certain test cases and restore the original implementation in others.

      Beware that mockFn.mockRestore only works when mock was created with jest.spyOn. Thus you have to take care of restoration yourself when manually assigning jest.fn().

      The restoreMocks configuration option is available to restore mocks automatically between tests.

      Returns void

    • Just a simple sugar function for:

      Returns this

      jest.fn(function() {
          return this;
        });

    • Accepts a value that will be returned whenever the mock function is called.

      Parameters

      • value: T

      Returns this

      const mock = jest.fn();
      mock.mockReturnValue(42);
      mock(); // 42
      mock.mockReturnValue(43);
      mock(); // 43

    • Accepts a value that will be returned for one call to the mock function. Can be chained so that successive calls to the mock function return different values. When there are no more mockReturnValueOnce values to use, calls will return a value specified by mockReturnValue.

      Parameters

      • value: T

      Returns this

      const myMockFn = jest.fn()
        .mockReturnValue('default')
        .mockReturnValueOnce('first call')
        .mockReturnValueOnce('second call');

      // 'first call', 'second call', 'default', 'default'
      console.log(myMockFn(), myMockFn(), myMockFn(), myMockFn());

    • Returns a string representation of a function.

      Returns string

    • Temporarily overrides the default mock implementation within the callback, then restores its previous implementation.

      Parameters

      • fn: (...args: Y) => T
      • callback: () => Promise<unknown>

      Returns Promise<void>

      If the callback is async or returns a thenable, withImplementation will return a promise. Awaiting the promise will await the callback and reset the implementation.

    • Temporarily overrides the default mock implementation within the callback, then restores its previous implementation.

      Parameters

      • fn: (...args: Y) => T
      • callback: () => void

      Returns void

    Settings

    Member Visibility

    On This Page

    Constructors
    Properties
    Methods