expect

constructor

constructor(sample: {}, inverse?: boolean);

property $$typeof

$$typeof: Symbol;

property inverse

protected inverse: boolean;

property sample

protected sample: {};

method asymmetricMatch

abstract asymmetricMatch: (other: unknown) => boolean;

method getExpectedType

getExpectedType: () => string;

method getMatcherContext

protected getMatcherContext: () => MatcherContext;

method toAsymmetricMatcher

toAsymmetricMatcher: () => string;

method toString

abstract toString: () => string;

property matcherResult

matcherResult?: Omit<SyncExpectationResult, 'message'> & { message: string };

method any

any: (sample: unknown) => AsymmetricMatcher_2;

method anything

anything: () => AsymmetricMatcher_2;

method arrayContaining

arrayContaining: (sample: Array<unknown>) => AsymmetricMatcher_2;

method arrayOf

arrayOf: (sample: unknown) => AsymmetricMatcher_2;

method closeTo

closeTo: (sample: number, precision?: number) => AsymmetricMatcher_2;

method objectContaining

objectContaining: (sample: Record<string, unknown>) => AsymmetricMatcher_2;

method stringContaining

stringContaining: (sample: string) => AsymmetricMatcher_2;

method stringMatching

stringMatching: (sample: string | RegExp) => AsymmetricMatcher_2;

method addEqualityTesters

addEqualityTesters: (testers: Array<Tester>) => void;

method assertions

assertions: (numberOfAssertions: number) => void;

method extend

extend: (matchers: MatchersObject) => void;

method extractExpectedAssertionsErrors

extractExpectedAssertionsErrors: () => ExpectedAssertionsErrors;

method getState

getState: () => MatcherState;

method hasAssertions

hasAssertions: () => void;

method setState

setState: (state: Partial<MatcherState>) => void;

method toBe

toBe: (expected: unknown) => R;

• Checks that a value is what you expect. It calls Object.is to compare values. Don't use toBe with floating-point numbers.

method toBeCloseTo

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

• Using exact equality with floating point numbers is a bad idea. Rounding means that intuitive things fail. The default for precision 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 numbers.

method toBeGreaterThanOrEqual

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

• For comparing floating point numbers.

method toBeInstanceOf

toBeInstanceOf: (expected: unknown) => R;

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

method toBeLessThan

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

• For comparing floating point numbers.

method toBeLessThanOrEqual

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

• For comparing floating point 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: (expected: unknown) => 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.

method toContainEqual

toContainEqual: (expected: unknown) => 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.

method toEqual

toEqual: (expected: unknown) => 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.

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: (...expected: MockParameters<T>) => R;

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

method toHaveBeenLastCalledWith

toHaveBeenLastCalledWith: (...expected: MockParameters<T>) => R;

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

method toHaveBeenNthCalledWith

toHaveBeenNthCalledWith: (nth: number, ...expected: MockParameters<T>) => R;

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

method toHaveLastReturnedWith

toHaveLastReturnedWith: (expected?: unknown) => 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.

method toHaveLength

toHaveLength: (expected: number) => R;

• Used to check that an object has a .length property and it is set to a certain numeric value.

method toHaveNthReturnedWith

toHaveNthReturnedWith: (nth: number, expected?: unknown) => R;

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

method toHaveProperty

toHaveProperty: (
    expectedPath: string | Array<string>,
    expectedValue?: unknown
) => R;

• Use to check if property at provided reference keyPath exists for an object. For checking deeply nested properties in an object you may use dot notation or an array containing the keyPath for deep references.

  Optionally, you can provide a value to check if it's equal to the value present at keyPath on the target object. This matcher uses 'deep equality' (like toEqual()) and recursively checks the equality of all fields.

  Example 1

  expect(houseForSale).toHaveProperty('kitchen.area', 20);

method toHaveReturned

toHaveReturned: () => R;

• Use to test that the mock function successfully returned (i.e., did not throw an error) at least one time

method toHaveReturnedTimes

toHaveReturnedTimes: (expected: number) => R;

• Use to ensure that a mock function returned successfully (i.e., did not throw an error) an exact number of times. Any calls to the mock function that throw an error are not counted toward the number of times the function returned.

method toHaveReturnedWith

toHaveReturnedWith: (expected?: unknown) => R;

• Use to ensure that a mock function returned a specific value.

method toMatch

toMatch: (expected: string | RegExp) => R;

• Check that a string matches a regular expression.

method toMatchObject

toMatchObject: (
    expected: Record<string, unknown> | Array<Record<string, unknown>>
) => R;

• Used to check that a JavaScript object matches a subset of the properties of an object

method toStrictEqual

toStrictEqual: (expected: unknown) => R;

• Use to test that objects have the same types as well as structure.

method toThrow

toThrow: (expected?: unknown) => R;

• Used to test that a function throws when it is called.

property assertionCalls

assertionCalls: number;

property currentConcurrentTestName

currentConcurrentTestName?: () => string | undefined;

property currentTestName

currentTestName?: string;

property error

error?: Error;

property expand

expand?: boolean;

property expectedAssertionsNumber

expectedAssertionsNumber: number | null;

property expectedAssertionsNumberError

expectedAssertionsNumberError?: Error;

property isExpectingAssertions

isExpectingAssertions: boolean;

property isExpectingAssertionsError

isExpectingAssertionsError?: Error;

property isNot

isNot?: boolean;

property numPassingAsserts

numPassingAsserts: number;

property promise

promise?: string;

property suppressedErrors

suppressedErrors: Array<Error>;

property testPath

testPath?: string;

property customTesters

customTesters: Array<Tester>;

property equals

equals: EqualsFunction;

property utils

utils: typeof jestMatcherUtils & {
    iterableEquality: Tester;
    subsetEquality: Tester;
};

method dontThrow

dontThrow: () => void;