test(coverage): real-behaviour tests for admin routes + glitchtip ingest (#141)

Adds vitest unit tests for five previously zero-coverage routes:

- /api/admin/users (GET) — admin gate, safe select shape regression, no
  password-hash leak.
- /api/admin/users/[id] (PUT) — Zod validation, 404 for unknown id,
  last-admin demotion guard, audit-log call shape.
- /api/admin/settings (GET / PUT) — singleton row regression, encrypted
  blob never reaches the client, AES encrypt() called for VAPID +
  GitHub-issue tokens, clear flags wipe encrypted columns, every
  schema-allowed field round-trips through upsert.
- /api/admin/status (GET) — integration health summary aggregates umami
  / glitchtip / web-push / bug-report flags, only non-revoked tokens
  count as active, encrypted blobs never appear in the envelope.
- /api/monitoring/glitchtip (POST) — IP rate-limit gate, short-circuit
  when DSN is null, message/stack size caps (2000 / 20 000 chars),
  upstream 5xx mapped to 502, environment fallback to "production".

All five files now land at >=80% line coverage:
- admin/users/route.ts: 100%
- admin/users/[id]/route.ts: 100%
- admin/settings/route.ts: 100%
- admin/status/route.ts: 84.21%
- monitoring/glitchtip/route.ts: 100%

Test count: 469 -> 523 (+54; my files contribute 46, the other 8 were
unblocked by re-running prisma generate in the worktree).

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

src/app/api/admin/users/[id]/__tests__/route.test.ts

@@ -0,0 +1,208 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { NextRequest } from "next/server";
+
+vi.mock("@/lib/db", () => ({
+  prisma: {
+    user: {
+      findUnique: vi.fn(),
+      count: vi.fn(),
+      update: vi.fn(),
+    },
+  },
+}));
+
+vi.mock("@/lib/api-handler", async () => {
+  const actual =
+    await vi.importActual<typeof import("@/lib/api-handler")>(
+      "@/lib/api-handler",
+    );
+  return {
+    ...actual,
+    apiHandler: <T extends (...args: unknown[]) => Promise<Response>>(
+      h: T,
+    ): T => h,
+    requireAdmin: vi.fn(),
+  };
+});
+
+vi.mock("@/lib/auth/audit", () => ({
+  auditLog: vi.fn().mockResolvedValue(undefined),
+}));
+
+vi.mock("@/lib/logging/context", () => ({
+  annotate: vi.fn(),
+  getEvent: vi.fn(() => null),
+}));
+
+import { PUT } from "../route";
+import { prisma } from "@/lib/db";
+import { requireAdmin, HttpError } from "@/lib/api-handler";
+import { auditLog } from "@/lib/auth/audit";
+
+const ADMIN_CTX = {
+  session: { id: "s1", expiresAt: new Date(Date.now() + 3_600_000) },
+  user: {
+    id: "admin-1",
+    username: "admin",
+    role: "ADMIN",
+  } as never,
+};
+
+function jsonReq(body: unknown): NextRequest {
+  return new NextRequest("http://localhost/api/admin/users/u1", {
+    method: "PUT",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body),
+  });
+}
+
+function params(id: string) {
+  return { params: Promise.resolve({ id }) };
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  vi.mocked(requireAdmin).mockResolvedValue(ADMIN_CTX);
+});
+
+describe("PUT /api/admin/users/[id]", () => {
+  it("rejects with 401 when unauthenticated", async () => {
+    vi.mocked(requireAdmin).mockRejectedValue(
+      new HttpError(401, "Not authenticated"),
+    );
+    await expect(
+      PUT(jsonReq({ username: "marc" }), params("u1")),
+    ).rejects.toThrow("Not authenticated");
+  });
+
+  it("rejects with 403 when caller is not admin", async () => {
+    vi.mocked(requireAdmin).mockRejectedValue(
+      new HttpError(403, "Admin access required"),
+    );
+    await expect(
+      PUT(jsonReq({ username: "marc" }), params("u1")),
+    ).rejects.toThrow("Admin access required");
+  });
+
+  it("returns 422 when payload fails Zod validation (short username)", async () => {
+    const res = await PUT(jsonReq({ username: "ab" }), params("u1"));
+    expect(res.status).toBe(422);
+    expect(vi.mocked(prisma.user.findUnique)).not.toHaveBeenCalled();
+  });
+
+  it("returns 422 when role is unknown", async () => {
+    const res = await PUT(jsonReq({ role: "SUPERUSER" }), params("u1"));
+    expect(res.status).toBe(422);
+  });
+
+  it("returns 404 when target user does not exist", async () => {
+    vi.mocked(prisma.user.findUnique).mockResolvedValue(null);
+    const res = await PUT(jsonReq({ username: "marc" }), params("u-missing"));
+    expect(res.status).toBe(404);
+    expect(vi.mocked(prisma.user.update)).not.toHaveBeenCalled();
+  });
+
+  it("forbids demoting the last remaining admin", async () => {
+    vi.mocked(prisma.user.findUnique).mockResolvedValue({
+      id: "u1",
+      role: "ADMIN",
+    } as never);
+    vi.mocked(prisma.user.count).mockResolvedValue(1);
+    const res = await PUT(jsonReq({ role: "USER" }), params("u1"));
+    expect(res.status).toBe(400);
+    const body = (await res.json()) as { error: string };
+    expect(body.error).toMatch(/last admin/i);
+    expect(vi.mocked(prisma.user.update)).not.toHaveBeenCalled();
+  });
+
+  it("allows demoting an admin while another admin exists", async () => {
+    vi.mocked(prisma.user.findUnique).mockResolvedValue({
+      id: "u1",
+      role: "ADMIN",
+    } as never);
+    vi.mocked(prisma.user.count).mockResolvedValue(2);
+    vi.mocked(prisma.user.update).mockResolvedValue({
+      id: "u1",
+      username: "alice",
+      email: "a@b.com",
+      role: "USER",
+      createdAt: new Date("2024-01-01T00:00:00Z"),
+    } as never);
+    const res = await PUT(jsonReq({ role: "USER" }), params("u1"));
+    expect(res.status).toBe(200);
+    const updateArgs = vi.mocked(prisma.user.update).mock.calls[0]?.[0];
+    expect(updateArgs?.where).toEqual({ id: "u1" });
+    expect(updateArgs?.data).toEqual({ role: "USER" });
+  });
+
+  it("persists username + email + role and writes an audit-log entry", async () => {
+    vi.mocked(prisma.user.findUnique).mockResolvedValue({
+      id: "u1",
+      role: "USER",
+    } as never);
+    const updated = {
+      id: "u1",
+      username: "renamed",
+      email: "new@example.com",
+      role: "ADMIN" as const,
+      createdAt: new Date("2024-01-01T00:00:00Z"),
+    };
+    vi.mocked(prisma.user.update).mockResolvedValue(updated as never);
+
+    const res = await PUT(
+      jsonReq({
+        username: "renamed",
+        email: "new@example.com",
+        role: "ADMIN",
+      }),
+      params("u1"),
+    );
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as { data: Record<string, unknown> };
+    expect(body.data.username).toBe("renamed");
+    expect(body.data.role).toBe("ADMIN");
+    expect(body.data).not.toHaveProperty("passwordHash");
+
+    const updateArgs = vi.mocked(prisma.user.update).mock.calls[0]?.[0];
+    expect(updateArgs?.data).toEqual({
+      username: "renamed",
+      email: "new@example.com",
+      role: "ADMIN",
+    });
+    expect(auditLog).toHaveBeenCalledWith(
+      "admin.user.update",
+      expect.objectContaining({
+        userId: "admin-1",
+        details: expect.objectContaining({ targetUserId: "u1" }),
+      }),
+    );
+  });
+
+  it("supports clearing email by passing null", async () => {
+    vi.mocked(prisma.user.findUnique).mockResolvedValue({
+      id: "u1",
+      role: "USER",
+    } as never);
+    vi.mocked(prisma.user.update).mockResolvedValue({
+      id: "u1",
+      username: "alice",
+      email: null,
+      role: "USER",
+      createdAt: new Date(),
+    } as never);
+    const res = await PUT(jsonReq({ email: null }), params("u1"));
+    expect(res.status).toBe(200);
+    const updateArgs = vi.mocked(prisma.user.update).mock.calls[0]?.[0];
+    expect(updateArgs?.data).toEqual({ email: null });
+  });
+
+  it("returns 415 when content-type is not JSON", async () => {
+    const r = new NextRequest("http://localhost/api/admin/users/u1", {
+      method: "PUT",
+      headers: { "content-type": "text/plain" },
+      body: "{}",
+    });
+    const res = await PUT(r, params("u1"));
+    expect(res.status).toBe(415);
+  });
+});

src/app/api/admin/users/__tests__/route.test.ts

@@ -0,0 +1,119 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+vi.mock("@/lib/db", () => ({
+  prisma: {
+    user: { findMany: vi.fn() },
+  },
+}));
+
+vi.mock("@/lib/api-handler", async () => {
+  const actual =
+    await vi.importActual<typeof import("@/lib/api-handler")>(
+      "@/lib/api-handler",
+    );
+  return {
+    ...actual,
+    apiHandler: <T extends (...args: unknown[]) => Promise<Response>>(
+      h: T,
+    ): T => h,
+    requireAdmin: vi.fn(),
+  };
+});
+
+vi.mock("@/lib/logging/context", () => ({
+  annotate: vi.fn(),
+  getEvent: vi.fn(() => null),
+}));
+
+import { GET } from "../route";
+import { prisma } from "@/lib/db";
+import { requireAdmin, HttpError } from "@/lib/api-handler";
+
+const mockUserFindMany = vi.mocked(prisma.user.findMany);
+const mockRequireAdmin = vi.mocked(requireAdmin);
+
+describe("GET /api/admin/users", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockRequireAdmin.mockResolvedValue({
+      session: { id: "s1", expiresAt: new Date(Date.now() + 3_600_000) },
+      user: {
+        id: "admin-1",
+        username: "admin",
+        role: "ADMIN",
+      } as never,
+    });
+    mockUserFindMany.mockResolvedValue([] as never);
+  });
+
+  it("rejects with 401 when no session", async () => {
+    mockRequireAdmin.mockRejectedValue(new HttpError(401, "Not authenticated"));
+    await expect(GET()).rejects.toThrow("Not authenticated");
+  });
+
+  it("rejects with 403 when caller is not admin", async () => {
+    mockRequireAdmin.mockRejectedValue(
+      new HttpError(403, "Admin access required"),
+    );
+    await expect(GET()).rejects.toThrow("Admin access required");
+  });
+
+  it("returns users sorted by createdAt ascending with passkey counts", async () => {
+    const created = new Date("2024-01-01T00:00:00Z");
+    mockUserFindMany.mockResolvedValue([
+      {
+        id: "u1",
+        username: "alice",
+        email: "alice@example.com",
+        role: "ADMIN",
+        createdAt: created,
+        _count: { passkeys: 2 },
+      },
+      {
+        id: "u2",
+        username: "bob",
+        email: null,
+        role: "USER",
+        createdAt: created,
+        _count: { passkeys: 0 },
+      },
+    ] as never);
+
+    const res = await GET();
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as {
+      data: Array<Record<string, unknown>>;
+    };
+    expect(body.data).toHaveLength(2);
+    expect(body.data[0]).toEqual({
+      id: "u1",
+      username: "alice",
+      email: "alice@example.com",
+      role: "ADMIN",
+      createdAt: created.toISOString(),
+      passkeyCount: 2,
+    });
+    expect(body.data[1].passkeyCount).toBe(0);
+    expect(body.data[1].email).toBeNull();
+  });
+
+  it("queries Prisma with the safe select shape (no password / sensitive cols)", async () => {
+    await GET();
+    expect(mockUserFindMany).toHaveBeenCalledTimes(1);
+    const args = mockUserFindMany.mock.calls[0]?.[0] as {
+      select: Record<string, unknown>;
+      orderBy: { createdAt: "asc" | "desc" };
+    };
+    // Regression: the route must NOT pull password hash / token columns.
+    expect(args.select).toEqual({
+      id: true,
+      username: true,
+      email: true,
+      role: true,
+      createdAt: true,
+      _count: { select: { passkeys: true } },
+    });
+    expect(args.select).not.toHaveProperty("passwordHash");
+    expect(args.orderBy).toEqual({ createdAt: "asc" });
+  });
+});