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。

22.1 KB
Raw Blame
import { createPinia, setActivePinia } from "pinia";
import { beforeEach, describe, expect, it, vi } from "vitest";
import { ACTIVE_TAB_STORAGE_KEY, OPEN_TABS_STORAGE_KEY } from "@/lib/app/openTabsPersistence";

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)),
  });
  return data;
}

describe("queryStore database open state", () => {
  beforeEach(() => {
    vi.resetModules();
    vi.unstubAllGlobals();
    installLocalStorage();
    setActivePinia(createPinia());
  });

  it("tracks whether a connection database has open tabs", async () => {
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();

    const tabId = store.createTab("pg-1", "app", "query_1");

    expect(store.isDatabaseOpen("pg-1", "app")).toBe(true);
    expect(store.isDatabaseOpen("pg-1", "analytics")).toBe(false);
    expect(store.isDatabaseOpen("pg-2", "app")).toBe(false);

    store.updateDatabase(tabId, "analytics");

    expect(store.isDatabaseOpen("pg-1", "app")).toBe(false);
    expect(store.isDatabaseOpen("pg-1", "analytics")).toBe(true);

    store.closeTab(tabId);

    expect(store.isDatabaseOpen("pg-1", "analytics")).toBe(false);
  }, 10_000);

  it("reuses one database browser tab per connection", async () => {
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();

    const firstId = store.openDatabaseBrowser("pg-1");
    const secondId = store.openDatabaseBrowser("pg-1");
    const otherConnectionId = store.openDatabaseBrowser("pg-2");

    expect(secondId).toBe(firstId);
    expect(otherConnectionId).not.toBe(firstId);
    expect(store.tabs.filter((tab) => tab.mode === "databases")).toHaveLength(2);
    expect(store.tabs.find((tab) => tab.id === firstId)).toMatchObject({ connectionId: "pg-1", database: "", mode: "databases" });
  });

  it.each(["create", "view"] as const)("does not reuse a consumed Schema index %s navigation request id", async (kind) => {
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const request = kind === "create" ? { create: true } : { view: { schema: "APP", name: "IX_A", parentSchema: "OTHER", parentName: "T" } };
    const id = store.openObjectBrowser("ob", "service", "APP", undefined, undefined, false, "indexes", undefined, request);
    const state = store.tabs.find((tab) => tab.id === id)!.objectBrowser!;
    const firstRequest = kind === "create" ? state.indexCreateRequestId : state.initialViewRequestId;
    state.indexCreateRequestId = undefined;
    state.initialViewRequestId = undefined;
    state.initialViewTarget = undefined;
    expect(store.openObjectBrowser("ob", "service", "APP", undefined, undefined, false, "indexes", undefined, request)).toBe(id);
    const next = store.tabs.find((tab) => tab.id === id)!.objectBrowser!;
    expect(kind === "create" ? next.indexCreateRequestId : next.initialViewRequestId).toBeGreaterThan(firstRequest!);
  });

  it.each(["create", "view"] as const)("supersedes an unconsumed Schema index %s request in the reused tab", async (first) => {
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const view = { schema: "APP", name: "IX_A", parentSchema: "OTHER", parentName: "T" };
    const id = store.openObjectBrowser("ob", "service", "APP", undefined, undefined, false, "indexes", undefined, first === "create" ? { create: true } : { view });
    const sequence = store.tabs.find((tab) => tab.id === id)!.objectBrowser!.indexRequestSequence!;
    expect(store.openObjectBrowser("ob", "service", "APP", undefined, undefined, false, "indexes", undefined, first === "create" ? { view } : { create: true })).toBe(id);
    const state = store.tabs.find((tab) => tab.id === id)!.objectBrowser!;
    expect(state.indexRequestSequence).toBeGreaterThan(sequence);
    expect(state.indexCreateRequestId).toBe(first === "view" ? state.indexRequestSequence : undefined);
    expect(state.initialViewRequestId).toBe(first === "create" ? state.indexRequestSequence : undefined);
    expect(state.initialViewTarget).toEqual(first === "create" ? view : undefined);
    expect(store.tabs.filter((tab) => tab.mode === "objects")).toHaveLength(1);
  });

  it("retargets a connection-scoped driver workspace to a database branch", async () => {
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();

    const firstId = store.openDriverProfileWorkspace("dolt-1", "inventory", "Version Control", "dolt-version-control", "connection");
    const branchId = store.openDriverProfileWorkspace("dolt-1", "analytics", "Version Control", "dolt-version-control", "connection", "feature/orders");

    expect(branchId).toBe(firstId);
    expect(store.tabs.find((tab) => tab.id === firstId)).toMatchObject({
      database: "analytics",
      workspaceBranch: "feature/orders",
      mode: "dolt-version-control",
    });
  });

  it("keeps database-scoped driver workspaces isolated", async () => {
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();

    const inventoryId = store.openDriverProfileWorkspace("profile-1", "inventory", "Workspace", "dolt-version-control", "database");
    const analyticsId = store.openDriverProfileWorkspace("profile-1", "analytics", "Workspace", "dolt-version-control", "database");

    expect(analyticsId).not.toBe(inventoryId);
    expect(store.tabs.filter((tab) => tab.mode === "dolt-version-control")).toHaveLength(2);
  });

  it("keeps object browser filter, search, and viewport per tab", async () => {
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();

    const tabId = store.openObjectBrowser("pg-1", "app", "public");
    store.updateObjectBrowserFilter(tabId, "views");
    store.updateObjectBrowserSearch(tabId, "orders");
    store.updateObjectBrowserViewport(tabId, { scrollTop: 340, viewMode: "list" });

    const tab = store.tabs.find((item) => item.id === tabId);
    expect(tab?.objectBrowser?.filter).toBe("views");
    expect(tab?.objectBrowser?.searchQuery).toBe("orders");
    expect(tab?.objectBrowser?.viewport).toEqual({ scrollTop: 340, viewMode: "list" });

    const otherTabId = store.createTab("pg-1", "app", "query");
    store.switchTab(otherTabId);
    store.switchTab(tabId);
    expect(store.tabs.find((item) => item.id === tabId)?.objectBrowser?.filter).toBe("views");
    expect(store.tabs.find((item) => item.id === tabId)?.objectBrowser?.searchQuery).toBe("orders");

    store.updateSchema(tabId, "archive");

    expect(tab?.objectBrowser?.schema).toBe("archive");
    // The keyword intentionally survives a schema switch: the mounted browser keeps its local search too.
    expect(tab?.objectBrowser?.searchQuery).toBe("orders");
    expect(tab?.objectBrowser?.filter).toBeUndefined();
    expect(tab?.objectBrowser?.viewport).toBeUndefined();
  });

  it("keeps external catalog object browsers isolated", async () => {
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();

    const icebergTabId = store.openObjectBrowser("doris-1", "default", undefined, "iceberg_catalog");
    const hiveTabId = store.openObjectBrowser("doris-1", "default", undefined, "hive_catalog");

    expect(hiveTabId).not.toBe(icebergTabId);
    expect(store.tabs.find((tab) => tab.id === icebergTabId)?.objectBrowser?.catalog).toBe("iceberg_catalog");
    expect(store.tabs.find((tab) => tab.id === hiveTabId)?.objectBrowser?.catalog).toBe("hive_catalog");
    expect(store.openObjectBrowser("doris-1", "default", undefined, "iceberg_catalog")).toBe(icebergTabId);
  });

  it("keeps external catalog structure editors isolated", async () => {
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();

    const icebergTabId = store.openTableStructure("doris-1", "sales", undefined, "orders", undefined, undefined, "iceberg_catalog");
    const hiveTabId = store.openTableStructure("doris-1", "sales", undefined, "orders", undefined, undefined, "hive_catalog");

    expect(hiveTabId).not.toBe(icebergTabId);
    expect(store.tabs.find((tab) => tab.id === icebergTabId)?.catalog).toBe("iceberg_catalog");
    expect(store.tabs.find((tab) => tab.id === hiveTabId)?.catalog).toBe("hive_catalog");
    expect(store.openTableStructure("doris-1", "sales", undefined, "orders", undefined, undefined, "iceberg_catalog")).toBe(icebergTabId);
  });

  it("keeps same-name structure editors in different schemas isolated", async () => {
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();

    const publicTabId = store.openTableStructure("pg-1", "app", "public", "users");
    const archiveTabId = store.openTableStructure("pg-1", "app", "archive", "users");

    expect(archiveTabId).not.toBe(publicTabId);
    expect(store.tabs.filter((tab) => tab.mode === "structure")).toHaveLength(2);
    expect(store.tabs.find((tab) => tab.id === publicTabId)?.schema).toBe("public");
    expect(store.tabs.find((tab) => tab.id === archiveTabId)?.schema).toBe("archive");
    expect(store.openTableStructure("pg-1", "app", "public", "users")).toBe(publicTabId);
    expect(store.activeTabId).toBe(publicTabId);
  });

  it("preserves case-sensitive schema and table identities", async () => {
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();

    const quotedTabId = store.openTableStructure("pg-1", "app", "Sales", "Users");
    const schemaCaseTabId = store.openTableStructure("pg-1", "app", "sales", "Users");
    const tableCaseTabId = store.openTableStructure("pg-1", "app", "Sales", "users");

    expect(new Set([quotedTabId, schemaCaseTabId, tableCaseTabId])).toHaveLength(3);
    expect(store.openTableStructure("pg-1", "app", "Sales", "Users")).toBe(quotedTabId);
  });

  it("never upgrades a legacy structure draft to an exact dictionary target", async () => {
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const legacy = store.openTableStructure("ob", "service", " Mixed ", " T(a) ");
    const oldTab = store.tabs.find((tab) => tab.id === legacy)!;
    oldTab.structureDraft = { dirty: true, newTableName: "untouched" } as NonNullable<typeof oldTab.structureDraft>;
    const exact = store.openTableStructure("ob", "service", " Mixed ", " T(a) ", "indexes", { kind: "index", name: " Ix(a) " }, undefined, "table", true);
    expect(exact).not.toBe(legacy);
    expect(oldTab.structureDraft.newTableName).toBe("untouched");
    expect(oldTab.structureExactIdentity).toBeUndefined();
    expect(store.tabs.find((tab) => tab.id === exact)).toMatchObject({ schema: " Mixed ", structureTableName: " T(a) ", structureExactIdentity: true });
    expect(store.openTableStructure("ob", "service", " Mixed ", " T(a) ", "indexes", { kind: "index", name: "Ix(a)" }, undefined, "table", true)).toBe(exact);
    expect(store.openTableStructure("ob", "service", "Mixed", "T(a)", "indexes", undefined, undefined, "table", true)).not.toBe(exact);
  });

  it("isolates exact structure refreshes by raw identity, catalog and metadata mode", async () => {
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    store.invalidateTableStructure("ob", "service", " Mixed ", " T(a) ", true, "catalog");
    expect(store.tableStructureRefreshVersion("ob", "service", " Mixed ", " T(a) ", true, "catalog")).toBe(1);
    expect(store.tableStructureRefreshVersion("ob", "service", " Mixed ", " T(a) ")).toBe(0);
    expect(store.tableStructureRefreshVersion("ob", "service", " Mixed ", " T(a) ", true, "other")).toBe(0);
    expect(store.tableStructureRefreshVersion("ob", "service", " mixed ", " T(a) ", true, "catalog")).toBe(0);
    expect(store.tableStructureRefreshVersion("ob", "service", "Mixed", "T(a)", true, "catalog")).toBe(0);
    store.invalidateTableStructure("ob", "service", "APP", "TABLE");
    expect(store.tableStructureRefreshVersion("ob", "service", "app", "table")).toBe(1);
  });

  it("retains explicit create-index requests without inventing an existing index name", async () => {
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const create = { kind: "index", name: "", action: "create" } as const;
    const id = store.openTableStructure("ob", "service", "APP", "Items", undefined, create, undefined, "table", true);
    expect(store.tabs.find((tab) => tab.id === id)).toMatchObject({ structureInitialTarget: create, structureInitialTabRequestId: 1 });
    store.openTableStructure("ob", "service", "APP", "Items", undefined, create, undefined, "table", true);
    expect(store.tabs.find((tab) => tab.id === id)).toMatchObject({ structureInitialTarget: create, structureInitialTabRequestId: 2 });
  });

  it("retains raw index owner requests while reusing an exact parent tab with dirty drafts", async () => {
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const initial = { kind: "index", name: " Ix(a) ", owner: " Owner " } as const;
    const id = store.openTableStructure("ob", "service", " Owner ", " T(a) ", "indexes", initial, undefined, "table", true);
    const tab = store.tabs.find((item) => item.id === id)!;
    tab.structureDraft = { dirty: true, newTableName: "untouched" } as NonNullable<typeof tab.structureDraft>;
    expect(tab.structureInitialTarget).toEqual(initial);

    const deletion = { ...initial, action: "delete" } as const;
    expect(store.openTableStructure("ob", "service", " Owner ", " T(a) ", "indexes", deletion, undefined, "table", true)).toBe(id);
    expect(tab.structureInitialTarget).toEqual(deletion);
    expect(tab.structureDraft.newTableName).toBe("untouched");
  });

  it("reuses only matching schema-less structure targets", async () => {
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();

    const schemaLessTabId = store.openTableStructure("mysql-1", "app", undefined, "users");
    const reusedTabId = store.openTableStructure("mysql-1", "app", undefined, "users", "columns", { kind: "column", name: "id" });
    const explicitSchemaTabId = store.openTableStructure("mysql-1", "app", "public", "users");
    const firstCreateTabId = store.openTableStructure("mysql-1", "app", undefined, "");
    const secondCreateTabId = store.openTableStructure("mysql-1", "app", undefined, "");

    expect(reusedTabId).toBe(schemaLessTabId);
    expect(store.tabs.find((tab) => tab.id === schemaLessTabId)).toMatchObject({
      schema: undefined,
      structureInitialTab: "columns",
      structureInitialTabRequestId: 1,
      structureInitialTarget: { kind: "column", name: "id" },
    });
    expect(explicitSchemaTabId).not.toBe(schemaLessTabId);
    expect(secondCreateTabId).not.toBe(firstCreateTabId);
  });

  it("clears the catalog when changing a query tab connection", async () => {
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();

    const tabId = store.createTab("doris-1", "sales", "Query", "query", undefined, undefined, "hive_catalog");
    const tab = store.tabs.find((item) => item.id === tabId)!;

    store.updateConnection(tabId, "doris-2", "analytics");

    expect(tab.connectionId).toBe("doris-2");
    expect(tab.catalog).toBeUndefined();
    expect(tab.database).toBe("analytics");
    expect(tab.schema).toBeUndefined();
  });

  it("closes data and structure tabs for a dropped table object", async () => {
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();

    const queryId = store.createTab("pg-1", "app", "Query", "query", "public");
    const dataId = store.createTab("pg-1", "app", "users", "data", "public");
    store.setTableMeta(dataId, {
      schema: "public",
      tableName: "users",
      tableType: "TABLE",
      columns: [],
      primaryKeys: [],
    });
    const otherSchemaDataId = store.createTab("pg-1", "app", "users", "data", "archive");
    store.setTableMeta(otherSchemaDataId, {
      schema: "archive",
      tableName: "users",
      tableType: "TABLE",
      columns: [],
      primaryKeys: [],
    });
    const otherConnectionDataId = store.createTab("pg-2", "app", "users", "data", "public");
    store.setTableMeta(otherConnectionDataId, {
      schema: "public",
      tableName: "users",
      tableType: "TABLE",
      columns: [],
      primaryKeys: [],
    });
    const structureId = store.openTableStructure("pg-1", "app", "public", "users");

    store.activeTabId = dataId;
    store.closeDroppedTableObjectTabs({
      connectionId: "pg-1",
      database: "app",
      schema: "public",
      name: "users",
      objectType: "TABLE",
    });

    expect(store.tabs.some((tab) => tab.id === dataId)).toBe(false);
    expect(store.tabs.some((tab) => tab.id === structureId)).toBe(false);
    expect(store.tabs.some((tab) => tab.id === otherSchemaDataId)).toBe(true);
    expect(store.tabs.some((tab) => tab.id === otherConnectionDataId)).toBe(true);
    expect(store.tabs.some((tab) => tab.id === queryId)).toBe(true);
    expect(store.activeTabId).not.toBe(dataId);
  });

  it("closes data tabs but keeps structure tabs for dropped views", async () => {
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();

    const dataId = store.createTab("pg-1", "app", "report_view", "data", "public");
    store.setTableMeta(dataId, {
      schema: "public",
      tableName: "report_view",
      tableType: "VIEW",
      columns: [],
      primaryKeys: [],
    });
    const structureId = store.openTableStructure("pg-1", "app", "public", "report_view");

    store.closeDroppedTableObjectTabs({
      connectionId: "pg-1",
      database: "app",
      schema: "public",
      name: "report_view",
      objectType: "VIEW",
    });

    expect(store.tabs.some((tab) => tab.id === dataId)).toBe(false);
    expect(store.tabs.some((tab) => tab.id === structureId)).toBe(true);
  });

  it("closes only the matching HBase table tab after deletion", async () => {
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();

    const deletedTableId = store.createTab("hbase-1", "metrics", "events", "hbase", undefined, "events");
    const otherTableId = store.createTab("hbase-1", "metrics", "archive", "hbase", undefined, "archive");
    const otherNamespaceId = store.createTab("hbase-1", "default", "events", "hbase", undefined, "events");

    store.closeDroppedTableObjectTabs({
      connectionId: "hbase-1",
      database: "metrics",
      name: "events",
      objectType: "TABLE",
    });

    expect(store.tabs.some((tab) => tab.id === deletedTableId)).toBe(false);
    expect(store.tabs.some((tab) => tab.id === otherTableId)).toBe(true);
    expect(store.tabs.some((tab) => tab.id === otherNamespaceId)).toBe(true);
  });

  it("matches dropped table schema candidates", async () => {
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();

    const dataId = store.createTab("pg-1", "app", "orders", "data", "app");
    store.setTableMeta(dataId, {
      schema: "app",
      tableName: "orders",
      tableType: "TABLE",
      columns: [],
      primaryKeys: [],
    });
    const structureId = store.openTableStructure("pg-1", "app", undefined, "orders");

    store.closeDroppedTableObjectTabs({
      connectionId: "pg-1",
      database: "app",
      schema: "app",
      schemaCandidates: [undefined, "app"],
      name: "orders",
      objectType: "TABLE",
    });

    expect(store.tabs.some((tab) => tab.id === dataId)).toBe(false);
    expect(store.tabs.some((tab) => tab.id === structureId)).toBe(false);
  });

  it("does not restore open tabs when launch restore mode is none", async () => {
    const persistedTabs = JSON.stringify([
      {
        id: "tab-1",
        title: "Query 1",
        connectionId: "pg-1",
        database: "app",
        sql: "select 1",
      },
    ]);

    vi.resetModules();
    vi.unstubAllGlobals();
    const storage = installLocalStorage();
    storage.set("dbx-editor-settings", JSON.stringify({ openTabsRestoreMode: "none" }));
    storage.set("dbx-app-state:open_tabs", JSON.stringify({ tabs: JSON.parse(persistedTabs), activeTabId: "tab-1" }));
    storage.set(OPEN_TABS_STORAGE_KEY, persistedTabs);
    storage.set(ACTIVE_TAB_STORAGE_KEY, "tab-1");
    setActivePinia(createPinia());

    const { useSettingsStore } = await import("@/stores/settingsStore");
    const { useQueryStore } = await import("@/stores/queryStore");
    await useSettingsStore().initEditorSettings();
    const store = useQueryStore();
    await store.initOpenTabs();

    expect(store.tabs).toEqual([]);
    expect(store.activeTabId).toBeNull();
    expect(storage.get(OPEN_TABS_STORAGE_KEY)).toBeUndefined();
    expect(storage.get(ACTIVE_TAB_STORAGE_KEY)).toBeUndefined();
    expect(JSON.parse(storage.get("dbx-app-state:open_tabs") ?? "{}")).toEqual({ tabs: [], activeTabId: null });
  });

  it("restores only pinned tabs when launch restore mode is pinned", async () => {
    const persistedTabs = JSON.stringify([
      {
        id: "tab-1",
        title: "Pinned",
        connectionId: "pg-1",
        database: "app",
        sql: "select 1",
        pinned: true,
      },
      {
        id: "tab-2",
        title: "Regular",
        connectionId: "pg-1",
        database: "app",
        sql: "select 2",
      },
    ]);

    vi.resetModules();
    vi.unstubAllGlobals();
    const storage = installLocalStorage();
    storage.set("dbx-editor-settings", JSON.stringify({ openTabsRestoreMode: "pinned" }));
    storage.set(OPEN_TABS_STORAGE_KEY, persistedTabs);
    storage.set(ACTIVE_TAB_STORAGE_KEY, "tab-2");
    setActivePinia(createPinia());

    const { useSettingsStore } = await import("@/stores/settingsStore");
    const { useQueryStore } = await import("@/stores/queryStore");
    await useSettingsStore().initEditorSettings();
    const store = useQueryStore();
    await store.initOpenTabs();

    expect(store.tabs.map((tab) => tab.id)).toEqual(["tab-1"]);
    expect(store.activeTabId).toBe("tab-1");
  });
});