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。

9.0 KB
Raw Blame
import { describe, expect, it } from "vitest";
import { canApplyDataTabMetadata, dataTabMetadataNeedsRefresh, dataTabOpenModeFromTreeClick, findExistingDataTabCandidate, isDataTabMetadataLifecycleStale } from "@/lib/sidebar/dataTabOpenPolicy";
import type { QueryTab } from "@/types/database";

function click(modifiers: Partial<Pick<MouseEvent, "metaKey" | "ctrlKey" | "altKey" | "shiftKey">> = {}) {
  return {
    metaKey: modifiers.metaKey ?? false,
    ctrlKey: modifiers.ctrlKey ?? false,
    altKey: modifiers.altKey ?? false,
    shiftKey: modifiers.shiftKey ?? false,
  };
}

function dataTab(id: string, title: string, schema = "public"): QueryTab {
  return {
    id,
    title,
    connectionId: "conn",
    database: "app",
    schema,
    sql: "",
    isExecuting: false,
    mode: "data",
  };
}

const usersTarget = { connectionId: "conn", database: "app", schema: "public", tableName: "users" };

describe("dataTabOpenPolicy", () => {
  it("maps the default Alt/Option modifier to explicit new-tab mode for data nodes only", () => {
    expect(dataTabOpenModeFromTreeClick("table", click({ altKey: true }), "Alt")).toBe("new-tab");
    expect(dataTabOpenModeFromTreeClick("view", click({ altKey: true }), "Alt")).toBe("new-tab");
    expect(dataTabOpenModeFromTreeClick("materialized_view", click({ altKey: true }), "Alt")).toBe("new-tab");
    expect(dataTabOpenModeFromTreeClick("database", click({ altKey: true }), "Alt")).toBe("default");
  });

  it("honors customized modifier-only shortcuts and a cleared shortcut", () => {
    expect(dataTabOpenModeFromTreeClick("table", click({ ctrlKey: true }), "Mod")).toBe("new-tab");
    expect(dataTabOpenModeFromTreeClick("table", click({ metaKey: true }), "Mod")).toBe("new-tab");
    expect(dataTabOpenModeFromTreeClick("table", click({ shiftKey: true }), "Shift")).toBe("new-tab");
    expect(dataTabOpenModeFromTreeClick("table", click({ altKey: true }), "")).toBe("default");
  });

  it("does not consume tree selection modifier combinations under the default Alt shortcut", () => {
    expect(dataTabOpenModeFromTreeClick("table", click({ metaKey: true }), "Alt")).toBe("default");
    expect(dataTabOpenModeFromTreeClick("table", click({ ctrlKey: true }), "Alt")).toBe("default");
    expect(dataTabOpenModeFromTreeClick("table", click({ shiftKey: true }), "Alt")).toBe("default");
    expect(dataTabOpenModeFromTreeClick("table", click({ altKey: true, shiftKey: true }), "Alt")).toBe("default");
  });

  it("never returns an existing tab in explicit new-tab mode", () => {
    const existing = dataTab("users", "users");
    existing.tableMeta = { schema: "public", tableName: "users", columns: [], primaryKeys: [] };

    expect(findExistingDataTabCandidate([existing], usersTarget, { openMode: "new-tab", reuseMode: "same-table" })).toBeUndefined();
    expect(findExistingDataTabCandidate([existing], usersTarget, { openMode: "new-tab", reuseMode: "active-tab", activeTabId: existing.id })).toBeUndefined();
  });

  it("only reuses the same table when reuse is enabled", () => {
    const sameTable = dataTab("users", "users");
    sameTable.tableMeta = { schema: "public", tableName: "users", columns: [], primaryKeys: [] };
    const otherTable = dataTab("orders", "orders");

    expect(findExistingDataTabCandidate([sameTable], usersTarget, { openMode: "default", reuseMode: "always-new" })).toBeUndefined();
    expect(findExistingDataTabCandidate([sameTable], usersTarget, { openMode: "default", reuseMode: "same-table" })).toEqual({ tab: sameTable, match: "same-table" });
    expect(findExistingDataTabCandidate([otherTable], usersTarget, { openMode: "default", reuseMode: "same-table" })).toBeUndefined();
  });

  it("reuses the active safe data tab for a different table", () => {
    const active = dataTab("orders", "orders");

    expect(findExistingDataTabCandidate([active], usersTarget, { openMode: "default", reuseMode: "active-tab", activeTabId: active.id })).toEqual({ tab: active, match: "active-tab" });
  });

  it.each([
    ["pinned", { pinned: true }],
    ["executing", { isExecuting: true }],
    ["cancelling", { isCancelling: true }],
    ["explaining", { isExplaining: true }],
    ["manual transaction", { txnSessionId: "txn-1" }],
    ["pending edits", { pendingDataChangeCount: 1 }],
    ["pending editor draft", { hasPendingDataEditorDraft: true }],
  ])("does not reuse the active tab when it is %s", (_label, patch) => {
    const active = Object.assign(dataTab("orders", "orders"), patch);

    expect(findExistingDataTabCandidate([active], usersTarget, { openMode: "default", reuseMode: "active-tab", activeTabId: active.id })).toBeUndefined();
  });

  it("does not reuse an active tab from another database or catalog", () => {
    const otherDatabase = dataTab("orders", "orders");
    otherDatabase.database = "archive";
    const otherCatalog = dataTab("catalog-orders", "orders");
    otherCatalog.catalog = "analytics";

    expect(findExistingDataTabCandidate([otherDatabase], usersTarget, { openMode: "default", reuseMode: "active-tab", activeTabId: otherDatabase.id })).toBeUndefined();
    expect(findExistingDataTabCandidate([otherCatalog], usersTarget, { openMode: "default", reuseMode: "active-tab", activeTabId: otherCatalog.id })).toBeUndefined();
  });

  it("does not reuse a same-name table from another schema", () => {
    const archiveUsers = dataTab("archive-users", "users", "archive");
    archiveUsers.tableMeta = { schema: "archive", tableName: "users", columns: [], primaryKeys: [] };

    expect(findExistingDataTabCandidate([archiveUsers], usersTarget, { openMode: "default", reuseMode: "same-table" })).toBeUndefined();
  });

  it("allows metadata to update a tab that still points to the requested table", () => {
    const tab = dataTab("users", "users");
    tab.tableMeta = { schema: "public", tableName: "users", columns: [], primaryKeys: [] };

    expect(canApplyDataTabMetadata(tab, usersTarget, new AbortController().signal)).toBe(true);
  });

  it("uses restored table metadata as the schema identity fallback", () => {
    const tab = dataTab("users", "users");
    tab.schema = undefined;
    tab.tableMeta = { schema: "public", tableName: "users", columns: [], primaryKeys: [] };

    expect(canApplyDataTabMetadata(tab, usersTarget, new AbortController().signal)).toBe(true);
    expect(findExistingDataTabCandidate([tab], usersTarget, { openMode: "default", reuseMode: "same-table" })).toEqual({ tab, match: "same-table" });
  });

  it("ignores metadata query schemas for database-scoped tables", () => {
    const tab = dataTab("users", "users");
    tab.schema = undefined;
    tab.tableMeta = { schema: "app", tableName: "users", columns: [], primaryKeys: [] };
    const mysqlTarget = { connectionId: "conn", database: "app", tableName: "users" };

    expect(canApplyDataTabMetadata(tab, mysqlTarget, new AbortController().signal)).toBe(true);
    expect(findExistingDataTabCandidate([tab], mysqlTarget, { openMode: "default", reuseMode: "same-table" })).toEqual({ tab, match: "same-table" });
  });

  it("rejects metadata after its request is cancelled", () => {
    const tab = dataTab("users", "users");
    tab.tableMeta = { schema: "public", tableName: "users", columns: [], primaryKeys: [] };
    const controller = new AbortController();
    controller.abort();

    expect(canApplyDataTabMetadata(tab, usersTarget, controller.signal)).toBe(false);
  });

  it("rejects stale metadata after a reusable tab switches to another table", () => {
    const tab = dataTab("reused", "orders");
    tab.tableMeta = { schema: "public", tableName: "orders", columns: [], primaryKeys: [] };

    expect(canApplyDataTabMetadata(tab, usersTarget, new AbortController().signal)).toBe(false);
  });

  it("refreshes missing, restored, and expired table metadata", () => {
    const now = 100_000;
    const ttl = 30_000;
    const tab = dataTab("users", "users");

    expect(dataTabMetadataNeedsRefresh(tab, ttl, now)).toBe(true);

    tab.tableMeta = {
      schema: "public",
      tableName: "users",
      columns: [{ name: "id", data_type: "integer", is_nullable: false, column_default: null, is_primary_key: true, extra: null }],
      primaryKeys: ["id"],
    };
    expect(dataTabMetadataNeedsRefresh(tab, ttl, now)).toBe(true);

    tab.tableMetaUpdatedAt = now - ttl + 1;
    expect(dataTabMetadataNeedsRefresh(tab, ttl, now)).toBe(false);

    tab.tableMetaUpdatedAt = now - ttl;
    expect(dataTabMetadataNeedsRefresh(tab, ttl, now)).toBe(true);
  });

  it("treats missing freshness or a generation mismatch as lifecycle-stale", () => {
    const tab = dataTab("users", "users");
    tab.tableMeta = {
      schema: "public",
      tableName: "users",
      columns: [{ name: "id", data_type: "integer", is_nullable: false, column_default: null, is_primary_key: true, extra: null }],
      primaryKeys: ["id"],
    };
    tab.tableMetaUpdatedAt = Date.now();
    tab.tableMetaGeneration = 0;

    expect(isDataTabMetadataLifecycleStale(tab, 0)).toBe(false);
    expect(isDataTabMetadataLifecycleStale(tab, 1)).toBe(true);

    tab.tableMetaUpdatedAt = undefined;
    expect(isDataTabMetadataLifecycleStale(tab, 0)).toBe(true);
  });
});