externalexpect
Callable
Type parameters
- T = unknown
Parameters
externalactual: T
externaloptionalmessageOrOptions: string | { message?: string }
externaloptionalmessage: string
Returns MakeMatchers<void, T, {}>
Index
Properties
externalsoft
Type declaration
Type parameters
- T = unknown
Parameters
externalactual: T
externaloptionalmessageOrOptions: string | { message?: string }
externaloptionalmessage: string
Returns MakeMatchers<void, T, {}>
externalpoll
Type declaration
Type parameters
- T = unknown
Parameters
externalactual: () => T | Promise<T>
externaloptionalmessageOrOptions: string | { message?: string; timeout?: number; intervals?: number[] }
externaloptionalmessage: string
externaloptionaltimeout: number
externaloptionalintervals: number[]
Returns PollMatchers<Promise<void>, T, {}>
externalconfigure
Type declaration
Parameters
externalconfiguration: { message?: string; timeout?: number; soft?: boolean }
externaloptionalmessage: string
externaloptionaltimeout: number
externaloptionalsoft: boolean
Returns Expect<{}>
externalnot
Methods
externalany
Parameters
externalsample: unknown
Returns AsymmetricMatcher
externalanything
expect.anything()
matches everything exceptnull
andundefined
. Use it inside expect(value).toEqual(expected) to perform pattern matching.Usage
const value = { prop: 1 };
expect(value).toEqual({ prop: expect.anything() });
expect(value).not.toEqual({ otherProp: expect.anything() });Returns AsymmetricMatcher
externalarrayContaining
expect.arrayContaining()
matches an array that contains all of the elements in the expected array, in any order. Note that received array may be a superset of the expected array and contain some extra elements.Use this method inside expect(value).toEqual(expected) to perform pattern matching.
Usage
expect([1, 2, 3]).toEqual(expect.arrayContaining([3, 1]));
expect([1, 2, 3]).not.toEqual(expect.arrayContaining([1, 4]));Parameters
externalsample: unknown[]
Returns AsymmetricMatcher
externalcloseTo
Compares floating point numbers for approximate equality. Use this method inside expect(value).toEqual(expected) to perform pattern matching. When just comparing two numbers, prefer expect(value).toBeCloseTo(expected[, numDigits]).
Usage
expect({ prop: 0.1 + 0.2 }).not.toEqual({ prop: 0.3 });
expect({ prop: 0.1 + 0.2 }).toEqual({ prop: expect.closeTo(0.3, 5) });Parameters
externalsample: number
externaloptionalprecision: number
Returns AsymmetricMatcher
externalobjectContaining
expect.objectContaining()
matches an object that contains and matches all of the properties in the expected object. Note that received object may be a superset of the expected object and contain some extra properties.Use this method inside expect(value).toEqual(expected) to perform pattern matching. Object properties can be matchers to further relax the expectation. See examples.
Usage
// Assert some of the properties.
expect({ foo: 1, bar: 2 }).toEqual(expect.objectContaining({ foo: 1 }));
// Matchers can be used on the properties as well.
expect({ foo: 1, bar: 2 }).toEqual(expect.objectContaining({ bar: expect.any(Number) }));
// Complex matching of sub-properties.
expect({
list: [1, 2, 3],
obj: { prop: 'Hello world!', another: 'some other value' },
extra: 'extra',
}).toEqual(expect.objectContaining({
list: expect.arrayContaining([2, 3]),
obj: expect.objectContaining({ prop: expect.stringContaining('Hello') }),
}));Parameters
externalsample: Record<string, unknown>
Returns AsymmetricMatcher
externalstringContaining
expect.stringContaining()
matches a string that contains the expected substring. Use this method inside expect(value).toEqual(expected) to perform pattern matching.Usage
expect('Hello world!').toEqual(expect.stringContaining('Hello'));
Parameters
externalsample: string
Returns AsymmetricMatcher
externalstringMatching
expect.stringMatching()
matches a received string that in turn matches the expected pattern. Use this method inside expect(value).toEqual(expected) to perform pattern matching.Usage
expect('123ms').toEqual(expect.stringMatching(/\d+m?s/));
// Inside another matcher.
expect({
status: 'passed',
time: '123ms',
}).toEqual({
status: expect.stringMatching(/passed|failed/),
time: expect.stringMatching(/\d+m?s/),
});Parameters
externalsample: string | RegExp
Returns AsymmetricMatcher
externalextend
Type parameters
- MoreMatchers: Record<string, (this: ExpectMatcherState, receiver: any, ...args: any[]) => MatcherReturnType | Promise<MatcherReturnType>>
Parameters
externalmatchers: MoreMatchers
Returns Expect<{} & MoreMatchers>
externalgetState
Returns unknown
expect.any()
matches any object instance created from theconstructor
or a corresponding primitive type. Use it inside expect(value).toEqual(expected) to perform pattern matching.Usage