You want to use jest to write tests that assert various things about the state of a DOM. As part of that goal, you want to avoid all the repetitive patterns that arise in doing so. Checking for an element's attributes, its text content, its css classes, you name it.
The @testing-library/jest-dom library provides a set of custom jest matchers
that you can use to extend jest. These will make your tests more declarative,
clear to read and to maintain.
- Installation
- Usage
- Custom matchers
toBeDisabledtoBeEnabledtoBeEmptyDOMElementtoBeInTheDocumenttoBeInvalidtoBeRequiredtoBeValidtoBeVisibletoContainElementtoContainHTMLtoHaveAccessibleDescriptiontoHaveAccessibleErrorMessagetoHaveAccessibleNametoHaveAttributetoHaveClasstoHaveFocustoHaveFormValuestoHaveStyletoHaveTextContenttoHaveValuetoHaveDisplayValuetoBeCheckedtoBePartiallyCheckedtoHaveRoletoHaveErrorMessagetoHaveSelection
- Deprecated matchers
- Inspiration
- Other Solutions
- Guiding Principles
- Contributors
- LICENSE
This module is distributed via npm which is bundled with node and
should be installed as one of your project's devDependencies:
npm install --save-dev @testing-library/jest-dom
or
for installation with yarn package manager.
yarn add --dev @testing-library/jest-dom
Note: We also recommend installing the jest-dom eslint plugin which provides auto-fixable lint rules that prevent false positive tests and improve test readability by ensuring you are using the right matchers in your tests. More details can be found at eslint-plugin-jest-dom.
Import @testing-library/jest-dom once (for instance in your tests setup
file) and you're good to go:
// In your own jest-setup.js (or any other name)
import '@testing-library/jest-dom'
// In jest.config.js add (if you haven't already)
setupFilesAfterEnv: ['<rootDir>/jest-setup.js']If you are using @jest/globals with
injectGlobals: false, you will need to use a different
import in your tests setup file:
// In your own jest-setup.js (or any other name)
import '@testing-library/jest-dom/jest-globals'If you are using vitest, this module will work as-is, but you will need to
use a different import in your tests setup file. This file should be added to
the setupFiles property in your vitest config:
// In your own vitest-setup.js (or any other name)
import '@testing-library/jest-dom/vitest'
// In vitest.config.js add (if you haven't already)
setupFiles: ['./vitest-setup.js']Also, depending on your local setup, you may need to update your
tsconfig.json:
// In tsconfig.json
"compilerOptions": {
...
"types": ["vitest/globals", "@testing-library/jest-dom"]
},
"include": [
...
"./vitest.setup.ts"
],If you're using TypeScript, make sure your setup file is a .ts and not a .js
to include the necessary types.
You will also need to include your setup file in your tsconfig.json if you
haven't already:
// In tsconfig.json
"include": [
...
"./jest-setup.ts"
],If you are using a different test runner that is compatible with Jest's expect
interface, it might be possible to use it with this library:
import * as matchers from '@testing-library/jest-dom/matchers'
import {expect} from 'my-test-runner/expect'
expect.extend(matchers)@testing-library/jest-dom can work with any library or framework that returns
DOM elements from queries. The custom matcher examples below are written using
matchers from @testing-library's suite of libraries (e.g. getByTestId,
queryByTestId, getByText, etc.)
toBeDisabled()This allows you to check whether an element is disabled from the user's
perspective. According to the specification, the following elements can be
disabled:
button, input, select, textarea, optgroup, option, fieldset, and
custom elements.
This custom matcher considers an element as disabled if the element is among the
types of elements that can be disabled (listed above), and the disabled
attribute is present. It will also consider the element as disabled if it's
inside a parent form element that supports being disabled and has the disabled
attribute present.
<button data-testid="button" type="submit" disabled>submit</button>
<fieldset disabled><input type="text" data-testid="input" /></fieldset>
<a href="..." disabled>link</a>expect(getByTestId('button')).toBeDisabled()
expect(getByTestId('input')).toBeDisabled()
expect(getByText('link')).not.toBeDisabled()This custom matcher does not take into account the presence or absence of the
aria-disabledattribute. For more on why this is the case, check #144.
toBeEnabled()This allows you to check whether an element is not disabled from the user's perspective.
It works like not.toBeDisabled(). Use this matcher to avoid double negation in
your tests.
This custom matcher does not take into account the presence or absence of the
aria-disabledattribute. For more on why this is the case, check #144.
toBeEmptyDOMElement()This allows you to assert whether an element has no visible content for the user. It ignores comments but will fail if the element contains white-space.
<span data-testid="not-empty"><span data-testid="empty"></span></span>
<span data-testid="with-whitespace"> </span>
<span data-testid="with-comment"><!-- comment --></span>expect(getByTestId('empty')).toBeEmptyDOMElement()
expect(getByTestId('not-empty')).not.toBeEmptyDOMElement()
expect(getByTestId('with-whitespace')).not.toBeEmptyDOMElement()toBeInTheDocument()This allows you to assert whether an element is present in the document or not.
<span data-testid="html-element"><span>Html Element</span></span>
<svg data-testid="svg-element"></svg>expect(
getByTestId(document.documentElement, 'html-element'),
).toBeInTheDocument()
expect(getByTestId(document.documentElement, 'svg-element')).toBeInTheDocument()
expect(
queryByTestId(document.documentElement, 'does-not-exist'),
).not.toBeInTheDocument()Note: This matcher does not find detached elements. The element must be added to the document to be found by toBeInTheDocument. If you desire to search in a detached element please use:
toContainElement
toBeInvalid()This allows you to check if an element, is currently invalid.
An element is invalid if it has an
aria-invalid attribute
with no value or a value of "true", or if the result of
checkValidity()
is false.
<input data-testid="no-aria-invalid" />
<input data-testid="aria-invalid" aria-invalid />
<input data-testid="aria-invalid-value" aria-invalid="true" />
<input data-testid="aria-invalid-false" aria-invalid="false" />
<form data-testid="valid-form">
<input />
</form>
<form data-testid="invalid-form">
<input required />
</form>expect(getByTestId('no-aria-invalid')).not.toBeInvalid()
expect(getByTestId('aria-invalid')).toBeInvalid()
expect(getByTestId('aria-invalid-value')).toBeInvalid()
expect(getByTestId('aria-invalid-false')).not.toBeInvalid()
expect(getByTestId('valid-form')).not.toBeInvalid()
expect(getByTestId('invalid-form')).toBeInvalid()toBeRequired()This allows you to check if a form element is currently required.
An element is required if it is having a required or aria-required="true"
attribute.
<input data-testid="required-input" required />
<input data-testid="aria-required-input" aria-required="true" />
<input data-testid="conflicted-input" required aria-required="false" />
<input data-testid="aria-not-required-input" aria-required="false" />
<input data-testid="optional-input" />
<input data-testid="unsupported-type" type="image" required />
<select data-testid="select" required></select>
<textarea data-testid="textarea" required></textarea>
<div data-testid="supported-role" role="tree" required></div>
<div data-testid="supported-role-aria" role="tree" aria-required="true"></div>expect(getByTestId('required-input')).toBeRequired()
expect(getByTestId('aria-required-input')).toBeRequired()
expect(getByTestId('conflicted-input')).toBeRequired()
expect(getByTestId('aria-not-required-input')).not.toBeRequired()
expect(getByTestId('optional-input')).not.toBeRequired()
expect(getByTestId('unsupported-type')).not.toBeRequired()
expect(getByTestId('select')).toBeRequired()
expect(getByTestId('textarea')).toBeRequired()
expect(getByTestId('supported-role')).not.toBeRequired()
expect(getByTestId('supported-role-aria')).toBeRequired()toBeValid()This allows you to check if the value of an element, is currently valid.
An element is valid if it has no
aria-invalid attributes
or an attribute value of "false". The result of
checkValidity()
must also be true if it's a form element.
<input data-testid="no-aria-invalid" />
<input data-testid="aria-invalid" aria-invalid />
<input data-testid="aria-invalid-value" aria-invalid="true" />
<input data-testid="aria-invalid-false" aria-invalid="false" />
<form data-testid="valid-form">
<input />
</form>
<form data-testid="invalid-form">
<input required />
</form>expect(getByTestId('no-aria-invalid')).toBeValid()
expect(getByTestId('aria-invalid')).not.toBeValid()
expect(getByTestId('aria-invalid-value')).not.toBeValid()
expect(getByTestId('aria-invalid-false')).toBeValid()
expect(getByTestId('valid-form')).toBeValid()
expect(getByTestId('invalid-form')).not.toBeValid()toBeVisible()This allows you to check if an element is currently visible to the user.
An element is visible if all the following conditions are met:
- it is present in the document
- it does not have its css property
displayset tonone - it does not have its css property
visibilityset to eitherhiddenorcollapse - it does not have its css property
opacityset to0 - its parent element is also visible (and so on up to the top of the DOM tree)
- it does not have the
hiddenattribute - if
<details />it has theopenattribute
<div data-testid="zero-opacity" style="opacity: 0">Zero Opacity Example</div>
<div data-testid="visibility-hidden" style="visibility: hidden">
Visibility Hidden Example
</div>
<div data-testid="display-none" style="display: none">Display None Example</div>
<div style="opacity: 0">
<span data-testid="hidden-parent">Hidden Parent Example</span>
</div>
<div data-testid="visible">Visible Example</div>
<div data-testid="hidden-attribute" hidden>Hidden Attribute Example</div>
<details>
<summary>Title of hidden text</summary>
Hidden Details Example
</details>
<details open>
<summary>Title of visible text</summary>
<div>Visible Details Example</div>
</details>expect(getByText('Zero Opacity Example')).not.toBeVisible()
expect(getByText('Visibility Hidden Example')).not.toBeVisible()
expect(getByText('Display None Example')).not.toBeVisible()
expect(getByText('Hidden Parent Example')).not.toBeVisible()
expect(getByText('Visible Example')).toBeVisible()
expect(getByText('Hidden Attribute Example')).not.toBeVisible()
expect(getByText('Hidden Details Example')).not.toBeVisible()
expect(getByText('Visible Details Example')).toBeVisible()toContainElement(element: HTMLElement | SVGElement | null)This allows you to assert whether an element contains another element as a descendant or not.
<span data-testid="ancestor"><span data-testid="descendant"></span></span>const ancestor = getByTestId('ancestor')
const descendant = getByTestId('descendant')
const nonExistantElement = getByTestId('does-not-exist')
expect(ancestor).toContainElement(descendant)
expect(descendant).not.toContainElement(ancestor)
expect(ancestor).not.toContainElement(nonExistantElement)toContainHTML(htmlText: string)Assert whether a string representing a HTML element is contained in another element. The string should contain valid html, and not any incomplete html.
<span data-testid="parent"><span data-testid="child"></span></span>// These are valid uses
expect(getByTestId('parent')).toContainHTML('<span data-testid="child"></span>')
expect(getByTestId('parent')).toContainHTML('<span data-testid="child" />')
expect(getByTestId('parent')).not.toContainHTML('<br />')
// These won't work
expect(getByTestId('parent')).toContainHTML('data-testid="child"')
expect(getByTestId('parent')).toContainHTML('data-testid')
expect(getByTestId('parent')).toContainHTML('</span>')Chances are you probably do not need to use this matcher. We encourage testing from the perspective of how the user perceives the app in a browser. That's why testing against a specific DOM structure is not advised.
It could be useful in situations where the code being tested renders html that was obtained from an external source, and you want to validate that that html code was used as intended.
It should not be used to check DOM structure that you control. Please use
toContainElementinstead.
toHaveAccessibleDescription(expectedAccessibleDescription?: string | RegExp)This allows you to assert that an element has the expected accessible description.
You can pass the exact string of the expected accessible description, or you can make a partial match passing a regular expression, or by using expect.stringContaining/expect.stringMatching.
<a
data-testid="link"
href="/"
aria-label="Home page"
title="A link to start over"
>Start</a
>
<a data-testid="extra-link" href="/about" aria-label="About page">About</a>
<img src="avatar.jpg" data-testid="avatar" alt="User profile pic" />
<img
src="logo.jpg"
data-testid="logo"
alt="Company logo"
aria-describedby="t1"
/>
<span id="t1" role="presentation">The logo of Our Company</span>
<img
src="logo.jpg"
data-testid="logo2"
alt="Company logo"
aria-description="The logo of Our Company"
/>expect(getByTestId('link')).toHaveAccessibleDescription()
expect(getByTestId('link')).toHaveAccessibleDescription('A link to start over')
expect(getByTestId('link')).not.toHaveAccessibleDescription('Home page')
expect(getByTestId('extra-link')).not.toHaveAccessibleDescription()
expect(getByTestId('avatar')).not.toHaveAccessibleDescription()
expect(getByTestId('logo')).not.toHaveAccessibleDescription('Company logo')
expect(getByTestId('logo')).toHaveAccessibleDescription(
'The logo of Our Company',
)
expect(getByTestId('logo2')).toHaveAccessibleDescription(
'The logo of Our Company',
)toHaveAccessibleErrorMessage(expectedAccessibleErrorMessage?: string | RegExp)This allows you to assert that an element has the expected accessible error message.
You can pass the exact string of the expected accessible error message. Alternatively, you can perform a partial match by passing a regular expression or by using expect.stringContaining/expect.stringMatching.
<input
aria-label="Has Error"
aria-invalid="true"
aria-errormessage="error-message"
/>
<div id="error-message" role="alert">This field is invalid</div>
<input aria-label="No Error Attributes" />
<input
aria-label="Not Invalid"
aria-invalid="false"
aria-errormessage="error-message"
/>// Inputs with Valid Error Messages
expect(getByRole('textbox', {name: 'Has Error'})).toHaveAccessibleErrorMessage()
expect(getByRole('textbox', {name: 'Has Error'})).toHaveAccessibleErrorMessage(
'This field is invalid',
)
expect(getByRole('textbox', {name: 'Has Error'})).toHaveAccessibleErrorMessage(
/invalid/i,
)
expect(
getByRole('textbox', {name: 'Has Error'}),
).not.toHaveAccessibleErrorMessage('This field is absolutely correct!')
// Inputs without Valid Error Messages
expect(
getByRole('textbox', {name: 'No Error Attributes'}),
).not.toHaveAccessibleErrorMessage()
expect(
getByRole('textbox', {name: 'Not Invalid'}),
).not.toHaveAccessibleErrorMessage()toHaveAccessibleName(expectedAccessibleName?: string | RegExp)This allows you to assert that an element has the expected accessible name. It is useful, for instance, to assert that form elements and buttons are properly labelled.
You can pass the exact string of the expected accessible name, or you can make a partial match passing a regular expression, or by using expect.stringContaining/expect.stringMatching.
<img data-testid="img-alt" src="" alt="Test alt" />
<img data-testid="img-empty-alt" src="" alt="" />
<svg data-testid="svg-title"><title>Test title</title></svg>
<button data-testid="button-img-alt"><img src="" alt="Test" /></button>
<p><img data-testid="img-paragraph" src="" alt="" /> Test content</p>
<button data-testid="svg-button"><svg><title>Test</title></svg></p>
<div><svg data-testid="svg-without-title"></svg></div>
<input data-testid="input-title" title="test" />expect(getByTestId('img-alt')).toHaveAccessibleName('Test alt')
expect(getByTestId('img-empty-alt')).not.toHaveAccessibleName()
expect(getByTestId('svg-title')).toHaveAccessibleName('Test title')
expect(getByTestId('button-img-alt')).toHaveAccessibleName()
expect(getByTestId('img-paragraph')).not.toHaveAccessibleName()
expect(getByTestId('svg-button')).toHaveAccessibleName()
expect(getByTestId('svg-without-title')).not.toHaveAccessibleName()
expect(getByTestId('input-title')).toHaveAccessibleName()toHaveAttribute(attr: string, value?: any)This allows you to check whether the given element has an attribute or not. You can also optionally check that the attribute has a specific expected value or partial match using expect.stringContaining/expect.stringMatching
<button data-testid="ok-button" type="submit" disabled>ok</button>const button = getByTestId('ok-button')
expect(button).toHaveAttribute('disabled')
expect(button).toHaveAttribute('type', 'submit')
expect(button).not.toHaveAttribute('type', 'button')
expect(button).toHaveAttribute('type', expect.stringContaining('sub'))
expect(button).toHaveAttribute('type', expect.not.stringContaining('but'))toHaveClass(...classNames: string[], options?: {exact: boolean})This allows you to check whether the given element has certain classes within
its class attribute. You must provide at least one class, unless you are
asserting that an element does not have any classes.
The list of class names may include strings and regular expressions. Regular
expressions are matched against each individual class in the target element, and
it is NOT matched against its full class attribute value as whole.
<button data-testid="delete-button" class="btn extra btn-danger">
Delete item
</button>
<button data-testid="no-classes">No Classes</button>const deleteButton = getByTestId('delete-button')
const noClasses = getByTestId('no-classes')
expect(deleteButton).toHaveClass('extra')
expect(deleteButton).toHaveClass('btn-danger btn')
expect(deleteButton).toHaveClass(/danger/, 'btn')
expect(deleteButton).toHaveClass('btn-danger', 'btn')
expect(deleteButton).not.toHaveClass('btn-link')
expect(deleteButton).not.toHaveClass(/link/)
expect(deleteButton).not.toHaveClass(/btn extra/) // It does not match
expect(deleteButton).toHaveClass('btn-danger extra btn', {exact: true}) // to check if the element has EXACTLY a set of classes
expect(deleteButton).not.toHaveClass('btn-danger extra', {exact: true}) // if it has more than expected it is going to fail
expect(noClasses).not.toHaveClass()toHaveFocus()This allows you to assert whether an element has focus or not.
<div><input type="text" data-testid="element-to-focus" /></div>const input = getByTestId('element-to-focus')
input.focus()
expect(input).toHaveFocus()
input.blur()
expect(input).not.toHaveFocus()toHaveFormValues(expectedValues: {
[name: string]: any
})This allows you to check if a form or fieldset contains form controls for each given name, and having the specified value.
It is important to stress that this matcher can only be invoked on a form or a fieldset element.
This allows it to take advantage of the .elements property in
formandfieldsetto reliably fetch all form controls within them.This also avoids the possibility that users provide a container that contains more than one
form, thereby intermixing form controls that are not related, and could even conflict with one another.
This matcher abstracts away the particularities with which a form control value
is obtained depending on the type of form control. For instance, <input>
elements have a value attribute, but <select> elements do not. Here's a list
of all cases covered:
<input type="number">elements return the value as a number, instead of a string.<input type="checkbox">elements:- if there's a single one with the given
nameattribute, it is treated as a boolean, returningtrueif the checkbox is checked,falseif unchecked. - if there's more than one checkbox with the same
nameattribute, they are all treated collectively as a single form control, which returns the value as an array containing all the values of the selected checkboxes in the collection.
- if there's a single one with the given
<input type="radio">elements are all grouped by thenameattribute, and such a group treated as a single form control. This form control returns the value as a string corresponding to thevalueattribute of the selected radio button within the group.<input type="text">elements return the value as a string. This also applies to<input>elements having any other possibletypeattribute that's not explicitly covered in different rules above (e.g.search,email,date,password,hidden, etc.)<select>elements without themultipleattribute return the value as a string corresponding to thevalueattribute of the selectedoption, orundefinedif there's no selected option.<select multiple>elements return the value as an array containing all the values of the selected options.<textarea>elements return their value as a string. The value corresponds to their node content.
The above rules make it easy, for instance, to switch from using a single select control to using a group of radio buttons. Or to switch from a multi select control, to using a group of checkboxes. The resulting set of form values used by this matcher to compare against would be the same.
<form data-testid="login-form">
<input type="text" name="username" value="jane.doe" />
<input type="password" name="password" value="12345678" />
<input type="checkbox" name="rememberMe" checked />
<button type="submit">Sign in</button>
</form>expect(getByTestId('login-form')).toHaveFormValues({
username: 'jane.doe',
rememberMe: true,
})toHaveStyle(css: string | object)This allows you to check if a certain element has some specific css properties with specific values applied. It matches only if the element has all the expected properties applied, not just some of them.
<button
data-testid="delete-button"
style="display: none; background-color: red"
>
Delete item
</button>const button = getByTestId('delete-button')
expect(button).toHaveStyle('display: none')
expect(button).toHaveStyle({display: 'none'})
expect(button).toHaveStyle(`
background-color: red;
display: none;
`)
expect(button).toHaveStyle({
backgroundColor: 'red',
display: 'none',
})
expect(button).not.toHaveStyle(`
background-color: blue;
display: none;
`)
expect(button).not.toHaveStyle({
backgroundColor: 'blue',
display: 'none',
})This also works with rules that are applied to the element via a class name for which some rules are defined in a stylesheet currently active in the document. The usual rules of css precedence apply.
toHaveTextContent(text: string | RegExp, options?: {normalizeWhitespace: boolean})