@types/jest

method jasmineMatches

jasmineMatches: (other: any) => boolean;

method jasmineToString

jasmineToString: () => string;

construct signature

new (expectedClass: any): any;

method asymmetricMatch

asymmetricMatch: (other: any) => boolean;

method jasmineToString

jasmineToString: () => string;

construct signature

new (sample: readonly any[]): any;

property length

length: number;

index signature

[n: number]: T;

property args

args: any[];

• All arguments passed to the call

property object

object: any;

• The context (the this) for the call

property returnValue

returnValue: any;

• The return value of the call

method all

all: () => CallInfo[];

• By chaining the spy with calls.all(), will return the context (the this) and arguments passed all calls

method allArgs

allArgs: () => any[];

• By chaining the spy with calls.allArgs(), will return the arguments to all calls

method any

any: () => boolean;

• By chaining the spy with calls.any(), will return false if the spy has not been called at all, and then true once at least one call happens.

method argsFor

argsFor: (index: number) => any[];

• By chaining the spy with calls.argsFor(), will return the arguments passed to call number index

method count

count: () => number;

• By chaining the spy with calls.count(), will return the number of times the spy was called

method first

first: () => CallInfo;

• By chaining the spy with calls.first(), will return the context (the this) and arguments for the first call

method mostRecent

mostRecent: () => CallInfo;

• By chaining the spy with calls.mostRecent(), will return the context (the this) and arguments for the most recent call

method reset

reset: () => void;

• By chaining the spy with calls.reset(), will clears all tracking for a spy

method install

install: () => void;

method mockDate

mockDate: (date?: Date) => void;

method tick

tick: (ms: number) => void;

• Calls to any registered callback are triggered when the clock isticked forward via the jasmine.clock().tick function, which takes a number of milliseconds.

method uninstall

uninstall: () => void;

method compare

compare: {
    <T>(actual: T, expected: T, ...args: any[]): CustomMatcherResult;
    (actual: any, ...expected: any[]): CustomMatcherResult;
};

index signature

[index: string]: CustomMatcherFactory;

property message

message: string | (() => string);

property pass

pass: boolean;

method buildFailureMessage

buildFailureMessage: (
    matcherName: string,
    isNot: boolean,
    actual: any,
    ...expected: any[]
) => string;

method contains

contains: <T>(
    haystack: ArrayLike<T> | string,
    needle: any,
    customTesters?: CustomEqualityTester[]
) => boolean;

method equals

equals: (a: any, b: any, customTesters?: CustomEqualityTester[]) => boolean;

method jasmineMatches

jasmineMatches: (
    other: any,
    mismatchKeys: any[],
    mismatchValues: any[]
) => boolean;

method jasmineToString

jasmineToString: () => string;

construct signature

new (sample: any): any;

property and

and: SpyAnd;

property argsForCall

argsForCall: any[];

property calls

calls: Calls;

property identity

identity: string;

property mostRecentCall

mostRecentCall: { args: any[] };

property wasCalled

wasCalled: boolean;

call signature

(...params: any[]): any;

method callFake

callFake: (fn: (...args: any[]) => any) => Spy;

• By chaining the spy with and.callFake, all calls to the spy will delegate to the supplied function.

method callThrough

callThrough: () => Spy;

• By chaining the spy with and.callThrough, the spy will still track all calls to it but in addition it will delegate to the actual implementation.

method returnValue

returnValue: (val: any) => Spy;

• By chaining the spy with and.returnValue, all calls to the function will return a specific value.

method returnValues

returnValues: (...values: any[]) => Spy;

• By chaining the spy with and.returnValues, all calls to the function will return specific values in order until it reaches the end of the return values list.

method stub

stub: () => Spy;

• When a calling strategy is used for a spy, the original stubbing behavior can be returned at any time with and.stub.

method throwError

throwError: (msg: string) => Spy;

• By chaining the spy with and.throwError, all calls to the spy will throw the specified value.

method asymmetricMatch

asymmetricMatch: (other: unknown) => boolean;

construct signature

new (...args: any[]): any;

property message

message: () => string;

property pass

pass: boolean;

property each

each: Each;

property only

only: Describe;

• Only runs the tests inside this describe for the current file

property skip

skip: Describe;

• Skips running the tests inside this describe for the current file

call signature

(name: number | string | Function | FunctionLike, fn: EmptyFunction): void;

method fail

fail: (error?: string | { message: string }) => any;

call signature

(...args: any[]): any;

call signature

<T extends any[] | [any]>(cases: readonly T[]): (
    name: string,
    fn: (...args: T) => any,
    timeout?: number
) => void;

call signature

<T extends readonly any[]>(cases: readonly T[]): (
    name: string,
    fn: (...args: ExtractEachCallbackArgs<T>) => any,
    timeout?: number
) => void;

call signature

<T>(cases: readonly T[]): (
    name: string,
    fn: (arg: T, done: DoneCallback) => any,
    timeout?: number
) => void;

call signature

(cases: ReadonlyArray<readonly any[]>): (
    name: string,
    fn: (...args: any[]) => any,
    timeout?: number
) => void;

call signature

(strings: TemplateStringsArray, ...placeholders: any[]): (
    name: string,
    fn: (arg: any, done: DoneCallback) => any,
    timeout?: number
) => void;

property not

not: InverseAsymmetricMatchers;

method addSnapshotSerializer

addSnapshotSerializer: (serializer: any) => void;

• Adds a module to format application-specific data structures for serialization.

method any

any: (classType: any) => any;

• Matches anything that was created with the given constructor. You can use it inside toEqual or toBeCalledWith instead of a literal value.

  Example 1

  function randocall(fn) { return fn(Math.floor(Math.random() * 6 + 1)); }

  test('randocall calls its callback with a number', () => { const mock = jest.fn(); randocall(mock); expect(mock).toBeCalledWith(expect.any(Number)); });

method anything

anything: () => any;

• Matches anything but null or undefined. You can use it inside toEqual or toBeCalledWith instead of a literal value. For example, if you want to check that a mock function is called with a non-null argument:

  Example 1

  test('map calls its argument with a non-null argument', () => { const mock = jest.fn(); [1].map(x => mock(x)); expect(mock).toBeCalledWith(expect.anything()); });

method arrayContaining

arrayContaining: <E = any>(arr: readonly E[]) => any;

• Matches any array made up entirely of elements in the provided array. You can use it inside toEqual or toBeCalledWith instead of a literal value.

  Optionally, you can provide a type for the elements via a generic.

method assertions

assertions: (num: number) => void;

• Verifies that a certain number of assertions are called during a test. This is often useful when testing asynchronous code, in order to make sure that assertions in a callback actually got called.

method closeTo

closeTo: (num: number, numDigits?: number) => any;

• Useful when comparing floating point numbers in object properties or array item. If you need to compare a number, use .toBeCloseTo instead.

  The optional numDigits argument limits the number of digits to check after the decimal point. For the default value 2, the test criterion is Math.abs(expected - received) < 0.005 (that is, 10 ** -2 / 2).

method extend

extend: (obj: ExpectExtendMap) => void;

• You can use expect.extend to add your own matchers to Jest.

method getState

getState: () => MatcherState & Record<string, any>;

method hasAssertions

hasAssertions: () => void;

• Verifies that at least one assertion is called during a test. This is often useful when testing asynchronous code, in order to make sure that assertions in a callback actually got called.

method objectContaining

objectContaining: <E = {}>(obj: E) => any;

• Matches any object that recursively matches the provided keys. This is often handy in conjunction with other asymmetric matchers.

  Optionally, you can provide a type for the object via a generic. This ensures that the object contains the desired structure.

method setState

setState: (state: object) => void;

method stringContaining

stringContaining: (str: string) => any;

• Matches any received string that contains the exact expected string

method stringMatching

stringMatching: (str: string | RegExp) => any;

• Matches any string that contains the exact provided string

call signature

<T = any>(actual: T): JestMatchers<T>;

• The expect function is used every time you want to test a value. You will rarely call expect by itself.

  Parameter actual

  The value to apply matchers against.

index signature

[key: string]: CustomMatcher;

property name

readonly name: string;

method arrayContaining

arrayContaining: <E = any>(arr: readonly E[]) => any;

• expect.not.arrayContaining(array) matches a received array which does not contain all of the elements in the expected array. That is, the expected array is not a subset of the received array. It is the inverse of expect.arrayContaining.

  Optionally, you can provide a type for the elements via a generic.

method objectContaining

objectContaining: <E = {}>(obj: E) => any;

• expect.not.objectContaining(object) matches any received object that does not recursively match the expected properties. That is, the expected object is not a subset of the received object. Therefore, it matches a received object which contains properties that are not in the expected object. It is the inverse of expect.objectContaining.

  Optionally, you can provide a type for the object via a generic. This ensures that the object contains the desired structure.

method stringContaining

stringContaining: (str: string) => any;

• expect.not.stringContaining(string) matches the received string that does not contain the exact expected string. It is the inverse of expect.stringContaining.

method stringMatching

stringMatching: (str: string | RegExp) => any;

• expect.not.stringMatching(string | regexp) matches the received string that does not match the expected regexp. It is the inverse of expect.stringMatching.

property concurrent

concurrent: It;

• Experimental and should be avoided.

property each

each: Each;

• Use if you keep duplicating the same test with different data. .each allows you to write the test once and pass data in.

  .each is available with two APIs:

  #### 1 test.each(table)(name, fn)

  - table: Array of Arrays with the arguments that are passed into the test fn for each row. - name: String the title of the test block. - fn: Function the test to be run, this is the function that will receive the parameters in each row as function arguments.

  #### 2 test.each table(name, fn)

  - table: Tagged Template Literal - name: String the title of the test, use $variable to inject test data into the test title from the tagged template expressions. - fn: Function the test to be run, this is the function that will receive the test data object.

  Example 1

  // API 1 test.each([[1, 1, 2], [1, 2, 3], [2, 1, 3]])( '.add(%i, %i)', (a, b, expected) => { expect(a + b).toBe(expected); }, );

  // API 2 test.each` a | b | expected ${1} | ${1} | ${2} ${1} | ${2} | ${3} ${2} | ${1} | ${3} `('returns $expected when $a is added $b', ({a, b, expected}) => { expect(a + b).toBe(expected); });

property failing

failing: It;

• Mark this test as expecting to fail.

  Only available in the default jest-circus runner.

property only

only: It;

• Only runs this test in the current file.

property skip

skip: It;

• Skips running this test in the current file.

property todo

todo: (name: string) => void;

• Sketch out which tests to write in the future.

call signature

(name: string, fn?: ProvidesCallback, timeout?: number): void;

• Creates a test closure.

  Parameter name

  The name of your test

  Parameter fn

  The function for your test

  Parameter timeout

  The timeout for an async function test

method lastCalledWith

lastCalledWith: <E extends any[]>(...args: E) => R;

• Ensures the last call to a mock function was provided specific args.

  Optionally, you can provide a type for the expected arguments via a generic. Note that the type must be either an array or a tuple.

  Deprecated

  in favor of toHaveBeenLastCalledWith

method lastReturnedWith

lastReturnedWith: <E = any>(expected?: E) => R;

• Ensure that the last call to a mock function has returned a specified value.

  Optionally, you can provide a type for the expected value via a generic. This is particularly useful for ensuring expected objects have the right structure.

  Deprecated

  in favor of toHaveLastReturnedWith

method nthCalledWith

nthCalledWith: <E extends any[]>(nthCall: number, ...params: E) => R;

• Ensure that a mock function is called with specific arguments on an Nth call.

  Optionally, you can provide a type for the expected arguments via a generic. Note that the type must be either an array or a tuple.

  Deprecated

  in favor of toHaveBeenNthCalledWith

method nthReturnedWith

nthReturnedWith: <E = any>(n: number, expected?: E) => R;

• Ensure that the nth call to a mock function has returned a specified value.

  Optionally, you can provide a type for the expected value via a generic. This is particularly useful for ensuring expected objects have the right structure.

  Deprecated

  in favor of toHaveNthReturnedWith

method toBe

toBe: <E = any>(expected: E) => R;

• Checks that a value is what you expect. It uses Object.is to check strict equality. Don't use toBe with floating-point numbers.

  Optionally, you can provide a type for the expected value via a generic. This is particularly useful for ensuring expected objects have the right structure.

method toBeCalled

toBeCalled: () => R;

• Ensures that a mock function is called.

  Deprecated

  in favor of toHaveBeenCalled

method toBeCalledTimes

toBeCalledTimes: (expected: number) => R;

• Ensures that a mock function is called an exact number of times.

  Deprecated

  in favor of toHaveBeenCalledTimes

method toBeCalledWith

toBeCalledWith: <E extends any[]>(...args: E) => R;

• Ensure that a mock function is called with specific arguments.

  Optionally, you can provide a type for the expected arguments via a generic. Note that the type must be either an array or a tuple.

  Deprecated

  in favor of toHaveBeenCalledWith

method toBeCloseTo

toBeCloseTo: (expected: number, numDigits?: number) => R;

• Using exact equality with floating point numbers is a bad idea. Rounding means that intuitive things fail. The default for numDigits is 2.

method toBeDefined

toBeDefined: () => R;

• Ensure that a variable is not undefined.

method toBeFalsy

toBeFalsy: () => R;

• When you don't care what a value is, you just want to ensure a value is false in a boolean context.

method toBeGreaterThan

toBeGreaterThan: (expected: number | bigint) => R;

• For comparing floating point or big integer numbers.

method toBeGreaterThanOrEqual

toBeGreaterThanOrEqual: (expected: number | bigint) => R;

• For comparing floating point or big integer numbers.

method toBeInstanceOf

toBeInstanceOf: <E = any>(expected: E) => R;

• Ensure that an object is an instance of a class. This matcher uses instanceof underneath.

  Optionally, you can provide a type for the expected value via a generic. This is particularly useful for ensuring expected objects have the right structure.

method toBeLessThan

toBeLessThan: (expected: number | bigint) => R;

• For comparing floating point or big integer numbers.

method toBeLessThanOrEqual

toBeLessThanOrEqual: (expected: number | bigint) => R;

• For comparing floating point or big integer numbers.

method toBeNaN

toBeNaN: () => R;

• Used to check that a variable is NaN.

method toBeNull

toBeNull: () => R;

• This is the same as .toBe(null) but the error messages are a bit nicer. So use .toBeNull() when you want to check that something is null.

method toBeTruthy

toBeTruthy: () => R;

• Use when you don't care what a value is, you just want to ensure a value is true in a boolean context. In JavaScript, there are six falsy values: false, 0, '', null, undefined, and NaN. Everything else is truthy.

method toBeUndefined

toBeUndefined: () => R;

• Used to check that a variable is undefined.

method toContain

toContain: <E = any>(expected: E) => R;

• Used when you want to check that an item is in a list. For testing the items in the list, this uses ===, a strict equality check. It can also check whether a string is a substring of another string.

  Optionally, you can provide a type for the expected value via a generic. This is particularly useful for ensuring expected objects have the right structure.

method toContainEqual

toContainEqual: <E = any>(expected: E) => R;

• Used when you want to check that an item is in a list. For testing the items in the list, this matcher recursively checks the equality of all fields, rather than checking for object identity.

  Optionally, you can provide a type for the expected value via a generic. This is particularly useful for ensuring expected objects have the right structure.

method toEqual

toEqual: <E = any>(expected: E) => R;

• Used when you want to check that two objects have the same value. This matcher recursively checks the equality of all fields, rather than checking for object identity.

  Optionally, you can provide a type for the expected value via a generic. This is particularly useful for ensuring expected objects have the right structure.

method toHaveBeenCalled

toHaveBeenCalled: () => R;

• Ensures that a mock function is called.

method toHaveBeenCalledTimes

toHaveBeenCalledTimes: (expected: number) => R;

• Ensures that a mock function is called an exact number of times.

method toHaveBeenCalledWith

toHaveBeenCalledWith: <E extends any[]>(...params: E) => R;

• Ensure that a mock function is called with specific arguments.

  Optionally, you can provide a type for the expected arguments via a generic. Note that the type must be either an array or a tuple.

method toHaveBeenLastCalledWith

toHaveBeenLastCalledWith: <E extends any[]>(...params: E) => R;

• If you have a mock function, you can use .toHaveBeenLastCalledWith to test what arguments it was last called with.

  Optionally, you can provide a type for the expected arguments via a generic. Note that the type must be either an array or a tuple.

method toHaveBeenNthCalledWith

toHaveBeenNthCalledWith: <E extends any[]>(nthCall: number, ...params: E) => R;

• Ensure that a mock function is called with specific arguments on an Nth call.

  Optionally, you can provide a type for the expected arguments via a generic. Note that the type must be either an array or a tuple.

method toHaveLastReturnedWith

toHaveLastReturnedWith: <E = any>(expected?: E) => R;

• Use to test the specific value that a mock function last returned. If the last call to the mock function threw an error, then this matcher will fail no matter what value you provided as the expected return value.

  Optionally, you can provide a type for the expected value via a generic. This is particularly useful for ensuring expected objects have the right structure.

method toHaveLength

toHaveLength: (expected: number) => R;