| |
| import { beforeEach, describe, expect, it, vi } from "vitest"; |
| import { PlatformMessageNotDispatchedError } from "../../infra/outbound/deliver-types.js"; |
|
|
| const mocks = vi.hoisted(() => ({ |
| loadChannelOutboundAdapter: vi.fn(), |
| })); |
|
|
| vi.mock("../../channels/plugins/outbound/load.js", () => ({ |
| loadChannelOutboundAdapter: mocks.loadChannelOutboundAdapter, |
| })); |
|
|
| describe("createChannelOutboundRuntimeSend", () => { |
| beforeEach(() => { |
| vi.clearAllMocks(); |
| }); |
|
|
| function expectSingleCallParams(mockFn: ReturnType<typeof vi.fn>) { |
| expect(mockFn).toHaveBeenCalledTimes(1); |
| const params = mockFn.mock.calls[0]?.[0] as Record<string, unknown> | undefined; |
| if (params === undefined) { |
| throw new Error("expected outbound send call params"); |
| } |
| return params; |
| } |
|
|
| it.each(["discord", "telegram"] as const)( |
| "classifies unavailable %s adapters as definitely not dispatched", |
| async (channelId) => { |
| mocks.loadChannelOutboundAdapter.mockResolvedValue(undefined); |
| const unavailableMessage = `${channelId} outbound adapter is unavailable.`; |
|
|
| const { createChannelOutboundRuntimeSend } = await import("./channel-outbound-send.js"); |
| const runtimeSend = createChannelOutboundRuntimeSend({ |
| channelId, |
| unavailableMessage, |
| }); |
|
|
| const error = await runtimeSend |
| .sendMessage("target", "hello", { cfg: {} }) |
| .catch((caught: unknown) => caught); |
| expect(error).toBeInstanceOf(PlatformMessageNotDispatchedError); |
| expect(error).toMatchObject({ |
| name: "PlatformMessageNotDispatchedError", |
| message: unavailableMessage, |
| cause: expect.objectContaining({ |
| message: unavailableMessage, |
| }), |
| }); |
| }, |
| ); |
|
|
| it("routes media sends through sendMedia and preserves media access", async () => { |
| const sendMedia = vi.fn(async () => ({ channel: "whatsapp", messageId: "wa-1" })); |
| mocks.loadChannelOutboundAdapter.mockResolvedValue({ |
| sendText: vi.fn(), |
| sendMedia, |
| }); |
|
|
| const { createChannelOutboundRuntimeSend } = await import("./channel-outbound-send.js"); |
| const mediaReadFile = vi.fn(async () => Buffer.from("image")); |
| const runtimeSend = createChannelOutboundRuntimeSend({ |
| channelId: "whatsapp" as never, |
| unavailableMessage: "unavailable", |
| }); |
|
|
| await runtimeSend.sendMessage("+15551234567", "caption", { |
| cfg: {}, |
| mediaUrl: "file:///tmp/photo.png", |
| mediaAccess: { |
| localRoots: ["/tmp/workspace"], |
| readFile: mediaReadFile, |
| }, |
| mediaLocalRoots: ["/tmp/fallback-root"], |
| mediaReadFile, |
| accountId: "default", |
| gifPlayback: true, |
| }); |
|
|
| const params = expectSingleCallParams(sendMedia); |
| expect(params.cfg).toEqual({}); |
| expect(params.to).toBe("+15551234567"); |
| expect(params.text).toBe("caption"); |
| expect(params.mediaUrl).toBe("file:///tmp/photo.png"); |
| expect(params.mediaAccess).toEqual({ |
| localRoots: ["/tmp/workspace"], |
| readFile: mediaReadFile, |
| }); |
| expect(params.mediaLocalRoots).toEqual(["/tmp/fallback-root"]); |
| expect(params.mediaReadFile).toBe(mediaReadFile); |
| expect(params.accountId).toBe("default"); |
| expect(params.gifPlayback).toBe(true); |
| }); |
|
|
| it("falls back to sendText for text-only sends", async () => { |
| const sendText = vi.fn(async () => ({ channel: "whatsapp", messageId: "wa-2" })); |
| mocks.loadChannelOutboundAdapter.mockResolvedValue({ |
| sendText, |
| sendMedia: vi.fn(), |
| }); |
|
|
| const { createChannelOutboundRuntimeSend } = await import("./channel-outbound-send.js"); |
| const runtimeSend = createChannelOutboundRuntimeSend({ |
| channelId: "whatsapp" as never, |
| unavailableMessage: "unavailable", |
| }); |
| const onPlatformSendDispatch = vi.fn(); |
|
|
| await runtimeSend.sendMessage("+15551234567", "hello", { |
| cfg: {}, |
| accountId: "default", |
| deliveryQueueId: "queue-1", |
| deliveryPartIndex: 3, |
| deliveryPartCount: 4, |
| onPlatformSendDispatch, |
| }); |
|
|
| const params = expectSingleCallParams(sendText); |
| expect(params.cfg).toEqual({}); |
| expect(params.to).toBe("+15551234567"); |
| expect(params.text).toBe("hello"); |
| expect(params.accountId).toBe("default"); |
| expect(params.deliveryQueueId).toBe("queue-1"); |
| expect(params.deliveryPartIndex).toBe(3); |
| expect(params.deliveryPartCount).toBe(4); |
| expect(params.onPlatformSendDispatch).toBe(onPlatformSendDispatch); |
| }); |
|
|
| it("preserves rendered html formatting through lazy text sends", async () => { |
| const sendText = vi.fn(async () => ({ channel: "telegram", messageId: "tg-1" })); |
| mocks.loadChannelOutboundAdapter.mockResolvedValue({ |
| sendText, |
| }); |
|
|
| const { createChannelOutboundRuntimeSend } = await import("./channel-outbound-send.js"); |
| const runtimeSend = createChannelOutboundRuntimeSend({ |
| channelId: "telegram" as never, |
| unavailableMessage: "unavailable", |
| }); |
| const opts = { |
| cfg: {}, |
| textMode: "html" as const, |
| }; |
|
|
| await runtimeSend.sendMessage("12345", '<a href="https://example.com">Example</a>', opts); |
|
|
| const params = expectSingleCallParams(sendText); |
| expect(params.formatting).toEqual({ parseMode: "HTML" }); |
| }); |
|
|
| it("routes block sends through payload delivery", async () => { |
| const sendPayload = vi.fn(async () => ({ channel: "slack", messageId: "slack-blocks" })); |
| const sendText = vi.fn(); |
| mocks.loadChannelOutboundAdapter.mockResolvedValue({ |
| sendPayload, |
| sendText, |
| }); |
|
|
| const { createChannelOutboundRuntimeSend } = await import("./channel-outbound-send.js"); |
| const runtimeSend = createChannelOutboundRuntimeSend({ |
| channelId: "slack" as never, |
| unavailableMessage: "unavailable", |
| }); |
| const blocks = [ |
| { |
| type: "actions", |
| elements: [{ type: "button", text: { type: "plain_text", text: "OK" }, value: "ok" }], |
| }, |
| ]; |
|
|
| await runtimeSend.sendMessage("C123", "fallback", { |
| cfg: {}, |
| accountId: "default", |
| blocks, |
| }); |
|
|
| const params = expectSingleCallParams(sendPayload); |
| expect(params.accountId).toBe("default"); |
| expect(params.cfg).toEqual({}); |
| expect(params.payload).toEqual({ |
| channelData: { |
| slack: { blocks }, |
| }, |
| text: "fallback", |
| }); |
| expect(params.text).toBe("fallback"); |
| expect(params.to).toBe("C123"); |
| expect(sendText).not.toHaveBeenCalled(); |
| }); |
|
|
| it("accepts plugin outbound thread and reply aliases", async () => { |
| const sendText = vi.fn(async () => ({ channel: "matrix", messageId: "$reply" })); |
| mocks.loadChannelOutboundAdapter.mockResolvedValue({ |
| sendText, |
| }); |
|
|
| const { createChannelOutboundRuntimeSend } = await import("./channel-outbound-send.js"); |
| const runtimeSend = createChannelOutboundRuntimeSend({ |
| channelId: "matrix" as never, |
| unavailableMessage: "unavailable", |
| }); |
|
|
| await runtimeSend.sendMessage("room:!ops:example.org", "hello thread", { |
| cfg: {}, |
| accountId: "sut", |
| replyToId: "$parent", |
| threadId: "$thread-root", |
| }); |
|
|
| const params = expectSingleCallParams(sendText); |
| expect(params.accountId).toBe("sut"); |
| expect(params.replyToId).toBe("$parent"); |
| expect(params.threadId).toBe("$thread-root"); |
| expect(params.to).toBe("room:!ops:example.org"); |
| }); |
|
|
| it("forwards Slack threadTs alias to threadId", async () => { |
| const sendText = vi.fn(async () => ({ channel: "slack", messageId: "slack-1" })); |
| mocks.loadChannelOutboundAdapter.mockResolvedValue({ |
| sendText, |
| }); |
|
|
| const { createChannelOutboundRuntimeSend } = await import("./channel-outbound-send.js"); |
| const runtimeSend = createChannelOutboundRuntimeSend({ |
| channelId: "slack" as never, |
| unavailableMessage: "unavailable", |
| }); |
|
|
| await runtimeSend.sendMessage("C123", "hello", { |
| cfg: {}, |
| threadTs: "1712345678.123456", |
| }); |
|
|
| const params = expectSingleCallParams(sendText); |
| expect(params.cfg).toEqual({}); |
| expect(params.to).toBe("C123"); |
| expect(params.text).toBe("hello"); |
| expect(params.threadId).toBe("1712345678.123456"); |
| }); |
|
|
| it("prefers canonical thread fields over Slack aliases", async () => { |
| const sendText = vi.fn(async () => ({ channel: "slack", messageId: "slack-2" })); |
| mocks.loadChannelOutboundAdapter.mockResolvedValue({ |
| sendText, |
| }); |
|
|
| const { createChannelOutboundRuntimeSend } = await import("./channel-outbound-send.js"); |
| const runtimeSend = createChannelOutboundRuntimeSend({ |
| channelId: "slack" as never, |
| unavailableMessage: "unavailable", |
| }); |
|
|
| await runtimeSend.sendMessage("C123", "hello", { |
| cfg: {}, |
| messageThreadId: "200.000", |
| threadId: "150.000", |
| threadTs: "100.000", |
| replyToMessageId: "400.000", |
| replyToId: "300.000", |
| }); |
|
|
| const params = expectSingleCallParams(sendText); |
| expect(params.cfg).toEqual({}); |
| expect(params.threadId).toBe("200.000"); |
| expect(params.replyToId).toBe("400.000"); |
| }); |
|
|
| it("falls back to sendText when media is present but sendMedia is unavailable", async () => { |
| const sendText = vi.fn(async () => ({ channel: "whatsapp", messageId: "wa-3" })); |
| mocks.loadChannelOutboundAdapter.mockResolvedValue({ |
| sendText, |
| }); |
|
|
| const { createChannelOutboundRuntimeSend } = await import("./channel-outbound-send.js"); |
| const mediaReadFile = vi.fn(async () => Buffer.from("pdf")); |
| const runtimeSend = createChannelOutboundRuntimeSend({ |
| channelId: "whatsapp" as never, |
| unavailableMessage: "unavailable", |
| }); |
|
|
| await runtimeSend.sendMessage("+15551234567", "caption", { |
| cfg: {}, |
| mediaUrl: "file:///tmp/test.pdf", |
| mediaAccess: { |
| localRoots: ["/tmp/workspace"], |
| readFile: mediaReadFile, |
| }, |
| mediaLocalRoots: ["/tmp/fallback-root"], |
| mediaReadFile, |
| accountId: "default", |
| forceDocument: true, |
| }); |
|
|
| const params = expectSingleCallParams(sendText); |
| expect(params.cfg).toEqual({}); |
| expect(params.to).toBe("+15551234567"); |
| expect(params.text).toBe("caption"); |
| expect(params.mediaUrl).toBe("file:///tmp/test.pdf"); |
| expect(params.mediaAccess).toEqual({ |
| localRoots: ["/tmp/workspace"], |
| readFile: mediaReadFile, |
| }); |
| expect(params.mediaLocalRoots).toEqual(["/tmp/fallback-root"]); |
| expect(params.mediaReadFile).toBe(mediaReadFile); |
| expect(params.accountId).toBe("default"); |
| expect(params.forceDocument).toBe(true); |
| }); |
| }); |
|
|
