@yanhaidao/wecom 2.4.160 → 2.5.110

package/src/transport/bot-ws/reply.test.ts

@@ -1,450 +0,0 @@
-import os from "node:os";
-import path from "node:path";
-import type { WSClient } from "@wecom/aibot-node-sdk";
-import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
-import { resolvePreferredOpenClawTmpDir } from "openclaw/plugin-sdk/infra-runtime";
-import { uploadAndSendBotWsMedia } from "./media.js";
-import { createBotWsReplyHandle } from "./reply.js";
-
-vi.mock("./media.js", () => ({
-  uploadAndSendBotWsMedia: vi.fn(),
-}));
-
-type ReplyHandleParams = Parameters<typeof createBotWsReplyHandle>[0];
-
-describe("createBotWsReplyHandle", () => {
-  let mockClient: import("vitest").Mocked<WSClient>;
-  const uploadAndSendBotWsMediaMock = vi.mocked(uploadAndSendBotWsMedia);
-
-  beforeEach(async () => {
-    vi.useFakeTimers();
-    vi.stubEnv("OPENCLAW_STATE_DIR", "/tmp/wecom-reply-state");
-    mockClient = {
-      replyStream: vi.fn(),
-      sendMessage: vi.fn(),
-      replyWelcome: vi.fn(),
-    } as unknown as import("vitest").Mocked<WSClient>;
-    mockClient.replyStream.mockResolvedValue({} as any);
-    mockClient.sendMessage.mockResolvedValue({} as any);
-    mockClient.replyWelcome.mockResolvedValue({} as any);
-    uploadAndSendBotWsMediaMock.mockReset();
-    uploadAndSendBotWsMediaMock.mockResolvedValue({ ok: true, messageId: "media-1" } as any);
-    const runtime = await import("../../runtime.js");
-    runtime.setWecomRuntime({
-      config: {
-        loadConfig: () => ({
-          channels: {
-            wecom: {},
-          },
-        }),
-      },
-    } as any);
-  });
-
-  afterEach(() => {
-    vi.clearAllTimers();
-    vi.useRealTimers();
-    vi.restoreAllMocks();
-    vi.unstubAllEnvs();
-  });
-
-  it("uses configured placeholder content for immediate ws ack", async () => {
-    createBotWsReplyHandle({
-      client: mockClient,
-      frame: {
-        headers: { req_id: "req-1" },
-        body: { chatid: "123", chattype: "group" },
-        cmd: "aibot_msg_callback",
-      } as unknown as ReplyHandleParams["frame"],
-      accountId: "default",
-      inboundKind: "text",
-      placeholderContent: "正在思考...",
-    });
-
-    vi.advanceTimersByTime(3000);
-    // Let promises flush
-    await Promise.resolve();
-
-    expect(mockClient.replyStream).toHaveBeenCalledWith(
-      expect.objectContaining({
-        headers: { req_id: "req-1" },
-      }),
-      expect.any(String),
-      "正在思考...",
-      false,
-    );
-  });
-
-  it("keeps placeholder alive until the first real ws chunk arrives", async () => {
-    const handle = createBotWsReplyHandle({
-      client: mockClient,
-      frame: {
-        headers: { req_id: "req-keepalive" },
-        body: {},
-      } as unknown as ReplyHandleParams["frame"],
-      accountId: "default",
-      inboundKind: "text",
-      placeholderContent: "正在思考...",
-    });
-
-    vi.advanceTimersByTime(3000);
-    // Flush the microtasks so `placeholderInFlight` becomes false
-    for (let i = 0; i < 10; i++) await Promise.resolve();
-
-    // Now trigger the next timer
-    vi.advanceTimersByTime(3000);
-    for (let i = 0; i < 10; i++) await Promise.resolve();
-    expect(mockClient.replyStream).toHaveBeenCalledTimes(2);
-
-    handle.deliver({ text: "最终回复", isReasoning: false }, { kind: "final" });
-    await Promise.resolve();
-
-    expect(mockClient.replyStream).toHaveBeenCalledWith(
-      expect.objectContaining({
-        headers: { req_id: "req-keepalive" },
-      }),
-      expect.any(String),
-      "最终回复",
-      true,
-    );
-
-    // Ensure interval is cleared
-    vi.advanceTimersByTime(6000);
-    await Promise.resolve();
-    expect(mockClient.replyStream).toHaveBeenCalledTimes(3);
-  });
-
-  it("does not auto-send placeholder when disabled", async () => {
-    createBotWsReplyHandle({
-      client: mockClient,
-      frame: {
-        headers: { req_id: "req-2" },
-        body: {},
-      } as unknown as ReplyHandleParams["frame"],
-      accountId: "default",
-      inboundKind: "text",
-      autoSendPlaceholder: false,
-    });
-
-    vi.advanceTimersByTime(3000);
-    await Promise.resolve();
-    expect(mockClient.replyStream).not.toHaveBeenCalled();
-  });
-
-  it("sends cumulative content for block streaming updates", async () => {
-    const handle = createBotWsReplyHandle({
-      client: mockClient,
-      frame: {
-        headers: { req_id: "req-blocks" },
-        body: {},
-      } as unknown as ReplyHandleParams["frame"],
-      accountId: "default",
-      inboundKind: "text",
-      autoSendPlaceholder: false,
-    });
-
-    await handle.deliver({ text: "第一段", isReasoning: false }, { kind: "block" });
-    await handle.deliver({ text: "第二段", isReasoning: false }, { kind: "block" });
-    await handle.deliver({ text: "收尾", isReasoning: false }, { kind: "final" });
-
-    expect(mockClient.replyStream).toHaveBeenNthCalledWith(
-      1,
-      expect.objectContaining({ headers: { req_id: "req-blocks" } }),
-      expect.any(String),
-      "第一段",
-      false,
-    );
-    expect(mockClient.replyStream).toHaveBeenNthCalledWith(
-      2,
-      expect.objectContaining({ headers: { req_id: "req-blocks" } }),
-      expect.any(String),
-      "第一段\n第二段",
-      false,
-    );
-    expect(mockClient.replyStream).toHaveBeenNthCalledWith(
-      3,
-      expect.objectContaining({ headers: { req_id: "req-blocks" } }),
-      expect.any(String),
-      "第一段\n第二段\n收尾",
-      true,
-    );
-  });
-
-  it("streams block text even when media is deferred to final", async () => {
-    const handle = createBotWsReplyHandle({
-      client: mockClient,
-      frame: {
-        headers: { req_id: "req-block-media" },
-        body: {},
-      } as unknown as ReplyHandleParams["frame"],
-      accountId: "default",
-      inboundKind: "text",
-      autoSendPlaceholder: false,
-    });
-
-    await handle.deliver(
-      {
-        text: "正文先发",
-        mediaUrls: ["/tmp/a.png", "/tmp/b.png"],
-        isReasoning: false,
-      },
-      { kind: "block" },
-    );
-
-    expect(mockClient.replyStream).toHaveBeenCalledWith(
-      expect.objectContaining({ headers: { req_id: "req-block-media" } }),
-      expect.any(String),
-      "正文先发",
-      false,
-    );
-  });
-
-  it("includes default global media local roots for final media sends", async () => {
-    const runtime = await import("../../runtime.js");
-    runtime.setWecomRuntime({
-      config: {
-        loadConfig: () => ({}),
-      },
-    } as any);
-
-    const handle = createBotWsReplyHandle({
-      client: mockClient,
-      frame: {
-        headers: { req_id: "req-final-media-roots" },
-        body: {
-          from: { userid: "hidao" },
-          chattype: "single",
-        },
-      } as unknown as ReplyHandleParams["frame"],
-      accountId: "default",
-      inboundKind: "text",
-      autoSendPlaceholder: false,
-    });
-
-    await handle.deliver(
-      {
-        mediaUrls: ["/Users/YanHaidao/Downloads/01.png"],
-        isReasoning: false,
-      },
-      { kind: "final" },
-    );
-
-    expect(uploadAndSendBotWsMediaMock).toHaveBeenCalledWith(
-      expect.objectContaining({
-        chatId: "hidao",
-        maxBytes: 80 * 1024 * 1024,
-        mediaUrl: "/Users/YanHaidao/Downloads/01.png",
-        mediaLocalRoots: expect.arrayContaining([
-          path.resolve(resolvePreferredOpenClawTmpDir()),
-          "/tmp/wecom-reply-state",
-          "/tmp/wecom-reply-state/media",
-          path.resolve(os.homedir(), "Desktop"),
-          path.resolve(os.homedir(), "Documents"),
-          path.resolve(os.homedir(), "Downloads"),
-        ]),
-      }),
-    );
-    expect(mockClient.replyStream).toHaveBeenCalledWith(
-      expect.objectContaining({ headers: { req_id: "req-final-media-roots" } }),
-      expect.any(String),
-      "文件已发送。",
-      true,
-    );
-  });
-
-  it("passes configured mediaMaxMb to final media sends", async () => {
-    const runtime = await import("../../runtime.js");
-    runtime.setWecomRuntime({
-      config: {
-        loadConfig: () => ({
-          agents: {
-            defaults: {
-              mediaMaxMb: 12,
-            },
-          },
-          channels: {
-            wecom: {
-              mediaMaxMb: 24,
-              accounts: {
-                default: {
-                  mediaMaxMb: 40,
-                },
-              },
-            },
-          },
-        }),
-      },
-    } as any);
-
-    const handle = createBotWsReplyHandle({
-      client: mockClient,
-      frame: {
-        headers: { req_id: "req-final-media-max-bytes" },
-        body: {
-          from: { userid: "hidao" },
-          chattype: "single",
-        },
-      } as unknown as ReplyHandleParams["frame"],
-      accountId: "default",
-      inboundKind: "text",
-      autoSendPlaceholder: false,
-    });
-
-    await handle.deliver(
-      {
-        mediaUrls: ["/Users/YanHaidao/Downloads/01.png"],
-        isReasoning: false,
-      },
-      { kind: "final" },
-    );
-
-    expect(uploadAndSendBotWsMediaMock).toHaveBeenCalledWith(
-      expect.objectContaining({
-        chatId: "hidao",
-        maxBytes: 40 * 1024 * 1024,
-      }),
-    );
-  });
-
-  it("stops placeholder keepalive when the first block contains media", async () => {
-    const handle = createBotWsReplyHandle({
-      client: mockClient,
-      frame: {
-        headers: { req_id: "req-placeholder-media" },
-        body: {},
-      } as unknown as ReplyHandleParams["frame"],
-      accountId: "default",
-      inboundKind: "text",
-      placeholderContent: "正在思考...",
-    });
-
-    vi.advanceTimersByTime(3000);
-    for (let i = 0; i < 10; i++) await Promise.resolve();
-    expect(mockClient.replyStream).toHaveBeenCalledTimes(1);
-
-    await handle.deliver(
-      {
-        text: "正文先发",
-        mediaUrls: ["/tmp/a.png"],
-        isReasoning: false,
-      },
-      { kind: "block" },
-    );
-
-    vi.advanceTimersByTime(6000);
-    for (let i = 0; i < 10; i++) await Promise.resolve();
-
-    expect(mockClient.replyStream).toHaveBeenCalledTimes(2);
-    expect(mockClient.replyStream).toHaveBeenNthCalledWith(
-      2,
-      expect.objectContaining({ headers: { req_id: "req-placeholder-media" } }),
-      expect.any(String),
-      "正文先发",
-      false,
-    );
-  });
-
-  it("swallows expired stream update errors during delivery", async () => {
-    const expiredError = {
-      headers: { req_id: "req-expired" },
-      errcode: 846608,
-      errmsg: "stream message update expired (>6 minutes), cannot update",
-    };
-    mockClient.replyStream.mockRejectedValueOnce(expiredError);
-    const onFail = vi.fn();
-
-    const handle = createBotWsReplyHandle({
-      client: mockClient,
-      frame: {
-        headers: { req_id: "req-expired" },
-        body: {},
-      } as unknown as ReplyHandleParams["frame"],
-      accountId: "default",
-      inboundKind: "text",
-      autoSendPlaceholder: false,
-      onFail,
-    });
-
-    await handle.deliver({ text: "最终回复", isReasoning: false }, { kind: "final" });
-
-    expect(mockClient.replyStream).toHaveBeenCalledTimes(1);
-    expect(onFail).toHaveBeenCalledWith(expiredError);
-  });
-
-  it.each([
-    [{ headers: { req_id: "req-invalid" }, errcode: 846605, errmsg: "invalid req_id" }],
-    [
-      {
-        headers: { req_id: "req-expired" },
-        errcode: 846608,
-        errmsg: "stream message update expired (>6 minutes), cannot update",
-      },
-    ],
-  ])("does not retry error reply when the ws reply window is already closed", async (error) => {
-    const onFail = vi.fn();
-    const handle = createBotWsReplyHandle({
-      client: mockClient,
-      frame: {
-        headers: { req_id: String(error.headers.req_id) },
-        body: {},
-      } as unknown as ReplyHandleParams["frame"],
-      accountId: "default",
-      inboundKind: "text",
-      autoSendPlaceholder: false,
-      onFail,
-    });
-
-    await handle.fail?.(error);
-
-    expect(mockClient.replyStream).not.toHaveBeenCalled();
-    expect(onFail).toHaveBeenCalledTimes(1);
-  });
-
-  it("sends simple fallback message for ordinary events without placeholders", async () => {
-    const handle = createBotWsReplyHandle({
-      client: mockClient,
-      frame: {
-        headers: { req_id: "event_req" },
-        body: { chattype: "single", from: { userid: "alice" } },
-      } as unknown as ReplyHandleParams["frame"],
-      accountId: "default",
-      inboundKind: "event",
-    });
-
-    vi.advanceTimersByTime(3000);
-    await Promise.resolve();
-    // Events should not send stream placeholders
-    expect(mockClient.replyStream).not.toHaveBeenCalled();
-
-    handle.deliver({ text: "Event Reply", isReasoning: false }, { kind: "final" });
-    await Promise.resolve();
-
-    expect(mockClient.sendMessage).toHaveBeenCalledWith("alice", {
-      msgtype: "markdown",
-      markdown: { content: "Event Reply" },
-    });
-  });
-
-  it("sends replyWelcome for welcome events", async () => {
-    const handle = createBotWsReplyHandle({
-      client: mockClient,
-      frame: {
-        headers: { req_id: "welcome_req" },
-        body: { chattype: "single", from: { userid: "bob" } },
-      } as unknown as ReplyHandleParams["frame"],
-      accountId: "default",
-      inboundKind: "welcome",
-    });
-
-    handle.deliver({ text: "Hello Bob", isReasoning: false }, { kind: "final" });
-    await Promise.resolve();
-
-    expect(mockClient.replyWelcome).toHaveBeenCalledWith(
-      expect.objectContaining({ headers: { req_id: "welcome_req" } }),
-      {
-        msgtype: "text",
-        text: { content: "Hello Bob" },
-      },
-    );
-  });
-});