@allbluecn/web-app 0.18.2 → 0.19.0

package/src/server/collab/__tests__/write-guard-sdk.test.ts

@@ -0,0 +1,501 @@
+// 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/>.
+
+// SDK/AI 机器写入 × 协同门卫测试（任务 23，规格 §5.3）——机器写入入口清单：
+// 1. Bug SDK 上报去重重开（report-handler dedupeExistingBug，actorType=sdk，
+//    Y 属主面 = state reopen）
+// 2. MCP report_result 修复完成（tools.ts，actorType=agent，Y 属主面 =
+//    state fixed）
+//
+// §5.3 口径钉死：
+// - 快照存在 → 一律转发 /internal/apply（信封 actor=机器身份 sdk:/agent:），
+//   **DB 侧剥离 Y 属主面**（state 不直写、活动由 collab 侧产出防重复流水）
+// - collab 不可达 → 3s TTL 排队重试后降级直写（不可丢链路：state 落库 +
+//   actorType=sdk/agent 活动保留；快照行不触碰 → 业务列反超 → 下次协同打开
+//   重种子化以 DB 为准，T14 闭环）
+// - 无快照 → 照旧直写（非协同态零行为变化）
+
+import { beforeEach, afterEach, describe, expect, it, vi } from "vitest";
+import { INTERNAL_DOMAIN_APPLY } from "@allbluecn/collab-core/internal";
+
+const mocks = vi.hoisted(() => ({
+  checkRateLimit: vi.fn(),
+  tokenFindUnique: vi.fn(),
+  tokenUpdate: vi.fn(),
+  settingsUpsert: vi.fn(),
+  bugFindUnique: vi.fn(),
+  bugFindFirst: vi.fn(),
+  bugUpdate: vi.fn(),
+  bugActivityCreate: vi.fn(),
+  bugEventFindMany: vi.fn(),
+  fixRunFindFirst: vi.fn(),
+  fixRunUpdateMany: vi.fn(),
+  collabDocumentFindUnique: vi.fn(),
+  collabDocumentUpdateMany: vi.fn(),
+  fireBugWebhook: vi.fn(),
+  fireTestRunWebhook: vi.fn(),
+  scheduleFlakyRetry: vi.fn(),
+  transaction: vi.fn(),
+}));
+
+// report-handler / mcp tools / write-guard 三方共用一个 prisma 形状（并集）
+vi.mock("@allbluecn/database", () => ({
+  prisma: {
+    projectAccessToken: {
+      findUnique: mocks.tokenFindUnique,
+      update: mocks.tokenUpdate,
+    },
+    bugProjectSettings: { upsert: mocks.settingsUpsert },
+    bug: {
+      findUnique: mocks.bugFindUnique,
+      findFirst: mocks.bugFindFirst,
+      update: mocks.bugUpdate,
+    },
+    bugActivity: { create: mocks.bugActivityCreate },
+    bugEvent: { findMany: mocks.bugEventFindMany },
+    bugFixRun: {
+      findFirst: mocks.fixRunFindFirst,
+      updateMany: mocks.fixRunUpdateMany,
+    },
+    $transaction: mocks.transaction,
+  },
+  Prisma: {},
+}));
+
+vi.mock("@allbluecn/database/get-prisma", () => ({
+  getPrisma: async () => ({
+    collabDocument: { findUnique: mocks.collabDocumentFindUnique },
+  }),
+}));
+
+vi.mock("@/server/lib/rate-limit", () => ({
+  checkRateLimit: mocks.checkRateLimit,
+}));
+
+vi.mock("@/server/bug-report/webhook-out", () => ({
+  fireBugWebhook: mocks.fireBugWebhook,
+}));
+
+vi.mock("@/server/testcase/run-webhook", () => ({
+  fireTestRunWebhook: mocks.fireTestRunWebhook,
+}));
+
+// flaky-retry 判定用真实现，仅 stub 回池调度（照 tools.test.ts 口径）
+vi.mock("@/server/testcase/flaky-retry", async (importOriginal) => ({
+  ...(await importOriginal<object>()),
+  scheduleFailedExecRetry: mocks.scheduleFlakyRetry,
+}));
+
+import { handleBugReport } from "@/server/bug-report/report-handler";
+import { handleMcpRequest, type McpRequestContext } from "@/server/mcp/protocol";
+import { BUG_MCP_TOOLS, TOOL_NAMES } from "@/server/mcp/tools";
+
+const SECRET = "test-sdk-guard-secret";
+const URL_BASE = "http://collab.test:3030";
+const VALID_KEY = `abk_${"a".repeat(32)}`;
+
+/** fetch 202 应答（collab 在线） */
+function okResponse(): Response {
+  return new Response(JSON.stringify({ applied: "ydoc", connections: 1 }), { status: 202 });
+}
+
+function forwardedFetch(): ReturnType<typeof vi.fn> {
+  return vi.fn().mockResolvedValue(okResponse());
+}
+
+function lastEnvelope(): Record<string, unknown> {
+  const fetchMock = vi.mocked(globalThis.fetch);
+  expect(fetchMock).toHaveBeenCalled();
+  const init = fetchMock.mock.calls[fetchMock.mock.calls.length - 1]![1] ?? {};
+  return JSON.parse(String(init.body)) as Record<string, unknown>;
+}
+
+// ── SDK 上报 fixtures（照 report-handler.test.ts 样板）─────────────────
+
+const TOKEN_ROW = { id: "tok1", projectId: "p1", scope: "bug.report", revokedAt: null };
+const SETTINGS_ROW = {
+  projectId: "p1",
+  autoReportEnabled: true,
+  sampleRate: 1,
+  reopenOnDuplicate: true,
+  autoFixEnabled: false,
+};
+const validEvent = {
+  errorName: "TypeError",
+  message: "x is not a function",
+  stack: "at foo (app.ts:1:1)",
+};
+const validPayload = () => ({
+  sdkVersion: "1.0.0",
+  type: "js_error",
+  events: [validEvent],
+});
+const makeRequest = (body: unknown) =>
+  new Request("http://localhost:3020/api/bugs/report", {
+    method: "POST",
+    headers: { "Content-Type": "application/json", "X-Bug-Key": VALID_KEY },
+    body: JSON.stringify(body),
+  });
+const postWithKey = (payload: unknown) => handleBugReport(makeRequest(payload));
+
+/** state=fixed 既有 BUG（重开语义触发：reopenOnDuplicate=true） */
+const FIXED_BUG = () => ({
+  id: "bug2",
+  projectId: "p1",
+  state: "fixed",
+  lastOccurAt: new Date(Date.now() - 60_000),
+  totalCount: 5,
+});
+
+// ── MCP report_result fixtures（照 tools.test.ts 样板）──────────────────
+
+const ctx: McpRequestContext = {
+  auth: { projectId: "p1", tokenId: "tok1" },
+  tools: BUG_MCP_TOOLS,
+};
+const BUG_P1 = {
+  id: "b1",
+  projectId: "p1",
+  identifier: "BCT-B1",
+  title: "TypeError: cannot read properties of null",
+  state: "open",
+  severity: "high",
+  url: "https://app.example.com/login",
+  stackSummary: "TypeError",
+  source: "sdk_auto",
+};
+const RUN_IN_PROGRESS = {
+  id: "run1",
+  bugId: "b1",
+  status: "in_progress",
+  triggerType: "manual",
+  agentName: "opencode",
+};
+
+async function callReportResult(args: Record<string, unknown>) {
+  const res = await handleMcpRequest(
+    JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "tools/call",
+      params: { name: TOOL_NAMES.reportResult, arguments: args },
+    }),
+    ctx,
+  );
+  expect(res.status).toBe(200);
+  const body = (await res.json()) as { error?: unknown; result?: { content: Array<{ type: string; text: string }> } };
+  expect(body.error).toBeUndefined();
+  const result = body.result!;
+  expect(result.content).toHaveLength(1);
+  expect(result.content[0]!.type).toBe("text");
+  return { payload: JSON.parse(result.content[0]!.text) as Record<string, unknown> };
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  vi.stubEnv("COLLAB_SECRET", SECRET);
+  vi.stubEnv("COLLAB_INTERNAL_URL", URL_BASE);
+  vi.stubGlobal("fetch", vi.fn());
+  mocks.checkRateLimit.mockReturnValue({ allowed: true, retryAfterMs: 0 });
+  mocks.tokenFindUnique.mockResolvedValue(TOKEN_ROW);
+  mocks.tokenUpdate.mockResolvedValue(TOKEN_ROW);
+  mocks.settingsUpsert.mockResolvedValue(SETTINGS_ROW);
+  mocks.bugFindUnique.mockResolvedValue(null);
+  // R11 touch 读回读行 updatedAt——缺省给足，专测可覆写
+  mocks.bugUpdate.mockResolvedValue({ updatedAt: new Date("2026-01-01T00:00:00Z") });
+  mocks.bugActivityCreate.mockResolvedValue({});
+  mocks.collabDocumentFindUnique.mockResolvedValue(null);
+  mocks.collabDocumentUpdateMany.mockResolvedValue({ count: 1 });
+  mocks.bugFindFirst.mockResolvedValue(BUG_P1);
+  mocks.fixRunFindFirst.mockResolvedValue(RUN_IN_PROGRESS);
+  mocks.fixRunUpdateMany.mockResolvedValue({ count: 1 });
+  // R11 touch：指标写 + 快照 touch 同事务（dedupeExistingBug）——tx 携带
+  // bug.update 与 collabDocument.updateMany
+  mocks.transaction.mockImplementation(
+    async (fn: (tx: unknown) => unknown) =>
+      fn({
+        bug: { update: mocks.bugUpdate },
+        collabDocument: { updateMany: mocks.collabDocumentUpdateMany },
+      }),
+  );
+});
+
+afterEach(() => {
+  vi.unstubAllEnvs();
+  vi.unstubAllGlobals();
+});
+
+// ── 1. SDK 上报去重重开（dedupeExistingBug 经门卫）──────────────────────
+
+describe("SDK 去重重开 × 门卫（§5.3 机器写入）", () => {
+  it("快照存在（room 协同中）→ state 经门卫转发（actor=sdk:bug-report），DB 剥离 Y 属主面", async () => {
+    mocks.collabDocumentFindUnique.mockResolvedValue({ id: "snap-1" });
+    const fetchMock = forwardedFetch();
+    vi.stubGlobal("fetch", fetchMock);
+    mocks.bugFindUnique.mockResolvedValue(FIXED_BUG());
+
+    const res = await postWithKey(validPayload());
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as { results: Array<{ bugId: string; deduplicated: boolean }> };
+    expect(body.results).toEqual([{ bugId: "bug2", deduplicated: true }]);
+
+    // 信封：机器身份 actor + roomOf(entity:bug) + 仅 Y 属主面 state
+    expect(lastEnvelope()).toMatchObject({
+      domain: INTERNAL_DOMAIN_APPLY,
+      roomName: "entity:bug:bug2",
+      docId: "bug2",
+      actor: "sdk:bug-report",
+      patch: { fields: { state: "open" } },
+    });
+
+    // DB 零 Y 属主 mutation：state 剥离（totalCount/lastOccurAt 指标列照旧直写）
+    expect(mocks.bugUpdate).toHaveBeenCalledWith({
+      where: { id: "bug2" },
+      data: {
+        totalCount: { increment: 1 },
+        lastOccurAt: expect.any(Date),
+      },
+    });
+    // 活动由 collab 侧产出（actorType=sdk 保留）——web 不再写 reopened_by_sdk 防重复流水
+    expect(mocks.bugActivityCreate).not.toHaveBeenCalled();
+  });
+
+  it("collab 不可达 → 3s TTL 排队重试后降级直写（不丢上报：state + actorType=sdk 活动保留）", async () => {
+    vi.useFakeTimers();
+    try {
+      mocks.collabDocumentFindUnique.mockResolvedValue({ id: "snap-1" });
+      vi.stubGlobal("fetch", vi.fn().mockRejectedValue(new Error("connection refused")));
+      mocks.bugFindUnique.mockResolvedValue(FIXED_BUG());
+      const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+      const pending = postWithKey(validPayload());
+      await vi.runAllTimersAsync();
+      const res = await pending;
+      warn.mockRestore();
+
+      expect(res.status).toBe(200);
+      const body = (await res.json()) as { results: Array<{ bugId: string }> };
+      expect(body.results[0]).toMatchObject({ bugId: "bug2", deduplicated: true });
+
+      // 排队重试确实发生（≥2 次尝试）
+      expect(vi.mocked(globalThis.fetch).mock.calls.length).toBeGreaterThanOrEqual(2);
+
+      // 不可丢链路：降级直写含 state（T14 重种子化的 DB 权威输入）
+      expect(mocks.bugUpdate).toHaveBeenCalledWith(
+        expect.objectContaining({
+          where: { id: "bug2" },
+          data: expect.objectContaining({ state: "open", totalCount: { increment: 1 } }),
+        }),
+      );
+      // SDK 活动保留（actorType=sdk）
+      expect(mocks.bugActivityCreate).toHaveBeenCalledWith({
+        data: expect.objectContaining({ actorType: "sdk", action: "reopened_by_sdk" }),
+      });
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it("无快照 → 照旧直写（非协同态零行为变化，不触网络）", async () => {
+    mocks.bugFindUnique.mockResolvedValue(FIXED_BUG());
+
+    const res = await postWithKey(validPayload());
+    expect(res.status).toBe(200);
+    expect(vi.mocked(globalThis.fetch)).not.toHaveBeenCalled();
+
+    expect(mocks.bugUpdate).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({ state: "open" }),
+      }),
+    );
+    expect(mocks.bugActivityCreate).toHaveBeenCalledWith({
+      data: expect.objectContaining({ actorType: "sdk", action: "reopened_by_sdk" }),
+    });
+  });
+
+  it("无重开（state=open 重复上报）→ 纯指标列不查快照不触网络（省一次查询）", async () => {
+    mocks.bugFindUnique.mockResolvedValue({
+      id: "bug2",
+      projectId: "p1",
+      state: "open",
+      lastOccurAt: new Date(Date.now() - 60_000),
+      totalCount: 5,
+    });
+
+    await postWithKey(validPayload());
+    expect(mocks.collabDocumentFindUnique).not.toHaveBeenCalled();
+    expect(vi.mocked(globalThis.fetch)).not.toHaveBeenCalled();
+    expect(mocks.bugUpdate).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: { totalCount: { increment: 1 }, lastOccurAt: expect.any(Date) },
+      }),
+    );
+  });
+
+  // R11 touch 不变式（审查 Important 1）：totalCount/lastOccurAt 指标 bump
+  // 不含 Y 属主面 → 同事务 touch 快照，防有上报的 BUG 每次打开都重种子化
+
+  it("R11：纯指标 bump（forwarded 剥离 state）→ 同事务 touch 快照", async () => {
+    mocks.collabDocumentFindUnique.mockResolvedValue({ id: "snap-1" });
+    vi.stubGlobal("fetch", forwardedFetch());
+    mocks.bugFindUnique.mockResolvedValue(FIXED_BUG());
+    const TOUCH_AT = new Date("2026-05-05T00:00:00Z");
+    mocks.bugUpdate.mockResolvedValue({ updatedAt: TOUCH_AT });
+
+    await postWithKey(validPayload());
+
+    expect(mocks.collabDocumentUpdateMany).toHaveBeenCalledWith({
+      where: { roomName: "entity:bug:bug2" },
+      data: { updatedAt: TOUCH_AT },
+    });
+  });
+
+  it("R11：降级直写 state（Y 属主面）→ 不 touch（业务列反超快照让重种子化兜底）", async () => {
+    vi.stubEnv("COLLAB_INTERNAL_URL", "");
+    mocks.collabDocumentFindUnique.mockResolvedValue({ id: "snap-1" });
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    mocks.bugFindUnique.mockResolvedValue(FIXED_BUG());
+
+    try {
+      const res = await postWithKey(validPayload());
+      expect(res.status).toBe(200);
+      // state 已直写（不可丢链路）但快照不触碰
+      expect(mocks.bugUpdate).toHaveBeenCalledWith(
+        expect.objectContaining({
+          data: expect.objectContaining({ state: "open" }),
+        }),
+      );
+      expect(mocks.collabDocumentUpdateMany).not.toHaveBeenCalled();
+    } finally {
+      vi.unstubAllEnvs();
+      warn.mockRestore();
+    }
+  });
+});
+
+// ── 2. MCP report_result 修复完成（complete_fix 经门卫）─────────────────
+
+describe("MCP report_result fixed × 门卫（§5.3 机器写入）", () => {
+  it("快照存在 → state 经门卫转发（actor=agent:opencode），DB 剥离 state；fix_completed 活动保留但剥离 state diff 面", async () => {
+    mocks.collabDocumentFindUnique.mockResolvedValue({ id: "snap-1" });
+    const fetchMock = forwardedFetch();
+    vi.stubGlobal("fetch", fetchMock);
+
+    const { payload } = await callReportResult({
+      bugId: "b1",
+      result: "fixed",
+      summary: "修复了 login.ts 空指针",
+    });
+    expect(payload?.ok).toBe(true);
+
+    // 信封：agent 机器身份（agentName 来源）+ roomOf(entity:bug)
+    expect(lastEnvelope()).toMatchObject({
+      domain: INTERNAL_DOMAIN_APPLY,
+      roomName: "entity:bug:b1",
+      docId: "b1",
+      actor: "agent:opencode",
+      patch: { fields: { state: "fixed" } },
+    });
+
+    // DB 零 Y 属主 mutation：state 由 collab 接管
+    expect(mocks.bugUpdate).not.toHaveBeenCalled();
+
+    // run 完成活动保留（fix_completed 是 run 生命周期语义，非 Y 属主面），
+    // 但 state diff 面剥离（collab 侧产 actorType=agent 活动防重复流水）
+    expect(mocks.bugActivityCreate).toHaveBeenCalledWith({
+      data: expect.objectContaining({
+        bugId: "b1",
+        action: "fix_completed",
+        actorType: "agent",
+        agentName: "opencode",
+        isAI: true,
+      }),
+    });
+    const activityData = (mocks.bugActivityCreate.mock.calls[0]?.[0] as { data: Record<string, unknown> })
+      .data;
+    expect(activityData.field).toBeUndefined();
+    expect(activityData.oldValue).toBeUndefined();
+    expect(activityData.newValue).toBeUndefined();
+  });
+
+  it("collab 不可达 → 3s TTL 降级直写（state 落库 + fix_completed 携 state diff，不丢修复结果）", async () => {
+    vi.useFakeTimers();
+    try {
+      mocks.collabDocumentFindUnique.mockResolvedValue({ id: "snap-1" });
+      vi.stubGlobal("fetch", vi.fn().mockRejectedValue(new Error("connection refused")));
+      const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+      const pending = callReportResult({ bugId: "b1", result: "fixed", summary: "修复" });
+      await vi.runAllTimersAsync();
+      const { payload } = await pending;
+      warn.mockRestore();
+
+      expect(payload?.ok).toBe(true);
+      expect(vi.mocked(globalThis.fetch).mock.calls.length).toBeGreaterThanOrEqual(2);
+
+      // 降级直写照旧（state + fix_completed 含 state diff 面）
+      expect(mocks.bugUpdate).toHaveBeenCalledWith({
+        where: { id: "b1" },
+        data: { state: "fixed" },
+      });
+      expect(mocks.bugActivityCreate).toHaveBeenCalledWith({
+        data: expect.objectContaining({
+          action: "fix_completed",
+          actorType: "agent",
+          field: "state",
+          newValue: "fixed",
+        }),
+      });
+      expect(payload?.bugState).toBe("fixed");
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it("无快照 → 照旧直写（非协同态零行为变化）", async () => {
+    const { payload } = await callReportResult({
+      bugId: "b1",
+      result: "fixed",
+      summary: "修复",
+    });
+
+    expect(payload?.ok).toBe(true);
+    expect(vi.mocked(globalThis.fetch)).not.toHaveBeenCalled();
+    expect(mocks.bugUpdate).toHaveBeenCalledWith({
+      where: { id: "b1" },
+      data: { state: "fixed" },
+    });
+    expect(mocks.bugActivityCreate).toHaveBeenCalledWith({
+      data: expect.objectContaining({
+        action: "fix_completed",
+        actorType: "agent",
+        field: "state",
+        newValue: "fixed",
+      }),
+    });
+  });
+
+  it("failed 结果不触门卫（不改 Bug.state，无 Y 属主面）", async () => {
+    mocks.collabDocumentFindUnique.mockResolvedValue({ id: "snap-1" });
+
+    await callReportResult({ bugId: "b1", result: "failed", summary: "引入回归" });
+
+    expect(vi.mocked(globalThis.fetch)).not.toHaveBeenCalled();
+    expect(mocks.collabDocumentFindUnique).not.toHaveBeenCalled();
+    expect(mocks.bugUpdate).not.toHaveBeenCalled();
+  });
+});