Automated Testing with Jest

Why write tests?

Right now, when you change your code, you probably check it by hand — open the page, click around, see if it still works. That is slow, easy to forget, and gets worse as your project grows. An automated test is a tiny program that checks your code for you: it runs your function with known inputs and confirms it gives the expected output. Run all your tests with one command, any time, and instantly know if something broke.

Jest is the most popular JavaScript testing tool. It runs in Node.js (not the browser), so the examples below are run from a terminal, not a live preview. The idea is simple: keep your real code in one file and your tests in a separate file that imports and checks it.

Your first test

Say you have a simple function to test. We put it in its own file and export it so the test can import it.

// math.js — the real code we want to test
function add(a, b) {
  return a + b;
}
module.exports = add;

Now the test file. Jest gives you two key words: test() describes one thing you are checking, and expect(...).toBe(...) states what you expect. Read it almost like English.

// math.test.js — the tests for math.js
const add = require("./math");

test("add returns the sum of two numbers", () => {
  expect(add(2, 3)).toBe(5);
});

test("add works with zero", () => {
  expect(add(0, 7)).toBe(7);
});

Reading the first test in plain words:

1. test("...", () => { ... }) declares one test with a description and a function holding the check.
2. expect(add(2, 3)) says "I am about to make a claim about the result of add(2, 3)".
3. .toBe(5) is the claim: that result should be 5. (.toBe is called a matcher — it compares actual vs expected.)
4. If add(2, 3) really returns 5, the test passes (green). If it returned something else, the test fails and Jest shows what it got vs what it expected.

You run the tests with one terminal command, npx jest:

# Run all *.test.js files
npx jest

What a failing test looks like

Failing tests are not bad news — they are the whole point: they catch a bug the moment it appears. If add had a mistake (say it multiplied instead), Jest would tell you exactly what went wrong:

Common matchers and the arrange-act-assert pattern

Beyond .toBe, Jest has many matchers for different checks:

Well-written tests follow a simple three-step shape called Arrange–Act–Assert (AAA): set up the data, run the thing, then check the result. Here it is applied to a filter-based function:

// returns only the passing scores (>= 40)
function passing(scores) {
  return scores.filter(s => s >= 40);
}
module.exports = passing;

// --- passing.test.js ---
const passing = require("./passing");

test("keeps only scores of 40 or more", () => {
  const scores = [55, 30, 40, 12];     // Arrange: set up input
  const result = passing(scores);      // Act: run the function
  expect(result).toEqual([55, 40]);    // Assert: check the output
});

The three comments map to AAA: we arrange the input array, act by calling passing(scores), and assert with .toEqual([55, 40]) that only the scores ≥ 40 came back. Note we use .toEqual (not .toBe) because we are comparing the contents of an array, not a single primitive value.