@allbluecn/web-app 0.17.2 → 0.18.1

package/src/server/testcase/auto-bug.ts

@@ -0,0 +1,547 @@
+// 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/>.
+
+// 指纹判重与 Bug 自动起草（任务 34，规格 §10 R6 / Q2）：triage 完成后（非 env_issue，
+// env_issue 已翻转 blocked 隔离在 bug 链外）对 failed RunCase：
+//   ① 指纹 = execFingerprint({projectId, caseId, 首个失败步 order, category, 错误摘要})，
+//      错误摘要取 stepResults 首个失败步（order 升序）actual——确定性执行产物；不用
+//      ExecRun.report.triage.evidence（AI 逐次生成措辞不稳定，同根因会算出不同指纹破坏判重）。
+//   ② 判重（命中口径=规格 §10 指纹行）：同 case 存在 bugId 非空且关联 Bug.state ∈
+//      {open,in_progress} 的历史 RunCase 同指纹 → 关联既有 Bug（totalCount+1 +
+//      lastOccurAt + RunCase.bugId/fingerprint 回写），不新建不通知；resolved（fixed/
+//      closed/wontfix）历史不命中→走新建（回归语义）。
+//   ③ 未命中→起草：title=[TC{seq}] {快照.title} · {category 摘要}、reproduceSteps=
+//      快照 steps 同构直拷+失败步 actual（任务 17 buildConvertBugDefaults 组装口径的
+//      server 端复刻）、severity=priorityToSeverity(快照 priority)、storyId 继承
+//      case.storyId、description=归因证据+截图 blob 引用（≤4KB）、source=test_run、
+//      state=open、pendingConfirm=!BugProjectSettings.autoSubmitTestBugs（Q2 闸门，
+//      缺行惰性默认 false→待确认）。Bug 列表默认视图过滤 pendingConfirm 已由任务 17
+//      buildListWhere 交付，确认走 confirmTestRunBugFn（test-bug-confirm.ts）。
+//   ④ 起草提交后派发 webhook test.bug.drafted（run-webhook 同款 fire-and-forget）+
+//      站内通知批次创建人（createNotification 内部全吞异常）。
+//
+// 指纹唯一约束（Bug @@unique([projectId, fingerprint])）与「resolved 不命中→新建」
+// 的组合：新建事务内先把同指纹旧 Bug 的指纹腾挪为 null（恒一行 updateMany，无主时
+// 零行幂等），保证「每项目每指纹至多一个活跃 Bug」不变量；并发窗口仍撞 P2002 时
+// 降级关联既有 Bug（不当作错误）。identifier 撞号照 bug-crud 重试取新 seq。
+//
+// 本模块为 server/testcase/ 纯服务端模块（同 triage 口径），非 serverFn；顶层
+// try/catch 全吞——bug 链任何失败只落 console.warn，永不反噬 triage 主链路
+// （triage 已落账，人工转单兜底仍在）。
+import { getPrisma } from "@allbluecn/database/get-prisma";
+import type { Prisma } from "@allbluecn/database";
+import { createNotification } from "@/server/notifications/notification-service";
+import { m } from "@/paraglide/messages.js";
+import { execFingerprint, type ExecutionFailureCategory } from "./fingerprint";
+import { priorityToSeverity, type BugSeverity } from "./severity-map";
+import { fireTestBugDraftedWebhook } from "./run-webhook";
+import type { TestCasePriority } from "@/server/serverFns/testcase/constants";
+
+// ── category 摘要（title 组成部分；中文为项目基础 locale，Bug title 是数据非 UI 文案）──
+
+export const TEST_BUG_CATEGORY_LABEL: Record<ExecutionFailureCategory, string> = {
+  frontend_error: "前端错误",
+  api_error: "接口错误",
+  assertion_mismatch: "断言不符",
+  env_issue: "环境问题",
+  data_issue: "数据问题",
+  unknown: "未知原因",
+};
+
+// 判重命中口径（规格 §10）：只关联仍活跃的历史 Bug
+const DEDUP_ACTIVE_BUG_STATES = ["open", "in_progress"] as const;
+
+// description 证据文本上限（规格 §10「console/network 摘录 ≤4KB」口径，含证据全文）
+const DESCRIPTION_MAX_LENGTH = 4_000;
+
+// title 列宽与 createBugFn 校验对齐（快照标题过长截断保后缀）
+const TITLE_MAX_LENGTH = 200;
+
+// identifier 撞号重试（bug-crud 同值）
+const IDENTIFIER_MAX_RETRIES = 5;
+
+interface StepResultEntry {
+  order: number;
+  status?: string;
+  actual?: string;
+  evidenceBlobIds?: unknown;
+}
+
+/** stepResults 读侧收敛：bare array（schema 注释形状），异常形状按空数组起步 */
+function readStepResultList(value: unknown): StepResultEntry[] {
+  if (!Array.isArray(value)) return [];
+  return value
+    .filter(
+      (item): item is StepResultEntry =>
+        item !== null && typeof item === "object",
+    )
+    .map((item) => item as StepResultEntry);
+}
+
+/** 首个失败步 order（order 升序首个 status=fail；无失败步 0 哨兵——整单失败无步骤明细） */
+export function pickFirstFailedOrder(stepResults: unknown): number {
+  const failed = readStepResultList(stepResults)
+    .filter((r) => r.status === "fail" && typeof r.order === "number")
+    .sort((a, b) => a.order - b.order);
+  return failed[0]?.order ?? 0;
+}
+
+/** 指纹错误摘要：首个失败步 actual（trim；缺失降级空串，category+order 仍判别） */
+export function pickFirstFailedActual(stepResults: unknown): string {
+  const order = pickFirstFailedOrder(stepResults);
+  const first = readStepResultList(stepResults)
+    .filter((r) => r.status === "fail" && r.order === order)
+    .at(0);
+  return typeof first?.actual === "string" ? first.actual.trim() : "";
+}
+
+/** 失败步 actual 拼接（任务 17 buildConvertBugDefaults 同口径：order 升序换行） */
+function joinFailedActuals(stepResults: unknown): string {
+  return readStepResultList(stepResults)
+    .filter((r) => r.status === "fail" && typeof r.actual === "string" && r.actual.trim())
+    .sort((a, b) => a.order - b.order)
+    .map((r) => (r.actual as string).trim())
+    .join("\n");
+}
+
+/** case.identifier（形如 STORY-TC3）→ seq 令牌 TC3（任务 17 extractCaseSeqToken 口径复刻） */
+function extractCaseSeqToken(identifier: string | null | undefined): string {
+  if (!identifier) return "TC";
+  const tc = /-TC(\d+)$/i.exec(identifier);
+  if (tc) return `TC${tc[1]}`;
+  const tail = /-([^-\s]+)$/.exec(identifier);
+  return (tail?.[1] ?? identifier).toUpperCase();
+}
+
+function buildTitle(seqToken: string, snapshotTitle: string, category: ExecutionFailureCategory): string {
+  const full = `[${seqToken}] ${snapshotTitle} · ${TEST_BUG_CATEGORY_LABEL[category]}`;
+  return full.length > TITLE_MAX_LENGTH ? full.slice(0, TITLE_MAX_LENGTH) : full;
+}
+
+/** description：归因证据 + 失败步截图 blob 引用（存储形状同 parseStoryDescription 兜底契约） */
+function buildDescription(
+  evidence: string[],
+  stepResults: unknown,
+): string {
+  const lines: string[] = [];
+  for (const result of readStepResultList(stepResults)) {
+    if (result.status !== "fail") continue;
+    for (const blobId of Array.isArray(result.evidenceBlobIds) ? result.evidenceBlobIds : []) {
+      if (typeof blobId === "string" && blobId) lines.push(`步骤 ${result.order} 截图: /api/blob/${blobId}`);
+    }
+  }
+  lines.push(...evidence);
+  const markdown = lines.join("\n").slice(0, DESCRIPTION_MAX_LENGTH);
+  const html = markdown
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/\n/g, "<br>");
+  return JSON.stringify({ html, markdown });
+}
+
+/** severity 推导：快照 priority 白名单外（脏数据）降级 medium（Bug 列默认） */
+function resolveSeverity(priority: unknown): BugSeverity {
+  const valid: TestCasePriority[] = ["p0", "p1", "p2", "p3"];
+  return valid.includes(priority as TestCasePriority)
+    ? priorityToSeverity(priority as TestCasePriority)
+    : "medium";
+}
+
+export interface AutoBugOutcome {
+  /** linked=判重命中关联既有 Bug；drafted=未命中新建起草 */
+  action: "linked" | "drafted";
+  bugId: string;
+  /** 起草单是否落在待确认闸门后（=!autoSubmitTestBugs）；关联既有单恒 false */
+  pendingConfirm: boolean;
+}
+
+interface RunCaseLoaded {
+  id: string;
+  runId: string;
+  caseId: string;
+  status: string;
+  flaky: boolean;
+  bugId: string | null;
+  execRunId: string | null;
+  stepResults: unknown;
+  caseSnapshot: unknown;
+  run: { id: string; projectId: string; createdById: string };
+  case: { storyId: string | null; identifier: string | null } | null;
+}
+
+/**
+ * triage 完成后的指纹判重 + 起草入口（triage.ts 非 env_issue 分支尾部接线）。
+ * 队列口径自守卫：failed 非 flaky 有 ExecRun、已归因（report.triage 存在）、
+ * category 非 env_issue、RunCase 未关联 Bug——任一不满足返回 null 零写入。
+ * 顶层全吞异常（console.warn），永不反噬 triage 主链路。
+ */
+export async function autoBugForTrialedRunCase(runCaseId: string): Promise<AutoBugOutcome | null> {
+  try {
+    const prisma = await getPrisma();
+    const runCase = (await prisma.testRunCase.findUnique({
+      where: { id: runCaseId },
+      select: {
+        id: true,
+        runId: true,
+        caseId: true,
+        status: true,
+        flaky: true,
+        bugId: true,
+        execRunId: true,
+        stepResults: true,
+        caseSnapshot: true,
+        run: { select: { id: true, projectId: true, createdById: true } },
+        case: { select: { storyId: true, identifier: true } },
+      },
+    })) as RunCaseLoaded | null;
+    if (
+      !runCase ||
+      runCase.status !== "failed" ||
+      runCase.flaky ||
+      !runCase.execRunId ||
+      runCase.bugId
+    ) {
+      return null;
+    }
+
+    const execRun = await prisma.testExecRun.findUnique({
+      where: { id: runCase.execRunId },
+      select: { report: true },
+    });
+    const triage = (execRun?.report as { triage?: { category?: unknown; evidence?: unknown } } | null)
+      ?.triage;
+    const category = triage?.category;
+    if (
+      typeof category !== "string" ||
+      !(category in TEST_BUG_CATEGORY_LABEL) ||
+      category === "env_issue"
+    ) {
+      return null;
+    }
+    const evidence = Array.isArray(triage?.evidence)
+      ? (triage.evidence as unknown[]).filter((line): line is string => typeof line === "string")
+      : [];
+
+    const firstFailedOrder = pickFirstFailedOrder(runCase.stepResults);
+    const fingerprint = execFingerprint({
+      projectId: runCase.run.projectId,
+      caseId: runCase.caseId,
+      firstFailedOrder,
+      category: category as ExecutionFailureCategory,
+      errorSummary: pickFirstFailedActual(runCase.stepResults),
+    });
+
+    // 判重（规格 §10 命中口径）：同 case + 同指纹 + 历史已关联 Bug 且该 Bug 仍活跃
+    const history = await prisma.testRunCase.findFirst({
+      where: {
+        caseId: runCase.caseId,
+        fingerprint,
+        bugId: { not: null },
+        bug: { state: { in: [...DEDUP_ACTIVE_BUG_STATES] } },
+      },
+      select: { bugId: true },
+      orderBy: { id: "desc" },
+    });
+    if (history?.bugId) {
+      // try 块内必须 return await：裸 return promise 的 reject 发生在退出 try 之后，
+      // 下方 catch（全吞兜底）接不到——顶层全吞语义失效
+      return await linkExistingBug(prisma, runCase.id, history.bugId, fingerprint);
+    }
+    return await draftBug(prisma, runCase, {
+      category: category as ExecutionFailureCategory,
+      evidence,
+      fingerprint,
+      firstFailedOrder,
+    });
+  } catch (error: unknown) {
+    const detail = error instanceof Error ? error.message.replace(/\s+/g, " ") : String(error ?? "");
+    console.warn(`[auto-bug] runCase ${runCaseId} bug 链失败（人工转单兜底）: ${detail}`);
+    return null;
+  }
+}
+
+/**
+ * 命中关联：RunCase 条件回写（bugId 仍 null 才命中，并发已关联零行即止）与既有 Bug
+ * 计数（totalCount+1 + lastOccurAt）折同一事务——两写原子，计数失败整体回滚，
+ * 不留「已关联未计数」半态。
+ */
+async function linkExistingBug(
+  prisma: Awaited<ReturnType<typeof getPrisma>>,
+  runCaseId: string,
+  bugId: string,
+  fingerprint: string,
+): Promise<AutoBugOutcome | null> {
+  return prisma.$transaction(async (tx) => {
+    const linked = await tx.testRunCase.updateMany({
+      where: { id: runCaseId, bugId: null },
+      data: { bugId, fingerprint },
+    });
+    if (linked.count === 0) return null;
+    await tx.bug.update({
+      where: { id: bugId },
+      data: { totalCount: { increment: 1 }, lastOccurAt: new Date() },
+    });
+    return { action: "linked" as const, bugId, pendingConfirm: false };
+  });
+}
+
+interface DraftContext {
+  category: ExecutionFailureCategory;
+  evidence: string[];
+  fingerprint: string;
+  firstFailedOrder: number;
+}
+
+/** 未命中起草：事务（腾挪指纹→发号→建单→活动→RunCase 回写）+ 提交后通知/webhook */
+async function draftBug(
+  prisma: Awaited<ReturnType<typeof getPrisma>>,
+  runCase: RunCaseLoaded,
+  ctx: DraftContext,
+): Promise<AutoBugOutcome | null> {
+  const settings = await prisma.bugProjectSettings.findUnique({
+    where: { projectId: runCase.run.projectId },
+    select: { autoSubmitTestBugs: true },
+  });
+  const autoSubmit = settings?.autoSubmitTestBugs === true;
+  const pendingConfirm = !autoSubmit;
+
+  const snapshot = (runCase.caseSnapshot ?? {}) as {
+    title?: unknown;
+    priority?: unknown;
+    steps?: { steps?: Array<{ order?: unknown; action?: unknown; expected?: unknown }> } | null;
+  };
+  const snapshotSteps = Array.isArray(snapshot.steps?.steps) ? snapshot.steps!.steps! : [];
+  const reproduceSteps = {
+    steps: snapshotSteps
+      .filter(
+        (step): step is { order: number; action: string; expected?: string } =>
+          typeof step?.order === "number" && typeof step?.action === "string",
+      )
+      .map((step) => ({
+        order: step.order,
+        action: step.action,
+        ...(step.expected !== undefined ? { expected: step.expected } : {}),
+      })),
+    ...(joinFailedActuals(runCase.stepResults)
+      ? { actualResult: joinFailedActuals(runCase.stepResults) }
+      : {}),
+  };
+  const seqToken = extractCaseSeqToken(runCase.case?.identifier);
+  const snapshotTitle = typeof snapshot.title === "string" ? snapshot.title : "（未命名用例）";
+  const title = buildTitle(seqToken, snapshotTitle, ctx.category);
+  const severity = resolveSeverity(snapshot.priority);
+  const description = buildDescription(ctx.evidence, runCase.stepResults);
+
+  const result = await createBugWithRetry(prisma, {
+    projectId: runCase.run.projectId,
+    runCaseId: runCase.id,
+    title,
+    severity,
+    description,
+    reproduceSteps,
+    storyId: runCase.case?.storyId ?? null,
+    fingerprint: ctx.fingerprint,
+    pendingConfirm,
+    createdById: runCase.run.createdById,
+  });
+  // 指纹唯一冲突降级关联：与判重命中同语义（不新建不通知不派 webhook）
+  if (result.kind === "linked") return result.outcome;
+  const created = result.bug;
+
+  // 事务已提交：起草完成通知 + webhook（fire-and-forget，失败静默）
+  await notifyDrafted(runCase, {
+    bugId: created.id,
+    identifier: created.identifier,
+    title,
+    pendingConfirm,
+    snapshotTitle,
+  });
+  fireTestBugDraftedWebhook({
+    projectId: runCase.run.projectId,
+    bug: {
+      id: created.id,
+      identifier: created.identifier,
+      title,
+      severity,
+      state: "open",
+      pendingConfirm,
+      fingerprint: ctx.fingerprint,
+    },
+  });
+  return { action: "drafted", bugId: created.id, pendingConfirm };
+}
+
+interface CreateBugArgs {
+  projectId: string;
+  runCaseId: string;
+  title: string;
+  severity: string;
+  description: string;
+  reproduceSteps: unknown;
+  storyId: string | null;
+  fingerprint: string;
+  pendingConfirm: boolean;
+  createdById: string;
+}
+
+/** 建单事务结果：created=新建成功；linked=指纹唯一冲突降级关联既有 Bug（无通知无 webhook） */
+type CreateBugResult =
+  | { kind: "created"; bug: { id: string; identifier: string } }
+  | { kind: "linked"; outcome: AutoBugOutcome };
+
+/** 建单事务（identifier 撞号重试 + 指纹腾挪 + P2002 指纹降级关联） */
+async function createBugWithRetry(
+  prisma: Awaited<ReturnType<typeof getPrisma>>,
+  args: CreateBugArgs,
+): Promise<CreateBugResult> {
+  for (let attempt = 0; attempt < IDENTIFIER_MAX_RETRIES; attempt++) {
+    try {
+      return await prisma.$transaction(async (tx) => {
+        const project = await tx.project.findUnique({
+          where: { id: args.projectId },
+          select: { id: true, name: true, displayId: true },
+        });
+        if (!project) throw new Error("项目不存在");
+
+        // 腾挪同指纹 resolved 旧 Bug（回归语义：活跃单唯一持有指纹；无主零行幂等）。
+        // state 过滤：活跃单（open/in_progress）持指纹时禁止腾挪——并发双 worker 同
+        // 指纹双双 dedup miss 时，后提交者 create 撞 P2002 走降级关联（同根因仍收敛
+        // 单 Bug），若放行会把首单指纹抹掉且产出双 open 单
+        await tx.bug.updateMany({
+          where: {
+            projectId: args.projectId,
+            fingerprint: args.fingerprint,
+            state: { not: { in: [...DEDUP_ACTIVE_BUG_STATES] } },
+          },
+          data: { fingerprint: null },
+        });
+
+        // Bug 发号 scope 带 bug: 前缀（bug-crud 同款）
+        const counter = await tx.sequenceCounter.upsert({
+          where: { scope: `bug:${args.projectId}` },
+          create: { scope: `bug:${args.projectId}`, seq: 1 },
+          update: { seq: { increment: 1 } },
+        });
+        const prefix =
+          (project.displayId ?? project.name ?? "").replace(/[^a-zA-Z0-9]/g, "").toUpperCase() ||
+          "PRJ";
+        const identifier = `${prefix}-B${counter.seq}`;
+
+        const bug = await tx.bug.create({
+          data: {
+            sequenceId: counter.seq,
+            identifier,
+            projectId: args.projectId,
+            title: args.title,
+            description: args.description,
+            reproduceSteps: args.reproduceSteps as Prisma.InputJsonValue,
+            state: "open",
+            severity: args.severity,
+            source: "test_run",
+            pendingConfirm: args.pendingConfirm,
+            fingerprint: args.fingerprint,
+            storyId: args.storyId,
+            createdById: args.createdById,
+          },
+          select: { id: true },
+        });
+
+        await tx.bugActivity.create({
+          data: { bugId: bug.id, userId: args.createdById, action: "created", isAI: true },
+        });
+        await tx.projectActivity.create({
+          data: {
+            projectId: args.projectId,
+            userId: args.createdById,
+            action: "created",
+            targetType: "bug",
+            targetId: bug.id,
+          },
+        });
+
+        // RunCase 回写条件更新（并发已关联零行 → 抛错整体回滚，防重复转单）
+        const linked = await tx.testRunCase.updateMany({
+          where: { id: args.runCaseId, bugId: null },
+          data: { bugId: bug.id, fingerprint: args.fingerprint },
+        });
+        if (linked.count === 0) throw new Error("该执行用例已关联 BUG");
+
+        return { kind: "created" as const, bug: { id: bug.id, identifier } };
+      });
+    } catch (error: unknown) {
+      const code = (error as { code?: string }).code;
+      const target = (error as { meta?: { target?: string[] } }).meta?.target;
+      if (code === "P2002" && target?.includes("identifier") && attempt < IDENTIFIER_MAX_RETRIES - 1) {
+        continue; // 并发发号撞 identifier，重试取新 seq
+      }
+      if (code === "P2002" && target?.includes("fingerprint")) {
+        // 并发窗口仍撞指纹唯一（腾挪未及提交）：降级关联既有 Bug，不当作错误
+        const existing = await prisma.bug.findUnique({
+          where: {
+            projectId_fingerprint: { projectId: args.projectId, fingerprint: args.fingerprint },
+          },
+          select: { id: true },
+        });
+        if (existing) {
+          const outcome = await linkExistingBug(prisma, args.runCaseId, existing.id, args.fingerprint);
+          if (outcome) return { kind: "linked" as const, outcome };
+        }
+      }
+      throw error;
+    }
+  }
+  throw new Error("创建 BUG 失败：编号冲突，请重试");
+}
+
+/**
+ * 起草完成通知批次创建人（locale 对齐任务 33 notifyEnvIssue；createNotification 全吞
+ * 异常）。内部自吞全部异常（含 locale 查询）——排在 webhook 派发之前，通知链任何
+ * 失败不得连坐 test.bug.drafted 派发。
+ */
+async function notifyDrafted(
+  runCase: RunCaseLoaded,
+  info: { bugId: string; identifier: string; title: string; pendingConfirm: boolean; snapshotTitle: string },
+): Promise<void> {
+  try {
+    const prisma = await getPrisma();
+    const user = await prisma.user.findUnique({
+      where: { id: runCase.run.createdById },
+      select: { locale: true },
+    });
+    const msgOptions = user?.locale === "en" ? { locale: "en" as const } : undefined;
+    await createNotification({
+      userId: runCase.run.createdById,
+      category: "collaboration",
+      type: "test.bug.drafted",
+      title: m.testcase_autoBug_draftedTitle({ caseTitle: info.snapshotTitle }, msgOptions),
+      body: m.testcase_autoBug_draftedBody(
+        {
+          bugTitle: info.title,
+          hint: info.pendingConfirm
+            ? m.testcase_autoBug_pendingHint(msgOptions)
+            : m.testcase_autoBug_submittedHint(msgOptions),
+        },
+        msgOptions,
+      ),
+      link: `/test-cases/runs/${runCase.runId}`,
+    });
+  } catch (error: unknown) {
+    const detail = error instanceof Error ? error.message.replace(/\s+/g, " ") : String(error ?? "");
+    console.warn(`[auto-bug] 起草通知失败（webhook 派发不受影响）: ${detail}`);
+  }
+}