Testing React Native with the *new* Jest — Part I

Snapshots come into play!

Ferran Negre Blocked Unblock Follow Following Sep 9, 2016

In my journey with React, I have been always testing and encouraging people who surround me to test their apps. I have always used Jest for it. But let’s not talk about it again and let’s focus on React Native. Wouldn’t it be nice to use the same framework to test our amazing mobile apps? Furthermore… Wouldn’t it be nice to reuse some tests if we are reusing logic between our web app and our mobile app?

I will try to answer those questions in the following series. In this first article, I will focus on testing React Native components and the pros and cons of using the new Snapshot system provided by Jest vs. shallow rendering comparison (test utils and Enzyme).

The new Jest ?

Before you ask me why I am calling it the new Jest, please check out the updates notes from Jest 14 and Jest 15. It is not only me who says that Jest has a total new face compared to 1 year ago… It is also his number one core contributor:

In this series we will focus on one of the new Jest features: Snapshot testing.

Jest can capture snapshots of React trees or other serializable values to write tests quickly and it provides a seamless update experience.

Let’s begin to prove the above quote!

Set up Jest in a React Native project

Trivial, seriously. Just follow the docs:

// Install dependencies

npm install --save-dev jest babel-jest jest-react-native babel-preset-react-native react-test-renderer

// package.json

"scripts": {

"test": "jest"

},

"jest": {

"preset": "jest-react-native"

}

// .babelrc

{

"presets": ["react-native"]

}

DONE. Try it out with:

npm test

Time to test components

The example repo for this article renders a list of Github repositories. You can read several test examples in there but for the purpose this article, let’s focus on testing a simple component called RepoItem:

Full file includes the props definition and styles

As you can see, this component has an interesting prop called isSelected:

When isSelected = true, then the item renders with a green background

The problems of Shallow Rendering comparison

Have you ever used Shallow rendering from react-addons-test-utils or Enzyme? They are pretty similar, Enzyme got popular cause it has a nicer API which also allows you to find elements in your React trees. Let’s choose this one and try to test a React Native component using it.

Enzyme

First problems when trying to use the shallow function from Enzyme (forget about mount in react-native):

react-addons-test-utils is an implicit dependency in order to support react@0.13–14. Please add the appropriate version to your devDependencies. See https://github.com/airbnb/enzyme#installation

react-dom is an implicit dependency in order to support react@0.13–14. Please add the appropriate version to your devDependencies. See https://github.com/airbnb/enzyme#installation

So we actually need to install react-dom and react-addons-test-util to our devDependencies for Enzyme to work… Ouch!:

npm install react-dom react-addons-test-util --save-dev

Ok, let’s go and try to do the first full shallow comparison:

The onPress function will make this test to fail

Ok, actually, this first example won’t work. See the onPress property? The first problem that we have here is the way it’s defined in the component:

onPress={() => {props.selectRepo(id)}}

Both functions won’t be the same (we are creating a new function instance) thus the comparison will fail. We could make some workarounds here but… Let’s be lazy and skip the TouchableHighlight part and assume that nobody will break it:

This will work but…

Don’t you feel we are reimplementing the render() again? Any prop you add/remove or any change you make… You need to come back here and do the same.

All right, now we want to test the component when the prop isSelected is set to true:

Copy-paste-copy-paste…

Since recreating the bigger picture gets so repetitive, developers tend to test only the dynamic parts, see:

Yes, you can create a function that gives you the shallow component and accepts the isSelected prop

This seems better, right? Let’s continue…

Assume that at some point on this project, our client decides that when you click a list item, a part from the selected background color, we also want to show more information, specifically, the repo description. It would look like:

When isSelected = true, the item renders with a green background and shows the repo description

With this change, two things will happen:

The test that checks all the render output will fail: We will need to go back and reimplement it The test that checks only the dynamic part will pass anyway (Oops! is that good?)

In the first case, we need to go back and copy-paste this line into it’s corresponded place:

When isSelected prop is true

In the second case, we need to remember to go back to the test and add the new cases:

New cases

Do you see the problems? The way I see it… The bigger picture (full render) is complicated to create, tedious to maintain and very repetitive (copy-paste). The second approach (using find, contains…) is unstable: We need to remember to implement all the cases since the new ones won’t break those tests.

Check the full RepoItem-Shallow-test.js file for a bigger picture.

Shallow rendering summary

Pros

Powerful selector api (find, contains, etc)

It is actually working in React Native (shallow part)

Cons

It feels you are repeating yourself all the time, thus, people will usually tend to test only specific parts of the output (render) instead of the big picture

Copy-paste from the component to the test

Difficult to maintain

Go try convincing people to write them

Snapshots to the rescue

Jest 14 introduced Snapshots testing: Check out why are they so great:

No flakiness: Because tests are run in a command line runner instead of a real browser or on a real phone, the test runner doesn’t have to wait for builds, spawn browsers, load a page and drive the UI to get a component into the expected state which tends to be flaky and the test results become noisy.

Fast iteration speed: Engineers want to get results in less than a second rather than waiting for minutes or even hours. If tests don’t run quickly like in most end-to-end frameworks, engineers don’t run them at all or don’t bother writing them in the first place.

Debugging: It’s easy to step into the code of an integration test in JS instead of trying to recreate the screenshot test scenario and debugging what happened in the visual diff.

After the read, let’s try it out and convince ourselves.

We can write a Snapshot test for our first RepoItem (when isSelected is set to false):

Check the result at: RepoItem-Snapshot-test.snap. You will find that it does not use the background color property (as expected) because isSelected is false:

// RepoItem-Snapshot-test.snap

...

style={

Array [

Object {

"backgroundColor": "transparent"

},

undefined

]

}

...

Now, let’s test the output when isSelected is set to true (it needs to render a green background). Since our component is actually a pure function, this becomes trivial:

And we can find the expected part inside the resulted snapshot RepoItem-Snapshot-test.snap:

// RepoItem-Snapshot-test.snap

style={

Array [

Object {

"paddingHorizontal": 24,

"paddingVertical": 8

},

Object {

"backgroundColor": "#B2DFDB"

}

]

}>

Great! Now, remember that our client came and asked us to implement the expanded part to show the repo description (a part from the background color). Let’s run the tests:

Oops! A test has failed

Let’s check why:

Nice output!

At developing time, Jest will show us very useful error outputs (you can use the watch argument to see them live). Since this change is expected, we can run:

npm test -- -u RepoItem-Snapshot

And that will update our snapshot for free. Check it out:

...

50000 stars

</Text>

<Text

accessible={true}

allowFontScaling={true}

ellipsizeMode="tail">

Useful description goes here.

</Text>

</View>

</View>

...

Boom! Our test failed, we inspected it, the failure was expected and we re-generated the snapshot. We did not have to modify our test. Moreover, this snapshot difference will be shown in our next Pull Request.

And that is all, seriously. Our render output is fully tested for both cases and it is capable to react to changes giving us nice error outputs and an easy way to fix them. Quiet neat, right?

Can I test components with internal state?

Before you ask, yes, you can. Check this example in the Jest repo: Link.react-test.js. Of course, if your component has internal state (side effects), it will get much more complicated to test. See:

I am missing a selector api like Enzyme

Specially if your component has state and you need to trigger some event, it can be very tedious to find the node inside the tree. However, this question has been already asked https://github.com/facebook/jest/issues/1411 and it has an official answer:

We are working on a selector API for the test renderer which will make this possible through an official API — Christoph Pojer

Snapshots summary

Pros

Easy to write

Don’t repeat yourself (DRY)

Compatible with React Native: Check RepoList-Snapshot-test.js and its snapshot which renders a ListView with its items (try to do that without snapshots if you can)

Error messages on develop time (you can use —watch t00)

More goodies to come!

Cons