Why you might not need Jest anymore

A good argument for using some new technology is always

it's native

it's included in the standard library

Using code which is officially supported by the language rarely has downsides. It's pretty much guaranteed to not become outdated, it's updated when you update your language version and code from the std-library is never going to become a stale project because of open source drama (looking at you 🦀-foundation).

import test from 'node:test';

The node test runner is now stable since node v20.0.0. Usually I just reach for jest to run my tests but seeing how jest has had such a big problem with es-modules I reached out to the native node test runner to give it a shot. Fortunately the node:test api has been heavily inspired by jest's api making a transition quite easy. This also makes sense since jest has been the industry standard for testing in node for a while now.

Creating a test

Creating a test in jest and node looks eerily similar:

Jest1describe("maths", () => {
2  it("should sum", () => {
3    expect(1 + 2).toEqual(3);
4  });
5});

Node1import { describe, it } from "node:test";
2import assert from "node:assert";
3
4describe("maths", () => {
5  it("should sum", () => {
6    assert.strictEqual(1 + 2, 3);
7  });
8});

The only major difference is the node test runner requires you to import the functions called. Which I prefer since it removes the "magic" part of creating the tests while still keeping them declarative.

Testing async functions

Async functions are first class citizens in the node:test module:

Jest1describe("maths", () => {
2  it("should sum", async () => {
3    expect(1 + 2).toEqual(3);
4  });
5});

Node1import { describe, it } from "node:test";
2import assert from "node:assert";
3
4describe("maths", () => {
5  it("should sum", async () => {
6    assert.strictEqual(1 + 2, 3);
7  });
8});

The api works the same, any async function which returns a rejected promise in the it function is a failed test. That means this is also a failed test:

Node1import { describe, it } from "node:test";
2import assert from "node:assert";
3
4describe("maths", () => {
5  it("should sum", () => {
6    return Promise.reject();
7  });
8});

Type assertions

The node assert package also has a neat feature in that it returns the asserts value return type which means you will get first class typescript support in your tests.

In a typical jest test this would not narrow the type to a string even though we clearly have asserted that the type is supposed to be a string

Jest1describe("test", () => {
2  let thing: string | undefined;
3  expect(typeof thing === "string");
4  // Typescript still thinks this type is string | undefined
5  thing;
6});

The asserts package in node will correctly infer the narrowed type

Node1import { describe } from "node:test";
2import assert from "node:assert";
3
4describe("test", () => {
5  let thing: string | undefined;
6  assert(thing);
7  // Typescript correctly narrows this variables type to string
8  thing;
9});

Hooks

The node api also has support for the regular lifecycle hooks jest also exposes such as beforeAll, beforeEach, afterAll and afterEach allowing you to setup and destroy resources and mocks needed for tests:

Jest1beforeEach(() => {
2  initializeDatabase();
3});
4
5afterEach(() => {
6  clearDatabase();
7});
8
9beforeAll(() => initializeDatabase());
10
11afterAll(() => clearDatabase());
12
13describe("test", () => {
14  it("should sum", async () => {
15    expect(1 + 2).toEqual(3);
16  });
17});

Again, node requires you to import these lifecycle hooks from the node:test module

Node1import { describe, it, before, after, beforeEach, afterEach } from "node:test";
2import assert from "node:assert";
3
4beforeEach(() => {
5  initializeDatabase();
6});
7
8afterEach(() => {
9  clearDatabase();
10});
11
12before(() => initializeDatabase());
13
14after(() => clearDatabase());
15
16describe("test", () => {
17  it("should sum", async () => {
18    assert.strictEqual(1 + 2, 3);
19  });
20});