jest

Delightful JavaScript Testing.

weekly downloads37.5M

versionv30.2.0

licenseMIT

categorytesting

avababelcoverageeasyexpectfacebookimmersiveinstantjasminejestjsdommochamockingpainlessqunitrunnersandboxedsnapshottaptapetesttestingtypescriptwatch

Overview

Jest is a comprehensive JavaScript testing framework maintained by Meta (Facebook) that bundles a test runner, assertion library, mocking utilities, and code coverage tools into a single package. Originally created to test React applications, it has evolved into a general-purpose testing solution for any JavaScript or TypeScript project, including Node.js backends, Vue, Angular, and vanilla JavaScript codebases.

The framework's primary value proposition is eliminating configuration overhead. Unlike traditional testing stacks that require assembling separate tools (test runner + assertion library + mocking + coverage), Jest works out-of-the-box with sensible defaults. It automatically finds test files, transforms modern JavaScript/TypeScript, and runs tests in parallel with process isolation to prevent cross-test contamination.

With over 37 million weekly downloads, Jest dominates the JavaScript testing ecosystem, particularly in React-heavy environments where its snapshot testing and module mocking shine. It includes a sophisticated watch mode that intelligently re-runs only affected tests, timer manipulation for async code, and extensive CLI options for CI/CD integration. The framework's opinionated design trades flexibility for developer productivity, making it ideal for teams wanting consistent testing patterns without toolchain maintenance.

Jest is particularly well-suited for frontend component testing, API endpoint validation, and utility function testing. Its built-in code coverage reports (via Istanbul under the hood) and threshold enforcement make it a complete solution for quality gates in modern CI pipelines.

Quick Start

typescript

// math.js
export const add = (a, b) => a + b;
export const fetchUser = async (id) => {
  const response = await fetch(`https://api.example.com/users/${id}`);
  return response.json();
};

// math.test.js
import { add, fetchUser } from './math';

describe('Math utilities', () => {
  test('adds two numbers correctly', () => {
    expect(add(2, 3)).toBe(5);
    expect(add(-1, 1)).toBe(0);
  });

  test('handles edge cases', () => {
    expect(add(0.1, 0.2)).toBeCloseTo(0.3);
    expect(() => add('a', 'b')).not.toThrow();
  });
});

describe('API integration', () => {
  beforeEach(() => {
    global.fetch = jest.fn();
  });

  test('fetches user data successfully', async () => {
    const mockUser = { id: 1, name: 'Alice' };
    global.fetch.mockResolvedValueOnce({
      json: async () => mockUser
    });

    const user = await fetchUser(1);
    
    expect(fetch).toHaveBeenCalledWith('https://api.example.com/users/1');
    expect(user).toEqual(mockUser);
  });

  test('handles fetch errors', async () => {
    global.fetch.mockRejectedValueOnce(new Error('Network failure'));
    
    await expect(fetchUser(1)).rejects.toThrow('Network failure');
  });
});

// Run with: npx jest
// Watch mode: npx jest --watch
// Coverage: npx jest --coverage

Use Cases

React component testing with snapshots: Test React components by rendering them to JSON and storing snapshots to detect unintended UI changes. Jest's shallow rendering integration with libraries like React Testing Library makes component behavior validation straightforward without actual browser overhead.

Node.js API testing with mocking: Validate Express or Fastify endpoints by mocking database calls, external HTTP requests, and authentication layers. Jest's module mocking system intercepts require()/import statements, letting you isolate business logic from infrastructure.

Async code testing with timer manipulation: Test setTimeout, setInterval, debounce, and throttle logic by using jest.useFakeTimers() to control time progression. This eliminates flaky tests caused by real timing dependencies and speeds up test execution.

TypeScript project testing: Test TypeScript codebases without separate transpilation setup. Jest automatically uses Babel or ts-jest to transform TypeScript files, respecting tsconfig.json paths and type definitions during test execution.

CI/CD quality gates: Run jest --coverage --coverageThreshold in continuous integration pipelines to enforce minimum code coverage percentages. Combined with watch mode locally, developers get instant feedback while CI enforces team standards before merge.

Pros & Cons

Pros

+Zero-config setup works immediately for most JavaScript/TypeScript projects without manual configuration files
+Complete testing solution bundles runner, assertions, mocking, coverage, and snapshots eliminating dependency management
+Intelligent watch mode and parallel execution with caching significantly reduces test iteration time
+Powerful module mocking system automatically mocks dependencies and provides fine-grained control over function behavior
+Snapshot testing catches UI regressions with minimal boilerplate, particularly effective for React components

Cons

−Abstraction layer can hide underlying behavior making debugging complex test failures difficult for newcomers
−Snapshot tests can create maintenance burden if overused or committed without proper review of changes
−Global namespace pollution with describe/it/expect makes some developers prefer explicit imports from testing libraries
−Module mocking magic sometimes conflicts with ES modules requiring experimental flags or workarounds
−Large test suites can still be slow despite optimizations, especially with heavy DOM manipulation or unoptimized beforeEach hooks

Alternatives

vitestv4.0.18

Next generation testing framework powered by Vite

testingvitevitest

31.1M / week

Comparisons

vitest vs jest

testing

Install

bash

npm install jest

bash

pnpm add jest

bash

bun add jest

Overview

Quick Start

typescript

// math.js
export const add = (a, b) => a + b;
export const fetchUser = async (id) => {
  const response = await fetch(`https://api.example.com/users/${id}`);
  return response.json();
};

// math.test.js
import { add, fetchUser } from './math';

describe('Math utilities', () => {
  test('adds two numbers correctly', () => {
    expect(add(2, 3)).toBe(5);
    expect(add(-1, 1)).toBe(0);
  });

  test('handles edge cases', () => {
    expect(add(0.1, 0.2)).toBeCloseTo(0.3);
    expect(() => add('a', 'b')).not.toThrow();
  });
});

describe('API integration', () => {
  beforeEach(() => {
    global.fetch = jest.fn();
  });

  test('fetches user data successfully', async () => {
    const mockUser = { id: 1, name: 'Alice' };
    global.fetch.mockResolvedValueOnce({
      json: async () => mockUser
    });

    const user = await fetchUser(1);
    
    expect(fetch).toHaveBeenCalledWith('https://api.example.com/users/1');
    expect(user).toEqual(mockUser);
  });

  test('handles fetch errors', async () => {
    global.fetch.mockRejectedValueOnce(new Error('Network failure'));
    
    await expect(fetchUser(1)).rejects.toThrow('Network failure');
  });
});

// Run with: npx jest
// Watch mode: npx jest --watch
// Coverage: npx jest --coverage

Use Cases

Pros & Cons

Pros

+Zero-config setup works immediately for most JavaScript/TypeScript projects without manual configuration files
+Complete testing solution bundles runner, assertions, mocking, coverage, and snapshots eliminating dependency management
+Intelligent watch mode and parallel execution with caching significantly reduces test iteration time
+Powerful module mocking system automatically mocks dependencies and provides fine-grained control over function behavior
+Snapshot testing catches UI regressions with minimal boilerplate, particularly effective for React components

Cons

−Abstraction layer can hide underlying behavior making debugging complex test failures difficult for newcomers
−Snapshot tests can create maintenance burden if overused or committed without proper review of changes
−Global namespace pollution with describe/it/expect makes some developers prefer explicit imports from testing libraries
−Module mocking magic sometimes conflicts with ES modules requiring experimental flags or workarounds
−Large test suites can still be slow despite optimizations, especially with heavy DOM manipulation or unoptimized beforeEach hooks