@allbluecn/web-app 0.10.3 → 0.11.0

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

@@ -0,0 +1,265 @@
+// 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-comments 域覆盖补全：4 个 serverFn（list/create/update/delete）。
+// 关键断言：未登录拒绝且不触达评论查询；删除走级联（含回复子评论计数）；
+// 每条断言锁死 Prisma where 形状。mock 骨架同 workspace-kb-idor.test.ts 样板。
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("@tanstack/react-start", () => ({
+  createServerFn: (_config: unknown) => {
+    const api: any = {
+      _validator: undefined,
+      validator(schema: any) {
+        this._validator = schema;
+        return this;
+      },
+      handler(fn: Function) {
+        return async (args: any) => {
+          let data = args?.data;
+          if (this._validator && data !== undefined) {
+            data = this._validator.parse(data);
+          }
+          return fn({ data });
+        };
+      },
+    };
+    return api;
+  },
+}));
+vi.mock("@tanstack/react-start/server", () => ({ getRequest: () => ({}) }));
+
+const M = vi.hoisted(() => {
+  const f = () => vi.fn();
+  return {
+    requireAuth: f(),
+    storyComment: { findUnique: f(), findMany: f(), create: f(), update: f(), delete: f() },
+    storyActivity: { create: f() },
+  };
+});
+
+vi.mock("@allbluecn/database", () => ({
+  prisma: {
+    storyComment: M.storyComment,
+    storyActivity: M.storyActivity,
+  },
+  Prisma: {},
+}));
+vi.mock("@/server/auth-helpers", () => ({ requireAuth: M.requireAuth }));
+
+import {
+  createCommentFn,
+  deleteCommentFn,
+  listCommentsFn,
+  updateCommentFn,
+} from "../story/story-comments";
+import { USER_BRIEF_SELECT } from "../story/types";
+
+const USER = "u-current";
+const OTHER = "u-other";
+const STORY_ID = "st-1";
+const T1 = new Date("2026-01-01T00:00:00Z");
+const T2 = new Date("2026-01-02T00:00:00Z");
+
+const userRow = {
+  id: USER,
+  username: "alice",
+  email: "alice@example.com",
+  avatarConfig: null,
+  bgShape: null,
+  bgColor: null,
+};
+const commentRow = (over: Record<string, unknown> = {}) => ({
+  id: "c1",
+  content: "评论内容",
+  parentId: null,
+  createdAt: T1,
+  updatedAt: T1,
+  user: userRow,
+  reactions: [],
+  ...over,
+});
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  M.requireAuth.mockResolvedValue({ user: { id: USER } });
+  M.storyComment.create.mockResolvedValue(commentRow());
+  M.storyActivity.create.mockResolvedValue({});
+});
+
+describe("listCommentsFn", () => {
+  it("按 createdAt 升序取出后组装为多级回复树", async () => {
+    M.storyComment.findMany.mockResolvedValue([
+      commentRow({ id: "c1", parentId: null, reactions: [{ emoji: "👍", userId: OTHER }] }),
+      commentRow({ id: "c2", parentId: "c1" }),
+      commentRow({ id: "c3", parentId: "c2" }),
+    ]);
+
+    const res = await listCommentsFn({ data: { storyId: STORY_ID } });
+
+    expect(M.storyComment.findMany).toHaveBeenCalledWith({
+      where: { storyId: STORY_ID },
+      orderBy: { createdAt: "asc" },
+      select: {
+        id: true,
+        content: true,
+        parentId: true,
+        createdAt: true,
+        updatedAt: true,
+        user: { select: USER_BRIEF_SELECT },
+        reactions: { select: { emoji: true, userId: true } },
+      },
+    });
+    expect(res).toHaveLength(1);
+    expect(res[0].id).toBe("c1");
+    expect(res[0].parentId).toBeNull();
+    expect(res[0].createdAt).toBe(T1.toISOString());
+    expect(res[0].user.id).toBe(USER);
+    expect(res[0].reactions).toEqual([{ emoji: "👍", count: 1, userIds: [OTHER], reacted: false }]);
+    expect(res[0].replies).toHaveLength(1);
+    expect(res[0].replies[0].id).toBe("c2");
+    expect(res[0].replies[0].parentId).toBe("c1");
+    expect(res[0].replies[0].replies).toHaveLength(1);
+    expect(res[0].replies[0].replies[0].id).toBe("c3");
+    expect(res[0].replies[0].replies[0].replies).toEqual([]);
+  });
+
+  it("无评论时返回空数组", async () => {
+    M.storyComment.findMany.mockResolvedValue([]);
+    await expect(listCommentsFn({ data: { storyId: STORY_ID } })).resolves.toEqual([]);
+  });
+
+  it("未登录拒绝且不查询评论", async () => {
+    M.requireAuth.mockRejectedValue(new Error("UNAUTHORIZED"));
+    await expect(listCommentsFn({ data: { storyId: STORY_ID } })).rejects.toThrow("UNAUTHORIZED");
+    expect(M.storyComment.findMany).not.toHaveBeenCalled();
+  });
+});
+
+describe("createCommentFn", () => {
+  it("创建评论并追加 commented 活动记录", async () => {
+    const content = "x".repeat(60);
+    M.storyComment.create.mockResolvedValue(commentRow({ content, parentId: null }));
+
+    const res = await createCommentFn({ data: { storyId: STORY_ID, content, parentId: null } });
+
+    expect(M.storyComment.create).toHaveBeenCalledWith({
+      data: { storyId: STORY_ID, userId: USER, parentId: null, content },
+      select: {
+        id: true,
+        content: true,
+        parentId: true,
+        createdAt: true,
+        updatedAt: true,
+        user: { select: USER_BRIEF_SELECT },
+      },
+    });
+    expect(M.storyActivity.create).toHaveBeenCalledWith({
+      data: { storyId: STORY_ID, userId: USER, action: "commented", newValue: "x".repeat(50) },
+    });
+    expect(res.content).toBe(content);
+    expect(res.createdAt).toBe(T1.toISOString());
+    expect(res.replies).toEqual([]);
+    expect(res.reactions).toEqual([]);
+  });
+
+  it("子评论带上 parentId 写入", async () => {
+    await createCommentFn({ data: { storyId: STORY_ID, content: "回复", parentId: "c1" } });
+    expect(M.storyComment.create).toHaveBeenCalledWith(
+      expect.objectContaining({ data: expect.objectContaining({ parentId: "c1" }) }),
+    );
+  });
+
+  it("空内容被 validator 拒绝（不落库）", async () => {
+    await expect(createCommentFn({ data: { storyId: STORY_ID, content: "" } })).rejects.toThrow();
+    expect(M.storyComment.create).not.toHaveBeenCalled();
+  });
+
+  it("未登录拒绝且不创建评论", async () => {
+    M.requireAuth.mockRejectedValue(new Error("UNAUTHORIZED"));
+    await expect(
+      createCommentFn({ data: { storyId: STORY_ID, content: "hi" } }),
+    ).rejects.toThrow("UNAUTHORIZED");
+    expect(M.storyComment.create).not.toHaveBeenCalled();
+  });
+});
+
+describe("updateCommentFn", () => {
+  it("本人评论可编辑并返回新内容", async () => {
+    M.storyComment.findUnique.mockResolvedValue({ userId: USER });
+    M.storyComment.update.mockResolvedValue({ id: "c1", content: "新内容", updatedAt: T2 });
+
+    const res = await updateCommentFn({ data: { commentId: "c1", content: "新内容" } });
+
+    expect(M.storyComment.findUnique).toHaveBeenCalledWith({
+      where: { id: "c1" },
+      select: { userId: true },
+    });
+    expect(M.storyComment.update).toHaveBeenCalledWith({
+      where: { id: "c1" },
+      data: { content: "新内容" },
+      select: { id: true, content: true, updatedAt: true },
+    });
+    expect(res).toEqual({ id: "c1", content: "新内容", updatedAt: T2.toISOString() });
+  });
+
+  it("他人评论被拒且不执行更新", async () => {
+    M.storyComment.findUnique.mockResolvedValue({ userId: OTHER });
+    await expect(
+      updateCommentFn({ data: { commentId: "c1", content: "篡改" } }),
+    ).rejects.toThrow("无权编辑他人评论");
+    expect(M.storyComment.update).not.toHaveBeenCalled();
+  });
+
+  it("评论不存在时报错且不执行更新", async () => {
+    M.storyComment.findUnique.mockResolvedValue(null);
+    await expect(
+      updateCommentFn({ data: { commentId: "missing", content: "x" } }),
+    ).rejects.toThrow("评论不存在");
+    expect(M.storyComment.update).not.toHaveBeenCalled();
+  });
+});
+
+describe("deleteCommentFn", () => {
+  it("本人评论可删除", async () => {
+    M.storyComment.findUnique.mockResolvedValue({ userId: USER });
+    M.storyComment.delete.mockResolvedValue({ id: "c1" });
+
+    await expect(deleteCommentFn({ data: { commentId: "c1" } })).resolves.toEqual({ success: true });
+    expect(M.storyComment.delete).toHaveBeenCalledWith({ where: { id: "c1" } });
+  });
+
+  it("他人评论被拒且不删除", async () => {
+    M.storyComment.findUnique.mockResolvedValue({ userId: OTHER });
+    await expect(deleteCommentFn({ data: { commentId: "c1" } })).rejects.toThrow("无权删除他人评论");
+    expect(M.storyComment.delete).not.toHaveBeenCalled();
+  });
+
+  it("评论不存在时报错且不删除", async () => {
+    M.storyComment.findUnique.mockResolvedValue(null);
+    await expect(deleteCommentFn({ data: { commentId: "missing" } })).rejects.toThrow("评论不存在");
+    expect(M.storyComment.delete).not.toHaveBeenCalled();
+  });
+
+  it("未登录拒绝且不查询评论归属", async () => {
+    M.requireAuth.mockRejectedValue(new Error("UNAUTHORIZED"));
+    await expect(deleteCommentFn({ data: { commentId: "c1" } })).rejects.toThrow("UNAUTHORIZED");
+    expect(M.storyComment.findUnique).not.toHaveBeenCalled();
+    expect(M.storyComment.delete).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,266 @@
+// 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 衍生域覆盖补全：archiveStoryFn / unarchiveStoryFn / getStoryNeighborsFn /
+// getStoryDetailFn。关键断言：归档状态流转与相邻节点排序；详情查询断言 select 形状；
+// 未登录/不存在拒绝且零资源查询。mock 骨架同 workspace-kb-idor.test.ts 样板。
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("@tanstack/react-start", () => ({
+  createServerFn: (_config: unknown) => {
+    const api: any = {
+      _validator: undefined,
+      validator(schema: any) {
+        this._validator = schema;
+        return this;
+      },
+      handler(fn: Function) {
+        return async (args: any) => {
+          let data = args?.data;
+          if (this._validator && data !== undefined) {
+            data = this._validator.parse(data);
+          }
+          return fn({ data });
+        };
+      },
+    };
+    return api;
+  },
+}));
+vi.mock("@tanstack/react-start/server", () => ({ getRequest: () => ({}) }));
+
+const M = vi.hoisted(() => {
+  const f = () => vi.fn();
+  return {
+    requireAuth: f(),
+    story: { findUnique: f(), findFirst: f(), update: f() },
+    storyActivity: { create: f() },
+  };
+});
+
+vi.mock("@allbluecn/database", () => ({
+  prisma: {
+    story: M.story,
+    storyActivity: M.storyActivity,
+  },
+  Prisma: {},
+}));
+vi.mock("@/server/auth-helpers", () => ({ requireAuth: M.requireAuth }));
+
+import { archiveStoryFn, unarchiveStoryFn } from "../story/story-crud/archive";
+import { getStoryDetailFn, getStoryNeighborsFn } from "../story/story-crud/detail";
+import { STORY_LIST_SELECT } from "../story/types";
+
+const USER = "u-current";
+const STORY_ID = "st-1";
+const PROJECT_ID = "pr-1";
+const T1 = new Date("2026-01-01T00:00:00Z");
+const T2 = new Date("2026-01-02T00:00:00Z");
+
+const userRow = {
+  id: USER,
+  username: "alice",
+  email: "alice@example.com",
+  avatarConfig: null,
+  bgShape: null,
+  bgColor: null,
+};
+/** STORY_LIST_SELECT 形状的需求行 fixture（castStoryUsers 需要 createdBy/labels 等） */
+const storyRow = (over: Record<string, unknown> = {}) => ({
+  id: STORY_ID,
+  identifier: "STORY-1",
+  sequenceId: 1,
+  name: "需求A",
+  description: null,
+  state: "backlog",
+  priority: "none",
+  archived: false,
+  startDate: null,
+  targetDate: null,
+  boardOrder: 0,
+  projectId: PROJECT_ID,
+  parentId: null,
+  parent: null,
+  assignee: null,
+  createdBy: userRow,
+  updatedBy: null,
+  labels: [],
+  createdAt: T1,
+  updatedAt: T2,
+  ...over,
+});
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  M.requireAuth.mockResolvedValue({ user: { id: USER } });
+  M.story.update.mockResolvedValue(storyRow());
+  M.storyActivity.create.mockResolvedValue({});
+});
+
+describe("archiveStoryFn", () => {
+  it("归档时置 archived 并写入 archivedAt 与活动记录", async () => {
+    M.story.update.mockResolvedValue(storyRow({ archived: true, archivedAt: new Date("2026-01-03T00:00:00Z") }));
+    const res = await archiveStoryFn({ data: { storyId: STORY_ID } });
+
+    expect(M.story.update).toHaveBeenCalledWith({
+      where: { id: STORY_ID },
+      data: expect.objectContaining({ archived: true, archivedAt: expect.any(Date) }),
+      select: STORY_LIST_SELECT,
+    });
+    expect(M.storyActivity.create).toHaveBeenCalledWith({
+      data: {
+        storyId: STORY_ID,
+        userId: USER,
+        action: "archived",
+        field: "archived",
+        oldValue: "false",
+        newValue: "true",
+      },
+    });
+    expect(res).toMatchObject({
+      id: STORY_ID,
+      identifier: "STORY-1",
+      name: "需求A",
+      archived: true,
+      createdAt: T1.toISOString(),
+      updatedAt: T2.toISOString(),
+      labels: [],
+    });
+    expect(res.createdBy).toMatchObject({ id: USER, username: "alice" });
+    expect(res.startDate).toBeNull();
+  });
+
+  it("未登录拒绝且不更新不写活动", async () => {
+    M.requireAuth.mockRejectedValue(new Error("UNAUTHORIZED"));
+    await expect(archiveStoryFn({ data: { storyId: STORY_ID } })).rejects.toThrow("UNAUTHORIZED");
+    expect(M.story.update).not.toHaveBeenCalled();
+    expect(M.storyActivity.create).not.toHaveBeenCalled();
+  });
+});
+
+describe("unarchiveStoryFn", () => {
+  it("恢复时清空 archivedAt 并写入 unarchived 活动记录", async () => {
+    const res = await unarchiveStoryFn({ data: { storyId: STORY_ID } });
+
+    expect(M.story.update).toHaveBeenCalledWith({
+      where: { id: STORY_ID },
+      data: { archived: false, archivedAt: null },
+      select: STORY_LIST_SELECT,
+    });
+    expect(M.storyActivity.create).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({ action: "unarchived", oldValue: "true", newValue: "false" }),
+      }),
+    );
+    expect(res.archived).toBe(false);
+  });
+
+  it("未登录拒绝且不更新", async () => {
+    M.requireAuth.mockRejectedValue(new Error("UNAUTHORIZED"));
+    await expect(unarchiveStoryFn({ data: { storyId: STORY_ID } })).rejects.toThrow("UNAUTHORIZED");
+    expect(M.story.update).not.toHaveBeenCalled();
+  });
+});
+
+describe("getStoryNeighborsFn", () => {
+  it("需求不存在时返回双 null 且不查询相邻需求", async () => {
+    M.story.findUnique.mockResolvedValue(null);
+
+    await expect(getStoryNeighborsFn({ data: { storyId: STORY_ID } })).resolves.toEqual({
+      prevId: null,
+      nextId: null,
+    });
+    expect(M.story.findFirst).not.toHaveBeenCalled();
+  });
+
+  it("按 createdAt 分别取最新与最早作为前后邻居", async () => {
+    M.story.findUnique.mockResolvedValue({ id: STORY_ID, projectId: PROJECT_ID, createdAt: T1 });
+    M.story.findFirst.mockImplementation(({ orderBy }: { orderBy: unknown }) => {
+      const desc = JSON.stringify(orderBy).includes('"desc"');
+      return Promise.resolve(desc ? { id: "st-prev" } : { id: "st-next" });
+    });
+
+    const res = await getStoryNeighborsFn({ data: { storyId: STORY_ID } });
+
+    expect(M.story.findUnique).toHaveBeenCalledWith({
+      where: { id: STORY_ID },
+      select: { id: true, projectId: true, createdAt: true },
+    });
+    expect(M.story.findFirst).toHaveBeenCalledTimes(2);
+    expect(M.story.findFirst).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: expect.objectContaining({ projectId: PROJECT_ID, archived: false, id: { not: STORY_ID } }),
+        orderBy: [{ createdAt: "desc" }, { id: "desc" }],
+        select: { id: true },
+      }),
+    );
+    expect(res).toEqual({ prevId: "st-prev", nextId: "st-next" });
+  });
+
+  it("查询到邻居为空时对应字段为 null", async () => {
+    M.story.findUnique.mockResolvedValue({ id: STORY_ID, projectId: PROJECT_ID, createdAt: T1 });
+    M.story.findFirst.mockResolvedValue(null);
+    await expect(getStoryNeighborsFn({ data: { storyId: STORY_ID } })).resolves.toEqual({
+      prevId: null,
+      nextId: null,
+    });
+  });
+
+  it("未登录拒绝且不查询", async () => {
+    M.requireAuth.mockRejectedValue(new Error("UNAUTHORIZED"));
+    await expect(getStoryNeighborsFn({ data: { storyId: STORY_ID } })).rejects.toThrow("UNAUTHORIZED");
+    expect(M.story.findUnique).not.toHaveBeenCalled();
+  });
+});
+
+describe("getStoryDetailFn", () => {
+  it("返回序列化后的需求详情", async () => {
+    M.story.findUnique.mockResolvedValue(
+      storyRow({ name: "需求详情", startDate: T1, labels: [{ label: { id: "lb-1", name: "标签", color: "#f00" } }] }),
+    );
+
+    const res = await getStoryDetailFn({ data: { storyId: STORY_ID } });
+
+    expect(M.story.findUnique).toHaveBeenCalledWith({
+      where: { id: STORY_ID },
+      select: STORY_LIST_SELECT,
+    });
+    expect(res).toMatchObject({
+      id: STORY_ID,
+      name: "需求详情",
+      state: "backlog",
+      priority: "none",
+      startDate: T1.toISOString(),
+      targetDate: null,
+      parent: null,
+      assignee: null,
+      labels: [{ id: "lb-1", name: "标签", color: "#f00" }],
+    });
+  });
+
+  it("需求不存在时报错", async () => {
+    M.story.findUnique.mockResolvedValue(null);
+    await expect(getStoryDetailFn({ data: { storyId: "missing" } })).rejects.toThrow("需求不存在");
+  });
+
+  it("未登录拒绝且不查询详情", async () => {
+    M.requireAuth.mockRejectedValue(new Error("UNAUTHORIZED"));
+    await expect(getStoryDetailFn({ data: { storyId: STORY_ID } })).rejects.toThrow("UNAUTHORIZED");
+    expect(M.story.findUnique).not.toHaveBeenCalled();
+  });
+});