@testing-library/jasmine-dom
Advanced tools
Custom Jasmine matchers to test the state of the DOM
You want to use Jasmine to write tests that assert various things about the state of the 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 jasmine-dom library provides a set of custom Jasmine matchers that you can use to extend Jasmine. These will make your tests more declarative, clear to read and to maintain.
toBeDisabledtoBeEnabledtoBeEmptyDOMElementtoBeInTheDocumenttoBeInvalidtoBeRequiredtoBeValidtoBeVisibletoContainHTMLtoContainElementtoHaveAccessibleDescriptiontoHaveAccessibleNametoHaveAttributetoHaveClassNametoHaveFocustoHaveFormValuestoHaveStyletoHaveTextContenttoHaveValuetoHaveDisplayValuetoBeCheckedtoBePartiallyCheckedtoHaveErrorMessagetoHaveDescriptionThis module is distributed via npm which is bundled with node and should be installed as one of your project's devDependencies.
Using npm:
npm install --save-dev @testing-library/jasmine-dom
or for installation using yarn package manager:
yarn add --dev @testing-library/jasmine-dom
You should have a directory for helpers specified inside the helpers array in your jasmine.json file.
Example:
{
"spec_dir": "src/__tests__",
"spec_files": ["**/*.test.js"],
"helpers": ["helpers/**/*.js"],
"stopSpecOnExpectationFailure": false,
"random": false
}
Make a new file inside that directory, import @testing-library/jasmine-dom and add the matchers like so:
import JasmineDOM from '@testing-library/jasmine-dom';
beforeAll(() => {
jasmine.getEnv().addMatchers(JasmineDOM);
});
Add "@testing-library/jasmine-dom" to types in the tests tsconfig (e.g. tsconfig.spec.json in an Angular project).
Example:
{
"compilerOptions": {
"types": ["jasmine", "node", "@testing-library/jasmine-dom"]
}
}
In your tests setup file, (test.ts in an Angular project) import jasmine-dom and add the matchers like so:
import JasmineDOM from '@testing-library/jasmine-dom/dist';
beforeAll(() => {
jasmine.getEnv().addMatchers(JasmineDOM);
});
This library is meant to be a Jasmine version of @testing-library/jest-dom library. As such, it provides the same set of matchers and the same functionality for each one, with a couple of minor diferences:
toBeEmpty() is not included, in favor of toBeEmptyDOMElement()toBeInTheDOM() is not included, since it's deprecatedtoHaveClass() is renamed as toHaveClassName() to prevent name collision with Jasmine's toHaveClass()toBeDisabledtoBeDisabled();
This allows you to check whether an element is disabled from the user's perspective.
It matches if the element is a form control and the disabled attribute is
specified on this element or the element is a descendant of a form element with
a disabled attribute.
According to the specification, the following elements can be
actually disabled:
button, input, select, textarea, optgroup, option, fieldset.
<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();
toBeEnabledtoBeEnabled();
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.
toBeEmptyDOMElementtoBeEmptyDOMElement();
This allows you to assert whether an element has content or not.
<span data-testid="not-empty"><span data-testid="empty"></span></span>
expect(getByTestId('empty')).toBeEmptyDOMElement();
expect(getByTestId('not-empty')).not.toBeEmptyDOMElement();
toBeInTheDocumenttoBeInTheDocument();
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
toBeInvalidtoBeInvalid();
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();
toBeRequiredtoBeRequired();
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();
toBeValidtoBeValid();
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();
toBeVisibletoBeVisible();
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:
display set to nonevisibility set to either hidden or
collapseopacity set to 0hidden
attribute<details /> it has the open attribute<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>
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();
toContainHTMLtoContainHTML(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.
toContainElementtoContainElement(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);
toHaveAccessibleDescriptiontoHaveAccessibleDescription(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 jasmine.stringContaining/jasmine.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>
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');
toHaveAccessibleNametoHaveAccessibleName(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 jasmine.stringContaining/jasmine.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();
toHaveAttributetoHaveAttribute(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 a RegExp.
<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', /sub/))
expect(button).toHaveAttribute('type', /but/))
toHaveClassNametoHaveClassName(...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.
<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).toHaveClassName('extra');
expect(deleteButton).toHaveClassName('btn-danger btn');
expect(deleteButton).toHaveClassName('btn-danger', 'btn');
expect(deleteButton).not.toHaveClassName('btn-link');
expect(deleteButton).toHaveClassName('btn-danger extra btn', { exact: true }); // to check if the element has EXACTLY a set of classes
expect(deleteButton).not.toHaveClassName('btn-danger extra', { exact: true }); // if it has more than expected it is going to fail
expect(noClasses).not.toHaveClassName();
toHaveFocustoHaveFocus();
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();
toHaveFormValuestoHaveFormValues(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:
name attribute, it is treated as a
boolean, returning true if the checkbox is checked, false if
unchecked.name attribute, 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.<input type="radio"> elements are all grouped by the name attribute, and
such a group treated as a single form control. This form control returns the
value as a string corresponding to the value attribute 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 possible type attribute
that's not explicitly covered in different rules above (e.g. search,
email, date, password, hidden, etc.)<select> elements without the multiple attribute return the value as a
string corresponding to the value attribute of the selected option, or
undefined if 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,
});
toHaveStyletoHaveStyle(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.
toHaveTextContenttoHaveTextContent(text: string | RegExp, options?: {normalizeWhitespace: boolean})
This allows you to check whether the given element has a text content or not.
When a string argument is passed through, it will perform a partial
case-sensitive match to the element content.
To perform a case-insensitive match, you can use a RegExp with the /i
modifier.
If you want to match the whole content, you can use a RegExp to do it.
<span data-testid="text-content">Text Content</span>
const element = getByTestId('text-content');
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');
toHaveValuetoHaveValue(value: string | string[] | number)
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.
<input type="text" value="text" data-testid="input-text" />
<input type="number" value="5" data-testid="input-number" />
<input type="text" data-testid="input-empty" />
<select data-testid="multiple" multiple data-testid="select-number">
<option value="first">First Value</option>
<option value="second" selected>Second Value</option>
<option value="third" selected>Third Value</option>
</select>
const textInput = screen.getByTestId('input-text');
const numberInput = screen.getByTestId('input-number');
const emptyInput = screen.getByTestId('input-empty');
const selectInput = screen.getByTestId('select-number');
expect(textInput).toHaveValue('text');
expect(numberInput).toHaveValue(5);
expect(emptyInput).not.toHaveValue();
expect(selectInput).not.toHaveValue(['second', 'third']);
toHaveDisplayValuetoHaveDisplayValue(value: string | RegExp | (string|RegExp)[])
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.
<label for="input-example">First name</label>
<input type="text" id="input-example" value="Luca" />
<label for="textarea-example">Description</label>
<textarea id="textarea-example">An example description here.</textarea>
<label for="single-select-example">Fruit</label>
<select id="single-select-example">
<option value="">Select a fruit...</option>
<option value="banana">Banana</option>
<option value="ananas">Ananas</option>
<option value="avocado">Avocado</option>
</select>
<label for="mutiple-select-example">Fruits</label>
<select id="multiple-select-example" multiple>
<option value="">Select a fruit...</option>
<option value="banana" selected>Banana</option>
<option value="ananas">Ananas</option>
<option value="avocado" selected>Avocado</option>
</select>
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']);
toBeCheckedtoBeChecked();
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".
<input type="checkbox" checked data-testid="input-checkbox-checked" />
<input type="checkbox" data-testid="input-checkbox-unchecked" />
<div role="checkbox" aria-checked="true" data-testid="aria-checkbox-checked" />
<div role="checkbox" aria-checked="false" data-testid="aria-checkbox-unchecked" />
<input type="radio" checked value="foo" data-testid="input-radio-checked" />
<input type="radio" value="foo" data-testid="input-radio-unchecked" />
<div role="radio" aria-checked="true" data-testid="aria-radio-checked" />
<div role="radio" aria-checked="false" data-testid="aria-radio-unchecked" />
<div role="switch" aria-checked="true" data-testid="aria-switch-checked" />
<div role="switch" aria-checked="false" data-testid="aria-switch-unchecked" />
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();
toBePartiallyCheckedtoBePartiallyChecked();
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
<input type="checkbox" aria-checked="mixed" data-testid="aria-checkbox-mixed" />
<input type="checkbox" checked data-testid="input-checkbox-checked" />
<input type="checkbox" data-testid="input-checkbox-unchecked" />
<div role="checkbox" aria-checked="true" data-testid="aria-checkbox-checked" />
<div role="checkbox" aria-checked="false" data-testid="aria-checkbox-unchecked" />
<input type="checkbox" data-testid="input-checkbox-indeterminate" />
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();
toHaveErrorMessagetoHaveErrorMessage(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
jasmine.stringContaining("partial string").
<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>
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(jasmine.stringContaining('Invalid time')); // to partially match
expect(timeInput).not.toHaveErrorMessage('Pikachu!');
toHaveDescriptiontoHaveDescription(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.
<button aria-label="Close" aria-describedby="description-close">X</button>
<div id="description-close">Closing will discard any changes</div>
<button>Delete</button>
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(/^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
This library was heavily inspired by testing-library being jest-dom a part of its ecosystem, and Kent C. Dodds' guiding principles.
The intention is to make these matchers available to developers using Jasmine instead of Jest.
I'm not aware of any, if you are please do make a PR and add it here!
For extending Jasmine's matchers outside the realm of DOM testing, Jasmine-Matchers is an option.
The more your tests resemble the way your software is used, the more confidence they can give you
Thanks goes to these people (emoji key)
 Kent C. Dodds 🚇 |  Brian Alexis 🤔 💻 📖 ⚠️ |  IanGrainger 💻 |  Michaël De Boey 🚇 |  Nick McCurdy 🚇 |  Ori Livni 💻 ⚠️ |
This project follows the all-contributors specification. Contributions of any kind are welcome!
MIT
FAQs
Custom Jasmine matchers for testing DOM elements
We found that @testing-library/jasmine-dom demonstrated a not healthy version release cadence and project activity because the last version was released a year ago. It has 15 open source maintainers collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
Research
A malicious npm package disguised as a WhatsApp client is exploiting authentication flows with a remote kill switch to exfiltrate data and destroy files.
Security News
PyPI now supports digital attestations, enhancing security and trust by allowing package maintainers to verify the authenticity of Python packages.
Security News
GitHub removed 27 malicious pull requests attempting to inject harmful code across multiple open source repositories, in another round of low-effort attacks.