Writing code is only one part of software development. You also need to make sure that your code works correctly.

This is where testing becomes important.

As a JavaScript application grows, it becomes harder to check every feature manually. A small change can also break code that was already working.

Unit testing helps solve this problem.

It allows developers to test small parts of an application automatically. With the right tests in place, you can make changes with more confidence.

Jest is one of the most popular tools for JavaScript testing. It provides a simple way to write, run, and organize tests.

In this guide, you will learn the fundamentals of unit testing in JavaScript with Jest. You will also learn how to write your first test, use common matchers, test functions, handle errors, and follow useful testing practices.

Let’s get started.

---

What Is Unit Testing?

Unit testing is a type of software testing.

It focuses on small and individual parts of your code.

A unit can be:

• A function
• A method
• A class
• A module

The goal is simple.

You test one part of the code and check whether it produces the expected result.

For example, consider this function:

function add(a, b) {
  return a + b;
}

You can test whether the function returns the correct result.

expect(add(2, 3)).toBe(5);

If the result is 5, the test passes.

If the result is different, the test fails.

---

Why Is Unit Testing Important in JavaScript?

JavaScript applications can become complex very quickly.

A project may contain many functions, components, modules, and features.

When you change one part of the code, another part may stop working.

Unit testing helps you catch these problems early.

It can help you:

• Find bugs before users find them
• Check whether functions work correctly
• Prevent existing features from breaking
• Make code changes with confidence
• Reduce manual testing
• Improve code quality
• Make debugging easier

As a result, unit tests can save time during development.

---

What Is Jest?

Jest is a JavaScript testing framework.

It helps developers write and run automated tests.

Jest provides several useful features.

These include:

• A test runner
• Assertions
• Mock functions
• Code coverage
• Snapshot testing

Jest works well with plain JavaScript.

It is also commonly used with Node.js, React, and other JavaScript applications.

For beginners, Jest is a good choice because its syntax is easy to understand.

---

How to Install Jest

Before installing Jest, make sure you have Node.js installed.

Create a JavaScript project if you do not already have one.

Then install Jest as a development dependency.

npm install --save-dev jest

Next, open your package.json file.

Add a test script.

{
  "scripts": {
    "test": "jest"
  }
}

You can now run your tests with:

npm test

Jest will find and run your test files.

---

Your First Unit Test With Jest

Let’s start with a simple example.

Create a file named math.js.

function add(a, b) {
  return a + b;
}

module.exports = add;

Now create a test file named:

math.test.js

Add the following code.

const add = require("./math");

test("adds two numbers correctly", () => {
  expect(add(2, 3)).toBe(5);
});

Now run:

npm test

Jest will run the test.

The test checks whether:

add(2, 3)

returns:

5

If the result matches, the test passes.

---

Understanding the Basic Jest Test Structure

A simple Jest test has two main parts.

test("description", () => {
  expect(value).toBe(expectedValue);
});

Let’s understand them.

---

The test() Function

The test() function creates a test.

The first value is the test description.

The second value contains the test code.

For example:

test("returns the correct total", () => {
  // Test code
});

A clear description makes your tests easier to understand.

---

The expect() Function

The expect() function checks a value.

For example:

expect(10).toBe(10);

The value inside expect() is compared with the expected result.

The test passes if the values match.

---

What Are Jest Matchers?

Matchers help you check different types of values.

Jest provides many built-in matchers.

Here are some common ones.

---

toBe()

Use toBe() to check primitive values.

expect(5).toBe(5);

You can also use it with strings.

expect("Hello").toBe("Hello");

---

toEqual()

Use toEqual() to compare objects and arrays.

For example:

expect({
  name: "John",
  age: 25
}).toEqual({
  name: "John",
  age: 25
});

---

toBeTruthy()

Checks whether a value is truthy.

expect(true).toBeTruthy();

---

toBeFalsy()

Checks whether a value is falsy.

expect(false).toBeFalsy();

---

toContain()

Checks whether an array contains a value.

expect([1, 2, 3]).toContain(2);

It can also be used with strings.

expect("JavaScript").toContain("Script");

---

toBeNull()

Checks whether a value is null.

expect(null).toBeNull();

---

toBeDefined()

Checks whether a value is defined.

const name = "John";

expect(name).toBeDefined();

---

How to Test JavaScript Functions

Most unit tests focus on functions.

Consider this example.

function multiply(a, b) {
  return a * b;
}

module.exports = multiply;

Now write tests.

const multiply = require("./multiply");

test("multiplies two positive numbers", () => {
  expect(multiply(2, 4)).toBe(8);
});

test("multiplies a number by zero", () => {
  expect(multiply(10, 0)).toBe(0);
});

test("multiplies negative numbers", () => {
  expect(multiply(-2, -3)).toBe(6);
});

Each test checks a different situation.

This helps you find problems in different cases.

---

How to Group Tests With describe()

As your tests grow, grouping them becomes useful.

Jest provides the describe() function.

For example:

describe("Math functions", () => {
  test("adds numbers", () => {
    expect(2 + 3).toBe(5);
  });

  test("subtracts numbers", () => {
    expect(5 - 2).toBe(3);
  });
});

The describe() block groups related tests.

This makes the test output easier to read.

---

How to Test Strings With Jest

You can also test functions that return strings.

For example:

function getGreeting(name) {
  return `Hello, ${name}!`;
}

module.exports = getGreeting;

Now test the function.

const getGreeting = require("./greeting");

test("returns a greeting with the user name", () => {
  expect(getGreeting("John")).toBe(
    "Hello, John!"
  );
});

This test checks whether the returned string is correct.

---

How to Test Arrays With Jest

Let’s test a function that returns an array.

function getNumbers() {
  return [1, 2, 3];
}

module.exports = getNumbers;

Now write a test.

const getNumbers = require("./numbers");

test("returns the expected numbers", () => {
  expect(getNumbers()).toEqual([1, 2, 3]);
});

You can also check whether a specific value exists.

test("contains the number 2", () => {
  expect(getNumbers()).toContain(2);
});

---

How to Test Objects With Jest

Objects are common in JavaScript applications.

For example:

function getUser() {
  return {
    name: "John",
    age: 25
  };
}

module.exports = getUser;

You can test the object with toEqual().

const getUser = require("./user");

test("returns the correct user", () => {
  expect(getUser()).toEqual({
    name: "John",
    age: 25
  });
});

---

How to Test Errors With Jest

Good unit tests should also test error cases.

Consider this function.

function divide(a, b) {
  if (b === 0) {
    throw new Error("Cannot divide by zero");
  }

  return a / b;
}

module.exports = divide;

Now test the error.

const divide = require("./divide");

test("throws an error when dividing by zero", () => {
  expect(() => {
    divide(10, 0);
  }).toThrow("Cannot divide by zero");
});

This checks whether the function handles invalid input correctly.

---

How to Test Edge Cases

Testing normal input is important.

However, you should also test unusual situations.

These are called edge cases.

For example:

• Empty strings
• Empty arrays
• Zero
• Negative numbers
• Invalid input
• Missing values

Consider this function.

function isAdult(age) {
  return age >= 18;
}

You can test several cases.

test("returns true for an adult", () => {
  expect(isAdult(20)).toBe(true);
});

test("returns false for a minor", () => {
  expect(isAdult(17)).toBe(false);
});

test("returns true for age 18", () => {
  expect(isAdult(18)).toBe(true);
});

The last test checks the boundary value.

Boundary tests are often important because bugs can happen around limits.

---

How to Test Asynchronous Functions With Jest

JavaScript often works with asynchronous code.

For example, you may:

• Call an API
• Read a file
• Query a database
• Work with Promises

Jest can test asynchronous functions.

Consider this function.

function getUser() {
  return Promise.resolve({
    name: "John"
  });
}

You can test it with async and await.

test("returns the user", async () => {
  const user = await getUser();

  expect(user.name).toBe("John");
});

The test waits for the Promise to finish.

Then it checks the result.

---

How to Test Rejected Promises

You should also test failures.

For example:

function getUser() {
  return Promise.reject(
    new Error("User not found")
  );
}

You can test the rejected Promise.

test("throws an error when the user is not found", async () => {
  await expect(getUser()).rejects.toThrow(
    "User not found"
  );
});

This helps you test both successful and failed results.

---

What Are Jest Mock Functions?

Mock functions allow you to test code without using real dependencies.

For example, your code may depend on:

• An API
• A database
• Another function
• A third-party service

A mock function replaces the real dependency during a test.

You can create a mock function with:

const mockFunction = jest.fn();

You can then check whether it was called.

mockFunction();

expect(mockFunction).toHaveBeenCalled();

Mocks help you keep unit tests focused.

---

How to Test a Function Call With a Mock

Consider this function.

function saveUser(callback) {
  callback();
}

You can test whether the callback runs.

test("calls the callback", () => {
  const callback = jest.fn();

  saveUser(callback);

  expect(callback).toHaveBeenCalledTimes(1);
});

This checks that the function calls the callback exactly once.

---

What Is Test Coverage?

Test coverage shows how much of your code is tested.

Jest can generate a coverage report.

Run:

npm test -- --coverage

The report can show information about:

• Functions
• Lines
• Statements
• Branches

Higher coverage can be useful.

However, 100% coverage does not always mean your code is fully tested.

A few meaningful tests can be better than many weak tests.

Therefore, focus on important behavior instead of only increasing the coverage percentage.

---

Best Practices for Unit Testing With Jest

Writing tests is important.

However, writing good tests is even more important.

Here are some useful practices.

---

1. Keep Tests Small

Each test should check one behavior.

Avoid testing many things in one test.

Small tests are easier to understand.

They are also easier to fix.

---

2. Use Clear Test Names

Your test name should explain what you expect.

Avoid this:

test("test 1", () => {
});

Use this instead:

test("returns false when the age is below 18", () => {
});

Clear names make failed tests easier to understand.

---

3. Test Edge Cases

Do not only test normal input.

Also test unusual values.

For example:

• Empty input
• Zero
• Negative numbers
• Maximum values
• Invalid data

These tests can reveal hidden bugs.

---

4. Keep Tests Independent

One test should not depend on another.

Each test should work correctly by itself.

This makes your test suite more reliable.

---

5. Avoid Testing Implementation Details

Focus on what the code should do.

Avoid testing how every internal step works.

Tests should verify behavior.

This makes them easier to maintain.

---

Common Mistakes Beginners Make

Beginners often make a few mistakes when writing unit tests.

---

Testing Too Much in One Test

A single test should not check many unrelated behaviors.

If one test fails, it should be easy to understand why.

---

Only Testing the Happy Path

Do not only test correct input.

Also test invalid and unexpected input.

---

Using Unclear Test Names

A test called test 1 does not explain anything.

Always describe the expected behavior.

---

Depending on External Services

Unit tests should not depend on a real API or database when possible.

External services can make tests slow and unreliable.

Use mocks when appropriate.

---

Frequently Asked Questions

What Is Unit Testing in JavaScript?

Unit testing is the process of testing small parts of JavaScript code, such as functions and modules.

The goal is to check whether each part works correctly.

---

Is Jest Good for Unit Testing?

Yes.

Jest is widely used for unit testing in JavaScript.

It provides a test runner, assertions, mocks, and coverage reports.

---

What Should I Unit Test?

You should test important logic.

For example:

• Functions
• Modules
• Calculations
• Validation logic
• Error handling

Focus on code that contains important behavior.

---

Do I Need 100% Test Coverage?

Not necessarily.

High coverage does not always mean high-quality tests.

Focus on meaningful tests that check important behavior and edge cases.

---

Can Jest Test Asynchronous Code?

Yes.

Jest can test Promises and asynchronous functions.

You can use async/await or Jest’s async matchers.

---

Conclusion

Unit testing is an important part of JavaScript development.

It helps you check small parts of your code automatically.

Jest makes this process easier by providing a simple testing framework with useful features.

You can use Jest to test functions, arrays, objects, errors, asynchronous code, and more.

Start with simple tests.

Then test different inputs and edge cases.

As your application grows, good unit tests can help you find bugs earlier and make changes with more confidence.

The best way to learn unit testing is through practice.

Start testing the functions you write every day. Over time, writing tests will become a natural part of your JavaScript development process.