@llblab/pi-telegram 0.2.7 → 0.2.9

package/tests/replies.test.ts

@@ -1,239 +1,19 @@
 /**
- * Regression tests for the Telegram replies domain
- * Covers preview decisions, rendered-message delivery, and plain or markdown reply sending in one suite
+ * Regression tests for Telegram reply delivery helpers
+ * Covers rendered-message transport, chunk delivery, and plain or markdown final reply sending
  */
 
 import assert from "node:assert/strict";
 import test from "node:test";
 
 import {
-  buildTelegramPreviewFinalText,
-  buildTelegramPreviewFlushText,
   buildTelegramReplyTransport,
-  clearTelegramPreview,
   editTelegramRenderedMessage,
-  finalizeTelegramMarkdownPreview,
-  finalizeTelegramPreview,
-  flushTelegramPreview,
   sendTelegramMarkdownReply,
   sendTelegramPlainReply,
   sendTelegramRenderedChunks,
-  shouldUseTelegramDraftPreview,
 } from "../lib/replies.ts";
 
-function createPreviewRuntimeHarness(state?: {
-  mode: "draft" | "message";
-  draftId?: number;
-  messageId?: number;
-  pendingText: string;
-  lastSentText: string;
-  flushTimer?: ReturnType<typeof setTimeout>;
-}) {
-  let previewState = state;
-  let draftSupport: "unknown" | "supported" | "unsupported" = "unknown";
-  let nextDraftId = 10;
-  const events: string[] = [];
-  return {
-    events,
-    getState: () => previewState,
-    getDraftSupport: () => draftSupport,
-    setDraftSupport: (support: "unknown" | "supported" | "unsupported") => {
-      draftSupport = support;
-    },
-    deps: {
-      getState: () => previewState,
-      setState: (nextState: typeof previewState) => {
-        previewState = nextState;
-      },
-      clearScheduledFlush: (nextState: NonNullable<typeof previewState>) => {
-        if (!nextState.flushTimer) return;
-        clearTimeout(nextState.flushTimer);
-        nextState.flushTimer = undefined;
-        events.push("clear-timer");
-      },
-      maxMessageLength: 5,
-      renderPreviewText: (markdown: string) => markdown.replaceAll("*", ""),
-      getDraftSupport: () => draftSupport,
-      setDraftSupport: (support: "unknown" | "supported" | "unsupported") => {
-        draftSupport = support;
-      },
-      allocateDraftId: () => nextDraftId++,
-      sendDraft: async (chatId: number, draftId: number, text: string) => {
-        events.push(`draft:${chatId}:${draftId}:${text}`);
-      },
-      sendMessage: async (chatId: number, text: string) => {
-        events.push(`send:${chatId}:${text}`);
-        return { message_id: 77 };
-      },
-      editMessageText: async (
-        chatId: number,
-        messageId: number,
-        text: string,
-      ) => {
-        events.push(`edit:${chatId}:${messageId}:${text}`);
-      },
-      renderTelegramMessage: (text: string, options?: { mode?: string }) => [
-        { text: `${options?.mode ?? "plain"}:${text}` },
-      ],
-      sendRenderedChunks: async (
-        chatId: number,
-        chunks: Array<{ text: string }>,
-      ) => {
-        events.push(
-          `render-send:${chatId}:${chunks.map((chunk) => chunk.text).join("|")}`,
-        );
-        return 88;
-      },
-      editRenderedMessage: async (
-        chatId: number,
-        messageId: number,
-        chunks: Array<{ text: string }>,
-      ) => {
-        events.push(
-          `render-edit:${chatId}:${messageId}:${chunks.map((chunk) => chunk.text).join("|")}`,
-        );
-        return messageId;
-      },
-    },
-  };
-}
-
-test("Reply previews build flush text only when the preview changed", () => {
-  assert.equal(
-    buildTelegramPreviewFlushText({
-      state: {
-        mode: "draft",
-        pendingText: "**hello**",
-        lastSentText: "",
-      },
-      maxMessageLength: 4096,
-      renderPreviewText: (markdown) => markdown.replaceAll("*", ""),
-    }),
-    "hello",
-  );
-  assert.equal(
-    buildTelegramPreviewFlushText({
-      state: {
-        mode: "draft",
-        pendingText: "**hello**",
-        lastSentText: "hello",
-      },
-      maxMessageLength: 4096,
-      renderPreviewText: (markdown) => markdown.replaceAll("*", ""),
-    }),
-    undefined,
-  );
-});
-
-test("Reply previews truncate long flush text and compute final text fallback", () => {
-  assert.equal(
-    buildTelegramPreviewFlushText({
-      state: {
-        mode: "message",
-        pendingText: "abcdef",
-        lastSentText: "",
-      },
-      maxMessageLength: 3,
-      renderPreviewText: (markdown) => markdown,
-    }),
-    "abc",
-  );
-  assert.equal(
-    buildTelegramPreviewFinalText({
-      mode: "message",
-      pendingText: "   ",
-      lastSentText: "saved",
-    }),
-    "saved",
-  );
-  assert.equal(
-    buildTelegramPreviewFinalText({
-      mode: "message",
-      pendingText: "   ",
-      lastSentText: "   ",
-    }),
-    undefined,
-  );
-});
-
-test("Reply previews use drafts unless support is explicitly disabled", () => {
-  assert.equal(
-    shouldUseTelegramDraftPreview({ draftSupport: "unknown" }),
-    true,
-  );
-  assert.equal(
-    shouldUseTelegramDraftPreview({ draftSupport: "supported" }),
-    true,
-  );
-  assert.equal(
-    shouldUseTelegramDraftPreview({ draftSupport: "unsupported" }),
-    false,
-  );
-});
-
-test("Reply preview runtime prefers draft updates and can clear draft previews", async () => {
-  const harness = createPreviewRuntimeHarness({
-    mode: "draft",
-    pendingText: "**hello**",
-    lastSentText: "",
-    flushTimer: setTimeout(() => {}, 1000),
-  });
-  await flushTelegramPreview(7, harness.deps);
-  assert.deepEqual(harness.events, ["draft:7:10:hello"]);
-  assert.equal(harness.getState()?.mode, "draft");
-  assert.equal(harness.getState()?.draftId, 10);
-  assert.equal(harness.getState()?.lastSentText, "hello");
-  assert.equal(harness.getDraftSupport(), "supported");
-  await clearTelegramPreview(7, harness.deps);
-  assert.deepEqual(harness.events, ["draft:7:10:hello", "draft:7:10:"]);
-  assert.equal(harness.getState(), undefined);
-});
-
-test("Reply preview runtime falls back to editable messages when draft delivery fails", async () => {
-  const harness = createPreviewRuntimeHarness({
-    mode: "draft",
-    pendingText: "abcdef",
-    lastSentText: "",
-  });
-  harness.deps.sendDraft = async () => {
-    throw new Error("draft unsupported");
-  };
-  await flushTelegramPreview(7, harness.deps);
-  assert.deepEqual(harness.events, ["send:7:abcde"]);
-  assert.equal(harness.getState()?.mode, "message");
-  assert.equal(harness.getState()?.messageId, 77);
-  assert.equal(harness.getDraftSupport(), "unsupported");
-});
-
-test("Reply preview runtime finalizes plain and markdown previews", async () => {
-  const plainHarness = createPreviewRuntimeHarness({
-    mode: "message",
-    messageId: 44,
-    pendingText: "done",
-    lastSentText: "",
-  });
-  plainHarness.setDraftSupport("unsupported");
-  assert.equal(await finalizeTelegramPreview(7, plainHarness.deps), true);
-  assert.deepEqual(plainHarness.events, ["edit:7:44:done"]);
-  assert.equal(plainHarness.getState(), undefined);
-  const markdownHarness = createPreviewRuntimeHarness({
-    mode: "message",
-    messageId: 55,
-    pendingText: "done",
-    lastSentText: "",
-  });
-  markdownHarness.setDraftSupport("unsupported");
-  assert.equal(
-    await finalizeTelegramMarkdownPreview(7, "**done**", markdownHarness.deps),
-    true,
-  );
-  assert.deepEqual(markdownHarness.events, [
-    "edit:7:55:done",
-    "render-edit:7:55:markdown:**done**",
-  ]);
-  assert.equal(markdownHarness.getState(), undefined);
-});
-
 test("Reply transport forwards send and edit operations through delivery helpers", async () => {
   const events: string[] = [];
   const transport = buildTelegramReplyTransport({

package/tests/updates.test.ts

@@ -30,28 +30,20 @@ test("Update helpers normalize emoji reactions and collect emoji-only entries",
   assert.deepEqual([...emojis], ["👍", "👎"]);
 });
 
-test("Update helpers extract deleted message ids from Telegram update variants", () => {
+test("Update helpers extract deleted business-message ids only from Bot API shapes", () => {
   assert.deepEqual(
     extractDeletedTelegramMessageIds({
-      _: "other",
       deleted_business_messages: { message_ids: [1, 2] },
     }),
     [1, 2],
   );
   assert.deepEqual(
     extractDeletedTelegramMessageIds({
-      _: "updateDeleteMessages",
-      messages: [3, 4],
-    }),
-    [3, 4],
-  );
-  assert.deepEqual(
-    extractDeletedTelegramMessageIds({
-      _: "updateDeleteMessages",
-      messages: [3, "bad"],
+      deleted_business_messages: { message_ids: [3, "bad"] },
     }),
     [],
   );
+  assert.deepEqual(extractDeletedTelegramMessageIds({}), []);
 });
 
 test("Update routing classifies authorization state for pair, allow, and deny", () => {
@@ -101,11 +93,10 @@ test("Update routing extracts private human messages from message or edited_mess
   assert.ok(directMessage);
 });
 
-test("Update flow prioritizes deleted-message handling over other update kinds", () => {
+test("Update flow prioritizes deleted business-message handling over other update kinds", () => {
   const action = buildTelegramUpdateFlowAction(
     {
-      _: "updateDeleteMessages",
-      messages: [1, 2],
+      deleted_business_messages: { message_ids: [1, 2] },
       message_reaction: {
         chat: { type: "private" },
         user: { id: 1, is_bot: false },
@@ -119,7 +110,6 @@ test("Update flow prioritizes deleted-message handling over other update kinds",
 test("Update flow returns authorized callback and message actions", () => {
   const callbackAction = buildTelegramUpdateFlowAction(
     {
-      _: "other",
       callback_query: {
         from: { id: 7, is_bot: false },
         message: { chat: { type: "private" } },
@@ -129,11 +119,12 @@ test("Update flow returns authorized callback and message actions", () => {
   );
   assert.equal(callbackAction.kind, "callback");
   assert.deepEqual(
-    callbackAction.kind === "callback" ? callbackAction.authorization : undefined,
+    callbackAction.kind === "callback"
+      ? callbackAction.authorization
+      : undefined,
     { kind: "allow" },
   );
   const messageAction = buildTelegramUpdateFlowAction({
-    _: "other",
     message: {
       chat: { type: "private" },
       from: { id: 9, is_bot: false },
@@ -148,7 +139,6 @@ test("Update flow returns authorized callback and message actions", () => {
 
 test("Update flow ignores unauthorized transport shapes and preserves reaction events", () => {
   const reactionAction = buildTelegramUpdateFlowAction({
-    _: "other",
     message_reaction: {
       chat: { type: "private" },
       user: { id: 1, is_bot: false },
@@ -156,7 +146,6 @@ test("Update flow ignores unauthorized transport shapes and preserves reaction e
   });
   assert.equal(reactionAction.kind, "reaction");
   const ignored = buildTelegramUpdateFlowAction({
-    _: "other",
     callback_query: {
       from: { id: 1, is_bot: true },
       message: { chat: { type: "private" } },
@@ -218,7 +207,6 @@ test("Update execution plan preserves deleted and reaction actions", () => {
 test("Update execution plan can be built directly from updates", () => {
   const plan = buildTelegramUpdateExecutionPlanFromUpdate(
     {
-      _: "other",
       callback_query: {
         from: { id: 4, is_bot: false },
         message: { chat: { type: "private" } },
@@ -237,10 +225,10 @@ test("Update runtime executes delete and reaction plans through the right side e
     {
       ctx: {} as never,
       removePendingMediaGroupMessages: (ids) => {
-        events.push(`media:${ids.join(',')}`);
+        events.push(`media:${ids.join(",")}`);
       },
       removeQueuedTelegramTurnsByMessageIds: (ids) => {
-        events.push(`queue:${ids.join(',')}`);
+        events.push(`queue:${ids.join(",")}`);
         return ids.length;
       },
       handleAuthorizedTelegramReactionUpdate: async () => {
@@ -260,7 +248,6 @@ test("Update runtime can execute directly from raw updates", async () => {
   const events: string[] = [];
   await executeTelegramUpdate(
     {
-      _: "other",
       message: {
         chat: { id: 10, type: "private" },
         message_id: 20,
@@ -288,7 +275,11 @@ test("Update runtime can execute directly from raw updates", async () => {
       },
     },
   );
-  assert.deepEqual(events, ["pair", "reply:Telegram bridge paired with this account.", "message"]);
+  assert.deepEqual(events, [
+    "pair",
+    "reply:Telegram bridge paired with this account.",
+    "message",
+  ]);
 });
 
 test("Update runtime handles callback deny and message pair flows", async () => {