@allbluecn/web-app 0.17.2 → 0.18.0

package/src/server/serverFns/testcase/__tests__/schemas.test.ts

@@ -0,0 +1,145 @@
+// 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 } from "vitest";
+import {
+  TestCaseStepsSchema,
+  RunCaseStatusSchema,
+  CreateTestCaseInputSchema,
+  UpdateTestCaseInputSchema,
+} from "../schemas";
+import {
+  RUN_CASE_STATUS_VALUES,
+  TEST_CASE_STATE_VALUES,
+  TEST_CASE_IDENTIFIER_PREFIX,
+} from "../constants";
+
+describe("TestCaseStepsSchema", () => {
+  it("接受单步骤（含 expected）", () => {
+    expect(
+      TestCaseStepsSchema.parse({
+        steps: [{ order: 1, action: "登录", expected: "进入首页" }],
+      }),
+    ).toEqual({ steps: [{ order: 1, action: "登录", expected: "进入首页" }] });
+  });
+
+  it("接受省略 expected 的步骤（expected 可选）", () => {
+    expect(TestCaseStepsSchema.parse({ steps: [{ order: 1, action: "打开设置页" }] })).toEqual({
+      steps: [{ order: 1, action: "打开设置页" }],
+    });
+  });
+
+  it("拒绝空 steps 数组（至少 1 步——空产物不得污染库）", () => {
+    expect(() => TestCaseStepsSchema.parse({ steps: [] })).toThrow();
+  });
+
+  it("拒绝 order 重复", () => {
+    expect(() =>
+      TestCaseStepsSchema.parse({
+        steps: [
+          { order: 1, action: "第一步" },
+          { order: 1, action: "第二步" },
+        ],
+      }),
+    ).toThrow();
+  });
+
+  it("拒绝 action 空串", () => {
+    expect(() => TestCaseStepsSchema.parse({ steps: [{ order: 1, action: "" }] })).toThrow();
+  });
+});
+
+describe("RunCaseStatusSchema（规格 §11 六态）", () => {
+  it("值域与规格 §11 完全一致", () => {
+    expect([...RUN_CASE_STATUS_VALUES]).toEqual([
+      "untested",
+      "passed",
+      "failed",
+      "blocked",
+      "skipped",
+      "retest",
+    ]);
+  });
+
+  it("六态逐一可解析，域外值拒绝", () => {
+    for (const status of RUN_CASE_STATUS_VALUES) {
+      expect(RunCaseStatusSchema.parse(status)).toBe(status);
+    }
+    expect(() => RunCaseStatusSchema.parse("pending")).toThrow();
+  });
+});
+
+describe("TEST_CASE_STATE_VALUES（四态——规格 §3.1/§11 权威口径）", () => {
+  it("draft|in_review|approved|deprecated 恰四态（控制者裁定「五态」为笔误）", () => {
+    expect([...TEST_CASE_STATE_VALUES]).toEqual(["draft", "in_review", "approved", "deprecated"]);
+  });
+});
+
+describe("CreateTestCaseInputSchema", () => {
+  it("最小输入应用默认值：state=approved（手建）、priority=p1、type=functional、automation=none", () => {
+    const parsed = CreateTestCaseInputSchema.parse({
+      projectId: "p1",
+      title: "登录成功跳转首页",
+      steps: { steps: [{ order: 1, action: "登录", expected: "进入首页" }] },
+    });
+    expect(parsed.state).toBe("approved");
+    expect(parsed.priority).toBe("p1");
+    expect(parsed.type).toBe("functional");
+    expect(parsed.automation).toBe("none");
+  });
+
+  it("拒绝空标题", () => {
+    expect(() =>
+      CreateTestCaseInputSchema.parse({
+        projectId: "p1",
+        title: "",
+        steps: { steps: [{ order: 1, action: "打开首页" }] },
+      }),
+    ).toThrow();
+  });
+
+  it("steps 字段走 TestCaseStepsSchema（order 重复拒绝）", () => {
+    expect(() =>
+      CreateTestCaseInputSchema.parse({
+        projectId: "p1",
+        title: "t",
+        steps: {
+          steps: [
+            { order: 1, action: "a" },
+            { order: 1, action: "b" },
+          ],
+        },
+      }),
+    ).toThrow();
+  });
+});
+
+describe("UpdateTestCaseInputSchema", () => {
+  it("仅 id 也可解析（其余字段全部可选）", () => {
+    expect(UpdateTestCaseInputSchema.parse({ id: "c1" })).toEqual({ id: "c1" });
+  });
+
+  it("steps 变更走同一 TestCaseStepsSchema 校验（空 steps 拒绝）", () => {
+    expect(() => UpdateTestCaseInputSchema.parse({ id: "c1", steps: { steps: [] } })).toThrow();
+  });
+});
+
+describe("TEST_CASE_IDENTIFIER_PREFIX（规格 §3.1）", () => {
+  it("标识符前缀为 -TC", () => {
+    expect(TEST_CASE_IDENTIFIER_PREFIX).toBe("-TC");
+  });
+});

package/src/server/serverFns/testcase/__tests__/stats.test.ts

@@ -0,0 +1,553 @@
+// 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/>.
+
+// 任务 23：需求变更过期提示 + 生成采纳率统计（照 runs.test.ts 样板）。断言面（简报步骤 1）：
+// ① getStoryStalenessFn：story.updatedAt 晚于关联用例 max(createdAt) → stale=true；
+//    未变更/零关联用例 → stale=false（零用例 latestCaseCreatedAt=null）
+// ② 归档用例不参与过期判定（archived: false 与 listTestCasesFn 面板口径一致）
+// ③ listGenerationStatsFn：按 storyId 过滤批次（createdAt desc），各批次返回
+//    draftCount/adoptedCount/adoptionRate——draftCount>0 时 round(采纳/草稿*100)，
+//    draftCount=0 时 null（0/0 无意义，不显示 0% 误导）
+// ④ 权限：story 不存在 / 项目成员 suspended 视同无权限（口径同 runs.ts/plans.ts）
+//
+// 任务 36 扩展（报告与项目统计，简报步骤 1 断言面）：
+// ⑤ getProjectTestStatsFn 四指标聚合 SQL 形状（prisma mock）：
+//    - 通过率趋势：近 30 天 completed 批次 findMany（createdAt asc，summary.passRate 透传）
+//    - 生成采纳率：TestGenerationRun aggregate _sum（adopted/draft，0 草稿 null）
+//    - 自动化覆盖率：TestCase groupBy automation（archived=false，automation≠none/total）
+//    - flaky 率：TestRunCase groupBy flaky（经 run.projectId 圈项目）
+// ⑥ listRunFailuresFn 归因分组失败清单数据面：failed 全收 + blocked 仅 triage 翻转件
+//    （env_issue 翻转后仍需呈现）；triage 脏数据（category 非法）降级 null
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const H = vi.hoisted(() => {
+  const fns = {
+    requireAuth: vi.fn(),
+    resolveStoryScopeProjectId: vi.fn(),
+  };
+  const db = {
+    storyFindUnique: vi.fn(),
+    caseFindFirst: vi.fn(),
+    runFindMany: vi.fn(),
+    memberFindUnique: vi.fn(),
+    trendFindMany: vi.fn(),
+    genAggregate: vi.fn(),
+    caseGroupBy: vi.fn(),
+    runCaseGroupBy: vi.fn(),
+    failRunFindUnique: vi.fn(),
+    failCasesFindMany: vi.fn(),
+  };
+  const prisma = {
+    story: { findUnique: db.storyFindUnique },
+    testCase: { findFirst: db.caseFindFirst, groupBy: db.caseGroupBy },
+    testGenerationRun: { findMany: db.runFindMany, aggregate: db.genAggregate },
+    testRun: { findMany: db.trendFindMany, findUnique: db.failRunFindUnique },
+    testRunCase: { groupBy: db.runCaseGroupBy, findMany: db.failCasesFindMany },
+    projectMember: { findUnique: db.memberFindUnique },
+  };
+  return { fns, db, prisma };
+});
+const M = H.fns;
+const DB = H.db;
+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/get-prisma", () => ({
+  getPrisma: async () => PRISMA,
+}));
+
+vi.mock("@/server/auth-helpers", () => ({ requireAuth: H.fns.requireAuth }));
+vi.mock("@/server/builtin-project", () => ({
+  resolveStoryScopeProjectId: H.fns.resolveStoryScopeProjectId,
+}));
+
+import {
+  getProjectTestStatsFn,
+  getStoryStalenessFn,
+  listGenerationStatsFn,
+  listRunFailuresFn,
+} from "../stats";
+
+const U = "u-1";
+const P = "pr-1";
+const S = "story-1";
+const STORY_UPDATED_AT = new Date("2026-10-05T12:00:00Z");
+
+const storyRow = (over: Record<string, unknown> = {}) => ({
+  id: S,
+  projectId: P,
+  updatedAt: STORY_UPDATED_AT,
+  ...over,
+});
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  M.requireAuth.mockResolvedValue({ user: { id: U } });
+  M.resolveStoryScopeProjectId.mockResolvedValue(P);
+  DB.memberFindUnique.mockResolvedValue({ status: "active" });
+  DB.storyFindUnique.mockResolvedValue(storyRow());
+});
+
+describe("getStoryStalenessFn 需求变更过期判定", () => {
+  it("story.updatedAt 晚于最新关联用例 createdAt → stale=true", async () => {
+    // 最新用例 10-01 生成，需求 10-05 又改过 → 过期
+    DB.caseFindFirst.mockResolvedValue({ createdAt: new Date("2026-10-01T00:00:00Z") });
+
+    const res = (await getStoryStalenessFn({ data: { storyId: S } })) as {
+      stale: boolean;
+      storyUpdatedAt: string;
+      latestCaseCreatedAt: string | null;
+    };
+
+    expect(res.stale).toBe(true);
+    expect(res.storyUpdatedAt).toBe(STORY_UPDATED_AT.toISOString());
+    expect(res.latestCaseCreatedAt).toBe("2026-10-01T00:00:00.000Z");
+  });
+
+  it("最新用例 createdAt 晚于 story.updatedAt → stale=false（生成后再改的是用例）", async () => {
+    DB.caseFindFirst.mockResolvedValue({ createdAt: new Date("2026-10-06T00:00:00Z") });
+
+    const res = (await getStoryStalenessFn({ data: { storyId: S } })) as { stale: boolean };
+    expect(res.stale).toBe(false);
+  });
+
+  it("零关联用例 → stale=false 且 latestCaseCreatedAt=null（无可过期对象）", async () => {
+    DB.caseFindFirst.mockResolvedValue(null);
+
+    const res = (await getStoryStalenessFn({ data: { storyId: S } })) as {
+      stale: boolean;
+      latestCaseCreatedAt: string | null;
+    };
+    expect(res.stale).toBe(false);
+    expect(res.latestCaseCreatedAt).toBeNull();
+  });
+
+  it("归档用例不参与判定：查询过滤 archived=false（与面板列表口径一致）", async () => {
+    DB.caseFindFirst.mockResolvedValue(null);
+    await getStoryStalenessFn({ data: { storyId: S } });
+
+    expect(DB.caseFindFirst).toHaveBeenCalledTimes(1);
+    const args = DB.caseFindFirst.mock.calls[0][0] as {
+      where: { storyId: string; archived: boolean };
+      orderBy: { createdAt: string };
+    };
+    expect(args.where).toEqual({ storyId: S, archived: false });
+    expect(args.orderBy).toEqual({ createdAt: "desc" });
+  });
+
+  it("story 不存在 → 抛错", async () => {
+    DB.storyFindUnique.mockResolvedValue(null);
+    await expect(getStoryStalenessFn({ data: { storyId: "ghost" } })).rejects.toThrow(
+      "需求不存在",
+    );
+  });
+
+  it("非成员（suspended）→ 抛错拒绝", async () => {
+    DB.memberFindUnique.mockResolvedValue({ status: "suspended" });
+    DB.caseFindFirst.mockResolvedValue(null);
+    await expect(getStoryStalenessFn({ data: { storyId: S } })).rejects.toThrow("无权限");
+  });
+});
+
+describe("listGenerationStatsFn 生成采纳率统计", () => {
+  const runRow = (over: Record<string, unknown> = {}) => ({
+    id: "run-1",
+    status: "completed",
+    draftCount: 4,
+    adoptedCount: 3,
+    createdAt: new Date("2026-10-05T00:00:00Z"),
+    completedAt: new Date("2026-10-05T00:01:00Z"),
+    ...over,
+  });
+
+  it("各批次返回 draftCount/adoptedCount/adoptionRate（75% = 3/4）", async () => {
+    DB.runFindMany.mockResolvedValue([runRow()]);
+
+    const res = (await listGenerationStatsFn({ data: { storyId: S } })) as {
+      items: Array<{
+        id: string;
+        status: string;
+        draftCount: number;
+        adoptedCount: number;
+        adoptionRate: number | null;
+        createdAt: string;
+        completedAt: string | null;
+      }>;
+    };
+
+    expect(res.items).toHaveLength(1);
+    expect(res.items[0]).toEqual({
+      id: "run-1",
+      status: "completed",
+      draftCount: 4,
+      adoptedCount: 3,
+      adoptionRate: 75,
+      createdAt: "2026-10-05T00:00:00.000Z",
+      completedAt: "2026-10-05T00:01:00.000Z",
+    });
+  });
+
+  it("adoptionRate 四舍五入到整数百分比（1/3 → 33）", async () => {
+    DB.runFindMany.mockResolvedValue([runRow({ draftCount: 3, adoptedCount: 1 })]);
+
+    const res = (await listGenerationStatsFn({ data: { storyId: S } })) as {
+      items: Array<{ adoptionRate: number | null }>;
+    };
+    expect(res.items[0].adoptionRate).toBe(33);
+  });
+
+  it("draftCount=0 → adoptionRate=null（0/0 无意义）", async () => {
+    DB.runFindMany.mockResolvedValue([runRow({ draftCount: 0, adoptedCount: 0 })]);
+
+    const res = (await listGenerationStatsFn({ data: { storyId: S } })) as {
+      items: Array<{ adoptionRate: number | null }>;
+    };
+    expect(res.items[0].adoptionRate).toBeNull();
+  });
+
+  it("按 storyId 过滤批次且 createdAt 倒序", async () => {
+    DB.runFindMany.mockResolvedValue([]);
+    await listGenerationStatsFn({ data: { storyId: S } });
+
+    const args = DB.runFindMany.mock.calls[0][0] as {
+      where: { storyId: string };
+      orderBy: Array<Record<string, string>>;
+    };
+    expect(args.where).toEqual({ storyId: S });
+    expect(args.orderBy).toEqual([{ createdAt: "desc" }]);
+  });
+
+  it("story 不存在 → 抛错", async () => {
+    DB.storyFindUnique.mockResolvedValue(null);
+    await expect(listGenerationStatsFn({ data: { storyId: "ghost" } })).rejects.toThrow(
+      "需求不存在",
+    );
+  });
+
+  it("非成员（suspended）→ 抛错拒绝", async () => {
+    DB.memberFindUnique.mockResolvedValue({ status: "suspended" });
+    DB.runFindMany.mockResolvedValue([]);
+    await expect(listGenerationStatsFn({ data: { storyId: S } })).rejects.toThrow("无权限");
+  });
+});
+
+describe("getProjectTestStatsFn 项目统计四指标", () => {
+  const DAY = 24 * 60 * 60 * 1000;
+
+  it("通过率趋势：近 30 天 completed 批次（createdAt asc），passRate 从 summary 透传", async () => {
+    DB.trendFindMany.mockResolvedValue([
+      {
+        id: "run-1",
+        name: "批次一",
+        summary: { passRate: 0.75 },
+        createdAt: new Date("2026-10-01T00:00:00Z"),
+      },
+      {
+        id: "run-2",
+        name: "批次二",
+        summary: { passRate: 0.5 },
+        createdAt: new Date("2026-10-03T00:00:00Z"),
+      },
+    ]);
+    DB.genAggregate.mockResolvedValue({ _sum: { draftCount: 0, adoptedCount: 0 } });
+    DB.caseGroupBy.mockResolvedValue([]);
+    DB.runCaseGroupBy.mockResolvedValue([]);
+
+    const res = (await getProjectTestStatsFn({ data: {} })) as {
+      passRateTrend: Array<{ runId: string; name: string; passRate: number; createdAt: string }>;
+    };
+
+    expect(DB.trendFindMany).toHaveBeenCalledTimes(1);
+    const args = DB.trendFindMany.mock.calls[0][0] as {
+      where: {
+        projectId: string;
+        status: string;
+        createdAt: { gte: Date };
+      };
+      orderBy: Array<Record<string, string>>;
+      select: Record<string, boolean>;
+    };
+    expect(args.where.projectId).toBe(P);
+    expect(args.where.status).toBe("completed");
+    // 趋势窗口 = 近 30 天（TREND_DAYS）：gte 为 Date 且落在 [now-31d, now]
+    const gte = args.where.createdAt.gte;
+    expect(gte).toBeInstanceOf(Date);
+    expect(gte.getTime()).toBeLessThanOrEqual(Date.now());
+    expect(Date.now() - gte.getTime()).toBeLessThanOrEqual(31 * DAY + 60_000);
+    expect(args.orderBy).toEqual([{ createdAt: "asc" }]);
+    expect(args.select).toMatchObject({ id: true, name: true, summary: true, createdAt: true });
+
+    expect(res.passRateTrend).toHaveLength(2);
+    expect(res.passRateTrend[0]).toEqual({
+      runId: "run-1",
+      name: "批次一",
+      passRate: 0.75,
+      createdAt: "2026-10-01T00:00:00.000Z",
+    });
+    expect(res.passRateTrend[1]!.passRate).toBe(0.5);
+  });
+
+  it("scope 解析走 resolveStoryScopeProjectId（未传 projectId 回退内置独立项目）", async () => {
+    DB.trendFindMany.mockResolvedValue([]);
+    DB.genAggregate.mockResolvedValue({ _sum: { draftCount: 0, adoptedCount: 0 } });
+    DB.caseGroupBy.mockResolvedValue([]);
+    DB.runCaseGroupBy.mockResolvedValue([]);
+
+    await getProjectTestStatsFn({ data: {} });
+
+    expect(M.resolveStoryScopeProjectId).toHaveBeenCalledWith(undefined, U);
+  });
+
+  it("生成采纳率：aggregate _sum 聚合（adopted/draft 整数百分比；0 草稿 null）", async () => {
+    DB.trendFindMany.mockResolvedValue([]);
+    DB.caseGroupBy.mockResolvedValue([]);
+    DB.runCaseGroupBy.mockResolvedValue([]);
+
+    DB.genAggregate.mockResolvedValue({ _sum: { draftCount: 6, adoptedCount: 3 } });
+    let res = (await getProjectTestStatsFn({ data: {} })) as {
+      generation: { draftCount: number; adoptedCount: number; adoptionRate: number | null };
+    };
+    expect(DB.genAggregate).toHaveBeenCalledWith({
+      where: { projectId: P },
+      _sum: { draftCount: true, adoptedCount: true },
+    });
+    expect(res.generation).toEqual({ draftCount: 6, adoptedCount: 3, adoptionRate: 50 });
+
+    DB.genAggregate.mockResolvedValue({ _sum: { draftCount: 0, adoptedCount: 0 } });
+    res = (await getProjectTestStatsFn({ data: {} })) as typeof res;
+    expect(res.generation.adoptionRate).toBeNull();
+  });
+
+  it("自动化覆盖率：groupBy automation（archived=false），非 none 计数/总数", async () => {
+    DB.trendFindMany.mockResolvedValue([]);
+    DB.genAggregate.mockResolvedValue({ _sum: { draftCount: 0, adoptedCount: 0 } });
+    DB.runCaseGroupBy.mockResolvedValue([]);
+    DB.caseGroupBy.mockResolvedValue([
+      { automation: "none", _count: { _all: 2 } },
+      { automation: "e2e", _count: { _all: 1 } },
+      { automation: "both", _count: { _all: 1 } },
+    ]);
+
+    const res = (await getProjectTestStatsFn({ data: {} })) as {
+      automationCoverage: { count: number; total: number; rate: number | null };
+    };
+
+    expect(DB.caseGroupBy).toHaveBeenCalledWith({
+      by: ["automation"],
+      where: { projectId: P, archived: false },
+      _count: { _all: true },
+    });
+    expect(res.automationCoverage).toEqual({ count: 2, total: 4, rate: 50 });
+  });
+
+  it("自动化覆盖率：零用例 → rate=null（0/0 无意义）", async () => {
+    DB.trendFindMany.mockResolvedValue([]);
+    DB.genAggregate.mockResolvedValue({ _sum: { draftCount: 0, adoptedCount: 0 } });
+    DB.runCaseGroupBy.mockResolvedValue([]);
+    DB.caseGroupBy.mockResolvedValue([]);
+
+    const res = (await getProjectTestStatsFn({ data: {} })) as {
+      automationCoverage: { count: number; total: number; rate: number | null };
+    };
+    expect(res.automationCoverage).toEqual({ count: 0, total: 0, rate: null });
+  });
+
+  it("flaky 率：TestRunCase groupBy flaky（经 run.projectId 圈项目），true 计数/总数", async () => {
+    DB.trendFindMany.mockResolvedValue([]);
+    DB.genAggregate.mockResolvedValue({ _sum: { draftCount: 0, adoptedCount: 0 } });
+    DB.caseGroupBy.mockResolvedValue([]);
+    DB.runCaseGroupBy.mockResolvedValue([
+      { flaky: true, _count: { _all: 1 } },
+      { flaky: false, _count: { _all: 3 } },
+    ]);
+
+    const res = (await getProjectTestStatsFn({ data: {} })) as {
+      flakyRate: { count: number; total: number; rate: number | null };
+    };
+
+    expect(DB.runCaseGroupBy).toHaveBeenCalledWith({
+      by: ["flaky"],
+      where: { run: { projectId: P } },
+      _count: { _all: true },
+    });
+    expect(res.flakyRate).toEqual({ count: 1, total: 4, rate: 25 });
+  });
+
+  it("flaky 率：零 RunCase → rate=null", async () => {
+    DB.trendFindMany.mockResolvedValue([]);
+    DB.genAggregate.mockResolvedValue({ _sum: { draftCount: 0, adoptedCount: 0 } });
+    DB.caseGroupBy.mockResolvedValue([]);
+    DB.runCaseGroupBy.mockResolvedValue([]);
+
+    const res = (await getProjectTestStatsFn({ data: {} })) as {
+      flakyRate: { count: number; total: number; rate: number | null };
+    };
+    expect(res.flakyRate).toEqual({ count: 0, total: 0, rate: null });
+  });
+});
+
+describe("listRunFailuresFn 归因分组失败清单", () => {
+  const triage = (category: string, confidence = 0.9) => ({
+    category,
+    evidence: [`${category} 证据`],
+    confidence,
+  });
+
+  const failureRow = (over: Record<string, unknown> = {}) => ({
+    id: "rc-1",
+    status: "failed",
+    caseSnapshot: { title: "用例一" },
+    bugId: null,
+    flaky: false,
+    execRunId: "e-1",
+    execRun: { report: { perStep: [], triage: triage("api_error") } },
+    case: { identifier: "STORY-TC1" },
+    ...over,
+  });
+
+  it("批次不存在 → 抛错", async () => {
+    DB.failRunFindUnique.mockResolvedValue(null);
+    await expect(listRunFailuresFn({ data: { id: "ghost" } })).rejects.toThrow("执行批次不存在");
+  });
+
+  it("非成员（suspended）→ 抛错拒绝", async () => {
+    DB.failRunFindUnique.mockResolvedValue({ id: "run-1", projectId: P });
+    DB.memberFindUnique.mockResolvedValue({ status: "suspended" });
+    await expect(listRunFailuresFn({ data: { id: "run-1" } })).rejects.toThrow("无权限");
+  });
+
+  it("查询形状：failed+blocked 圈定、id 升序、execRun 只取 report", async () => {
+    DB.failRunFindUnique.mockResolvedValue({ id: "run-1", projectId: P });
+    DB.failCasesFindMany.mockResolvedValue([]);
+    await listRunFailuresFn({ data: { id: "run-1" } });
+
+    expect(DB.failRunFindUnique).toHaveBeenCalledWith({
+      where: { id: "run-1" },
+      select: { id: true, projectId: true },
+    });
+    const args = DB.failCasesFindMany.mock.calls[0][0] as {
+      where: { runId: string; status: { in: string[] } };
+      orderBy: Record<string, string>;
+      select: Record<string, unknown>;
+    };
+    expect(args.where).toEqual({ runId: "run-1", status: { in: ["failed", "blocked"] } });
+    expect(args.orderBy).toEqual({ id: "asc" });
+    expect(args.select).toMatchObject({
+      id: true,
+      status: true,
+      caseSnapshot: true,
+      bugId: true,
+      flaky: true,
+      execRun: { select: { report: true } },
+      case: { select: { identifier: true } },
+    });
+  });
+
+  it("映射：failed 带 triage 透传六元分类；failed 无 triage → null；日期无关字段全带", async () => {
+    DB.failRunFindUnique.mockResolvedValue({ id: "run-1", projectId: P });
+    DB.failCasesFindMany.mockResolvedValue([
+      failureRow(),
+      failureRow({
+        id: "rc-2",
+        execRunId: null,
+        execRun: null,
+        caseSnapshot: { title: "人工判失败" },
+        case: { identifier: "STORY-TC2" },
+      }),
+    ]);
+
+    const res = (await listRunFailuresFn({ data: { id: "run-1" } })) as {
+      items: Array<{
+        id: string;
+        status: string;
+        identifier: string;
+        title: string;
+        bugId: string | null;
+        flaky: boolean;
+        triage: { category: string; evidence: string[]; confidence: number } | null;
+      }>;
+    };
+
+    expect(res.items).toHaveLength(2);
+    expect(res.items[0]).toEqual({
+      id: "rc-1",
+      status: "failed",
+      identifier: "STORY-TC1",
+      title: "用例一",
+      bugId: null,
+      flaky: false,
+      triage: triage("api_error"),
+    });
+    expect(res.items[1]!.triage).toBeNull();
+    expect(res.items[1]!.title).toBe("人工判失败");
+  });
+
+  it("blocked 仅收 triage 翻转件（env_issue）；人工 blocked（无 triage）排除", async () => {
+    DB.failRunFindUnique.mockResolvedValue({ id: "run-1", projectId: P });
+    DB.failCasesFindMany.mockResolvedValue([
+      failureRow({ id: "rc-3", status: "blocked", execRun: { report: { triage: triage("env_issue", 0.8) } } }),
+      failureRow({ id: "rc-4", status: "blocked", execRunId: null, execRun: null }),
+    ]);
+
+    const res = (await listRunFailuresFn({ data: { id: "run-1" } })) as {
+      items: Array<{ id: string; status: string }>;
+    };
+
+    expect(res.items).toHaveLength(1);
+    expect(res.items[0]).toMatchObject({ id: "rc-3", status: "blocked" });
+  });
+
+  it("triage 脏数据（category 非法 / report 缺失）→ triage 降级 null 不炸", async () => {
+    DB.failRunFindUnique.mockResolvedValue({ id: "run-1", projectId: P });
+    DB.failCasesFindMany.mockResolvedValue([
+      failureRow({ id: "rc-5", execRun: { report: { triage: { category: "weird", evidence: "not-array", confidence: 9 } } } }),
+      failureRow({ id: "rc-6", execRun: { report: null } }),
+    ]);
+
+    const res = (await listRunFailuresFn({ data: { id: "run-1" } })) as {
+      items: Array<{ id: string; triage: unknown }>;
+    };
+
+    expect(res.items).toHaveLength(2);
+    expect(res.items[0]!.triage).toBeNull();
+    expect(res.items[1]!.triage).toBeNull();
+  });
+});