API

Vue Testing Library re-exports everything from DOM Testing Library.

It also exposes these methods:


render(Component, options, callback)

The render function is the only way of rendering components in Vue Testing Library.

It takes up to 3 parameters and returns an object with some helper methods.

function render(Component, options, callbackFunction) {
return {
...DOMTestingLibraryQueries,
container,
baseElement,
debug,
unmount,
isUnmounted,
html,
emitted,
updateProps,
}
}

Parameters

Component

The valid Vue Component to be tested.

Options

An object containing additional information to be passed to @vue/test-utils mount.

Additionally, the following options can also be provided:

store (Object | Store)

The object definition of a Vuex store. If a store object is provided, Vue Testing Library will import and configure a Vuex store. If an instantiated Vuex store is passed, it will be used.

routes (Array | VueRouter)

A set of routes for Vue Router. If routes is provided, the library will import and configure Vue Router. If an instantiated Vue Router is passed, it will be used.

props (Object)

It will be merged with propsData.

container (HTMLElement)

By default, Vue Testing Library will create a div and append it to the baseElement. This is where your component will be rendered. If you provide your own HTMLElement container via this option, it will not be appended to the baseElement automatically.

For example: If you are unit testing a tablebody element, it cannot be a child of a div. In this case, you can specify a table as the render container.

const table = document.createElement('table')
const {container} = render(TableBody, {
props,
container: document.body.appendChild(table),
})
baseElement (HTMLElement)

If the container is specified, then this defaults to that, otherwise this defaults to document.body. baseElement is used as the base element for the queries as well as what is printed when you use debug().

Callback Function

function callbackFunction(vueInstance, vuexStore, router) {}

A callback function that receives the Vue instance as a parameter. Its return value is merged with options, allowing 3rd party plugins to be installed prior to mount. To see how this works, see the example using vue-i18n.

The function will also receive the Store or the Router object if the associated option was passed in during render.

render result

The render method returns an object that has a few properties:

...queries

The most important feature of render is that the queries from DOM Testing Library are automatically returned with their first argument bound to the baseElement, which defaults to document.body.

See Queries for a complete list.

const {getByLabelText, queryAllByTestId} = render(Component)

container

The containing DOM node of your rendered Vue Component. By default it's a div. This is a regular DOM node, so you can call container.querySelector etc. to inspect the children.

Tip: To get the root element of your rendered element, use container.firstChild.

๐Ÿšจ If you find yourself using container to query for rendered elements then you should reconsider! The other queries are designed to be more resilient to changes that will be made to the component you're testing. Avoid using container to query for elements!

baseElement

The containing DOM node where your Vue Component is rendered in the container. If you don't specify the baseElement in the options of render, it will default to document.body.

This is useful when the component you want to test renders something outside the container div, e.g. when you want to snapshot test your portal component which renders its HTML directly in the body.

Note: the queries returned by the render looks into baseElement, so you can use queries to test your portal component without the baseElement.

debug(element)

This method is a shortcut for console.log(prettyDOM(element)).

element can either be a DOM element or an array containing DOM elements. It defaults to baseElement

import { render } from '@testing-library/vue'
const HelloWorldComponent {
template: `<h1>Hello World</h1>`
}
const { debug } = render(HelloWorldComponent)
debug()
// <div>
// <h1>Hello World</h1>
// </div>
// you can also pass an element: debug(getByTestId('messages'))

This is a simple wrapper around prettyDOM which is also exposed and comes from DOM Testing Library.

unmount()

An alias for @vue/test-utils destroy.

isUnmounted()

Returns whether if a Vue component has been destroyed.

html()

An alias for @vue/test-utils html.

emitted()

An alias for @vue/test-utils emitted.

updateProps(props)

An alias for @vue/test-utils setProps.

It returns a Promise through wait(), so you can await updateProps(...).


fireEvent

Because Vue applies DOM updates asynchronously during re-renders, the fireEvent tools are re-exported as async functions. To ensure that the DOM is properly updated in response to an event in a test, it's recommended to always await fireEvent.

await fireEvent.click(getByText('Click me'))

Additionally, Vue Testing Library exposes two useful methods:

touch(elem)

It triggers both focus() and blur() events.

await fireEvent.touch(getByLabelText('username'))
// Same as:
await fireEvent.focus(getByLabelText('username'))
await fireEvent.blur(getByLabelText('username'))

update(elem, value)

Properly handles inputs controlled by v-model. It updates the input/select/textarea inner value while emitting the appropriate native event.

See a working example of update in the v-model example test.


cleanup

Unmounts Vue trees that were mounted with render.

If you are using an environment that supports afterEach hook (as in Jest), there's no need to call cleanup manually. Vue Testing Library handles it for you.

Failing to call cleanup when you've called render could result in a memory leak and tests which are not idempotent (which can lead to difficult to debug errors in your tests).

Last updated on by Nick McCurdy