Testing Fundamentals in JavaScript

Automated tests are code that checks whether other code behaves correctly, run automatically instead of manually clicking through an application after every change. They catch regressions early, document expected behavior, and give developers confidence to refactor without fear of silently breaking something.

Modern JavaScript testing typically uses a test runner and assertion library like Jest or Vitest, both of which share a very similar API and philosophy.

Why it matters

A change that fixes one thing often breaks another, and without tests nobody notices until a user does. Automated tests check the behaviour of code in seconds, every time it changes. Teams expect code to come with tests, and writing testable functions makes the code itself simpler.

The Arrange-Act-Assert Pattern

Most well-written tests follow a simple three-part structure, regardless of the testing library used.

• Arrange — set up the inputs, initial state, or objects the test needs.
• Act — call the function or perform the action being tested.
• Assert — check that the actual result matches the expected result.

Writing a Simple Test

In Jest or Vitest, tests are grouped in describe() blocks and individual cases are written with test() (or its alias it()). Inside a test, expect(actualValue) returns a set of "matcher" methods like .toBe(), .toEqual(), or .toThrow() to assert the expected outcome. A test file is typically run automatically by the test runner whenever code changes, or as part of continuous integration before code is merged.

What Makes a Good Unit Test

A good unit test is isolated (it tests one function or unit of behavior, not the whole application), deterministic (it produces the same result every run, with no reliance on real time, network calls, or random values unless explicitly controlled), and readable (its name and structure make clear what behavior is being verified and why it might fail).

Examples

// sum.js
export function sum(a, b) {
  return a + b;
}

// sum.test.js
import { sum } from './sum.js';

describe('sum()', () => {
  test('adds two positive numbers correctly', () => {
    // Arrange
    const a = 2;
    const b = 3;

    // Act
    const result = sum(a, b);

    // Assert
    expect(result).toBe(5);
  });

  test('adds negative numbers correctly', () => {
    expect(sum(-2, -3)).toBe(-5);
  });
});

// Running "npx vitest" (or "npx jest") would report:

PASS  sum.test.js
  sum()
    ✓ adds two positive numbers correctly
    ✓ adds negative numbers correctly

Test Suites: 1 passed, 1 total
Tests:       2 passed, 2 total

// validateAge.js
export function validateAge(age) {
  if (age < 0) {
    throw new Error('Age cannot be negative');
  }
  return age;
}

// validateAge.test.js
import { validateAge } from './validateAge.js';

test('throws an error for a negative age', () => {
  expect(() => validateAge(-1)).toThrow('Age cannot be negative');
});

test('returns the age when valid', () => {
  expect(validateAge(28)).toBe(28);
});

PASS  validateAge.test.js
  ✓ throws an error for a negative age
  ✓ returns the age when valid

Tests: 2 passed, 2 total

Exercise

A tiny test runner is provided: test runs a function and prints PASS or FAIL, and expectEqual throws when two values differ. Write isEven, and two tests for it that follow the arrange, act, assert pattern.

Expected output: PASS isEven returns true for 4 then PASS isEven returns false for 7

function test(name, fn) {
  try {
    fn();
    console.log("PASS " + name);
  } catch (error) {
    console.log("FAIL " + name + ": " + error.message);
  }
}

function expectEqual(actual, expected) {
  if (actual !== expected) {
    throw new Error("expected " + expected + " but got " + actual);
  }
}

function isEven(number) {
  // TODO
}

// TODO: test "isEven returns true for 4"

// TODO: test "isEven returns false for 7"

function test(name, fn) {
  try {
    fn();
    console.log("PASS " + name);
  } catch (error) {
    console.log("FAIL " + name + ": " + error.message);
  }
}

function expectEqual(actual, expected) {
  if (actual !== expected) {
    throw new Error("expected " + expected + " but got " + actual);
  }
}

function isEven(number) {
  return number % 2 === 0;
}

test("isEven returns true for 4", () => {
  const input = 4;
  const result = isEven(input);
  expectEqual(result, true);
});

test("isEven returns false for 7", () => {
  const input = 7;
  const result = isEven(input);
  expectEqual(result, false);
});

Quick quiz

Interview questions