chat: { id: "123" },

});

await sendMessageTelegram("123", "hi", { ...testCase.opts, cfg: testCase.cfg });

const [token, options] = requireMockCall(botCtorSpy.mock.calls[0], "bot constructor call");

const [token, options] = requireMockCall(botCtorSpy.mock.calls.at(0), "bot constructor call");

expect(token, testCase.name).toBe("tok");

const client = requireRecord(requireRecord(options, "bot options").client, "bot client");

expect(client.timeoutSeconds, testCase.name).toBe(testCase.expectedTimeout);

await sendMessageTelegram("123", "hi", { cfg, token: "tok", accountId: "foo" });

const [token, options] = requireMockCall(botCtorSpy.mock.calls[0], "bot constructor call");

const [token, options] = requireMockCall(botCtorSpy.mock.calls.at(0), "bot constructor call");

expect(token).toBe("tok");

const client = requireRecord(requireRecord(options, "bot options").client, "bot client");

expect(client.apiRoot).toBe("https://api.telegram.org");

await sendMessageTelegram("123", "hi", { cfg: TELEGRAM_TEST_CFG, token: "tok" });

const [middleware] = requireMockCall(botConfigUseSpy.mock.calls[0], "bot config use call");

const [middleware] = requireMockCall(botConfigUseSpy.mock.calls.at(0), "bot config use call");

expect(middleware).toBeTypeOf("function");

});

});

try {

await sendMessageTelegram("123", "hi", { cfg: TELEGRAM_TEST_CFG, token: "tok" });

const clientFetch = (botCtorSpy.mock.calls[0]?.[1] as { client?: { fetch?: unknown } })

const clientFetch = (botCtorSpy.mock.calls.at(0)?.[1] as { client?: { fetch?: unknown } })

?.client?.fetch;

expect(clientFetch).toBeTypeOf("function");

expect(clientFetch).not.toBe(fetchSpy);

messageThreadId: 99,

});

expectMediaSendCall(sendPhoto.mock.calls[0], "send photo call", chatId, {

expectMediaSendCall(sendPhoto.mock.calls.at(0), "send photo call", chatId, {

caption: "photo in topic",

parse_mode: "HTML",

message_thread_id: 99,

mediaUrl: "https://example.com/photo.jpg",

});

expectMediaSendCall(sendPhoto.mock.calls[0], "send photo call", chatId, {

expectMediaSendCall(sendPhoto.mock.calls.at(0), "send photo call", chatId, {

caption: undefined,

});

expect(sendMessage).toHaveBeenCalledWith(chatId, longText, {

mediaUrl: "https://example.com/photo.jpg",

});

expectMediaSendCall(sendPhoto.mock.calls[0], "send photo call", chatId, {

expectMediaSendCall(sendPhoto.mock.calls.at(0), "send photo call", chatId, {

caption: undefined,

});

expect(sendMessage).toHaveBeenCalledTimes(2);

mediaUrl: "https://example.com/photo.jpg",

});

expectMediaSendCall(sendPhoto.mock.calls[0], "send photo call", chatId, {

expectMediaSendCall(sendPhoto.mock.calls.at(0), "send photo call", chatId, {

caption: shortText,

parse_mode: "HTML",

});

mediaUrl: "https://example.com/photo.jpg",

});

expectMediaSendCall(sendPhoto.mock.calls[0], "send photo call", chatId, {

expectMediaSendCall(sendPhoto.mock.calls.at(0), "send photo call", chatId, {

caption: "hi <b>boss</b>",

parse_mode: "HTML",

});

asVideoNote: true,

});

expectMediaSendCall(sendVideoNote.mock.calls[0], "send video note call", chatId, {});

expectMediaSendCall(sendVideoNote.mock.calls.at(0), "send video note call", chatId, {});

expect(sendMessage).toHaveBeenCalledWith(chatId, text, {

parse_mode: "HTML",

});

asVideoNote: false,

});

const [, media, videoParams] = requireMockCall(sendVideo.mock.calls[0], "send video call");

expect(sendVideo.mock.calls[0]?.[0]).toBe(chatId);

const [, media, videoParams] = requireMockCall(sendVideo.mock.calls.at(0), "send video call");

expect(sendVideo.mock.calls.at(0)?.[0]).toBe(chatId);

if (media === undefined) {

throw new Error("expected send video media");

}

});

expect(probeVideoDimensions).toHaveBeenCalledWith(videoBuffer);

expectMediaSendCall(sendVideo.mock.calls[0], "send video call", chatId, {

expectMediaSendCall(sendVideo.mock.calls.at(0), "send video call", chatId, {

caption: "my caption",

parse_mode: "HTML",

width: 720,

});

expect(probeVideoDimensions).not.toHaveBeenCalled();

expectMediaSendCall(sendVideoNote.mock.calls[0], "send video note call", chatId, {});

expectMediaSendCall(sendVideoNote.mock.calls.at(0), "send video note call", chatId, {});

});

it("applies reply markup and thread options to split video-note sends", async () => {

await sendMessageTelegram(chatId, testCase.text, sendOptions);

expectMediaSendCall(

sendVideoNote.mock.calls[0],

sendVideoNote.mock.calls.at(0),

"send video note call",

chatId,

testCase.expectedVideoNote,

await vi.runAllTimersAsync();

await expect(promise).resolves.toEqual({ messageId: "1", chatId });

expect(setTimeoutSpy.mock.calls[0]?.[1]).toBe(500);

expect(setTimeoutSpy.mock.calls.at(0)?.[1]).toBe(500);

setTimeoutSpy.mockRestore();

vi.useRealTimers();

});

});

expect(sendAnimation).toHaveBeenCalledTimes(1);

expectMediaSendCall(sendAnimation.mock.calls[0], "send animation call", chatId, {

expectMediaSendCall(sendAnimation.mock.calls.at(0), "send animation call", chatId, {

caption: "caption",

parse_mode: "HTML",

});

forceDocument: true,

});

expectMediaSendCall(sendDocument.mock.calls[0], `send document call ${testCase.name}`, chatId, {

caption: "caption",

parse_mode: "HTML",

disable_content_type_detection: true,

});

expectMediaSendCall(

sendDocument.mock.calls.at(0),

`send document call ${testCase.name}`,

chatId,

{

caption: "caption",

parse_mode: "HTML",

disable_content_type_detection: true,

},

);

expect(sendPhoto, testCase.name).not.toHaveBeenCalled();

expect(sendAnimation, testCase.name).not.toHaveBeenCalled();

expect(sendVideo, testCase.name).not.toHaveBeenCalled();

mediaUrl: "https://example.com/photo.png",

});

expectMediaSendCall(sendDocument.mock.calls[0], "send document call", chatId, {

expectMediaSendCall(sendDocument.mock.calls.at(0), "send document call", chatId, {

caption: "caption",

parse_mode: "HTML",

});

mediaUrl: "https://example.com/photo.png",

});

expectMediaSendCall(sendDocument.mock.calls[0], "send document call", chatId, {

expectMediaSendCall(sendDocument.mock.calls.at(0), "send document call", chatId, {

caption: "caption",

parse_mode: "HTML",

});

mediaUrl: "https://example.com/report.pdf",

});

expectMediaSendCall(sendDocument.mock.calls[0], "send document call", chatId, {

expectMediaSendCall(sendDocument.mock.calls.at(0), "send document call", chatId, {

caption: "caption",

parse_mode: "HTML",

});

const called = testCase.expectedMethod === "sendVoice" ? sendVoice : sendAudio;

const notCalled = testCase.expectedMethod === "sendVoice" ? sendAudio : sendVoice;

expectMediaSendCall(

called.mock.calls[0],

called.mock.calls.at(0),

`${testCase.expectedMethod} call ${testCase.name}`,

testCase.chatId,

testCase.expectedOptions,

messageThreadId: 271,

});

expectMediaSendCall(sendPhoto.mock.calls[0], "first send photo call", chatId, {

expectMediaSendCall(sendPhoto.mock.calls.at(0), "first send photo call", chatId, {

caption: "photo",

parse_mode: "HTML",

message_thread_id: 271,

});

expectMediaSendCall(sendPhoto.mock.calls[1], "second send photo call", chatId, {

expectMediaSendCall(sendPhoto.mock.calls.at(1), "second send photo call", chatId, {

caption: "photo",

parse_mode: "HTML",

});

mediaUrl: "https://example.com/photo.jpg",

});

const [mediaUrl, options] = requireMockCall(loadWebMedia.mock.calls[0], "load web media call");

const [mediaUrl, options] = requireMockCall(

loadWebMedia.mock.calls.at(0),

"load web media call",

);

expect(mediaUrl).toBe("https://example.com/photo.jpg");

expect(requireRecord(options, "load web media options").maxBytes).toBe(100 * 1024 * 1024);

});

mediaUrl: "https://example.com/photo.jpg",

});

const [mediaUrl, options] = requireMockCall(loadWebMedia.mock.calls[0], "load web media call");

const [mediaUrl, options] = requireMockCall(

loadWebMedia.mock.calls.at(0),

"load web media call",

);

expect(mediaUrl).toBe("https://example.com/photo.jpg");

expect(requireRecord(options, "load web media options").maxBytes).toBe(42 * 1024 * 1024);

});

});

expect(sendMessage).toHaveBeenCalledTimes(2);

const firstCall = requireMockCall(sendMessage.mock.calls[0], "first sendMessage call");

const secondCall = requireMockCall(sendMessage.mock.calls[1], "second sendMessage call");

const firstCall = requireMockCall(sendMessage.mock.calls.at(0), "first sendMessage call");

const secondCall = requireMockCall(sendMessage.mock.calls.at(1), "second sendMessage call");

expect((firstCall[1] as string).length).toBeLessThanOrEqual(4000);

expect((secondCall[1] as string).length).toBeLessThanOrEqual(4000);

expect(firstCall[2]?.reply_markup).toBeUndefined();

});

expect(sendMessage).toHaveBeenCalledTimes(2);

const firstCall = requireMockCall(sendMessage.mock.calls[0], "first sendMessage call");

const secondCall = requireMockCall(sendMessage.mock.calls[1], "second sendMessage call");

const firstCall = requireMockCall(sendMessage.mock.calls.at(0), "first sendMessage call");

const secondCall = requireMockCall(sendMessage.mock.calls.at(1), "second sendMessage call");

expect(String(firstCall[1] ?? "").length).toBeLessThanOrEqual(4000);

expect(String(secondCall[1] ?? "").length).toBeLessThanOrEqual(4000);

expect(firstCall[2]?.parse_mode).toBe("HTML");

});

expect(sendMessage).toHaveBeenCalledTimes(4);

const plainFallbackCalls = [sendMessage.mock.calls[1], sendMessage.mock.calls[3]];

const plainFallbackCalls = [sendMessage.mock.calls.at(1), sendMessage.mock.calls.at(3)];

expect(plainFallbackCalls.map((call) => String(call?.[1] ?? "")).join("")).toBe(plainText);

expect(plainFallbackCalls.some((call) => String(call?.[1] ?? "").includes("<"))).toBe(false);

expect(res.messageId).toBe("91");

});

expect(sendMessage).toHaveBeenCalledTimes(4);

expect(String(sendMessage.mock.calls[0]?.[1] ?? "")).toMatch(/^&/);

const plainFallbackCalls = [sendMessage.mock.calls[1], sendMessage.mock.calls[3]];

expect(String(sendMessage.mock.calls.at(0)?.[1] ?? "")).toMatch(/^&/);

const plainFallbackCalls = [sendMessage.mock.calls.at(1), sendMessage.mock.calls.at(3)];

expect(plainFallbackCalls.map((call) => String(call?.[1] ?? "")).join("")).toBe(plainText);

expect(plainFallbackCalls.every((call) => String(call?.[1] ?? "").length > 0)).toBe(true);

expect(res.messageId).toBe("93");

await vi.runAllTimersAsync();

await expect(promise).resolves.toEqual({ messageId: "109", chatId });

expect(setTimeoutSpy.mock.calls[0]?.[1]).toBe(1000);

expect(setTimeoutSpy.mock.calls.at(0)?.[1]).toBe(1000);

expect(sendSticker).toHaveBeenCalledTimes(2);

setTimeoutSpy.mockRestore();

vi.useRealTimers();

});

expect(botCtorSpy, testCase.name).toHaveBeenCalledTimes(1);

expect(botCtorSpy.mock.calls[0]?.[0], testCase.name).toBe("tok");

expect(botCtorSpy.mock.calls.at(0)?.[0], testCase.name).toBe("tok");

expect(botApi.editMessageText, testCase.name).toHaveBeenCalledTimes(testCase.expectedCalls);

const firstParams = requireRecord(

(botApi.editMessageText.mock.calls[0] ?? [])[3],

(botApi.editMessageText.mock.calls.at(0) ?? [])[3],

"first edit params",

);

expect(firstParams.parse_mode, testCase.name).toBe("HTML");

if ("secondExpectReplyMarkup" in testCase && testCase.secondExpectReplyMarkup) {

const secondParams = requireRecord(

(botApi.editMessageText.mock.calls[1] ?? [])[3],

(botApi.editMessageText.mock.calls.at(1) ?? [])[3],

"second edit params",

);

expect(secondParams.reply_markup, testCase.name).toEqual(testCase.secondExpectReplyMarkup);

});

expect(botApi.editMessageText).toHaveBeenCalledTimes(1);

const params = requireRecord((botApi.editMessageText.mock.calls[0] ?? [])[3], "edit params");

const params = requireRecord((botApi.editMessageText.mock.calls.at(0) ?? [])[3], "edit params");

expect(params.parse_mode).toBe("HTML");

expect(params.link_preview_options).toEqual({ is_disabled: true });

});

expect(res).toEqual({ messageId: "123", chatId: "555", pollId: "p1" });

expect(api.sendPoll).toHaveBeenCalledTimes(1);

const sendPollMock = api.sendPoll as ReturnType<typeof vi.fn>;

expect(sendPollMock.mock.calls[0]?.[0]).toBe("123");

expect(sendPollMock.mock.calls[0]?.[1]).toBe("Q");

expect(sendPollMock.mock.calls[0]?.[2]).toEqual(["A", "B"]);

expect(requireRecord(sendPollMock.mock.calls[0]?.[3], "send poll params").open_period).toBe(60);

expect(sendPollMock.mock.calls.at(0)?.[0]).toBe("123");

expect(sendPollMock.mock.calls.at(0)?.[1]).toBe("Q");

expect(sendPollMock.mock.calls.at(0)?.[2]).toEqual(["A", "B"]);

expect(requireRecord(sendPollMock.mock.calls.at(0)?.[3], "send poll params").open_period).toBe(

60,

);

});

it("retries without message_thread_id on thread-not-found", async () => {

expect(res).toEqual({ messageId: "1", chatId: "2", pollId: "p2" });

expect(api.sendPoll).toHaveBeenCalledTimes(2);

expect(

requireRecord(api.sendPoll.mock.calls[0]?.[3], "send poll params").message_thread_id,

requireRecord(api.sendPoll.mock.calls.at(0)?.[3], "send poll params").message_thread_id,

).toBe(99);

expect(

(api.sendPoll.mock.calls[1]?.[3] as { message_thread_id?: unknown } | undefined)

(api.sendPoll.mock.calls.at(1)?.[3] as { message_thread_id?: unknown } | undefined)

?.message_thread_id,

).toBeUndefined();

});