Skip to content

armgit / dbx

Public Imported from GitHub
0

25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。

29.8 KB
Raw Blame
// @vitest-environment happy-dom

import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { createApp, h, nextTick, ref, type App } from "vue";
import type { MqSystemKind, PeekedMessage } from "@/types/mq";

const backend = vi.hoisted(() => ({
  mqPeekMessages: vi.fn(),
}));

const clipboard = vi.hoisted(() => ({
  copyToClipboard: vi.fn(),
}));

const toast = vi.hoisted(() => ({
  toast: vi.fn(),
}));

vi.mock("vue-i18n", () => ({
  useI18n: () => ({ t: (key: string, params?: Record<string, unknown>) => (params ? `${key}:${JSON.stringify(params)}` : key) }),
}));

vi.mock("@/lib/backend/api", () => ({
  mqPeekMessages: backend.mqPeekMessages,
}));

vi.mock("@/lib/common/clipboard", () => ({
  copyToClipboard: clipboard.copyToClipboard,
}));

vi.mock("@/composables/useToast", () => ({
  useToast: () => toast,
}));

vi.mock("@/components/ui/select", async () => (await import("./selectStub")).createSelectStub());

import MessageBrowser from "@/components/mq/MessageBrowser.vue";

const TOPIC = {
  tenant: "_kafka",
  namespace: "default",
  topic: "events",
  persistent: true,
  partitioned: false,
};

let app: App<Element> | null = null;
let root: HTMLDivElement | null = null;

async function flushUi() {
  await Promise.resolve();
  await Promise.resolve();
  await nextTick();
}

function buttonByText(container: ParentNode, text: string): HTMLButtonElement {
  const button = [...container.querySelectorAll<HTMLButtonElement>("button")].find((item) => item.textContent?.includes(text));
  if (!button) throw new Error(`Button not found: ${text}`);
  return button;
}

async function setInputValue(input: HTMLInputElement, value: string) {
  input.value = value;
  input.dispatchEvent(new Event("input", { bubbles: true }));
  await nextTick();
}

async function setSelectValue(trigger: HTMLElement, value: string) {
  trigger.click();
  await flushUi();
  const item = document.querySelector<HTMLElement>(`[data-slot="select-item"][data-value="${value}"]`);
  if (!item) throw new Error(`Select item not found: ${value}`);
  item.click();
  await flushUi();
}

async function mountBrowser(mqSystemKind: "kafka" | "rabbitmq" = "kafka", appearance: "form" | "monitoring" = "form") {
  root = document.createElement("div");
  document.body.appendChild(root);
  app = createApp(MessageBrowser, {
    connectionId: "mq-1",
    topic: { ...TOPIC, tenant: mqSystemKind === "rabbitmq" ? "_rabbitmq" : "_kafka" },
    mqSystemKind,
    appearance,
  });
  app.mount(root);
  await flushUi();
  return root;
}

async function mountBrowserWithMutableTopic() {
  const topic = ref({ ...TOPIC });
  const connectionId = ref("mq-1");
  const mqSystemKind = ref<MqSystemKind>("kafka");
  root = document.createElement("div");
  document.body.appendChild(root);
  app = createApp({
    setup: () => () =>
      h(MessageBrowser, {
        connectionId: connectionId.value,
        topic: topic.value,
        mqSystemKind: mqSystemKind.value,
      }),
  });
  app.mount(root);
  await flushUi();
  return { browser: root, topic, connectionId, mqSystemKind };
}

function deferred<T>() {
  let resolve!: (value: T) => void;
  let reject!: (reason?: unknown) => void;
  const promise = new Promise<T>((resolvePromise, rejectPromise) => {
    resolve = resolvePromise;
    reject = rejectPromise;
  });
  return { promise, resolve, reject };
}

async function loadMessages(container: ParentNode) {
  buttonByText(container, "mqMessages.loadMessages").click();
  await flushUi();
}

function displayedPayloads(container: ParentNode): string[] {
  return [...container.querySelectorAll<HTMLElement>(".message-payload")].map((element) => element.textContent || "");
}

beforeEach(() => {
  backend.mqPeekMessages.mockReset();
  clipboard.copyToClipboard.mockReset();
  clipboard.copyToClipboard.mockResolvedValue(undefined);
  toast.toast.mockReset();
  backend.mqPeekMessages.mockResolvedValue([
    {
      position: 1,
      messageId: "17",
      payloadBase64: "",
      payloadText: "existing message",
      properties: { partition: "0" },
      headers: {},
    },
  ]);
});

afterEach(() => {
  app?.unmount();
  app = null;
  root?.remove();
  root = null;
});

describe("MessageBrowser", () => {
  it("shows and copies RabbitMQ standard properties separately from headers", async () => {
    const properties = { content_type: "application/json", delivery_mode: "2", priority: "0", expiration: "60000", correlation_id: "rpc-13512" };
    backend.mqPeekMessages.mockResolvedValueOnce([
      {
        position: 1,
        messageId: "13512",
        payloadBase64: "e30=",
        payloadText: "{}",
        properties,
        headers: { "x-trace": "trace-13512" },
      },
    ]);
    const browser = await mountBrowser("rabbitmq");
    await loadMessages(browser);

    const section = browser.querySelector('[data-testid="message-properties"]');
    expect(section?.textContent).toContain("content_type: application/json");
    expect(section?.textContent).toContain("priority: 0");
    expect(section?.textContent).not.toContain("x-trace");
    const copyButton = browser.querySelector<HTMLButtonElement>('[data-testid="copy-message-properties"]');
    if (!copyButton) throw new Error("Properties copy button not found");
    copyButton.click();
    await flushUi();
    expect(clipboard.copyToClipboard).toHaveBeenCalledWith(JSON.stringify(properties, null, 2));
    expect(copyButton.getAttribute("aria-label")).toBe("grid.copy mqMessages.messageProperties");
  });

  it("does not show a RabbitMQ properties section for Kafka metadata", async () => {
    const browser = await mountBrowser("kafka");
    await loadMessages(browser);
    expect(browser.textContent).toContain("mqMessages.metaPartition");
    expect(browser.querySelector('[data-testid="message-properties"]')).toBeNull();
  });

  it("hides the RabbitMQ properties section when a message has no properties", async () => {
    backend.mqPeekMessages.mockResolvedValueOnce([{ position: 1, payloadBase64: "e30=", payloadText: "{}", properties: {}, headers: {} }]);
    const browser = await mountBrowser("rabbitmq");
    await loadMessages(browser);
    expect(browser.querySelector(".message-row")).not.toBeNull();
    expect(browser.querySelector('[data-testid="message-properties"]')).toBeNull();
  });

  it("copies a message's displayed payload", async () => {
    const browser = await mountBrowser();

    await loadMessages(browser);
    const copyButton = browser.querySelector<HTMLButtonElement>('[data-testid="copy-message-payload"]');
    if (!copyButton) throw new Error("Message payload copy button not found");
    copyButton.click();
    await flushUi();

    expect(clipboard.copyToClipboard).toHaveBeenCalledWith("existing message");
    expect(copyButton.dataset.variant).toBe("outline");
    expect(copyButton.dataset.size).toBe("sm");
    expect(copyButton.getAttribute("aria-label")).toBe("grid.copy mqMessages.messageContent");
    expect(toast.toast).toHaveBeenCalledWith("grid.copied");
    expect(browser.querySelector('[data-testid="copy-message-headers"]')).toBeNull();
  });

  it("copies the base64 payload when no text payload is available", async () => {
    backend.mqPeekMessages.mockResolvedValueOnce([
      {
        position: 1,
        messageId: "binary",
        payloadBase64: "AAE=",
        properties: { partition: "0" },
        headers: {},
      },
    ]);
    const browser = await mountBrowser();

    await loadMessages(browser);
    const copyButton = browser.querySelector<HTMLButtonElement>('[data-testid="copy-message-payload"]');
    if (!copyButton) throw new Error("Message payload copy button not found");
    copyButton.click();
    await flushUi();

    expect(clipboard.copyToClipboard).toHaveBeenCalledWith("AAE=");
  });

  it("decodes thrift.TBinaryProtocol payloads when browsing RabbitMQ messages", async () => {
    // Raw TSerializer struct: field 1 (string) = "hello", STOP -> base64 "CwABAAAABWhlbGxvAA=="
    backend.mqPeekMessages.mockResolvedValueOnce([
      {
        position: 1,
        messageId: "thrift-1",
        payloadBase64: "CwABAAAABWhlbGxvAA==",
        payloadText: "\u000b\u0000\u0001\u0000\u0000\u0000\u0005hello\u0000",
        properties: {},
        headers: {},
      },
    ]);
    const browser = await mountBrowser("rabbitmq");

    await loadMessages(browser);
    expect(displayedPayloads(browser)).toEqual(['{\n  "1": "hello"\n}']);
  });

  it("copies message headers as formatted JSON", async () => {
    backend.mqPeekMessages.mockResolvedValueOnce([
      {
        position: 1,
        messageId: "17",
        payloadBase64: "",
        payloadText: "existing message",
        properties: { partition: "0" },
        headers: { source: "billing", traceId: "abc-123" },
      },
    ]);
    const browser = await mountBrowser();

    await loadMessages(browser);
    const copyButton = browser.querySelector<HTMLButtonElement>('[data-testid="copy-message-headers"]');
    if (!copyButton) throw new Error("Message headers copy button not found");
    copyButton.click();
    await flushUi();

    expect(clipboard.copyToClipboard).toHaveBeenCalledWith('{\n  "source": "billing",\n  "traceId": "abc-123"\n}');
    expect(copyButton.getAttribute("aria-label")).toBe("grid.copy mqMessages.messageHeaders");
  });

  it("shows a copy failure toast without breaking the message browser", async () => {
    clipboard.copyToClipboard.mockRejectedValueOnce(new Error("Clipboard unavailable"));
    const browser = await mountBrowser();

    await loadMessages(browser);
    const copyButton = browser.querySelector<HTMLButtonElement>('[data-testid="copy-message-payload"]');
    if (!copyButton) throw new Error("Message payload copy button not found");
    copyButton.click();
    await flushUi();

    expect(toast.toast).toHaveBeenCalledWith('grid.copyFailed:{"message":"Clipboard unavailable"}', 5000);
    expect(browser.textContent).toContain("existing message");
  });

  it("loads Kafka's latest messages by default", async () => {
    const browser = await mountBrowser();

    await loadMessages(browser);

    expect(backend.mqPeekMessages).toHaveBeenCalledWith("mq-1", expect.objectContaining({ topic: "events" }), "__dbx_kafka_viewer__", 20, { startPosition: "latest" });
  });

  it("orders loaded Kafka messages newest first by default and changes presentation without reloading", async () => {
    backend.mqPeekMessages.mockResolvedValueOnce([
      { position: 1, messageId: "1", publishTime: "1000", payloadBase64: "", payloadText: "oldest", properties: {}, headers: {} },
      { position: 2, messageId: "2", publishTime: "3000", payloadBase64: "", payloadText: "newest", properties: {}, headers: {} },
      { position: 3, messageId: "3", publishTime: "2000", payloadBase64: "", payloadText: "middle", properties: {}, headers: {} },
    ]);
    const browser = await mountBrowser();

    await loadMessages(browser);
    expect(displayedPayloads(browser)).toEqual(["newest", "middle", "oldest"]);

    const displayOrder = browser.querySelector<HTMLElement>('[data-testid="kafka-message-display-order"]');
    if (!displayOrder) throw new Error("Kafka message display order select not found");
    await setSelectValue(displayOrder, "oldest");

    expect(displayedPayloads(browser)).toEqual(["oldest", "middle", "newest"]);
    expect(backend.mqPeekMessages).toHaveBeenCalledTimes(1);
  });

  it("keeps the selected Kafka display order when filtering loaded messages", async () => {
    backend.mqPeekMessages.mockResolvedValueOnce([
      { position: 1, messageId: "1", publishTime: "1000", payloadBase64: "", payloadText: "matching oldest", properties: {}, headers: {} },
      { position: 2, messageId: "2", publishTime: "3000", payloadBase64: "", payloadText: "matching newest", properties: {}, headers: {} },
      { position: 3, messageId: "3", publishTime: "2000", payloadBase64: "", payloadText: "excluded", properties: {}, headers: {} },
    ]);
    const browser = await mountBrowser();

    await loadMessages(browser);
    const displayOrder = browser.querySelector<HTMLElement>('[data-testid="kafka-message-display-order"]');
    const filter = browser.querySelector<HTMLInputElement>('[data-testid="kafka-message-filter-input"]');
    if (!displayOrder || !filter) throw new Error("Kafka message presentation controls not found");
    await setSelectValue(displayOrder, "oldest");
    await setInputValue(filter, "matching");

    expect(displayedPayloads(browser)).toEqual(["matching oldest", "matching newest"]);
    expect(backend.mqPeekMessages).toHaveBeenCalledTimes(1);
  });

  it("shows Kafka display ordering in the monitoring appearance", async () => {
    const browser = await mountBrowser("kafka", "monitoring");

    expect(browser.querySelector('[data-testid="kafka-message-display-order"]')).not.toBeNull();
    expect(browser.querySelector('[data-testid="kafka-peek-start-position"]')).toBeNull();
  });

  it("normalizes a decimal count before sending the request", async () => {
    const browser = await mountBrowser();
    const countInput = browser.querySelector<HTMLInputElement>('[data-testid="peek-count"]');
    if (!countInput) throw new Error("Peek count input not found");

    await setInputValue(countInput, "2.9");
    await loadMessages(browser);

    expect(countInput.value).toBe("2");
    expect(backend.mqPeekMessages).toHaveBeenCalledWith("mq-1", expect.objectContaining({ topic: "events" }), "__dbx_kafka_viewer__", 2, { startPosition: "latest" });
  });

  it("shows an explicit warning when the broker returns an incomplete snapshot", async () => {
    backend.mqPeekMessages.mockResolvedValueOnce({
      messages: [
        {
          position: 1,
          messageId: "partial",
          payloadBase64: "",
          payloadText: "partial message",
          properties: {},
          headers: {},
        },
      ],
      incomplete: true,
    });
    const browser = await mountBrowser();

    await loadMessages(browser);

    expect(browser.querySelector('[data-testid="peek-incomplete"]')?.textContent).toContain("mqMessages.peekIncomplete");
    expect(browser.textContent).toContain("partial message");
  });

  it("filters loaded Kafka messages and shows the matching count", async () => {
    backend.mqPeekMessages.mockResolvedValueOnce([
      {
        position: 1,
        messageId: "11",
        key: "order-alpha",
        payloadBase64: "",
        payloadText: "first payload",
        properties: { partition: "0" },
        headers: {},
      },
      {
        position: 2,
        messageId: "12",
        key: "order-beta",
        payloadBase64: "",
        payloadText: "second payload",
        properties: { partition: "1" },
        headers: { TraceId: "REQUEST-99" },
      },
    ]);
    const browser = await mountBrowser();

    await loadMessages(browser);
    const filter = browser.querySelector<HTMLInputElement>('[data-testid="kafka-message-filter-input"]');
    if (!filter) throw new Error("Kafka message filter input not found");
    expect(filter.getAttribute("aria-label")).toBe("mqMessages.filterLoadedPlaceholder");
    expect(browser.querySelector('[data-testid="kafka-message-filter-count"]')?.textContent).toContain('mqMessages.filterLoadedCount:{"matched":2,"loaded":2}');

    await setInputValue(filter, "request-99");

    expect(browser.textContent).not.toContain("first payload");
    expect(browser.textContent).toContain("second payload");
    expect(browser.querySelector('[data-testid="kafka-message-filter-count"]')?.textContent).toContain('mqMessages.filterLoadedCount:{"matched":1,"loaded":2}');
  });

  it("shows a dedicated empty state without hiding an incomplete warning", async () => {
    backend.mqPeekMessages.mockResolvedValueOnce({
      messages: [
        {
          position: 1,
          messageId: "partial",
          payloadBase64: "",
          payloadText: "partial message",
          properties: {},
          headers: {},
        },
      ],
      incomplete: true,
    });
    const browser = await mountBrowser();

    await loadMessages(browser);
    const filter = browser.querySelector<HTMLInputElement>('[data-testid="kafka-message-filter-input"]');
    if (!filter) throw new Error("Kafka message filter input not found");
    await setInputValue(filter, "missing value");

    expect(browser.querySelector('[data-testid="peek-incomplete"]')).not.toBeNull();
    expect(browser.querySelector('[data-testid="kafka-message-filter-empty"]')?.textContent).toContain("mqMessages.noMatchingMessages");
    expect(browser.textContent).not.toContain("partial message");
  });

  it("keeps a filter across reloads and Kafka start-position changes", async () => {
    backend.mqPeekMessages.mockResolvedValue([
      {
        position: 1,
        messageId: "17",
        payloadBase64: "",
        payloadText: "keep this message",
        properties: {},
        headers: {},
      },
    ]);
    const browser = await mountBrowser();

    await loadMessages(browser);
    const filter = browser.querySelector<HTMLInputElement>('[data-testid="kafka-message-filter-input"]');
    const startPosition = browser.querySelector<HTMLElement>('[data-testid="kafka-peek-start-position"]');
    if (!filter || !startPosition) throw new Error("Kafka message filter controls not found");
    await setInputValue(filter, "keep");
    await loadMessages(browser);
    expect(browser.querySelector<HTMLInputElement>('[data-testid="kafka-message-filter-input"]')?.value).toBe("keep");

    await setSelectValue(startPosition, "earliest");
    await loadMessages(browser);

    expect(browser.querySelector<HTMLInputElement>('[data-testid="kafka-message-filter-input"]')?.value).toBe("keep");
    expect(browser.textContent).toContain("keep this message");
  });

  it("clears the filter when the topic or connection context changes", async () => {
    const { browser, topic, connectionId } = await mountBrowserWithMutableTopic();

    await loadMessages(browser);
    const filter = browser.querySelector<HTMLInputElement>('[data-testid="kafka-message-filter-input"]');
    if (!filter) throw new Error("Kafka message filter input not found");
    await setInputValue(filter, "existing");

    topic.value = { ...TOPIC, topic: "payments" };
    await flushUi();
    await loadMessages(browser);

    expect(browser.querySelector<HTMLInputElement>('[data-testid="kafka-message-filter-input"]')?.value).toBe("");

    const reloadedFilter = browser.querySelector<HTMLInputElement>('[data-testid="kafka-message-filter-input"]');
    if (!reloadedFilter) throw new Error("Reloaded Kafka message filter input not found");
    await setInputValue(reloadedFilter, "existing");
    connectionId.value = "mq-2";
    await flushUi();
    await loadMessages(browser);

    expect(browser.querySelector<HTMLInputElement>('[data-testid="kafka-message-filter-input"]')?.value).toBe("");
  });

  it("does not expose the loaded-message filter for non-Kafka browsers", async () => {
    const browser = await mountBrowser("rabbitmq");

    await loadMessages(browser);

    expect(browser.querySelector('[data-testid="kafka-message-filter"]')).toBeNull();
    expect(browser.querySelector('[data-testid="kafka-message-display-order"]')).toBeNull();
  });

  it("sends explicit earliest and offset read positions", async () => {
    const browser = await mountBrowser();
    const startPosition = browser.querySelector<HTMLElement>('[data-testid="kafka-peek-start-position"]');
    if (!startPosition) throw new Error("Kafka start position select not found");

    await setSelectValue(startPosition, "earliest");
    await loadMessages(browser);
    expect(backend.mqPeekMessages).toHaveBeenLastCalledWith("mq-1", expect.objectContaining({ topic: "events" }), "__dbx_kafka_viewer__", 20, { startPosition: "earliest" });

    await setSelectValue(startPosition, "offset");
    const partition = browser.querySelector<HTMLInputElement>('[data-testid="kafka-peek-partition"]');
    const offset = browser.querySelector<HTMLInputElement>('[data-testid="kafka-peek-offset"]');
    if (!partition || !offset) throw new Error("Kafka offset inputs not found");
    await setInputValue(partition, "2");
    await setInputValue(offset, "17");
    await loadMessages(browser);

    expect(backend.mqPeekMessages).toHaveBeenLastCalledWith("mq-1", expect.objectContaining({ topic: "events" }), "__dbx_kafka_viewer__", 20, { startPosition: "offset", partition: 2, offset: 17 });
  });

  it("allows an all-partition offset read but requires an offset", async () => {
    const browser = await mountBrowser();
    const startPosition = browser.querySelector<HTMLElement>('[data-testid="kafka-peek-start-position"]');
    if (!startPosition) throw new Error("Kafka start position control not found");

    await setSelectValue(startPosition, "offset");
    await loadMessages(browser);
    expect(backend.mqPeekMessages).not.toHaveBeenCalled();
    expect(browser.textContent).toContain("mqMessages.offsetRequiredForOffset");

    const offset = browser.querySelector<HTMLInputElement>('[data-testid="kafka-peek-offset"]');
    if (!offset) throw new Error("Kafka offset input not found");
    await setInputValue(offset, "-1");
    await loadMessages(browser);
    expect(backend.mqPeekMessages).not.toHaveBeenCalled();
    expect(browser.textContent).toContain("mqMessages.offsetMustBeNonNegativeIntRequired");

    await setInputValue(offset, "17");
    await loadMessages(browser);
    expect(backend.mqPeekMessages).toHaveBeenLastCalledWith("mq-1", expect.objectContaining({ topic: "events" }), "__dbx_kafka_viewer__", 20, { startPosition: "offset", offset: 17 });
  });

  it("clears results and does not leak an offset into a different read mode", async () => {
    const browser = await mountBrowser();
    const startPosition = browser.querySelector<HTMLElement>('[data-testid="kafka-peek-start-position"]');
    const partition = browser.querySelector<HTMLInputElement>('[data-testid="kafka-peek-partition"]');
    if (!startPosition || !partition) throw new Error("Kafka start position controls not found");

    await loadMessages(browser);
    expect(browser.textContent).toContain("existing message");

    await setSelectValue(startPosition, "offset");
    expect(browser.textContent).not.toContain("existing message");
    await setInputValue(partition, "2");
    const offset = browser.querySelector<HTMLInputElement>('[data-testid="kafka-peek-offset"]');
    if (!offset) throw new Error("Kafka offset input not found");
    await setInputValue(offset, "17");

    await setSelectValue(startPosition, "latest");
    await loadMessages(browser);
    expect(backend.mqPeekMessages).toHaveBeenLastCalledWith("mq-1", expect.objectContaining({ topic: "events" }), "__dbx_kafka_viewer__", 20, { startPosition: "latest", partition: 2 });
  });

  it("ignores an older topic request that resolves after the current request", async () => {
    const first = deferred<PeekedMessage[]>();
    const second = deferred<PeekedMessage[]>();
    backend.mqPeekMessages.mockReturnValueOnce(first.promise).mockReturnValueOnce(second.promise);
    const { browser, topic } = await mountBrowserWithMutableTopic();

    await loadMessages(browser);
    topic.value = { ...TOPIC, topic: "payments" };
    await flushUi();
    await loadMessages(browser);

    second.resolve([
      {
        position: 1,
        messageId: "new",
        payloadBase64: "",
        payloadText: "new topic message",
        properties: {},
        headers: {},
      },
    ]);
    await flushUi();
    expect(browser.textContent).toContain("new topic message");

    first.resolve([
      {
        position: 1,
        messageId: "old",
        payloadBase64: "",
        payloadText: "old topic message",
        properties: {},
        headers: {},
      },
    ]);
    await flushUi();

    expect(browser.textContent).toContain("new topic message");
    expect(browser.textContent).not.toContain("old topic message");
  });

  it("invalidates a request when the topic persistence changes", async () => {
    const first = deferred<PeekedMessage[]>();
    const second = deferred<PeekedMessage[]>();
    backend.mqPeekMessages.mockReturnValueOnce(first.promise).mockReturnValueOnce(second.promise);
    const { browser, topic } = await mountBrowserWithMutableTopic();

    await loadMessages(browser);
    topic.value = { ...TOPIC, persistent: false };
    await flushUi();
    await loadMessages(browser);

    second.resolve([
      {
        position: 1,
        messageId: "non-persistent",
        payloadBase64: "",
        payloadText: "new persistence message",
        properties: {},
        headers: {},
      },
    ]);
    await flushUi();
    first.resolve([
      {
        position: 1,
        messageId: "persistent",
        payloadBase64: "",
        payloadText: "stale persistence message",
        properties: {},
        headers: {},
      },
    ]);
    await flushUi();

    expect(browser.textContent).toContain("new persistence message");
    expect(browser.textContent).not.toContain("stale persistence message");
  });

  it("ignores an older topic request failure after the current request succeeds", async () => {
    const first = deferred<PeekedMessage[]>();
    const second = deferred<PeekedMessage[]>();
    backend.mqPeekMessages.mockReturnValueOnce(first.promise).mockReturnValueOnce(second.promise);
    const { browser, topic } = await mountBrowserWithMutableTopic();

    await loadMessages(browser);
    topic.value = { ...TOPIC, topic: "payments" };
    await flushUi();
    await loadMessages(browser);

    second.resolve([
      {
        position: 1,
        messageId: "new",
        payloadBase64: "",
        payloadText: "new topic message",
        properties: {},
        headers: {},
      },
    ]);
    await flushUi();

    first.reject(new Error("old topic request failed"));
    await flushUi();

    expect(browser.textContent).toContain("new topic message");
    expect(browser.textContent).not.toContain("old topic request failed");
  });

  it("ignores an older connection request after the connection changes", async () => {
    const first = deferred<PeekedMessage[]>();
    const second = deferred<PeekedMessage[]>();
    backend.mqPeekMessages.mockReturnValueOnce(first.promise).mockReturnValueOnce(second.promise);
    const { browser, connectionId } = await mountBrowserWithMutableTopic();

    await loadMessages(browser);
    connectionId.value = "mq-2";
    await flushUi();
    await loadMessages(browser);

    second.resolve([
      {
        position: 1,
        messageId: "new-connection",
        payloadBase64: "",
        payloadText: "new connection message",
        properties: {},
        headers: {},
      },
    ]);
    await flushUi();
    expect(browser.textContent).toContain("new connection message");

    first.resolve([
      {
        position: 1,
        messageId: "old-connection",
        payloadBase64: "",
        payloadText: "old connection message",
        properties: {},
        headers: {},
      },
    ]);
    await flushUi();

    expect(browser.textContent).toContain("new connection message");
    expect(browser.textContent).not.toContain("old connection message");
  });

  it("ignores an older start-mode request that resolves after the mode switches", async () => {
    const first = deferred<PeekedMessage[]>();
    backend.mqPeekMessages.mockReturnValueOnce(first.promise);
    const browser = await mountBrowser();
    const startPosition = browser.querySelector<HTMLElement>('[data-testid="kafka-peek-start-position"]');
    if (!startPosition) throw new Error("Kafka start position select not found");

    await loadMessages(browser);
    await setSelectValue(startPosition, "earliest");
    expect(browser.textContent).not.toContain("latest-mode message");

    first.resolve([
      {
        position: 1,
        messageId: "stale",
        payloadBase64: "",
        payloadText: "latest-mode message",
        properties: {},
        headers: {},
      },
    ]);
    await flushUi();

    expect(browser.textContent).not.toContain("latest-mode message");
    expect(browser.querySelector(".panel-error")).toBeNull();
    expect(browser.textContent).toContain("mqMessages.noMessages");
  });

  it("ignores an older start-mode failure after the mode switches and a new load succeeds", async () => {
    const first = deferred<PeekedMessage[]>();
    const second = deferred<PeekedMessage[]>();
    backend.mqPeekMessages.mockReturnValueOnce(first.promise).mockReturnValueOnce(second.promise);
    const browser = await mountBrowser();
    const startPosition = browser.querySelector<HTMLElement>('[data-testid="kafka-peek-start-position"]');
    if (!startPosition) throw new Error("Kafka start position select not found");

    await loadMessages(browser);
    await setSelectValue(startPosition, "earliest");
    await loadMessages(browser);

    second.resolve([
      {
        position: 1,
        messageId: "fresh",
        payloadBase64: "",
        payloadText: "earliest-mode message",
        properties: {},
        headers: {},
      },
    ]);
    await flushUi();
    expect(browser.textContent).toContain("earliest-mode message");

    first.reject(new Error("latest-mode request failed"));
    await flushUi();

    expect(browser.textContent).toContain("earliest-mode message");
    expect(browser.textContent).not.toContain("latest-mode request failed");
  });

  it("keeps RabbitMQ's advanced filters collapsed and sends its existing request shape", async () => {
    const browser = await mountBrowser("rabbitmq");

    expect(browser.querySelector('input[placeholder="mqMessages.partitionPlaceholderAll"]')).toBeNull();
    buttonByText(browser, "mqMessages.advancedFilter").click();
    await nextTick();
    const partition = browser.querySelector<HTMLInputElement>('input[placeholder="mqMessages.partitionPlaceholderAll"]');
    const offset = browser.querySelector<HTMLInputElement>('input[placeholder="mqMessages.offsetPlaceholderEarliest"]');
    if (!partition || !offset) throw new Error("RabbitMQ advanced filter inputs not found");
    await setInputValue(partition, "2");
    await setInputValue(offset, "17");
    await loadMessages(browser);

    expect(backend.mqPeekMessages).toHaveBeenCalledWith("mq-1", expect.objectContaining({ tenant: "_rabbitmq", topic: "events" }), "__dbx_kafka_viewer__", 20, { partition: 2, offset: 17 });
  });
});