@allbluecn/web-app 0.10.2 → 0.11.0

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

@@ -0,0 +1,230 @@
+// 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-reactions 域覆盖补全：4 个 serverFn（list/add/toggleStory/toggleComment）。
+// 关键断言：未登录拒绝时全部反应查询零触达；toggle 的 up/down 幂等与计数一致性；
+// 断言 Prisma where/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(),
+    storyReaction: { findUnique: f(), findMany: f(), create: f(), delete: f() },
+    commentReaction: { findUnique: f(), findMany: f(), create: f(), delete: f() },
+  };
+});
+
+vi.mock("@allbluecn/database", () => ({
+  prisma: {
+    storyReaction: M.storyReaction,
+    commentReaction: M.commentReaction,
+  },
+  Prisma: {},
+}));
+vi.mock("@/server/auth-helpers", () => ({ requireAuth: M.requireAuth }));
+
+import {
+  addStoryReactionFn,
+  listStoryReactionsFn,
+  toggleCommentReactionFn,
+  toggleStoryReactionFn,
+} from "../story/story-reactions";
+
+const USER = "u-current";
+const OTHER = "u-other";
+const STORY_ID = "st-1";
+const COMMENT_ID = "cm-1";
+const EMOJI = "👍";
+
+const storyReactionQueries = [
+  M.storyReaction.findUnique,
+  M.storyReaction.findMany,
+  M.storyReaction.create,
+  M.storyReaction.delete,
+];
+const commentReactionQueries = [
+  M.commentReaction.findUnique,
+  M.commentReaction.findMany,
+  M.commentReaction.create,
+  M.commentReaction.delete,
+];
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  M.requireAuth.mockResolvedValue({ user: { id: USER } });
+  M.storyReaction.findMany.mockResolvedValue([]);
+  M.commentReaction.findMany.mockResolvedValue([]);
+});
+
+describe("listStoryReactionsFn", () => {
+  it("按 emoji 聚合并标记当前用户是否已点赞", async () => {
+    M.storyReaction.findMany.mockResolvedValue([
+      { emoji: "👍", userId: USER },
+      { emoji: "👍", userId: OTHER },
+      { emoji: "🎉", userId: OTHER },
+    ]);
+    const res = await listStoryReactionsFn({ data: { storyId: STORY_ID } });
+    expect(M.storyReaction.findMany).toHaveBeenCalledWith({
+      where: { storyId: STORY_ID },
+      select: { emoji: true, userId: true },
+    });
+    expect(res).toEqual([
+      { emoji: "👍", count: 2, userIds: [USER, OTHER], reacted: true },
+      { emoji: "🎉", count: 1, userIds: [OTHER], reacted: false },
+    ]);
+  });
+
+  it("无点赞数据时返回空数组", async () => {
+    const res = await listStoryReactionsFn({ data: { storyId: STORY_ID } });
+    expect(res).toEqual([]);
+  });
+
+  it("未登录拒绝且不发起任何点赞查询", async () => {
+    M.requireAuth.mockRejectedValue(new Error("UNAUTHORIZED"));
+    await expect(
+      listStoryReactionsFn({ data: { storyId: STORY_ID } }),
+    ).rejects.toThrow("UNAUTHORIZED");
+    for (const q of storyReactionQueries) expect(q).not.toHaveBeenCalled();
+  });
+});
+
+describe("addStoryReactionFn", () => {
+  it("首次点赞写入 storyReaction 并返回全量聚合", async () => {
+    M.storyReaction.findUnique.mockResolvedValue(null);
+    M.storyReaction.create.mockResolvedValue({ id: "r1" });
+    M.storyReaction.findMany.mockResolvedValue([{ emoji: EMOJI, userId: USER }]);
+
+    const res = await addStoryReactionFn({ data: { storyId: STORY_ID, emoji: EMOJI } });
+
+    expect(M.storyReaction.findUnique).toHaveBeenCalledWith({
+      where: { storyId_userId_emoji: { storyId: STORY_ID, userId: USER, emoji: EMOJI } },
+    });
+    expect(M.storyReaction.create).toHaveBeenCalledWith({
+      data: { storyId: STORY_ID, userId: USER, emoji: EMOJI },
+    });
+    expect(res).toEqual([{ emoji: EMOJI, count: 1, userIds: [USER], reacted: true }]);
+  });
+
+  it("重复点赞不重复写入（幂等），仅重算聚合", async () => {
+    M.storyReaction.findUnique.mockResolvedValue({ id: "r1" });
+    M.storyReaction.findMany.mockResolvedValue([{ emoji: EMOJI, userId: USER }]);
+
+    const res = await addStoryReactionFn({ data: { storyId: STORY_ID, emoji: EMOJI } });
+
+    expect(M.storyReaction.create).not.toHaveBeenCalled();
+    expect(res).toEqual([{ emoji: EMOJI, count: 1, userIds: [USER], reacted: true }]);
+  });
+
+  it("未登录拒绝且不写库", async () => {
+    M.requireAuth.mockRejectedValue(new Error("UNAUTHORIZED"));
+    await expect(
+      addStoryReactionFn({ data: { storyId: STORY_ID, emoji: EMOJI } }),
+    ).rejects.toThrow("UNAUTHORIZED");
+    expect(M.storyReaction.create).not.toHaveBeenCalled();
+    expect(M.storyReaction.findMany).not.toHaveBeenCalled();
+  });
+});
+
+describe("toggleStoryReactionFn", () => {
+  it("已点赞时删除记录（切换为取消）", async () => {
+    M.storyReaction.findUnique.mockResolvedValue({ id: "r9" });
+    M.storyReaction.delete.mockResolvedValue({ id: "r9" });
+    M.storyReaction.findMany.mockResolvedValue([]);
+
+    const res = await toggleStoryReactionFn({ data: { storyId: STORY_ID, emoji: EMOJI } });
+
+    expect(M.storyReaction.delete).toHaveBeenCalledWith({ where: { id: "r9" } });
+    expect(M.storyReaction.create).not.toHaveBeenCalled();
+    expect(res).toEqual([]);
+  });
+
+  it("未点赞时创建记录", async () => {
+    M.storyReaction.findUnique.mockResolvedValue(null);
+    M.storyReaction.create.mockResolvedValue({ id: "r1" });
+    M.storyReaction.findMany.mockResolvedValue([{ emoji: EMOJI, userId: USER }]);
+
+    const res = await toggleStoryReactionFn({ data: { storyId: STORY_ID, emoji: EMOJI } });
+
+    expect(M.storyReaction.create).toHaveBeenCalledWith({
+      data: { storyId: STORY_ID, userId: USER, emoji: EMOJI },
+    });
+    expect(M.storyReaction.delete).not.toHaveBeenCalled();
+    expect(res[0]?.reacted).toBe(true);
+  });
+});
+
+describe("toggleCommentReactionFn", () => {
+  it("已点赞时删除 commentReaction", async () => {
+    M.commentReaction.findUnique.mockResolvedValue({ id: "cr9" });
+    M.commentReaction.delete.mockResolvedValue({ id: "cr9" });
+
+    const res = await toggleCommentReactionFn({ data: { commentId: COMMENT_ID, emoji: EMOJI } });
+
+    expect(M.commentReaction.findUnique).toHaveBeenCalledWith({
+      where: { commentId_userId_emoji: { commentId: COMMENT_ID, userId: USER, emoji: EMOJI } },
+    });
+    expect(M.commentReaction.delete).toHaveBeenCalledWith({ where: { id: "cr9" } });
+    expect(M.commentReaction.create).not.toHaveBeenCalled();
+    expect(res).toEqual([]);
+  });
+
+  it("未点赞时创建 commentReaction", async () => {
+    M.commentReaction.findUnique.mockResolvedValue(null);
+    M.commentReaction.create.mockResolvedValue({ id: "cr1" });
+    M.commentReaction.findMany.mockResolvedValue([{ emoji: EMOJI, userId: USER }]);
+
+    const res = await toggleCommentReactionFn({ data: { commentId: COMMENT_ID, emoji: EMOJI } });
+
+    expect(M.commentReaction.create).toHaveBeenCalledWith({
+      data: { commentId: COMMENT_ID, userId: USER, emoji: EMOJI },
+    });
+    expect(res).toEqual([{ emoji: EMOJI, count: 1, userIds: [USER], reacted: true }]);
+  });
+
+  it("未登录拒绝且不查询评论点赞", async () => {
+    M.requireAuth.mockRejectedValue(new Error("UNAUTHORIZED"));
+    await expect(
+      toggleCommentReactionFn({ data: { commentId: COMMENT_ID, emoji: EMOJI } }),
+    ).rejects.toThrow("UNAUTHORIZED");
+    for (const q of commentReactionQueries) expect(q).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,317 @@
+// 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-tree 域覆盖补全：5 个 serverFn（getStoryTreeFn/addChildFn/moveChildFn/
+// removeChildFn/getChildrenCountFn）。关键断言：循环依赖拒绝且 $transaction 零回滚写入；
+// 子节点排序与父级断链；活动记录写入形状锁死。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(), findMany: f(), update: f(), count: f() },
+    storyActivity: { create: f() },
+    $transaction: f(),
+  };
+});
+
+vi.mock("@allbluecn/database", () => ({
+  prisma: {
+    story: M.story,
+    storyActivity: M.storyActivity,
+    $transaction: M.$transaction,
+  },
+  Prisma: {},
+}));
+vi.mock("@/server/auth-helpers", () => ({ requireAuth: M.requireAuth }));
+
+import {
+  addChildFn,
+  getChildrenCountFn,
+  getStoryTreeFn,
+  moveChildFn,
+  removeChildFn,
+} from "../story/story-tree";
+
+const USER = "u-current";
+const PARENT = "st-parent";
+const CHILD = "st-child";
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  M.requireAuth.mockResolvedValue({ user: { id: USER } });
+  M.story.findMany.mockResolvedValue([]);
+  M.story.count.mockResolvedValue(0);
+  M.$transaction.mockImplementation(async (arg: unknown) =>
+    Array.isArray(arg) ? Promise.all(arg) : Promise.resolve(undefined),
+  );
+});
+
+describe("getStoryTreeFn", () => {
+  const node = (id: string, parentId: string | null, children: unknown[] = []) => ({
+    id,
+    name: `需求-${id}`,
+    state: "backlog",
+    parentId,
+    children,
+  });
+
+  it("未传 rootId 时以全部顶层需求为根构建多层树", async () => {
+    M.story.findMany.mockResolvedValue([
+      node(PARENT, null, [node("st-2", PARENT, [node("st-4", "st-2")]), node("st-3", PARENT)]),
+    ]);
+    M.story.count.mockImplementation(({ where }: { where: { parentId: string } }) => {
+      const n = where.parentId === PARENT ? 2 : where.parentId === "st-2" ? 1 : 0;
+      return Promise.resolve(n);
+    });
+
+    const res = await getStoryTreeFn({ data: {} });
+
+    expect(M.story.findMany).toHaveBeenCalledWith({
+      where: { parentId: null },
+      include: expect.any(Object),
+    });
+    expect(res).toHaveLength(1);
+    const root = res[0];
+    expect(root.id).toBe(PARENT);
+    expect(root.title).toBe("需求-st-parent");
+    expect(root.depth).toBe(0);
+    expect(root.hasChildren).toBe(true);
+    expect(root.childrenCount).toBe(2);
+    expect(root.children).toBeDefined();
+    const children = root.children ?? [];
+    expect(children).toHaveLength(2);
+    expect(children[0]).toMatchObject({ id: "st-2", depth: 1, childrenCount: 1, hasChildren: true });
+    expect(children[0]?.children).toHaveLength(1);
+    expect(children[0]?.children?.[0]).toMatchObject({ id: "st-4", depth: 2, childrenCount: 0, hasChildren: false });
+    expect(children[1]).toMatchObject({ id: "st-3", depth: 1, childrenCount: 0, hasChildren: false });
+  });
+
+  it("传入 rootId 时仅以该需求为根", async () => {
+    M.story.findMany.mockResolvedValue([node("st-9", null)]);
+    const res = await getStoryTreeFn({ data: { rootId: "st-9" } });
+    expect(M.story.findMany).toHaveBeenCalledWith({
+      where: { id: "st-9" },
+      include: expect.any(Object),
+    });
+    expect(res).toEqual([
+      expect.objectContaining({ id: "st-9", parentId: null, depth: 0, childrenCount: 0 }),
+    ]);
+  });
+
+  it("无根节点时返回空数组", async () => {
+    await expect(getStoryTreeFn({ data: {} })).resolves.toEqual([]);
+  });
+
+  it("未登录拒绝且不查询需求", async () => {
+    M.requireAuth.mockRejectedValue(new Error("UNAUTHORIZED"));
+    await expect(getStoryTreeFn({ data: {} })).rejects.toThrow("UNAUTHORIZED");
+    expect(M.story.findMany).not.toHaveBeenCalled();
+    expect(M.story.count).not.toHaveBeenCalled();
+  });
+});
+
+describe("addChildFn", () => {
+  const standaloneChild = {
+    id: CHILD,
+    parentId: null,
+    identifier: "STORY-2",
+    name: "子需求",
+  };
+
+  it("子需求已有父需求时被拒，且不更新不写活动", async () => {
+    M.story.findUnique.mockImplementation(({ where }: { where: { id: string } }) =>
+      where.id === CHILD
+        ? Promise.resolve({ ...standaloneChild, parentId: PARENT })
+        : Promise.resolve(null),
+    );
+
+    await expect(
+      addChildFn({ data: { parentId: PARENT, childId: CHILD } }),
+    ).rejects.toThrow("此需求已经是某个需求的子需求");
+    expect(M.story.update).not.toHaveBeenCalled();
+    expect(M.$transaction).not.toHaveBeenCalled();
+  });
+
+  it("目标父需求是该需求的后代时拒绝（防循环依赖）", async () => {
+    M.story.findUnique.mockImplementation(({ where }: { where: { id: string } }) => {
+      if (where.id === CHILD) return Promise.resolve(standaloneChild);
+      // 从 parentId 向上走一步即回到 CHILD → 判定为后代
+      return Promise.resolve({ id: PARENT, parentId: CHILD });
+    });
+
+    await expect(
+      addChildFn({ data: { parentId: PARENT, childId: CHILD } }),
+    ).rejects.toThrow("循环依赖");
+    expect(M.story.update).not.toHaveBeenCalled();
+    expect(M.$transaction).not.toHaveBeenCalled();
+  });
+
+  it("父需求存在时更新 parentId 并在事务内写入两条活动记录", async () => {
+    M.story.findUnique.mockImplementation(({ where }: { where: { id: string } }) => {
+      if (where.id === CHILD) return Promise.resolve(standaloneChild);
+      return Promise.resolve({ id: PARENT, identifier: "STORY-1", name: "父需求", parentId: null });
+    });
+    M.storyActivity.create.mockResolvedValue({});
+    const updated = { id: CHILD, parentId: PARENT };
+    M.story.update.mockResolvedValue(updated);
+    const res = await addChildFn({ data: { parentId: PARENT, childId: CHILD } });
+
+    expect(M.story.update).toHaveBeenCalledWith({
+      where: { id: CHILD },
+      data: { parentId: PARENT },
+    });
+    expect(M.$transaction).toHaveBeenCalledWith([expect.any(Promise), expect.any(Promise)]);
+    expect(M.storyActivity.create).toHaveBeenCalledTimes(2);
+    expect(M.storyActivity.create.mock.calls[0][0].data).toMatchObject({
+      storyId: PARENT,
+      userId: USER,
+      action: "child_added",
+      newValue: "STORY-2 子需求",
+    });
+    expect(M.storyActivity.create.mock.calls[1][0].data).toMatchObject({
+      storyId: CHILD,
+      action: "parent_changed",
+      field: "parentId",
+      oldValue: "",
+      newValue: "STORY-1 父需求",
+    });
+    expect(res).toBe(updated);
+  });
+
+  it("父需求不存在时仍更新父子关系但跳过活动记录", async () => {
+    M.story.findUnique.mockImplementation(({ where }: { where: { id: string } }) =>
+      where.id === CHILD ? Promise.resolve(standaloneChild) : Promise.resolve(null),
+    );
+    const updated = { id: CHILD, parentId: PARENT };
+    M.story.update.mockResolvedValue(updated);
+
+    const res = await addChildFn({ data: { parentId: PARENT, childId: CHILD } });
+
+    expect(M.story.update).toHaveBeenCalledWith({
+      where: { id: CHILD },
+      data: { parentId: PARENT },
+    });
+    expect(M.$transaction).not.toHaveBeenCalled();
+    expect(M.storyActivity.create).not.toHaveBeenCalled();
+    expect(res).toBe(updated);
+  });
+
+  it("未登录拒绝且不更新父子关系", async () => {
+    M.requireAuth.mockRejectedValue(new Error("UNAUTHORIZED"));
+    await expect(addChildFn({ data: { parentId: PARENT, childId: CHILD } })).rejects.toThrow("UNAUTHORIZED");
+    expect(M.story.update).not.toHaveBeenCalled();
+  });
+});
+
+describe("removeChildFn", () => {
+  it("清空 parentId 使需求回到顶层", async () => {
+    const updated = { id: CHILD, parentId: null };
+    M.story.update.mockResolvedValue(updated);
+
+    const res = await removeChildFn({ data: { childId: CHILD } });
+
+    expect(M.story.update).toHaveBeenCalledWith({ where: { id: CHILD }, data: { parentId: null } });
+    expect(res).toBe(updated);
+  });
+
+  it("未登录拒绝且不更新", async () => {
+    M.requireAuth.mockRejectedValue(new Error("UNAUTHORIZED"));
+    await expect(removeChildFn({ data: { childId: CHILD } })).rejects.toThrow("UNAUTHORIZED");
+    expect(M.story.update).not.toHaveBeenCalled();
+  });
+});
+
+describe("moveChildFn", () => {
+  it("新父需求是该需求的后代时拒绝（防循环依赖）", async () => {
+    M.story.findUnique.mockResolvedValue({ id: "new-parent", parentId: CHILD });
+
+    await expect(
+      moveChildFn({ data: { childId: CHILD, newParentId: "new-parent" } }),
+    ).rejects.toThrow("循环依赖");
+    expect(M.story.update).not.toHaveBeenCalled();
+  });
+
+  it("移动通过时更新为新父需求", async () => {
+    M.story.findUnique.mockResolvedValue({ id: "new-parent", parentId: null });
+    const updated = { id: CHILD, parentId: "new-parent" };
+    M.story.update.mockResolvedValue(updated);
+
+    const res = await moveChildFn({ data: { childId: CHILD, newParentId: "new-parent" } });
+
+    expect(M.story.update).toHaveBeenCalledWith({
+      where: { id: CHILD },
+      data: { parentId: "new-parent" },
+    });
+    expect(res).toBe(updated);
+  });
+
+  it("未登录拒绝且不更新", async () => {
+    M.requireAuth.mockRejectedValue(new Error("UNAUTHORIZED"));
+    await expect(
+      moveChildFn({ data: { childId: CHILD, newParentId: "new-parent" } }),
+    ).rejects.toThrow("UNAUTHORIZED");
+    expect(M.story.update).not.toHaveBeenCalled();
+  });
+});
+
+describe("getChildrenCountFn", () => {
+  it("返回该父需求下的子需求数量", async () => {
+    M.story.count.mockResolvedValue(3);
+
+    const res = await getChildrenCountFn({ data: { parentId: PARENT } });
+
+    expect(M.story.count).toHaveBeenCalledWith({ where: { parentId: PARENT } });
+    expect(res).toEqual({ count: 3 });
+  });
+
+  it("无子需求时返回 0", async () => {
+    M.story.count.mockResolvedValue(0);
+    await expect(getChildrenCountFn({ data: { parentId: PARENT } })).resolves.toEqual({ count: 0 });
+  });
+
+  it("未登录拒绝且不查询计数", async () => {
+    M.requireAuth.mockRejectedValue(new Error("UNAUTHORIZED"));
+    await expect(getChildrenCountFn({ data: { parentId: PARENT } })).rejects.toThrow("UNAUTHORIZED");
+    expect(M.story.count).not.toHaveBeenCalled();
+  });
+});