Testing all 2 written

maths.mjs

1
2
3
4
5
6
7
8export function add(a, b) {
  return a + b;
}

export function average(numbers) {
  if (numbers.length === 0) throw new RangeError("average of an empty list");
  return numbers.reduce((sum, n) => sum + n, 0) / numbers.length;
}

maths.test.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17import { test, describe, it } from "node:test";
import assert from "node:assert/strict";
import { add, average } from "./maths.mjs";

test("add puts two numbers together", () => {
  assert.equal(add(2, 3), 5);
});

describe("average", () => {
  it("averages a list", () => {
    assert.equal(average([1, 2, 3, 4]), 2.5);
  });

  it("refuses an empty list", () => {
    assert.throws(() => average([]), RangeError);
  });
});

price.mjs

1
2
3export function formatPrice(pence) {
  return `£${Math.floor(pence / 100)}.${pence % 100}`;
}

price.fixed.mjs

1
2
3export function formatPrice(pence) {
  return `£${Math.floor(pence / 100)}.${String(pence % 100).padStart(2, "0")}`;
}

price.test.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15import { test } from "node:test";
import assert from "node:assert/strict";
import { formatPrice } from "./price.mjs";

test("formats pounds and pence", () => {
  assert.equal(formatPrice(1250), "£12.50");
});

test("formats whole pounds", () => {
  assert.equal(formatPrice(1200), "£12.00");
});

test("formats single-digit pence", () => {
  assert.equal(formatPrice(1205), "£12.05");
});

users.mjs

1
2
3
4export async function loadUser(id) {
  if (id < 0) throw new RangeError(`no user can have id ${id}`);
  return { id, name: "Ada" };
}

forgot.test.mjs

1
2
3
4
5
6
7
8import { test } from "node:test";
import assert from "node:assert/strict";
import { loadUser } from "./users.mjs";

// Wrong: loadUser(0) does not reject. This test should fail.
test("rejects an id of 0, without await", () => {
  assert.rejects(loadUser(0), RangeError);
});

awaited.test.mjs

1
2
3
4
5
6
7
8import { test } from "node:test";
import assert from "node:assert/strict";
import { loadUser } from "./users.mjs";

// The same wrong test, awaited.
test("rejects an id of 0, with await", async () => {
  await assert.rejects(loadUser(0), RangeError);
});

app.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130import { createServer } from "node:http";

export class HttpError extends Error {
  constructor(status, message) {
    super(message);
    this.status = status;
  }
}

// ---- JSON in and out ------------------------------------------------------

async function readJson(req, limit = 10_000) {
  if (!req.headers["content-type"]?.startsWith("application/json")) {
    throw new HttpError(415, "send JSON, with Content-Type: application/json");
  }
  let size = 0;
  const chunks = [];
  for await (const chunk of req) {
    size += chunk.length;
    if (size > limit) throw new HttpError(413, `the body is over ${limit} bytes`);
    chunks.push(chunk);
  }
  try {
    return JSON.parse(Buffer.concat(chunks).toString("utf8"));
  } catch {
    throw new HttpError(400, "the body is not valid JSON");
  }
}

function send(res, status, body, headers = {}) {
  if (body === undefined) {
    res.writeHead(status, headers);
    return res.end();
  }
  const text = JSON.stringify(body);
  res.writeHead(status, {
    "content-type": "application/json; charset=utf-8",
    "content-length": Buffer.byteLength(text),
    ...headers,
  });
  res.end(text);
}

// ---- validation -------------------------------------------------------------

function checkTodo(input, { partial = false } = {}) {
  if (typeof input !== "object" || input === null || Array.isArray(input)) {
    throw new HttpError(400, "send a JSON object");
  }
  const unknown = Object.keys(input).filter((key) => key !== "title" && key !== "done");
  if (unknown.length > 0) throw new HttpError(400, `unknown field: ${unknown.join(", ")}`);

  if (!partial || "title" in input) {
    if (typeof input.title !== "string" || input.title.trim() === "") {
      throw new HttpError(400, "title must be a non-empty string");
    }
  }
  if ("done" in input && typeof input.done !== "boolean") {
    throw new HttpError(400, "done must be true or false");
  }
  return input;
}

// ---- the app ------------------------------------------------------------------

export function createApp() {
  const todos = new Map();           // the data lives here, one store per app
  let nextId = 1;
  const routes = [];
  const route = (method, pathname, handler) =>
    routes.push({ method, pattern: new URLPattern({ pathname }), handler });

  const find = (id) => {
    const todo = todos.get(Number(id));
    if (!todo) throw new HttpError(404, `no todo with id ${id}`);
    return todo;
  };

  route("GET", "/todos", ({ url }) => {
    let list = [...todos.values()];
    const done = url.searchParams.get("done");
    if (done !== null) list = list.filter((todo) => String(todo.done) === done);
    return { status: 200, body: list };
  });

  route("POST", "/todos", async ({ req }) => {
    const input = checkTodo(await readJson(req));
    const todo = { id: nextId++, title: input.title.trim(), done: input.done ?? false };
    todos.set(todo.id, todo);
    return { status: 201, body: todo, headers: { location: `/todos/${todo.id}` } };
  });

  route("GET", "/todos/:id(\\d+)", ({ params }) => ({ status: 200, body: find(params.id) }));

  route("PATCH", "/todos/:id(\\d+)", async ({ req, params }) => {
    const todo = find(params.id);
    const changes = checkTodo(await readJson(req), { partial: true });
    if ("title" in changes) todo.title = changes.title.trim();
    if ("done" in changes) todo.done = changes.done;
    return { status: 200, body: todo };
  });

  route("DELETE", "/todos/:id(\\d+)", ({ params }) => {
    find(params.id);
    todos.delete(Number(params.id));
    return { status: 204 };
  });

  return createServer(async (req, res) => {
    try {
      const url = new URL(req.url, "http://localhost");
      const matches = routes.filter((r) => r.pattern.test({ pathname: url.pathname }));
      if (matches.length === 0) throw new HttpError(404, `nothing at ${url.pathname}`);

      const match = matches.find((r) => r.method === req.method);
      if (!match) {
        res.setHeader("allow", matches.map((r) => r.method).join(", "));
        throw new HttpError(405, `${req.method} is not allowed here`);
      }

      const params = match.pattern.exec({ pathname: url.pathname }).pathname.groups;
      const { status, body, headers } = await match.handler({ req, url, params });
      send(res, status, body, headers);
    } catch (err) {
      if (err instanceof HttpError) return send(res, err.status, { error: err.message });
      console.error(err);
      send(res, 500, { error: "internal error" });
    }
  });
}

test/helpers.mjs

1
2
3
4
5
6
7
8
9import { once } from "node:events";
import { createApp } from "../app.mjs";

// A new, empty app on a free port.
export async function startApp() {
  const server = createApp().listen(0, "127.0.0.1");
  await once(server, "listening");
  return { server, base: `http://127.0.0.1:${server.address().port}` };
}

test/app.test.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46import { describe, it, beforeEach, afterEach } from "node:test";
import assert from "node:assert/strict";
import { startApp } from "./helpers.mjs";

describe("the todo API", () => {
  let app;
  beforeEach(async () => { app = await startApp(); });   // fresh for every test
  afterEach(() => app.server.close());

  const post = (body) => fetch(`${app.base}/todos`, {
    method: "POST",
    headers: { "content-type": "application/json" },
    body: JSON.stringify(body),
  });

  it("starts empty", async () => {
    const res = await fetch(`${app.base}/todos`);
    assert.equal(res.status, 200);
    assert.deepEqual(await res.json(), []);
  });

  it("creates a todo and says where it is", async () => {
    const res = await post({ title: "Buy tea" });
    assert.equal(res.status, 201);
    assert.equal(res.headers.get("location"), "/todos/1");
    assert.deepEqual(await res.json(), { id: 1, title: "Buy tea", done: false });
  });

  it("refuses fields it does not know", async () => {
    const res = await post({ title: "Pay me", owner: "admin" });
    assert.equal(res.status, 400);
    assert.match((await res.json()).error, /unknown field: owner/);
  });

  it("answers 405, with an allow header, for the wrong method", async () => {
    const res = await fetch(`${app.base}/todos`, { method: "PUT" });
    assert.equal(res.status, 405);
    assert.equal(res.headers.get("allow"), "GET, POST");
  });

  it("forgets a deleted todo", async () => {
    await post({ title: "Temporary" });
    assert.equal((await fetch(`${app.base}/todos/1`, { method: "DELETE" })).status, 204);
    assert.equal((await fetch(`${app.base}/todos/1`)).status, 404);
  });
});

package.json

1
2
3
4
5
6
7
8{
  "name": "todo-api",
  "version": "1.0.0",
  "type": "module",
  "scripts": {
    "test": "node --test \"test/**/*.test.mjs\""
  }
}

signup.mjs

1
2
3
4
5
6
7
8export async function signUp(email, { users, sendEmail }) {
  if (!email.includes("@")) throw new Error(`not an email address: ${email}`);
  if (users.has(email)) return { created: false };

  users.add(email);
  await sendEmail(email, "Welcome!", "Thanks for signing up.");
  return { created: true };
}

signup.test.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30import { test, mock } from "node:test";
import assert from "node:assert/strict";
import { signUp } from "./signup.mjs";

test("a new user gets one welcome email", async () => {
  const sendEmail = mock.fn(async () => {});        // records every call, sends nothing

  await signUp("ada@example.com", { users: new Set(), sendEmail });

  assert.equal(sendEmail.mock.callCount(), 1);
  assert.deepEqual(sendEmail.mock.calls[0].arguments,
    ["ada@example.com", "Welcome!", "Thanks for signing up."]);
});

test("signing up twice does not email twice", async () => {
  const sendEmail = mock.fn(async () => {});
  const users = new Set(["ada@example.com"]);

  const result = await signUp("ada@example.com", { users, sendEmail });

  assert.deepEqual(result, { created: false });
  assert.equal(sendEmail.mock.callCount(), 0);
});

test("a bad address never reaches the mailer", async () => {
  const sendEmail = mock.fn(async () => {});

  await assert.rejects(signUp("not-an-email", { users: new Set(), sendEmail }), /not an email/);
  assert.equal(sendEmail.mock.callCount(), 0);
});

weather.mjs

1
2
3
4
5
6
7export async function temperature(city, { baseUrl }) {
  const url = `${baseUrl}/forecast?city=${encodeURIComponent(city)}`;
  const res = await fetch(url, { signal: AbortSignal.timeout(2000) });
  if (!res.ok) throw new Error(`the weather service answered ${res.status}`);
  const data = await res.json();
  return Math.round(data.current.celsius);
}

weather.test.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27import { test } from "node:test";
import assert from "node:assert/strict";
import { temperature } from "./weather.mjs";

const baseUrl = "http://localhost:8080";      // never contacted: fetch is replaced

test("rounds the temperature", async (t) => {
  const fetch = t.mock.method(globalThis, "fetch",
    async () => Response.json({ current: { celsius: 18.6 } }));

  assert.equal(await temperature("Paris", { baseUrl }), 19);
  assert.equal(fetch.mock.callCount(), 1);
});

test("encodes the city name in the URL", async (t) => {
  const fetch = t.mock.method(globalThis, "fetch",
    async () => Response.json({ current: { celsius: 25 } }));

  await temperature("São Paulo", { baseUrl });
  assert.equal(fetch.mock.calls[0].arguments[0], `${baseUrl}/forecast?city=S%C3%A3o%20Paulo`);
});

test("reports a service that is down", async (t) => {
  t.mock.method(globalThis, "fetch", async () => new Response("busy", { status: 503 }));

  await assert.rejects(temperature("Paris", { baseUrl }), /answered 503/);
});

time.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26export const SESSION_LENGTH = 30 * 60 * 1000;      // thirty minutes

export function createSessions() {
  const sessions = new Map();
  return {
    start(user) {
      const id = crypto.randomUUID();
      sessions.set(id, { user, expires: Date.now() + SESSION_LENGTH });
      return id;
    },
    user(id) {
      const session = sessions.get(id);
      if (!session || Date.now() >= session.expires) return null;
      return session.user;
    },
  };
}

// Call fn only once calls have stopped for `ms` -- a search box, say.
export function debounce(fn, ms) {
  let timer;
  return (...args) => {
    clearTimeout(timer);
    timer = setTimeout(() => fn(...args), ms);
  };
}

time.test.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32import { test, mock } from "node:test";
import assert from "node:assert/strict";
import { createSessions, debounce } from "./time.mjs";

test("a session lasts thirty minutes, and not a second more", (t) => {
  t.mock.timers.enable({ apis: ["Date"], now: new Date("2026-09-30T09:00:00Z") });
  const sessions = createSessions();
  const id = sessions.start("ada");

  t.mock.timers.tick(29 * 60 * 1000);
  assert.equal(sessions.user(id), "ada");

  t.mock.timers.tick(60 * 1000);
  assert.equal(new Date().toISOString(), "2026-09-30T09:30:00.000Z");
  assert.equal(sessions.user(id), null);
});

test("debounce waits for the typing to stop", (t) => {
  t.mock.timers.enable({ apis: ["setTimeout"] });
  const search = mock.fn();
  const onType = debounce(search, 300);

  onType("t");
  onType("te");
  onType("tea");
  t.mock.timers.tick(299);
  assert.equal(search.mock.callCount(), 0);

  t.mock.timers.tick(1);
  assert.equal(search.mock.callCount(), 1);
  assert.deepEqual(search.mock.calls[0].arguments, ["tea"]);
});

src/price.mjs

1
2
3
4
5
6
7
8
9
10
11export function priceWithTax(pence, { country }) {
  if (!Number.isInteger(pence) || pence < 0) {
    throw new RangeError("price must be a whole number of pence");
  }
  if (country === "GB") return Math.round(pence * 1.2);
  if (country === "DE") return Math.round(pence * 1.19);
  if (country === "US") {
    return pence;
  }
  throw new Error(`no tax rule for ${country}`);
}

test/price.test.mjs

1
2
3
4
5
6
7
8
9
10
11import { test } from "node:test";
import assert from "node:assert/strict";
import { priceWithTax } from "../src/price.mjs";

test("adds UK VAT", () => {
  assert.equal(priceWithTax(1000, { country: "GB" }), 1200);
});

test("refuses a fractional price", () => {
  assert.throws(() => priceWithTax(9.99, { country: "GB" }), RangeError);
});