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。

9.0 KB
Raw Blame
import { createPinia, setActivePinia } from "pinia";
import { beforeEach, describe, expect, it, vi } from "vitest";
import * as api from "@/lib/backend/api";
import { saveObjectSourceTab } from "@/lib/table/objectSourceTabSave";
import { useConnectionStore } from "@/stores/connectionStore";
import { useProductionSafetyStore } from "@/stores/productionSafetyStore";
import { useQueryStore } from "@/stores/queryStore";
import type { ConnectionConfig } from "@/types/database";
import type { OracleRoutineOperation, OracleRoutineSaveInput } from "@/types/schemaDiff";

vi.mock("@/i18n", () => ({ default: { global: { t: (key: string) => key, locale: { value: "en-US" } } } }));
vi.mock("@/lib/backend/api", () => ({
  buildExecutableObjectSourceStatements: vi.fn(),
  prepareOracleRoutineSave: vi.fn(),
  updateOracleRoutineOperationReferences: vi.fn(async () => {}),
  executeOracleRoutineOperation: vi.fn(),
  observeOracleRoutineOperation: vi.fn(),
  executeQuery: vi.fn(),
  saveOpenTabsState: vi.fn(async () => {}),
}));

function operation(input: OracleRoutineSaveInput): OracleRoutineOperation {
  return {
    operationId: `approval-${input.identity.name}`,
    target: { connectionId: input.connectionId, database: input.database, schema: input.identity.owner, databaseType: "oceanbase-oracle", generation: 0 },
    identity: input.identity,
    lifecycle: "terminal",
    dispatched: true,
    acknowledged: true,
    readback: { identity: input.identity, state: "verified", exists: true, source: input.sql, version: null, definitionMatches: true, compilerMessages: [], issues: [] },
    error: null,
  };
}

function openDraft(name: string, kind: "FUNCTION" | "PACKAGE" | "PACKAGE_BODY" = "FUNCTION") {
  const connection = { id: `source-tab-${name}`, name: "Routine target", db_type: "oceanbase-oracle", is_production: true } as ConnectionConfig;
  useConnectionStore().connections.push(connection);
  const queryStore = useQueryStore();
  const original = kind === "FUNCTION" ? `CREATE OR REPLACE FUNCTION "APP"."${name}" RETURN NUMBER AS BEGIN RETURN 1; END;` : `CREATE OR REPLACE ${kind.replaceAll("_", " ")} "APP"."${name}" AS g NUMBER := 1; END "${name}";`;
  const sql = original.replace("RETURN 1", "RETURN 2").replace(":= 1", ":= 2");
  const id = queryStore.openObjectSourceTab({ connectionId: connection.id, database: "ORCL", schema: "APP", title: name, sql: original, objectSource: { name, schema: "APP", objectType: kind } });
  queryStore.updateSql(id, sql);
  const tab = queryStore.tabs.find((tab) => tab.id === id)!;
  const toast = vi.fn();
  const t = (key: string, values?: Record<string, unknown>) => `${key}${values ? `:${values.message}` : ""}`;
  return { connection, queryStore, tab, sql, original, toast, save: () => saveObjectSourceTab(tab, { connection, queryStore, t, toast }) };
}

beforeEach(() => {
  vi.clearAllMocks();
  vi.stubGlobal("localStorage", { getItem: vi.fn(() => null), setItem: vi.fn(), removeItem: vi.fn() });
  setActivePinia(createPinia());
  vi.mocked(api.buildExecutableObjectSourceStatements).mockImplementation(async ({ source }) => [source]);
  vi.mocked(api.prepareOracleRoutineSave).mockImplementation(async (input) => ({ ...operation(input), lifecycle: "prepared", dispatched: false, acknowledged: false, readback: null }));
  vi.mocked(api.executeOracleRoutineOperation).mockImplementation(async () => operation(vi.mocked(api.prepareOracleRoutineSave).mock.calls.at(-1)![0]));
});

describe("App object source tab Save handler", () => {
  it.each(["PACKAGE", "PACKAGE_BODY"] as const)("prepares %s before confirmation and saves only its approved draft", async (kind) => {
    const draft = openDraft(`Confirmed${kind}`, kind);
    const pending = draft.save();
    const safety = useProductionSafetyStore();
    await vi.waitFor(() => expect(safety.pending).toMatchObject({ sql: draft.sql }));
    expect(api.prepareOracleRoutineSave).toHaveBeenCalledExactlyOnceWith({ connectionId: draft.connection.id, database: "ORCL", identity: { owner: "APP", name: draft.tab.objectSource!.name, kind }, sql: draft.sql });
    expect(api.executeQuery).not.toHaveBeenCalled();
    expect(api.executeOracleRoutineOperation).not.toHaveBeenCalled();
    safety.confirm();
    await expect(pending).resolves.toBe(true);
    expect(api.executeOracleRoutineOperation).toHaveBeenCalledExactlyOnceWith(`approval-Confirmed${kind}`, draft.sql);
    expect(draft.queryStore.isTabDirty(draft.tab)).toBe(false);
  });

  it("waits for real production confirmation, then saves exactly the approved ID and SQL and marks the draft clean", async () => {
    const draft = openDraft("Confirmed");
    const pending = draft.save();
    const safety = useProductionSafetyStore();
    await vi.waitFor(() => expect(safety.pending).toMatchObject({ connectionName: draft.connection.name, database: "ORCL", sql: draft.sql, source: "production.sourceObjectSource" }));
    expect(api.prepareOracleRoutineSave).toHaveBeenCalledExactlyOnceWith({ connectionId: draft.connection.id, database: "ORCL", identity: { owner: "APP", name: "Confirmed", kind: "FUNCTION" }, sql: draft.sql });
    expect(api.executeOracleRoutineOperation).not.toHaveBeenCalled();
    expect(draft.queryStore.isTabDirty(draft.tab)).toBe(true);
    safety.confirm();
    await expect(pending).resolves.toBe(true);
    expect(api.executeOracleRoutineOperation).toHaveBeenCalledExactlyOnceWith("approval-Confirmed", draft.sql);
    expect(api.executeQuery).not.toHaveBeenCalled();
    expect(draft.queryStore.isTabDirty(draft.tab)).toBe(false);
    expect(draft.toast).toHaveBeenCalledWith("objects.sourceSaved", 2000);
  });

  it("cancel preserves the actual dirty tab and dispatches nothing", async () => {
    const draft = openDraft("Canceled");
    const pending = draft.save();
    const safety = useProductionSafetyStore();
    await vi.waitFor(() => expect(safety.pending).toBeDefined());
    expect(api.executeOracleRoutineOperation).not.toHaveBeenCalled();
    safety.cancel();
    await expect(pending).resolves.toBe(false);
    expect(api.executeOracleRoutineOperation).not.toHaveBeenCalled();
    expect(api.executeQuery).not.toHaveBeenCalled();
    expect(draft.tab.sql).toBe(draft.sql);
    expect(draft.tab.originalSql).toBe(draft.original);
    expect(draft.queryStore.isTabDirty(draft.tab)).toBe(true);
    expect(draft.toast).not.toHaveBeenCalled();
  });

  it("a target switch during confirmation prevents dispatch", async () => {
    const draft = openDraft("Retargeted");
    const pending = draft.save();
    const safety = useProductionSafetyStore();
    await vi.waitFor(() => expect(safety.pending).toBeDefined());
    draft.queryStore.updateDatabase(draft.tab.id, "OTHER");
    safety.confirm();
    await expect(pending).resolves.toBe(false);
    expect(api.executeOracleRoutineOperation).not.toHaveBeenCalled();
    expect(draft.queryStore.isTabDirty(draft.tab)).toBe(true);
  });

  it("does not mark a newer draft clean when the approved original finishes", async () => {
    const draft = openDraft("EditedWhileConfirming");
    const pending = draft.save();
    const safety = useProductionSafetyStore();
    await vi.waitFor(() => expect(safety.pending).toBeDefined());
    const newer = draft.sql.replace("RETURN 2", "RETURN 3");
    draft.queryStore.updateSql(draft.tab.id, newer);
    safety.confirm();
    await expect(pending).resolves.toBe(true);
    expect(api.executeOracleRoutineOperation).toHaveBeenCalledExactlyOnceWith("approval-EditedWhileConfirming", draft.sql);
    expect(draft.tab.sql).toBe(newer);
    expect(draft.tab.originalSql).toBe(draft.original);
    expect(draft.queryStore.isTabDirty(draft.tab)).toBe(true);
  });

  it.each(["FUNCTION", "PACKAGE", "PACKAGE_BODY"] as const)("INVALID %s readback retains the actual dirty tab and compiler location", async (kind) => {
    const draft = openDraft(`InvalidReadback${kind}`, kind);
    vi.mocked(api.executeOracleRoutineOperation).mockImplementationOnce(async () => {
      const result = operation(vi.mocked(api.prepareOracleRoutineSave).mock.calls.at(-1)![0]);
      result.readback!.state = "invalid";
      result.readback!.compilerMessages = [{ attribute: "ERROR", line: 3, position: 12, text: "missing identifier" }];
      return result;
    });
    const pending = draft.save();
    const safety = useProductionSafetyStore();
    await vi.waitFor(() => expect(safety.pending).toBeDefined());
    safety.confirm();
    await expect(pending).resolves.toBe(false);
    expect(draft.tab.sql).toBe(draft.sql);
    expect(draft.queryStore.isTabDirty(draft.tab)).toBe(true);
    expect(draft.toast).toHaveBeenCalledWith(expect.stringContaining("ERROR 3:12 missing identifier"), 5000);
    expect(draft.toast).not.toHaveBeenCalledWith("objects.sourceSaved", 2000);
  });

  it("preserves backend object-message errors", async () => {
    const draft = openDraft("BackendMessage");
    vi.mocked(api.buildExecutableObjectSourceStatements).mockRejectedValueOnce({ message: "Source validation failed" });
    await expect(draft.save()).resolves.toBe(false);
    expect(draft.toast).toHaveBeenCalledWith("objects.sourceSaveFailed:Source validation failed", 5000);
    expect(api.executeOracleRoutineOperation).not.toHaveBeenCalled();
  });
});