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 { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import type { DatabaseType } from "@/types/database";
const mocks = vi.hoisted(() => ({
beginManualTransaction: vi.fn(),
closeClientConnectionSession: vi.fn(),
commitManualTransaction: vi.fn(),
rollbackManualTransaction: vi.fn(),
saveOpenTabsState: vi.fn(),
}));
vi.mock("@/lib/backend/api", () => mocks);
function deferred<T>() {
let resolve!: (value: T) => void;
let reject!: (error: Error) => void;
const promise = new Promise<T>((resolvePromise, rejectPromise) => {
resolve = resolvePromise;
reject = rejectPromise;
});
return { promise, resolve, reject };
}
async function setupManualTab(dbType: DatabaseType) {
const { useConnectionStore } = await import("@/stores/connectionStore");
const { useSettingsStore } = await import("@/stores/settingsStore");
const { useQueryStore } = await import("@/stores/queryStore");
useConnectionStore().connections.push(...["conn", "other-conn"].map((id) => ({ id, name: id, db_type: dbType, database: "ORCL", host: "localhost", port: 1521, username: "", password: "" })));
useSettingsStore().editorSettings.confirmUnsavedSqlClose = false;
const store = useQueryStore();
const id = store.createTab("conn", "ORCL", "Query", "query", "APP");
store.setAutoCommit(id, false);
mocks.beginManualTransaction.mockResolvedValueOnce("txn-old");
await store.ensureManualTransactionSession(id, "ORCL", "APP");
store.markManualTransactionDirty(id);
const tab = store.tabs.find((candidate) => candidate.id === id)!;
return { store, id, tab };
}
async function finishCommit(commit: ReturnType<typeof deferred<void>>, committing: Promise<void>, outcome: "success" | "failure") {
const error = new Error("Commit response lost");
const settled = outcome === "success" ? expect(committing).resolves.toBeUndefined() : expect(committing).rejects.toBe(error);
if (outcome === "success") commit.resolve();
else commit.reject(error);
await settled;
}
describe.each(["oracle", "oceanbase-oracle"] as const)("queryStore %s commit lifecycle", (dbType) => {
beforeEach(() => {
vi.resetAllMocks();
vi.stubGlobal("localStorage", { getItem: () => null, setItem: () => {}, removeItem: () => {} });
setActivePinia(createPinia());
mocks.saveOpenTabsState.mockResolvedValue(undefined);
mocks.closeClientConnectionSession.mockResolvedValue(undefined);
mocks.rollbackManualTransaction.mockResolvedValue(undefined);
});
afterEach(() => vi.unstubAllGlobals());
it("preserves a synchronous backend error and permits the next transaction to commit", async () => {
const { store, id, tab } = await setupManualTab(dbType);
const error = new Error("Synchronous commit boundary failure");
mocks.commitManualTransaction.mockImplementationOnce(() => {
throw error;
});
await expect(store.commitTransaction(id)).rejects.toBe(error);
expect(tab.txnSessionId).toBeUndefined();
expect(tab.txnPossiblyDirty).toBe(false);
mocks.beginManualTransaction.mockResolvedValueOnce("txn-next");
await store.ensureManualTransactionSession(id, "ORCL", "APP");
mocks.commitManualTransaction.mockResolvedValueOnce(undefined);
await expect(store.commitTransaction(id)).resolves.toBeUndefined();
expect(mocks.commitManualTransaction.mock.calls.map(([sessionId]) => sessionId)).toEqual(["txn-old", "txn-next"]);
expect(tab.txnSessionId).toBeUndefined();
});
it.each(["success", "failure"] as const)("shares an in-flight commit until its %s result arrives", async (outcome) => {
const { store, id, tab } = await setupManualTab(dbType);
const commit = deferred<void>();
mocks.commitManualTransaction.mockReturnValueOnce(commit.promise).mockRejectedValue(new Error("Transaction session not found"));
const first = store.commitTransaction(id);
const second = store.commitTransaction(id);
const secondResult = second.then(
() => undefined,
(error) => error,
);
await Promise.resolve();
await Promise.resolve();
expect(mocks.commitManualTransaction).toHaveBeenCalledTimes(1);
expect(tab.txnSessionId).toBe("txn-old");
expect(tab.txnPossiblyDirty).toBe(true);
await finishCommit(commit, first, outcome);
expect(await secondResult).toEqual(outcome === "success" ? undefined : new Error("Commit response lost"));
expect(tab.txnSessionId).toBeUndefined();
});
it("tracks a replacement commit independently while the old commit finishes", async () => {
const { store, id, tab } = await setupManualTab(dbType);
const oldCommit = deferred<void>();
const newCommit = deferred<void>();
mocks.commitManualTransaction.mockReturnValueOnce(oldCommit.promise).mockReturnValueOnce(newCommit.promise);
const oldCommitting = store.commitTransaction(id);
store.updateSchema(id, "OTHER");
mocks.beginManualTransaction.mockResolvedValueOnce("txn-new");
await store.ensureManualTransactionSession(id, "ORCL", "OTHER");
store.markManualTransactionDirty(id);
const newCommitting = store.commitTransaction(id);
oldCommit.resolve();
await oldCommitting;
const duplicate = store.commitTransaction(id);
expect(mocks.commitManualTransaction.mock.calls.map(([sessionId]) => sessionId)).toEqual(["txn-old", "txn-new"]);
expect(tab.txnSessionId).toBe("txn-new");
expect(tab.txnPossiblyDirty).toBe(true);
newCommit.resolve();
await Promise.all([newCommitting, duplicate]);
expect(tab.txnSessionId).toBeUndefined();
});
describe.each(["success", "failure"] as const)("old commit %s", (outcome) => {
it("keeps a reopened tab's new transaction independent of the old pending commit", async () => {
const { store, id, tab } = await setupManualTab(dbType);
const oldCommit = deferred<void>();
const newCommit = deferred<void>();
mocks.commitManualTransaction.mockReturnValueOnce(oldCommit.promise).mockReturnValueOnce(newCommit.promise);
const oldCommitting = store.commitTransaction(id);
store.closeTab(id);
expect(store.reopenClosedTab()).toBe(id);
const reopened = store.tabs.find((candidate) => candidate.id === id)!;
expect(reopened).not.toBe(tab);
expect(reopened.txnSessionId).toBeUndefined();
store.setAutoCommit(id, false);
mocks.beginManualTransaction.mockResolvedValueOnce("txn-reopened");
await store.ensureManualTransactionSession(id, "ORCL", "APP");
store.markManualTransactionDirty(id);
const newCommitting = store.commitTransaction(id);
await finishCommit(oldCommit, oldCommitting, outcome);
expect(reopened.txnSessionId).toBe("txn-reopened");
expect(reopened.txnPossiblyDirty).toBe(true);
const duplicate = store.commitTransaction(id);
expect(mocks.commitManualTransaction.mock.calls.map(([sessionId]) => sessionId)).toEqual(["txn-old", "txn-reopened"]);
newCommit.resolve();
await Promise.all([newCommitting, duplicate]);
expect(reopened.txnSessionId).toBeUndefined();
expect(reopened.txnPossiblyDirty).toBe(false);
});
it.each(["mode", "schema", "database", "connection"] as const)("preserves a replacement transaction after a %s change", async (change) => {
const { store, id, tab } = await setupManualTab(dbType);
const commit = deferred<void>();
mocks.commitManualTransaction.mockReturnValueOnce(commit.promise);
const committing = store.commitTransaction(id);
expect(mocks.commitManualTransaction).toHaveBeenCalledWith("txn-old");
const rollback = deferred<void>();
if (change === "schema") mocks.rollbackManualTransaction.mockReturnValueOnce(rollback.promise);
if (change === "mode") {
// Core removes the old session before awaiting COMMIT, so rollback can see not-found.
mocks.rollbackManualTransaction.mockRejectedValueOnce(new Error("Transaction session not found"));
store.setAutoCommit(id, true);
store.setAutoCommit(id, false);
} else if (change === "schema") store.updateSchema(id, "OTHER");
else if (change === "database") store.updateDatabase(id, "OTHER");
else {
store.updateConnection(id, "other-conn", "OTHER");
store.setAutoCommit(id, false);
}
mocks.beginManualTransaction.mockResolvedValueOnce("txn-new");
await store.ensureManualTransactionSession(id, tab.database, tab.schema);
store.markManualTransactionDirty(id);
await finishCommit(commit, committing, outcome);
expect(tab.txnSessionId).toBe("txn-new");
expect(tab.txnPossiblyDirty).toBe(true);
rollback.resolve();
await rollback.promise;
// The replacement remains usable by the next caller and by the rollback control.
await expect(store.ensureManualTransactionSession(id, tab.database, tab.schema)).resolves.toBe("txn-new");
await store.rollbackTransaction(id);
expect(mocks.rollbackManualTransaction).toHaveBeenLastCalledWith("txn-new");
expect(tab.txnSessionId).toBeUndefined();
expect(tab.txnPossiblyDirty).toBe(false);
});
it("cleans up the original session when no replacement was opened", async () => {
const { store, id, tab } = await setupManualTab(dbType);
const commit = deferred<void>();
mocks.commitManualTransaction.mockReturnValueOnce(commit.promise);
const committing = store.commitTransaction(id);
await finishCommit(commit, committing, outcome);
expect(tab.txnSessionId).toBeUndefined();
expect(tab.txnStatus).toBeUndefined();
expect(tab.txnPossiblyDirty).toBe(false);
expect(tab.txnAutoRolledBack).toBe(false);
expect(tab.autoCommit).toBe(false);
});
it("keeps auto-commit mode after the old session was discarded", async () => {
const { store, id, tab } = await setupManualTab(dbType);
const commit = deferred<void>();
mocks.commitManualTransaction.mockReturnValueOnce(commit.promise);
const committing = store.commitTransaction(id);
store.setAutoCommit(id, true);
await finishCommit(commit, committing, outcome);
expect(tab.autoCommit).toBe(true);
expect(tab.txnSessionId).toBeUndefined();
expect(tab.txnPossiblyDirty).toBe(false);
});
it("allows a replacement session still opening when the old commit ends", async () => {
const { store, id, tab } = await setupManualTab(dbType);
const commit = deferred<void>();
mocks.commitManualTransaction.mockReturnValueOnce(commit.promise);
const committing = store.commitTransaction(id);
store.setAutoCommit(id, true);
store.setAutoCommit(id, false);
const begin = deferred<string>();
mocks.beginManualTransaction.mockReturnValueOnce(begin.promise);
const starting = store.ensureManualTransactionSession(id, "ORCL", "APP");
await finishCommit(commit, committing, outcome);
begin.resolve("txn-new");
await expect(starting).resolves.toBe("txn-new");
store.markManualTransactionDirty(id);
expect(tab.txnSessionId).toBe("txn-new");
expect(tab.txnPossiblyDirty).toBe(true);
});
it("does not affect a new tab after the committing tab closes", async () => {
const { store, id } = await setupManualTab(dbType);
const commit = deferred<void>();
mocks.commitManualTransaction.mockReturnValueOnce(commit.promise);
const committing = store.commitTransaction(id);
store.closeTab(id);
expect(store.tabs.some((tab) => tab.id === id)).toBe(false);
const newId = store.createTab("conn", "ORCL", "Query", "query", "APP");
store.setAutoCommit(newId, false);
mocks.beginManualTransaction.mockResolvedValueOnce("txn-new");
await store.ensureManualTransactionSession(newId, "ORCL", "APP");
store.markManualTransactionDirty(newId);
await finishCommit(commit, committing, outcome);
const newTab = store.tabs.find((tab) => tab.id === newId)!;
expect(newTab.txnSessionId).toBe("txn-new");
expect(newTab.txnPossiblyDirty).toBe(true);
expect(store.activeTabId).toBe(newId);
});
});
});