Difference between Shallow, Mount and render of Enzyme

enzyme_render_diffs.md

Shallow

Real unit test (isolation, no children render)

Simple shallow

Calls:

• constructor
• render

Shallow + setProps

Calls:

• componentWillReceiveProps
• shouldComponentUpdate
• componentWillUpdate
• render

Shallow + unmount

Calls:

• componentWillUnmount

Mount

The only way to test componentDidMount and componentDidUpdate. Full rendering including child components. Requires a DOM (jsdom, domino). More constly in execution time. If react is included before JSDOM, it can require some tricks:

require('fbjs/lib/ExecutionEnvironment').canUseDOM = true;

Simple mount

Calls:

• constructor
• render
• componentDidMount

Mount + setProps

Calls:

• componentWillReceiveProps
• shouldComponentUpdate
• componentWillUpdate
• render
• componentDidUpdate

Mount + unmount

Calls:

• componentWillUnmount

Render

only calls render but renders all children.

So my rule of thumbs is:

• Always begin with shallow
• If componentDidMount or componentDidUpdate should be tested, use mount
• If you want to test component lifecycle and children behavior, use mount
• If you want to test children rendering with less overhead than mount and you are not interested in lifecycle methods, use render

There seems to be a very tiny use case for render. I like it because it seems snappier than requiring jsdom but as @ljharb said, we cannot really test React internals with this.

I wonder if it would be possible to emulate lifecycle methods with the render method just like shallow ? I would really appreciate if you could give me the use cases you have for render internally or what use cases you have seen in the wild.

I'm also curious to know why shallow does not call componentDidUpdate.

Kudos goes to enzymejs/enzyme#465 (comment) this gist is basically a copy of the comment but I wanted to separate it from there as it includes a lot of general Enzyme information which is missing in the docs.

@ycjcl868
TL;DR:
Shallow: create and test component only (no children)
Mount: same as shallow but mounts with children and parent/host component, allows lifecycle methods
Render: outputs the html given by the component, including children

For those of you coming or familiar with Angular testing, Shallow is basically just testing the component while providing 'stub' children component in the TestingModule, if necessary. Mount would be the same but instead providing the real children components in the TestingModule. Render would be basically using the fixture.debugElement.query(By.css("") feature.

Sorry everyone, this gist is still creating value for people, so I will allocate time this week, to get it updated for v3 of Enzyme. Especially as of React 15 (I think) many lifecycle methods are deprecated, so shallow and mount definitely behave different.

Helpful. Just started to work on react and enzyme.

@fokusferit as of Enzyme v3, Shallow supports CDM and CDU. I see your comment above, I do think it's worth mentioning, however.

Good to know. Please keep it up to date. Thank you.

Thank you!

Thanks for sharing!

Really helpful. Thanks

Really good Things. Thanks.

Concise and helpful! Thanks

I'm going to have this framed on my office wall 😆 thanks 👍

If you're still maintaining this it would be useful to scope this to a specific version of enzyme or else update for latest version. I spent a little bit of time being confused about my test functionality before I realized that as of v3, shallow calls additional lifecycle methods.

I have a question about testing a HOC component defined with withNavigation

class Device extends React.Component { ... }
export default withNavigation(Device)

When i try to shallow render it produces the following snapshot

<ContextConsumer>
  <Component />
</ContextConsumer>

I am not interested in testing the lifecycle of the component or behavior of componentDidMount, just want the snapshot to include the general structure and styling of the original <Device> component

@marin-k-marinov sounds like you just need render

Great，and hope the api docs can explain more

Awesome 👍

Thanks. Good thing for sharing👍

Thanks 👍

Awesome! Thanks 👏

Simple and neat explanation! Love it, Thank you!! 👍🏻

Great! Thanks 👍

thank u

Thanks a lot 👍

Thanks!!!!!!!!!!

Good one

In enzyme V3 I think shallow can call React lifecycle methods as well.

See doc: https://enzymejs.github.io/enzyme/docs/api/shallow.html

As of Enzyme v3, the shallow API does call React lifecycle methods such as componentDidMount and componentDidUpdate

Simple and clear explanation. Thanks, @fokusferit.

Good one.. Thanks.

Thanks! 👍

@fokusferit Thanks for this!
One thing to improve with respect to use cases for each: What if you have a component that needs a context, like:

• a component that must be wrapped in a provider, e.g., your SessionContext.Provider
• a component that needs to be rendered inside of a router (MemoryRouter?) because it uses useLocation()

If you use shallow, won't it just end up "rendering" the SessionContext.Provider/MemoryRouter because that's the first level of component? That seems like it would always be useless. I'm trying to figure this out now, and Google sent me here, but your gist doesn't quite mention these cases. Thanks again 👍