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 * as api from "@/lib/backend/api";
import { nextTransferTaskCopyName, TransferTaskNameConflictError, useTransferTaskStore } from "@/stores/transferTaskStore";
import type { TransferTask, TransferTaskConfig, TransferTaskLibrary } from "@/types/database";
vi.mock("@/lib/backend/api", () => ({
loadTransferTaskLibrary: vi.fn(),
saveTransferTaskLibrary: vi.fn(),
}));
function deferred<T>() {
let resolve!: (value: T | PromiseLike<T>) => void;
let reject!: (reason?: unknown) => void;
const promise = new Promise<T>((resolvePromise, rejectPromise) => {
resolve = resolvePromise;
reject = rejectPromise;
});
return { promise, resolve, reject };
}
function makeConfig(overrides: Partial<TransferTaskConfig> = {}): TransferTaskConfig {
return {
sourceConnectionId: "conn-a",
sourceDatabase: "app_db",
sourceSchema: "public",
targetConnectionId: "conn-b",
targetDatabase: "warehouse",
targetSchema: "public",
objects: { TABLE: ["users", "orders"] },
content: "structureAndData",
mode: "append",
targetTableNameCase: "preserve",
quoteTargetColumnNames: true,
batchSize: 1000,
...overrides,
};
}
async function createTask(store: ReturnType<typeof useTransferTaskStore>, name: string, folderId?: string): Promise<TransferTask> {
const input: { name: string; folderId?: string; config: TransferTaskConfig } = { name, config: makeConfig() };
if (folderId !== undefined) input.folderId = folderId;
return store.saveTask(input);
}
describe("transferTaskStore", () => {
beforeEach(() => {
setActivePinia(createPinia());
vi.clearAllMocks();
vi.mocked(api.loadTransferTaskLibrary).mockResolvedValue(null);
vi.mocked(api.saveTransferTaskLibrary).mockResolvedValue(undefined);
});
it("loads and normalizes the persisted library", async () => {
const library: TransferTaskLibrary = {
version: 1,
folders: [{ id: "folder-1", name: "ETL", orderIndex: 0, createdAt: "2026-01-01T00:00:00.000Z", updatedAt: "2026-01-01T00:00:00.000Z" }],
tasks: [{ id: "task-1", folderId: "folder-1", name: "daily sync", orderIndex: 0, config: makeConfig(), createdAt: "2026-01-01T00:00:00.000Z", updatedAt: "2026-01-01T00:00:00.000Z" }],
};
vi.mocked(api.loadTransferTaskLibrary).mockResolvedValue(library);
const store = useTransferTaskStore();
await store.initFromStorage();
expect(store.isLoaded).toBe(true);
expect(store.folders).toHaveLength(1);
expect(store.tasks).toHaveLength(1);
expect(store.listTasks("folder-1").map((task) => task.id)).toEqual(["task-1"]);
});
it("normalizes a legacy task with no object selection to an empty modern selection map", async () => {
const legacyConfig = makeConfig() as Partial<TransferTaskConfig>;
delete legacyConfig.objects;
vi.mocked(api.loadTransferTaskLibrary).mockResolvedValue({
version: 1,
folders: [],
tasks: [{ id: "legacy-selection", name: "legacy selection", config: legacyConfig }],
} as unknown as TransferTaskLibrary);
const store = useTransferTaskStore();
await store.initFromStorage();
expect(store.getTask("legacy-selection")?.config.objects).toEqual({});
});
it.each([
["source", "source"],
["target", "target"],
[undefined, undefined],
["invalid", undefined],
] as const)("round-trips package body choice %s without retaining approvals or operation records", async (bodySource, expectedSource) => {
const sql = 'CREATE PACKAGE BODY "T"."Pkg.With.Dot" AS -- 中文😀\nEND;';
const config = makeConfig({
objects: { PACKAGE_BODY: ["Pkg.With.Dot"] },
oraclePackageDrafts: [
{
identity: { owner: "T", name: "Pkg.With.Dot", kind: "PACKAGE_BODY" },
sql,
packageBodySource: bodySource,
packageContract: "target",
reviewedTargetDraft: true,
operation: { operationId: "old-operation" },
baselineOperationId: "old-operation",
supersedesOperationId: "old-preparation",
} as never,
],
});
const store = useTransferTaskStore();
const saved = await store.saveTask({ name: "package-body-draft", config });
expect(saved.config.oraclePackageDrafts?.[0].packageBodySource).toBe(expectedSource);
const persisted = vi.mocked(api.saveTransferTaskLibrary).mock.calls.at(-1)![0];
expect(JSON.stringify(persisted)).not.toContain("old-operation");
expect(JSON.stringify(persisted)).not.toContain("old-preparation");
vi.mocked(api.loadTransferTaskLibrary).mockResolvedValue(persisted);
setActivePinia(createPinia());
const reloaded = useTransferTaskStore();
await reloaded.initFromStorage();
expect(reloaded.getTask(saved.id)?.config.objects).toEqual({ PACKAGE_BODY: ["Pkg.With.Dot"] });
expect(reloaded.getTask(saved.id)?.config.oraclePackageDrafts).toEqual([expect.objectContaining({ identity: { owner: "T", name: "Pkg.With.Dot", kind: "PACKAGE_BODY" }, sql, packageContract: "target", reviewedTargetDraft: true })]);
expect(reloaded.getTask(saved.id)?.config.oraclePackageDrafts?.[0].packageBodySource).toBe(expectedSource);
expect(reloaded.getTask(saved.id)?.config.dropTargetConfirmed).toBe(false);
});
it("round-trips TABLE-only and TABLE + VIEW task selections", async () => {
const store = useTransferTaskStore();
const tableOnly = await store.saveTask({ name: "table-only", config: makeConfig({ objects: { TABLE: ["orders"] } }) });
const tableAndView = await store.saveTask({
name: "table-and-view",
config: makeConfig({ objects: { TABLE: ["orders"], VIEW: ["v_orders"] } }),
});
const persisted = vi.mocked(api.saveTransferTaskLibrary).mock.calls.at(-1)?.[0] as TransferTaskLibrary;
vi.mocked(api.loadTransferTaskLibrary).mockResolvedValue(persisted);
setActivePinia(createPinia());
const reloadedStore = useTransferTaskStore();
await reloadedStore.initFromStorage();
expect(reloadedStore.getTask(tableOnly.id)?.config.objects).toEqual({ TABLE: ["orders"] });
expect(reloadedStore.getTask(tableAndView.id)?.config.objects).toEqual({ TABLE: ["orders"], VIEW: ["v_orders"] });
});
it("keeps target column quoting enabled for saved tasks created before the option existed", async () => {
const legacyConfig = makeConfig() as Partial<TransferTaskConfig>;
delete legacyConfig.quoteTargetColumnNames;
vi.mocked(api.loadTransferTaskLibrary).mockResolvedValue({
version: 1,
folders: [],
tasks: [{ id: "legacy", name: "legacy", config: legacyConfig, createdAt: "2026-01-01T00:00:00.000Z", updatedAt: "2026-01-01T00:00:00.000Z" }],
} as unknown as TransferTaskLibrary);
const store = useTransferTaskStore();
await store.initFromStorage();
expect(store.tasks[0]?.config.quoteTargetColumnNames).toBe(true);
});
it("round-trips the target column name case and defaults legacy tasks to preserve", async () => {
const legacyConfig = makeConfig() as Partial<TransferTaskConfig>;
const store = useTransferTaskStore();
const saved = await store.saveTask({ name: "upper", config: makeConfig({ targetColumnNameCase: "upper" }) });
vi.mocked(api.loadTransferTaskLibrary).mockResolvedValue({
version: 1,
folders: [],
tasks: [saved, { id: "legacy", name: "legacy", config: legacyConfig, createdAt: "2026-01-01T00:00:00.000Z", updatedAt: "2026-01-01T00:00:00.000Z" }],
} as unknown as TransferTaskLibrary);
setActivePinia(createPinia());
const reloaded = useTransferTaskStore();
await reloaded.initFromStorage();
expect(reloaded.getTask(saved.id)?.config.targetColumnNameCase).toBe("upper");
expect(reloaded.getTask("legacy")?.config.targetColumnNameCase).toBe("preserve");
});
it("keeps legacy tasks on inherited timeouts and round-trips a custom timeout", async () => {
const store = useTransferTaskStore();
const inherited = await store.saveTask({ name: "inherited", config: makeConfig() });
const custom = await store.saveTask({ name: "custom", config: makeConfig({ operationTimeoutSecs: 600 }) });
const unlimited = await store.saveTask({ name: "unlimited", config: makeConfig({ operationTimeoutSecs: 0 }) });
expect(inherited.config.operationTimeoutSecs).toBeUndefined();
expect(custom.config.operationTimeoutSecs).toBe(600);
expect(unlimited.config.operationTimeoutSecs).toBe(0);
});
it("drops an invalid persisted transfer timeout instead of applying it", async () => {
vi.mocked(api.loadTransferTaskLibrary).mockResolvedValue({
version: 1,
folders: [],
tasks: [{ id: "invalid-timeout", name: "invalid timeout", config: makeConfig({ operationTimeoutSecs: 3601 }) }],
} as unknown as TransferTaskLibrary);
const store = useTransferTaskStore();
await store.initFromStorage();
expect(store.getTask("invalid-timeout")?.config.operationTimeoutSecs).toBeUndefined();
});
it("loads a legacy rebuild task as append without restoring its previous confirmation", async () => {
vi.mocked(api.loadTransferTaskLibrary).mockResolvedValue({
version: 1,
folders: [],
tasks: [{ id: "legacy-rebuild", name: "legacy rebuild", config: makeConfig({ mode: "upsert", dropTargetBeforeCreate: true, dropTargetConfirmed: true }) }],
});
const store = useTransferTaskStore();
await store.initFromStorage();
expect(store.getTask("legacy-rebuild")?.config).toMatchObject({ mode: "append", dropTargetBeforeCreate: true, dropTargetConfirmed: false });
});
it("saves mutually exclusive rebuild options without persisting request confirmation", async () => {
const store = useTransferTaskStore();
const task = await store.saveTask({ name: "rebuild", config: makeConfig({ mode: "overwrite", dropTargetBeforeCreate: true, dropTargetConfirmed: true }) });
expect(task.config).toMatchObject({ mode: "append", dropTargetBeforeCreate: true, dropTargetConfirmed: false });
const persisted = vi.mocked(api.saveTransferTaskLibrary).mock.calls.at(-1)?.[0] as TransferTaskLibrary;
expect(persisted.tasks[0]?.config).toMatchObject({ mode: "append", dropTargetBeforeCreate: true, dropTargetConfirmed: false });
});
it.each(["append", "overwrite", "upsert"] as const)("keeps ordinary %s tasks unchanged while dropping stale confirmation", async (mode) => {
const store = useTransferTaskStore();
const task = await store.saveTask({ name: mode, config: makeConfig({ mode, dropTargetBeforeCreate: false, dropTargetConfirmed: true }) });
expect(task.config).toMatchObject({ mode, dropTargetBeforeCreate: false, dropTargetConfirmed: false });
});
it("refuses to overwrite a persisted library with invalid entries", async () => {
vi.mocked(api.loadTransferTaskLibrary).mockResolvedValue({
version: 1,
folders: [{ id: "folder-1", name: "ETL" }, { name: "missing id" }],
tasks: [{ id: "task-1", name: "ok", config: makeConfig() }],
});
const store = useTransferTaskStore();
await store.initFromStorage();
expect(store.isLoaded).toBe(false);
await expect(store.createFolder("new folder")).rejects.toThrow("Invalid transfer task library entry");
expect(api.saveTransferTaskLibrary).not.toHaveBeenCalled();
});
it("refuses unknown persisted versions without replacing them", async () => {
vi.mocked(api.loadTransferTaskLibrary).mockResolvedValue({ version: 2, folders: [], tasks: [] });
const store = useTransferTaskStore();
await expect(store.createFolder("new folder")).rejects.toThrow("Unsupported transfer task library version: 2");
expect(store.isLoaded).toBe(false);
expect(api.saveTransferTaskLibrary).not.toHaveBeenCalled();
});
it("loads the legacy unversioned shape and migrates it on the next save", async () => {
vi.mocked(api.loadTransferTaskLibrary).mockResolvedValue({
folders: [{ id: "folder-1", name: "ETL", createdAt: "2026-01-01T00:00:00.000Z", updatedAt: "2026-01-01T00:00:00.000Z" }],
tasks: [],
});
const store = useTransferTaskStore();
await store.createFolder("reporting");
expect(api.saveTransferTaskLibrary).toHaveBeenCalledWith(
expect.objectContaining({
version: 1,
folders: expect.arrayContaining([expect.objectContaining({ name: "ETL" }), expect.objectContaining({ name: "reporting" })]),
}),
);
});
it("waits for delayed initialization before applying an immediate mutation", async () => {
const loadGate = deferred<TransferTaskLibrary>();
vi.mocked(api.loadTransferTaskLibrary).mockReturnValue(loadGate.promise);
const store = useTransferTaskStore();
const initialization = store.initFromStorage();
const creation = store.createFolder("reporting");
await Promise.resolve();
expect(api.saveTransferTaskLibrary).not.toHaveBeenCalled();
loadGate.resolve({
version: 1,
folders: [{ id: "folder-1", name: "ETL", createdAt: "2026-01-01T00:00:00.000Z", updatedAt: "2026-01-01T00:00:00.000Z" }],
tasks: [],
});
await initialization;
await creation;
expect(store.folders.map((folder) => folder.name)).toEqual(["ETL", "reporting"]);
expect(api.saveTransferTaskLibrary).toHaveBeenCalledWith(expect.objectContaining({ version: 1 }));
});
it("serializes whole-library saves so later mutations cannot finish first", async () => {
const firstSave = deferred<void>();
vi.mocked(api.saveTransferTaskLibrary)
.mockImplementationOnce(() => firstSave.promise)
.mockResolvedValueOnce(undefined);
const store = useTransferTaskStore();
const first = store.createFolder("first");
await vi.waitFor(() => expect(api.saveTransferTaskLibrary).toHaveBeenCalledTimes(1));
const second = store.createFolder("second");
await Promise.resolve();
expect(api.saveTransferTaskLibrary).toHaveBeenCalledTimes(1);
firstSave.resolve();
await Promise.all([first, second]);
const secondPayload = vi.mocked(api.saveTransferTaskLibrary).mock.calls[1]?.[0] as TransferTaskLibrary;
expect(secondPayload.folders.map((folder) => folder.name)).toEqual(["first", "second"]);
});
it("keeps a later successful mutation when the first queued save fails", async () => {
vi.mocked(api.saveTransferTaskLibrary).mockRejectedValueOnce(new Error("disk full")).mockResolvedValueOnce(undefined);
const store = useTransferTaskStore();
const first = store.createFolder("first");
const second = store.createFolder("second");
await expect(first).rejects.toThrow("disk full");
await expect(second).resolves.toEqual(expect.objectContaining({ name: "second" }));
expect(store.folders.map((folder) => folder.name)).toEqual(["second"]);
const secondPayload = vi.mocked(api.saveTransferTaskLibrary).mock.calls[1]?.[0] as TransferTaskLibrary;
expect(secondPayload.folders.map((folder) => folder.name)).toEqual(["second"]);
});
it("creates folders and rejects duplicate names within the same parent", async () => {
const store = useTransferTaskStore();
await store.initFromStorage();
await store.createFolder("ETL");
await expect(store.createFolder("etl")).rejects.toBeInstanceOf(TransferTaskNameConflictError);
const child = await store.createFolder("etl", store.folders[0]?.id);
expect(child.parentFolderId).toBe(store.folders[0]?.id);
expect(api.saveTransferTaskLibrary).toHaveBeenCalled();
});
it("creates and updates tasks, keeping the folder on config-only updates", async () => {
const store = useTransferTaskStore();
await store.initFromStorage();
const folder = await store.createFolder("ETL");
const task = await store.saveTask({ name: "sync", folderId: folder.id, config: makeConfig() });
const updated = await store.saveTask({ id: task.id, name: "sync", config: makeConfig({ mode: "overwrite" }) });
expect(updated.folderId).toBe(folder.id);
expect(updated.config.mode).toBe("overwrite");
expect(store.tasks).toHaveLength(1);
});
it("rejects duplicate task names within the same folder", async () => {
const store = useTransferTaskStore();
await store.initFromStorage();
await createTask(store, "sync");
await expect(createTask(store, "SYNC")).rejects.toBeInstanceOf(TransferTaskNameConflictError);
const folder = await store.createFolder("ETL");
await expect(createTask(store, "sync", folder.id)).resolves.toBeTruthy();
});
it("duplicates a task with an incrementing copy name", async () => {
const store = useTransferTaskStore();
await store.initFromStorage();
const task = await createTask(store, "sync");
const first = await store.duplicateTask(task.id);
const second = await store.duplicateTask(task.id);
expect(first?.name).toBe("sync_copy1");
expect(second?.name).toBe("sync_copy2");
expect(first?.config).toEqual(task.config);
expect(first?.id).not.toBe(task.id);
});
it("cascades folder deletion to descendant folders and tasks", async () => {
const store = useTransferTaskStore();
await store.initFromStorage();
const parent = await store.createFolder("parent");
const child = await store.createFolder("child", parent.id);
await createTask(store, "in-parent", parent.id);
await createTask(store, "in-child", child.id);
await createTask(store, "root-task");
await store.deleteFolder(parent.id);
expect(store.folders).toHaveLength(0);
expect(store.tasks.map((task) => task.name)).toEqual(["root-task"]);
});
it("moves a task into a folder and reindexes both groups", async () => {
const store = useTransferTaskStore();
await store.initFromStorage();
const folder = await store.createFolder("ETL");
const first = await createTask(store, "first");
const second = await createTask(store, "second");
await store.moveTaskToFolder(first.id, folder.id);
expect(store.getTask(first.id)?.folderId).toBe(folder.id);
expect(store.listTasks(undefined).map((task) => task.name)).toEqual(["second"]);
expect(store.listTasks(folder.id).map((task) => task.name)).toEqual(["first"]);
expect(store.listTasks(undefined)[0]?.orderIndex).toBe(0);
expect(second.folderId).toBeUndefined();
});
it("reorders tasks within a folder", async () => {
const store = useTransferTaskStore();
await store.initFromStorage();
const first = await createTask(store, "first");
await createTask(store, "second");
const third = await createTask(store, "third");
await store.reorderTasks(third.id, first.id, "before");
expect(store.listTasks(undefined).map((task) => task.name)).toEqual(["third", "first", "second"]);
expect(store.listTasks(undefined).map((task) => task.orderIndex)).toEqual([0, 1, 2]);
});
it("moves a folder into another folder and prevents cycles", async () => {
const store = useTransferTaskStore();
await store.initFromStorage();
const parent = await store.createFolder("parent");
const child = await store.createFolder("child", parent.id);
// Moving a folder into its own descendant must be rejected (cycle).
await store.moveFolderToFolder(parent.id, child.id);
expect(store.folders.find((folder) => folder.id === parent.id)?.parentFolderId).toBeUndefined();
await store.moveFolderToFolder(child.id, undefined);
expect(store.folders.find((folder) => folder.id === child.id)?.parentFolderId).toBeUndefined();
});
it("rolls back state when persistence fails", async () => {
const store = useTransferTaskStore();
await store.initFromStorage();
await store.createFolder("ETL");
vi.mocked(api.saveTransferTaskLibrary).mockRejectedValueOnce(new Error("disk full"));
await expect(store.createFolder("fail")).rejects.toThrow("disk full");
expect(store.folders.map((folder) => folder.name)).toEqual(["ETL"]);
});
});
describe("nextTransferTaskCopyName", () => {
it("increments the copy suffix and reuses a stripped copy base", () => {
expect(nextTransferTaskCopyName("sync", new Set())).toBe("sync_copy1");
expect(nextTransferTaskCopyName("sync", new Set(["sync_copy1"]))).toBe("sync_copy2");
expect(nextTransferTaskCopyName("sync_copy1", new Set(["sync_copy1"]))).toBe("sync_copy2");
});
});