Academy — Sanjib Sikder

Why Tests Exist

A function that works today can break tomorrow — when requirements change, when a dependency updates, when a colleague refactors the code path it depends on. Tests are the only mechanism that makes that breakage visible immediately rather than in production at 2am.

But tests can lie. A test suite that always passes regardless of what the code does is worse than no tests — it gives false confidence. The discipline is in writing tests that can actually fail.

Start by building a minimal test harness from scratch so you understand exactly what testing frameworks do:

JavaScript

Ctrl+Enter to run

// A test runner in 20 lines
function describe(suite, fn) {
  console.log(`\n▶ ${suite}`);
  fn();
}

function it(name, fn) {
try {
fn();
console.log(` ✓ ${name}`);
} catch (err) {
console.log(` ✗ ${name}`);
console.log(` ${err.message}`);
}
}

function expect(actual) {
return {
toBe: expected => { if (actual !== expected) throw new Error(`Expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`); },
toEqual: expected => { if (JSON.stringify(actual) !== JSON.stringify(expected)) throw new Error(`Expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`); },
toThrow: () => { if (typeof actual !== "function") throw new Error("Expected a function"); try { actual(); throw new Error("Did not throw"); } catch(e) { if (e.message === "Did not throw") throw e; } },
toBeGreaterThan: n => { if (actual <= n) throw new Error(`Expected ${actual} > ${n}`); },
toBeTruthy: () => { if (!actual) throw new Error(`Expected truthy, got ${actual}`); },
toBeFalsy: () => { if (actual) throw new Error(`Expected falsy, got ${actual}`); },
};
}

// The code under test
function grade(marks) {
if (typeof marks !== "number") throw new TypeError("marks must be a number");
if (marks < 0 || marks > 100) throw new RangeError("marks must be 0–100");
if (marks >= 90) return "A+";
if (marks >= 75) return "A";
if (marks >= 50) return "B";
return "F";
}

// Tests
describe("grade()", () => {
it("returns A+ for 90 and above", () => expect(grade(90)).toBe("A+"));
it("returns A+ for 100", () => expect(grade(100)).toBe("A+"));
it("returns A for 75–89", () => expect(grade(75)).toBe("A"));
it("returns A for 89", () => expect(grade(89)).toBe("A"));
it("returns B for 50–74", () => expect(grade(50)).toBe("B"));
it("returns F for below 50", () => expect(grade(49)).toBe("F"));
it("throws on non-number", () => expect(() => grade("A")).toThrow());
it("throws on marks above 100", () => expect(() => grade(101)).toThrow());
it("throws on negative marks", () => expect(() => grade(-1)).toThrow());
});

// A test runner in 20 lines
function describe(suite, fn) {
  console.log(`\n▶ ${suite}`);
  fn();
}

function it(name, fn) {
try {
fn();
console.log(` ✓ ${name}`);
} catch (err) {
console.log(` ✗ ${name}`);
console.log(` ${err.message}`);
}
}

// The code under test
function grade(marks) {
if (typeof marks !== "number") throw new TypeError("marks must be a number");
if (marks < 0 || marks > 100) throw new RangeError("marks must be 0–100");
if (marks >= 90) return "A+";
if (marks >= 75) return "A";
if (marks >= 50) return "B";
return "F";
}

// Tests
describe("grade()", () => {
it("returns A+ for 90 and above", () => expect(grade(90)).toBe("A+"));
it("returns A+ for 100", () => expect(grade(100)).toBe("A+"));
it("returns A for 75–89", () => expect(grade(75)).toBe("A"));
it("returns A for 89", () => expect(grade(89)).toBe("A"));
it("returns B for 50–74", () => expect(grade(50)).toBe("B"));
it("returns F for below 50", () => expect(grade(49)).toBe("F"));
it("throws on non-number", () => expect(() => grade("A")).toThrow());
it("throws on marks above 100", () => expect(() => grade(101)).toThrow());
it("throws on negative marks", () => expect(() => grade(-1)).toThrow());
});

describe groups related tests. it runs one test and catches any thrown assertion error. expect returns an object of matchers — each throws if the condition is not met. Jest, Vitest, and Mocha are this pattern, scaled up.

Test Boundary Conditions, Not the Happy Path

Beginners write one test: the case they already know works. Real tests live at the boundaries — the exact values where behaviour changes:

JavaScript

Ctrl+Enter to run

function it(name, fn) {
  try { fn(); console.log(`✓ ${name}`); }
  catch (e) { console.log(`✗ ${name}: ${e.message}`); }
}
const expect = actual => ({
  toBe: expected => { if (actual !== expected) throw new Error(`got ${JSON.stringify(actual)}, want ${JSON.stringify(expected)}`); },
  toEqual: expected => { if (JSON.stringify(actual) !== JSON.stringify(expected)) throw new Error(`got ${JSON.stringify(actual)}, want ${JSON.stringify(expected)}`); },
});

// Boundary analysis: find every value where behaviour changes
// grade() changes at 90, 75, 50 — test each boundary from both sides
function grade(marks) {
if (marks >= 90) return "A+";
if (marks >= 75) return "A";
if (marks >= 50) return "B";
return "F";
}

// Boundaries: 49/50, 74/75, 89/90
it("49 → F (below B boundary)", () => expect(grade(49)).toBe("F"));
it("50 → B (at B boundary)", () => expect(grade(50)).toBe("B"));
it("74 → B (below A boundary)", () => expect(grade(74)).toBe("B"));
it("75 → A (at A boundary)", () => expect(grade(75)).toBe("A"));
it("89 → A (below A+ boundary)", () => expect(grade(89)).toBe("A"));
it("90 → A+ (at A+ boundary)", () => expect(grade(90)).toBe("A+"));
it("0 → F (minimum)", () => expect(grade(0)).toBe("F"));
it("100 → A+(maximum)", () => expect(grade(100)).toBe("A+"));

// Now deliberately introduce a bug and watch tests catch it
function gradeBuggy(marks) {
if (marks > 90) return "A+"; // bug: should be >= 90
if (marks > 75) return "A"; // bug: should be >= 75
if (marks > 50) return "B"; // bug: should be >= 50
return "F";
}

console.log("\n--- Same tests on buggy version ---");
it("49 → F", () => expect(gradeBuggy(49)).toBe("F"));
it("50 → B", () => expect(gradeBuggy(50)).toBe("B")); // fails
it("75 → A", () => expect(gradeBuggy(75)).toBe("A")); // fails
it("90 → A+", () => expect(gradeBuggy(90)).toBe("A+")); // fails

// Boundary analysis: find every value where behaviour changes
// grade() changes at 90, 75, 50 — test each boundary from both sides
function grade(marks) {
if (marks >= 90) return "A+";
if (marks >= 75) return "A";
if (marks >= 50) return "B";
return "F";
}

// Boundaries: 49/50, 74/75, 89/90
it("49 → F (below B boundary)", () => expect(grade(49)).toBe("F"));
it("50 → B (at B boundary)", () => expect(grade(50)).toBe("B"));
it("74 → B (below A boundary)", () => expect(grade(74)).toBe("B"));
it("75 → A (at A boundary)", () => expect(grade(75)).toBe("A"));
it("89 → A (below A+ boundary)", () => expect(grade(89)).toBe("A"));
it("90 → A+ (at A+ boundary)", () => expect(grade(90)).toBe("A+"));
it("0 → F (minimum)", () => expect(grade(0)).toBe("F"));
it("100 → A+(maximum)", () => expect(grade(100)).toBe("A+"));

// Now deliberately introduce a bug and watch tests catch it
function gradeBuggy(marks) {
if (marks > 90) return "A+"; // bug: should be >= 90
if (marks > 75) return "A"; // bug: should be >= 75
if (marks > 50) return "B"; // bug: should be >= 50
return "F";
}

console.log("\n--- Same tests on buggy version ---");
it("49 → F", () => expect(gradeBuggy(49)).toBe("F"));
it("50 → B", () => expect(gradeBuggy(50)).toBe("B")); // fails
it("75 → A", () => expect(gradeBuggy(75)).toBe("A")); // fails
it("90 → A+", () => expect(gradeBuggy(90)).toBe("A+")); // fails

The buggy version passes only the cases away from boundaries. The boundary tests catch it immediately. This is why boundary testing is non-negotiable — bugs almost always live at the edges.

Testing Pure Functions vs Side-Effect Functions

Pure functions are trivial to test. Functions with side effects require isolation:

JavaScript

Ctrl+Enter to run

function it(name, fn) {
  try { fn(); console.log(`✓ ${name}`); }
  catch (e) { console.log(`✗ ${name}: ${e.message}`); }
}
const expect = actual => ({
  toBe:    exp => { if (actual !== exp) throw new Error(`got ${JSON.stringify(actual)}, want ${JSON.stringify(exp)}`); },
  toEqual: exp => { if (JSON.stringify(actual) !== JSON.stringify(exp)) throw new Error(`got ${JSON.stringify(actual)}, want ${JSON.stringify(exp)}`); },
});

// Pure functions — test directly, no setup needed
function clamp(n, min, max) { return Math.max(min, Math.min(max, n)); }
function average(nums) { return nums.reduce((a, b) => a + b, 0) / nums.length; }
function normalise(student) { return { ...student, marks: clamp(student.marks, 0, 100) }; }

it("clamp: within range", () => expect(clamp(50, 0, 100)).toBe(50));
it("clamp: above max", () => expect(clamp(150, 0, 100)).toBe(100));
it("clamp: below min", () => expect(clamp(-5, 0, 100)).toBe(0));
it("average: [80,90,70]", () => expect(average([80, 90, 70])).toBe(80));
it("normalise: clamps marks",() => expect(normalise({ name: "X", marks: 120 })).toEqual({ name: "X", marks: 100 }));

// Functions with side effects — test by observing what changed
class StudentStore {
#students = [];
add(s) { this.#students.push(s); }
remove(id){ this.#students = this.#students.filter(s => s.id !== id); }
find(id) { return this.#students.find(s => s.id === id); }
get count(){ return this.#students.length; }
}

// Each test gets a fresh store — no shared state between tests
it("store: add increases count", () => {
const store = new StudentStore();
store.add({ id: 1, name: "Rahul" });
expect(store.count).toBe(1);
});

it("store: remove decreases count", () => {
const store = new StudentStore();
store.add({ id: 1, name: "Rahul" });
store.add({ id: 2, name: "Priya" });
store.remove(1);
expect(store.count).toBe(1);
});

it("store: find returns correct student", () => {
const store = new StudentStore();
store.add({ id: 1, name: "Rahul" });
expect(store.find(1).name).toBe("Rahul");
});

it("store: find returns undefined for missing", () => {
const store = new StudentStore();
expect(store.find(99)).toBe(undefined);
});

// Pure functions — test directly, no setup needed
function clamp(n, min, max) { return Math.max(min, Math.min(max, n)); }
function average(nums) { return nums.reduce((a, b) => a + b, 0) / nums.length; }
function normalise(student) { return { ...student, marks: clamp(student.marks, 0, 100) }; }

it("clamp: within range", () => expect(clamp(50, 0, 100)).toBe(50));
it("clamp: above max", () => expect(clamp(150, 0, 100)).toBe(100));
it("clamp: below min", () => expect(clamp(-5, 0, 100)).toBe(0));
it("average: [80,90,70]", () => expect(average([80, 90, 70])).toBe(80));
it("normalise: clamps marks",() => expect(normalise({ name: "X", marks: 120 })).toEqual({ name: "X", marks: 100 }));

// Functions with side effects — test by observing what changed
class StudentStore {
#students = [];
add(s) { this.#students.push(s); }
remove(id){ this.#students = this.#students.filter(s => s.id !== id); }
find(id) { return this.#students.find(s => s.id === id); }
get count(){ return this.#students.length; }
}

// Each test gets a fresh store — no shared state between tests
it("store: add increases count", () => {
const store = new StudentStore();
store.add({ id: 1, name: "Rahul" });
expect(store.count).toBe(1);
});

it("store: remove decreases count", () => {
const store = new StudentStore();
store.add({ id: 1, name: "Rahul" });
store.add({ id: 2, name: "Priya" });
store.remove(1);
expect(store.count).toBe(1);
});

it("store: find returns correct student", () => {
const store = new StudentStore();
store.add({ id: 1, name: "Rahul" });
expect(store.find(1).name).toBe("Rahul");
});

it("store: find returns undefined for missing", () => {
const store = new StudentStore();
expect(store.find(99)).toBe(undefined);
});

Each test creates its own fresh StudentStore. Tests that share state contaminate each other — a passing test at 9am can cause a different test to fail at 9pm simply because of run order. Isolation is not optional.

Mocking — Replacing the World With a Controlled Fake

A unit test should test one unit. If your code calls a database, sends an email, or hits an API, those dependencies must be replaced with fakes — otherwise you are testing the network, not your logic:

JavaScript

Ctrl+Enter to run

function it(name, fn) {
  try { fn(); console.log(`✓ ${name}`); }
  catch (e) { console.log(`✗ ${name}: ${e.message}`); }
}
const expect = actual => ({
  toBe:      exp => { if (actual !== exp) throw new Error(`got ${JSON.stringify(actual)}, want ${JSON.stringify(exp)}`); },
  toEqual:   exp => { if (JSON.stringify(actual) !== JSON.stringify(exp)) throw new Error(`got ${JSON.stringify(actual)}, want ${JSON.stringify(exp)}`); },
  toHaveBeenCalledWith: (...args) => {
    const calls = actual._calls ?? [];
    const match = calls.some(c => JSON.stringify(c) === JSON.stringify(args));
    if (!match) throw new Error(`Never called with ${JSON.stringify(args)}. Calls: ${JSON.stringify(calls)}`);
  },
});

// Mock factory — creates a tracked function
function mock(returnValue) {
const fn = (...args) => { fn._calls.push(args); return returnValue; };
fn._calls = [];
return fn;
}
function asyncMock(returnValue) {
const fn = (...args) => { fn._calls.push(args); return Promise.resolve(returnValue); };
fn._calls = [];
return fn;
}

// The unit under test — depends on external services
class EnrolmentService {
constructor(db, emailer, logger) {
this.db = db;
this.emailer = emailer;
this.logger = logger;
}

async enrol(studentId, courseId) {
const student = await this.db.findStudent(studentId);
if (!student) throw new Error(`Student ${studentId} not found`);

    await this.db.createEnrolment({ studentId, courseId });
    await this.emailer.send(student.email, `Enrolled in course ${courseId}`);
    this.logger.log(`Enrolled student ${studentId} in ${courseId}`);

    return { success: true, student, courseId };

}
}

// Tests — all dependencies are mocks
it("enrol: creates enrolment and sends email", async () => {
const db = { findStudent: asyncMock({ id: 1, name: "Rahul", email: "r@x.com" }), createEnrolment: asyncMock(true) };
const emailer = { send: asyncMock(true) };
const logger = { log: mock() };

const svc = new EnrolmentService(db, emailer, logger);
const result = await svc.enrol(1, "JS-101");

expect(result.success).toBe(true);
expect(emailer.send).toHaveBeenCalledWith("r@x.com", "Enrolled in course JS-101");
expect(logger.log).toHaveBeenCalledWith("Enrolled student 1 in JS-101");
});

it("enrol: throws when student not found", async () => {
const db = { findStudent: asyncMock(null), createEnrolment: asyncMock(true) };
const emailer = { send: asyncMock(true) };
const logger = { log: mock() };

const svc = new EnrolmentService(db, emailer, logger);
try {
await svc.enrol(99, "JS-101");
throw new Error("Should have thrown");
} catch (e) {
expect(e.message).toBe("Student 99 not found");
}
});

// Mock factory — creates a tracked function
function mock(returnValue) {
const fn = (...args) => { fn._calls.push(args); return returnValue; };
fn._calls = [];
return fn;
}
function asyncMock(returnValue) {
const fn = (...args) => { fn._calls.push(args); return Promise.resolve(returnValue); };
fn._calls = [];
return fn;
}

// The unit under test — depends on external services
class EnrolmentService {
constructor(db, emailer, logger) {
this.db = db;
this.emailer = emailer;
this.logger = logger;
}

async enrol(studentId, courseId) {
const student = await this.db.findStudent(studentId);
if (!student) throw new Error(`Student ${studentId} not found`);

await this.db.createEnrolment({ studentId, courseId });
    await this.emailer.send(student.email, `Enrolled in course ${courseId}`);
    this.logger.log(`Enrolled student ${studentId} in ${courseId}`);

return { success: true, student, courseId };

}
}

// Tests — all dependencies are mocks
it("enrol: creates enrolment and sends email", async () => {
const db = { findStudent: asyncMock({ id: 1, name: "Rahul", email: "r@x.com" }), createEnrolment: asyncMock(true) };
const emailer = { send: asyncMock(true) };
const logger = { log: mock() };

const svc = new EnrolmentService(db, emailer, logger);
const result = await svc.enrol(1, "JS-101");

expect(result.success).toBe(true);
expect(emailer.send).toHaveBeenCalledWith("r@x.com", "Enrolled in course JS-101");
expect(logger.log).toHaveBeenCalledWith("Enrolled student 1 in JS-101");
});

it("enrol: throws when student not found", async () => {
const db = { findStudent: asyncMock(null), createEnrolment: asyncMock(true) };
const emailer = { send: asyncMock(true) };
const logger = { log: mock() };

const svc = new EnrolmentService(db, emailer, logger);
try {
await svc.enrol(99, "JS-101");
throw new Error("Should have thrown");
} catch (e) {
expect(e.message).toBe("Student 99 not found");
}
});

The EnrolmentService never touches a real database or sends a real email. The mocks record what they were called with — so tests can verify not just that the function returned the right value, but that it interacted with its dependencies correctly.

Property-Based Testing — Let the Computer Find the Bugs

Unit tests prove that specific inputs produce specific outputs. Property-based testing generates hundreds of random inputs and checks that invariant properties hold for all of them. It finds edge cases you would never think to write manually:

JavaScript

Ctrl+Enter to run

// A minimal property-based test engine
function forAll(label, generator, property, runs = 200) {
  const failures = [];
  for (let i = 0; i < runs; i++) {
    const value = generator();
    try { property(value); }
    catch (e) { failures.push({ value, error: e.message }); if (failures.length >= 3) break; }
  }
  if (failures.length === 0) {
    console.log(`✓ ${label} (passed ${runs} cases)`);
  } else {
    console.log(`✗ ${label}`);
    failures.forEach(({ value, error }) =>
      console.log(`    counterexample: ${JSON.stringify(value)} → ${error}`));
  }
}

// Generators
const int = (lo, hi) => () => Math.floor(Math.random() * (hi - lo + 1)) + lo;
const array = (gen, min = 1, max = 20) => () => Array.from({ length: int(min, max)() }, gen);
const string = () => () => Math.random().toString(36).slice(2, 2 + int(1, 10)());

// The code under test
function clamp(n, lo, hi) { return Math.max(lo, Math.min(hi, n)); }
function sortedUnique(arr) { return [...new Set(arr)].sort((a, b) => a - b); }
function average(arr) { return arr.reduce((a, b) => a + b, 0) / arr.length; }

// Properties — universal truths that must hold for ANY valid input
forAll(
"clamp: result is always within [lo, hi]",
int(-1000, 1000),
n => {
const result = clamp(n, 0, 100);
if (result < 0 || result > 100) throw new Error(`${result} out of range`);
}
);

forAll(
"sortedUnique: output is sorted",
array(int(0, 100)),
arr => {
const result = sortedUnique(arr);
for (let i = 1; i < result.length; i++) {
if (result[i] < result[i - 1]) throw new Error(`Not sorted at index ${i}`);
}
}
);

forAll(
"sortedUnique: output has no duplicates",
array(int(0, 10)), // small range — high chance of duplicates
arr => {
const result = sortedUnique(arr);
const set = new Set(result);
if (set.size !== result.length) throw new Error("Contains duplicates");
}
);

forAll(
"average: result is within [min, max] of input",
array(int(0, 100)),
arr => {
const avg = average(arr);
const min = Math.min(...arr);
const max = Math.max(...arr);
if (avg < min || avg > max) throw new Error(`${avg} outside [${min}, ${max}]`);
}
);

// Deliberately buggy function — property testing will find it
function buggySort(arr) {
return arr.sort(); // bug: default sort is lexicographic, not numeric
}

forAll(
"buggySort: should be numerically sorted (will fail)",
array(int(0, 100)),
arr => {
const result = buggySort([...arr]);
for (let i = 1; i < result.length; i++) {
if (result[i] < result[i - 1])
throw new Error(`${result[i-1]}, ${result[i]}: not numerically sorted`);
}
}
);

// A minimal property-based test engine
function forAll(label, generator, property, runs = 200) {
  const failures = [];
  for (let i = 0; i < runs; i++) {
    const value = generator();
    try { property(value); }
    catch (e) { failures.push({ value, error: e.message }); if (failures.length >= 3) break; }
  }
  if (failures.length === 0) {
    console.log(`✓ ${label} (passed ${runs} cases)`);
  } else {
    console.log(`✗ ${label}`);
    failures.forEach(({ value, error }) =>
      console.log(`    counterexample: ${JSON.stringify(value)} → ${error}`));
  }
}

// Generators
const int = (lo, hi) => () => Math.floor(Math.random() * (hi - lo + 1)) + lo;
const array = (gen, min = 1, max = 20) => () => Array.from({ length: int(min, max)() }, gen);
const string = () => () => Math.random().toString(36).slice(2, 2 + int(1, 10)());

// The code under test
function clamp(n, lo, hi) { return Math.max(lo, Math.min(hi, n)); }
function sortedUnique(arr) { return [...new Set(arr)].sort((a, b) => a - b); }
function average(arr) { return arr.reduce((a, b) => a + b, 0) / arr.length; }

// Properties — universal truths that must hold for ANY valid input
forAll(
"clamp: result is always within [lo, hi]",
int(-1000, 1000),
n => {
const result = clamp(n, 0, 100);
if (result < 0 || result > 100) throw new Error(`${result} out of range`);
}
);

forAll(
"sortedUnique: output is sorted",
array(int(0, 100)),
arr => {
const result = sortedUnique(arr);
for (let i = 1; i < result.length; i++) {
if (result[i] < result[i - 1]) throw new Error(`Not sorted at index ${i}`);
}
}
);

forAll(
"sortedUnique: output has no duplicates",
array(int(0, 10)), // small range — high chance of duplicates
arr => {
const result = sortedUnique(arr);
const set = new Set(result);
if (set.size !== result.length) throw new Error("Contains duplicates");
}
);

forAll(
"average: result is within [min, max] of input",
array(int(0, 100)),
arr => {
const avg = average(arr);
const min = Math.min(...arr);
const max = Math.max(...arr);
if (avg < min || avg > max) throw new Error(`${avg} outside [${min}, ${max}]`);
}
);

// Deliberately buggy function — property testing will find it
function buggySort(arr) {
return arr.sort(); // bug: default sort is lexicographic, not numeric
}

forAll(
"buggySort: should be numerically sorted (will fail)",
array(int(0, 100)),
arr => {
const result = buggySort([...arr]);
for (let i = 1; i < result.length; i++) {
if (result[i] < result[i - 1])
throw new Error(`${result[i-1]}, ${result[i]}: not numerically sorted`);
}
}
);

The last property test finds the lexicographic sort bug in seconds — something you might not discover with hand-written tests unless you specifically thought to try [10, 9, 2].

Test-Driven Development — Write the Test First

TDD inverts the workflow: write a failing test, write the minimum code to make it pass, refactor. The test defines what the code should do before the code exists:

JavaScript

Ctrl+Enter to run

function it(name, fn) {
  try { fn(); console.log(`✓ ${name}`); }
  catch (e) { console.log(`✗ ${name}: ${e.message}`); }
}
const expect = actual => ({
  toBe:    exp => { if (actual !== exp) throw new Error(`got ${JSON.stringify(actual)}, want ${JSON.stringify(exp)}`); },
  toEqual: exp => { if (JSON.stringify(actual) !== JSON.stringify(exp)) throw new Error(`got ${JSON.stringify(actual)}, want ${JSON.stringify(exp)}`); },
  toThrow: ()  => { if (typeof actual !== "function") throw new Error("Need a function"); try { actual(); throw new Error("Did not throw"); } catch(e) { if (e.message === "Did not throw") throw e; } },
});

// Step 1: write ALL tests first — they all fail (no implementation yet)
// Step 2: implement just enough to pass one at a time
// Step 3: refactor once green

// The spec: a StudentRoster class
// - add(student): adds a student, throws if duplicate id
// - remove(id): removes by id
// - find(id): returns student or undefined
// - topN(n): returns top N students by marks, descending
// - average(): returns mean marks across all students

class StudentRoster {
#students = new Map();

add(student) {
if (this.#students.has(student.id))
throw new Error(`Duplicate id: ${student.id}`);
this.#students.set(student.id, student);
return this;
}

remove(id) { this.#students.delete(id); return this; }
find(id) { return this.#students.get(id); }

topN(n) {
return [...this.#students.values()]
.sort((a, b) => b.marks - a.marks)
.slice(0, n);
}

average() {
if (this.#students.size === 0) return 0;
const total = [...this.#students.values()].reduce((s, st) => s + st.marks, 0);
return total / this.#students.size;
}

get size() { return this.#students.size; }
}

// The tests — written as a specification
const r = () => new StudentRoster(); // fresh instance each time
const s1 = { id: 1, name: "Rahul", marks: 82 };
const s2 = { id: 2, name: "Priya", marks: 91 };
const s3 = { id: 3, name: "Arjun", marks: 49 };

it("add: increases size", () => { const roster = r(); roster.add(s1); expect(roster.size).toBe(1); });
it("add: throws on duplicate id", () => { const roster = r(); roster.add(s1); expect(() => roster.add(s1)).toThrow(); });
it("remove: decreases size", () => { const roster = r(); roster.add(s1).add(s2).remove(1); expect(roster.size).toBe(1); });
it("find: returns correct student", () => { const roster = r(); roster.add(s1); expect(roster.find(1)).toEqual(s1); });
it("find: returns undefined if absent", () => { expect(r().find(99)).toBe(undefined); });
it("topN: returns top 2 by marks", () => { const roster = r(); roster.add(s1).add(s2).add(s3); expect(roster.topN(2)).toEqual([s2, s1]); });
it("topN: returns all if n > size", () => { const roster = r(); roster.add(s1); expect(roster.topN(10).length).toBe(1); });
it("average: correct mean", () => { const roster = r(); roster.add(s1).add(s2).add(s3); expect(roster.average()).toBe((82+91+49)/3); });
it("average: 0 for empty roster", () => { expect(r().average()).toBe(0); });

// Step 1: write ALL tests first — they all fail (no implementation yet)
// Step 2: implement just enough to pass one at a time
// Step 3: refactor once green

// The spec: a StudentRoster class
// - add(student): adds a student, throws if duplicate id
// - remove(id): removes by id
// - find(id): returns student or undefined
// - topN(n): returns top N students by marks, descending
// - average(): returns mean marks across all students

class StudentRoster {
#students = new Map();

add(student) {
if (this.#students.has(student.id))
throw new Error(`Duplicate id: ${student.id}`);
this.#students.set(student.id, student);
return this;
}

remove(id) { this.#students.delete(id); return this; }
find(id) { return this.#students.get(id); }

topN(n) {
return [...this.#students.values()]
.sort((a, b) => b.marks - a.marks)
.slice(0, n);
}

average() {
if (this.#students.size === 0) return 0;
const total = [...this.#students.values()].reduce((s, st) => s + st.marks, 0);
return total / this.#students.size;
}

get size() { return this.#students.size; }
}

// The tests — written as a specification
const r = () => new StudentRoster(); // fresh instance each time
const s1 = { id: 1, name: "Rahul", marks: 82 };
const s2 = { id: 2, name: "Priya", marks: 91 };
const s3 = { id: 3, name: "Arjun", marks: 49 };

it("add: increases size", () => { const roster = r(); roster.add(s1); expect(roster.size).toBe(1); });
it("add: throws on duplicate id", () => { const roster = r(); roster.add(s1); expect(() => roster.add(s1)).toThrow(); });
it("remove: decreases size", () => { const roster = r(); roster.add(s1).add(s2).remove(1); expect(roster.size).toBe(1); });
it("find: returns correct student", () => { const roster = r(); roster.add(s1); expect(roster.find(1)).toEqual(s1); });
it("find: returns undefined if absent", () => { expect(r().find(99)).toBe(undefined); });
it("topN: returns top 2 by marks", () => { const roster = r(); roster.add(s1).add(s2).add(s3); expect(roster.topN(2)).toEqual([s2, s1]); });
it("topN: returns all if n > size", () => { const roster = r(); roster.add(s1); expect(roster.topN(10).length).toBe(1); });
it("average: correct mean", () => { const roster = r(); roster.add(s1).add(s2).add(s3); expect(roster.average()).toBe((82+91+49)/3); });
it("average: 0 for empty roster", () => { expect(r().average()).toBe(0); });

Writing tests first forces you to think about the interface before the implementation. The tests are the specification — they answer "what should this do?" before you answer "how should this work?"

Code Coverage — What It Means and What It Doesn't

Coverage measures which lines of your code were executed during tests. 100% coverage does not mean the code is correct — it means every line ran at least once. A test can execute a line without checking its output:

JavaScript

Ctrl+Enter to run

function it(name, fn) {
  try { fn(); console.log(`✓ ${name}`); }
  catch (e) { console.log(`✗ ${name}: ${e.message}`); }
}
const expect = actual => ({
  toBe: exp => { if (actual !== exp) throw new Error(`got ${JSON.stringify(actual)}, want ${JSON.stringify(exp)}`); },
});

function divide(a, b) {
if (b === 0) return Infinity; // ← this line could be tested without verifying the value
return a / b;
}

// High coverage — all lines run — but the assertion is wrong
it("divide: runs all branches (bad assertion)", () => {
divide(10, 2); // runs the return branch
divide(10, 0); // runs the Infinity branch
expect(1).toBe(1); // always passes — not testing divide at all
});

// Meaningful coverage — lines run AND results verified
it("divide: 10/2 = 5", () => expect(divide(10, 2)).toBe(5));
it("divide: by zero returns ∞", () => expect(divide(10, 0)).toBe(Infinity));
it("divide: negative/positive", () => expect(divide(-6, 3)).toBe(-2));

// Coverage target advice:
// - Aim for high coverage as a floor (80%+), not a ceiling
// - 100% coverage with weak assertions is worse than 70% with strong ones
// - Uncovered code is definitely untested; covered code is not necessarily correct
console.log("\nCoverage is a floor, not a ceiling.");
console.log("The question is not 'did this line run?' but 'did this line do the right thing?'");

function divide(a, b) {
if (b === 0) return Infinity; // ← this line could be tested without verifying the value
return a / b;
}

// High coverage — all lines run — but the assertion is wrong
it("divide: runs all branches (bad assertion)", () => {
divide(10, 2); // runs the return branch
divide(10, 0); // runs the Infinity branch
expect(1).toBe(1); // always passes — not testing divide at all
});

// Meaningful coverage — lines run AND results verified
it("divide: 10/2 = 5", () => expect(divide(10, 2)).toBe(5));
it("divide: by zero returns ∞", () => expect(divide(10, 0)).toBe(Infinity));
it("divide: negative/positive", () => expect(divide(-6, 3)).toBe(-2));

// Coverage target advice:
// - Aim for high coverage as a floor (80%+), not a ceiling
// - 100% coverage with weak assertions is worse than 70% with strong ones
// - Uncovered code is definitely untested; covered code is not necessarily correct
console.log("\nCoverage is a floor, not a ceiling.");
console.log("The question is not 'did this line run?' but 'did this line do the right thing?'");

What You Have Learned

Testing is not a phase at the end of development. It is the mechanism that makes confident change possible — the difference between "I hope this refactor didn't break anything" and "I know it didn't."

The key ideas:

A test harness is describe + it + expect — the frameworks just add better output and tooling
Test boundary conditions — bugs live at the edges, not in the middle of the happy path
Each test needs a fresh instance of stateful objects — shared state between tests causes order-dependent failures
Mocking replaces real dependencies with tracked fakes — tests verify logic, not the network or database
Property-based testing generates hundreds of random inputs and checks invariant properties — finds bugs you would never think to write tests for
TDD: test first, implement second, refactor third — tests become the specification
Coverage is a floor, not a ceiling — 100% coverage with weak assertions is false confidence; strong assertions with 80% coverage is more valuable

In the next lesson: TypeScript Essentials — static types, interfaces, generics, and the type system that catches entire categories of bugs before the code ever runs. Everything you have learned in JavaScript translates directly; TypeScript adds a layer of verification on top.

Testing JavaScript

Why Tests Exist

Test Boundary Conditions, Not the Happy Path

Testing Pure Functions vs Side-Effect Functions

Mocking — Replacing the World With a Controlled Fake

Property-Based Testing — Let the Computer Find the Bugs

Test-Driven Development — Write the Test First

Code Coverage — What It Means and What It Doesn't

What You Have Learned