Testing React Apps

    If you are new to React, we recommend using Create React App. It is ready to use and ! You will only need to add for rendering snapshots.

    Run

    • npm
    • Yarn
    • pnpm
    1. yarn add --dev react-test-renderer
    1. pnpm add --save-dev react-test-renderer

    If you have an existing application you’ll need to install a few packages to make everything work well together. We are using the babel-jest package and the react babel preset to transform our code inside of the test environment. Also see .

    Run

    • npm
    • Yarn
    • pnpm
    1. npm install --save-dev jest babel-jest @babel/preset-env @babel/preset-react react-test-renderer
    1. yarn add --dev jest babel-jest @babel/preset-env @babel/preset-react react-test-renderer
    1. pnpm add --save-dev jest babel-jest @babel/preset-env @babel/preset-react react-test-renderer

    Your package.json should look something like this (where <current-version> is the actual latest version number for the package). Please add the scripts and jest configuration entries:

    1. {
    2.   "dependencies": {
    3.     "react": "<current-version>",
    4.     "react-dom": "<current-version>"
    5.   },
    6.   "devDependencies": {
    7.     "@babel/preset-env": "<current-version>",
    8.     "@babel/preset-react": "<current-version>",
    9.     "babel-jest": "<current-version>",
    10.     "jest": "<current-version>",
    11.     "react-test-renderer": "<current-version>"
    12.   },
    13.   "scripts": {
    14.     "test": "jest"
    15.   }
    16. }

    babel.config.js

    1. module.exports = {
    2.   presets: [
    3.     '@babel/preset-env',
    4.     ['@babel/preset-react', {runtime: 'automatic'}],
    5.   ],
    6. };

    And you’re good to go!

    Let’s create a for a Link component that renders hyperlinks:

    Link.js

    1. import {useState} from 'react';
    3. const STATUS = {
    4.   HOVERED: 'hovered',
    5.   NORMAL: 'normal',
    6. };
    8. export default function Link({page, children}) {
    9.   const [status, setStatus] = useState(STATUS.NORMAL);
    11.   const onMouseEnter = () => {
    12.     setStatus(STATUS.HOVERED);
    13.   };
    15.   const onMouseLeave = () => {
    16.     setStatus(STATUS.NORMAL);
    17.   };
    19.   return (
    20.     <a
    21.       className={status}
    22.       href={page || '#'}
    23.       onMouseLeave={onMouseLeave}
    24.     >
    25.       {children}
    26.     </a>
    27.   );
    28. }

    note

    Examples are using Function components, but Class components can be tested in the same way. See React: Function and Class Components. Reminders that with Class components, we expect Jest to be used to test props and not methods directly.

    Now let’s use React’s test renderer and Jest’s snapshot feature to interact with the component and capture the rendered output and create a snapshot file:

    When you run yarn test or , this will produce an output file like this:

    __tests__/__snapshots__/Link.test.js.snap

    1. exports[`changes the class when hovered 1`] = `
    2. <a
    3.   className="normal"
    4.   href="http://www.facebook.com"
    5.   onMouseEnter={[Function]}
    6.   onMouseLeave={[Function]}
    7. >
    8.   Facebook
    9. </a>
    10. `;
    12. exports[`changes the class when hovered 2`] = `
    13. <a
    14.   className="hovered"
    15.   href="http://www.facebook.com"
    16.   onMouseEnter={[Function]}
    17.   onMouseLeave={[Function]}
    18. >
    19.   Facebook
    20. </a>
    21. `;
    23. exports[`changes the class when hovered 3`] = `
    24. <a
    25.   className="normal"
    26.   href="http://www.facebook.com"
    27.   onMouseEnter={[Function]}
    28.   onMouseLeave={[Function]}
    29. >
    30.   Facebook
    31. </a>
    32. `;

    The next time you run the tests, the rendered output will be compared to the previously created snapshot. The snapshot should be committed along with code changes. When a snapshot test fails, you need to inspect whether it is an intended or unintended change. If the change is expected you can invoke Jest with jest -u to overwrite the existing snapshot.

    The code for this example is available at .

    Snapshot Testing with Mocks, Enzyme and React 16+

    There’s a caveat around snapshot testing when using Enzyme and React 16+. If you mock out a module using the following style:

    1. jest.mock('../SomeDirectory/SomeComponent', () => 'SomeComponent');

    Then you will see warnings in the console:

    1. Warning: <SomeComponent /> is using uppercase HTML. Always use lowercase HTML tags in React.
    3. # Or:
    4. Warning: The tag <SomeComponent> is unrecognized in this browser. If you meant to render a React component, start its name with an uppercase letter.

    React 16 triggers these warnings due to how it checks element types, and the mocked module fails these checks. Your options are:

    1. Render as text. This way you won’t see the props passed to the mock component in the snapshot, but it’s straightforward:

      1. jest.mock('./SomeComponent', () => () => 'SomeComponent');

    2. Render as a custom element. DOM “custom elements” aren’t checked for anything and shouldn’t fire warnings. They are lowercase and have a dash in the name.

      1. jest.mock('./Widget', () => () => <mock-widget />);

    3. Use react-test-renderer. The test renderer doesn’t care about element types and will happily accept e.g. SomeComponent. You could check snapshots using the test renderer, and check component behavior separately using Enzyme.

    4. Disable warnings all together (should be done in your jest setup file):

      1. jest.mock('fbjs/lib/warning', () => require('fbjs/lib/emptyFunction'));

      This shouldn’t normally be your option of choice as useful warnings could be lost. However, in some cases, for example when testing react-native’s components we are rendering react-native tags into the DOM and many warnings are irrelevant. Another option is to swizzle the console.warn and suppress specific warnings.

    react-testing-library

    • npm
    • Yarn
    • pnpm
    1. npm install --save-dev @testing-library/react
    1. yarn add --dev @testing-library/react

    Let’s implement a checkbox which swaps between two labels:

    CheckboxWithLabel.js

    1. import {useState} from 'react';
    3. export default function CheckboxWithLabel({labelOn, labelOff}) {
    4.   const [isChecked, setIsChecked] = useState(false);
    6.   const onChange = () => {
    7.     setIsChecked(!isChecked);
    8.   };
    10.     <label>
    11.       <input type="checkbox" checked={isChecked} onChange={onChange} />
    12.       {isChecked ? labelOn : labelOff}
    13.     </label>
    14.   );
    15. }

    __tests__/CheckboxWithLabel-test.js

    2. import CheckboxWithLabel from '../CheckboxWithLabel';
    4. // Note: running cleanup afterEach is done automatically for you in @testing-library/react@9.0.0 or higher
    5. // unmount and cleanup DOM after the test is finished.
    6. afterEach(cleanup);
    8. it('CheckboxWithLabel changes the text after click', () => {
    9.   const {queryByLabelText, getByLabelText} = render(
    10.     <CheckboxWithLabel labelOn="On" labelOff="Off" />,
    11.   );
    13.   expect(queryByLabelText(/off/i)).toBeTruthy();
    15.   fireEvent.click(getByLabelText(/off/i));
    17.   expect(queryByLabelText(/on/i)).toBeTruthy();
    18. });

    The code for this example is available at .

    Enzyme

    • npm
    • Yarn
    • pnpm
    1. npm install --save-dev enzyme
    1. yarn add --dev enzyme
    1. pnpm add --save-dev enzyme

    If you are using a React version below 15.5.0, you will also need to install react-addons-test-utils.

    Let’s rewrite the test from above using Enzyme instead of react-testing-library. We use Enzyme’s in this example.

    __tests__/CheckboxWithLabel-test.js

    1. import Enzyme, {shallow} from 'enzyme';
    2. import Adapter from 'enzyme-adapter-react-16';
    3. import CheckboxWithLabel from '../CheckboxWithLabel';
    5. Enzyme.configure({adapter: new Adapter()});
    7. it('CheckboxWithLabel changes the text after click', () => {
    8.   // Render a checkbox with label in the document
    9.   const checkbox = shallow(<CheckboxWithLabel labelOn="On" labelOff="Off" />);
    11.   expect(checkbox.text()).toBe('Off');
    13.   checkbox.find('input').simulate('change');
    15.   expect(checkbox.text()).toBe('On');
    16. });

    The code for this example is available at examples/enzyme.

    If you need more advanced functionality, you can also build your own transformer. Instead of using babel-jest, here is an example of using @babel/core:

    custom-transformer.js

    1. 'use strict';
    3. const {transform} = require('@babel/core');
    4. const jestPreset = require('babel-preset-jest');
    6. module.exports = {
    7.   process(src, filename) {
    8.     const result = transform(src, {
    9.       filename,
    10.       presets: [jestPreset],
    11.     });
    13.     return result || src;
    14.   },
    15. };

    Don’t forget to install the @babel/core and babel-preset-jest packages for this example to work.

    To make this work with Jest you need to update your Jest configuration with this: "transform": {"\\.js$": "path/to/custom-transformer.js"}.

    1. const babelJest = require('babel-jest');
    3. module.exports = babelJest.createTransformer({
    4. });

    See dedicated docs for more details.