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。

8.7 KB
Raw Blame
// @vitest-environment happy-dom
import { createApp, defineComponent, h, nextTick, ref, type App } from "vue";
import { createPinia, disposePinia, type Pinia } from "pinia";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { useObjectDependencies } from "@/composables/useObjectDependencies";
import { useConnectionStore } from "@/stores/connectionStore";
import type { ObjectDependencyTarget } from "@/lib/database/objectDependencyDetails";
import type { QueryResult } from "@/types/database";

const backend = vi.hoisted(() => ({ executeQuery: vi.fn(), cancelQuery: vi.fn(async () => true), checkConnectionHealth: vi.fn(async () => undefined) }));
vi.mock("@/lib/backend/api", async (original) => ({ ...(await original<typeof import("@/lib/backend/api")>()), ...backend }));
const mounted: Array<{ app: App; host: HTMLElement; pinia: Pinia }> = [];
const identity: ObjectDependencyTarget = { connectionId: "original", database: "ORCL", schema: "APP", name: "P", objectType: "PROCEDURE" };
const result = (name = "T"): QueryResult => ({
  columns: ["DIRECTION", "OBJECT_OWNER", "OBJECT_NAME", "OBJECT_TYPE", "REFERENCED_OWNER", "REFERENCED_NAME", "REFERENCED_TYPE", "DEPENDENCY_TYPE", "REFERENCED_LINK_NAME"],
  rows: [["DEPENDS_ON", "APP", "P", "PROCEDURE", "OTHER", name, "TABLE", "HARD", null]],
  affected_rows: 0,
  execution_time_ms: 1,
});
function deferred<T>() {
  let resolve!: (value: T) => void;
  const promise = new Promise<T>((done) => {
    resolve = done;
  });
  return { promise, resolve };
}

function mountLoader(enabled = true) {
  const target = ref<ObjectDependencyTarget | undefined>({ ...identity });
  const active = ref(enabled);
  const pinia = createPinia();
  const connections = useConnectionStore(pinia);
  connections.connections = [{ id: "original", name: "original", db_type: "oracle", host: "localhost", port: 1521, username: "test", password: "" }];
  connections.connectedIds.add("original");
  let loader!: ReturnType<typeof useObjectDependencies>;
  const app = createApp(
    defineComponent({
      setup() {
        loader = useObjectDependencies(target, active);
        return () => h("div");
      },
    }),
  );
  app.use(pinia);
  const host = document.createElement("div");
  document.body.append(host);
  app.mount(host);
  mounted.push({ app, host, pinia });
  return { loader, target, active, app, connections };
}
beforeEach(() => {
  vi.clearAllMocks();
  backend.executeQuery.mockReset();
});
afterEach(() => {
  for (const item of mounted.splice(0)) {
    item.app.unmount();
    item.host.remove();
    disposePinia(item.pinia);
  }
});

describe("independent object dependency lifecycle", () => {
  it("does not report a managed execution error as confirmed empty relations", async () => {
    backend.executeQuery.mockResolvedValue({ ...result(), rows: [], execution_error: true });
    const { loader } = mountLoader();
    await vi.waitFor(() => expect(loader.loading.value).toBe(false));
    expect(loader.loaded.value).toBe(false);
    expect(loader.error.value).not.toBe("");
  });

  it("loads lazily without a query session and keeps previous rows on refresh failure", async () => {
    backend.executeQuery.mockResolvedValue(result());
    const { loader, active } = mountLoader(false);
    await nextTick();
    expect(backend.executeQuery).not.toHaveBeenCalled();
    active.value = true;
    await vi.waitFor(() => expect(loader.loaded.value).toBe(true));
    expect(backend.executeQuery.mock.calls[0]).toEqual(["original", "ORCL", expect.stringContaining("ALL_DEPENDENCIES"), "APP", expect.stringContaining("object-dependencies-"), { catalog: undefined }]);
    expect(loader.rows.value[0]?.name).toBe("T");
    backend.executeQuery.mockRejectedValueOnce(new Error("permission denied"));
    await loader.refresh();
    expect(loader.error.value).toBe("permission denied");
    expect(loader.rows.value[0]?.name).toBe("T");
    expect(loader.loaded.value).toBe(true);
    backend.executeQuery.mockResolvedValueOnce({ ...result(), rows: [], truncated: true });
    await loader.refresh();
    expect(loader.error.value).toBe("");
    expect(loader.rows.value).toEqual([]);
    expect(loader.truncated.value).toBe(true);
  });

  it("keeps an initial rejection distinct from a confirmed empty retry", async () => {
    backend.executeQuery.mockRejectedValueOnce(new Error("permission denied")).mockResolvedValueOnce({ ...result(), rows: [] });
    const { loader } = mountLoader();
    await vi.waitFor(() => expect(loader.error.value).toBe("permission denied"));
    expect(loader.loaded.value).toBe(false);
    await loader.refresh();
    expect(loader.error.value).toBe("");
    expect(loader.loaded.value).toBe(true);
    expect(loader.rows.value).toEqual([]);
    expect(loader.truncated.value).toBe(false);
  });

  it("does not dispatch after a hidden connection wait completes and can reopen", async () => {
    const pending = deferred<void>();
    const { loader, active, connections } = mountLoader(false);
    vi.spyOn(connections, "ensureConnected").mockReturnValueOnce(pending.promise);
    backend.executeQuery.mockResolvedValue(result("REOPENED"));
    active.value = true;
    await vi.waitFor(() => expect(connections.ensureConnected).toHaveBeenCalledTimes(1));
    active.value = false;
    await nextTick();
    pending.resolve();
    await nextTick();
    expect(backend.executeQuery).not.toHaveBeenCalled();
    expect(loader.loaded.value).toBe(false);
    active.value = true;
    await vi.waitFor(() => expect(loader.rows.value[0]?.name).toBe("REOPENED"));
  });

  it("rejects stale refresh responses and cancels only its own execution id", async () => {
    const first = deferred<QueryResult>(),
      second = deferred<QueryResult>();
    backend.executeQuery.mockReturnValueOnce(first.promise).mockReturnValueOnce(second.promise);
    const { loader } = mountLoader();
    await vi.waitFor(() => expect(backend.executeQuery).toHaveBeenCalledTimes(1));
    const refresh = loader.refresh();
    await vi.waitFor(() => expect(backend.executeQuery).toHaveBeenCalledTimes(2));
    expect(backend.cancelQuery).toHaveBeenCalledWith(backend.executeQuery.mock.calls[0]![4]);
    second.resolve(result("CURRENT"));
    await refresh;
    first.resolve(result("OLD"));
    await nextTick();
    expect(loader.rows.value[0]?.name).toBe("CURRENT");
  });

  it("distinguishes A→B→A generations even when the final identity is equal", async () => {
    const a = deferred<QueryResult>(),
      b = deferred<QueryResult>(),
      a2 = deferred<QueryResult>();
    backend.executeQuery.mockReturnValueOnce(a.promise).mockReturnValueOnce(b.promise).mockReturnValueOnce(a2.promise);
    const { target, loader } = mountLoader();
    await vi.waitFor(() => expect(backend.executeQuery).toHaveBeenCalledTimes(1));
    target.value = { ...identity, name: "B", schema: "OTHER" };
    await vi.waitFor(() => expect(backend.executeQuery).toHaveBeenCalledTimes(2));
    target.value = { ...identity };
    await vi.waitFor(() => expect(backend.executeQuery).toHaveBeenCalledTimes(3));
    a2.resolve(result("CURRENT"));
    await vi.waitFor(() => expect(loader.loaded.value).toBe(true));
    a.resolve(result("OLD_A"));
    b.resolve(result("OLD_B"));
    await nextTick();
    expect(loader.rows.value[0]?.name).toBe("CURRENT");
  });

  it("invalidates close and context changes; a late response cannot refill closed content", async () => {
    const pending = deferred<QueryResult>();
    backend.executeQuery.mockReturnValue(pending.promise);
    const { target, loader } = mountLoader();
    await vi.waitFor(() => expect(backend.executeQuery).toHaveBeenCalledTimes(1));
    target.value = undefined;
    pending.resolve(result());
    await nextTick();
    expect(loader.rows.value).toEqual([]);
    expect(loader.loaded.value).toBe(false);
    expect(loader.loading.value).toBe(false);
    expect(backend.cancelQuery).toHaveBeenCalledTimes(1);
  });

  it("cancels a hidden pending query and reloads on return without accepting the old result", async () => {
    const first = deferred<QueryResult>(),
      second = deferred<QueryResult>();
    backend.executeQuery.mockReturnValueOnce(first.promise).mockReturnValueOnce(second.promise);
    const { loader, active } = mountLoader();
    await vi.waitFor(() => expect(backend.executeQuery).toHaveBeenCalledTimes(1));
    active.value = false;
    await nextTick();
    expect(backend.cancelQuery).toHaveBeenCalledWith(backend.executeQuery.mock.calls[0]![4]);
    expect(loader.loading.value).toBe(false);
    active.value = true;
    await vi.waitFor(() => expect(backend.executeQuery).toHaveBeenCalledTimes(2));
    first.resolve(result("HIDDEN"));
    await nextTick();
    expect(loader.rows.value).toEqual([]);
    second.resolve(result("CURRENT"));
    await vi.waitFor(() => expect(loader.rows.value[0]?.name).toBe("CURRENT"));
  });
});