@allbluecn/web-app 0.17.1 → 0.18.0

package/src/server/serverFns/bug/__tests__/bug-groups.test.ts

@@ -0,0 +1,570 @@
+// 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/>.
+
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+vi.mock("@tanstack/react-start", () => ({
+  createServerFn: (config: any) => {
+    const api: any = {
+      _validator: undefined,
+      validator(schema: any) {
+        this._validator = schema;
+        return this;
+      },
+      handler(fn: Function) {
+        const wrapped = async (args: any) => {
+          let data = args?.data;
+          if (this._validator && data !== undefined) {
+            data = this._validator.parse ? this._validator.parse(data) : data;
+          }
+          return fn({ data });
+        };
+        return wrapped;
+      },
+    };
+    return api;
+  },
+}));
+
+vi.mock("@tanstack/react-start/server", () => ({
+  getRequest: () => ({}),
+}));
+
+const mocks = vi.hoisted(() => ({
+  currentSession: vi.fn(),
+  resolveStoryScopeProjectId: vi.fn(),
+  bugFindMany: vi.fn(),
+  bugCount: vi.fn(),
+  bugGroupBy: vi.fn(),
+  viewFindFirst: vi.fn(),
+  viewFindMany: vi.fn(),
+  viewCreate: vi.fn(),
+  viewUpdate: vi.fn(),
+  viewDelete: vi.fn(),
+  requireFeature: vi.fn(),
+  isProEdition: vi.fn(),
+}));
+
+vi.mock("@allbluecn/database", () => {
+  const prisma = {
+    bug: {
+      findMany: mocks.bugFindMany,
+      count: mocks.bugCount,
+      groupBy: mocks.bugGroupBy,
+    },
+    bugFilterView: {
+      findFirst: mocks.viewFindFirst,
+      findMany: mocks.viewFindMany,
+      create: mocks.viewCreate,
+      update: mocks.viewUpdate,
+      delete: mocks.viewDelete,
+    },
+  };
+  return { prisma, Prisma: {} };
+});
+
+vi.mock("@/server/auth-helpers", () => ({
+  requireAuth: mocks.currentSession,
+}));
+
+vi.mock("@/server/builtin-project", () => ({
+  ensureBuiltinIndependentProject: vi.fn(),
+  resolveStoryScopeProjectId: mocks.resolveStoryScopeProjectId,
+}));
+
+vi.mock("@/server/entitlements", () => ({
+  requireFeature: mocks.requireFeature,
+}));
+
+vi.mock("@/server/pro-services", () => ({
+  isProEdition: mocks.isProEdition,
+}));
+
+import { listBugGroupsFn, listBugsInGroupFn } from "../bug-groups";
+import { getBugDisplayOptionsFn, updateBugDisplayOptionsFn } from "../bug-display-options";
+import { listBugViewsFn, createBugViewFn, updateBugViewFn, deleteBugViewFn } from "../bug-views";
+import {
+  buildBugGroupFilter,
+  bugSeverityTiers,
+  compareBugsByOrderKey,
+  fetchBugsInSeverityRankOrder,
+} from "../bug-group-query";
+import {
+  BUG_DISPLAY_OPTIONS_VIEW_NAME,
+  DEFAULT_BUG_DISPLAY_OPTIONS,
+} from "@/components/bug/display/types";
+import { BUG_STATES } from "@/shared/bug/constants";
+import { BUG_LIST_SELECT } from "@/components/bug/types";
+import type { BugDisplayOptions } from "@/components/bug/display/types";
+
+const DATE = new Date("2026-01-01T00:00:00Z");
+
+function bugRow(overrides: Record<string, unknown> = {}) {
+  return {
+    id: "b1",
+    sequenceId: 1,
+    identifier: "ABC-B1",
+    title: "登录页崩溃",
+    description: null,
+    state: "open",
+    severity: "medium",
+    source: "manual",
+    env: null,
+    url: null,
+    totalCount: 1,
+    firstOccurAt: DATE,
+    lastOccurAt: DATE,
+    archived: false,
+    projectId: "p1",
+    storyId: null,
+    story: null,
+    assignee: null,
+    createdBy: { id: "u1", username: "alice", email: "a@x.com", avatarConfig: null, bgShape: null, bgColor: null },
+    updatedBy: null,
+    labels: [],
+    createdAt: DATE,
+    updatedAt: DATE,
+    ...overrides,
+  };
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  mocks.currentSession.mockResolvedValue({ user: { id: "u1" } });
+  mocks.isProEdition.mockReturnValue(false);
+});
+
+describe("listBugGroupsFn", () => {
+  it("groupBy=state + showEmptyGroups 返回五组 keys（含空组，按 BUG_STATES rank 排序）并带计数", async () => {
+    mocks.resolveStoryScopeProjectId.mockResolvedValue("p1");
+    mocks.bugGroupBy.mockResolvedValue([
+      { state: "open", _count: { _all: 3 } },
+      { state: "fixed", _count: { _all: 1 } },
+    ]);
+
+    const out = await listBugGroupsFn({ data: { projectId: "p1", groupBy: "state", showEmptyGroups: true } });
+
+    expect(mocks.bugGroupBy).toHaveBeenCalledWith(expect.objectContaining({ by: ["state"] }));
+    expect(out.groups.map((g: { key: string }) => g.key)).toEqual(BUG_STATES.map((s) => s.value));
+    expect(out.groups).toEqual([
+      { key: "open", total: 3 },
+      { key: "in_progress", total: 0 },
+      { key: "fixed", total: 1 },
+      { key: "closed", total: 0 },
+      { key: "wontfix", total: 0 },
+    ]);
+  });
+
+  it("groupBy=severity 组序按严重度 rank（critical → low），空组保留", async () => {
+    mocks.resolveStoryScopeProjectId.mockResolvedValue("p1");
+    mocks.bugGroupBy.mockResolvedValue([{ severity: "low", _count: { _all: 2 } }]);
+
+    const out = await listBugGroupsFn({ data: { projectId: "p1", groupBy: "severity", showEmptyGroups: true } });
+
+    expect(out.groups.map((g: { key: string }) => g.key)).toEqual(["critical", "high", "medium", "low"]);
+    expect(out.groups.find((g: { key: string }) => g.key === "critical")).toEqual({ key: "critical", total: 0 });
+    expect(out.groups.find((g: { key: string }) => g.key === "low")).toEqual({ key: "low", total: 2 });
+  });
+
+  it("showEmptyGroups=false 只返回非空组", async () => {
+    mocks.resolveStoryScopeProjectId.mockResolvedValue("p1");
+    mocks.bugGroupBy.mockResolvedValue([
+      { state: "open", _count: { _all: 3 } },
+      { state: "fixed", _count: { _all: 1 } },
+    ]);
+
+    const out = await listBugGroupsFn({ data: { projectId: "p1", groupBy: "state" } });
+
+    expect(out.groups).toEqual([
+      { key: "open", total: 3 },
+      { key: "fixed", total: 1 },
+    ]);
+  });
+
+  it("assignee 组 null 归并为 unassigned", async () => {
+    mocks.resolveStoryScopeProjectId.mockResolvedValue("p1");
+    mocks.bugGroupBy.mockResolvedValue([
+      { assigneeId: null, _count: { _all: 5 } },
+      { assigneeId: "u2", _count: { _all: 1 } },
+    ]);
+
+    const out = await listBugGroupsFn({ data: { projectId: "p1", groupBy: "assignee" } });
+
+    expect(out.groups).toEqual([
+      { key: "unassigned", total: 5 },
+      { key: "u2", total: 1 },
+    ]);
+  });
+
+  it("__archived__ 直达归档成员圈定，不做项目 scope 解析", async () => {
+    mocks.bugGroupBy.mockResolvedValue([]);
+
+    await listBugGroupsFn({ data: { projectId: "__archived__", groupBy: "state", showEmptyGroups: true } });
+
+    expect(mocks.resolveStoryScopeProjectId).not.toHaveBeenCalled();
+    expect(mocks.bugGroupBy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: {
+          archived: true,
+          pendingConfirm: false,
+          project: { members: { some: { userId: "u1", status: { not: "suspended" } } } },
+        },
+      }),
+    );
+  });
+});
+
+describe("listBugsInGroupFn", () => {
+  it("state 组值过滤 + skip/take 分页，orderBy=created 走 DB 排序", async () => {
+    mocks.resolveStoryScopeProjectId.mockResolvedValue("p1");
+    mocks.bugFindMany.mockResolvedValue([bugRow()]);
+    mocks.bugCount.mockResolvedValue(100);
+
+    const out = await listBugsInGroupFn({
+      data: { projectId: "p1", groupBy: "state", groupKey: "open", orderBy: "created", orderDir: "desc", skip: 50, take: 20 },
+    });
+
+    expect(mocks.bugFindMany).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: { archived: false, projectId: "p1", pendingConfirm: false, AND: [{ state: "open" }] },
+        orderBy: [{ createdAt: "desc" }, { id: "asc" }],
+        skip: 50,
+        take: 20,
+      }),
+    );
+    expect(out.items).toHaveLength(1);
+    expect(out.items[0].identifier).toBe("ABC-B1");
+    expect(out.items[0].firstOccurAt).toBe("2026-01-01T00:00:00.000Z");
+    expect(out.total).toBe(100);
+    expect(out.hasMore).toBe(true);
+  });
+
+  it("assignee 组值 unassigned → assigneeId null 过滤", async () => {
+    mocks.resolveStoryScopeProjectId.mockResolvedValue("p1");
+    mocks.bugFindMany.mockResolvedValue([]);
+    mocks.bugCount.mockResolvedValue(0);
+
+    await listBugsInGroupFn({
+      data: { projectId: "p1", groupBy: "assignee", groupKey: "unassigned" },
+    });
+
+    expect(mocks.bugFindMany).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: { archived: false, projectId: "p1", pendingConfirm: false, AND: [{ assigneeId: null }] },
+      }),
+    );
+  });
+
+  it("orderBy=severity desc 走 rank 分层查询（首层 critical，层内 id asc）", async () => {
+    mocks.resolveStoryScopeProjectId.mockResolvedValue("p1");
+    mocks.bugFindMany
+      .mockResolvedValueOnce([bugRow({ id: "b-c", severity: "critical" })])
+      .mockResolvedValue([]);
+
+    const out = await listBugsInGroupFn({
+      data: { projectId: "p1", groupBy: "severity", groupKey: "critical", orderBy: "severity", orderDir: "desc", take: 20 },
+    });
+
+    expect(mocks.bugFindMany).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({
+        where: expect.objectContaining({ severity: "critical" }),
+        orderBy: [{ id: "asc" }],
+        skip: 0,
+        take: 20,
+        select: BUG_LIST_SELECT,
+      }),
+    );
+    expect(out.items[0].severity).toBe("critical");
+  });
+
+  it("severity 分层取页向 delegate 透传 BUG_LIST_SELECT（缺 select 关联字段缺失，castBugUsers 必炸）", async () => {
+    // 空 mock 返回值：只验证 findMany 的参数契约，避免全字段 mock 行掩盖缺 select
+    const findMany = vi.fn().mockResolvedValue([]);
+    const count = vi.fn().mockResolvedValue(0);
+
+    await fetchBugsInSeverityRankOrder(
+      { findMany, count },
+      { archived: false, projectId: "p1", pendingConfirm: false },
+      0,
+      20,
+      "desc",
+    );
+
+    expect(findMany).toHaveBeenCalledTimes(4);
+    expect(findMany).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: expect.objectContaining({ severity: "critical" }),
+        orderBy: [{ id: "asc" }],
+        select: BUG_LIST_SELECT,
+      }),
+    );
+  });
+
+  it("severity desc 分层顺序与 bugSeverityTiers 一致（critical→low）", () => {
+    expect(bugSeverityTiers("desc")).toEqual(["critical", "high", "medium", "low"]);
+    expect(bugSeverityTiers("asc")).toEqual(["low", "medium", "high", "critical"]);
+  });
+
+  it("未登录时拒绝且不查询", async () => {
+    mocks.currentSession.mockRejectedValue(new Error("unauthorized"));
+    await expect(listBugsInGroupFn({ data: { projectId: "p1", groupBy: "state", groupKey: "open" } })).rejects.toThrow(
+      "unauthorized",
+    );
+    expect(mocks.bugFindMany).not.toHaveBeenCalled();
+  });
+});
+
+describe("buildBugGroupFilter 纯函数", () => {
+  it("state/severity 直传组值", () => {
+    expect(buildBugGroupFilter("state", "open")).toEqual({ state: "open" });
+    expect(buildBugGroupFilter("severity", "high")).toEqual({ severity: "high" });
+  });
+
+  it("assignee unassigned → null；具体 id → 直传", () => {
+    expect(buildBugGroupFilter("assignee", "unassigned")).toEqual({ assigneeId: null });
+    expect(buildBugGroupFilter("assignee", "u2")).toEqual({ assigneeId: "u2" });
+  });
+
+  it("createdBy 直传；none/空 groupKey 返回空对象", () => {
+    expect(buildBugGroupFilter("createdBy", "u1")).toEqual({ createdById: "u1" });
+    expect(buildBugGroupFilter("none", "anything")).toEqual({});
+    expect(buildBugGroupFilter("state", "")).toEqual({});
+  });
+});
+
+describe("compareBugsByOrderKey 纯函数", () => {
+  const row = (overrides: Partial<{ id: string; severity: string; createdAt: string; updatedAt: string }> = {}) => ({
+    id: "b1",
+    severity: "medium",
+    createdAt: "2026-01-01T00:00:00.000Z",
+    updatedAt: "2026-01-02T00:00:00.000Z",
+    ...overrides,
+  });
+
+  it("severity 按 rank 比较（critical > high > medium > low），desc 时 critical 在前", () => {
+    expect(compareBugsByOrderKey(row({ severity: "critical" }), row({ severity: "high" }), "severity", "desc")).toBeLessThan(0);
+    expect(compareBugsByOrderKey(row({ severity: "low" }), row({ severity: "critical" }), "severity", "desc")).toBeGreaterThan(0);
+    expect(compareBugsByOrderKey(row({ severity: "low" }), row({ severity: "critical" }), "severity", "asc")).toBeLessThan(0);
+  });
+
+  it("字符串 rank 序与 rank 序不同（防字典序回归）", () => {
+    // 字典序 "critical" < "medium"，但 rank 序 critical(4) > medium(2)
+    expect(compareBugsByOrderKey(row({ severity: "critical" }), row({ severity: "medium" }), "severity", "desc")).toBeLessThan(0);
+  });
+
+  it("created/updated 按 ISO 时间比较，dir 翻转符号", () => {
+    const early = row({ createdAt: "2026-01-01T00:00:00.000Z", updatedAt: "2026-01-01T00:00:00.000Z" });
+    const late = row({ createdAt: "2026-02-01T00:00:00.000Z", updatedAt: "2026-02-01T00:00:00.000Z" });
+    expect(compareBugsByOrderKey(late, early, "created", "desc")).toBeLessThan(0);
+    expect(compareBugsByOrderKey(late, early, "created", "asc")).toBeGreaterThan(0);
+    expect(compareBugsByOrderKey(early, late, "updated", "asc")).toBeLessThan(0);
+  });
+
+  it("主键相等时 id 升序 tiebreaker（与 dir 无关）", () => {
+    const a = row({ id: "a", severity: "high" });
+    const b = row({ id: "b", severity: "high" });
+    expect(compareBugsByOrderKey(a, b, "severity", "desc")).toBeLessThan(0);
+    expect(compareBugsByOrderKey(a, b, "severity", "asc")).toBeLessThan(0);
+  });
+});
+
+describe("getBugDisplayOptionsFn / updateBugDisplayOptionsFn", () => {
+  it("无存储记录时返回默认值", async () => {
+    mocks.viewFindFirst.mockResolvedValue(null);
+
+    const out = await getBugDisplayOptionsFn({ data: undefined });
+
+    expect(mocks.viewFindFirst).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: { userId: "u1", name: BUG_DISPLAY_OPTIONS_VIEW_NAME },
+      }),
+    );
+    expect(out).toEqual(DEFAULT_BUG_DISPLAY_OPTIONS);
+  });
+
+  it("存储的非法字段逐项回退默认值，合法字段保留", async () => {
+    mocks.viewFindFirst.mockResolvedValue({
+      displayOptions: { groupBy: "hack", orderBy: 42, orderDir: "sideways", properties: ["bogus", "labels"], pageSize: "many" },
+    });
+
+    const out = await getBugDisplayOptionsFn({ data: undefined });
+
+    expect(out).toEqual({
+      groupBy: "state",
+      orderBy: "created",
+      orderDir: "desc",
+      properties: ["labels"],
+      pageSize: 100,
+    });
+  });
+
+  it("update 无保留行时创建（filters 存空数组），返回更新后的完整对象", async () => {
+    mocks.viewFindFirst.mockResolvedValue(null);
+    const options: BugDisplayOptions = { groupBy: "severity", orderBy: "severity", orderDir: "asc", properties: ["state"], pageSize: 100 };
+
+    const out = await updateBugDisplayOptionsFn({ data: options });
+
+    expect(mocks.viewCreate).toHaveBeenCalledWith({
+      data: {
+        userId: "u1",
+        name: BUG_DISPLAY_OPTIONS_VIEW_NAME,
+        filters: [],
+        displayOptions: options,
+      },
+    });
+    expect(out).toEqual(options);
+  });
+
+  it("update 已有保留行时按 id 更新", async () => {
+    mocks.viewFindFirst.mockResolvedValue({ id: "v9" });
+    const options: BugDisplayOptions = { groupBy: "state", orderBy: "updated", orderDir: "asc", properties: ["state", "labels"], pageSize: 100 };
+
+    const out = await updateBugDisplayOptionsFn({ data: options });
+
+    // 与 get 路径对齐：并发双保留行时 update 也取 createdAt 首行，避免写第二行后读不到
+    expect(mocks.viewFindFirst).toHaveBeenCalledWith({
+      where: { userId: "u1", name: BUG_DISPLAY_OPTIONS_VIEW_NAME },
+      orderBy: { createdAt: "asc" },
+      select: { id: true },
+    });
+    expect(mocks.viewUpdate).toHaveBeenCalledWith({
+      where: { id: "v9" },
+      data: { displayOptions: options },
+    });
+    expect(out).toEqual(options);
+  });
+
+  it("pageSize > 200 在 OSS 环境降级为 200", async () => {
+    mocks.isProEdition.mockReturnValue(false);
+    mocks.viewFindFirst.mockResolvedValue({ id: "v9" });
+
+    const out = await updateBugDisplayOptionsFn({
+      data: { groupBy: "state", orderBy: "created", orderDir: "desc", properties: ["state"], pageSize: 500 },
+    });
+
+    expect(out.pageSize).toBe(200);
+    expect(mocks.viewUpdate).toHaveBeenCalledWith({
+      where: { id: "v9" },
+      data: { displayOptions: expect.objectContaining({ pageSize: 200 }) },
+    });
+  });
+
+  it("Pro 环境下 pageSize > 200 走 largePageSize feature gate", async () => {
+    mocks.isProEdition.mockReturnValue(true);
+    mocks.requireFeature.mockResolvedValue(undefined);
+    mocks.viewFindFirst.mockResolvedValue(null);
+
+    const out = await updateBugDisplayOptionsFn({
+      data: { groupBy: "state", orderBy: "created", orderDir: "desc", properties: ["state"], pageSize: 1000 },
+    });
+
+    expect(mocks.requireFeature).toHaveBeenCalledWith({}, "largePageSize");
+    expect(out.pageSize).toBe(1000);
+  });
+});
+
+describe("bug-views CRUD", () => {
+  const viewRow = {
+    id: "v1",
+    userId: "u1",
+    name: "我的视图",
+    projectId: null,
+    filters: [{ property: "severity", operator: "is", value: "high" }],
+    displayOptions: { groupBy: "state" },
+    createdAt: DATE,
+    updatedAt: DATE,
+  };
+
+  it("list 按 userId 圈定且排除显示选项保留行，日期转 ISO", async () => {
+    mocks.viewFindMany.mockResolvedValue([viewRow]);
+
+    const out = await listBugViewsFn({ data: undefined });
+
+    expect(mocks.viewFindMany).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: { userId: "u1", name: { not: BUG_DISPLAY_OPTIONS_VIEW_NAME } },
+      }),
+    );
+    expect(out).toEqual([
+      {
+        id: "v1",
+        name: "我的视图",
+        projectId: null,
+        filters: [{ property: "severity", operator: "is", value: "high" }],
+        displayOptions: { groupBy: "state" },
+        createdAt: "2026-01-01T00:00:00.000Z",
+        updatedAt: "2026-01-01T00:00:00.000Z",
+      },
+    ]);
+  });
+
+  it("create 拒绝系统保留名", async () => {
+    await expect(
+      createBugViewFn({
+        data: { name: BUG_DISPLAY_OPTIONS_VIEW_NAME, filters: [], displayOptions: {} },
+      }),
+    ).rejects.toThrow("保留");
+    expect(mocks.viewCreate).not.toHaveBeenCalled();
+  });
+
+  it("create 归属当前用户并返回映射结果", async () => {
+    mocks.viewCreate.mockResolvedValue(viewRow);
+
+    const out = await createBugViewFn({
+      data: { name: "我的视图", filters: [{ property: "severity", operator: "is", value: "high" }], displayOptions: { groupBy: "state" } },
+    });
+
+    expect(mocks.viewCreate).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({
+          userId: "u1",
+          name: "我的视图",
+          filters: [{ property: "severity", operator: "is", value: "high" }],
+        }),
+      }),
+    );
+    expect(out.id).toBe("v1");
+    expect(out.createdAt).toBe("2026-01-01T00:00:00.000Z");
+  });
+
+  it("update where 同时限定 id + userId（归属校验），重命名为保留名被拒", async () => {
+    mocks.viewUpdate.mockResolvedValue(viewRow);
+
+    const out = await updateBugViewFn({ data: { id: "v1", name: "改名" } });
+
+    expect(mocks.viewUpdate).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: { id: "v1", userId: "u1", name: { not: BUG_DISPLAY_OPTIONS_VIEW_NAME } },
+      }),
+    );
+    expect(out.name).toBe("我的视图");
+
+    await expect(updateBugViewFn({ data: { id: "v1", name: BUG_DISPLAY_OPTIONS_VIEW_NAME } })).rejects.toThrow("保留");
+    expect(mocks.viewUpdate).toHaveBeenCalledTimes(1);
+  });
+
+  it("delete where 限定 id + userId 且不可删保留行", async () => {
+    mocks.viewDelete.mockResolvedValue(viewRow);
+
+    await deleteBugViewFn({ data: { id: "v9" } });
+
+    expect(mocks.viewDelete).toHaveBeenCalledWith({
+      where: { id: "v9", userId: "u1", name: { not: BUG_DISPLAY_OPTIONS_VIEW_NAME } },
+    });
+  });
+});