@openclaw/qqbot 2026.5.2 → 2026.5.3-beta.2

package/src/engine/gateway/message-queue.test.ts

@@ -1,282 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { createMessageQueue, mergeGroupMessages, type QueuedMessage } from "./message-queue.js";
-
-function groupMsg(overrides: Partial<QueuedMessage> = {}): QueuedMessage {
-  return {
-    type: "group",
-    senderId: "U1",
-    senderName: "Alice",
-    content: "hello",
-    messageId: "M1",
-    timestamp: "2026-01-01T00:00:00Z",
-    groupOpenid: "G1",
-    ...overrides,
-  };
-}
-
-describe("engine/gateway/message-queue", () => {
-  describe("mergeGroupMessages", () => {
-    it("returns the single message unchanged", () => {
-      const m = groupMsg();
-      const merged = mergeGroupMessages([m]);
-      expect(merged).toBe(m);
-    });
-
-    it("joins content with sender prefix per line", () => {
-      const merged = mergeGroupMessages([
-        groupMsg({ senderName: "A", content: "hi" }),
-        groupMsg({ senderName: "B", content: "yo" }),
-      ]);
-      expect(merged.content).toBe("[A]: hi\n[B]: yo");
-      expect(merged.merge?.count).toBe(2);
-      expect(merged.merge?.messages).toHaveLength(2);
-    });
-
-    it("takes messageId / msgIdx / timestamp from the last message", () => {
-      const merged = mergeGroupMessages([
-        groupMsg({ messageId: "M1", msgIdx: "I1", timestamp: "T1" }),
-        groupMsg({ messageId: "M2", msgIdx: "I2", timestamp: "T2" }),
-      ]);
-      expect(merged.messageId).toBe("M2");
-      expect(merged.msgIdx).toBe("I2");
-      expect(merged.timestamp).toBe("T2");
-    });
-
-    it("takes refMsgIdx from the first message", () => {
-      const merged = mergeGroupMessages([
-        groupMsg({ refMsgIdx: "R1" }),
-        groupMsg({ refMsgIdx: "R2" }),
-      ]);
-      expect(merged.refMsgIdx).toBe("R1");
-    });
-
-    it("concatenates attachments in order", () => {
-      const merged = mergeGroupMessages([
-        groupMsg({
-          attachments: [{ content_type: "image/png", url: "a" }],
-        }),
-        groupMsg({
-          attachments: [
-            { content_type: "image/png", url: "b" },
-            { content_type: "image/png", url: "c" },
-          ],
-        }),
-      ]);
-      expect(merged.attachments?.map((a) => a.url)).toEqual(["a", "b", "c"]);
-    });
-
-    it("deduplicates mentions by member/user openid", () => {
-      const merged = mergeGroupMessages([
-        groupMsg({ mentions: [{ member_openid: "X" }, { member_openid: "Y" }] }),
-        groupMsg({ mentions: [{ member_openid: "X" }, { member_openid: "Z" }] }),
-      ]);
-      expect(merged.mentions?.map((m) => m.member_openid)).toEqual(["X", "Y", "Z"]);
-    });
-
-    it("flags merged turn as @bot when ANY source was GROUP_AT_MESSAGE_CREATE", () => {
-      const merged = mergeGroupMessages([
-        groupMsg({ eventType: "GROUP_MESSAGE_CREATE" }),
-        groupMsg({ eventType: "GROUP_AT_MESSAGE_CREATE" }),
-      ]);
-      expect(merged.eventType).toBe("GROUP_AT_MESSAGE_CREATE");
-    });
-
-    it("keeps last eventType when no @bot event was present", () => {
-      const merged = mergeGroupMessages([
-        groupMsg({ eventType: "GROUP_MESSAGE_CREATE" }),
-        groupMsg({ eventType: "GROUP_MESSAGE_CREATE" }),
-      ]);
-      expect(merged.eventType).toBe("GROUP_MESSAGE_CREATE");
-    });
-
-    it("marks as bot only when every source is a bot", () => {
-      expect(
-        mergeGroupMessages([groupMsg({ senderIsBot: true }), groupMsg({ senderIsBot: false })])
-          .senderIsBot,
-      ).toBe(false);
-
-      expect(
-        mergeGroupMessages([groupMsg({ senderIsBot: true }), groupMsg({ senderIsBot: true })])
-          .senderIsBot,
-      ).toBe(true);
-    });
-  });
-
-  describe("createMessageQueue enqueue / evict", () => {
-    it("uses group peerId for group messages", () => {
-      const q = createMessageQueue({ accountId: "a", isAborted: () => true });
-      expect(q.getMessagePeerId(groupMsg({ groupOpenid: "G9" }))).toBe("group:G9");
-    });
-
-    it("uses dm peerId for c2c messages", () => {
-      const q = createMessageQueue({ accountId: "a", isAborted: () => true });
-      expect(
-        q.getMessagePeerId({
-          ...groupMsg(),
-          type: "c2c",
-          groupOpenid: undefined,
-          senderId: "U9",
-        }),
-      ).toBe("dm:U9");
-    });
-
-    it("enqueue without processor still drains (no-op when fn is null)", async () => {
-      // When no processor is attached, drain shifts messages but does
-      // nothing with them. The queue ends empty on the next microtask.
-      const q = createMessageQueue({ accountId: "a", isAborted: () => false });
-      q.enqueue(groupMsg({ messageId: "M1" }));
-      q.enqueue(groupMsg({ messageId: "M2" }));
-      await Promise.resolve();
-      await Promise.resolve();
-      expect(q.getSnapshot("group:G1").senderPending).toBe(0);
-    });
-
-    it("group overflow evicts a bot message first (eviction is synchronous)", () => {
-      // Use isAborted=true so drain exits immediately on the first
-      // microtask. Our `eviction` logic runs synchronously inside
-      // enqueue, BEFORE drain kicks in, so the 4th enqueue still has to
-      // evict even though we never actually process anything.
-      const q = createMessageQueue({
-        accountId: "a",
-        isAborted: () => true,
-        groupQueueSize: 3,
-      });
-      // Fill the queue to the cap (3), then enqueue one more to trigger
-      // eviction. The first three enqueues trigger drainUserQueue which
-      // synchronously deletes the empty queue in its finally block when
-      // isAborted=true. We bypass that by calling enqueue then reading
-      // inside the same synchronous tick via getSnapshot is NOT viable,
-      // so we instead observe the eviction by counting what ends up
-      // visible after the queue has stabilized.
-      q.enqueue(groupMsg({ messageId: "H1" }));
-      q.enqueue(groupMsg({ messageId: "B1", senderIsBot: true }));
-      q.enqueue(groupMsg({ messageId: "H2" }));
-      q.enqueue(groupMsg({ messageId: "H3" }));
-      // With isAborted=true the drain deletes the queue after each
-      // enqueue, so the snapshot just confirms we didn't throw. The
-      // actual eviction logic is covered by the "group overflow via
-      // processor" scenario below.
-      expect(q.getSnapshot("group:G1").senderPending).toBe(0);
-    });
-
-    it("group overflow drops bot messages first (via processor)", async () => {
-      const seen: QueuedMessage[] = [];
-      let gate!: (value?: unknown) => void;
-      const blocker = new Promise((res) => {
-        gate = res;
-      });
-      const q = createMessageQueue({
-        accountId: "a",
-        isAborted: () => false,
-        groupQueueSize: 3,
-      });
-      q.startProcessor(async (msg) => {
-        seen.push(msg);
-        // Hold the processor until we've filled the queue to capacity.
-        await blocker;
-      });
-      // First enqueue starts processing immediately (blocker held).
-      q.enqueue(groupMsg({ messageId: "First" }));
-      await Promise.resolve();
-      // Now fill the queue with 3 more (cap=3).
-      q.enqueue(groupMsg({ messageId: "H1" }));
-      q.enqueue(groupMsg({ messageId: "B1", senderIsBot: true }));
-      q.enqueue(groupMsg({ messageId: "H2" }));
-      expect(q.getSnapshot("group:G1").senderPending).toBe(3);
-      // 5th enqueue → eviction. Bot message (B1) should be the victim.
-      q.enqueue(groupMsg({ messageId: "H3" }));
-      const peerQueueIds = q.getSnapshot("group:G1");
-      expect(peerQueueIds.senderPending).toBe(3);
-      // Release the processor and drain.
-      gate();
-      await new Promise((res) => setTimeout(res, 0));
-      const seenIds = seen.map((m) => m.messageId);
-      expect(seenIds).toContain("First");
-      // The bot message should NOT have been processed — it was evicted.
-      // (Note: The first batch ran merged, so the exact count of calls
-      //  varies; we only assert the bot message id never appeared.)
-      const mergedCall = seen.find((m) => (m.merge?.count ?? 0) > 1);
-      if (mergedCall) {
-        expect(mergedCall.merge?.messages.map((m) => m.messageId)).not.toContain("B1");
-      } else {
-        expect(seenIds).not.toContain("B1");
-      }
-    });
-
-    it("clearUserQueue drops buffered items before drain runs", () => {
-      // Use a processor that never resolves so enqueued messages stay
-      // buffered behind a single active worker — then clearUserQueue
-      // should drop the rest.
-      let release!: () => void;
-      const blocker = new Promise<void>((res) => {
-        release = res;
-      });
-      const q = createMessageQueue({ accountId: "a", isAborted: () => false });
-      q.startProcessor(async () => {
-        await blocker;
-      });
-      q.enqueue(groupMsg({ messageId: "M1" }));
-      q.enqueue(groupMsg({ messageId: "M2" }));
-      q.enqueue(groupMsg({ messageId: "M3" }));
-      // First message is being processed; remaining two are queued.
-      expect(q.getSnapshot("group:G1").senderPending).toBeGreaterThanOrEqual(0);
-      const dropped = q.clearUserQueue("group:G1");
-      expect(dropped).toBeGreaterThanOrEqual(0);
-      release();
-    });
-  });
-
-  describe("drainGroupBatch merging", () => {
-    it("merges multiple normal group messages into one processor call", async () => {
-      const seen: QueuedMessage[] = [];
-      let aborted = false;
-      const q = createMessageQueue({
-        accountId: "a",
-        isAborted: () => aborted,
-      });
-      q.startProcessor(async (msg) => {
-        seen.push(msg);
-      });
-      // Enqueue three normal group messages synchronously so they batch
-      // before the drain loop kicks in — the first enqueue starts the
-      // drain, but the synchronous enqueues land before the first await.
-      q.enqueue(groupMsg({ messageId: "M1", content: "hi" }));
-      q.enqueue(groupMsg({ messageId: "M2", content: "yo" }));
-      q.enqueue(groupMsg({ messageId: "M3", content: "!!" }));
-      // Allow microtasks to flush.
-      await Promise.resolve();
-      await Promise.resolve();
-      aborted = true;
-      // Depending on timing the first message may have been processed solo;
-      // what we guarantee is that the total processor calls are fewer than
-      // three and the remaining messages were merged.
-      expect(seen.length).toBeGreaterThanOrEqual(1);
-      expect(seen.length).toBeLessThan(3);
-      const mergedCall = seen.find((m) => (m.merge?.count ?? 0) > 1);
-      expect(mergedCall).toBeDefined();
-      expect(mergedCall?.content).toContain("[Alice]:");
-    });
-
-    it("processes slash commands independently from regular messages", async () => {
-      const seen: QueuedMessage[] = [];
-      let aborted = false;
-      const q = createMessageQueue({
-        accountId: "a",
-        isAborted: () => aborted,
-      });
-      q.startProcessor(async (msg) => {
-        seen.push(msg);
-      });
-      q.enqueue(groupMsg({ messageId: "M1", content: "hi" }));
-      q.enqueue(groupMsg({ messageId: "M2", content: "/stop" }));
-      q.enqueue(groupMsg({ messageId: "M3", content: "yo" }));
-      await Promise.resolve();
-      await Promise.resolve();
-      aborted = true;
-      // Command should appear as its own call (not merged with the others).
-      const cmdCall = seen.find((m) => m.content === "/stop");
-      expect(cmdCall).toBeDefined();
-      expect(cmdCall?.merge).toBeUndefined();
-    });
-  });
-});