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。

19.9 KB
Raw Blame
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");
  });
});