Tests with assert

node:assert/strict

A test is code that runs other code and fails loudly when reality differs from the plan. The node:assert/strict module ships with Node, so no install step stands between the reader and the first green run. Import it once at the top of the test file and call its functions directly:

import assert from "node:assert/strict"; function add(a: number, b: number): number { return a + b; } assert.equal(add(2, 3), 5); console.log("green");

When the values match, the file runs quietly and prints green. When they differ, equal throws an error that shows both sides, and Node exits before the last line ever runs.

deepStrictEqual

equal uses strict equality, so it fits numbers and strings but not objects. Two object literals are never the same reference, even when every field matches. deepStrictEqual walks both structures and compares every field instead, which is exactly what object tests need:

import assert from "node:assert/strict"; const point = { x: 1, y: 2 }; assert.deepStrictEqual(point, { x: 1, y: 2 });

This check passes because both sides hold the same shape and the same values. Change one field and the error prints the expected and actual objects, so the difference is visible at once.

Check throws

Some code must fail, and a test can demand that failure. assert.throws runs a function and passes only when that function throws. Add a pattern to check the message as well, so the wrong error cannot sneak through:

import assert from "node:assert/strict"; function fail(): never { throw new Error("boom"); } assert.throws(fail, /boom/);

When the function needs arguments, wrap the call in an arrow function so throws controls the moment of the call. A function that returns normally fails the test, which is the correct verdict for code that should have blown up.

One assert per test

One assert per test keeps failures obvious. A test with five checks stops at the first failure, hides the rest, and points at a crowd. Small focused checks with plain names read like a list of promises. For background on full test frameworks, read the mocha testing background article:

import assert from "node:assert/strict"; function double(n: number): number { return n * 2; } function check(name: string, fn: () => void): void { fn(); console.log("pass: " + name); } check("doubles two", () => { assert.equal(double(2), 4); }); check("doubles zero", () => { assert.equal(double(0), 0); });

Each check carries one assert and one name. A failure prints the name of the broken promise, and the fix location is never in doubt.

Next: Test layout

Article author: Arthur Isaev