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。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
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: [] });
});
});