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。

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

import { createApp, nextTick } from "vue";
import { createI18n } from "vue-i18n";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { forgetRedisKeySearchHistory, loadRedisKeySearchHistory, rememberRedisKeySearchHistory } from "@/lib/redis/redisKeySearchHistory";

const mocks = vi.hoisted(() => ({
  redisScanKeysBatch: vi.fn(),
  redisGetValue: vi.fn(),
  redisSetString: vi.fn(),
  redisJsonSet: vi.fn(),
  redisHashSet: vi.fn(),
  redisListPush: vi.fn(),
  redisSetAdd: vi.fn(),
  redisZadd: vi.fn(),
  redisStreamAdd: vi.fn(),
  redisSetTtl: vi.fn(),
  redisSetExpireAt: vi.fn(),
  redisSetKeysTtl: vi.fn(),
  redisSetKeysExpireAt: vi.fn(),
  redisCheckJsonModule: vi.fn(),
  redisDeleteKey: vi.fn(),
  redisDeleteKeys: vi.fn(),
  redisDeleteKeysByPattern: vi.fn(),
  redisExecuteCommand: vi.fn(),
  saveHistory: vi.fn(),
  toast: vi.fn(),
  updateRedisDbKeyStats: vi.fn(),
  listRedisCompletionCommandDocs: vi.fn(),
  listRedisCompletionKeys: vi.fn(),
  redisScanPageSize: 100,
  infiniteScroll: false,
  queryResultMaxRowsEnabled: true,
  queryResultMaxRows: 5000,
}));

vi.mock("@/lib/backend/api", () => ({
  redisScanKeysBatch: mocks.redisScanKeysBatch,
  redisGetValue: mocks.redisGetValue,
  redisSetString: mocks.redisSetString,
  redisJsonSet: mocks.redisJsonSet,
  redisHashSet: mocks.redisHashSet,
  redisListPush: mocks.redisListPush,
  redisSetAdd: mocks.redisSetAdd,
  redisZadd: mocks.redisZadd,
  redisStreamAdd: mocks.redisStreamAdd,
  redisSetTtl: mocks.redisSetTtl,
  redisSetExpireAt: mocks.redisSetExpireAt,
  redisSetKeysTtl: mocks.redisSetKeysTtl,
  redisSetKeysExpireAt: mocks.redisSetKeysExpireAt,
  redisCheckJsonModule: mocks.redisCheckJsonModule,
  redisDeleteKey: mocks.redisDeleteKey,
  redisDeleteKeys: mocks.redisDeleteKeys,
  redisDeleteKeysByPattern: mocks.redisDeleteKeysByPattern,
  redisExecuteCommand: mocks.redisExecuteCommand,
  saveHistory: mocks.saveHistory,
}));

vi.mock("@/stores/connectionStore", () => ({
  useConnectionStore: () => ({
    ensureConnected: vi.fn().mockResolvedValue(undefined),
    getConfig: () => ({ name: "Redis", redis_key_separator: ":", redis_scan_page_size: mocks.redisScanPageSize, redis_key_templates: ["user:{$id}", "session:{$token}"] }),
    updateRedisDbKeyStats: mocks.updateRedisDbKeyStats,
    listRedisCompletionCommandDocs: mocks.listRedisCompletionCommandDocs,
    listRedisCompletionKeys: mocks.listRedisCompletionKeys,
    invalidateCompletionCache: vi.fn(),
    refreshRedisDbKeyCounts: vi.fn(),
  }),
}));

vi.mock("@/stores/settingsStore", () => ({
  useSettingsStore: () => ({
    editorSettings: {
      infiniteScroll: mocks.infiniteScroll,
      queryResultMaxRowsEnabled: mocks.queryResultMaxRowsEnabled,
      queryResultMaxRows: mocks.queryResultMaxRows,
    },
  }),
}));

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

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

vi.mock("@/components/ui/button", async () => {
  const { defineComponent, h } = await import("vue");
  return {
    Button: defineComponent({
      inheritAttrs: false,
      props: { disabled: Boolean },
      setup(props, { attrs, slots }) {
        return () => h("button", { ...attrs, disabled: props.disabled }, slots.default?.());
      },
    }),
  };
});

vi.mock("@/components/ui/input", async () => {
  const { defineComponent, h, mergeProps } = await import("vue");
  return {
    Input: defineComponent({
      inheritAttrs: false,
      props: { modelValue: String, disabled: Boolean },
      emits: ["update:modelValue"],
      setup(props, { attrs, emit }) {
        return () =>
          h(
            "input",
            mergeProps(attrs, {
              value: props.modelValue ?? "",
              disabled: props.disabled,
              onInput: (event: Event) => emit("update:modelValue", (event.target as HTMLInputElement).value),
            }),
          );
      },
    }),
  };
});

vi.mock("@/components/ui/badge", async () => {
  const { defineComponent, h } = await import("vue");
  return {
    Badge: defineComponent({
      setup:
        (_, { attrs, slots }) =>
        () =>
          h("span", attrs, slots.default?.()),
    }),
  };
});

vi.mock("@/components/ui/dialog", async () => {
  const { defineComponent, h } = await import("vue");
  const slotContainer = defineComponent({
    setup:
      (_, { attrs, slots }) =>
      () =>
        h("div", attrs, slots.default?.()),
  });
  return {
    Dialog: defineComponent({
      props: { open: Boolean },
      setup(props, { slots }) {
        return () => (props.open ? h("div", { "data-test-dialog": "" }, slots.default?.()) : null);
      },
    }),
    DialogContent: slotContainer,
    DialogFooter: slotContainer,
    DialogHeader: slotContainer,
    DialogTitle: slotContainer,
  };
});

vi.mock("@/components/ui/select", async () => {
  const { defineComponent, h } = await import("vue");
  const slotContainer = defineComponent({
    setup:
      (_, { attrs, slots }) =>
      () =>
        h("div", attrs, slots.default?.()),
  });
  return {
    Select: slotContainer,
    SelectContent: slotContainer,
    SelectItem: defineComponent({
      props: { value: String },
      setup(props, { slots }) {
        return () => h("button", { type: "button", "data-test-select-value": props.value }, slots.default?.());
      },
    }),
    SelectTrigger: slotContainer,
    SelectValue: slotContainer,
  };
});

vi.mock("@/components/ui/option-help-panel", async () => {
  const { defineComponent, h } = await import("vue");
  return { OptionHelpPanel: defineComponent({ setup: () => () => h("div") }) };
});

vi.mock("@/components/ui/tabs", async () => {
  const { defineComponent, h } = await import("vue");
  const slotContainer = defineComponent({
    setup:
      (_, { attrs, slots }) =>
      () =>
        h("div", attrs, slots.default?.()),
  });
  return { Tabs: slotContainer, TabsContent: slotContainer, TabsList: slotContainer, TabsTrigger: slotContainer };
});

vi.mock("@/components/ui/switch", async () => {
  const { defineComponent, h } = await import("vue");
  return { Switch: defineComponent({ setup: () => () => h("button", { type: "button" }) }) };
});

vi.mock("@/components/ui/date-time-picker/DateTimePicker.vue", async () => {
  const { defineComponent, h } = await import("vue");
  return { default: defineComponent({ setup: () => () => h("div") }) };
});

vi.mock("@/components/ui/CustomContextMenu.vue", async () => {
  const { defineComponent, h } = await import("vue");
  return {
    default: defineComponent({
      setup(_, { slots }) {
        return () => h("div", slots.default?.({ onContextMenu: () => undefined }));
      },
    }),
  };
});

vi.mock("@/components/editor/DangerConfirmDialog.vue", async () => {
  const { defineComponent, h } = await import("vue");
  return { default: defineComponent({ props: { open: Boolean }, setup: () => () => h("div") }) };
});

vi.mock("./RedisValueViewer.vue", async () => {
  const { defineComponent, h } = await import("vue");
  return { default: defineComponent({ setup: () => () => h("div") }) };
});

vi.mock("./RedisPubSubPanel.vue", async () => {
  const { defineComponent, h } = await import("vue");
  return { default: defineComponent({ setup: () => () => h("div") }) };
});

vi.mock("./RedisSlowlogPanel.vue", async () => {
  const { defineComponent, h } = await import("vue");
  return { default: defineComponent({ setup: () => () => h("div") }) };
});

vi.mock("vue-virtual-scroller", async () => {
  const { defineComponent, h } = await import("vue");
  return {
    RecycleScroller: defineComponent({
      inheritAttrs: false,
      props: { items: { type: Array, default: () => [] } },
      setup(props, { attrs, slots }) {
        return () =>
          h(
            "div",
            attrs,
            props.items.slice(0, 20).map((item) => slots.default?.({ item })),
          );
      },
    }),
  };
});

vi.mock("splitpanes", async () => {
  const { defineComponent, h } = await import("vue");
  const slotContainer = defineComponent({
    setup:
      (_, { attrs, slots }) =>
      () =>
        h("div", attrs, slots.default?.()),
  });
  return { Splitpanes: slotContainer, Pane: slotContainer };
});

import RedisKeyBrowser from "./RedisKeyBrowser.vue";

const mountedApps: Array<{ unmount: () => void; host: HTMLElement }> = [];

async function settle() {
  for (let index = 0; index < 4; index++) {
    await nextTick();
    await Promise.resolve();
  }
}

function mountBrowser(overrides?: { connectionId?: string; db?: number; stateKey?: string }) {
  const host = document.createElement("div");
  document.body.append(host);
  const app = createApp(RedisKeyBrowser, {
    connectionId: overrides?.connectionId ?? "connection",
    db: overrides?.db ?? 0,
    blockDangerousRedisCommands: false,
    stateKey: overrides?.stateKey,
  });
  app.use(
    createI18n({
      legacy: false,
      locale: "en",
      messages: {
        en: {
          redis: {
            keySearchHistory: "Search history",
            keySearchHistoryForget: "Remove from history",
            keySearchHistoryEmpty: "No history yet",
            keyTemplateSuggestions: "Key templates",
          },
        },
      },
      missingWarn: false,
      fallbackWarn: false,
    }),
  );
  app.mount(host);
  mountedApps.push({ unmount: () => app.unmount(), host });
  return host;
}

beforeEach(() => {
  vi.clearAllMocks();
  mocks.redisScanKeysBatch.mockResolvedValue({ cursor: 0, keys: [], total_keys: 0 });
  localStorage.clear();
});

afterEach(() => {
  while (mountedApps.length > 0) {
    const mounted = mountedApps.pop()!;
    mounted.unmount();
    mounted.host.remove();
  }
});

async function submitSearch(host: HTMLElement, pattern: string) {
  const input = host.querySelector("[data-redis-search-input]") as HTMLInputElement;
  input.value = pattern;
  input.dispatchEvent(new Event("input", { bubbles: true }));
  await settle();
  input.dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true }));
  await settle();
}

describe("RedisKeyBrowser search history", () => {
  it("remembers a submitted pattern and fills the input when selected from history", async () => {
    const host = mountBrowser();
    await settle();

    await submitSearch(host, "monitor:job:*");
    expect(loadRedisKeySearchHistory({ connectionId: "connection", db: 0 })).toEqual(["monitor:job:*"]);

    const input = host.querySelector("[data-redis-search-input]") as HTMLInputElement;
    input.value = "";
    input.dispatchEvent(new Event("input", { bubbles: true }));
    await settle();

    (host.querySelector("[data-redis-search-history-toggle]") as HTMLButtonElement).click();
    await settle();

    expect(host.querySelector("[data-redis-search-history-list]")).not.toBeNull();
    const item = host.querySelector("[data-redis-search-history-item]") as HTMLElement;
    expect(item.textContent).toContain("monitor:job:*");
    item.dispatchEvent(new MouseEvent("mousedown", { bubbles: true }));
    await settle();

    expect((host.querySelector("[data-redis-search-input]") as HTMLInputElement).value).toBe("monitor:job:*");
    expect(host.querySelector("[data-redis-search-history-list]")).toBeNull();
  });

  it("keeps earlier patterns after switching to another key search like queue_update then insert", async () => {
    const host = mountBrowser();
    await settle();

    await submitSearch(host, "queue_update");
    await submitSearch(host, "insert");

    expect(loadRedisKeySearchHistory({ connectionId: "connection", db: 0 })).toEqual(["insert", "queue_update"]);

    // Input still holds the latest search; dropdown must still list earlier keys.
    (host.querySelector("[data-redis-search-history-toggle]") as HTMLButtonElement).click();
    await settle();

    const text = host.querySelector("[data-redis-search-history-list]")?.textContent ?? "";
    expect(text).toContain("insert");
    expect(text).toContain("queue_update");
  });

  it("forgets an individual history entry from the dropdown", async () => {
    rememberRedisKeySearchHistory({ connectionId: "connection", db: 0 }, "cache:*");
    rememberRedisKeySearchHistory({ connectionId: "connection", db: 0 }, "user:*");

    const host = mountBrowser();
    await settle();

    (host.querySelector("[data-redis-search-history-toggle]") as HTMLButtonElement).click();
    await settle();

    const items = [...host.querySelectorAll("[data-redis-search-history-item]")];
    const forgetUser = items.find((el) => el.textContent?.includes("user:*"))!.querySelector("[data-redis-search-history-forget]") as HTMLButtonElement;
    forgetUser.dispatchEvent(new MouseEvent("mousedown", { bubbles: true }));
    await settle();

    expect(loadRedisKeySearchHistory({ connectionId: "connection", db: 0 })).toEqual(["cache:*"]);
    expect(host.querySelector("[data-redis-search-history-list]")?.textContent).toContain("cache:*");
    expect(host.querySelector("[data-redis-search-history-list]")?.textContent).not.toContain("user:*");
  });

  it("does not mix history across connectionId+db scopes", async () => {
    rememberRedisKeySearchHistory({ connectionId: "connection", db: 0 }, "db0:*");
    rememberRedisKeySearchHistory({ connectionId: "connection", db: 1 }, "db1:*");
    rememberRedisKeySearchHistory({ connectionId: "other", db: 0 }, "other:*");

    const host = mountBrowser({ connectionId: "connection", db: 0 });
    await settle();
    (host.querySelector("[data-redis-search-history-toggle]") as HTMLButtonElement).click();
    await settle();

    const text = host.querySelector("[data-redis-search-history-list]")?.textContent ?? "";
    expect(text).toContain("db0:*");
    expect(text).not.toContain("db1:*");
    expect(text).not.toContain("other:*");
  });

  it("keeps history and key-template menus mutually exclusive", async () => {
    rememberRedisKeySearchHistory({ connectionId: "connection", db: 0 }, "legacy:*");

    const host = mountBrowser();
    await settle();

    const input = host.querySelector("[data-redis-search-input]") as HTMLInputElement;
    input.dispatchEvent(new FocusEvent("focus", { bubbles: true }));
    await settle();
    expect(host.querySelector('[role="listbox"][aria-label="Key templates"]')).not.toBeNull();
    expect(host.querySelector("[data-redis-search-history-list]")).toBeNull();

    (host.querySelector("[data-redis-search-history-toggle]") as HTMLButtonElement).click();
    await settle();
    expect(host.querySelector("[data-redis-search-history-list]")).not.toBeNull();
    expect(host.querySelector('[role="listbox"][aria-label="Key templates"]')).toBeNull();
  });

  it("does not remember empty search submissions", async () => {
    const host = mountBrowser();
    await settle();

    const input = host.querySelector("[data-redis-search-input]") as HTMLInputElement;
    input.value = "   ";
    input.dispatchEvent(new Event("input", { bubbles: true }));
    await settle();
    input.dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true }));
    await settle();

    expect(loadRedisKeySearchHistory({ connectionId: "connection", db: 0 })).toEqual([]);
    expect(forgetRedisKeySearchHistory({ connectionId: "connection", db: 0 }, "noop")).toEqual([]);
  });
});