ClaudeMailbox/node/tests/server.test.ts

import { describe, it, expect, afterEach, beforeEach } from "vitest";
import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { MailboxStore } from "../src/db.js";
import { buildServer } from "../src/server.js";
import type { FastifyInstance } from "fastify";

let dir: string;
let dbPath: string;
let store: MailboxStore;
let app: FastifyInstance;
let baseUrl: string;

beforeEach(async () => {
  dir = mkdtempSync(join(tmpdir(), "claude-mailbox-srv-"));
  dbPath = join(dir, "test.db");
  store = new MailboxStore(dbPath);
  app = await buildServer({ port: 0, bind: "127.0.0.1", dbPath }, store);
  await app.listen({ host: "127.0.0.1", port: 0 });
  const addr = app.server.address();
  if (!addr || typeof addr === "string") throw new Error("no address");
  baseUrl = `http://127.0.0.1:${addr.port}`;
});

afterEach(async () => {
  await app.close();
  store.close();
  rmSync(dir, { recursive: true, force: true });
});

async function call(
  method: string,
  path: string,
  init: { headers?: Record<string, string>; body?: unknown } = {},
): Promise<{ status: number; body: unknown }> {
  const headers: Record<string, string> = { Accept: "application/json", ...(init.headers ?? {}) };
  let body: string | undefined;
  if (init.body !== undefined) {
    headers["Content-Type"] = "application/json";
    body = JSON.stringify(init.body);
  }
  const res = await fetch(`${baseUrl}${path}`, { method, headers, body });
  const text = await res.text();
  return { status: res.status, body: text.length ? JSON.parse(text) : null };
}

describe("REST surface", () => {
  it("/health is anonymous", async () => {
    const r = await call("GET", "/health");
    expect(r.status).toBe(200);
    expect(r.body).toMatchObject({ status: "ok", dbPath });
  });

  it("POST /v1/send requires X-Mailbox", async () => {
    const r = await call("POST", "/v1/send", { body: { to: "bob", body: "hi" } });
    expect(r.status).toBe(400);
  });

  it("POST /v1/send → /v1/check-inbox round-trip", async () => {
    const send = await call("POST", "/v1/send", {
      headers: { "X-Mailbox": "alice" },
      body: { to: "bob", body: "hi bob" },
    });
    expect(send.status).toBe(200);
    expect(send.body).toMatchObject({ id: expect.any(Number), queuedAt: expect.any(String) });

    const peek = await call("GET", "/v1/peek?name=bob");
    expect(peek.status).toBe(200);
    expect(peek.body).toMatchObject({ pending: 1 });

    const check = await call("POST", "/v1/check-inbox?name=bob", {
      headers: { "X-Mailbox": "bob" },
    });
    expect(check.status).toBe(200);
    expect(Array.isArray(check.body)).toBe(true);
    const arr = check.body as Array<{ from: string; body: string }>;
    expect(arr).toHaveLength(1);
    expect(arr[0]!.from).toBe("alice");
    expect(arr[0]!.body).toBe("hi bob");

    const peekAfter = await call("GET", "/v1/peek?name=bob");
    expect(peekAfter.body).toMatchObject({ pending: 0, oldestAt: null });
  });

  it("POST /v1/check-inbox rejects mismatched X-Mailbox", async () => {
    await call("POST", "/v1/send", {
      headers: { "X-Mailbox": "alice" },
      body: { to: "bob", body: "x" },
    });
    const wrong = await call("POST", "/v1/check-inbox?name=bob", {
      headers: { "X-Mailbox": "alice" },
    });
    expect(wrong.status).toBe(403);
  });

  it("/v1/list and /v1/peek are anonymous", async () => {
    await call("POST", "/v1/send", {
      headers: { "X-Mailbox": "alice" },
      body: { to: "bob", body: "x" },
    });
    const list = await call("GET", "/v1/list");
    expect(list.status).toBe(200);
    expect(Array.isArray(list.body)).toBe(true);

    const peek = await call("GET", "/v1/peek?name=bob");
    expect(peek.status).toBe(200);
  });
});