What is flaky unit tests and how to mitigate it.

Go Back to blogs page

Abhishekh Maharjan Photo
Abhishekh Maharjan
Full Stack Software Developer

Read Time : 4 mins

Main picture of the blog

React | unit testing | jest | react-testing-library |

Flaky tests are tests that produce different outcomes for the same code under the same conditions. They are unreliable and can lead to a lack of confidence in the testing process. Both mocking and not mocking components can potentially introduce flakiness if not done carefully, but they have different characteristics.

1. Mocking Components:

Potential for Flakiness:

  • If the mocks used in the test are not kept up-to-date with the actual implementation of the mocked components, the tests may pass even if the real components would fail.

  • Overly complex or incorrect mocks can introduce flakiness.

Example:If the mocked child component's behavior is not aligned with the actual behavior, changes in the actual component might not be reflected in the test, leading to false positives or negatives.

2. Not Mocking Components (Shallow Rendering):

Potential for Flakiness:

  • If the child components have side effects, network requests, or asynchronous behavior that is not properly handled in the test, it might lead to unpredictable outcomes.

  • Changes in the child components might affect the test outcomes, especially if the parent component relies heavily on their behavior.

Example:If the child components perform asynchronous operations (like fetching data), not properly waiting for them to complete before making assertions could lead to flakiness.

How to Mitigate Flakiness:

Regardless of the testing approach, there are strategies to mitigate flakiness:

  1. Maintain Mocks Carefully:

    • If you choose to mock components, keep the mocks up-to-date with the actual component behavior.

    • Regularly review and update mocks when component implementations change.

  2. Handle Asynchronous Operations:

    • For asynchronous code, ensure proper handling of promises, timeouts, and other async operations in your tests.

    • Use tools like


      or utilities provided by testing libraries to handle asynchronous behavior.

  3. Isolate Tests:

    • Ensure that each test is independent and doesn't rely on the state left behind by previous tests.

    • Avoid sharing state between tests.

  4. Use Realistic Data:

    • If you're not mocking, use realistic data in your tests to simulate real-world scenarios.

    • Mimic the conditions of your application as closely as possible.

  5. Regularly Review and Refactor Tests:

    • Periodically review and refactor your tests to ensure they remain reliable as your codebase evolves.

In summary, both mocking and not mocking can potentially introduce flakiness if not handled carefully. The key is to strike a balance, maintain tests regularly, and ensure they reflect the actual behavior of the application components.