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。

5.1 KB
Raw Blame
import { describe, expect, it } from "vitest";
import { createCloseAllTabMenuItem, createCloseLeftTabMenuItem, createCloseOtherTabMenuItem, createCloseRightTabMenuItem, createCloseTabMenuItem, createLocateTabMenuItem, createPinTabMenuItem, createRenameDuplicateTabItems, createSaveAllTabsMenuItem } from "@/lib/tabs/tabMenu";

const t = (key: string) => key;

describe("shared tab menu helpers", () => {
  it("builds rename and duplicate items for query tabs", () => {
    const items = createRenameDuplicateTabItems({
      tab: { id: "t1" } as never,
      t,
      canRename: true,
      onRename: () => undefined,
      onDuplicate: () => undefined,
    });

    expect(items).toHaveLength(2);
    expect(items[0]?.label).toBe("contextMenu.renameTab");
    expect(items[1]?.label).toBe("contextMenu.duplicateTab");
    expect(items[1]?.visible).toBe(true);

    const queryOnly = createRenameDuplicateTabItems({
      tab: { id: "t2" } as never,
      t,
      canRename: false,
      onRename: () => undefined,
      onDuplicate: () => undefined,
    });
    expect(queryOnly).toHaveLength(1);
    expect(queryOnly[0]?.visible).toBe(false);
  });

  it("allows duplicating data tabs without allowing rename", () => {
    let duplicated = false;
    const items = createRenameDuplicateTabItems({
      tab: { id: "data", mode: "data" } as never,
      t,
      canRename: false,
      onRename: () => undefined,
      onDuplicate: () => {
        duplicated = true;
      },
    });
    expect(items).toHaveLength(1);
    expect(items[0]?.label).toBe("contextMenu.duplicateTab");
    expect(items[0]?.visible).toBe(true);
    items[0]?.action?.();
    expect(duplicated).toBe(true);
  });

  it("builds locate and pin menu items with the expected actions", () => {
    let located = false;
    let toggled = false;

    const locate = createLocateTabMenuItem({
      t,
      visible: true,
      onLocate: () => {
        located = true;
      },
    });
    locate.action?.();
    expect(located).toBe(true);
    expect(locate.label).toBe("sidebar.locateActiveTab");

    const hiddenLocate = createLocateTabMenuItem({
      t,
      visible: false,
      onLocate: () => undefined,
    });
    expect(hiddenLocate.visible).toBe(false);

    const pin = createPinTabMenuItem({
      label: "Pin",
      iconClass: "fill-current",
      onToggle: () => {
        toggled = true;
      },
    });
    pin.action?.();
    expect(toggled).toBe(true);
    expect(pin.iconClass).toBe("fill-current");

    const pinWithoutIconClass = createPinTabMenuItem({
      label: "Pin",
      onToggle: () => undefined,
    });
    expect(pinWithoutIconClass.iconClass).toBeUndefined();
  });

  it("builds close menu items with labels and actions", () => {
    let closed = false;
    const close = createCloseTabMenuItem({
      label: "Close",
      onClose: () => {
        closed = true;
      },
    });
    close.action?.();
    expect(closed).toBe(true);

    const closeOther = createCloseOtherTabMenuItem({
      label: "Close Other",
      disabled: true,
      onClose: () => undefined,
    });
    expect(closeOther.disabled).toBe(true);

    const closeOtherWithoutDisabled = createCloseOtherTabMenuItem({
      label: "Close Other",
      onClose: () => undefined,
    });
    expect("disabled" in closeOtherWithoutDisabled).toBe(false);

    const closeRight = createCloseRightTabMenuItem({
      label: "Close Right",
      disabled: false,
      onClose: () => undefined,
    });
    expect(closeRight.disabled).toBe(false);

    const closeRightWithoutDisabled = createCloseRightTabMenuItem({
      label: "Close Right",
      onClose: () => undefined,
    });
    expect("disabled" in closeRightWithoutDisabled).toBe(false);

    const closeLeft = createCloseLeftTabMenuItem({
      label: "Close Left",
      disabled: true,
      onClose: () => undefined,
    });
    expect(closeLeft.disabled).toBe(true);

    const closeLeftWithoutDisabled = createCloseLeftTabMenuItem({
      label: "Close Left",
      onClose: () => undefined,
    });
    expect("disabled" in closeLeftWithoutDisabled).toBe(false);

    const closeAll = createCloseAllTabMenuItem({
      label: "Close All",
      variant: "destructive",
      onClose: () => undefined,
    });
    expect(closeAll.variant).toBe("destructive");

    const closeAllDefault = createCloseAllTabMenuItem({
      label: "Close All",
      onClose: () => undefined,
    });
    expect(closeAllDefault.variant).toBeUndefined();

    let savedAll = false;
    const saveAll = createSaveAllTabsMenuItem({
      label: "Save All Tabs",
      disabled: false,
      shortcut: "Shift+Mod+S",
      onSaveAll: () => {
        savedAll = true;
      },
    });
    expect(saveAll.label).toBe("Save All Tabs");
    expect(saveAll.disabled).toBe(false);
    expect(saveAll.shortcut).toBe("Shift+Mod+S");
    saveAll.action?.();
    expect(savedAll).toBe(true);

    const saveAllDisabled = createSaveAllTabsMenuItem({
      label: "Save All Tabs",
      disabled: true,
      onSaveAll: () => undefined,
    });
    expect(saveAllDisabled.disabled).toBe(true);
    expect("shortcut" in saveAllDisabled).toBe(false);
  });
});