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。

14.8 KB
Raw Blame
import { beforeEach, describe, expect, it, vi } from "vitest";
import { createPinia, setActivePinia } from "pinia";
import { useNavigationTargets } from "@/composables/useNavigationTargets";
import { clearTableMetadataCache } from "@/lib/metadata/tableMetadataCache";
import type { QueryTab } from "@/types/database";

const mocks = vi.hoisted(() => ({
  tabs: [] as QueryTab[],
  activeTabId: "",
  buildTableSelectSql: vi.fn(),
  databaseType: "postgres" as string,
  tableOpenSortMode: "none" as "none" | "database" | "local",
  ensureConnected: vi.fn(),
  executeTabSql: vi.fn(),
  getColumns: vi.fn(),
  invalidateCompletionTableCache: vi.fn(),
  listIndexes: vi.fn(),
  setErrorResult: vi.fn(),
  setTableMeta: vi.fn(),
  updateSql: vi.fn(),
  databaseInfo: undefined as { productName?: string; productVersion?: string } | undefined,
}));

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

vi.mock("@/stores/connectionStore", () => ({
  useConnectionStore: () => ({
    activeConnectionId: "",
    getConfig: () => ({ id: "connection-1", db_type: mocks.databaseType, database_info: mocks.databaseInfo }),
    ensureConnected: mocks.ensureConnected,
    connectionIdentifierQuote: () => undefined,
    metadataGenerationFor: () => 0,
    refreshObjectListTreeNode: vi.fn(),
    invalidateCompletionTableCache: mocks.invalidateCompletionTableCache,
  }),
}));

vi.mock("@/stores/queryStore", () => ({
  useQueryStore: () => ({
    tabs: mocks.tabs,
    activeTabId: mocks.activeTabId,
    createTab: (connectionId: string, database: string, title: string, mode: QueryTab["mode"], schema?: string) => {
      const tab = {
        id: `tab-${mocks.tabs.length + 1}`,
        connectionId,
        database,
        title,
        mode,
        schema,
        sql: "",
        isDirty: false,
        isExecuting: false,
        isCancelling: false,
        isExplaining: false,
      } as QueryTab;
      mocks.tabs.push(tab);
      return tab.id;
    },
    switchTab: vi.fn(),
    setExecuting: vi.fn(),
    setExecutingWithId: (id: string, executionId: string) => {
      const tab = mocks.tabs.find((item) => item.id === id);
      if (tab) {
        tab.isExecuting = true;
        tab.executionId = executionId;
      }
    },
    setTableMeta: mocks.setTableMeta.mockImplementation((id: string, meta: NonNullable<QueryTab["tableMeta"]>) => {
      const tab = mocks.tabs.find((item) => item.id === id);
      if (tab) {
        tab.tableMeta = meta;
        tab.tableMetaUpdatedAt = Date.now();
        // 与真实 store 一致:仅真实元数据(columns 非空)落地才结束行标识等待
        if (meta.columns.length > 0) tab.tableMetaPending = false;
      }
    }),
    updateSql: mocks.updateSql,
    executeTabSql: mocks.executeTabSql,
    setErrorResult: mocks.setErrorResult,
    invalidateTableStructure: vi.fn(),
  }),
}));

vi.mock("@/stores/settingsStore", () => ({
  useSettingsStore: () => ({ editorSettings: { dataTabReuseMode: "same-table", tableOpenSortMode: mocks.tableOpenSortMode, tableDatabaseSortDirection: "desc", tableLocalSortDirection: "asc" } }),
}));

vi.mock("@/stores/tunnelProfileStore", () => ({
  useTunnelProfileStore: () => ({ profileById: () => undefined }),
}));

vi.mock("@/lib/table/tableSelectSql", async (importOriginal) => ({
  ...(await importOriginal<typeof import("@/lib/table/tableSelectSql")>()),
  buildTableSelectSql: mocks.buildTableSelectSql,
}));

const dialogs = {
  showFieldLineageDialog: { value: false },
  showDatabaseSearchDialog: { value: false },
  showDiagramDialog: { value: false },
};

function column(name: string) {
  return { name, data_type: "integer", is_nullable: false, column_default: null, is_primary_key: true, extra: null };
}

describe("useNavigationTargets openTableTarget", () => {
  beforeEach(() => {
    setActivePinia(createPinia());
    clearTableMetadataCache();
    vi.clearAllMocks();
    mocks.tabs.length = 0;
    mocks.databaseType = "postgres";
    mocks.tableOpenSortMode = "none";
    mocks.databaseInfo = undefined;
    mocks.ensureConnected.mockResolvedValue(undefined);
    mocks.buildTableSelectSql.mockImplementation(async ({ tableName }: { tableName: string }) => `SELECT * FROM ${tableName}`);
    mocks.executeTabSql.mockResolvedValue(undefined);
    mocks.getColumns.mockResolvedValue([column("id")]);
    mocks.listIndexes.mockResolvedValue([]);
  });

  it.each(["oracle", "oceanbase-oracle", "xugu", "neo4j"])("keeps %s synthetic row identifiers out of default database ordering", async (databaseType) => {
    mocks.databaseType = databaseType;
    mocks.tableOpenSortMode = "database";
    mocks.getColumns.mockResolvedValue([{ ...column("name"), is_primary_key: false }]);

    await useNavigationTargets(dialogs).openTableTarget({ connectionId: "connection-1", database: "app", tableName: "users", tableType: "TABLE" });

    expect(mocks.executeTabSql).toHaveBeenCalled();
    expect(mocks.buildTableSelectSql).toHaveBeenCalled();
    for (const [options] of mocks.buildTableSelectSql.mock.calls) {
      expect(options.orderBy).toBeUndefined();
    }
    expect(mocks.tabs[0]?.orderByInput).toBeUndefined();
  });

  it("forwards the connected server version to the table SQL builder (#10503)", async () => {
    mocks.databaseType = "neo4j";
    mocks.databaseInfo = { productName: "Neo4j", productVersion: "Neo4j/4.4.44" };

    await useNavigationTargets(dialogs).openTableTarget({ connectionId: "connection-1", database: "neo4j", tableName: "users", tableType: "TABLE" });

    expect(mocks.buildTableSelectSql).toHaveBeenCalledWith(expect.objectContaining({ serverVersion: "Neo4j/4.4.44" }));
  });

  it("reads the server version when the SQL is built, not from the config captured before connect (#10503)", async () => {
    mocks.databaseType = "neo4j";
    mocks.databaseInfo = undefined;
    // The store swaps the config object when the probe lands, so the reference captured before
    // connect never sees the version.
    mocks.getColumns.mockImplementation(async () => {
      mocks.databaseInfo = { productName: "Neo4j", productVersion: "Neo4j/4.4.44" };
      return [column("id")];
    });

    await useNavigationTargets(dialogs).openTableTarget({ connectionId: "connection-1", database: "neo4j", tableName: "users", tableType: "TABLE" });

    expect(mocks.buildTableSelectSql).toHaveBeenCalledWith(expect.objectContaining({ serverVersion: "Neo4j/4.4.44" }));
  });

  it.each(["oracle", "oceanbase-oracle"])("uses the %s physical primary index for default ordering", async (databaseType) => {
    mocks.databaseType = databaseType;
    mocks.tableOpenSortMode = "database";
    mocks.getColumns.mockResolvedValue([{ ...column("id"), is_primary_key: false }]);
    mocks.listIndexes.mockResolvedValue([{ name: "users_pk", columns: ["id"], is_unique: true, is_primary: true }]);

    await useNavigationTargets(dialogs).openTableTarget({ connectionId: "connection-1", database: "app", tableName: "users", tableType: "TABLE" });

    expect(mocks.setErrorResult).not.toHaveBeenCalled();
    expect(mocks.buildTableSelectSql).toHaveBeenCalledWith(expect.objectContaining({ orderBy: '"id" DESC' }));
  });

  it("loads stable row identity before the first PostgreSQL table query", async () => {
    let releaseColumns: (columns: unknown[]) => void = () => {};
    mocks.getColumns.mockReturnValueOnce(
      new Promise((resolve) => {
        releaseColumns = resolve;
      }),
    );
    let pendingDuringQuery: boolean | undefined;
    mocks.executeTabSql.mockImplementationOnce(async () => {
      pendingDuringQuery = mocks.tabs[0]?.tableMetaPending;
    });

    const open = useNavigationTargets(dialogs).openLineageTarget({ connectionId: "connection-1", database: "app", schema: "public", tableName: "users" });
    releaseColumns([column("id")]);
    await open;

    expect(pendingDuringQuery).toBe(false);
    expect(mocks.tabs[0]?.tableMeta?.primaryKeys).toEqual(["id"]);
    expect(mocks.tabs[0]?.tableMetaPending).toBe(false);
    expect(mocks.buildTableSelectSql).toHaveBeenCalledWith(
      expect.objectContaining({
        columns: ["id"],
        primaryKeys: ["id"],
      }),
    );
  });

  it("reuses cached metadata and force-refreshes it once per catalog after a structure save", async () => {
    const navigation = useNavigationTargets(dialogs);
    const target = { connectionId: "connection-1", database: "app", schema: "public", catalog: "catalog-1", tableName: "users" };

    await navigation.openLineageTarget(target);
    await navigation.openLineageTarget(target);
    expect(mocks.getColumns).toHaveBeenCalledTimes(1);

    mocks.getColumns.mockResolvedValueOnce([column("fresh_id")]);

    await navigation.onStructureEditorSaved(vi.fn().mockResolvedValue(undefined), vi.fn(), {
      connectionId: target.connectionId,
      database: target.database,
      schema: target.schema,
      catalog: target.catalog,
      tableName: target.tableName,
    });

    expect(mocks.invalidateCompletionTableCache).toHaveBeenCalledWith("connection-1", "app", "users", "public", "catalog-1");
    expect(mocks.getColumns).toHaveBeenCalledTimes(2);
    expect(mocks.tabs.map((tab) => tab.tableMeta?.primaryKeys)).toEqual([["fresh_id"], ["fresh_id"]]);
  });

  it("keeps row identity pending when shared metadata loading fails", async () => {
    mocks.getColumns.mockRejectedValue(new Error("metadata unavailable"));

    await useNavigationTargets(dialogs).openLineageTarget({ connectionId: "connection-1", database: "app", schema: "public", tableName: "users" });

    expect(mocks.tabs[0]?.tableMeta?.columns).toEqual([]);
    expect(mocks.tabs[0]?.tableMetaPending).toBe(true);
  });

  it.each(["none", "database", "local"] as const)("opens the table when metadata preload fails in %s sort mode", async (mode) => {
    mocks.databaseType = "sqlite";
    mocks.tableOpenSortMode = mode;
    mocks.getColumns.mockRejectedValue(new Error("metadata unavailable"));

    await useNavigationTargets(dialogs).openLineageTarget({ connectionId: "connection-1", database: "app", tableName: "users" });

    expect(mocks.executeTabSql).toHaveBeenCalledTimes(1);
    expect(mocks.tabs[0]?.tableMetaPending).toBe(true);
  });

  it("uses the SQLite attached database as the table namespace when a target omits schema", async () => {
    mocks.databaseType = "sqlite";

    await useNavigationTargets(dialogs).openLineageTarget({ connectionId: "connection-1", database: "analytics", tableName: "events" });

    expect(mocks.tabs[0]?.schema).toBe("analytics");
    expect(mocks.tabs[0]?.tableMeta?.schema).toBe("analytics");
    expect(mocks.getColumns.mock.calls.some(([connectionId, database, schema, tableName]) => connectionId === "connection-1" && database === "analytics" && schema === "analytics" && tableName === "events")).toBe(true);
  });

  it("opens different targets in separate tabs even when sidebar data-tab reuse is enabled", async () => {
    const columnGates = new Map<string, (columns: unknown[]) => void>();
    mocks.getColumns.mockImplementation(
      (_connectionId: string, _database: string, _schema: string, tableName: string) =>
        new Promise((resolve) => {
          columnGates.set(tableName, resolve);
        }),
    );
    const navigation = useNavigationTargets(dialogs);
    const openA = navigation.openTableTarget({ connectionId: "connection-1", database: "app", schema: "public", tableName: "table_a" });
    await vi.waitFor(() => expect(columnGates.has("table_a")).toBe(true));

    const openB = navigation.openTableTarget({ connectionId: "connection-1", database: "app", schema: "public", tableName: "table_b" });
    await vi.waitFor(() => expect(columnGates.has("table_b")).toBe(true));
    expect(mocks.tabs).toHaveLength(2);
    expect(mocks.tabs.map((tab) => tab.tableMeta?.tableName)).toEqual(["table_a", "table_b"]);

    columnGates.get("table_a")?.([column("a_id")]);
    columnGates.get("table_b")?.([column("b_id")]);
    await Promise.all([openA, openB]);
    expect(mocks.tabs.map((tab) => tab.tableMeta?.primaryKeys)).toEqual([["a_id"], ["b_id"]]);
    expect(mocks.tabs.every((tab) => tab.tableMetaPending === false)).toBe(true);
  });

  it("stops landing when another entry point takes over the tab, even for the same table", async () => {
    const { beginDataTabNavigation } = await import("@/lib/tabs/dataTabNavigationGeneration");
    // A(openTableTarget)的 getColumns 挂起
    const columnGates = new Map<string, (columns: unknown[]) => void>();
    mocks.getColumns.mockImplementation(
      (_connectionId: string, _database: string, _schema: string, tableName: string) =>
        new Promise((resolve) => {
          columnGates.set(tableName, resolve);
        }),
    );
    const navigation = useNavigationTargets(dialogs);
    const openA = navigation.openLineageTarget({ connectionId: "connection-1", database: "app", schema: "public", tableName: "users" });
    await vi.waitFor(() => expect(columnGates.has("users")).toBe(true));
    mocks.setTableMeta.mockClear();

    // 侧边栏 openData 接管同一 tab(同表——目标身份校验无法区分):登记新代次即作废旧代次
    beginDataTabNavigation(mocks.tabs[0]!.id);

    // 旧 A 晚返回:目标身份仍匹配,但代次已作废,不得落地元数据
    columnGates.get("users")?.([column("id")]);
    await openA;
    expect(mocks.setTableMeta).not.toHaveBeenCalled();
  });

  it("skips the tdengine requery when a cancel was requested during the first execute", async () => {
    // tdengine 无条件走元数据后的第二次查询。模拟:首次 executeTabSql 期间
    // 用户点击停止,但取消返回 false(查询先完成),isCancelling 被清、
    // 结果正常——重查仍然必须被跳过(不能替用户重跑他停掉的查询)
    mocks.databaseType = "tdengine";
    mocks.executeTabSql.mockImplementationOnce(async (id: string) => {
      const tab = mocks.tabs.find((item) => item.id === id);
      if (tab) {
        // 用户在执行期间请求停止:计数单调递增;随后取消失败、状态被清
        tab.cancelRequestCount = (tab.cancelRequestCount ?? 0) + 1;
        tab.isCancelling = false;
        tab.result = { columns: ["id"], rows: [[1]], affected_rows: 0, execution_time_ms: 1 };
      }
    });

    await useNavigationTargets(dialogs).openLineageTarget({ connectionId: "connection-1", database: "app", schema: "public", tableName: "users" });

    // 只有首次执行;tdengine 重查被取消请求拦下,元数据仍正常落地
    expect(mocks.executeTabSql).toHaveBeenCalledTimes(1);
    expect(mocks.tabs[0]?.tableMeta?.columns.length).toBeGreaterThan(0);
  });

  it("runs the tdengine requery normally when no cancel was requested", async () => {
    mocks.databaseType = "tdengine";

    await useNavigationTargets(dialogs).openLineageTarget({ connectionId: "connection-1", database: "app", schema: "public", tableName: "users" });

    // 无取消请求:元数据落地后按既有行为执行第二次查询
    expect(mocks.executeTabSql).toHaveBeenCalledTimes(2);
  });
});