test: 添加完整测试套件（52 个文件，326 个用例）

基于 Vitest 搭建测试基础设施，覆盖后端纯函数、API 路由、
前端 hooks、UI 组件和页面级集成测试。

src/app/api/blindbox/draw/route.test.ts

@@ -0,0 +1,99 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { prismaMock, resetPrismaMock } from "@/__tests__/helpers/prisma-mock";
+import { createRequest, parseJsonResponse } from "@/__tests__/helpers/api-test-utils";
+import { TEST_USER } from "@/__tests__/helpers/fixtures";
+
+vi.mock("@/lib/blindbox", () => ({
+  requireMembership: vi.fn().mockResolvedValue({}),
+}));
+
+import { POST } from "./route";
+
+const mockCtx = { params: Promise.resolve({}) };
+
+beforeEach(() => {
+  resetPrismaMock();
+});
+
+describe("POST /api/blindbox/draw", () => {
+  it("draws a random idea", async () => {
+    prismaMock.$transaction.mockImplementation(async (fn: (tx: unknown) => Promise<unknown>) => {
+      const tx = {
+        blindBoxIdea: {
+          findMany: vi.fn().mockResolvedValue([{ id: "idea-1" }]),
+          updateMany: vi.fn().mockResolvedValue({ count: 1 }),
+          findUnique: vi.fn().mockResolvedValue({
+            id: "idea-1",
+            content: "去公园",
+            createdAt: new Date(),
+            user: { id: "user-2", username: "submitter", avatar: "🐶" },
+            drawnBy: { id: "user-1", username: "drawer", avatar: "🐱" },
+          }),
+        },
+      };
+      return fn(tx);
+    });
+
+    const req = createRequest("/api/blindbox/draw", {
+      method: "POST",
+      body: { roomId: "bb-room-1", userId: "user-1" },
+    });
+    const res = await POST(req, mockCtx);
+    const { status, data } = await parseJsonResponse(res);
+
+    expect(status).toBe(200);
+    expect(data.id).toBe("idea-1");
+    expect(data.content).toBe("去公园");
+    expect(data.submitter).toBeDefined();
+    expect(data.drawnBy).toBeDefined();
+  });
+
+  it("returns 404 when pool is empty", async () => {
+    prismaMock.$transaction.mockImplementation(async (fn: (tx: unknown) => Promise<unknown>) => {
+      const tx = {
+        blindBoxIdea: {
+          findMany: vi.fn().mockResolvedValue([]),
+          updateMany: vi.fn(),
+          findUnique: vi.fn(),
+        },
+      };
+      return fn(tx);
+    });
+
+    const req = createRequest("/api/blindbox/draw", {
+      method: "POST",
+      body: { roomId: "bb-room-1", userId: "user-1" },
+    });
+    const res = await POST(req, mockCtx);
+    expect(res.status).toBe(404);
+  });
+
+  it("returns 409 on race condition (count=0)", async () => {
+    prismaMock.$transaction.mockImplementation(async (fn: (tx: unknown) => Promise<unknown>) => {
+      const tx = {
+        blindBoxIdea: {
+          findMany: vi.fn().mockResolvedValue([{ id: "idea-1" }]),
+          updateMany: vi.fn().mockResolvedValue({ count: 0 }),
+          findUnique: vi.fn(),
+        },
+      };
+      return fn(tx);
+    });
+
+    const req = createRequest("/api/blindbox/draw", {
+      method: "POST",
+      body: { roomId: "bb-room-1", userId: "user-1" },
+    });
+    const res = await POST(req, mockCtx);
+    expect(res.status).toBe(409);
+  });
+
+  it("returns 400 when roomId is missing", async () => {
+    const req = createRequest("/api/blindbox/draw", {
+      method: "POST",
+      body: { userId: "user-1" },
+    });
+    const res = await POST(req, mockCtx);
+    expect(res.status).toBe(400);
+  });
+});

src/app/api/blindbox/plan/route.test.ts

@@ -0,0 +1,191 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { prismaMock, resetPrismaMock } from "@/__tests__/helpers/prisma-mock";
+import { createRequest, parseJsonResponse } from "@/__tests__/helpers/api-test-utils";
+import { TEST_WEEKEND_PLAN } from "@/__tests__/helpers/fixtures";
+
+vi.mock("@/lib/blindbox", () => ({
+  requireMembership: vi.fn().mockResolvedValue({}),
+}));
+
+vi.mock("@/lib/blindboxPlanGen", () => ({
+  runPlanGeneration: vi.fn().mockResolvedValue({
+    id: "plan-1",
+    days: [{ date: "周六", items: [] }],
+    createdAt: new Date(),
+  }),
+}));
+
+import { POST, PATCH, GET } from "./route";
+
+const mockCtx = { params: Promise.resolve({}) };
+
+beforeEach(() => {
+  resetPrismaMock();
+});
+
+describe("POST /api/blindbox/plan", () => {
+  it("generates a weekend plan", async () => {
+    const req = createRequest("/api/blindbox/plan", {
+      method: "POST",
+      body: {
+        roomId: "bb-room-1",
+        userId: "user-1",
+        availableTime: { date: "2025-03-01", startHour: 9, endHour: 18 },
+      },
+    });
+    const res = await POST(req, mockCtx);
+    const { status, data } = await parseJsonResponse(res);
+
+    expect(status).toBe(200);
+    expect(data.id).toBe("plan-1");
+  });
+
+  it("returns 400 for invalid available time", async () => {
+    const req = createRequest("/api/blindbox/plan", {
+      method: "POST",
+      body: {
+        roomId: "bb-room-1",
+        userId: "user-1",
+        availableTime: { date: "2025-03-01", startHour: 18, endHour: 9 },
+      },
+    });
+    const res = await POST(req, mockCtx);
+    expect(res.status).toBe(400);
+  });
+
+  it("returns 400 when roomId is missing", async () => {
+    const req = createRequest("/api/blindbox/plan", {
+      method: "POST",
+      body: {
+        userId: "user-1",
+        availableTime: { date: "2025-03-01", startHour: 9, endHour: 18 },
+      },
+    });
+    const res = await POST(req, mockCtx);
+    expect(res.status).toBe(400);
+  });
+});
+
+describe("PATCH /api/blindbox/plan", () => {
+  it("accepts a plan", async () => {
+    prismaMock.weekendPlan.findUnique.mockResolvedValue({
+      ...TEST_WEEKEND_PLAN,
+      status: "active",
+    } as never);
+    prismaMock.weekendPlan.update.mockResolvedValue({} as never);
+
+    const req = createRequest("/api/blindbox/plan", {
+      method: "PATCH",
+      body: { planId: "plan-1", userId: "user-1", action: "accept" },
+    });
+    const res = await PATCH(req, mockCtx);
+    const { status, data } = await parseJsonResponse(res);
+
+    expect(status).toBe(200);
+    expect(data.ok).toBe(true);
+  });
+
+  it("completes an accepted plan", async () => {
+    prismaMock.weekendPlan.findUnique.mockResolvedValue({
+      ...TEST_WEEKEND_PLAN,
+      status: "accepted",
+    } as never);
+    prismaMock.weekendPlan.update.mockResolvedValue({} as never);
+
+    const req = createRequest("/api/blindbox/plan", {
+      method: "PATCH",
+      body: { planId: "plan-1", userId: "user-1", action: "complete" },
+    });
+    const res = await PATCH(req, mockCtx);
+    expect(res.status).toBe(200);
+  });
+
+  it("expires an accepted plan", async () => {
+    prismaMock.weekendPlan.findUnique.mockResolvedValue({
+      ...TEST_WEEKEND_PLAN,
+      status: "accepted",
+    } as never);
+    prismaMock.weekendPlan.update.mockResolvedValue({} as never);
+
+    const req = createRequest("/api/blindbox/plan", {
+      method: "PATCH",
+      body: { planId: "plan-1", userId: "user-1", action: "expire" },
+    });
+    const res = await PATCH(req, mockCtx);
+    expect(res.status).toBe(200);
+  });
+
+  it("returns 400 when accepting non-active plan", async () => {
+    prismaMock.weekendPlan.findUnique.mockResolvedValue({
+      ...TEST_WEEKEND_PLAN,
+      status: "accepted",
+    } as never);
+
+    const req = createRequest("/api/blindbox/plan", {
+      method: "PATCH",
+      body: { planId: "plan-1", userId: "user-1", action: "accept" },
+    });
+    const res = await PATCH(req, mockCtx);
+    expect(res.status).toBe(400);
+  });
+
+  it("returns 403 when not plan owner", async () => {
+    prismaMock.weekendPlan.findUnique.mockResolvedValue({
+      ...TEST_WEEKEND_PLAN,
+      userId: "other-user",
+    } as never);
+
+    const req = createRequest("/api/blindbox/plan", {
+      method: "PATCH",
+      body: { planId: "plan-1", userId: "user-1", action: "accept" },
+    });
+    const res = await PATCH(req, mockCtx);
+    expect(res.status).toBe(403);
+  });
+
+  it("returns 400 for invalid action", async () => {
+    prismaMock.weekendPlan.findUnique.mockResolvedValue(TEST_WEEKEND_PLAN as never);
+
+    const req = createRequest("/api/blindbox/plan", {
+      method: "PATCH",
+      body: { planId: "plan-1", userId: "user-1", action: "invalid" },
+    });
+    const res = await PATCH(req, mockCtx);
+    expect(res.status).toBe(400);
+  });
+});
+
+describe("GET /api/blindbox/plan", () => {
+  it("returns latest accepted plan", async () => {
+    prismaMock.weekendPlan.findFirst.mockResolvedValue({
+      id: "plan-1",
+      planData: JSON.stringify({ days: [{ date: "周六", items: [] }] }),
+      endTime: null,
+      createdAt: new Date(),
+    } as never);
+
+    const req = createRequest("/api/blindbox/plan?mode=latest&userId=user-1&roomId=bb-room-1");
+    const res = await GET(req, mockCtx);
+    const { status, data } = await parseJsonResponse(res);
+
+    expect(status).toBe(200);
+    expect(data.plan).toBeDefined();
+    expect(data.plan.id).toBe("plan-1");
+  });
+
+  it("returns null when no plan found", async () => {
+    prismaMock.weekendPlan.findFirst.mockResolvedValue(null as never);
+
+    const req = createRequest("/api/blindbox/plan?mode=latest&userId=user-1&roomId=bb-room-1");
+    const res = await GET(req, mockCtx);
+    const { data } = await parseJsonResponse(res);
+
+    expect(data.plan).toBeNull();
+  });
+
+  it("returns 400 for invalid mode", async () => {
+    const req = createRequest("/api/blindbox/plan?mode=invalid&userId=user-1");
+    const res = await GET(req, mockCtx);
+    expect(res.status).toBe(400);
+  });
+});

src/app/api/blindbox/plan/stream/route.test.ts

@@ -0,0 +1,135 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+vi.mock("@/lib/prisma", () => ({ prisma: {} }));
+
+vi.mock("@/lib/blindbox", () => ({
+  requireMembership: vi.fn().mockResolvedValue({}),
+}));
+
+vi.mock("@/lib/api", () => ({
+  requireUserId: vi.fn((v) => {
+    if (!v || typeof v !== "string") throw new Error("请先登录");
+    return v;
+  }),
+}));
+
+vi.mock("@/lib/blindboxPlanGen", () => ({
+  runPlanGeneration: vi.fn(),
+}));
+
+import { POST } from "./route";
+import { runPlanGeneration } from "@/lib/blindboxPlanGen";
+
+const mockRunPlan = vi.mocked(runPlanGeneration);
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+async function readStream(response: Response): Promise<string> {
+  const reader = response.body!.getReader();
+  const decoder = new TextDecoder();
+  let text = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    text += decoder.decode(value, { stream: true });
+  }
+  return text;
+}
+
+describe("POST /api/blindbox/plan/stream", () => {
+  it("streams plan generation with SSE events", async () => {
+    mockRunPlan.mockImplementation(async (_roomId, _userId, _at, onProgress) => {
+      onProgress?.("正在搜索周边...");
+      onProgress?.("正在生成行程...");
+      return {
+        id: "plan-1",
+        days: [{ date: "周六", items: [] }],
+        createdAt: new Date(),
+      };
+    });
+
+    const req = new Request("http://localhost/api/blindbox/plan/stream", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        roomId: "bb-room-1",
+        userId: "user-1",
+        availableTime: { date: "2025-03-01", startHour: 9, endHour: 18 },
+      }),
+    });
+
+    const res = await POST(req);
+    expect(res.status).toBe(200);
+    expect(res.headers.get("Content-Type")).toBe("text/event-stream");
+
+    const text = await readStream(res);
+    expect(text).toContain("event: status");
+    expect(text).toContain("正在搜索周边...");
+    expect(text).toContain("event: plan");
+    expect(text).toContain("plan-1");
+  });
+
+  it("streams error event on generation failure", async () => {
+    mockRunPlan.mockRejectedValue(new Error("AI 服务不可用"));
+
+    const req = new Request("http://localhost/api/blindbox/plan/stream", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        roomId: "bb-room-1",
+        userId: "user-1",
+        availableTime: { date: "2025-03-01", startHour: 9, endHour: 18 },
+      }),
+    });
+
+    const res = await POST(req);
+    const text = await readStream(res);
+    expect(text).toContain("event: error");
+    expect(text).toContain("AI 服务不可用");
+  });
+
+  it("returns 400 for missing roomId", async () => {
+    const req = new Request("http://localhost/api/blindbox/plan/stream", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        userId: "user-1",
+        availableTime: { date: "2025-03-01", startHour: 9, endHour: 18 },
+      }),
+    });
+
+    const res = await POST(req);
+    expect(res.status).toBe(400);
+  });
+
+  it("returns 400 for invalid available time", async () => {
+    const req = new Request("http://localhost/api/blindbox/plan/stream", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        roomId: "bb-room-1",
+        userId: "user-1",
+        availableTime: { date: "2025-03-01", startHour: 18, endHour: 9 },
+      }),
+    });
+
+    const res = await POST(req);
+    expect(res.status).toBe(400);
+  });
+
+  it("returns 400 when userId is missing", async () => {
+    const req = new Request("http://localhost/api/blindbox/plan/stream", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        roomId: "bb-room-1",
+        availableTime: { date: "2025-03-01", startHour: 9, endHour: 18 },
+      }),
+    });
+
+    const res = await POST(req);
+    expect(res.status).toBe(400);
+  });
+});

src/app/api/blindbox/room/[code]/route.test.ts

@@ -0,0 +1,131 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { prismaMock, resetPrismaMock } from "@/__tests__/helpers/prisma-mock";
+import { createRequest, createRouteContext, parseJsonResponse } from "@/__tests__/helpers/api-test-utils";
+import { TEST_BLINDBOX_ROOM, TEST_USER } from "@/__tests__/helpers/fixtures";
+
+vi.mock("@/lib/blindbox", () => ({
+  getRoomByCode: vi.fn(),
+  requireMembership: vi.fn().mockResolvedValue({}),
+}));
+
+import { GET, PATCH, DELETE } from "./route";
+import { getRoomByCode } from "@/lib/blindbox";
+
+const mockGetRoomByCode = vi.mocked(getRoomByCode);
+
+beforeEach(() => {
+  resetPrismaMock();
+  vi.clearAllMocks();
+});
+
+describe("GET /api/blindbox/room/[code]", () => {
+  it("returns room data", async () => {
+    mockGetRoomByCode.mockResolvedValue({
+      ...TEST_BLINDBOX_ROOM,
+      _count: { ideas: 3 },
+      members: [
+        { user: { id: "user-1", username: "test", avatar: "🐱" }, joinedAt: new Date() },
+      ],
+    } as never);
+
+    const req = createRequest("/api/blindbox/room/ABC123");
+    const ctx = createRouteContext({ code: "ABC123" });
+    const res = await GET(req, ctx);
+    const { status, data } = await parseJsonResponse(res);
+
+    expect(status).toBe(200);
+    expect(data.code).toBe("ABC123");
+    expect(data.poolCount).toBe(3);
+    expect(data.members).toHaveLength(1);
+  });
+
+  it("returns 404 for nonexistent room", async () => {
+    mockGetRoomByCode.mockResolvedValue(null);
+
+    const req = createRequest("/api/blindbox/room/BADCODE");
+    const ctx = createRouteContext({ code: "BADCODE" });
+    const res = await GET(req, ctx);
+    expect(res.status).toBe(404);
+  });
+});
+
+describe("PATCH /api/blindbox/room/[code]", () => {
+  it("updates room location", async () => {
+    prismaMock.blindBoxRoom.findUnique.mockResolvedValue(TEST_BLINDBOX_ROOM as never);
+    prismaMock.blindBoxRoom.update.mockResolvedValue({
+      ...TEST_BLINDBOX_ROOM,
+      city: "上海",
+      lat: 31.2,
+      lng: 121.4,
+    } as never);
+
+    const req = createRequest("/api/blindbox/room/ABC123", {
+      method: "PATCH",
+      body: { userId: "user-1", city: "上海", lat: 31.2, lng: 121.4 },
+    });
+    const ctx = createRouteContext({ code: "ABC123" });
+    const res = await PATCH(req, ctx);
+    const { status, data } = await parseJsonResponse(res);
+
+    expect(status).toBe(200);
+    expect(data.city).toBe("上海");
+  });
+
+  it("returns 400 for invalid coordinates", async () => {
+    prismaMock.blindBoxRoom.findUnique.mockResolvedValue(TEST_BLINDBOX_ROOM as never);
+
+    const req = createRequest("/api/blindbox/room/ABC123", {
+      method: "PATCH",
+      body: { userId: "user-1", lat: 999, lng: 121.4 },
+    });
+    const ctx = createRouteContext({ code: "ABC123" });
+    const res = await PATCH(req, ctx);
+    expect(res.status).toBe(400);
+  });
+});
+
+describe("DELETE /api/blindbox/room/[code]", () => {
+  it("deletes room when creator", async () => {
+    prismaMock.blindBoxRoom.findUnique.mockResolvedValue(TEST_BLINDBOX_ROOM as never);
+    prismaMock.blindBoxRoom.delete.mockResolvedValue({} as never);
+
+    const req = createRequest("/api/blindbox/room/ABC123", {
+      method: "DELETE",
+      body: { userId: "user-1" },
+    });
+    const ctx = createRouteContext({ code: "ABC123" });
+    const res = await DELETE(req, ctx);
+    const { data } = await parseJsonResponse(res);
+
+    expect(data.action).toBe("deleted");
+  });
+
+  it("leaves room when not creator", async () => {
+    prismaMock.blindBoxRoom.findUnique.mockResolvedValue(TEST_BLINDBOX_ROOM as never);
+    prismaMock.blindBoxMember.findUnique.mockResolvedValue({ id: "member-2" } as never);
+    prismaMock.blindBoxMember.delete.mockResolvedValue({} as never);
+
+    const req = createRequest("/api/blindbox/room/ABC123", {
+      method: "DELETE",
+      body: { userId: "user-2" },
+    });
+    const ctx = createRouteContext({ code: "ABC123" });
+    const res = await DELETE(req, ctx);
+    const { data } = await parseJsonResponse(res);
+
+    expect(data.action).toBe("left");
+  });
+
+  it("returns 403 when not a member and not creator", async () => {
+    prismaMock.blindBoxRoom.findUnique.mockResolvedValue(TEST_BLINDBOX_ROOM as never);
+    prismaMock.blindBoxMember.findUnique.mockResolvedValue(null as never);
+
+    const req = createRequest("/api/blindbox/room/ABC123", {
+      method: "DELETE",
+      body: { userId: "stranger" },
+    });
+    const ctx = createRouteContext({ code: "ABC123" });
+    const res = await DELETE(req, ctx);
+    expect(res.status).toBe(403);
+  });
+});

src/app/api/blindbox/room/join/route.test.ts

@@ -0,0 +1,64 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { prismaMock, resetPrismaMock } from "@/__tests__/helpers/prisma-mock";
+import { createRequest, parseJsonResponse } from "@/__tests__/helpers/api-test-utils";
+import { TEST_BLINDBOX_ROOM } from "@/__tests__/helpers/fixtures";
+
+import { POST } from "./route";
+
+const mockCtx = { params: Promise.resolve({}) };
+
+beforeEach(() => {
+  resetPrismaMock();
+});
+
+describe("POST /api/blindbox/room/join", () => {
+  it("joins a room by code", async () => {
+    prismaMock.blindBoxRoom.findUnique.mockResolvedValue(TEST_BLINDBOX_ROOM as never);
+    prismaMock.blindBoxMember.findUnique.mockResolvedValue(null as never);
+    prismaMock.blindBoxMember.create.mockResolvedValue({} as never);
+
+    const req = createRequest("/api/blindbox/room/join", {
+      method: "POST",
+      body: { userId: "user-2", code: "ABC123" },
+    });
+    const res = await POST(req, mockCtx);
+    const { status, data } = await parseJsonResponse(res);
+
+    expect(status).toBe(201);
+    expect(data.code).toBe("ABC123");
+  });
+
+  it("returns alreadyMember if already joined", async () => {
+    prismaMock.blindBoxRoom.findUnique.mockResolvedValue(TEST_BLINDBOX_ROOM as never);
+    prismaMock.blindBoxMember.findUnique.mockResolvedValue({ id: "member-1" } as never);
+
+    const req = createRequest("/api/blindbox/room/join", {
+      method: "POST",
+      body: { userId: "user-1", code: "ABC123" },
+    });
+    const res = await POST(req, mockCtx);
+    const { data } = await parseJsonResponse(res);
+
+    expect(data.alreadyMember).toBe(true);
+  });
+
+  it("returns 404 when room code not found", async () => {
+    prismaMock.blindBoxRoom.findUnique.mockResolvedValue(null as never);
+
+    const req = createRequest("/api/blindbox/room/join", {
+      method: "POST",
+      body: { userId: "user-1", code: "BADCODE" },
+    });
+    const res = await POST(req, mockCtx);
+    expect(res.status).toBe(404);
+  });
+
+  it("returns 400 when code is missing", async () => {
+    const req = createRequest("/api/blindbox/room/join", {
+      method: "POST",
+      body: { userId: "user-1" },
+    });
+    const res = await POST(req, mockCtx);
+    expect(res.status).toBe(400);
+  });
+});

src/app/api/blindbox/room/route.test.ts

@@ -0,0 +1,66 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { prismaMock, resetPrismaMock } from "@/__tests__/helpers/prisma-mock";
+import { createRequest, parseJsonResponse } from "@/__tests__/helpers/api-test-utils";
+import { TEST_USER, TEST_BLINDBOX_ROOM } from "@/__tests__/helpers/fixtures";
+
+vi.mock("@/lib/blindbox", () => ({
+  generateUniqueRoomCode: vi.fn().mockResolvedValue("XYZ789"),
+}));
+
+import { POST } from "./route";
+
+const mockCtx = { params: Promise.resolve({}) };
+
+beforeEach(() => {
+  resetPrismaMock();
+});
+
+describe("POST /api/blindbox/room", () => {
+  it("creates a blindbox room", async () => {
+    prismaMock.user.findUnique.mockResolvedValue(TEST_USER as never);
+    prismaMock.blindBoxRoom.create.mockResolvedValue({
+      ...TEST_BLINDBOX_ROOM,
+      code: "XYZ789",
+    } as never);
+
+    const req = createRequest("/api/blindbox/room", {
+      method: "POST",
+      body: { userId: "user-1", name: "周末计划" },
+    });
+    const res = await POST(req, mockCtx);
+    const { status, data } = await parseJsonResponse(res);
+
+    expect(status).toBe(201);
+    expect(data.code).toBe("XYZ789");
+  });
+
+  it("uses default room name when not provided", async () => {
+    prismaMock.user.findUnique.mockResolvedValue(TEST_USER as never);
+    prismaMock.blindBoxRoom.create.mockResolvedValue(TEST_BLINDBOX_ROOM as never);
+
+    const req = createRequest("/api/blindbox/room", {
+      method: "POST",
+      body: { userId: "user-1" },
+    });
+    const res = await POST(req, mockCtx);
+    expect(res.status).toBe(201);
+  });
+
+  it("returns 401 when no userId", async () => {
+    const req = createRequest("/api/blindbox/room", {
+      method: "POST",
+      body: { name: "test" },
+    });
+    const res = await POST(req, mockCtx);
+    expect(res.status).toBe(401);
+  });
+
+  it("returns 400 when room name too long", async () => {
+    const req = createRequest("/api/blindbox/room", {
+      method: "POST",
+      body: { userId: "user-1", name: "a".repeat(31) },
+    });
+    const res = await POST(req, mockCtx);
+    expect(res.status).toBe(400);
+  });
+});

src/app/api/blindbox/rooms/route.test.ts

@@ -0,0 +1,51 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { prismaMock, resetPrismaMock } from "@/__tests__/helpers/prisma-mock";
+import { createRequest, parseJsonResponse } from "@/__tests__/helpers/api-test-utils";
+
+import { GET } from "./route";
+
+const mockCtx = { params: Promise.resolve({}) };
+
+beforeEach(() => {
+  resetPrismaMock();
+});
+
+describe("GET /api/blindbox/rooms", () => {
+  it("returns user rooms list", async () => {
+    prismaMock.blindBoxMember.findMany.mockResolvedValue([
+      {
+        room: {
+          id: "bb-room-1",
+          code: "ABC123",
+          name: "周末",
+          creatorId: "user-1",
+          _count: { members: 2, ideas: 5 },
+          members: [
+            { user: { id: "user-1", username: "test", avatar: "🐱" } },
+          ],
+          ideas: [{ content: "去公园", createdAt: new Date() }],
+        },
+        joinedAt: new Date(),
+      },
+    ] as never);
+
+    prismaMock.blindBoxIdea.groupBy.mockResolvedValue([
+      { roomId: "bb-room-1", _count: 3 },
+    ] as never);
+
+    const req = createRequest("/api/blindbox/rooms?userId=user-1");
+    const res = await GET(req, mockCtx);
+    const { status, data } = await parseJsonResponse(res);
+
+    expect(status).toBe(200);
+    expect(data.rooms).toHaveLength(1);
+    expect(data.rooms[0].code).toBe("ABC123");
+    expect(data.rooms[0].poolCount).toBe(3);
+  });
+
+  it("returns 401 when no userId", async () => {
+    const req = createRequest("/api/blindbox/rooms");
+    const res = await GET(req, mockCtx);
+    expect(res.status).toBe(401);
+  });
+});

src/app/api/blindbox/route.test.ts

@@ -0,0 +1,149 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { prismaMock, resetPrismaMock } from "@/__tests__/helpers/prisma-mock";
+import { createRequest, parseJsonResponse } from "@/__tests__/helpers/api-test-utils";
+import { TEST_BLINDBOX_IDEA } from "@/__tests__/helpers/fixtures";
+
+vi.mock("@/lib/blindbox", () => ({
+  requireMembership: vi.fn().mockResolvedValue({}),
+}));
+
+vi.mock("@/lib/ai", () => ({
+  tagIdea: vi.fn().mockResolvedValue({
+    category: "outdoor",
+    timeSlot: "morning",
+    estimatedMinutes: 120,
+    outdoor: true,
+    searchQuery: "公园",
+    searchType: "category",
+  }),
+}));
+
+import { POST, GET, PUT, DELETE } from "./route";
+
+const mockCtx = { params: Promise.resolve({}) };
+
+beforeEach(() => {
+  resetPrismaMock();
+});
+
+describe("POST /api/blindbox (create idea)", () => {
+  it("creates an idea successfully", async () => {
+    prismaMock.blindBoxIdea.create.mockResolvedValue(TEST_BLINDBOX_IDEA as never);
+    prismaMock.blindBoxIdea.update.mockResolvedValue(TEST_BLINDBOX_IDEA as never);
+
+    const req = createRequest("/api/blindbox", {
+      method: "POST",
+      body: { roomId: "bb-room-1", userId: "user-1", content: "去公园野餐" },
+    });
+    const res = await POST(req, mockCtx);
+    const { status, data } = await parseJsonResponse(res);
+
+    expect(status).toBe(201);
+    expect(data.id).toBe("idea-1");
+    expect(data.tags).toBeDefined();
+  });
+
+  it("returns 401 when no userId", async () => {
+    const req = createRequest("/api/blindbox", {
+      method: "POST",
+      body: { roomId: "bb-room-1", content: "test" },
+    });
+    const res = await POST(req, mockCtx);
+    expect(res.status).toBe(401);
+  });
+
+  it("returns 400 when content is empty", async () => {
+    const req = createRequest("/api/blindbox", {
+      method: "POST",
+      body: { roomId: "bb-room-1", userId: "user-1", content: "" },
+    });
+    const res = await POST(req, mockCtx);
+    expect(res.status).toBe(400);
+  });
+
+  it("returns 400 when content over 200 chars", async () => {
+    const req = createRequest("/api/blindbox", {
+      method: "POST",
+      body: { roomId: "bb-room-1", userId: "user-1", content: "a".repeat(201) },
+    });
+    const res = await POST(req, mockCtx);
+    expect(res.status).toBe(400);
+  });
+});
+
+describe("GET /api/blindbox (get pool data)", () => {
+  it("returns pool data for valid member", async () => {
+    prismaMock.blindBoxIdea.count.mockResolvedValue(5 as never);
+    prismaMock.blindBoxIdea.findMany
+      .mockResolvedValueOnce([TEST_BLINDBOX_IDEA] as never)
+      .mockResolvedValueOnce([] as never);
+
+    const req = createRequest("/api/blindbox?userId=user-1&roomId=bb-room-1");
+    const res = await GET(req, mockCtx);
+    const { status, data } = await parseJsonResponse(res);
+
+    expect(status).toBe(200);
+    expect(data.poolCount).toBe(5);
+    expect(data.myIdeas).toHaveLength(1);
+    expect(data.drawn).toHaveLength(0);
+  });
+
+  it("returns 401 when no userId", async () => {
+    const req = createRequest("/api/blindbox?roomId=bb-room-1");
+    const res = await GET(req, mockCtx);
+    expect(res.status).toBe(401);
+  });
+});
+
+describe("PUT /api/blindbox (edit idea)", () => {
+  it("edits an idea successfully", async () => {
+    prismaMock.blindBoxIdea.updateMany.mockResolvedValue({ count: 1 } as never);
+
+    const req = createRequest("/api/blindbox", {
+      method: "PUT",
+      body: { ideaId: "idea-1", userId: "user-1", content: "去公园散步" },
+    });
+    const res = await PUT(req, mockCtx);
+    const { status, data } = await parseJsonResponse(res);
+
+    expect(status).toBe(200);
+    expect(data.content).toBe("去公园散步");
+  });
+
+  it("returns 404 when idea not found or already drawn", async () => {
+    prismaMock.blindBoxIdea.updateMany.mockResolvedValue({ count: 0 } as never);
+
+    const req = createRequest("/api/blindbox", {
+      method: "PUT",
+      body: { ideaId: "nonexistent", userId: "user-1", content: "test" },
+    });
+    const res = await PUT(req, mockCtx);
+    expect(res.status).toBe(404);
+  });
+});
+
+describe("DELETE /api/blindbox (delete idea)", () => {
+  it("deletes an idea successfully", async () => {
+    prismaMock.blindBoxIdea.deleteMany.mockResolvedValue({ count: 1 } as never);
+
+    const req = createRequest("/api/blindbox", {
+      method: "DELETE",
+      body: { ideaId: "idea-1", userId: "user-1" },
+    });
+    const res = await DELETE(req, mockCtx);
+    const { data } = await parseJsonResponse(res);
+
+    expect(data.deleted).toBe(true);
+  });
+
+  it("returns 404 when idea not found or not owned", async () => {
+    prismaMock.blindBoxIdea.deleteMany.mockResolvedValue({ count: 0 } as never);
+
+    const req = createRequest("/api/blindbox", {
+      method: "DELETE",
+      body: { ideaId: "nonexistent", userId: "user-1" },
+    });
+    const res = await DELETE(req, mockCtx);
+    expect(res.status).toBe(404);
+  });
+});

src/app/api/blindbox/suggest/route.test.ts

@@ -0,0 +1,56 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { prismaMock, resetPrismaMock } from "@/__tests__/helpers/prisma-mock";
+import { createRequest, parseJsonResponse } from "@/__tests__/helpers/api-test-utils";
+
+vi.mock("@/lib/blindbox", () => ({
+  requireMembership: vi.fn().mockResolvedValue({}),
+}));
+
+vi.mock("@/lib/ai", () => ({
+  suggestIdeas: vi.fn().mockResolvedValue(["去爬山", "骑自行车", "看日出", "野餐"]),
+}));
+
+import { GET } from "./route";
+
+const mockCtx = { params: Promise.resolve({}) };
+
+beforeEach(() => {
+  resetPrismaMock();
+});
+
+describe("GET /api/blindbox/suggest", () => {
+  it("returns AI suggestions when enough ideas exist", async () => {
+    prismaMock.blindBoxIdea.findMany.mockResolvedValue([
+      { content: "去公园" },
+      { content: "看电影" },
+      { content: "吃火锅" },
+    ] as never);
+
+    const req = createRequest("/api/blindbox/suggest?roomId=bb-room-1&userId=user-1");
+    const res = await GET(req, mockCtx);
+    const { status, data } = await parseJsonResponse(res);
+
+    expect(status).toBe(200);
+    expect(data.suggestions).toHaveLength(4);
+    expect(data.source).toBe("ai");
+  });
+
+  it("returns empty when less than 2 ideas", async () => {
+    prismaMock.blindBoxIdea.findMany.mockResolvedValue([
+      { content: "去公园" },
+    ] as never);
+
+    const req = createRequest("/api/blindbox/suggest?roomId=bb-room-1&userId=user-1");
+    const res = await GET(req, mockCtx);
+    const { data } = await parseJsonResponse(res);
+
+    expect(data.suggestions).toHaveLength(0);
+    expect(data.source).toBe("none");
+  });
+
+  it("returns 400 when roomId missing", async () => {
+    const req = createRequest("/api/blindbox/suggest?userId=user-1");
+    const res = await GET(req, mockCtx);
+    expect(res.status).toBe(400);
+  });
+});