@kodelyth/feishu 2026.5.42 → 2026.6.1

package/src/send.test.ts

@@ -1,621 +0,0 @@
-import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
-import type { ClawdbotConfig } from "../runtime-api.js";
-import { buildMarkdownCard } from "./send.js";
-
-const {
-  mockConvertMarkdownTables,
-  mockClientGet,
-  mockClientList,
-  mockClientPatch,
-  mockCreateFeishuClient,
-  mockResolveMarkdownTableMode,
-  mockResolveFeishuAccount,
-  mockRuntimeConvertMarkdownTables,
-  mockRuntimeResolveMarkdownTableMode,
-} = vi.hoisted(() => ({
-  mockConvertMarkdownTables: vi.fn((text: string) => text),
-  mockClientGet: vi.fn(),
-  mockClientList: vi.fn(),
-  mockClientPatch: vi.fn(),
-  mockCreateFeishuClient: vi.fn(),
-  mockResolveMarkdownTableMode: vi.fn(() => "preserve"),
-  mockResolveFeishuAccount: vi.fn(),
-  mockRuntimeConvertMarkdownTables: vi.fn((text: string) => text),
-  mockRuntimeResolveMarkdownTableMode: vi.fn(() => "preserve"),
-}));
-
-vi.mock("klaw/plugin-sdk/markdown-table-runtime", () => ({
-  resolveMarkdownTableMode: mockResolveMarkdownTableMode,
-}));
-
-vi.mock("klaw/plugin-sdk/text-chunking", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("klaw/plugin-sdk/text-chunking")>();
-  return {
-    ...actual,
-    convertMarkdownTables: mockConvertMarkdownTables,
-  };
-});
-
-vi.mock("./client.js", () => ({
-  createFeishuClient: mockCreateFeishuClient,
-}));
-
-vi.mock("./accounts.js", () => ({
-  resolveFeishuAccount: mockResolveFeishuAccount,
-  resolveFeishuRuntimeAccount: mockResolveFeishuAccount,
-}));
-
-vi.mock("./runtime.js", () => ({
-  getFeishuRuntime: () => ({
-    channel: {
-      text: {
-        resolveMarkdownTableMode: mockRuntimeResolveMarkdownTableMode,
-        convertMarkdownTables: mockRuntimeConvertMarkdownTables,
-      },
-    },
-  }),
-}));
-
-let buildStructuredCard: typeof import("./send.js").buildStructuredCard;
-let editMessageFeishu: typeof import("./send.js").editMessageFeishu;
-let getMessageFeishu: typeof import("./send.js").getMessageFeishu;
-let listFeishuThreadMessages: typeof import("./send.js").listFeishuThreadMessages;
-let resolveFeishuCardTemplate: typeof import("./send.js").resolveFeishuCardTemplate;
-let sendMessageFeishu: typeof import("./send.js").sendMessageFeishu;
-
-describe("getMessageFeishu", () => {
-  beforeAll(async () => {
-    ({
-      buildStructuredCard,
-      editMessageFeishu,
-      getMessageFeishu,
-      listFeishuThreadMessages,
-      resolveFeishuCardTemplate,
-      sendMessageFeishu,
-    } = await import("./send.js"));
-  });
-
-  afterAll(() => {
-    vi.doUnmock("klaw/plugin-sdk/markdown-table-runtime");
-    vi.doUnmock("klaw/plugin-sdk/text-chunking");
-    vi.doUnmock("./client.js");
-    vi.doUnmock("./accounts.js");
-    vi.doUnmock("./runtime.js");
-    vi.resetModules();
-  });
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockResolveMarkdownTableMode.mockReturnValue("preserve");
-    mockConvertMarkdownTables.mockImplementation((text: string) => text);
-    mockRuntimeResolveMarkdownTableMode.mockReturnValue("preserve");
-    mockRuntimeConvertMarkdownTables.mockImplementation((text: string) => text);
-    mockResolveFeishuAccount.mockReturnValue({
-      accountId: "default",
-      configured: true,
-    });
-    mockCreateFeishuClient.mockReturnValue({
-      im: {
-        message: {
-          create: vi.fn(),
-          get: mockClientGet,
-          list: mockClientList,
-          patch: mockClientPatch,
-        },
-      },
-    });
-  });
-
-  it("sends text without requiring Feishu runtime text helpers", async () => {
-    mockRuntimeResolveMarkdownTableMode.mockImplementation(() => {
-      throw new Error("Feishu runtime not initialized");
-    });
-    mockRuntimeConvertMarkdownTables.mockImplementation(() => {
-      throw new Error("Feishu runtime not initialized");
-    });
-    mockClientPatch.mockResolvedValueOnce({ code: 0 });
-    mockCreateFeishuClient.mockReturnValue({
-      im: {
-        message: {
-          create: vi.fn().mockResolvedValue({ code: 0, data: { message_id: "om_send" } }),
-          reply: vi.fn(),
-          get: mockClientGet,
-          list: mockClientList,
-          patch: mockClientPatch,
-        },
-      },
-    });
-
-    const result = await sendMessageFeishu({
-      cfg: {} as ClawdbotConfig,
-      to: "oc_send",
-      text: "hello",
-    });
-
-    expect(mockResolveMarkdownTableMode).toHaveBeenCalledWith({
-      cfg: {},
-      channel: "feishu",
-    });
-    expect(mockConvertMarkdownTables).toHaveBeenCalledWith("hello", "preserve");
-    expect(typeof result.receipt.sentAt).toBe("number");
-    expect(result).toEqual({
-      messageId: "om_send",
-      chatId: "oc_send",
-      receipt: {
-        primaryPlatformMessageId: "om_send",
-        platformMessageIds: ["om_send"],
-        parts: [
-          {
-            platformMessageId: "om_send",
-            kind: "text",
-            index: 0,
-            raw: {
-              channel: "feishu",
-              messageId: "om_send",
-              chatId: "oc_send",
-              conversationId: "oc_send",
-            },
-            threadId: "oc_send",
-          },
-        ],
-        threadId: "oc_send",
-        sentAt: result.receipt.sentAt,
-        raw: [
-          {
-            channel: "feishu",
-            messageId: "om_send",
-            chatId: "oc_send",
-            conversationId: "oc_send",
-          },
-        ],
-      },
-    });
-  });
-
-  it("extracts text content from interactive card elements", async () => {
-    mockClientGet.mockResolvedValueOnce({
-      code: 0,
-      data: {
-        items: [
-          {
-            message_id: "om_1",
-            chat_id: "oc_1",
-            msg_type: "interactive",
-            body: {
-              content: JSON.stringify({
-                elements: [
-                  { tag: "markdown", content: "hello markdown" },
-                  { tag: "div", text: { content: "hello div" } },
-                ],
-              }),
-            },
-          },
-        ],
-      },
-    });
-
-    const result = await getMessageFeishu({
-      cfg: {} as ClawdbotConfig,
-      messageId: "om_1",
-    });
-
-    expect(result).toEqual({
-      messageId: "om_1",
-      chatId: "oc_1",
-      chatType: undefined,
-      senderId: undefined,
-      senderOpenId: undefined,
-      senderType: undefined,
-      content: "hello markdown\nhello div",
-      contentType: "interactive",
-      createTime: undefined,
-      threadId: undefined,
-    });
-  });
-
-  it("falls through empty interactive card element arrays and locale variants", async () => {
-    mockClientGet.mockResolvedValueOnce({
-      code: 0,
-      data: {
-        items: [
-          {
-            message_id: "om_i18n_card",
-            chat_id: "oc_i18n_card",
-            msg_type: "interactive",
-            body: {
-              content: JSON.stringify({
-                elements: [],
-                body: { elements: [] },
-                i18n_elements: {
-                  zh_cn: [],
-                  en_us: [
-                    {
-                      tag: "markdown",
-                      content: "hello ${count} {{label}} {{metadata}}",
-                    },
-                  ],
-                },
-                template_variable: {
-                  count: 2,
-                  label: "tasks",
-                  metadata: { ignored: true },
-                },
-              }),
-            },
-          },
-        ],
-      },
-    });
-
-    const result = await getMessageFeishu({
-      cfg: {} as ClawdbotConfig,
-      messageId: "om_i18n_card",
-    });
-
-    expect(result).toEqual({
-      messageId: "om_i18n_card",
-      chatId: "oc_i18n_card",
-      chatType: undefined,
-      senderId: undefined,
-      senderOpenId: undefined,
-      senderType: undefined,
-      content: "hello 2 tasks {{metadata}}",
-      contentType: "interactive",
-      createTime: undefined,
-      threadId: undefined,
-    });
-  });
-
-  it("falls back to post-format content when interactive card elements are empty", async () => {
-    mockClientGet.mockResolvedValueOnce({
-      code: 0,
-      data: {
-        items: [
-          {
-            message_id: "om_post_card",
-            chat_id: "oc_post_card",
-            msg_type: "interactive",
-            body: {
-              content: JSON.stringify({
-                elements: [],
-                post: {
-                  zh_cn: {
-                    title: "Card summary",
-                    content: [[{ tag: "md", text: "**fallback** body" }]],
-                  },
-                },
-              }),
-            },
-          },
-        ],
-      },
-    });
-
-    const result = await getMessageFeishu({
-      cfg: {} as ClawdbotConfig,
-      messageId: "om_post_card",
-    });
-
-    expect(result).toEqual({
-      messageId: "om_post_card",
-      chatId: "oc_post_card",
-      chatType: undefined,
-      senderId: undefined,
-      senderOpenId: undefined,
-      senderType: undefined,
-      content: "Card summary\n\n**fallback** body",
-      contentType: "interactive",
-      createTime: undefined,
-      threadId: undefined,
-    });
-  });
-
-  it("extracts text content from post messages", async () => {
-    mockClientGet.mockResolvedValueOnce({
-      code: 0,
-      data: {
-        items: [
-          {
-            message_id: "om_post",
-            chat_id: "oc_post",
-            msg_type: "post",
-            body: {
-              content: JSON.stringify({
-                zh_cn: {
-                  title: "Summary",
-                  content: [[{ tag: "text", text: "post body" }]],
-                },
-              }),
-            },
-          },
-        ],
-      },
-    });
-
-    const result = await getMessageFeishu({
-      cfg: {} as ClawdbotConfig,
-      messageId: "om_post",
-    });
-
-    expect(result).toEqual({
-      messageId: "om_post",
-      chatId: "oc_post",
-      chatType: undefined,
-      senderId: undefined,
-      senderOpenId: undefined,
-      senderType: undefined,
-      content: "Summary\n\npost body",
-      contentType: "post",
-      createTime: undefined,
-      threadId: undefined,
-    });
-  });
-
-  it("returns text placeholder instead of raw JSON for unsupported message types", async () => {
-    mockClientGet.mockResolvedValueOnce({
-      code: 0,
-      data: {
-        items: [
-          {
-            message_id: "om_file",
-            chat_id: "oc_file",
-            msg_type: "file",
-            body: {
-              content: JSON.stringify({ file_key: "file_v3_123" }),
-            },
-          },
-        ],
-      },
-    });
-
-    const result = await getMessageFeishu({
-      cfg: {} as ClawdbotConfig,
-      messageId: "om_file",
-    });
-
-    expect(result).toEqual({
-      messageId: "om_file",
-      chatId: "oc_file",
-      chatType: undefined,
-      senderId: undefined,
-      senderOpenId: undefined,
-      senderType: undefined,
-      content: "[file message]",
-      contentType: "file",
-      createTime: undefined,
-      threadId: undefined,
-    });
-  });
-
-  it("supports single-object response shape from Feishu API", async () => {
-    mockClientGet.mockResolvedValueOnce({
-      code: 0,
-      data: {
-        message_id: "om_single",
-        chat_id: "oc_single",
-        msg_type: "text",
-        body: {
-          content: JSON.stringify({ text: "single payload" }),
-        },
-      },
-    });
-
-    const result = await getMessageFeishu({
-      cfg: {} as ClawdbotConfig,
-      messageId: "om_single",
-    });
-
-    expect(result).toEqual({
-      messageId: "om_single",
-      chatId: "oc_single",
-      chatType: undefined,
-      senderId: undefined,
-      senderOpenId: undefined,
-      senderType: undefined,
-      content: "single payload",
-      contentType: "text",
-      createTime: undefined,
-      threadId: undefined,
-    });
-  });
-
-  it("reuses the same content parsing for thread history messages", async () => {
-    mockClientList.mockResolvedValueOnce({
-      code: 0,
-      data: {
-        items: [
-          {
-            message_id: "om_root",
-            msg_type: "text",
-            body: {
-              content: JSON.stringify({ text: "root starter" }),
-            },
-          },
-          {
-            message_id: "om_card",
-            msg_type: "interactive",
-            body: {
-              content: JSON.stringify({
-                body: {
-                  elements: [{ tag: "markdown", content: "hello from card 2.0" }],
-                },
-              }),
-            },
-            sender: {
-              id: "app_1",
-              sender_type: "app",
-            },
-            create_time: "1710000000000",
-          },
-          {
-            message_id: "om_file",
-            msg_type: "file",
-            body: {
-              content: JSON.stringify({ file_key: "file_v3_123" }),
-            },
-            sender: {
-              id: "ou_1",
-              sender_type: "user",
-            },
-            create_time: "1710000001000",
-          },
-        ],
-      },
-    });
-
-    const result = await listFeishuThreadMessages({
-      cfg: {} as ClawdbotConfig,
-      threadId: "omt_1",
-      rootMessageId: "om_root",
-    });
-
-    expect(result).toEqual([
-      {
-        messageId: "om_file",
-        senderId: "ou_1",
-        senderType: "user",
-        contentType: "file",
-        content: "[file message]",
-        createTime: 1710000001000,
-      },
-      {
-        messageId: "om_card",
-        senderId: "app_1",
-        senderType: "app",
-        contentType: "interactive",
-        content: "hello from card 2.0",
-        createTime: 1710000000000,
-      },
-    ]);
-  });
-});
-
-describe("editMessageFeishu", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockResolveFeishuAccount.mockReturnValue({
-      accountId: "default",
-      configured: true,
-    });
-    mockCreateFeishuClient.mockReturnValue({
-      im: {
-        message: {
-          patch: mockClientPatch,
-        },
-      },
-    });
-  });
-
-  it("patches post content for text edits", async () => {
-    mockRuntimeResolveMarkdownTableMode.mockImplementation(() => {
-      throw new Error("Feishu runtime not initialized");
-    });
-    mockRuntimeConvertMarkdownTables.mockImplementation(() => {
-      throw new Error("Feishu runtime not initialized");
-    });
-    mockClientPatch.mockResolvedValueOnce({ code: 0 });
-
-    const result = await editMessageFeishu({
-      cfg: {} as ClawdbotConfig,
-      messageId: "om_edit",
-      text: "updated body",
-    });
-
-    expect(mockClientPatch).toHaveBeenCalledWith({
-      path: { message_id: "om_edit" },
-      data: {
-        content: JSON.stringify({
-          zh_cn: {
-            content: [
-              [
-                {
-                  tag: "md",
-                  text: "updated body",
-                },
-              ],
-            ],
-          },
-        }),
-      },
-    });
-    expect(result).toEqual({ messageId: "om_edit", contentType: "post" });
-  });
-
-  it("patches interactive content for card edits", async () => {
-    mockClientPatch.mockResolvedValueOnce({ code: 0 });
-
-    const result = await editMessageFeishu({
-      cfg: {} as ClawdbotConfig,
-      messageId: "om_card",
-      card: { schema: "2.0" },
-    });
-
-    expect(mockClientPatch).toHaveBeenCalledWith({
-      path: { message_id: "om_card" },
-      data: {
-        content: JSON.stringify({ schema: "2.0" }),
-      },
-    });
-    expect(result).toEqual({ messageId: "om_card", contentType: "interactive" });
-  });
-});
-
-describe("resolveFeishuCardTemplate", () => {
-  it("accepts supported Feishu templates", () => {
-    expect(resolveFeishuCardTemplate(" purple ")).toBe("purple");
-  });
-
-  it("drops unsupported free-form identity themes", () => {
-    expect(resolveFeishuCardTemplate("space lobster")).toBeUndefined();
-  });
-});
-
-function expectSchema2WidthConfig(card: unknown) {
-  const typedCard = card as {
-    config: {
-      width_mode?: string;
-      enable_forward?: boolean;
-      wide_screen_mode?: boolean;
-    };
-  };
-
-  expect(typedCard.config.width_mode).toBe("fill");
-  expect(typedCard.config.enable_forward).toBeUndefined();
-  expect(typedCard.config.wide_screen_mode).toBeUndefined();
-}
-
-describe("Feishu card schema config", () => {
-  it.each([
-    {
-      name: "structured card",
-      build: () => buildStructuredCard("hello"),
-    },
-    {
-      name: "markdown card",
-      build: () => buildMarkdownCard("hello"),
-    },
-  ])("$name uses schema-2.0 width config instead of legacy wide screen mode", ({ build }) => {
-    expectSchema2WidthConfig(build());
-  });
-});
-
-describe("buildStructuredCard", () => {
-  it("falls back to blue when the header template is unsupported", () => {
-    const card = buildStructuredCard("hello", {
-      header: {
-        title: "Agent",
-        template: "space lobster",
-      },
-    });
-
-    expect(card).toEqual({
-      schema: "2.0",
-      config: { width_mode: "fill" },
-      body: { elements: [{ tag: "markdown", content: "hello" }] },
-      header: {
-        title: { tag: "plain_text", content: "Agent" },
-        template: "blue",
-      },
-    });
-  });
-});