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。

28.4 KB
Raw Blame
// @vitest-environment happy-dom
import { createApp, h, nextTick, ref, watch, type App } from "vue";
import { createPinia, getActivePinia, setActivePinia } from "pinia";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import i18n from "@/i18n";
import type { ConnectionConfig, ObjectSource, TreeNode, TriggerInfo } from "@/types/database";
import type { ContextMenuItem } from "@/components/ui/CustomContextMenu.vue";
import { useConnectionStore } from "@/stores/connectionStore";
import { useSettingsStore } from "@/stores/settingsStore";
import { useQueryStore } from "@/stores/queryStore";
import { useSqlExecutionDangerStore } from "@/stores/sqlExecutionDangerStore";
import { useProductionSafetyStore } from "@/stores/productionSafetyStore";
import type { SidebarDangerDialogRequest } from "@/lib/sidebar/sidebarDangerDialog";
import { compileErrorMessage, showCompileErrorDialog, showBatchDropConfirm } from "../sidebarTreeDialogState";
import SidebarTreeRuntimeHost from "../SidebarTreeRuntimeHost.vue";
import SidebarTreeItemDialogs from "../SidebarTreeItemDialogs.vue";
import { sidebarTreeContextKey } from "@/lib/sidebar/sidebarTreeContext";
import { useSidebarRemoteSearch } from "@/composables/useSidebarRemoteSearch";
import { useToast } from "@/composables/useToast";

const rpc = vi.hoisted(() => ({
  getObjectSource: vi.fn(),
  executeQuery: vi.fn(),
  listTriggers: vi.fn(),
  buildDropObjectSql: vi.fn(),
  checkConnectionHealth: vi.fn(async () => undefined),
  listPlugins: vi.fn(async () => []),
  listInstalledAgents: vi.fn(async () => []),
  loadSchemaCache: vi.fn(async () => null),
  saveSchemaCache: vi.fn(async () => undefined),
  saveOpenTabsState: vi.fn(async () => undefined),
  deleteSchemaCachePrefix: vi.fn(async () => undefined),
}));
vi.mock("@/lib/backend/api", async (original) => ({ ...(await original<typeof import("@/lib/backend/api")>()), ...rpc }));
const owner = " Trigger.Owner ",
  parent = " Parent.Owner ";
const names = [' Tr"igger ', "SecondTrigger"];
const quote = (value: string) => `"${value.replaceAll('"', '""')}"`;
const configs = { id: "native-trigger-menu", name: "Test", db_type: "oceanbase-oracle", database: "service", username: "Execution.Owner" } as ConnectionConfig;
const cleanup: (() => void)[] = [];
let enabled = false,
  invalid = false,
  denyGlobal = false;
let gone = new Set<string>();
let objectIds = new Map<string, string>();
let parentId = "parent-id";
let ddl: string[];
let request: SidebarDangerDialogRequest | undefined;
function trigger(name: string): TriggerInfo {
  return {
    name,
    timing: "INSTEAD OF",
    event: "UPDATE",
    enabled,
    valid: !invalid,
    oracle_metadata: {
      contractVersion: 1,
      identityMode: "exact",
      engine: configs.db_type === "dameng" ? "dm" : "oceanbase-oracle",
      engineVersion: configs.db_type === "dameng" ? "8.1.3" : "4.2.5.7_107",
      owner,
      name,
      objectId: objectIds.get(name) ?? `900719925474099${names.indexOf(name) + 3}`,
      scope: "VIEW",
      parent: { owner: parent, name: "V", objectType: "VIEW" },
      definition: { origin: "catalog-body", format: "body", complete: false },
      errors: invalid ? [{ sequence: 1, line: 2, position: 3, text: "Missing procedure" }] : [],
      reads: { identity: { state: "available" }, scope: { state: "available" }, parent: { state: "available" }, enabled: { state: "available" }, validity: { state: "available" }, definition: { state: "denied" }, errors: { state: "available" } },
    },
  };
}
beforeEach(() => {
  vi.clearAllMocks();
  useToast().message.value = "";
  configs.db_type = "oceanbase-oracle";
  configs.is_production = false;
  localStorage.clear();
  rpc.deleteSchemaCachePrefix.mockResolvedValue(undefined);
  enabled = false;
  invalid = false;
  denyGlobal = false;
  gone = new Set();
  objectIds = new Map();
  parentId = "parent-id";
  ddl = [];
  request = undefined;
  setActivePinia(createPinia());
  showCompileErrorDialog.value = false;
  showBatchDropConfirm.value = false;
  rpc.getObjectSource.mockImplementation(async (_id, _db, _owner, name) => {
    const info = trigger(name);
    if (gone.has(name)) {
      info.oracle_metadata!.objectId = null;
      info.oracle_metadata!.reads.identity = { state: "empty" };
    }
    return { name, schema: owner, object_type: "TRIGGER", source: gone.has(name) ? "" : "BEGIN NULL; END;", editable: false, trigger: info } as ObjectSource;
  });
  rpc.listTriggers.mockImplementation(async () => names.filter((name) => !gone.has(name)).map(trigger));
  rpc.buildDropObjectSql.mockImplementation(async (input) => `DROP TRIGGER ${quote(input.schema)}.${quote(input.name)};`);
  rpc.executeQuery.mockImplementation(async (_id, _db, sql) => {
    if (sql.startsWith("SELECT USER")) return { columns: ["SESSION_USER"], rows: [["Execution.Owner"]] };
    if (sql.includes("DBA_OBJECTS")) {
      if (denyGlobal) throw new Error("global dictionary denied");
      return { columns: ["OWNER", "OBJECT_NAME"], rows: [] };
    }
    if (sql.startsWith("SELECT")) return { columns: ["OWNER", "OBJECT_NAME", "OBJECT_TYPE", "OBJECT_ID"], rows: [[parent, "V", "VIEW", parentId]] };
    ddl.push(sql);
    if (sql.startsWith("DROP")) gone.add(names.find((name) => sql.includes(quote(name)))!);
    if (sql.endsWith(" ENABLE;")) enabled = true;
    return { columns: [], rows: [], affected_rows: 0 };
  });
});
afterEach(() => {
  for (const fn of cleanup.splice(0)) fn();
  useSqlExecutionDangerStore().cancelAll();
  useProductionSafetyStore().cancel();
  vi.restoreAllMocks();
  document.body.innerHTML = "";
});
async function mount(count = 1, searchProjection = false) {
  const store = useConnectionStore();
  store.connections = [configs];
  store.connectedIds.add(configs.id);
  const group: TreeNode = { id: "trigger-parent-group", label: "Triggers", type: "group-triggers", connectionId: configs.id, database: "service", schema: parent, tableName: "V", isExpanded: true };
  const nodes: TreeNode[] = names.slice(0, count).map((name) => ({ id: `trigger-node:${name}`, label: `${name} (display only)`, objectName: name, type: "trigger", connectionId: configs.id, database: "service", schema: owner, tableName: "V", meta: trigger(name) }));
  group.children = nodes;
  store.treeNodes = searchProjection ? [] : [group];
  const visibleNodes = ref(searchProjection ? [] : nodes);
  let removeSearchNode = (_node: TreeNode) => {};
  store.selectedTreeNodeId = nodes[0].id;
  store.selectedTreeNodeIds = nodes.map((node) => node.id);
  const component = ref<InstanceType<typeof SidebarTreeRuntimeHost> | null>(null);
  const dialogController = ref<Record<string, any>>();
  const openSource = vi.fn();
  const host = document.createElement("div");
  document.body.append(host);
  const app: App = createApp({
    setup() {
      if (searchProjection) {
        const query = ref("");
        const remote = useSidebarRemoteSearch({
          query,
          enabled: ref(true),
          context: [() => store.sidebarObjectSearchRevision],
          load: async () => [{ parentNodeId: group.id, nodeType: group.type, connectionId: configs.id, database: "service", schema: parent, children: nodes.filter((node) => !gone.has(node.objectName!)) }],
          onError: (error) => {
            throw error;
          },
        });
        watch(
          remote.results,
          (results) => {
            visibleNodes.value = results.flatMap((result) => result.children);
          },
          { flush: "sync" },
        );
        removeSearchNode = remote.removeVerifiedTriggerNode;
        query.value = "trigger";
      }
      return () =>
        h("div", [
          h(SidebarTreeRuntimeHost, {
            ref: component,
            node: group,
            depth: 0,
            onOpenObjectSource: openSource,
            onOpenDangerDialog: (next) => {
              request = next;
            },
            onOpenDialogController: (next) => {
              dialogController.value = next;
            },
          }),
          dialogController.value ? h(SidebarTreeItemDialogs, { controller: dialogController.value }) : null,
        ]);
    },
  });
  app.use(getActivePinia()!);
  app.use(i18n);
  if (searchProjection) app.provide(sidebarTreeContextKey, { getVisibleNodes: () => visibleNodes.value, getVisibleNodeIndex: (id) => visibleNodes.value.findIndex((node) => node.id === id), isSearchProjectionActive: () => true, removeVerifiedTriggerNode: (node) => removeSearchNode(node) });
  app.mount(host);
  let mounted = true;
  const unmount = () => {
    if (!mounted) return;
    mounted = false;
    app.unmount();
    host.remove();
  };
  cleanup.push(unmount);
  await nextTick();
  if (searchProjection) await vi.waitFor(() => expect(visibleNodes.value).toHaveLength(count));
  const buildMenu = (node: TreeNode) => (component.value as unknown as { buildContextMenu(node: TreeNode): ContextMenuItem[] }).buildContextMenu(node);
  return { store, nodes, group, visibleNodes, openSource, buildMenu, unmount, menu: buildMenu(nodes[0]) };
}
const flatten = (items: ContextMenuItem[]): ContextMenuItem[] => items.flatMap((item) => [item, ...flatten(item.children ?? [])]);

describe("exact trigger actions through the actual tree menu", () => {
  it.each(["contextMenu.enableTrigger", "processList.oracleInvalidObjects.compile", "delete"])("executes %s for an exact search-only result", async (label) => {
    const { menu, store, visibleNodes } = await mount(1, true);
    const pending = flatten(menu).find((item) => (label === "delete" ? item.variant === "destructive" : item.label === i18n.global.t(label)))!.action!();
    const danger = useSqlExecutionDangerStore();
    await vi.waitFor(() => expect(danger.pending).toBeDefined());
    danger.confirm();
    await pending;
    await vi.waitFor(() => expect(ddl).toHaveLength(1));
    expect(store.treeNodes).toEqual([]);
    expect(ddl).toHaveLength(1);
    expect(ddl[0]).toContain(quote(names[0]));
    if (label === "delete") await vi.waitFor(() => expect(visibleNodes.value).toEqual([]));
    if (label !== "contextMenu.enableTrigger") {
      const feedbackKey = label === "delete" ? "contextMenu.dropTableChildObjectSuccess" : "contextMenu.compileObjectSuccess";
      expect(i18n.global.te(feedbackKey)).toBe(true);
      await vi.waitFor(() => expect(useToast().message.value).toBe(i18n.global.t(feedbackKey, { name: names[0] })));
    }
  });

  it("deletes a search-only trigger batch through the original guarded sequence", async () => {
    const { menu, visibleNodes } = await mount(2, true);
    flatten(menu).find((item) => item.variant === "destructive")!.action!();
    await vi.waitFor(() => expect(request && !request.confirmDisabled).toBe(true));
    await request!.confirm();
    expect(ddl).toEqual(names.map((name) => `DROP TRIGGER ${quote(owner)}.${quote(name)};`));
    await vi.waitFor(() => expect(visibleNodes.value).toEqual([]));
  });

  it("retains a search-only result when deletion cannot be authoritatively verified", async () => {
    denyGlobal = true;
    const { menu, visibleNodes } = await mount(1, true);
    flatten(menu).find((item) => item.variant === "destructive")!.action!();
    const danger = useSqlExecutionDangerStore();
    await vi.waitFor(() => expect(danger.pending).toBeDefined());
    danger.confirm();
    await vi.waitFor(() => expect(showCompileErrorDialog.value).toBe(true));
    expect(visibleNodes.value).toHaveLength(1);
    expect(ddl).toEqual([`DROP TRIGGER ${quote(owner)}.${quote(names[0])};`]);
  });

  it("cancels an unissued search-only action when its projection disappears", async () => {
    const { menu, visibleNodes } = await mount(1, true);
    const pending = flatten(menu).find((item) => item.label === i18n.global.t("contextMenu.enableTrigger"))!.action!();
    const danger = useSqlExecutionDangerStore();
    await vi.waitFor(() => expect(danger.pending).toBeDefined());
    visibleNodes.value = [];
    danger.confirm();
    await pending;
    expect(ddl).toEqual([]);
  });

  it("does not dispatch a search-only deletion batch after the projection disappears", async () => {
    const { menu, visibleNodes } = await mount(2, true);
    flatten(menu).find((item) => item.variant === "destructive")!.action!();
    await vi.waitFor(() => expect(request && !request.confirmDisabled).toBe(true));
    visibleNodes.value = [];
    await request!.confirm();
    expect(ddl).toEqual([]);
  });

  it.each(["unmount", "selection"])("cancels the unissued batch production confirmation on %s", async (change) => {
    configs.is_production = true;
    const { menu, store, group, unmount } = await mount(2);
    flatten(menu).find((item) => item.variant === "destructive")!.action!();
    await vi.waitFor(() => expect(request && !request.confirmDisabled).toBe(true));
    const pending = request!.confirm();
    const production = useProductionSafetyStore();
    await vi.waitFor(() => expect(production.pending).toBeDefined());
    if (change === "unmount") unmount();
    else {
      store.selectedTreeNodeId = group.id;
      store.selectedTreeNodeIds = [group.id];
    }
    await vi.waitFor(() => expect(production.pending).toBeUndefined());
    await pending;
    expect(ddl).toEqual([]);
    expect(showCompileErrorDialog.value).toBe(false);
  });

  it("finishes the dispatched deletion on its fixed target but stops remaining batch objects after a UI selection change", async () => {
    const { menu, store, nodes, group } = await mount(2);
    const [first, second] = nodes;
    const execute = rpc.executeQuery.getMockImplementation()!;
    let finish!: () => void;
    rpc.executeQuery.mockImplementation(async (...args) => {
      const result = await execute(...args);
      if (args[2].startsWith("DROP") && ddl.length === 1)
        await new Promise<void>((resolve) => {
          finish = resolve;
        });
      return result;
    });
    flatten(menu).find((item) => item.variant === "destructive")!.action!();
    await vi.waitFor(() => expect(request && !request.confirmDisabled).toBe(true));
    const pending = request!.confirm();
    await vi.waitFor(() => expect(finish).toBeDefined());
    store.selectedTreeNodeId = group.id;
    store.selectedTreeNodeIds = [group.id];
    finish();
    await pending;
    expect(ddl).toEqual([`DROP TRIGGER ${quote(owner)}.${quote(names[0])};`]);
    expect(store.treeNodes[0].children?.some((node) => node.id === first.id)).toBe(false);
    expect(store.treeNodes[0].children?.some((node) => node.id === second.id)).toBe(true);
    expect(compileErrorMessage.value).toContain(i18n.global.t("oceanbasePrimaryKey.notExecuted"));
    expect(compileErrorMessage.value).not.toContain(i18n.global.t("oceanbasePrimaryKey.unknown"));
  });

  it("reviews a trigger deletion batch once in the production guard, with both confirmed SQL statements", async () => {
    configs.is_production = true;
    const { menu } = await mount(2);
    flatten(menu).find((item) => item.variant === "destructive")!.action!();
    await vi.waitFor(() => expect(request && !request.confirmDisabled).toBe(true));
    const production = useProductionSafetyStore();
    let settled = false;
    const pending = Promise.resolve(request!.confirm()).finally(() => {
      settled = true;
    });
    const reviews: string[] = [];
    for (let index = 0; index < 3 && !settled; index++) {
      await vi.waitFor(() => expect(settled || !!production.pending).toBe(true));
      if (production.pending) {
        reviews.push(production.pending.sql);
        production.confirm();
      }
    }
    await pending;
    expect(reviews).toHaveLength(1);
    expect(reviews[0]).toContain(quote(names[0]));
    expect(reviews[0]).toContain(quote(names[1]));
    expect(ddl).toHaveLength(2);
  });

  it("keeps batch unknown nodes and pins, then removes only the read-only verified deletion without replay", async () => {
    denyGlobal = true;
    const { menu, store, nodes } = await mount(2);
    const [first, second] = nodes;
    nodes.forEach((node) => store.toggleTreeNodePin(node));
    flatten(menu).find((item) => item.variant === "destructive")!.action!();
    await vi.waitFor(() => expect(request && !request.confirmDisabled).toBe(true));
    await request!.confirm();
    expect(ddl).toEqual([`DROP TRIGGER ${quote(owner)}.${quote(names[0])};`]);
    expect(store.isTreeNodePinned(first)).toBe(true);
    expect(store.isTreeNodePinned(second)).toBe(true);
    await nextTick();
    const verify = () => [...document.querySelectorAll<HTMLButtonElement>("button")].find((button) => button.textContent?.trim() === i18n.global.t("oracleTrigger.verifyReadOnly"));
    expect(verify()).toBeDefined();
    denyGlobal = false;
    verify()!.click();
    await vi.waitFor(() =>
      expect(
        store.treeNodes[0].children?.some((node) => node.id === first.id),
        compileErrorMessage.value,
      ).toBe(false),
    );
    expect(store.treeNodes[0].children?.some((node) => node.id === second.id)).toBe(true);
    expect(store.isTreeNodePinned(first)).toBe(false);
    expect(store.isTreeNodePinned(second)).toBe(true);
    await request!.confirm();
    expect(ddl).toHaveLength(1);
  });

  it("keeps a recreated row and its pin when the original batch deletion was verified before cache cleanup", async () => {
    const { menu, store, nodes } = await mount(2);
    const first = nodes[0];
    store.toggleTreeNodePin(first);
    let replaced = false;
    rpc.deleteSchemaCachePrefix.mockImplementation(async () => {
      if (!replaced && ddl.length) {
        replaced = true;
        gone.delete(names[0]);
        objectIds.set(names[0], "recreated-after-verify");
        const live = store.treeNodes[0].children!.find((node) => node.id === first.id)!;
        const meta = JSON.parse(JSON.stringify(live.meta)) as TriggerInfo;
        meta.oracle_metadata!.objectId = "recreated-after-verify";
        live.meta = meta;
      }
    });
    flatten(menu).find((item) => item.variant === "destructive")!.action!();
    await vi.waitFor(() => expect(request && !request.confirmDisabled).toBe(true));
    await request!.confirm();
    const live = store.treeNodes[0].children!.find((node) => node.id === first.id);
    expect((live?.meta as TriggerInfo | undefined)?.oracle_metadata?.objectId).toBe("recreated-after-verify");
    expect(store.isTreeNodePinned(first)).toBe(true);
    expect(ddl).toHaveLength(1);
  });

  it.each(["dialog", "query-tab"] as const)("opens DM8 trigger dependencies in the existing %s container without a general query or DDL", async (mode) => {
    configs.db_type = "dameng";
    useSettingsStore().editorSettings.routineSourceOpenMode = mode;
    const { menu, openSource } = await mount();
    const dependencies = flatten(menu).find((item) => item.label === i18n.global.t("contextMenu.viewDependencies"));
    expect(dependencies).toBeDefined();
    await dependencies!.action!();
    if (mode === "dialog") expect(openSource).toHaveBeenCalledWith(expect.objectContaining({ type: "trigger", schema: owner, objectName: names[0], meta: expect.objectContaining({ oracle_metadata: expect.objectContaining({ engine: "dm" }) }) }), false, "dependencies");
    else {
      const store = useQueryStore();
      await vi.waitFor(() => expect(store.tabs.some((tab) => tab.objectSource?.name === names[0])).toBe(true), { timeout: 30_000 });
      const tab = store.tabs.find((item) => item.objectSource?.name === names[0])!;
      expect(tab.objectDetails).toMatchObject({ schema: owner, name: names[0], objectType: "TRIGGER", section: "dependencies" });
      expect(store.oracleTriggerSourceState(tab.id)?.baseline?.metadata.engine).toBe("dm");
    }
    expect(ddl).toEqual([]);
    expect(rpc.executeQuery).not.toHaveBeenCalled();
  });

  it("does not replace the displayed physical identity from a mismatched post-compile snapshot", async () => {
    const { menu, store, nodes } = await mount();
    const source = rpc.getObjectSource.getMockImplementation()!;
    rpc.getObjectSource.mockImplementation(async (...args) => {
      const result = await source(...args);
      if (ddl.length) result.trigger!.oracle_metadata!.objectId = "replacement-id";
      return result;
    });
    const pending = flatten(menu).find((item) => item.label === i18n.global.t("processList.oracleInvalidObjects.compile"))!.action!();
    const danger = useSqlExecutionDangerStore();
    await vi.waitFor(() => expect(danger.pending).toBeDefined());
    danger.confirm();
    await pending;
    expect(showCompileErrorDialog.value).toBe(true);
    expect(compileErrorMessage.value).toContain("mismatch");
    const live = store.treeNodes[0].children!.find((node) => node.id === nodes[0].id)!;
    expect((live.meta as TriggerInfo).oracle_metadata?.objectId).toBe("9007199254740993");
    expect(ddl).toHaveLength(1);
    expect(rpc.listTriggers).not.toHaveBeenCalled();
  });

  it.each(["contextMenu.enableTrigger", "processList.oracleInvalidObjects.compile"])("rejects a same-name replacement before confirming %s", async (label) => {
    const { menu } = await mount();
    const source = rpc.getObjectSource.getMockImplementation()!;
    rpc.getObjectSource.mockImplementation(async (...args) => {
      const result = await source(...args);
      result.trigger.oracle_metadata.objectId = "replacement-id";
      return result;
    });
    let settled = false;
    const pending = Promise.resolve(flatten(menu).find((item) => item.label === i18n.global.t(label))!.action!()).finally(() => {
      settled = true;
    });
    const danger = useSqlExecutionDangerStore();
    await vi.waitFor(() => expect(settled || !!danger.pending).toBe(true));
    expect(danger.pending).toBeUndefined();
    await pending;
    expect(ddl).toEqual([]);
  });

  it("cancels a pending trigger confirmation when the tree host unmounts", async () => {
    const { menu, unmount } = await mount();
    const pending = flatten(menu).find((item) => item.label === i18n.global.t("contextMenu.enableTrigger"))!.action!();
    const danger = useSqlExecutionDangerStore();
    await vi.waitFor(() => expect(danger.pending).toBeDefined());
    unmount();
    await nextTick();
    expect(danger.pending).toBeUndefined();
    await pending;
    expect(ddl).toEqual([]);
  });

  it.each(["deleted", "parent-replaced", "trigger-replaced"])("retains an unverified deletion and reconciles it without replay (%s)", async (after) => {
    denyGlobal = true;
    const { menu, store, nodes } = await mount();
    flatten(menu).find((item) => item.variant === "destructive")!.action!();
    const danger = useSqlExecutionDangerStore();
    await vi.waitFor(() => expect(danger.pending).toBeDefined());
    danger.confirm();
    await vi.waitFor(() => expect(showCompileErrorDialog.value).toBe(true));
    expect(store.treeNodes[0].children?.some((node) => node.id === nodes[0].id)).toBe(true);
    await nextTick();
    const verify = [...document.querySelectorAll("button")].find((button) => button.textContent?.trim() === i18n.global.t("oracleTrigger.verifyReadOnly"));
    expect(verify).toBeDefined();
    denyGlobal = false;
    if (after === "parent-replaced") parentId = "new-parent-id";
    if (after === "trigger-replaced") gone.delete(names[0]);
    verify!.click();
    await vi.waitFor(() => expect(verify!.getAttribute("aria-busy")).not.toBe("true"));
    await vi.waitFor(() => expect(compileErrorMessage.value).toContain(after === "deleted" ? i18n.global.t("processList.oracleInvalidObjects.batchStatus.deleted") : after === "parent-replaced" ? "owning object changed" : "trigger still exists"));
    expect(store.treeNodes[0].children?.some((node) => node.id === nodes[0].id)).toBe(after !== "deleted");
    expect(ddl).toEqual([`DROP TRIGGER ${quote(owner)}.${quote(names[0])};`]);
  });

  it("finishes the original readback without reopening a dialog after an in-flight compile unmounts", async () => {
    invalid = true;
    const { menu, unmount } = await mount();
    const execute = rpc.executeQuery.getMockImplementation()!;
    let release!: () => void;
    const gate = new Promise<void>((resolve) => {
      release = resolve;
    });
    let dispatched = false;
    rpc.executeQuery.mockImplementation(async (...args) => {
      if (!args[2].startsWith("SELECT")) {
        dispatched = true;
        await gate;
      }
      return execute(...args);
    });
    const pending = flatten(menu).find((item) => item.label === i18n.global.t("processList.oracleInvalidObjects.compile"))!.action!();
    const danger = useSqlExecutionDangerStore();
    await vi.waitFor(() => expect(danger.pending).toBeDefined());
    danger.confirm();
    await vi.waitFor(() => expect(dispatched).toBe(true));
    unmount();
    release();
    await pending;
    expect(ddl).toEqual([`ALTER TRIGGER ${quote(owner)}.${quote(names[0])} COMPILE`]);
    expect(rpc.getObjectSource.mock.calls.at(-1)?.slice(0, 5)).toEqual([configs.id, "service", owner, names[0], "TRIGGER"]);
    expect(rpc.listTriggers).not.toHaveBeenCalled();
    expect(showCompileErrorDialog.value).toBe(false);
  });

  it("opens creation from an empty Schema trigger group without requiring an existing trigger", async () => {
    const { store, group, buildMenu, openSource } = await mount();
    group.children = [];
    group.tableName = undefined;
    group.schema = owner;
    store.selectedTreeNodeId = group.id;
    store.selectedTreeNodeIds = [group.id];
    const create = flatten(buildMenu(group)).find((item) => item.label === i18n.global.t("contextMenu.createTrigger"));
    expect(create).toBeDefined();
    await create!.action!();
    expect(openSource).toHaveBeenCalledWith(expect.objectContaining({ type: "trigger", schema: owner, objectName: "TRG_NEW" }), true, undefined, expect.objectContaining({ target: expect.objectContaining({ id: group.id, type: "group-triggers" }), payload: { scope: "TABLE" } }));
    expect(ddl).toEqual([]);
    expect(rpc.getObjectSource).not.toHaveBeenCalled();
  });

  it("uses the raw trigger owner and refreshes its independent parent after native enable", async () => {
    const { menu } = await mount();
    const pending = flatten(menu).find((item) => item.label === i18n.global.t("contextMenu.enableTrigger"))!.action!();
    const danger = useSqlExecutionDangerStore();
    await vi.waitFor(() => expect(danger.pending).toBeDefined());
    expect(danger.pending?.sql).toBe(`ALTER TRIGGER ${quote(owner)}.${quote(names[0])} ENABLE;`);
    danger.confirm();
    await pending;
    expect(ddl).toEqual([`ALTER TRIGGER ${quote(owner)}.${quote(names[0])} ENABLE;`]);
    expect(rpc.listTriggers).toHaveBeenCalledWith(configs.id, "service", parent, "V", undefined, { identityMode: "exact" });
  });

  it.each(["dialog", "query-tab"] as const)("shows real INVALID diagnostics and opens the fixed source target in %s mode", async (mode) => {
    invalid = true;
    useSettingsStore().editorSettings.routineSourceOpenMode = mode;
    const { menu, store, group, openSource } = await mount();
    const pending = flatten(menu).find((item) => item.label === i18n.global.t("processList.oracleInvalidObjects.compile"))!.action!();
    const danger = useSqlExecutionDangerStore();
    await vi.waitFor(() => expect(danger.pending).toBeDefined());
    danger.confirm();
    await pending;
    expect(ddl).toEqual([`ALTER TRIGGER ${quote(owner)}.${quote(names[0])} COMPILE`]);
    expect(showCompileErrorDialog.value).toBe(true);
    expect(compileErrorMessage.value).toContain("Missing procedure");
    expect(enabled).toBe(false);
    store.selectedTreeNodeId = group.id;
    store.selectedTreeNodeIds = [group.id];
    await nextTick();
    const source = [...document.querySelectorAll("button")].find((button) => button.textContent?.trim() === i18n.global.t("contextMenu.viewSource"));
    expect(source).toBeDefined();
    source!.click();
    await nextTick();
    if (mode === "dialog") expect(openSource).toHaveBeenCalledWith(expect.objectContaining({ type: "trigger", schema: owner, objectName: names[0] }), false, undefined);
    else await vi.waitFor(() => expect(useQueryStore().tabs.some((tab) => tab.objectSource?.schema === owner && tab.objectSource.name === names[0])).toBe(true));
    expect(showCompileErrorDialog.value).toBe(false);
    expect(ddl).toHaveLength(1);
  });

  it.each([true, false])("stops remaining confirmed batch targets only when deletion is unverified (global denied=%s)", async (denied) => {
    denyGlobal = denied;
    const { menu } = await mount(2);
    flatten(menu).find((item) => item.variant === "destructive")!.action!();
    await vi.waitFor(() => expect(request && !request.confirmDisabled && request.sql?.includes(quote(names[1]))).toBe(true));
    await request!.confirm();
    expect(ddl).toEqual((denied ? names.slice(0, 1) : names).map((name) => `DROP TRIGGER ${quote(owner)}.${quote(name)};`));
    if (denied) {
      expect(compileErrorMessage.value).toContain("global dictionary denied");
      expect(compileErrorMessage.value).toContain(i18n.global.t("oceanbasePrimaryKey.notExecuted"));
    }
  });
});