openclaw/extensions/qqbot/src/engine/gateway/message-queue.test.ts

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();
    });
  });
});