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。

10.9 KB
Raw Blame
import { createPinia, setActivePinia } from "pinia";
import { beforeEach, describe, expect, it, vi } from "vitest";
import { loadSidebarObjectGroup } from "@/lib/sidebar/sidebarObjectGroupRouting";
import type { ConnectionConfig, ObjectInfo, TreeNode, TriggerInfo } from "@/types/database";

function installLocalStorage() {
  const data = new Map<string, string>();
  vi.stubGlobal("localStorage", {
    getItem: vi.fn((key: string) => data.get(key) ?? null),
    setItem: vi.fn((key: string, value: string) => data.set(key, value)),
    removeItem: vi.fn((key: string) => data.delete(key)),
  });
}

function mysqlConnection(): ConnectionConfig {
  return {
    id: "mysql-1",
    name: "MySQL",
    db_type: "mysql",
    host: "127.0.0.1",
    port: 3306,
    username: "root",
    password: "",
    database: "app",
  } as ConnectionConfig;
}

function objectGroup(type: "group-triggers" | "group-synonyms" | "group-types" | "group-columns", id: string): TreeNode {
  const label = type === "group-triggers" ? "tree.triggers" : type === "group-synonyms" ? "tree.synonyms" : type === "group-types" ? "tree.types" : "tree.columns";
  return {
    id,
    label,
    type,
    connectionId: "mysql-1",
    database: "app",
    schema: "app",
    isExpanded: false,
    children: [],
  };
}

async function createStore({ listObjects, listTriggers, connection = mysqlConnection() }: { listObjects: ReturnType<typeof vi.fn>; listTriggers: ReturnType<typeof vi.fn>; connection?: ConnectionConfig }) {
  vi.doMock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));
  vi.doMock("@/lib/backend/api", () => ({
    checkConnectionHealth: vi.fn().mockResolvedValue(undefined),
    deleteSchemaCachePrefix: vi.fn().mockResolvedValue(undefined),
    listInstalledAgents: vi.fn().mockResolvedValue([]),
    listObjects,
    listTriggers,
    loadSchemaCache: vi.fn().mockResolvedValue(null),
    saveSchemaCache: vi.fn().mockResolvedValue(undefined),
    saveConnections: vi.fn().mockResolvedValue(undefined),
    saveSidebarLayout: vi.fn().mockResolvedValue(undefined),
  }));

  const { useConnectionStore } = await import("@/stores/connectionStore");
  const { useSettingsStore } = await import("@/stores/settingsStore");
  const store = useConnectionStore();
  store.connections = [connection];
  store.connectedIds.add(connection.id);
  useSettingsStore().desktopSettings.sidebar_table_page_size = 10;
  return { connection, store };
}

describe("sidebar object-group routing", () => {
  beforeEach(() => {
    vi.resetModules();
    vi.unstubAllGlobals();
    installLocalStorage();
    setActivePinia(createPinia());
  });

  it("uses listObjects for schema-level trigger, synonym, and type groups, including empty results", async () => {
    const listObjects = vi.fn<() => Promise<ObjectInfo[]>>().mockResolvedValue([]);
    const listTriggers = vi.fn<() => Promise<never[]>>().mockResolvedValue([]);
    const { connection, store } = await createStore({ listObjects, listTriggers });
    const triggerGroup = objectGroup("group-triggers", `${connection.id}:app:app:__triggers`);
    const synonymGroup = objectGroup("group-synonyms", `${connection.id}:app:app:__synonyms`);
    const typeGroup = objectGroup("group-types", `${connection.id}:app:app:__types`);
    store.treeNodes = [{ id: connection.id, label: connection.name, type: "connection", connectionId: connection.id, children: [triggerGroup, synonymGroup, typeGroup] }];
    const storedTriggerGroup = store.treeNodes[0].children![0];
    const storedSynonymGroup = store.treeNodes[0].children![1];
    const storedTypeGroup = store.treeNodes[0].children![2];

    await loadSidebarObjectGroup(storedTriggerGroup, store);
    await loadSidebarObjectGroup(storedSynonymGroup, store);
    await loadSidebarObjectGroup(storedTypeGroup, store);

    expect(listObjects).toHaveBeenNthCalledWith(1, connection.id, "app", "app", ["TRIGGER"], undefined, 11, 0);
    expect(listObjects).toHaveBeenNthCalledWith(2, connection.id, "app", "app", ["SYNONYM"], undefined, 11, 0);
    expect(listObjects).toHaveBeenNthCalledWith(3, connection.id, "app", "app", ["TYPE", "TYPE_BODY"], undefined, 11, 0);
    expect(listTriggers).not.toHaveBeenCalled();
    expect(storedTriggerGroup).toMatchObject({ isExpanded: true, isLoading: false, children: [] });
    expect(storedSynonymGroup).toMatchObject({ isExpanded: true, isLoading: false, children: [] });
    expect(storedTypeGroup).toMatchObject({ isExpanded: true, isLoading: false, children: [] });
  });

  it("keeps table-level trigger groups on listTriggers", async () => {
    const listObjects = vi.fn<() => Promise<ObjectInfo[]>>().mockResolvedValue([]);
    const listTriggers = vi.fn<() => Promise<TriggerInfo[]>>().mockResolvedValue([
      {
        name: "trg_orders_audit",
        timing: "AFTER",
        event: "UPDATE",
      },
    ]);
    const { connection, store } = await createStore({ listObjects, listTriggers });
    const tableTriggerGroup: TreeNode = {
      ...objectGroup("group-triggers", `${connection.id}:app:app:orders:__triggers`),
      tableName: "orders",
    };
    store.treeNodes = [{ id: connection.id, label: connection.name, type: "connection", connectionId: connection.id, children: [tableTriggerGroup] }];
    const storedTriggerGroup = store.treeNodes[0].children![0];

    await loadSidebarObjectGroup(storedTriggerGroup, store);

    expect(listTriggers).toHaveBeenCalledWith(connection.id, "app", "app", "orders", undefined);
    expect(listObjects).not.toHaveBeenCalled();
    expect(storedTriggerGroup).toMatchObject({
      isExpanded: true,
      isLoading: false,
      children: [
        {
          label: "trg_orders_audit (AFTER UPDATE)",
          objectName: "trg_orders_audit",
          tableName: "orders",
          type: "trigger",
        },
      ],
    });
  });

  it("refreshes table trigger groups using listTriggers instead of loading database objects", async () => {
    const listObjects = vi.fn<() => Promise<ObjectInfo[]>>().mockResolvedValue([]);
    const listTriggers = vi.fn<() => Promise<TriggerInfo[]>>().mockResolvedValue([
      {
        name: "trg_orders_audit",
        timing: "AFTER",
        event: "UPDATE",
      },
    ]);
    const { connection, store } = await createStore({ listObjects, listTriggers });
    const tableTriggerGroup: TreeNode = {
      ...objectGroup("group-triggers", `${connection.id}:app:app:orders:__triggers`),
      tableName: "orders",
    };
    store.treeNodes = [{ id: connection.id, label: connection.name, type: "connection", connectionId: connection.id, children: [tableTriggerGroup] }];
    const storedTriggerGroup = store.treeNodes[0].children![0];

    await store.refreshTreeNode(storedTriggerGroup);

    expect(listTriggers).toHaveBeenCalledWith(connection.id, "app", "app", "orders", undefined);
    expect(listObjects).not.toHaveBeenCalled();
    expect(storedTriggerGroup.children).toHaveLength(1);
    expect(storedTriggerGroup.children![0]).toMatchObject({
      label: "trg_orders_audit (AFTER UPDATE)",
      objectName: "trg_orders_audit",
      tableName: "orders",
      type: "trigger",
    });
  });

  it("preserves SQL Server table trigger status metadata across refreshes", async () => {
    const listObjects = vi.fn<() => Promise<ObjectInfo[]>>().mockResolvedValue([]);
    const listTriggers = vi.fn<() => Promise<TriggerInfo[]>>();
    const { connection, store } = await createStore({
      listObjects,
      listTriggers,
      connection: { ...mysqlConnection(), id: "sqlserver-1", name: "SQL Server", db_type: "sqlserver", port: 1433 },
    });
    const tableTriggerGroup: TreeNode = {
      ...objectGroup("group-triggers", `${connection.id}:app:dbo:orders:__triggers`),
      connectionId: connection.id,
      schema: "dbo",
      tableName: "orders",
    };
    store.treeNodes = [{ id: connection.id, label: connection.name, type: "connection", connectionId: connection.id, children: [tableTriggerGroup] }];
    const storedTriggerGroup = store.treeNodes[0].children![0];

    for (const enabled of [false, true, undefined, null, false]) {
      const trigger: TriggerInfo = { name: "trg_orders_audit", timing: "AFTER", event: "UPDATE", enabled };
      listTriggers.mockResolvedValueOnce([trigger]);
      await loadSidebarObjectGroup(storedTriggerGroup, store);

      expect(storedTriggerGroup.children).toHaveLength(1);
      expect(storedTriggerGroup.children![0]).toMatchObject({
        id: `${tableTriggerGroup.id}:trg_orders_audit`,
        label: "trg_orders_audit (AFTER UPDATE)",
        objectName: trigger.name,
        type: "trigger",
        tableName: "orders",
        meta: trigger,
      });
      expect((storedTriggerGroup.children![0].meta as TriggerInfo).enabled).toBe(enabled);
      expect(storedTriggerGroup.children![0].valid).toBeUndefined();
    }

    expect(listTriggers).toHaveBeenCalledTimes(5);
    expect(listTriggers).toHaveBeenLastCalledWith(connection.id, "app", "dbo", "orders", undefined);
    expect(listObjects).not.toHaveBeenCalled();
  });

  it("propagates rejected schema-level metadata while clearing the loading state", async () => {
    const listObjects = vi.fn<() => Promise<ObjectInfo[]>>().mockRejectedValue(new Error("metadata access denied"));
    const listTriggers = vi.fn<() => Promise<never[]>>().mockResolvedValue([]);
    const { connection, store } = await createStore({ listObjects, listTriggers });
    const triggerGroup = objectGroup("group-triggers", `${connection.id}:app:app:__triggers`);
    store.treeNodes = [{ id: connection.id, label: connection.name, type: "connection", connectionId: connection.id, children: [triggerGroup] }];
    const storedTriggerGroup = store.treeNodes[0].children![0];

    await expect(loadSidebarObjectGroup(storedTriggerGroup, store)).rejects.toThrow("metadata access denied");

    expect(listObjects).toHaveBeenCalledWith(connection.id, "app", "app", ["TRIGGER"], undefined, 11, 0);
    expect(listTriggers).not.toHaveBeenCalled();
    expect(storedTriggerGroup).toMatchObject({ isExpanded: false, isLoading: false, children: [] });
  });

  it("keeps table-level non-trigger structure groups off the object-group loader", async () => {
    const listObjects = vi.fn<() => Promise<ObjectInfo[]>>().mockResolvedValue([]);
    const listTriggers = vi.fn<() => Promise<never[]>>().mockResolvedValue([]);
    const { connection, store } = await createStore({ listObjects, listTriggers });
    const tableColumnsGroup: TreeNode = {
      ...objectGroup("group-columns", `${connection.id}:app:app:orders:__columns`),
      tableName: "orders",
    };
    store.treeNodes = [{ id: connection.id, label: connection.name, type: "connection", connectionId: connection.id, children: [tableColumnsGroup] }];
    const storedColumnsGroup = store.treeNodes[0].children![0];

    const handled = await loadSidebarObjectGroup(storedColumnsGroup, store);

    expect(handled).toBe(false);
    expect(listObjects).not.toHaveBeenCalled();
    expect(listTriggers).not.toHaveBeenCalled();
    expect(storedColumnsGroup).toMatchObject({ isExpanded: false, children: [] });
  });
});