@allbluecn/web-app 0.10.3 → 0.11.0

package/src/server/serverFns/__tests__/story-crud.test.ts

@@ -0,0 +1,526 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// AllBlue - 理想之海
+// Copyright (C) 2026 AllBlue Contributors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+
+// story-crud 核心域覆盖补全：listStoriesFn / createStoryFn / updateStoryFn / deleteStoryFn。
+// 关键断言：负责人必须是团队成员（否则拒绝且零 create）；分页 take 上限校验；活动条数与
+// 关联写入形状锁死（toHaveBeenCalledWith where/select）。createServerFn mock 用每实例
+// 独立 capture 变量，避免同模块多实例共用导致 validator 串号。骨架同 workspace-kb-idor.test.ts。
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const H = vi.hoisted(() => {
+  const fns = {
+    requireAuth: vi.fn(),
+    ensureBuiltinIndependentProject: vi.fn(),
+    resolveStoryScopeProjectId: vi.fn(),
+    isUserInTeam: vi.fn(),
+    projectFindUnique: vi.fn(),
+    storyFindUnique: vi.fn(),
+    storyFindMany: vi.fn(),
+    storyCreate: vi.fn(),
+    storyUpdate: vi.fn(),
+    storyDelete: vi.fn(),
+    storyCount: vi.fn(),
+    storyActivityCreate: vi.fn(),
+    sequenceCounterUpsert: vi.fn(),
+    userFindUnique: vi.fn(),
+    iterationFindUnique: vi.fn(),
+    transaction: vi.fn(),
+  };
+  const prisma = {
+    project: { findUnique: fns.projectFindUnique },
+    story: {
+      findUnique: fns.storyFindUnique,
+      findMany: fns.storyFindMany,
+      create: fns.storyCreate,
+      update: fns.storyUpdate,
+      delete: fns.storyDelete,
+      count: fns.storyCount,
+    },
+    storyActivity: { create: fns.storyActivityCreate },
+    sequenceCounter: { upsert: fns.sequenceCounterUpsert },
+    user: { findUnique: fns.userFindUnique },
+    iteration: { findUnique: fns.iterationFindUnique },
+    $transaction: fns.transaction,
+  };
+  return { fns, prisma };
+});
+const M = H.fns;
+const PRISMA = H.prisma;
+
+vi.mock("@tanstack/react-start", () => {
+  // 每个 serverFn 实例独立持有自己的 capture，避免同模块多实例共用导致 validator 串号
+  const createServerFn = () => {
+    const capture: { validator?: unknown; handler?: unknown } = {};
+    const api = {
+      validator: (v: unknown) => {
+        capture.validator = v;
+        return api;
+      },
+      handler: (h: unknown) => {
+        capture.handler = h;
+        return async (args: { data: unknown }) => {
+          const v = capture.validator as { parse?: (d: unknown) => unknown } | undefined;
+          const data = v && v.parse ? v.parse(args.data) : args.data;
+          return (h as (p: { data: unknown }) => Promise<unknown>)({ data });
+        };
+      },
+    };
+    return api;
+  };
+  return { createServerFn };
+});
+
+vi.mock("@tanstack/react-start/server", () => ({ getRequest: () => ({}) }));
+
+vi.mock("@allbluecn/database", () => ({ prisma: H.prisma, Prisma: {} }));
+
+vi.mock("@/server/auth-helpers", () => ({ requireAuth: H.fns.requireAuth }));
+vi.mock("@/server/builtin-project", () => ({
+  ensureBuiltinIndependentProject: H.fns.ensureBuiltinIndependentProject,
+  resolveStoryScopeProjectId: H.fns.resolveStoryScopeProjectId,
+}));
+vi.mock("@/server/team-access", () => ({ isUserInTeam: H.fns.isUserInTeam }));
+
+import { listStoriesFn, createStoryFn, updateStoryFn, deleteStoryFn } from "../story/story-crud";
+import { ACTIVITY_SELECT, STORY_LIST_SELECT } from "../story/types";
+
+const U = "u-1";
+const P = "pr-1";
+const BUILTIN_ID = "pr-builtin";
+
+const userBrief = (id: string) => ({
+  id,
+  username: `user-${id}`,
+  email: `${id}@example.com`,
+  avatarConfig: null,
+  bgShape: null,
+  bgColor: null,
+});
+
+const storyRow = (over: Record<string, unknown> = {}) => ({
+  id: "st-1",
+  identifier: "PRJ-1",
+  sequenceId: 1,
+  name: "需求A",
+  description: null,
+  state: "backlog",
+  priority: "none",
+  archived: false,
+  startDate: null,
+  targetDate: null,
+  boardOrder: 0,
+  projectId: P,
+  parentId: null,
+  parent: null,
+  assignee: null,
+  assigneeId: null,
+  iteration: null,
+  iterationId: null,
+  createdById: U,
+  createdBy: userBrief(U),
+  updatedBy: null,
+  labels: [],
+  createdAt: new Date("2026-01-01T12:00:00Z"),
+  updatedAt: new Date("2026-01-02T12:00:00Z"),
+  ...over,
+});
+
+/** $transaction(fn) 直接以 prisma 本身作为 tx 执行（让 tx.* 调用落到同一组 mock 上） */
+const txMock = async (fn: (tx: unknown) => Promise<unknown>) => fn(PRISMA);
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  M.requireAuth.mockResolvedValue({ user: { id: U } });
+  M.projectFindUnique.mockResolvedValue({ id: P, name: "项目甲", displayId: "PRJ", ownerId: "owner-1" });
+  M.sequenceCounterUpsert.mockResolvedValue({ scope: P, seq: 7 });
+  M.isUserInTeam.mockResolvedValue(true);
+  M.storyFindUnique.mockResolvedValue(storyRow());
+  M.storyFindMany.mockResolvedValue([storyRow()]);
+  M.storyCount.mockResolvedValue(2);
+  M.storyCreate.mockResolvedValue(storyRow({ identifier: "PRJ-7" }));
+  M.storyUpdate.mockResolvedValue(storyRow({ name: "需求B" }));
+  M.storyDelete.mockResolvedValue({ id: "st-1" });
+  M.storyActivityCreate.mockResolvedValue({
+    id: "act-1",
+    action: "created",
+    field: null,
+    oldValue: null,
+    newValue: null,
+    isAI: false,
+    createdAt: new Date("2026-02-01T12:00:00Z"),
+    user: userBrief(U),
+  });
+  M.userFindUnique.mockResolvedValue({ username: "user-u-2" });
+  M.iterationFindUnique.mockResolvedValue({ name: "迭代甲" });
+  M.transaction.mockImplementation(txMock);
+});
+
+describe("listStoriesFn", () => {
+  it("未登录拒绝且不发起查询", async () => {
+    M.requireAuth.mockRejectedValue(new Error("UNAUTHORIZED"));
+    await expect(listStoriesFn({ data: {} })).rejects.toThrow("UNAUTHORIZED");
+    expect(M.storyFindMany).not.toHaveBeenCalled();
+  });
+
+  it("经 resolveStoryScopeProjectId 解析作用域，分页取数并判断 hasMore", async () => {
+    M.resolveStoryScopeProjectId.mockResolvedValue(P);
+
+    const res = await listStoriesFn({ data: { projectId: P, skip: 0, take: 20 } });
+
+    expect(M.resolveStoryScopeProjectId).toHaveBeenCalledWith(P, U);
+    expect(M.storyFindMany).toHaveBeenCalledWith({
+      where: expect.objectContaining({ archived: false }),
+      orderBy: [{ createdAt: "desc" }, { id: "desc" }],
+      skip: 0,
+      take: 20,
+      select: STORY_LIST_SELECT,
+    });
+    expect(M.storyCount).toHaveBeenCalledWith({ where: expect.objectContaining({ archived: false }) });
+    expect(res.total).toBe(2);
+    expect(res.hasMore).toBe(true);
+    expect(res.items[0]).toMatchObject({ id: "st-1", name: "需求A", state: "backlog" });
+  });
+
+  it("take 超过 500 被校验拒绝", async () => {
+    await expect(listStoriesFn({ data: { take: 501 } })).rejects.toThrow();
+  });
+
+  it("无更多数据时 hasMore 为 false", async () => {
+    M.resolveStoryScopeProjectId.mockResolvedValue(P);
+    M.storyFindMany.mockResolvedValue([storyRow()]);
+    M.storyCount.mockResolvedValue(1);
+
+    const res = await listStoriesFn({ data: { skip: 0, take: 20 } });
+    expect(res.hasMore).toBe(false);
+  });
+});
+
+describe("createStoryFn", () => {
+  it("未登录拒绝", async () => {
+    M.requireAuth.mockRejectedValue(new Error("UNAUTHORIZED"));
+    await expect(createStoryFn({ data: { name: "x" } })).rejects.toThrow("UNAUTHORIZED");
+    expect(M.storyCreate).not.toHaveBeenCalled();
+  });
+
+  it("指定项目创建：序号计数器 + 活动记录", async () => {
+    M.storyCreate.mockResolvedValue(storyRow({ identifier: "PRJ-7", sequenceId: 7 }));
+
+    const res = await createStoryFn({ data: { name: "新需求", projectId: P } });
+
+    expect(M.sequenceCounterUpsert).toHaveBeenCalledWith({
+      where: { scope: P },
+      create: { scope: P, seq: 1 },
+      update: { seq: { increment: 1 } },
+    });
+    expect(M.storyCreate).toHaveBeenCalledWith({
+      data: expect.objectContaining({
+        sequenceId: 7,
+        identifier: "PRJ-7",
+        name: "新需求",
+        projectId: P,
+        createdById: U,
+        parentId: null,
+        assigneeId: null,
+      }),
+      select: STORY_LIST_SELECT,
+    });
+    expect(M.storyActivityCreate).toHaveBeenCalledWith({
+      data: { storyId: "st-1", userId: U, action: "created", isAI: false },
+    });
+    expect(res.activities).toEqual([]);
+    expect(res.identifier).toBe("PRJ-7");
+  });
+
+  it("未指定项目时兜底独立项目，使用 STORY- 前缀编号", async () => {
+    M.ensureBuiltinIndependentProject.mockResolvedValue(BUILTIN_ID);
+    M.projectFindUnique.mockResolvedValue({ id: BUILTIN_ID, name: "独立需求", displayId: "STORY", ownerId: "owner-1" });
+    M.sequenceCounterUpsert.mockResolvedValue({ scope: BUILTIN_ID, seq: 2 });
+    M.storyCreate.mockResolvedValue(storyRow({ identifier: "STORY-2" }));
+
+    const res = await createStoryFn({ data: { name: "独立需求A" } });
+
+    expect(M.ensureBuiltinIndependentProject).toHaveBeenCalledWith(U);
+    expect(M.sequenceCounterUpsert).toHaveBeenCalledWith({
+      where: { scope: BUILTIN_ID },
+      create: { scope: BUILTIN_ID, seq: 1 },
+      update: { seq: { increment: 1 } },
+    });
+    expect(res.identifier).toBe("STORY-2");
+  });
+
+  it("带标签时写入 labelIds 关联", async () => {
+    M.storyCreate.mockResolvedValue(storyRow({ identifier: "PRJ-7" }));
+
+    await createStoryFn({ data: { name: "新需求", projectId: P, labelIds: ["lb-1", "lb-2"] } });
+
+    expect(M.storyCreate).toHaveBeenCalledWith({
+      data: expect.objectContaining({ labels: { create: [{ labelId: "lb-1" }, { labelId: "lb-2" }] } }),
+      select: STORY_LIST_SELECT,
+    });
+  });
+
+  it("指定负责人时校验团队成员身份", async () => {
+    M.storyCreate.mockResolvedValue(storyRow({ identifier: "PRJ-7" }));
+
+    await createStoryFn({ data: { name: "新需求", projectId: P, assigneeId: "u-2" } });
+
+    expect(M.projectFindUnique).toHaveBeenCalledWith({ where: { id: P }, select: { ownerId: true } });
+    expect(M.isUserInTeam).toHaveBeenCalledWith("owner-1", "u-2");
+  });
+
+  it("负责人不在团队内时抛错且不创建", async () => {
+    M.isUserInTeam.mockResolvedValue(false);
+    await expect(createStoryFn({ data: { name: "新需求", projectId: P, assigneeId: "u-x" } })).rejects.toThrow(
+      "负责人必须是团队成员",
+    );
+    expect(M.storyCreate).not.toHaveBeenCalled();
+  });
+
+  it("指定不存在的父需求时抛错", async () => {
+    M.storyFindUnique.mockResolvedValue(null);
+    await expect(createStoryFn({ data: { name: "新需求", projectId: P, parentId: "st-none" } })).rejects.toThrow(
+      "父需求不存在",
+    );
+    expect(M.storyCreate).not.toHaveBeenCalled();
+  });
+
+  it("项目不存在时抛错", async () => {
+    M.projectFindUnique.mockResolvedValue(null);
+    await expect(createStoryFn({ data: { name: "新需求", projectId: P } })).rejects.toThrow("项目不存在");
+    expect(M.storyCreate).not.toHaveBeenCalled();
+  });
+
+  it("编号唯一冲突（P2002）时自动重试", async () => {
+    M.storyCreate.mockResolvedValue(storyRow({ identifier: "PRJ-8" }));
+    M.transaction.mockImplementation(
+      async (fn: (tx: unknown) => Promise<unknown>) => {
+        if (M.transaction.mock.calls.length === 1) {
+          throw Object.assign(new Error("unique conflict"), {
+            code: "P2002",
+            meta: { target: ["identifier"] },
+          });
+        }
+        return fn(PRISMA);
+      },
+    );
+
+    const res = await createStoryFn({ data: { name: "新需求", projectId: P } });
+
+    expect(M.transaction).toHaveBeenCalledTimes(2);
+    expect(res.identifier).toBe("PRJ-8");
+  });
+});
+
+describe("updateStoryFn", () => {
+  it("未登录拒绝", async () => {
+    M.requireAuth.mockRejectedValue(new Error("UNAUTHORIZED"));
+    await expect(updateStoryFn({ data: { storyId: "st-1", name: "x" } })).rejects.toThrow("UNAUTHORIZED");
+    expect(M.storyUpdate).not.toHaveBeenCalled();
+  });
+
+  it("需求不存在时抛错", async () => {
+    M.storyFindUnique.mockResolvedValue(null);
+    await expect(updateStoryFn({ data: { storyId: "st-1", name: "x" } })).rejects.toThrow("需求不存在");
+    expect(M.storyUpdate).not.toHaveBeenCalled();
+  });
+
+  it("负责人不在团队内时抛错", async () => {
+    M.isUserInTeam.mockResolvedValue(false);
+    await expect(
+      updateStoryFn({ data: { storyId: "st-1", name: "x", assigneeId: "u-x" } }),
+    ).rejects.toThrow("负责人必须是团队成员");
+  });
+
+  it("无任何字段变更时不写活动，仅更新 updatedBy", async () => {
+    const res = await updateStoryFn({ data: { storyId: "st-1", name: "需求A", state: "backlog", priority: "none" } });
+
+    expect(M.storyUpdate).toHaveBeenCalledWith({
+      where: { id: "st-1" },
+      data: { updatedBy: { connect: { id: U } } },
+      select: STORY_LIST_SELECT,
+    });
+    expect(M.storyActivityCreate).not.toHaveBeenCalled();
+    expect(res.activities).toEqual([]);
+  });
+
+  it("全字段变更：逐项生成活动并写入对应关联", async () => {
+    const existing = storyRow({
+      name: "旧名",
+      state: "todo",
+      priority: "medium",
+      assignee: userBrief("u-old"),
+      assigneeId: "u-old",
+      startDate: new Date("2026-02-01T12:00:00Z"),
+      targetDate: null,
+      description: '{"html":"<p>旧描述</p>"}',
+      parentId: "st-0",
+      parent: { id: "st-0", name: "旧父", identifier: "PRJ-0", state: "backlog" },
+      iteration: { id: "it-old", name: "旧迭代" },
+      iterationId: "it-old",
+    });
+    M.storyFindUnique.mockResolvedValueOnce(existing);
+    M.storyFindUnique.mockResolvedValue({ id: "st-new", name: "新父", identifier: "PRJ-9", state: "backlog" });
+    M.storyActivityCreate.mockImplementation(
+      ({ data }: { data: { action: string; field: string; oldValue: string; newValue: string } }) =>
+        Promise.resolve({
+          id: "act-1",
+          action: data.action,
+          field: data.field,
+          oldValue: data.oldValue,
+          newValue: data.newValue,
+          isAI: false,
+          createdAt: new Date("2026-02-01T12:00:00Z"),
+          user: userBrief(U),
+        }),
+    );
+    M.storyUpdate.mockResolvedValue(
+      storyRow({ name: "新名", state: "in_progress", priority: "high", description: '{"html":"<p>新描述</p>"}' }),
+    );
+    M.iterationFindUnique
+      .mockResolvedValueOnce({ name: "旧迭代" })
+      .mockResolvedValueOnce({ name: "新迭代" });
+
+    const res = await updateStoryFn({
+      data: {
+        storyId: "st-1",
+        name: "新名",
+        state: "in_progress",
+        priority: "high",
+        assigneeId: "u-2",
+        projectId: "pr-2",
+        startDate: "2026-03-05T12:00:00Z",
+        targetDate: "2026-04-01T12:00:00Z",
+        description: '{"html":"<p>新描述</p>"}',
+        labelIds: ["lb-9"],
+        parentId: "st-new",
+        iterationId: "it-new",
+      },
+    });
+
+    expect(M.storyUpdate).toHaveBeenCalledWith({
+      where: { id: "st-1" },
+      data: {
+        name: "新名",
+        state: "in_progress",
+        priority: "high",
+        assignee: { connect: { id: "u-2" } },
+        project: { connect: { id: "pr-2" } },
+        startDate: new Date("2026-03-05T12:00:00Z"),
+        targetDate: new Date("2026-04-01T12:00:00Z"),
+        description: '{"html":"<p>新描述</p>"}',
+        labels: { deleteMany: {}, create: [{ labelId: "lb-9" }] },
+        parent: { connect: { id: "st-new" } },
+        iteration: { connect: { id: "it-new" } },
+        updatedBy: { connect: { id: U } },
+      },
+      select: STORY_LIST_SELECT,
+    });
+    expect(M.userFindUnique).toHaveBeenCalledWith({ where: { id: "u-2" }, select: { username: true } });
+    expect(M.storyActivityCreate).toHaveBeenCalledTimes(9);
+
+    type ActivityData = { action: string; field: string };
+    const activities: ActivityData[] = M.storyActivityCreate.mock.calls.map(
+      (call) => call[0].data as ActivityData,
+    );
+    expect(activities.map((a) => [a.action, a.field])).toEqual([
+      ["name_changed", "name"],
+      ["state_changed", "state"],
+      ["priority_changed", "priority"],
+      ["assignee_changed", "assigneeId"],
+      ["startDate_changed", "startDate"],
+      ["targetDate_changed", "targetDate"],
+      ["description_changed", "description"],
+      ["parent_changed", "parentId"],
+      ["iteration_changed", "iterationId"],
+    ]);
+    expect(res.story).toMatchObject({ name: "新名", state: "in_progress" });
+    expect(res.activities).toHaveLength(9);
+    expect(res.activities[0]).toMatchObject({
+      action: "name_changed",
+      oldValue: "旧名",
+      newValue: "新名",
+      isAI: false,
+      user: expect.objectContaining({ id: U }),
+    });
+  });
+
+  it("清空负责人时断开关联", async () => {
+    M.storyFindUnique.mockResolvedValue(
+      storyRow({ assignee: userBrief("u-2"), assigneeId: "u-2", state: "in_progress" }),
+    );
+
+    await updateStoryFn({ data: { storyId: "st-1", assigneeId: null } });
+
+    expect(M.storyUpdate).toHaveBeenCalledWith({
+      where: { id: "st-1" },
+      data: expect.objectContaining({ assignee: { disconnect: true } }),
+      select: STORY_LIST_SELECT,
+    });
+    expect(M.storyActivityCreate).toHaveBeenCalledWith({
+      data: expect.objectContaining({
+        storyId: "st-1",
+        action: "assignee_changed",
+        field: "assigneeId",
+        oldValue: "user-u-2",
+        newValue: "",
+      }),
+      select: ACTIVITY_SELECT,
+    });
+  });
+
+  it("清空父需求时断开关联", async () => {
+    M.storyFindUnique.mockResolvedValue(
+      storyRow({ parentId: "st-0", parent: { id: "st-0", name: "父", identifier: "PRJ-0", state: "backlog" } }),
+    );
+
+    await updateStoryFn({ data: { storyId: "st-1", parentId: null } });
+
+    expect(M.storyUpdate).toHaveBeenCalledWith({
+      where: { id: "st-1" },
+      data: expect.objectContaining({ parent: { disconnect: true } }),
+      select: STORY_LIST_SELECT,
+    });
+    expect(M.storyActivityCreate).toHaveBeenCalledWith({
+      data: expect.objectContaining({ action: "parent_changed", newValue: "" }),
+      select: ACTIVITY_SELECT,
+    });
+  });
+
+  it("新父需求不存在时抛错且不更新", async () => {
+    M.storyFindUnique.mockImplementation(({ where }: { where: { id: string } }) =>
+      Promise.resolve(where.id === "st-1" ? storyRow() : null),
+    );
+    await expect(updateStoryFn({ data: { storyId: "st-1", parentId: "st-none" } })).rejects.toThrow(
+      "父需求不存在",
+    );
+    expect(M.storyUpdate).not.toHaveBeenCalled();
+  });
+});
+
+describe("deleteStoryFn", () => {
+  it("未登录拒绝", async () => {
+    M.requireAuth.mockRejectedValue(new Error("UNAUTHORIZED"));
+    await expect(deleteStoryFn({ data: { storyId: "st-1" } })).rejects.toThrow("UNAUTHORIZED");
+    expect(M.storyDelete).not.toHaveBeenCalled();
+  });
+
+  it("删除需求后返回成功", async () => {
+    await expect(deleteStoryFn({ data: { storyId: "st-1" } })).resolves.toEqual({ success: true });
+    expect(M.storyDelete).toHaveBeenCalledWith({ where: { id: "st-1" } });
+  });
+});