Node.js Testing Deep Dive — Complete Guide to Jest, Mocha, AVA, and Playwright

In this tutorial, you will learn about Node.js Testing Deep Dive. We cover key concepts, practical examples, and best practices to help you master this topic.

Node.js testing deep dive covers four major test frameworks: Jest (all-in-one), Mocha (flexible), AVA (concurrent), and Playwright (E2E browser), with patterns for each testing level.

What You'll Learn

By the end of this tutorial, you'll configure tests with Jest, Mocha, AVA, and Playwright, write unit, integration, and E2E tests, mock dependencies, and integrate testing into CI.

Why Testing Matters

Automated tests catch regressions, document expected behavior, and enable Refactoring with confidence. Without tests, every deployment risks breaking existing functionality.

Real-World Use

A CI pipeline runs unit tests (100ms), integration tests (2s), and E2E tests (30s) on every PR. Coverage reports gate merges below 80% threshold.

Testing Path

flowchart LR
  A[Dependency Mgmt] --> B[Testing Deep]
  B --> C[Debugging]
  C --> D[CI/CD]
  D --> E[Deployment]
  B --> F{You Are Here}
  style F fill:#f90,color:#fff

Jest Testing

Jest provides an all-in-one solution with built-in matchers, mocking, and coverage.

// sum.js
function sum(a, b) { return a + b; }
module.exports = sum;

// sum.test.js
const sum = require("./sum");
test("adds 1 + 2 to equal 3", () => {
  expect(sum(1, 2)).toBe(3);
});
test("handles negative numbers", () => {
  expect(sum(-1, -2)).toBe(-3);
});
test("handles zero", () => {
  expect(sum(0, 0)).toBe(0);
});

Mocha and Chai

Mocha is flexible and pairs with assertion libraries like Chai.

const { expect } = require("chai");
const { describe, it } = require("mocha");
const calculator = require("./calculator");
describe("Calculator", () => {
  it("should add two numbers", () => {
    expect(calculator.add(2, 3)).to.equal(5);
  });
  it("should subtract two numbers", () => {
    expect(calculator.subtract(5, 3)).to.equal(2);
  });
  it("should handle decimal numbers", () => {
    expect(calculator.add(0.1, 0.2)).to.be.closeTo(0.3, 0.0001);
  });
});

AVA for Concurrent Tests

AVA runs tests concurrently by default, making it faster for independent test suites.

// calculator.test.js
import test from "ava";
import calculator from "./calculator.js";
test("adds numbers", (t) => {
  t.is(calculator.add(2, 3), 5);
});
test("subtracts numbers", (t) => {
  t.is(calculator.subtract(5, 3), 2);
});
test.serial("only one at a time", (t) => {
  // use .serial for tests that cannot run concurrently
  t.pass();
});

Mocking in Jest

Mock external dependencies to isolate the code under test.

const axios = require("axios");
jest.mock("axios");
const userService = require("./userService");
test("fetches user by ID", async () => {
  const mockUser = { id: 1, name: "Alice" };
  axios.get.mockResolvedValue({ data: mockUser });
  const user = await userService.getUser(1);
  expect(user.name).toBe("Alice");
  expect(axios.get).toHaveBeenCalledWith("/users/1");
});

Playwright for E2e Testing

Playwright tests browser interactions across Chromium, Firefox, and WebKit.

const { test, expect } = require("@playwright/test");
test("user can login", async ({ page }) => {
  await page.goto("https://example.com/login");
  await page.fill("#email", "user@example.com");
  await page.fill("#password", "password123");
  await page.click("button[type=submit]");
  await expect(page.locator("h1")).toHaveText("Dashboard");
});

Common Mistakes

1. Testing Implementation Details

Test behavior, not internal implementation. Mocking internals makes tests brittle.

2. Flaky Tests From Shared State

Tests that share database state or global variables fail unpredictably. Use isolated fixtures.

3. Over-Mocking

Mocking everything hides integration issues. Use real objects for stable dependencies.

4. Slow Tests Without CI Optimization

Slow tests discourage running them. Use test splitting and parallel execution in CI.

5. No Coverage Thresholds

Without coverage gates, coverage drifts down. Set minimum thresholds in CI.

Practice Questions

1. What is the difference between unit tests and integration tests?

Unit tests isolate single functions. Integration tests verify interactions between components.

2. What is mocking and when should you use it?

Mocking replaces real dependencies with controlled substitutes. Use for external services, databases, and file systems.

3. How does AVA differ from Jest?

AVA runs tests concurrently by default. Jest runs them sequentially. AVA is faster for independent tests.

4. What is an E2E test?

End-to-end tests verify the full application stack from user interface to database.

5. Challenge: Create a test suite for an API client with mocking.

// apiClient.js
class APIClient {
  async getUser(id) { const res = await fetch(`/api/users/${id}`); return res.json(); }
}
// test
jest.mock("node-fetch");
const fetch = require("node-fetch");
test("getUser returns user data", async () => {
  fetch.mockResolvedValue({ json: () => ({ id: 1, name: "Alice" }) });
  const client = new APIClient();
  const user = await client.getUser(1);
  expect(user.name).toBe("Alice");
});

FAQ

Mini Project: Testing Setup Script

Build a script that generates a test file with boilerplate for any function.

const fs = require("node:fs");
const path = require("node:path");
function generateTest(functionName, params) {
  const testContent = `
const ${functionName} = require("./${functionName}");
describe("${functionName}", () => {
  it("should handle basic case", () => {
    const result = ${functionName}(${params.map(() => null).join(", ")});
    expect(result).toBeDefined();
  });
});
`;
  fs.writeFileSync(`${functionName}.test.js`, testContent.trim());
  console.log(`Created ${functionName}.test.js`);
}
generateTest("calculateTotal", ["items"]);

What's Next

Node.js Debugging Node.js CI/CD Node.js Security