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.7 KB
Raw Blame
// @vitest-environment happy-dom

import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { createApp, defineComponent, h, nextTick, type App } from "vue";

const backend = vi.hoisted(() => ({
  etcdSupportsTtl: vi.fn(),
  etcdListPrefix: vi.fn(),
  etcdGet: vi.fn(),
  etcdPut: vi.fn(),
  etcdDelete: vi.fn(),
  etcdRename: vi.fn(),
  etcdHistory: vi.fn(),
  etcdStatus: vi.fn(),
  etcdGetCalls: [] as unknown[][],
  capturedKvBrowserApi: null as any,
  capturedCanWriteKey: null as any,
  canWriteEtcdKey: vi.fn(),
  ensureEtcdAccessCapabilities: vi.fn(),
  selectKeyCalls: [] as unknown[],
  access: { admin: true, writable: true },
}));

vi.mock("vue-i18n", () => ({
  useI18n: () => ({ t: (key: string) => key }),
}));

vi.mock("@/lib/backend/api", () => ({
  etcdListPrefix: backend.etcdListPrefix,
  etcdGet: backend.etcdGet,
  etcdPut: backend.etcdPut,
  etcdDelete: backend.etcdDelete,
  etcdRename: backend.etcdRename,
  etcdHistory: backend.etcdHistory,
  etcdStatus: backend.etcdStatus,
  etcdSupportsTtl: backend.etcdSupportsTtl,
}));

vi.mock("@/stores/connectionStore", () => ({
  useConnectionStore: () => ({
    connections: [],
    getConfig: () => ({ id: "etcd-1", db_type: "etcd" }),
    getEtcdAccessCapabilities: () => backend.access,
    ensureEtcdAccessCapabilities: backend.ensureEtcdAccessCapabilities,
    canWriteEtcdKey: backend.canWriteEtcdKey,
  }),
}));

vi.mock("@/components/kv/KvKeyBrowser.vue", () => ({
  default: defineComponent({
    name: "KvKeyBrowserStub",
    inheritAttrs: false,
    props: {
      api: { type: Object, required: true },
      connectionId: { type: String, required: true },
      supportsTtl: { type: Boolean, default: false },
      supportsLeaseBinding: { type: Boolean, default: false },
      ttlCapabilityKnown: { type: Boolean, default: true },
      readOnly: { type: Boolean, default: false },
      canWriteKey: { type: Function, default: undefined },
    },
    emits: ["refreshRequested", "selectionChange"],
    setup(props, { emit, expose }) {
      backend.capturedKvBrowserApi = props.api;
      backend.capturedCanWriteKey = props.canWriteKey;
      expose({
        focusSearch: () => true,
        selectKey: (route: unknown) => {
          backend.selectKeyCalls.push(route);
          return Promise.resolve();
        },
        refresh: () => {
          emit("refreshRequested");
          return true;
        },
        selectAllMultiSelection: () => undefined,
        clearMultiSelection: () => emit("selectionChange", []),
        removeMultiSelection: (selection: unknown[]) => {
          if (selection.length) emit("selectionChange", []);
        },
      });
      return () =>
        h("div", [
          h(
            "button",
            {
              id: "kv-browser-stub",
              "data-supports-ttl": String(props.supportsTtl),
              "data-supports-lease-binding": String(props.supportsLeaseBinding),
              "data-capability-known": String(props.ttlCapabilityKnown),
              "data-read-only": String(props.readOnly),
              onClick: () => emit("refreshRequested"),
            },
            "refresh",
          ),
          h(
            "button",
            {
              id: "emit-tree-selection",
              onClick: () =>
                emit("selectionChange", [
                  {
                    key: "[base64:/w==]",
                    keyIdentity: "ff",
                    keyBytes: { encoding: "base64", data: "/w==" },
                    modRevision: "7",
                  },
                ]),
            },
            "select",
          ),
        ]);
    },
  }),
}));

vi.mock("@/components/editor/DangerConfirmDialog.vue", () => ({
  default: defineComponent({
    name: "DangerConfirmDialogStub",
    props: {
      open: { type: Boolean, default: false },
    },
    emits: ["confirm", "update:open"],
    setup(props, { emit }) {
      return () => (props.open ? h("button", { id: "confirm-batch-delete", onClick: () => emit("confirm") }, "confirm") : null);
    },
  }),
}));

vi.mock("@/components/etcd/EtcdAdminConsole.vue", () => ({
  default: defineComponent({
    name: "EtcdAdminConsoleStub",
    setup() {
      return () => h("div", { id: "etcd-admin-console-stub" });
    },
  }),
}));

vi.mock("@/components/ui/dropdown-menu", () => ({
  DropdownMenu: defineComponent({
    name: "DropdownMenuStub",
    setup(_, { slots }) {
      return () => h("div", slots.default?.());
    },
  }),
  DropdownMenuTrigger: defineComponent({
    name: "DropdownMenuTriggerStub",
    setup(_, { slots }) {
      return () => h("div", slots.default?.());
    },
  }),
  DropdownMenuContent: defineComponent({
    name: "DropdownMenuContentStub",
    setup(_, { slots }) {
      return () => h("div", slots.default?.());
    },
  }),
  DropdownMenuItem: defineComponent({
    name: "DropdownMenuItemStub",
    emits: ["select"],
    setup(_, { emit, slots }) {
      return () => h("button", { type: "button", onClick: () => emit("select") }, slots.default?.());
    },
  }),
  DropdownMenuSeparator: defineComponent({
    name: "DropdownMenuSeparatorStub",
    setup() {
      return () => h("hr");
    },
  }),
}));

import EtcdKeyBrowser from "@/components/etcd/EtcdKeyBrowser.vue";

let app: App<Element> | null = null;
let root: HTMLDivElement | null = null;

async function flushUi() {
  await Promise.resolve();
  await Promise.resolve();
  await nextTick();
}

async function mountBrowser() {
  root = document.createElement("div");
  document.body.appendChild(root);
  app = createApp(EtcdKeyBrowser, { connectionId: "etcd-1" });
  app.mount(root);
  await flushUi();
  return root.querySelector<HTMLButtonElement>("#kv-browser-stub")!;
}

beforeEach(() => {
  vi.useFakeTimers();
  backend.etcdSupportsTtl.mockReset();
  backend.etcdListPrefix.mockReset();
  backend.etcdGet.mockReset();
  backend.etcdPut.mockReset();
  backend.etcdDelete.mockReset();
  backend.etcdRename.mockReset();
  backend.etcdHistory.mockReset();
  backend.etcdStatus.mockReset();
  backend.etcdListPrefix.mockResolvedValue({ keys: [], continuation: null, revision: "1" });
  backend.etcdGetCalls.length = 0;
  backend.capturedKvBrowserApi = null;
  backend.capturedCanWriteKey = null;
  backend.canWriteEtcdKey.mockReset().mockReturnValue(true);
  backend.ensureEtcdAccessCapabilities.mockReset().mockImplementation(async () => backend.access);
  backend.selectKeyCalls.length = 0;
  backend.access.admin = true;
  backend.access.writable = true;
});

afterEach(() => {
  app?.unmount();
  app = null;
  root?.remove();
  root = null;
  vi.useRealTimers();
});

describe("EtcdKeyBrowser TTL capability recovery", () => {
  it("keeps a transient probe failure unknown and retries automatically", async () => {
    backend.etcdSupportsTtl.mockRejectedValueOnce(new Error("Agent is reconnecting")).mockResolvedValue(true);

    const browser = await mountBrowser();
    expect(browser.dataset.supportsTtl).toBe("false");
    expect(browser.dataset.capabilityKnown).toBe("false");

    await vi.advanceTimersByTimeAsync(5000);
    await flushUi();

    expect(backend.etcdSupportsTtl).toHaveBeenCalledTimes(2);
    expect(browser.dataset.supportsTtl).toBe("true");
    expect(browser.dataset.capabilityKnown).toBe("true");
  });

  it("rechecks a confirmed unsupported Agent when the user refreshes", async () => {
    backend.etcdSupportsTtl.mockResolvedValueOnce(false).mockResolvedValueOnce(true);

    const browser = await mountBrowser();
    expect(browser.dataset.supportsTtl).toBe("false");
    expect(browser.dataset.capabilityKnown).toBe("true");

    browser.click();
    await flushUi();

    expect(backend.etcdSupportsTtl).toHaveBeenCalledTimes(2);
    expect(browser.dataset.supportsTtl).toBe("true");
    expect(browser.dataset.capabilityKnown).toBe("true");
  });

  it("keeps the last confirmed capability through a transient later failure", async () => {
    backend.etcdSupportsTtl.mockResolvedValueOnce(true).mockRejectedValueOnce(new Error("temporary failure"));

    const browser = await mountBrowser();
    expect(browser.dataset.supportsTtl).toBe("true");
    expect(browser.dataset.capabilityKnown).toBe("true");

    await vi.advanceTimersByTimeAsync(5000);
    await flushUi();

    expect(backend.etcdSupportsTtl).toHaveBeenCalledTimes(2);
    expect(browser.dataset.supportsTtl).toBe("true");
    expect(browser.dataset.capabilityKnown).toBe("true");
  });
});

describe("EtcdKeyBrowser restricted etcd access", () => {
  it("loads access capabilities when a restored tab mounts without sidebar expansion", async () => {
    await mountBrowser();

    await vi.waitFor(() =>
      expect(backend.ensureEtcdAccessCapabilities).toHaveBeenCalledWith("etcd-1", {
        force: true,
        verifyHealth: false,
      }),
    );
  });

  it("hides cluster controls and opens a Key watch without reading cluster status", async () => {
    backend.access.admin = false;
    backend.access.writable = false;

    const browser = await mountBrowser();
    expect(browser.dataset.readOnly).toBe("true");
    expect(browser.dataset.supportsLeaseBinding).toBe("false");
    expect(root!.textContent).not.toContain("etcd.admin.maintenance");
    expect(root!.textContent).not.toContain("etcd.admin.lease");

    const watch = [...root!.querySelectorAll("button")].find((button) => button.textContent?.includes("etcd.admin.watch"));
    watch?.click();
    await flushUi();

    expect(root!.querySelector("#etcd-admin-console-stub")).toBeTruthy();
    expect(backend.etcdStatus).not.toHaveBeenCalled();
  });
});

describe("EtcdKeyBrowser global search", () => {
  it("clears results and counters while retaining the search form", async () => {
    backend.etcdListPrefix.mockResolvedValue({
      keys: [
        {
          key: "/test/config",
          keyBytes: { encoding: "utf8", data: "/test/config" },
          value: { encoding: "utf8", data: "matched value" },
          modRevision: "8",
        },
      ],
      continuation: null,
      revision: "8",
    });

    await mountBrowser();
    const openSearch = [...root!.querySelectorAll("button")].find((button) => button.textContent?.includes("etcd.globalSearch"));
    openSearch?.click();
    await flushUi();

    const input = root!.querySelector<HTMLInputElement>('input[placeholder="etcd.searchPlaceholder"]')!;
    input.value = "matched";
    input.dispatchEvent(new Event("input"));
    await flushUi();
    const submit = [...root!.querySelectorAll("button")].filter((button) => button.textContent?.includes("etcd.globalSearch")).at(-1);
    submit?.click();
    await flushUi();

    expect(root!.textContent).toContain("/test/config");
    const clear = [...root!.querySelectorAll("button")].find((button) => button.textContent?.includes("etcd.clearSearchResults"));
    expect(clear).toBeTruthy();
    clear?.click();
    await flushUi();

    expect(root!.textContent).not.toContain("/test/config");
    expect(root!.textContent).toContain("已扫描 0 个 Key");
    expect(input.value).toBe("matched");
    expect([...root!.querySelectorAll("button")].some((button) => button.textContent?.includes("etcd.clearSearchResults"))).toBe(false);
  });
});

describe("EtcdKeyBrowser byte-identity routing", () => {
  it("keeps colliding display keys on distinct keyBytes routes", async () => {
    backend.etcdListPrefix.mockResolvedValue({
      keys: [
        {
          key: "/w==",
          keyBytes: { encoding: "base64", data: "/w==" },
          value: { encoding: "utf8", data: "binary" },
          modRevision: "1",
        },
        {
          key: "[base64:/w==]",
          keyBytes: { encoding: "utf8", data: "[base64:/w==]" },
          value: { encoding: "utf8", data: "utf8" },
          modRevision: "2",
        },
      ],
      continuation: null,
      revision: "7",
    });
    backend.etcdGet.mockImplementation(async (_connectionId, key, options) => ({
      found: true,
      key,
      keyBytes: options?.keyBytes ?? null,
      value: { encoding: "utf8", data: "value" },
      metadata: { modRevision: "9" },
    }));
    backend.etcdPut.mockResolvedValue({ revision: 10, key: "[base64:/w==]" });
    backend.etcdDelete.mockResolvedValue({ deleted: 1 });
    backend.etcdRename.mockResolvedValue({ renamed: true, revision: "11" });
    backend.etcdHistory.mockResolvedValue({ events: [] });

    await mountBrowser();
    expect(backend.capturedKvBrowserApi).toBeTruthy();

    const { keys } = await backend.capturedKvBrowserApi.listPrefix("etcd-1", "", 20);
    expect(keys).toHaveLength(2);
    const [binaryKey, utf8Key] = keys;
    expect(binaryKey.key).toBe("[base64:/w==]");
    expect(utf8Key.key).toBe("[base64:/w==]");
    expect(binaryKey.keyIdentity).not.toBe(utf8Key.keyIdentity);

    await backend.capturedKvBrowserApi.get("etcd-1", binaryKey.key, { keyBytes: binaryKey.keyBytes });
    await backend.capturedKvBrowserApi.put("etcd-1", binaryKey.key, { encoding: "utf8", data: "x" }, { keyBytes: binaryKey.keyBytes });
    await backend.capturedKvBrowserApi.deleteKey("etcd-1", utf8Key.key, { keyBytes: utf8Key.keyBytes });
    await backend.capturedKvBrowserApi.rename?.("etcd-1", { key: binaryKey.key, keyBytes: binaryKey.keyBytes, newKey: "renamed", expectedModRevision: "9" });
    await backend.capturedKvBrowserApi.history?.("etcd-1", { key: utf8Key.key, keyBytes: utf8Key.keyBytes, limit: 10 });
    await backend.capturedKvBrowserApi.exportScope?.("etcd-1", { path: binaryKey.key, kind: "key", keyBytes: binaryKey.keyBytes });

    expect(backend.etcdGet).toHaveBeenCalledWith("etcd-1", "[base64:/w==]", expect.objectContaining({ keyBytes: binaryKey.keyBytes }));
    expect(backend.etcdPut).toHaveBeenCalledWith("etcd-1", "[base64:/w==]", { encoding: "utf8", data: "x" }, expect.objectContaining({ keyBytes: binaryKey.keyBytes }));
    expect(backend.etcdDelete).toHaveBeenCalledWith("etcd-1", "[base64:/w==]", expect.objectContaining({ keyBytes: utf8Key.keyBytes }));
    expect(backend.etcdRename).toHaveBeenCalledWith("etcd-1", expect.objectContaining({ key: "[base64:/w==]", keyBytes: binaryKey.keyBytes }));
    expect(backend.etcdHistory).toHaveBeenCalledWith("etcd-1", expect.objectContaining({ key: "[base64:/w==]", keyBytes: utf8Key.keyBytes }));
    expect(backend.etcdGet.mock.calls.at(-1)?.[2]).toEqual(expect.objectContaining({ keyBytes: binaryKey.keyBytes }));
  });

  it("opens search results with the selected keyBytes", async () => {
    backend.etcdListPrefix.mockResolvedValue({
      keys: [
        {
          key: "/w==",
          keyBytes: { encoding: "base64", data: "/w==" },
          value: { encoding: "utf8", data: "match" },
          modRevision: "1",
        },
        {
          key: "[base64:/w==]",
          keyBytes: { encoding: "utf8", data: "[base64:/w==]" },
          value: { encoding: "utf8", data: "match" },
          modRevision: "2",
        },
      ],
      continuation: null,
      revision: "7",
    });

    const root = document.createElement("div");
    document.body.appendChild(root);
    const app = createApp(EtcdKeyBrowser, { connectionId: "etcd-1" });
    app.mount(root);
    await flushUi();

    const searchButton = [...root.querySelectorAll("button")].find((button) => button.textContent?.includes("etcd.globalSearch")) as HTMLButtonElement | undefined;
    expect(searchButton).toBeTruthy();
    searchButton!.click();
    await flushUi();

    const input = root.querySelector('input[placeholder="etcd.searchPlaceholder"]') as HTMLInputElement | null;
    expect(input).toBeTruthy();
    input.value = "match";
    input.dispatchEvent(new Event("input"));
    await flushUi();

    const searchSubmit = [...root.querySelectorAll("button")].filter((button) => button.textContent?.includes("etcd.globalSearch")).at(-1) as HTMLButtonElement | undefined;
    searchSubmit?.click();
    await flushUi();

    const resultButtons = [...root.querySelectorAll("button")].filter((button) => button.textContent?.includes("[base64:/w==]"));
    expect(resultButtons).toHaveLength(2);
    resultButtons[0].click();
    resultButtons[1].click();
    await flushUi();

    expect(backend.selectKeyCalls).toHaveLength(2);
    expect(backend.selectKeyCalls[0]).toEqual(expect.objectContaining({ keyBytes: { encoding: "base64", data: "/w==" } }));
    expect(backend.selectKeyCalls[1]).toEqual(expect.objectContaining({ keyBytes: { encoding: "utf8", data: "[base64:/w==]" } }));
    app.unmount();
    root.remove();
  });
});

describe("EtcdKeyBrowser tree batch operations", () => {
  it("requires confirmation before deleting selected keys with their raw bytes and selection-time revision", async () => {
    backend.etcdDelete.mockResolvedValue({ deleted: 1 });

    await mountBrowser();
    root!.querySelector<HTMLButtonElement>("#emit-tree-selection")!.click();
    await flushUi();

    const batchDelete = [...root!.querySelectorAll("button")].find((button) => button.textContent?.includes("etcd.delete"));
    expect(root!.querySelector("#confirm-batch-delete")).toBeNull();
    expect(backend.etcdDelete).not.toHaveBeenCalled();

    batchDelete!.click();
    await flushUi();
    expect(root!.querySelector("#confirm-batch-delete")).toBeTruthy();
    expect(backend.etcdDelete).not.toHaveBeenCalled();

    root!.querySelector<HTMLButtonElement>("#confirm-batch-delete")!.click();
    await flushUi();

    expect(backend.etcdDelete).toHaveBeenCalledWith("etcd-1", "[base64:/w==]", {
      keyBytes: { encoding: "base64", data: "/w==" },
      expectedModRevision: "7",
    });
  });

  it("shows selected exports only after selecting keys and exports with raw key bytes", async () => {
    backend.etcdGet.mockResolvedValue({
      found: true,
      key: "[base64:/w==]",
      keyBytes: { encoding: "base64", data: "/w==" },
      value: { encoding: "utf8", data: "value" },
      metadata: { modRevision: "7" },
    });

    await mountBrowser();
    const selectedExports = () => [...root!.querySelectorAll("button")].filter((button) => button.textContent?.includes("etcd.exportSelection"));
    expect(selectedExports()).toHaveLength(0);

    root!.querySelector<HTMLButtonElement>("#emit-tree-selection")!.click();
    await flushUi();

    expect(selectedExports()).toHaveLength(3);
    selectedExports()[0]!.click();
    await flushUi();

    expect(backend.etcdGet).toHaveBeenCalledWith("etcd-1", "[base64:/w==]", {
      keyBytes: { encoding: "base64", data: "/w==" },
    });
  });

  it("clears the stale selection and refreshes after a batch delete fails", async () => {
    backend.etcdDelete.mockRejectedValue(new Error("ETCD_CAS_CONFLICT"));

    await mountBrowser();
    root!.querySelector<HTMLButtonElement>("#emit-tree-selection")!.click();
    await flushUi();

    const batchDelete = [...root!.querySelectorAll("button")].find((button) => button.textContent?.includes("etcd.delete"));
    batchDelete!.click();
    await flushUi();
    root!.querySelector<HTMLButtonElement>("#confirm-batch-delete")!.click();
    await flushUi();

    const selectedExports = [...root!.querySelectorAll("button")].filter((button) => button.textContent?.includes("etcd.exportSelection"));
    expect(selectedExports).toHaveLength(0);
  });

  it("blocks a selected Key outside the user's write ranges before any delete", async () => {
    backend.canWriteEtcdKey.mockImplementation((_connectionId, _key, keyBytes) => keyBytes?.data !== "/w==");

    await mountBrowser();
    root!.querySelector<HTMLButtonElement>("#emit-tree-selection")!.click();
    await flushUi();

    const batchDelete = [...root!.querySelectorAll("button")].find((button) => button.textContent?.includes("etcd.delete")) as HTMLButtonElement;
    expect(batchDelete.disabled).toBe(true);
    expect(() => backend.capturedKvBrowserApi.deleteKey("etcd-1", "[base64:/w==]", { keyBytes: { encoding: "base64", data: "/w==" } })).toThrow("ETCD_PERMISSION_DENIED");
    expect(backend.etcdDelete).not.toHaveBeenCalled();
    expect(backend.capturedCanWriteKey({ key: "[base64:/w==]", keyBytes: { encoding: "base64", data: "/w==" } })).toBe(false);
  });
});