What is the difference between toBe and toEqual?

toBe uses Object.is reference equality, so it suits primitives and the same object reference. toEqual recursively compares structure and value, so it suits arrays and objects. Use toStrictEqual to also check undefined properties and types.

How do I test asynchronous code?

Await the expect with the .resolves or .rejects modifier, for example await expect(promise).resolves.toBe(2). Alternatively await the value yourself and assert on the result, or return the promise from the test.

How do I assert a function throws?

Wrap the call in an arrow function and use toThrow: expect(() => parse(x)).toThrow(). Pass a string, regex or Error subclass to match the message or type. Passing the call directly would throw before expect runs.

What do mock matchers check?

Matchers like toHaveBeenCalled, toHaveBeenCalledTimes and toHaveBeenCalledWith inspect a jest.fn() or spied function's recorded calls, letting you assert it ran, how often and with which arguments.

What does the .not modifier do?

Chaining .not before a matcher inverts the assertion, so expect(x).not.toBe(5) passes when x is anything other than 5. It works in front of every matcher.

Jest Matchers Reference

Email me this result

Get this tool's output sent to your inbox, plus one useful tool a week. No spam, unsubscribe any time.

Look up Jest matchers without leaving your editor mindset

Jest’s expect() exposes many matchers, and remembering which to use for references, structure, numbers, exceptions, mocks and promises is half the battle. This reference lists every common matcher, what it asserts, the argument it takes and whether it has an async form, plus the .not, .resolves and .rejects modifiers. It runs entirely in your browser.

How it works

An assertion is expect(value).matcher(expected). The matcher decides the comparison: toBe is Object.is reference equality, toEqual is recursive structural equality, toContain checks membership, and toThrow runs a wrapped function and inspects the error. Modifiers chain before the matcher: .not inverts it, and .resolves/.rejects unwrap a promise:

expect(2 + 2).toBe(4);
expect([1, 2]).toEqual([1, 2]);
expect(() => parse("")).toThrow(/empty/);
await expect(fetchUser(1)).resolves.toHaveProperty("id", 1);
expect(mockFn).toHaveBeenCalledWith("ready");

Tips and examples

Prefer toStrictEqual over toEqual when you also want to catch undefined properties and mismatched class types.
Use expect.assertions(n) at the top of async tests to guarantee a callback assertion actually ran.
toMatchObject checks that an object contains a subset of expected properties, ignoring extras — handy for API responses.
Snapshot matchers toMatchSnapshot and toMatchInlineSnapshot store the rendered value on first run and compare on later runs.