Test title

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.

This solution

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

This module is distributed via npm which is bundled with node and should be installed as one of your project's devDependencies:

Usage

Import @testing-library/jest-dom once (for instance in your tests setup file) and you're good to go:

```javascript // 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: ['/jest-setup.js'] ```

With TypeScript

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:

Custom 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.

Examples

javascript
expect(getByTestId('button')).toBeDisabled()
expect(getByTestId('input')).toBeDisabled()
expect(getByText('link')).not.toBeDisabled()

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.

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.

Examples

html
<span data-testid="not-empty"><span data-testid="empty"></span></span>
<span data-testid="with-whitespace"> </span>
<span data-testid="with-comment"><!-- comment --></span>

javascript
expect(getByTestId('empty')).toBeEmptyDOMElement()
expect(getByTestId('not-empty')).not.toBeEmptyDOMElement()
expect(getByTestId('with-whitespace')).not.toBeEmptyDOMElement()

toBeInTheDocument

Examples

html
<span data-testid="html-element"><span>Html Element</span></span>
<svg data-testid="svg-element"></svg>

javascript
expect(
  getByTestId(document.documentElement, 'html-element'),
).toBeInTheDocument()
expect(getByTestId(document.documentElement, 'svg-element')).toBeInTheDocument()
expect(
  queryByTestId(document.documentElement, 'does-not-exist'),
).not.toBeInTheDocument()

toBeInvalid

Examples

```javascript 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

An element is required if it is having a required or aria-required="true" attribute.

Examples

javascript
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

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.

Examples

```javascript 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

Examples

javascript
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

This allows you to assert whether an element contains another element as a descendant or not.

Examples

html
<span data-testid="ancestor"><span data-testid="descendant"></span></span>

```javascript 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

Assert whether a string representing a HTML element is contained in another element. The string should contain valid html, and not any incomplete html.

Examples

```javascript // These are valid uses expect(getByTestId('parent')).toContainHTML('') expect(getByTestId('parent')).toContainHTML('') expect(getByTestId('parent')).not.toContainHTML('
')

// These won't work expect(getByTestId('parent')).toContainHTML('data-testid="child"') expect(getByTestId('parent')).toContainHTML('data-testid') expect(getByTestId('parent')).toContainHTML('') ```

toHaveAccessibleDescription

typescript
toHaveAccessibleDescription(expectedAccessibleDescription?: string | RegExp)

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.

Examples

```html <a data-testid="link" href="/" aria-label="Home page" title="A link to start over"

js
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',
)

toHaveAccessibleErrorMessage

typescript
toHaveAccessibleErrorMessage(expectedAccessibleErrorMessage?: string | RegExp)

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.

Examples

```js // 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

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.

Examples

javascript
expect(getByTestId('login-form')).toHaveFormValues({
  username: 'jane.doe',
  rememberMe: true,
})

toHaveStyle

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.

Examples

```html <button data-testid="delete-button" style="display: none; background-color: red"

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

typescript
toHaveTextContent(text: string | RegExp, options?: {normalizeWhitespace: boolean})

This allows you to check whether the given node has a text content or not. This supports elements, but also text nodes and fragments.

When a string argument is passed through, it will perform a partial case-sensitive match to the node content.

To perform a case-insensitive match, you can use a RegExp with the /i modifier.

Examples

expect(element).toHaveTextContent('Content') expect(element).toHaveTextContent(/^Text Content$/) // to match the whole content expect(element).toHaveTextContent(/content$/i) // to use case-insensitive match expect(element).not.toHaveTextContent('content') ```

toHaveValue

This allows you to check whether the given form element has the specified value. It accepts <input>, <select> and <textarea> elements with the exception of <input type="checkbox"> and <input type="radio">, which can be meaningfully matched only using toBeChecked or toHaveFormValues.

For all other form elements, the value is matched using the same algorithm as in toHaveFormValues does.

Examples

Using DOM Testing Library

```javascript const textInput = getByTestId('input-text') const numberInput = getByTestId('input-number') const emptyInput = getByTestId('input-empty') const selectInput = getByTestId('select-number')

expect(textInput).toHaveValue('text') expect(numberInput).toHaveValue(5) expect(emptyInput).not.toHaveValue() expect(selectInput).toHaveValue(['second', 'third']) ```

toHaveDisplayValue

This allows you to check whether the given form element has the specified displayed value (the one the end user will see). It accepts <input>, <select> and <textarea> elements with the exception of <input type="checkbox"> and <input type="radio">, which can be meaningfully matched only using toBeChecked or toHaveFormValues.

Examples

Using DOM Testing Library

```javascript const input = screen.getByLabelText('First name') const textarea = screen.getByLabelText('Description') const selectSingle = screen.getByLabelText('Fruit') const selectMultiple = screen.getByLabelText('Fruits')

expect(input).toHaveDisplayValue('Luca') expect(input).toHaveDisplayValue(/Luc/) expect(textarea).toHaveDisplayValue('An example description here.') expect(textarea).toHaveDisplayValue(/example/) expect(selectSingle).toHaveDisplayValue('Select a fruit...') expect(selectSingle).toHaveDisplayValue(/Select/) expect(selectMultiple).toHaveDisplayValue([/Avocado/, 'Banana']) ```

toBeChecked

This allows you to check whether the given element is checked. It accepts an input of type checkbox or radio and elements with a role of checkbox, radio or switch with a valid aria-checked attribute of "true" or "false".

Examples

```

```javascript const inputCheckboxChecked = getByTestId('input-checkbox-checked') const inputCheckboxUnchecked = getByTestId('input-checkbox-unchecked') const ariaCheckboxChecked = getByTestId('aria-checkbox-checked') const ariaCheckboxUnchecked = getByTestId('aria-checkbox-unchecked') expect(inputCheckboxChecked).toBeChecked() expect(inputCheckboxUnchecked).not.toBeChecked() expect(ariaCheckboxChecked).toBeChecked() expect(ariaCheckboxUnchecked).not.toBeChecked()

const inputRadioChecked = getByTestId('input-radio-checked') const inputRadioUnchecked = getByTestId('input-radio-unchecked') const ariaRadioChecked = getByTestId('aria-radio-checked') const ariaRadioUnchecked = getByTestId('aria-radio-unchecked') expect(inputRadioChecked).toBeChecked() expect(inputRadioUnchecked).not.toBeChecked() expect(ariaRadioChecked).toBeChecked() expect(ariaRadioUnchecked).not.toBeChecked()

const ariaSwitchChecked = getByTestId('aria-switch-checked') const ariaSwitchUnchecked = getByTestId('aria-switch-unchecked') expect(ariaSwitchChecked).toBeChecked() expect(ariaSwitchUnchecked).not.toBeChecked() ```

`toBePartiallyChecked`

typescript toBePartiallyChecked()

This allows you to check whether the given element is partially checked. It accepts an input of type checkbox and elements with a role of checkbox with a aria-checked="mixed", or input of type checkbox with indeterminate set to true

Examples

```html

```

```javascript const ariaCheckboxMixed = getByTestId('aria-checkbox-mixed') const inputCheckboxChecked = getByTestId('input-checkbox-checked') const inputCheckboxUnchecked = getByTestId('input-checkbox-unchecked') const ariaCheckboxChecked = getByTestId('aria-checkbox-checked') const ariaCheckboxUnchecked = getByTestId('aria-checkbox-unchecked') const inputCheckboxIndeterminate = getByTestId('input-checkbox-indeterminate')

expect(ariaCheckboxMixed).toBePartiallyChecked() expect(inputCheckboxChecked).not.toBePartiallyChecked() expect(inputCheckboxUnchecked).not.toBePartiallyChecked() expect(ariaCheckboxChecked).not.toBePartiallyChecked() expect(ariaCheckboxUnchecked).not.toBePartiallyChecked()

inputCheckboxIndeterminate.indeterminate = true expect(inputCheckboxIndeterminate).toBePartiallyChecked() ```

`toHaveErrorMessage`

This custom matcher is deprecated. Prefer toHaveAccessibleErrorMessage instead, which is more comprehensive in implementing the official spec.

typescript toHaveErrorMessage(text: string | RegExp)

This allows you to check whether the given element has an ARIA error message or not.

Use the aria-errormessage attribute to reference another element that contains custom error message text. Multiple ids is NOT allowed. Authors MUST use aria-invalid in conjunction with aria-errormessage. Learn more from aria-errormessage spec.

Whitespace is normalized.

When a string argument is passed through, it will perform a whole case-sensitive match to the error message text.

To perform a case-insensitive match, you can use a RegExp with the /i modifier.

To perform a partial match, you can pass a RegExp or use expect.stringContaining("partial string").

Examples

html <label for="startTime"> Please enter a start time for the meeting: </label> <input id="startTime" type="text" aria-errormessage="msgID" aria-invalid="true" value="11:30 PM" /> <span id="msgID" aria-live="assertive" style="visibility:visible"> Invalid time: the time must be between 9:00 AM and 5:00 PM </span>

```javascript const timeInput = getByLabel('startTime')

expect(timeInput).toHaveErrorMessage( 'Invalid time: the time must be between 9:00 AM and 5:00 PM', ) expect(timeInput).toHaveErrorMessage(/invalid time/i) // to partially match expect(timeInput).toHaveErrorMessage(expect.stringContaining('Invalid time')) // to partially match expect(timeInput).not.toHaveErrorMessage('Pikachu!') ```

Deprecated matchers

`toBeEmpty`

Note: This matcher is being deprecated due to a name clash with jest-extended. See more info in #216. In the future, please use only toBeEmptyDOMElement

typescript toBeEmpty()

This allows you to assert whether an element has content or not.

Examples

html <span data-testid="not-empty"><span data-testid="empty"></span></span>

javascript expect(getByTestId('empty')).toBeEmpty() expect(getByTestId('not-empty')).not.toBeEmpty()

`toBeInTheDOM`

This custom matcher is deprecated. Prefer toBeInTheDocument instead.

typescript toBeInTheDOM()

This allows you to check whether a value is a DOM element, or not.

Contrary to what its name implies, this matcher only checks that you passed to it a valid DOM element. It does not have a clear definition of what "the DOM" is. Therefore, it does not check whether that element is contained anywhere.

This is the main reason why this matcher is deprecated, and will be removed in the next major release. You can follow the discussion around this decision in more detail here.

As an alternative, you can use toBeInTheDocument or toContainElement. Or if you just want to check if a value is indeed an HTMLElement you can always use some of jest's built-in matchers:

js expect(document.querySelector('.ok-button')).toBeInstanceOf(HTMLElement) expect(document.querySelector('.cancel-button')).toBeTruthy()

Note: The differences between toBeInTheDOM and toBeInTheDocument are significant. Replacing all uses of toBeInTheDOM with toBeInTheDocument will likely cause unintended consequences in your tests. Please make sure when replacing toBeInTheDOM to read through the documentation of the proposed alternatives to see which use case works better for your needs.

`toHaveDescription`

This custom matcher is deprecated. Prefer toHaveAccessibleDescription instead, which is more comprehensive in implementing the official spec.

typescript toHaveDescription(text: string | RegExp)

This allows you to check whether the given element has a description or not.

An element gets its description via the aria-describedby attribute. Set this to the id of one or more other elements. These elements may be nested inside, be outside, or a sibling of the passed in element.

Whitespace is normalized. Using multiple ids will join the referenced elements’ text content separated by a space.

When a string argument is passed through, it will perform a whole case-sensitive match to the description text.

To perform a case-insensitive match, you can use a RegExp with the /i modifier.

To perform a partial match, you can pass a RegExp or use expect.stringContaining("partial string").

Examples

```html

Closing will discard any changes

```

```javascript const closeButton = getByRole('button', {name: 'Close'})

expect(closeButton).toHaveDescription('Closing will discard any changes') expect(closeButton).toHaveDescription(/will discard/) // to partially match expect(closeButton).toHaveDescription(expect.stringContaining('will discard')) // to partially match expect(closeButton).toHaveDescription(/^closing/i) // to use case-insensitive match expect(closeButton).not.toHaveDescription('Other description')

const deleteButton = getByRole('button', {name: 'Delete'}) expect(deleteButton).not.toHaveDescription() expect(deleteButton).toHaveDescription('') // Missing or empty description always becomes a blank string ```

Inspiration

This whole library was extracted out of Kent C. Dodds' DOM Testing Library, which was in turn extracted out of React Testing Library.

The intention is to make this available to be used independently of these other libraries, and also to make it more clear that these other libraries are independent from jest, and can be used with other tests runners as well.

Guiding Principles

The more your tests resemble the way your software is used, the more confidence they can give you.

This library follows the same guiding principles as its mother library DOM Testing Library. Go check them out for more details.

Additionally, with respect to custom DOM matchers, this library aims to maintain a minimal but useful set of them, while avoiding bloating itself with merely convenient ones that can be easily achieved with other APIs. In general, the overall criteria for what is considered a useful custom matcher to add to this library, is that doing the equivalent assertion on our own makes the test code more verbose, less clear in its intent, and/or harder to read.

Contributors

Thanks goes to these people (emoji key):

_{Kent C. Dodds} 💻 📖 🚇 ⚠️	_{Ryan Castner} 📖	_{Daniel Sandiego} 💻	_{Paweł Mikołajczyk} 💻	_{Alejandro Ñáñez Ortiz} 📖	_{Matt Parrish} 🐛 💻 📖 ⚠️	_{Justin Hall} 📦
_{Anto Aravinth} 💻 ⚠️ 📖	_{Jonah Moses} 📖	_{Łukasz Gandecki} 💻 ⚠️ 📖	_{Ivan Babak} 🐛 🤔	_{Jesse Day} 💻	_{Ernesto García} 💻 📖 ⚠️	_{Mark Volkmann} 🐛 💻
_{smacpherson64} 💻 📖 ⚠️	_{John Gozde} 🐛 💻	_Iwona 💻 📖 ⚠️	_Lewis 💻	_{Leandro Lourenci} 🐛 📖 💻 ⚠️	_{Shukhrat Mukimov} 🐛	_{Roman Usherenko} 💻 ⚠️
_{Joe Hsu} 📖	_Haz 🐛 💻	_{Revath S Kumar} 💻	_hiwelo. 💻 🤔 ⚠️	_{Łukasz Fiszer} 💻	_{Jean Chung} 💻 ⚠️	_CarlaTeo 💻 ⚠️
_{Yarden Shoham} 📖	_{Jaga Santagostino} 🐛 ⚠️ 📖	_{Connor Meredith} 💻 ⚠️ 📖	_{Pawel Wolak} ⚠️	_{Michaël De Boey} 🚇	_{Jānis Zaržeckis} 📖	_koala-lava 📖
_{Juan Pablo Blanco} 📖	_{Ben Monro} 📖	_{Jeff Bernstein} 📖	_Sergi 💻 ⚠️	_{Spencer Miskoviak} 📖	_{Jon Rimmer} 💻 ⚠️	_{Luca Barone} 💻 ⚠️ 🤔
_{Malte Felmy} 💻 ⚠️	_{Championrunner} 📖	_{Patrick Smith} 💻 ⚠️ 📖	_{Rubén Moya} 💻 ⚠️ 📖	_{Daniela Valero} 💻 ⚠️ 📖	_{Vladislav Katsura} 💻 ⚠️	_{Tim Fischbach} 💻 ⚠️ 🤔
_{Katie Boedges} 🚇	_{Brian Alexis} ⚠️	_{Boris Serdiuk} 🐛 💻 ⚠️	_{Dana Woodman} 📖	_{Mo Sattler} 📖	_{Geoff Rich} 💻 ⚠️ 🤔 🐛	_Syneva 💻
_{Nick McCurdy} 📖 🐛 💻	_{Obed Marquez Parlapiano} 📖	_{Caleb Eby} 📖 💻 ⚠️	_{Marcel Barner} 💻 ⚠️	_Doma 💻 ⚠️	_{Julien Wajsberg} 💻 ⚠️	_{steven nguyen} 📖
_tu4mo 📖	_{Matan Borenkraout} 📦	_{Yann Braga} 💻	_{Ian VanSchooten} 💻	_{Chantal Broeren} 📖	_{Jérémie Astori} 💻 🤔	_{Ashley Ryan} 💻 🤔