top of page
  • Writer's pictureCraig Risi

The Pros and Cons of Different Test Tools – Jest

In my previous blog post I spoke about the effectiveness of using the three different JavaScript libraries to help build an effective API automation framework. However, if you still want to get all the benefits of a JS-based framework that can easily execute tests in a pipeline without the hassle of trying to maintain three or more different libraries, then Jest is probably for you.

Developed by Facebook, Jest is a popular JavaScript testing framework that's widely used for automating unit, integration, and snapshot testing in JavaScript applications, particularly those built with frameworks like React, Vue.js, and Angular.

Jest takes a lot of the hassle of using multiple different packages to get the effectiveness of a complete automation tool and makes it significantly easier to work with. Combined with important features like built-in mocking, snapshot testing and code coverage measurement and it provides you with an all-round testing tool that is fast and effective. That can be used to drive better code coverage in unit tests and provide good end-to-end coverage across APIs and node.JS-based frontends at a bigger component and integration layer.

And, because it’s based on a lot of the same core principles as Mocha, it also means that teams that have built their frameworks around mocha, chai and axios won’t need to alter their scripts too much to use Jest and gain the benefit of its additional tools.

Here are some key features and concepts of the Jest testing framework:

Automated Testing: Jest is designed to make testing your JavaScript codebase as automated and efficient as possible. It provides a range of tools and utilities that help streamline the testing process.

Built-in Assertions: Jest comes with a set of built-in assertion functions that allow you to test different conditions in your code. These assertions include expect, which is used to make assertions about your code's behavior.

Mocking: Jest provides built-in mocking capabilities, allowing you to easily mock dependencies, functions, and modules. This is particularly useful for isolating the code you're testing from external dependencies, ensuring that your tests focus on the specific behavior you're testing.

Snapshot Testing: Snapshot testing is a unique feature of Jest. It allows you to capture a snapshot of the output of a component or function and compare it against the saved snapshot on subsequent test runs. This is useful for detecting unintended changes in the UI or output of your code.

Test Runners: Jest includes a powerful test runner that can run your tests in parallel, which helps to speed up the testing process. It also provides features like test prioritization, which ensures that the most relevant tests are executed first.

Test Suites and Test Cases: Jest organizes your tests into test suites and test cases. Test suites are containers for related test cases, and test cases contain individual test scenarios.

Asynchronous Testing: Jest provides tools for testing asynchronous code, including support for promises and async/await syntax. This makes it easy to test functions that involve asynchronous operations.

Code Coverage: Jest can generate code coverage reports that show which parts of your code are covered by tests. This helps you identify areas that need more thorough testing.

Configuration: Jest comes with sensible default configurations, but you can also customize it to fit your project's needs. You can configure various aspects of testing, including setting up test environments, defining global setup/teardown functions, and more.

Extensibility: Jest is highly extensible, and you can easily add plugins and custom matchers to enhance its functionality.

As with all things, there are always downsides and the biggest loss people will get in using Jest over the other JS-based approaches, is a lack of modularity and customization, as Jest does force you to use its own in-built libraries and features, which could restrict teams that have put in a lot of effort to use other node packages to create a well-rounded test automation approach.

To get started with Jest, you would typically install it as a dependency in your project using a package manager like npm or yarn. Then, you can write your test files using the describe, it, and expect syntax to define test suites, test cases, and assertions.

Here's a simple example of a Jest test:

export function add(a, b) 
    { return a + b; } 
import { add } from './math.js'; 

describe('add function', () => { 
    it('adds two numbers correctly', () => { 
        expect(add(2, 3)).toBe(5); 

Running your tests is usually as simple as executing a command like npm test or yarn test, depending on your project setup.

Remember that Jest is quite versatile and can be used for a variety of JavaScript projects. Its ease of use, built-in features, and strong community support have contributed to its widespread adoption for testing JavaScript applications.

*Image showing the lassive grwoth of Jest from 2016 to 2019

Below is a brief history of Jest:

· 2013: Jest's development began at Facebook as a response to the growing need for a more efficient and developer-friendly testing solution. At the time, existing testing frameworks had limitations that made testing large-scale JavaScript applications, like Facebook's own web applications, more difficult.

· 2014: Jest was open-sourced by Facebook in January 2014. It was initially released with a focus on simplicity, speed, and ease of use. It introduced features like automatic mocking of modules, parallel test execution, and built-in assertion functions.

· 2015: Snapshot testing was introduced to Jest. This feature allowed developers to capture and compare the output of components, making it easier to detect unintended changes in the UI.

· 2016: Jest gained more popularity within the JavaScript community, especially among developers working with React. Its speed and ease of use contributed to its adoption in various projects.

· 2017: The "Jest Platform" initiative was announced, which aimed to modularize Jest into smaller packages. This made it easier to use specific parts of Jest, like the testing utilities, without needing the entire framework.

· 2018: Jest continued to evolve with improvements to its features and performance. Facebook continued to maintain the project and incorporate contributions from the open-source community.

· 2019: Jest reached version 24, introducing features like improved error messages, enhanced watch mode, and support for test concurrency.

· 2020: Jest 26 was released with improvements to the test runner, a new configuration system, and various other enhancements. It also introduced a new way of handling asynchronous tests using the waitFor function.

· 2021: Jest 27 was released with features like a new default runner, improvements to the watch mode, and enhanced error messages. This version continued to refine the testing experience and make it even more efficient.

However, thanks to strong support from Facebook and a committed user base intent on radically improving the tool, Jest has continued to make improvements and developer far quicker than many other tools. This is great for innovation, though can also be a bane for teams not used to regular maintenance and can create a lot of tech debt if not managed correctly.

Here's a short list of pros and cons of using Jest for testing in JavaScript applications:


  • Easy Setup and Configuration: Jest comes with sensible default configurations, making it easy to get started with testing. The setup process is straightforward, and you can begin writing tests quickly.

  • Built-in Mocking: Jest provides built-in mocking capabilities, allowing you to easily mock modules, functions, and dependencies. This simplifies isolating components for testing and reduces the need for external mocking libraries.

  • Snapshot Testing: Snapshot testing in Jest allows you to capture and compare component outputs over time. This is especially useful for identifying unexpected changes in the UI.

  • Fast Test Execution: Jest's parallel test execution and efficient test runner contribute to faster test execution times, which is crucial for maintaining a smooth development workflow.

  • Comprehensive Assertion Library: Jest provides a wide range of built-in assertion functions (expect) for writing assertions. This helps you express the expected behavior of your code in a readable and expressive manner.

  • Automatic Test Watching: Jest's watch mode automatically detects changes to your code and re-runs relevant tests, providing immediate feedback during development.

  • Code Coverage Reporting: Jest can generate code coverage reports, helping you identify areas of your codebase that lack test coverage.

  • Large Community and Active Development: Jest is widely used and maintained by a large open-source community, ensuring that it stays up-to-date with best practices and new features.

  • ·Support for Asynchronous Testing: Jest provides tools for testing asynchronous code using callbacks, promises, and async/await syntax.


  • Large Bundle Size: Jest's feature-rich nature can result in a relatively larger bundle size compared to more minimalistic testing libraries, which might be a concern for some projects.

  • Learning Curve for Advanced Features: While basic usage is straightforward, fully utilizing advanced features like custom matchers, plugins, and configurations might require some learning and experimentation.

  • Snapshot Maintenance: While snapshot testing is convenient, maintaining snapshots can become cumbersome when UI changes are intentional and need to be updated across tests.

  • Opinionated Configuration: Jest comes with its own opinions on configuration, which might not align perfectly with every project's needs. Configuring Jest to work with some specific setups might take some additional effort.

  • Global Scope: Jest sets up some global variables and behaviors that might conflict with other tools or libraries, potentially causing unexpected issues.

  • Complexity for Smaller Projects: For small projects or projects with minimal testing needs, Jest's extensive features might feel like overkill and add unnecessary complexity.

  • Performance Impact: While Jest is generally fast, in some complex cases or on slower systems, its speed might not meet expectations.

When to select Jest for your automation tool:

  • When you require a node.JS tool for your Ci/CD pipelines, but want something easy to maintain

  • You want to use the same tool for unit tests, integration tests and end-to-end tests for web-based applications.

  • If you have a fairly developer-centric testing team that is comfortable in working with open-source technologies

Jest is widely used and respected in the JavaScript community, and its features can greatly benefit projects of varying sizes and complexities. It might mean teams that enjoy customising and harnessing tools to suit their own benefits may face some limitations, but as an all-round open-source test automation tool, it is certainly one of the best out there.


Thanks for subscribing!

bottom of page