Testing

bun test
# all *.test.ts / *.spec.ts files
bun test cart --watch
# filter by path, re-run on save
bun test -t "totals"          # filter by test name
bunx vitest
# watch mode; `vitest run` for CI
node --test "**/*.test.ts"    # Node 22+ glob

import { expect, it } from "bun:test";
 
it("creates a user", () => {
  const user = { id: 7, name: "Ada", createdAt: new Date() };
  expect(user).toEqual({
    id: expect.any(Number),
    name: "Ada",
    createdAt: expect.any(Date),
  });
  const loose: { a?: number; b: number } = {
    a: undefined,
    b: 2,
  };
  expect(loose).toEqual({ b: 2 });           // ✅
  expect(loose).not.toStrictEqual({ b: 2 }); // ✅
  expect(() => JSON.parse("{")).toThrow(SyntaxError);
});

import {
  afterEach,
  expect,
  it,
  mock,
  spyOn,
} from "bun:test";
 
type Notify = (
  userId: number,
  text: string,
) => Promise<void>;
 
afterEach(() => mock.restore());
 
it("notifies once per user", async () => {
  const notify = mock<Notify>(async () => {});
  await Promise.all([notify(1, "hi"), notify(2, "hi")]);
  expect(notify).toHaveBeenCalledTimes(2);
  expect(notify).toHaveBeenCalledWith(2, "hi");
});
 
it("silences expected errors", () => {
  const err = spyOn(console, "error")
    .mockImplementation(() => {});
  console.error("boom");
  expect(err).toHaveBeenCalledWith("boom");
});

import { afterEach, expect, it, jest, mock } from "bun:test";
 
afterEach(() => jest.useRealTimers());
 
function debounce(fn: () => void, ms: number) {
  let t: ReturnType<typeof setTimeout> | undefined;
  return () => {
    clearTimeout(t);
    t = setTimeout(fn, ms);
  };
}
 
it("debounces", () => {
  jest.useFakeTimers({ now: new Date("2026-01-01") });
  const fn = mock(() => {});
  const run = debounce(fn, 300);
  run(); run(); run();
  jest.advanceTimersByTime(299);
  expect(fn).not.toHaveBeenCalled();
  jest.advanceTimersByTime(1);
  expect(fn).toHaveBeenCalledTimes(1);
  expect(Date.now()).toBe(Date.parse("2026-01-01") + 300);
});

import { expect, it } from "bun:test";
 
async function load(id: number) {
  if (id < 0) throw new RangeError("bad id");
  return { id };
}
 
it("awaits", async () => {
  expect(await load(1)).toEqual({ id: 1 });
});
 
it("unwraps with resolves/rejects", async () => {
  await expect(load(1)).resolves.toEqual({ id: 1 });
  await expect(load(-1)).rejects.toThrow(RangeError);
});
 
it("counts assertions in callbacks", async () => {
  expect.assertions(1);
  await load(-1).catch((e) => {
    expect(e).toBeInstanceOf(RangeError);
  });
});

import { expect, it, vi } from "vitest";
 
async function retry<T>(fn: () => Promise<T>, tries = 3) {
  for (let i = 0; ; i++) {
    try {
      return await fn();
    } catch (e) {
      if (i >= tries - 1) throw e;
      await new Promise((r) => setTimeout(r, 1000 * 2 ** i));
    }
  }
}
 
it("backs off between attempts", async () => {
  vi.useFakeTimers();
  const fn = vi.fn<() => Promise<string>>()
    .mockRejectedValueOnce(new Error("503"))
    .mockResolvedValueOnce("ok");
  const p = retry(fn);
  await vi.advanceTimersByTimeAsync(1000);
  await expect(p).resolves.toBe("ok");
  expect(fn).toHaveBeenCalledTimes(2);
  vi.useRealTimers();
});

import { describe, expect, test } from "bun:test";
 
const slugify = (s: string) =>
  s.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-")
    .replace(/^-|-$/g, "");
 
describe("slugify", () => {
  test.each<[input: string, expected: string]>([
    ["Hello World", "hello-world"],
    ["  trim me  ", "trim-me"],
    ["a--b__c", "a-b-c"],
    ["", ""],
  ])("slugify(%p) -> %p", (input, expected) => {
    expect(slugify(input)).toBe(expected);
  });
});

type User = {
  id: number;
  name: string;
  email: string;
  role: "admin" | "member";
};
 
let seq = 0;
export function buildUser(
  overrides: Partial<User> = {},
): User {
  seq += 1;
  return {
    id: seq,
    name: `User ${seq}`,
    email: `user${seq}@example.com`,
    role: "member",
    ...overrides,
  };
}
 
const admin = buildUser({ role: "admin" });
// only what matters

import { expectTypeOf, test } from "bun:test"; // or "vitest"
 
declare function parse<T extends "int" | "bool">(
  kind: T,
  s: string,
): T extends "int" ? number : boolean;
 
test("parse return types", () => {
  expectTypeOf(parse("int", "1")).toEqualTypeOf<number>();
  expectTypeOf(parse("bool", "1")).toEqualTypeOf<boolean>();
  expectTypeOf(parse).parameter(1).toBeString();
  // @ts-expect-error: "date" is not a valid kind
  parse("date", "2026-01-01");
});

type Equal<X, Y> =
  (<T>() => T extends X ? 1 : 2) extends
  (<T>() => T extends Y ? 1 : 2) ? true : false;
type Expect<T extends true> = T;
 
type Cases = [
  Expect<Equal<ReturnType<typeof JSON.parse>, any>>,
  // @ts-expect-error: string is not number
  Expect<Equal<string, number>>,
];

import { render, screen } from "@testing-library/react";
import userEvent from "@testing-library/user-event";
import { expect, it } from "bun:test";
import { Counter } from "./Counter";
 
it("increments and saves", async () => {
  const user = userEvent.setup();
  render(<Counter initial={1} />);
 
  await user.click(
    screen.getByRole("button", { name: "+1" }),
  );
  expect(screen.getByRole("status")).toHaveTextContent("2");
 
  const save = screen.getByRole("button", { name: /save/i });
  await user.click(save);
  expect(
    await screen.findByText("Saved"),
  ).toBeInTheDocument();
  expect(
    screen.queryByRole("alert"),
  ).not.toBeInTheDocument();
});

[test]
preload = ["./tests/dom.ts", "./tests/setup.ts"]

import {
  GlobalRegistrator,
} from "@happy-dom/global-registrator";
 
// must run before anything imports @testing-library/*
GlobalRegistrator.register({
  url: "http://localhost:3000/",
});

import * as matchers
  from "@testing-library/jest-dom/matchers";
import { cleanup } from "@testing-library/react";
import { afterEach, expect } from "bun:test";
 
expect.extend(matchers);
afterEach(() => cleanup());

import type {
  TestingLibraryMatchers,
} from "@testing-library/jest-dom/matchers";
import type { expect } from "bun:test";
 
type Any = typeof expect.stringContaining;
declare module "bun:test" {
  interface Matchers<T>
    extends TestingLibraryMatchers<Any, T> {}
}

import { http, HttpResponse } from "msw";
import { setupServer } from "msw/node";
 
const API = "https://api.example.com";
 
export const handlers = [
  http.get(`${API}/users/:id`, ({ params }) =>
    HttpResponse.json({
      id: Number(params.id),
      name: "Ada",
    }),
  ),
  http.post(`${API}/users`, async ({ request }) => {
    const body = (await request.json()) as { name: string };
    const user = { id: 2, ...body };
    return HttpResponse.json(user, { status: 201 });
  }),
];
 
export const server = setupServer(...handlers);

import {
  afterAll, afterEach, beforeAll, expect, it,
} from "bun:test";
import { http, HttpResponse } from "msw";
import { server } from "./mocks/server";
import { getUser } from "./users";
 
beforeAll(() =>
  server.listen({ onUnhandledRequest: "error" }),
);
afterEach(() => server.resetHandlers());
afterAll(() => server.close());
 
it("surfaces a 500", async () => {
  server.use(
    http.get("https://api.example.com/users/:id", () =>
      new HttpResponse(null, { status: 500 }),
    ),
  );
  await expect(getUser(1)).rejects.toThrow("HTTP 500");
});

import { expect, it, mock } from "bun:test";
 
const API = "https://api.example.com";
 
type Fetch = (input: string | URL, init?: RequestInit) =>
  Promise<Response>;
 
function makeUsers(fetchFn: Fetch = fetch) {
  return async (id: number): Promise<unknown> => {
    const res = await fetchFn(`${API}/users/${id}`);
    if (!res.ok) throw new Error(`HTTP ${res.status}`);
    return res.json();
  };
}
 
it("calls the right URL", async () => {
  const fake = mock<Fetch>(async () =>
    Response.json({ id: 1 }),
  );
  const getUser = makeUsers(fake);
  expect(await getUser(1)).toEqual({ id: 1 });
  expect(fake).toHaveBeenCalledWith(`${API}/users/1`);
});

import { expect, test } from "@playwright/test";
 
test("signs in and sees the dashboard", async ({ page }) => {
  await page.goto("/login");
  await page.getByLabel("Email").fill("ada@example.com");
  await page.getByLabel("Password").fill("correct horse");
  await page
    .getByRole("button", { name: "Sign in" })
    .click();
 
  await expect(page).toHaveURL(/\/dashboard$/);
  await expect(page.getByRole("heading", { level: 1 }))
    .toHaveText("Welcome, Ada");
  await expect(page.getByRole("alert")).toHaveCount(0);
});

import { test as base, type Page } from "@playwright/test";
 
type Fixtures = { adminPage: Page };
 
export const test = base.extend<Fixtures>({
  adminPage: async ({ browser }, use) => {
    const context = await browser.newContext({
      storageState: "playwright/.auth/admin.json",
    });
    await use(await context.newPage());
    await context.close();
  },
});
export { expect } from "@playwright/test";

import { defineConfig, devices } from "@playwright/test";
 
const CI = !!process.env.CI;
 
export default defineConfig({
  testDir: "tests/e2e",
  fullyParallel: true,
  forbidOnly: CI,
  retries: CI ? 2 : 0,
  use: {
    baseURL: "http://localhost:3000",
    trace: "on-first-retry",
  },
  projects: [
    {
      name: "chromium",
      use: { ...devices["Desktop Chrome"] },
    },
    {
      name: "webkit",
      use: { ...devices["Desktop Safari"] },
    },
  ],
  webServer: {
    command: "bun run build && bun run start",
    url: "http://localhost:3000",
    reuseExistingServer: !CI,
  },
});

import { expect, it } from "bun:test";
import { Hono } from "hono";
 
const app = new Hono()
  .get("/health", (c) => c.json({ ok: true }))
  .post("/echo", async (c) => c.json(await c.req.json()));
 
it("GET /health", async () => {
  const res = await app.request("/health");
  expect(res.status).toBe(200);
  expect(await res.json()).toEqual({ ok: true });
});
 
it("POST /echo", async () => {
  const res = await app.request("/echo", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ n: 1 }),
  });
  expect(await res.json()).toEqual({ n: 1 });
});
// plain (req) => Response: handler(new Request("http://x/"))

import { afterAll, beforeAll, expect, it } from "bun:test";
 
let server: Bun.Server<undefined>;
 
beforeAll(() => {
  server = Bun.serve({
    port: 0, // any free port: parallel runs never clash
    routes: { "/ping": new Response("pong") },
    fetch: () => new Response("Not found", { status: 404 }),
  });
});
afterAll(() => server.stop(true)); // also close keep-alives
 
it("answers over real HTTP", async () => {
  const res = await fetch(new URL("/ping", server.url));
  expect(res.status).toBe(200);
  expect(await res.text()).toBe("pong");
});

import { afterEach, beforeEach, expect, it } from "bun:test";
import { mkdtemp, readFile, rm, writeFile }
  from "node:fs/promises";
import { tmpdir } from "node:os";
import path from "node:path";
 
let dir: string;
beforeEach(async () => {
  dir = await mkdtemp(path.join(tmpdir(), "app-test-"));
});
afterEach(() => rm(dir, { recursive: true, force: true }));
 
async function saveReport(out: string, rows: string[]) {
  const file = path.join(out, "report.csv");
  await writeFile(file, rows.join("\n"));
}
 
it("writes report.csv", async () => {
  await saveReport(dir, ["a,1", "b,2"]);
  const file = path.join(dir, "report.csv");
  const text = await readFile(file, "utf8");
  expect(text.split("\n")).toHaveLength(2);
});

import { afterEach, expect, it } from "bun:test";
 
type Env = Record<string, string | undefined>;
const saved = new Map<string, string | undefined>();
 
function put(key: string, value: string | undefined) {
  if (value === undefined) delete process.env[key];
  else process.env[key] = value;
}
function setEnv(vars: Env): void {
  for (const [key, value] of Object.entries(vars)) {
    if (!saved.has(key)) saved.set(key, process.env[key]);
    put(key, value);
  }
}
afterEach(() => {
  for (const [key, value] of saved) put(key, value);
  saved.clear();
});
 
const port = () => Number(process.env.PORT ?? 3000);
it("reads PORT", () => {
  setEnv({ PORT: "8080", DEBUG: undefined });
  expect(port()).toBe(8080);
});

import { expect, it } from "bun:test";
 
class HttpError extends Error {
  override name = "HttpError";
  constructor(
    readonly status: number,
    readonly url: string,
  ) {
    super(`HTTP ${status} ${url}`);
  }
}
 
async function getUser(id: number): Promise<{ id: number }> {
  if (id <= 0) throw new HttpError(404, `/users/${id}`);
  return { id };
}
 
it("rejects with a typed 404", async () => {
  const err = await getUser(0).catch((e: unknown) => e);
  expect(err).toBeInstanceOf(HttpError);
  expect(err).toMatchObject({
    status: 404,
    url: "/users/0",
  });
});