Complete Guide to JavaScript Mocking Libraries

Rohit Rajpal

October 6, 2025

14MIN READ

Explore the popular JavaScript mocking libraries, core mocking approaches, and understand how to choose the right library for API testing.

JavaScript mocking libraries help developers test applications without relying on live servers or fully built components. They allow teams to simulate APIs, functions, or modules so that testing can be faster, more predictable, and safer. Mocking reduces dependency on external services and isolates the behavior of the code under test.

These libraries are essential because they enable developers to catch issues early, test edge cases, and maintain consistent test environments. They also support both frontend and backend development by allowing simulation of network responses, database calls, and internal functions.

This article explains the core approaches, popular JavaScript mocking libraries, and best practices for using them.

What Are JavaScript Mocking Libraries and Why Are They Essential?

JavaScript mocking libraries are tools that let developers simulate parts of an application for testing purposes. They can imitate APIs, functions, modules, or even entire services so that tests do not rely on real implementations. This helps developers focus on the code they are testing without external dependencies affecting results.

JavaScript mocking libraries make testing faster because there is no need to call live APIs or set up databases. Here are a few more reasons mocking libraries are widely used:

Isolation: They separate the component under test from external systems. This ensures that test failures are due to the code itself and not external factors.
Speed: Mocked responses are faster than real network or database calls, which reduces test execution time.
Edge Case Testing: They allow simulation of unusual or rare conditions that are hard to reproduce with real services.
Parallel Development: Frontend and backend teams can work simultaneously without waiting for the other side to be fully implemented.
Consistency: Mocked data ensures tests produce repeatable results across environments and over time.

Core Mocking Approaches in JavaScript

JavaScript applications can be tested using different mocking approaches depending on the scope and level of the code being tested. Each approach serves a specific purpose and can be chosen based on the type of testing, whether it is unit, integration, or end-to-end.

Below are the primary approaches used in JavaScript mocking:

Network-Level API Mocking: Simulates HTTP requests and responses so that frontend or backend code can be tested without a live server. This is useful for testing API behavior, response handling, and error scenarios.
Unit-Level Function and Module Mocking: Replaces specific functions or modules with mock implementations. This isolates the code being tested and avoids unintended side effects from dependent modules.
Client-Side Mocking with Service Workers: Uses service workers to intercept network requests in the browser and return custom responses. This allows testing of frontend behavior in a controlled environment without changing production APIs.
Server-Side Mocking in Node.js and Cloud Environments: Creates mock servers or middleware in backend environments to simulate APIs, databases, or external services. This is helpful for testing server logic, workflows, and integration points in isolation.

Popular JavaScript Mocking Libraries

There are several JavaScript libraries designed to simplify mocking for testing purposes. Each library focuses on different levels of mocking, from functions and modules to network requests and full backend simulations.

Below are the most widely used JavaScript mocking libraries and their key features:

1. Jest

Jest is a comprehensive JavaScript testing framework developed by Meta (formerly Facebook). It comes bundled with tools for testing, including a built-in test runner, assertion library, and mocking utilities. Jest is commonly used with React applications, but it’s flexible enough for any JavaScript project.

Key Features of Jest:

Built-in mocking: Jest provides built-in utilities for creating mocks, spies, and stubs without needing additional libraries.
Zero configuration: It works out of the box for most JavaScript projects.
Snapshot testing: Captures a snapshot of output and compares it over time, useful for UI testing.
Timer mocks: Allows control over functions like setTimeout or setInterval.

How Mocking Works in Jest:

Jest can automatically mock modules using jest.mock(). You can also create manual mocks or use jest.fn() to track function calls.

				
					const fetchData = require('./fetchData');
// Automatically mock the module
jest.mock('./fetchData');

test('should call fetchData once', () => {
  fetchData();
  expect(fetchData).toHaveBeenCalledTimes(1);
});

Ideal Use Case:

Jest is ideal for developers looking for a one-stop solution for testing, especially in React ecosystems. Its simple syntax and tight integration with modern JavaScript tools make it beginner-friendly.

2. Sinon

Sinon is a standalone library specifically designed for creating mocks, stubs, and spies. Unlike Jest, Sinon does not include a test runner or assertion library, which makes it more modular and suitable for use with other testing tools like Mocha, Chai, or Jasmine.

Key Features of Sinon:

Spies: Observe function calls, arguments, return values, and call count.
Stubs: Replace functions with controlled behavior.
Mocks: Pre-programmed expectations for function calls.
Fakes: Combine features of spies and stubs into a more powerful tool.

How Mocking Works in Sinon:

Sinon allows you to wrap existing functions to observe behavior or replace them entirely.

				
					const sinon = require('sinon');

function greet(callback) {
  callback('Hello');
}

const spy = sinon.spy();

greet(spy);

console.log(spy.called); // true
console.log(spy.calledWith('Hello')); // true

Ideal Use Case:

Sinon is a good choice when you want fine-grained control over mocks or are working in a non-Jest testing setup. It integrates well with various testing frameworks, making it a flexible option for larger or more customized testing environments.

3. Mock Service Worker (MSW)

Mock Service Worker (MSW) is a powerful API mocking library that intercepts actual HTTP requests at the network level using Service Workers. This allows you to mock REST or GraphQL APIs in both browser and Node.js environments without changing your application code.

Key Features of MSW:

Network-level interception: Mocks requests as they happen in the real environment.
Seamless integration: Works with front-end and back-end frameworks.
Browser and Node.js support: Allows testing in realistic conditions across platforms.
Declarative API mocking: Define request handlers that simulate real API behavior.
Non-intrusive: No need to rewrite the code to use mocks.

Ideal Use Case:

MSW is ideal for integration and end-to-end testing, especially when simulating real-world server interactions without needing a live API.

4. Nock

Nock is a Node.js library that mocks HTTP requests. It intercepts outgoing requests and allows developers to define custom responses, simulate errors, or delay responses. It ensures tests run consistently even when the external service is unavailable or unstable.

Key Features of Nock:

Intercepts HTTP requests: Mocks out requests made via Node’s http module.
Persistent mocks: Allows defining mocks that persist across tests.
Request validation: Ensure requests are made with specific query parameters or headers.
Response simulation: Define the exact structure and delay of responses.
Recording capabilities: Can record real HTTP interactions for future mocks.

Ideal Use Case:

Nock is best suited for backend testing in Node.js applications where external HTTP requests need to be stubbed or verified.

5. Mirage JS

Mirage JS simulates full backend APIs in the browser or Node.js. Developers can define models, routes, and responses to mimic real server behavior. This makes it possible to develop and test frontend applications without a live backend.

Key Features of Mirage JS:

In-browser mock server: Runs entirely in the browser, mimicking real APIs.
Database simulation: Provides an in-memory database for testing CRUD operations.
Route handling: Define RESTful and GraphQL endpoints easily.
Dynamic data generation: Supports factories and fixtures to simulate realistic data.
Development and testing: Useful in both development environments and automated tests.

Ideal Use Case:

Mirage JS is ideal for front-end developers needing a realistic API experience during development or testing without a backend.

6. Axios Mock Adapter

Axios Mock Adapter integrates with the Axios HTTP client to mock requests and responses. Developers can define expected responses for specific requests, simulate errors, and track call history. This makes it straightforward to test frontend applications that rely on Axios for network communication without requiring a live server.

Key Features of Axios Mock Adapter:

Direct integration with Axios: Wraps Axios instances to intercept and mock requests.
Flexible matching: Match requests by method, URL, or parameters.
Response control: Simulate status codes, response data, and delays.
Chainable API: Easy to set up multiple request mocks in a readable format.
Lightweight and focused: Minimal setup, ideal for quick unit tests.

Ideal Use Case:

Best suited for unit tests where Axios is used as the HTTP client, and a lightweight mocking solution is preferred.

7. ts-mockito

ts-mockito is a mocking library for TypeScript projects. It allows developers to create mocks for classes and interfaces while maintaining type safety. ts-mockito provides features like verifying method calls, defining return values, and simulating exceptions.

Key Features of ts-mockito:

Type-safe mocking: Ensures mocks align with TypeScript interfaces or classes.
Behavior verification: Supports checking call counts, order, and parameters.
Fluent API: Offers an expressive syntax for defining and verifying mocks.
Partial mocking: Mock only parts of an object or class.
Zero configuration: Easy to integrate into any TypeScript test setup.

Ideal Use Case:

Perfect for TypeScript developers who want type safety and clear syntax when mocking class-based logic.

8. JSON Server

JSON Server is not a traditional mocking library. It is a tool that lets developers create a complete fake REST API using a simple JSON file as the data source. With JSON Server, endpoints, routes, and responses can be automatically generated, allowing frontend and full-stack developers to work without waiting for a real backend.

Key Features of JSON Server:

Instant REST API: Generates a working REST API with zero coding.
CRUD support: Automatically handles GET, POST, PUT, PATCH, and DELETE.
Custom routes and middlewares: Extend and customize the behavior easily.
Static file support: Serve static files alongside the API.
Real-time prototyping: Ideal for front-end developers who need a quick backend.

Ideal Use Case:

Ideal for prototyping, mock data testing, or when developing front-end applications without a real API.

How to Choose the Right JavaScript Mocking Library

Selecting the right JavaScript mocking library requires understanding the project’s testing needs, environment, and workflow. Not every library fits every situation, so careful evaluation ensures tests are reliable and maintainable.

Here are key factors to consider when choosing a mocking library:

Testing Goals: Identify whether tests cover individual functions, modules, full API interactions, or end-to-end workflows. Some libraries work best for unit tests, while others handle network-level simulations more effectively.
Environment Compatibility: Make sure the library runs in the target environment, such as the browser, Node.js, or cloud. Some tools only work on the server side, while others cover both client and server.
Setup and Maintenance: Check how easy it is to configure and maintain mocks as the project grows. Libraries that require extensive setup can slow development.
Required Features: Look for specific functionality like simulating network errors, controlling response delays, tracking function calls, or supporting TypeScript. The library should cover the key scenarios you need to test.
Community and Support: Active communities and clear documentation help solve problems faster and guide complex use cases.
Performance: Consider whether the library affects test speed. Tools that intercept network requests or handle large datasets can slow down tests if not optimized.

Advanced Mocking Strategies for API-First Applications

API-first applications depend on backend services, and testing them requires more than basic mocks. Advanced strategies simulate realistic API behavior, handle edge cases, and integrate with complex workflows. These approaches help catch issues early and allow frontend and backend development to proceed in parallel.

Below are advanced strategies with explanations and examples:

1. Conditional Mocking

Conditional mocking returns different responses based on the request data. This helps test how the application handles various API scenarios.

				
					import { rest } from 'msw';
import { setupServer } from 'msw/node';
const server = setupServer(
  rest.get('/api/user', (req, res, ctx) => {
    const userId = req.url.searchParams.get('id');
    if (userId === '1') {
      return res(ctx.json({ id: 1, name: 'Alice' }));
    }
    return res(ctx.status(404), ctx.json({ error: 'User not found' }));
  })
);
server.listen();

Here, the response changes depending on the id parameter. This allows testing both success and failure scenarios without hitting a real API.

2. Dynamic Response Generation

Instead of static responses, generate data dynamically to simulate realistic behavior.

				
					import faker from 'faker';
import { rest } from 'msw';
rest.get('/api/products', (req, res, ctx) => {
  const count = parseInt(req.url.searchParams.get('count')) || 5;
  const products = Array.from({ length: count }, () => ({
    id: faker.datatype.uuid(),
    name: faker.commerce.productName(),
    price: faker.commerce.price(),
  }));
  return res(ctx.json(products));
});

This ensures that components are tested against a variety of inputs and prevents brittle tests that only work with fixed data.

3. Request Recording and Replay

Capture real API responses and replay them in tests. This is useful for regression testing or offline development.

				
					# Capture requests using a tool like Postman or WireMock
# Save responses as JSON files
import nock from 'nock';
import fs from 'fs';
const recorded = JSON.parse(fs.readFileSync('./recorded-response.json', 'utf-8'));
nock('https://api.example.com')
  .get('/orders')
  .reply(200, recorded);

Replaying recorded responses ensures tests run consistently even when external APIs are unavailable.

4. Error and Latency Simulation

Test how your application handles failures or slow networks by simulating errors and delays.

				
					rest.get('/api/data', (req, res, ctx) => {
  return res(
    ctx.delay(2000),        // simulate 2-second network delay
    ctx.status(500),        // simulate server error
    ctx.json({ error: 'Server error' })
  );
});

This is critical for ensuring that retry logic, error messages, and loading states work correctly.

5. Service Virtualization

For applications that depend on multiple microservices, create virtual services to simulate their behavior.

				
					import { createServer, Model } from 'miragejs';
createServer({
  models: {
    user: Model,
    order: Model,
  },
  routes() {
    this.get('/api/users', (schema) => schema.users.all());
    this.get('/api/orders', (schema) => schema.orders.all());
  }
});

This approach allows frontend teams to develop and test independently of backend readiness.

Using JavaScript Mocking Libraries in CI/CD Workflows

Integrating mocking libraries into CI/CD pipelines ensures tests run reliably without depending on live services. This helps catch errors early, supports automated regression testing, and allows teams to validate features continuously as code changes.

Below are key ways to use JavaScript mocking libraries in CI/CD workflows, with practical examples:

1. Isolate Tests from External Dependencies

Mocking network requests ensures that tests do not fail due to unavailable APIs or third-party services.

				
					import nock from 'nock';
beforeAll(() => {
  nock('https://api.example.com')
    .get('/users')
    .reply(200, [{ id: 1, name: 'Alice' }]);
});

test('fetches users correctly', async () => {
  const response = await fetch('https://api.example.com/users');
  const data = await response.json();
  expect(data[0].name).toBe('Alice');
});

This allows tests to run consistently in CI environments without relying on live endpoints.

2. Automate Mock Server Setup

Mock servers can be started as part of the CI pipeline to simulate backend behavior for integration tests.

				
					import { setupServer } from 'msw/node';
import { rest } from 'msw';

const server = setupServer(
  rest.get('/api/orders', (req, res, ctx) => res(ctx.json([{ id: 101, status: 'shipped' }])))
);

beforeAll(() => server.listen());
afterEach(() => server.resetHandlers());
afterAll(() => server.close());

This setup ensures that mocked endpoints are available for tests without manual configuration.

3. Use Recorded Responses for Regression Testing

Capture API responses during development and replay them in CI pipelines to validate changes.

				
					import nock from 'nock';
import fs from 'fs';
const recorded = JSON.parse(fs.readFileSync('./recorded-response.json', 'utf-8'));
nock('https://api.example.com')
  .get('/products')
  .reply(200, recorded);

Replaying recorded responses guarantees deterministic tests and prevents failures caused by changing external data.

4. Simulate Errors and Latency in CI

Include tests for failure scenarios and slow responses to ensure resilience under real-world conditions.

				
					rest.get('/api/data', (req, res, ctx) => {
  return res(
    ctx.delay(1500),
    ctx.status(500),
    ctx.json({ error: 'Server unavailable' })
  );
});

This allows the pipeline to validate error handling, retries, and fallback mechanisms automatically.

Why Use Requestly for JavaScript Mocking

Requestly by BrowserStack is a tool that allows developers to intercept, modify, and mock HTTP requests in both development and testing environments. It extends the capabilities of traditional mocking libraries by providing a user-friendly interface for managing request rules and simulating API behavior without changing application code.

1. Setting Up Requestly

Requestly can be used as a browser extension, a Node.js library, or integrated into CI pipelines.

Browser Setup: Install the Requestly extension and configure rules via the UI.
Node.js Setup: Install Requestly SDK using npm:

				
					npm install @requestly/node

Then import and initialize it in your test setup:

				
					import { Requestly } from '@requestly/node';
const requestly = new Requestly();

2. Creating Mock Rules

Requestly lets you define rules to intercept requests and return custom responses.

				
					// Mock a GET request to /api/users
requestly.setRule({
  type: 'mock',
  url: '/api/users',
  method: 'GET',
  response: JSON.stringify([{ id: 1, name: 'Alice' }])
});

This ensures that whenever /api/users is called, it returns a predictable response for testing.

3. Modifying Requests On the Fly

You can redirect requests or modify headers and query parameters without touching application code.

				
					// Redirect requests to a local mock server
requestly.setRule({
  type: 'redirect',
  source: '/api/products',
  destination: 'http://localhost:3000/mock-products'
});

This is useful for testing different environments or feature variations.

4. Simulating Errors and Delays

Requestly can introduce network latency, HTTP errors, or malformed responses to test resilience.

				
					requestly.setRule({
  type: 'mock',
  url: '/api/orders',
  method: 'GET',
  response: JSON.stringify({ error: 'Service unavailable' }),
  statusCode: 500,
  delay: 1500
});

This allows teams to validate error handling, retries, and loading states.

5. Integrating with Automated Tests

Requestly can be combined with testing frameworks like Jest, Cypress, or Playwright to run automated tests against mocked APIs.

				
					test('fetches users with Requestly mock', async () => {
  const response = await fetch('/api/users');
  const data = await response.json();
  expect(data[0].name).toBe('Alice');
});

The same mock rules used in development can be applied in CI pipelines, ensuring consistent results across environments.

Conclusion

JavaScript mocking libraries are essential tools for testing modern applications. They allow developers to simulate APIs, functions, modules, and entire services and ensure that tests run reliably without relying on live systems. Advanced strategies and CI/CD integration help test realistic scenarios and maintain consistent results.

Requestly extends these capabilities by intercepting and modifying requests without changing application code. It supports real-time API simulations, error injection, and environment-specific rules, making it easier to test workflows, validate edge cases, and maintain reliable tests across development and CI/CD environments.

Written by

Rohit Rajpal

Rohit Rajpal is a B2B Content Strategist at BrowserStack, helping SaaS brands build AI-first strategies that drive authority and revenue. He writes about content, strategy, and the future of search in the zero-click era.

Endpoint ft. Mahdi Taghizadeh: A CTO’s guide to product thinking, observability, and growth

Engineering leader Mahdi Taghizadeh shares insights on agile thinking, AI’s impact on development, and the underrated skills that define great engineers

Dinesh Thakur

October 7, 2025

A Beginner’s Guide to WCAG Testing Checklist

Discover the essential WCAG testing checklist for ensuring web accessibility, covering key areas like contrast, keyboard navigation, and mobile responsiveness.

Azma Banu

October 6, 2025

How to Use Maestro for Flutter Testing

Learn how to use Maestro for Flutter testing including setup steps, test strategies, component validation, performance checks, and accessibility compliance.

Rohit Rajpal

October 6, 2025

Complete Guide to JavaScript Mocking Libraries

What Are JavaScript Mocking Libraries and Why Are They Essential?

Core Mocking Approaches in JavaScript

Popular JavaScript Mocking Libraries

1. Jest

2. Sinon

3. Mock Service Worker (MSW)

4. Nock

5. Mirage JS

6. Axios Mock Adapter

7. ts-mockito

8. JSON Server

How to Choose the Right JavaScript Mocking Library

Advanced Mocking Strategies for API-First Applications

1. Conditional Mocking

2. Dynamic Response Generation

3. Request Recording and Replay

4. Error and Latency Simulation

5. Service Virtualization

Using JavaScript Mocking Libraries in CI/CD Workflows

1. Isolate Tests from External Dependencies

2. Automate Mock Server Setup

3. Use Recorded Responses for Regression Testing

4. Simulate Errors and Latency in CI

Why Use Requestly for JavaScript Mocking

1. Setting Up Requestly

2. Creating Mock Rules

3. Modifying Requests On the Fly

4. Simulating Errors and Delays

5. Integrating with Automated Tests

Conclusion

How to Guides

Case Studies