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。

24.6 KB
Raw Blame
// @vitest-environment happy-dom

import { createApp, defineComponent, h, nextTick, type App } from "vue";
import { afterEach, describe, expect, it, vi } from "vitest";
import { createDataCompareSelection, isCompareRowSelected } from "@/lib/dataGrid/dataCompareSelection";
import i18n from "@/i18n";
import DataCompareDialog from "@/components/diff/DataCompareDialog.vue";
import type { DataCompareSession } from "@/composables/useDataCompareSession";

vi.mock("vue-virtual-scroller", () => ({
  DynamicScroller: defineComponent({
    props: ["items"],
    setup:
      (props, { slots }) =>
      () =>
        h(
          "div",
          props.items.map((item: unknown, index: number) => slots.default?.({ item, index, active: true })),
        ),
  }),
  DynamicScrollerItem: defineComponent({
    setup:
      (_, { slots }) =>
      () =>
        h("div", slots.default?.()),
  }),
}));

const mocks = vi.hoisted(() => ({
  toast: vi.fn(),
  copyToClipboard: vi.fn().mockResolvedValue(undefined),
  ensureConnected: vi.fn().mockResolvedValue(undefined),
  listDatabases: vi.fn().mockResolvedValue([]),
  listSchemas: vi.fn().mockResolvedValue(["DBX_TEST", "REPORTING", "SYS"]),
  listTables: vi.fn().mockResolvedValue([{ name: "CODEX_7467_META", table_type: "TABLE" }]),
  getColumns: vi.fn().mockResolvedValue([{ name: "ID", data_type: "NUMBER", is_primary_key: true }]),
  buildDataCompareSyncPlan: vi.fn(),
  executeBatch: vi.fn(),
  beginManualTransaction: vi.fn().mockResolvedValue("compare-txn"),
  executeInManualTransaction: vi.fn().mockResolvedValue([]),
  commitManualTransaction: vi.fn().mockResolvedValue({}),
  rollbackManualTransaction: vi.fn().mockResolvedValue({}),
}));

vi.mock("@/lib/common/clipboard", () => ({ copyToClipboard: mocks.copyToClipboard }));

vi.mock("@/composables/useToast", () => ({ useToast: () => ({ toast: mocks.toast }) }));

const sessionMocks = vi.hoisted(() => ({
  session: null as DataCompareSession | null,
}));

vi.mock("@/composables/useDataCompareSession", async (importOriginal) => {
  const actual = await importOriginal<typeof import("@/composables/useDataCompareSession")>();
  return {
    ...actual,
    getDataCompareSession: (id: string | null | undefined) => (id && sessionMocks.session?.id === id ? sessionMocks.session : undefined),
  };
});

vi.mock("@/stores/connectionStore", () => {
  const connections = [
    { id: "oracle-11g", name: "Oracle XE 11g", db_type: "oracle", driver_profile: "oracle", database: "XE" },
    {
      id: "oracle-jdbc-11g",
      name: "Oracle JDBC 11g",
      db_type: "jdbc",
      driver_profile: "oracle",
      connection_string: "jdbc:oracle:thin:@//localhost:1521/XE",
      jdbc_driver_class: "oracle.jdbc.OracleDriver",
    },
  ];
  return {
    useConnectionStore: () => ({
      connections,
      sidebarLayout: {
        groups: [{ id: "oracle", name: "Oracle", collapsed: false }],
        order: [{ type: "group", id: "oracle", children: connections.map((connection) => ({ type: "connection", id: connection.id })) }],
      },
      getConfig: (id: string) => connections.find((connection) => connection.id === id),
      ensureConnected: mocks.ensureConnected,
    }),
  };
});

vi.mock("@/lib/backend/api", () => ({
  listDatabases: mocks.listDatabases,
  listSchemas: mocks.listSchemas,
  listTables: mocks.listTables,
  getColumns: mocks.getColumns,
  buildDataCompareSyncPlan: mocks.buildDataCompareSyncPlan,
  executeBatch: mocks.executeBatch,
  beginManualTransaction: mocks.beginManualTransaction,
  executeInManualTransaction: mocks.executeInManualTransaction,
  commitManualTransaction: mocks.commitManualTransaction,
  rollbackManualTransaction: mocks.rollbackManualTransaction,
}));

const mountedApps: App[] = [];

async function flushAsyncSetup() {
  for (let index = 0; index < 8; index += 1) {
    await nextTick();
    await new Promise((resolve) => setTimeout(resolve, 0));
  }
}

afterEach(() => {
  for (const app of mountedApps.splice(0)) app.unmount();
  document.body.textContent = "";
  sessionMocks.session = null;
  vi.clearAllMocks();
  vi.unstubAllGlobals();
});

function completedSession(): DataCompareSession {
  return {
    id: "compare-session",
    version: 1,
    status: "completed",
    config: {
      sourceConnectionId: "oracle-11g",
      sourceDatabase: "DBX_TEST",
      sourceSchema: "DBX_TEST",
      sourceDatabases: ["DBX_TEST"],
      sourceSchemas: ["DBX_TEST"],
      sourceTables: ["ORDERS"],
      selectedSourceTables: ["ORDERS"],
      targetConnectionId: "oracle-jdbc-11g",
      targetDatabase: "REPORTING",
      targetSchema: "DBX_TEST",
      targetDatabases: ["REPORTING"],
      targetSchemas: ["DBX_TEST"],
      targetTables: ["ORDERS"],
      targetTable: "ORDERS",
      keyColumns: ["ID"],
      label: "Oracle source → Oracle target",
    },
    progress: null,
    batchResults: [
      {
        sourceTable: "ORDERS",
        targetTable: "ORDERS",
        keyColumns: ["ID"],
        columns: ["ID", "NAME"],
        columnInfo: [],
        status: "different",
        added: 2,
        removed: 0,
        modified: 0,
        sourceRowCount: 2,
        targetRowCount: 0,
        sourceTruncated: false,
        targetTruncated: false,
        rowBudget: 100_000,
        syncEligible: true,
        databaseType: "oracle",
        selection: { added: createDataCompareSelection(true), removed: createDataCompareSelection(true), modified: createDataCompareSelection(true) },
        diff: {
          added: [
            { key: "1", keyValues: { ID: 1 }, values: { ID: 1, NAME: "first" } },
            { key: "2", keyValues: { ID: 2 }, values: { ID: 2, NAME: "second" } },
          ],
          removed: [],
          modified: [],
        },
        expanded: true,
        showAll: { added: true, removed: true, modified: true },
      },
    ],
    syncPlan: {
      insertCount: 2,
      updateCount: 0,
      deleteCount: 0,
      statementCount: 2,
      syncStatements: ["INSERT 1", "INSERT 2"],
      syncSql: "INSERT 1;\nINSERT 2;",
    },
    error: null,
    startedAt: 1,
    finishedAt: 2,
  };
}

function mountSessionDialog(session: DataCompareSession): App {
  sessionMocks.session = session;
  const container = document.createElement("div");
  document.body.append(container);
  const app = createApp(
    defineComponent({
      setup: () => () => h(DataCompareDialog, { open: true, sessionId: session.id }),
    }),
  );
  mountedApps.push(app);
  app.use(i18n);
  app.mount(container);
  return app;
}

function buttonFor(key: string): HTMLButtonElement {
  const button = [...document.querySelectorAll<HTMLButtonElement>("button")].find((button) => button.textContent?.trim() === i18n.global.t(key));
  if (!button) throw new Error(`Missing button: ${key}`);
  return button;
}

async function mountManualSession(session = completedSession()) {
  const app = mountSessionDialog(session);
  await flushAsyncSetup();
  const label = [...document.querySelectorAll("label")].find((label) => label.textContent?.includes(i18n.global.t("toolbar.manualTransaction")));
  const checkbox = label?.querySelector<HTMLInputElement>('input[type="checkbox"]');
  expect(checkbox).toBeDefined();
  checkbox!.click();
  await nextTick();
  return app;
}

describe("DataCompareDialog manual transactions", () => {
  it("keeps the target session pending until commit and locks target changes", async () => {
    const session = completedSession();
    await mountManualSession(session);
    buttonFor("diff.executeSync").click();
    await vi.waitFor(() => expect(document.body.textContent).toContain(i18n.global.t("dataCompare.pendingTransaction")));
    expect(mocks.beginManualTransaction).toHaveBeenCalledWith("oracle-jdbc-11g", "REPORTING", "DBX_TEST");
    expect(mocks.executeInManualTransaction).toHaveBeenCalledWith("compare-txn", "INSERT 1;\nINSERT 2", "REPORTING", "DBX_TEST");
    expect(mocks.executeBatch).not.toHaveBeenCalled();
    expect(mocks.commitManualTransaction).not.toHaveBeenCalled();
    expect(buttonFor("dataCompare.recompare").disabled).toBe(true);
    expect([...document.querySelectorAll<HTMLButtonElement>("button.dbx-searchable-select-trigger")].every((button) => button.disabled)).toBe(true);
    buttonFor("toolbar.commit").click();
    await vi.waitFor(() => expect(mocks.commitManualTransaction).toHaveBeenCalledWith("compare-txn"));
    await flushAsyncSetup();
    expect(document.body.textContent).not.toContain(i18n.global.t("dataCompare.pendingTransaction"));
    expect(session.syncPlan.syncStatements).toEqual([]);
    expect(session.batchResults).toEqual([]);
  });

  it("rolls back without committing", async () => {
    await mountManualSession();
    buttonFor("diff.executeSync").click();
    await vi.waitFor(() => expect(document.body.textContent).toContain(i18n.global.t("dataCompare.pendingTransaction")));
    buttonFor("toolbar.rollback").click();
    await vi.waitFor(() => expect(mocks.rollbackManualTransaction).toHaveBeenCalledWith("compare-txn"));
    expect(mocks.commitManualTransaction).not.toHaveBeenCalled();
  });

  it("stops on the first failed batch without ordinary retries or later batches", async () => {
    const session = completedSession();
    session.syncPlan.syncStatements = Array.from({ length: 501 }, (_, index) => `INSERT ${index}`);
    session.syncPlan.statementCount = 501;
    mocks.executeInManualTransaction.mockRejectedValueOnce(new Error("transaction statement rejected"));
    await mountManualSession(session);
    buttonFor("diff.executeSync").click();
    await vi.waitFor(() => expect(mocks.rollbackManualTransaction).toHaveBeenCalledWith("compare-txn"));
    expect(mocks.executeInManualTransaction).toHaveBeenCalledTimes(1);
    expect(mocks.executeBatch).not.toHaveBeenCalled();
    expect(mocks.commitManualTransaction).not.toHaveBeenCalled();
  });

  it("cleans up a transaction created after the dialog unmounts", async () => {
    let resolveBegin!: (id: string) => void;
    mocks.beginManualTransaction.mockReturnValueOnce(new Promise((resolve) => (resolveBegin = resolve)));
    const app = await mountManualSession();
    buttonFor("diff.executeSync").click();
    await vi.waitFor(() => expect(mocks.beginManualTransaction).toHaveBeenCalled());
    mountedApps.splice(mountedApps.indexOf(app), 1);
    app.unmount();
    resolveBegin("late-compare-txn");
    await vi.waitFor(() => expect(mocks.rollbackManualTransaction).toHaveBeenCalledWith("late-compare-txn"));
    expect(mocks.executeInManualTransaction).not.toHaveBeenCalled();
  });

  it("keeps a rollback control when commit fails", async () => {
    mocks.commitManualTransaction.mockRejectedValueOnce(new Error("commit unavailable"));
    await mountManualSession();
    buttonFor("diff.executeSync").click();
    await vi.waitFor(() => expect(document.body.textContent).toContain(i18n.global.t("dataCompare.pendingTransaction")));
    buttonFor("toolbar.commit").click();
    await vi.waitFor(() => expect(mocks.commitManualTransaction).toHaveBeenCalled());
    await flushAsyncSetup();
    expect(buttonFor("toolbar.rollback").disabled).toBe(false);
    expect(document.body.textContent).toContain(i18n.global.t("dataCompare.pendingTransaction"));
  });

  it("waits for an active batch before rollback on unmount and skips later batches", async () => {
    const session = completedSession();
    session.syncPlan.syncStatements = Array.from({ length: 501 }, (_, index) => `INSERT ${index}`);
    session.syncPlan.statementCount = 501;
    let finish!: (rows: unknown[]) => void;
    mocks.executeInManualTransaction.mockReturnValueOnce(new Promise((resolve) => (finish = resolve)));
    const app = await mountManualSession(session);
    buttonFor("diff.executeSync").click();
    await vi.waitFor(() => expect(mocks.executeInManualTransaction).toHaveBeenCalledOnce());
    mountedApps.splice(mountedApps.indexOf(app), 1);
    app.unmount();
    expect(mocks.rollbackManualTransaction).not.toHaveBeenCalled();
    finish([]);
    await vi.waitFor(() => expect(mocks.rollbackManualTransaction).toHaveBeenCalledWith("compare-txn"));
    expect(mocks.executeInManualTransaction).toHaveBeenCalledTimes(1);
  });

  it("invalidates the sync plan after an unknown commit result without claiming success", async () => {
    const session = completedSession();
    mocks.commitManualTransaction.mockRejectedValueOnce(new Error("response lost"));
    await mountManualSession(session);
    buttonFor("diff.executeSync").click();
    await vi.waitFor(() => expect(document.body.textContent).toContain(i18n.global.t("dataCompare.pendingTransaction")));
    buttonFor("toolbar.commit").click();
    await vi.waitFor(() => expect(mocks.toast).toHaveBeenCalledWith("response lost", 5000));
    expect(buttonFor("toolbar.commit").disabled).toBe(true);
    mocks.rollbackManualTransaction.mockRejectedValueOnce(new Error("Transaction session not found"));
    buttonFor("toolbar.rollback").click();
    await vi.waitFor(() => expect(mocks.toast).toHaveBeenCalledWith(i18n.global.t("toolbar.commitOutcomeUnknown"), 5000));
    expect(session.syncPlan.syncStatements).toEqual([]);
    expect(session.batchResults).toEqual([]);
    expect(mocks.toast).not.toHaveBeenCalledWith(i18n.global.t("dataCompare.syncSuccess"), 2000);
  });

  it("disables commit when rollback after an execution error fails", async () => {
    mocks.executeInManualTransaction.mockRejectedValueOnce(new Error("statement failed"));
    mocks.rollbackManualTransaction.mockRejectedValueOnce(new Error("rollback unavailable"));
    await mountManualSession();
    buttonFor("diff.executeSync").click();
    await vi.waitFor(() => expect(mocks.rollbackManualTransaction).toHaveBeenCalled());
    await flushAsyncSetup();
    expect(buttonFor("toolbar.commit").disabled).toBe(true);
    expect(buttonFor("toolbar.rollback").disabled).toBe(false);
  });

  it("requires rollback confirmation before closing a pending transaction", async () => {
    const confirm = vi.fn().mockReturnValueOnce(false).mockReturnValueOnce(true);
    vi.stubGlobal("confirm", confirm);
    await mountManualSession();
    buttonFor("diff.executeSync").click();
    await vi.waitFor(() => expect(document.body.textContent).toContain(i18n.global.t("dataCompare.pendingTransaction")));
    buttonFor("common.close").click();
    await flushAsyncSetup();
    expect(mocks.rollbackManualTransaction).not.toHaveBeenCalled();
    buttonFor("common.close").click();
    await vi.waitFor(() => expect(mocks.rollbackManualTransaction).toHaveBeenCalledWith("compare-txn"));
    expect(confirm).toHaveBeenCalledTimes(2);
  });
});

describe("DataCompareDialog source prefill", () => {
  it("keeps the Oracle source table after loading database and schema prefills", async () => {
    const container = document.createElement("div");
    document.body.append(container);
    const app = createApp(
      defineComponent({
        setup: () => () =>
          h(DataCompareDialog, {
            open: true,
            prefillConnectionId: "oracle-11g",
            prefillDatabase: "DBX_TEST",
            prefillSchema: "DBX_TEST",
            prefillTable: "CODEX_7046_META",
          }),
      }),
    );
    mountedApps.push(app);
    app.use(i18n);
    app.mount(container);
    await flushAsyncSetup();

    expect(mocks.listDatabases).not.toHaveBeenCalled();
    expect(mocks.listSchemas).toHaveBeenCalledWith("oracle-11g", "XE", true);

    const searchableSelectTriggers = [...document.querySelectorAll<HTMLButtonElement>("button.dbx-searchable-select-trigger")];
    const sourceDatabaseTrigger = searchableSelectTriggers[0];
    expect(sourceDatabaseTrigger?.title).toBe("DBX_TEST");
    expect(sourceDatabaseTrigger?.disabled).toBe(false);
    sourceDatabaseTrigger?.click();
    await flushAsyncSetup();

    const databaseOptions = [...document.querySelectorAll<HTMLButtonElement>(".dbx-searchable-select-list button")].map((button) => button.textContent?.trim());
    expect(databaseOptions).toEqual(expect.arrayContaining(["DBX_TEST", "REPORTING"]));
    expect(mocks.listTables).toHaveBeenCalledWith("oracle-11g", "DBX_TEST", "DBX_TEST");
    expect(document.body.textContent).toContain("CODEX_7467_META");
    expect(document.body.textContent).not.toContain("暂无可比较的表");
  });

  it("loads schemas and tables after selecting an Oracle JDBC target connection", async () => {
    const container = document.createElement("div");
    document.body.append(container);
    const app = createApp(
      defineComponent({
        setup: () => () =>
          h(DataCompareDialog, {
            open: true,
            prefillConnectionId: "oracle-11g",
            prefillDatabase: "DBX_TEST",
            prefillSchema: "DBX_TEST",
            prefillTable: "CODEX_7467_META",
          }),
      }),
    );
    mountedApps.push(app);
    app.use(i18n);
    app.mount(container);
    await flushAsyncSetup();

    const targetConnectionTrigger = document.querySelectorAll<HTMLButtonElement>("button.dbx-diff-connection-trigger")[1];
    expect(targetConnectionTrigger).toBeDefined();
    targetConnectionTrigger?.click();
    await flushAsyncSetup();

    const jdbcConnectionOption = document.querySelector<HTMLButtonElement>('[data-picker-connection="oracle-jdbc-11g"]');
    expect(jdbcConnectionOption).toBeDefined();
    jdbcConnectionOption?.click();
    await flushAsyncSetup();

    expect(mocks.listSchemas).toHaveBeenCalledWith("oracle-jdbc-11g", "", true);

    const triggersAfterTargetLoad = [...document.querySelectorAll<HTMLButtonElement>("button.dbx-searchable-select-trigger")];
    const targetDatabaseTrigger = triggersAfterTargetLoad[2];
    expect(targetDatabaseTrigger?.disabled).toBe(false);
    targetDatabaseTrigger?.click();
    await flushAsyncSetup();

    const targetDatabaseOptions = [...document.querySelectorAll<HTMLButtonElement>(".dbx-searchable-select-list button")].map((button) => button.textContent?.trim());
    expect(targetDatabaseOptions).toEqual(expect.arrayContaining(["DBX_TEST", "REPORTING"]));

    const reportingOption = [...document.querySelectorAll<HTMLButtonElement>(".dbx-searchable-select-list button")].find((button) => button.textContent?.trim() === "REPORTING");
    expect(reportingOption).toBeDefined();
    reportingOption?.click();
    await flushAsyncSetup();

    expect(mocks.listTables).toHaveBeenCalledWith("oracle-jdbc-11g", "REPORTING", "DBX_TEST");
    expect(document.body.textContent).toContain("CODEX_7467_META");
  });
});

describe("DataCompareDialog session restore", () => {
  it("keeps restored fields, results, and sync SQL after queued watchers flush", async () => {
    const session = completedSession();
    mountSessionDialog(session);

    await flushAsyncSetup();

    expect(mocks.listSchemas).not.toHaveBeenCalled();
    expect(document.body.textContent).toContain("ORDERS");
    expect(document.body.textContent).toContain("ID=1");
    expect(document.querySelector<HTMLTextAreaElement>("textarea[readonly]")?.value).toBe("INSERT 1;\nINSERT 2;");
  });

  it("starts another comparison and distinguishes source and target panels after results", async () => {
    mountSessionDialog(completedSession());

    await flushAsyncSetup();

    const recompareButton = [...document.querySelectorAll<HTMLButtonElement>("button")].find((button) => button.textContent?.includes(i18n.global.t("dataCompare.recompare")));
    expect(recompareButton).toBeDefined();
    expect([...document.querySelectorAll("div")].filter((element) => element.classList.contains("border-blue-500/35"))).toHaveLength(1);
    expect([...document.querySelectorAll("div")].filter((element) => element.classList.contains("border-emerald-500/35"))).toHaveLength(1);

    recompareButton?.click();
    await flushAsyncSetup();

    expect(mocks.ensureConnected).toHaveBeenCalledWith("oracle-11g");
    expect(mocks.ensureConnected).toHaveBeenCalledWith("oracle-jdbc-11g");
  });

  it("disables recompare while sync SQL is still executing against the target", async () => {
    mocks.executeBatch.mockImplementation(() => new Promise(() => {}));
    mountSessionDialog(completedSession());

    await flushAsyncSetup();
    mocks.ensureConnected.mockClear();

    const executeButton = [...document.querySelectorAll<HTMLButtonElement>("button")].find((button) => button.textContent?.includes(i18n.global.t("diff.executeSync")));
    expect(executeButton).toBeDefined();
    executeButton?.click();
    await flushAsyncSetup();

    const recompareButton = [...document.querySelectorAll<HTMLButtonElement>("button")].find((button) => button.textContent?.includes(i18n.global.t("dataCompare.recompare")));
    expect(recompareButton).toBeDefined();
    expect(recompareButton?.disabled).toBe(true);

    recompareButton?.click();
    await flushAsyncSetup();

    expect(mocks.ensureConnected).not.toHaveBeenCalledWith("oracle-11g");
  });

  it("persists the latest selection plan when the dialog closes during planning", async () => {
    const session = completedSession();
    let resolvePlan!: (plan: DataCompareSession["syncPlan"]) => void;
    mocks.buildDataCompareSyncPlan.mockReturnValueOnce(new Promise((resolve) => (resolvePlan = resolve)));
    const app = mountSessionDialog(session);
    await flushAsyncSetup();

    const firstRow = [...document.querySelectorAll<HTMLButtonElement>("button")].find((button) => button.textContent?.includes("ID=1"));
    expect(firstRow).toBeDefined();
    firstRow?.click();
    await nextTick();
    expect(mocks.buildDataCompareSyncPlan).toHaveBeenCalledOnce();

    mountedApps.splice(mountedApps.indexOf(app), 1);
    app.unmount();
    resolvePlan({
      insertCount: 1,
      updateCount: 0,
      deleteCount: 0,
      statementCount: 1,
      syncStatements: ["INSERT 2"],
      syncSql: "INSERT 2;",
    });
    await flushAsyncSetup();

    expect(isCompareRowSelected(session.batchResults[0]!.selection.added, 0)).toBe(false);
    expect(session.syncPlan.syncStatements).toEqual(["INSERT 2"]);
    expect(session.syncPlan.syncSql).toBe("INSERT 2;");
  });
});

describe("DataCompareDialog results layout", () => {
  it("scrolls results in a plain container so the footer cannot overlap them", async () => {
    // Chromium cannot scroll or clip a <fieldset> that owns `overflow-auto`
    // (see issue #9839), so the scroll region must be a plain element and the
    // fieldset may only stay in the tree as the disabled-state provider.
    mountSessionDialog(completedSession());
    await flushAsyncSetup();

    const fieldset = document.querySelector("fieldset");
    expect(fieldset).not.toBeNull();
    expect(fieldset?.className).not.toContain("overflow-auto");

    const scroller = fieldset?.parentElement;
    expect(scroller?.tagName).toBe("DIV");
    expect(scroller?.className).toContain("overflow-auto");
    expect(scroller?.className).toContain("min-h-0");

    const dialogFooter = document.querySelector('[data-slot="dialog-footer"]');
    expect(dialogFooter).not.toBeNull();
    expect(scroller?.contains(dialogFooter)).toBe(false);
  });
});

describe("DataCompareDialog truncation warning", () => {
  it("warns that a table larger than the row budget was only partially compared", async () => {
    const session = completedSession();
    const result = session.batchResults[0]!;
    result.sourceTruncated = true;
    result.sourceRowCount = 4_000_000;
    result.rowBudget = 100_000;

    mountSessionDialog(session);
    await flushAsyncSetup();

    const text = document.body.textContent ?? "";
    expect(text).toContain(i18n.global.t("dataCompare.truncatedTitle"));
    expect(text).toContain(i18n.global.t("dataCompare.truncatedBadge", { budget: 100_000 }));
    expect(text).toContain(i18n.global.t("dataCompare.truncatedTable", { table: "ORDERS", source: 4_000_000, target: 0, budget: 100_000 }));
  });

  it("keeps the warning out of the results when every table fit the budget", async () => {
    mountSessionDialog(completedSession());
    await flushAsyncSetup();

    expect(document.body.textContent ?? "").not.toContain(i18n.global.t("dataCompare.truncatedTitle"));
  });
});

it("bounds the SQL preview while executing the complete plan", async () => {
  const session = completedSession();
  const statements = Array.from({ length: 1000 }, (_, index) => `UPDATE orders SET name = '${"x".repeat(32)}' WHERE id = ${index};`);
  session.syncPlan = { insertCount: 0, updateCount: 1000, deleteCount: 0, statementCount: statements.length, syncStatements: statements, syncSql: statements.join("\n") };
  mountSessionDialog(session);
  await flushAsyncSetup();
  const preview = document.querySelector<HTMLTextAreaElement>("textarea[readonly]")!.value;
  expect(preview.length).toBeLessThan(9000);
  expect(preview).toContain("WHERE id = 999;");
  buttonFor("diff.copySql").click();
  await vi.waitFor(() => expect(mocks.copyToClipboard).toHaveBeenCalledWith(session.syncPlan.syncSql));
  mocks.executeBatch.mockResolvedValue(undefined);
  buttonFor("diff.executeSync").click();
  await vi.waitFor(() => expect(mocks.executeBatch).toHaveBeenCalledTimes(2));
  expect(mocks.executeBatch.mock.calls.flatMap((call) => call[2])).toEqual(statements);
});