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。

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

import { createApp, defineComponent, h, nextTick, reactive, type App } from "vue";
import { afterEach, describe, expect, it, vi } from "vitest";
import i18n from "@/i18n";
import PluginConnectionFields from "./PluginConnectionFields.vue";
import type { PluginConnectionProviderContribution, PluginFormField, PluginFormFieldBinding, PluginFormFieldValue } from "@/types/database";

const invokePluginMock = vi.fn();
const { pickPluginFieldFileMock, tauriRuntime } = vi.hoisted(() => ({
  pickPluginFieldFileMock: vi.fn(),
  tauriRuntime: { value: false },
}));

vi.mock("@/lib/plugins/pluginFieldPicker", () => ({
  PLUGIN_PICKER_MAX_BYTES: 1_048_576,
  pickPluginFieldFile: (...args: unknown[]) => pickPluginFieldFileMock(...args),
}));
vi.mock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => tauriRuntime.value }));

vi.mock("@/lib/backend/api", () => ({
  listLocalSshKeys: vi.fn(async () => [
    { path: "/home/dev/.ssh/id_ed25519", algorithm: "ssh-ed25519", fingerprint: "SHA256:abc", hasPassphrase: false },
    { path: "/home/dev/.ssh/id_rsa", algorithm: "ssh-rsa", fingerprint: "", hasPassphrase: true },
  ]),
  invokePlugin: (...args: unknown[]) => invokePluginMock(...args),
}));

const mountedApps: App[] = [];

const contribution: PluginConnectionProviderContribution = {
  type: "connection-provider",
  id: "example.connection",
  label: "Example connection",
  database_type: "example",
  fields: [
    { key: "host", label: "Host", type: "text", required: true, placeholder: "localhost" },
    { key: "password", label: "Password", type: "password" },
  ],
};

async function mountFields(initialValues: Record<string, PluginFormFieldValue> = {}, hiddenBindings: PluginFormFieldBinding[] = [], layout: "stacked" | "connection-dialog" = "stacked") {
  const state = reactive({ values: initialValues });
  const container = document.createElement("div");
  document.body.append(container);
  const app = createApp(
    defineComponent({
      setup() {
        return () =>
          h(PluginConnectionFields, {
            contribution,
            modelValue: state.values,
            hiddenBindings,
            layout,
            "onUpdate:modelValue": (value: Record<string, PluginFormFieldValue>) => {
              state.values = value;
            },
          });
      },
    }),
  );
  mountedApps.push(app);
  app.use(i18n);
  app.mount(container);
  await nextTick();
  return state;
}

describe("PluginConnectionFields file picker", () => {
  const pickerContribution = (picker: PluginFormField["picker"], contentField = true): PluginConnectionProviderContribution => ({
    type: "connection-provider",
    id: "ssh.connection",
    label: "SSH",
    database_type: "ssh",
    fields: [{ key: "private_key_path", label: "Private key path", type: "text", picker }, ...(contentField ? [{ key: "private_key", label: "Private key", type: "textarea" as const, binding: "secret" as const }] : [])],
  });

  it("stores the chosen client path on desktop and drops a stale uploaded copy", async () => {
    tauriRuntime.value = true;
    pickPluginFieldFileMock.mockReset().mockResolvedValue({ path: "/Users/dev/.ssh/id_rsa", name: "id_rsa" });
    const provider = pickerContribution({ kind: "file", accept: [".pem"], content_field: "private_key" });
    const state = await mountContribution(provider, { private_key: "OLD-UPLOADED-KEY" });

    const browse = document.querySelector<HTMLButtonElement>("#ssh-connection-private_key_path-picker");
    expect(browse?.textContent).toContain("Choose file");
    browse?.click();

    await vi.waitFor(() => expect(state.values.private_key_path).toBe("/Users/dev/.ssh/id_rsa"));
    // The plugin prefers content over a path, so picking a path must clear the
    // previously uploaded key or the stale one would keep winning.
    expect(state.values.private_key).toBeUndefined();
  });

  it("uploads the file content into the paired field on browser hosts", async () => {
    tauriRuntime.value = false;
    pickPluginFieldFileMock.mockReset().mockResolvedValue({ content: "UPLOADED-KEY", name: "id_rsa" });
    const provider = pickerContribution({ kind: "file", accept: [".pem"], content_field: "private_key" });
    const state = await mountContribution(provider, { private_key_path: "/Users/dev/.ssh/id_rsa" });

    const upload = document.querySelector<HTMLButtonElement>("#ssh-connection-private_key_path-picker");
    expect(upload?.textContent).toContain("Upload file");
    upload?.click();

    await vi.waitFor(() => expect(state.values.private_key).toBe("UPLOADED-KEY"));
    // A browser path would point at the user's machine, not the host's.
    expect(state.values.private_key_path).toBeUndefined();
  });

  it("hides a browser-unsupported picker and keeps the desktop one available", async () => {
    const provider = pickerContribution({ kind: "file" }, false);

    tauriRuntime.value = false;
    await mountContribution(provider, {});
    expect(document.querySelector("#ssh-connection-private_key_path-picker")).toBeNull();

    tauriRuntime.value = true;
    await mountContribution(provider, {});
    expect(document.querySelector("#ssh-connection-private_key_path-picker")).not.toBeNull();
  });

  it("surfaces a picker failure without touching the form", async () => {
    tauriRuntime.value = false;
    pickPluginFieldFileMock.mockReset().mockRejectedValue(new Error("File is larger than 1024 KiB"));
    const provider = pickerContribution({ kind: "file", content_field: "private_key" });
    const state = await mountContribution(provider, { private_key: "KEEP-ME" });

    document.querySelector<HTMLButtonElement>("#ssh-connection-private_key_path-picker")?.click();

    await vi.waitFor(() => expect(pickPluginFieldFileMock).toHaveBeenCalled());
    await nextTick();
    expect(state.values).toEqual({ private_key: "KEEP-ME" });
  });
});

afterEach(() => {
  for (const app of mountedApps.splice(0)) app.unmount();
  document.body.innerHTML = "";
});

describe("PluginConnectionFields", () => {
  it("preserves multiline secret input and masks it again after its branch is reopened", async () => {
    const provider: PluginConnectionProviderContribution = {
      type: "connection-provider",
      id: "pem.connection",
      label: "PEM",
      database_type: "example",
      fields: [
        { key: "mode", label: "Mode", type: "text", default: "tls" },
        { key: "key", label: "Private key", type: "textarea", binding: "secret", visible_when: { field: "mode", one_of: ["tls"] } },
      ],
    };
    const state = await mountContribution(provider, {});
    const textarea = document.querySelector<HTMLTextAreaElement>("#pem-connection-key")!;
    const pem = "-----BEGIN PRIVATE KEY-----\nexample\n-----END PRIVATE KEY-----\n";
    expect(textarea.classList.contains("secret-masked")).toBe(true);
    textarea.value = pem;
    textarea.dispatchEvent(new Event("input", { bubbles: true }));
    await nextTick();
    expect(state.values.key).toBe(pem);
    textarea.parentElement!.querySelector<HTMLButtonElement>("button")!.click();
    await nextTick();
    expect(textarea.classList.contains("secret-masked")).toBe(false);
    expect(textarea.value).toBe(pem);
    state.values = { ...state.values, mode: "plain" };
    await nextTick();
    expect(document.querySelector("#pem-connection-key")).toBeNull();
    state.values = { ...state.values, mode: "tls" };
    await nextTick();
    const reopened = document.querySelector<HTMLTextAreaElement>("#pem-connection-key")!;
    expect(reopened.value).toBe(pem);
    expect(reopened.classList.contains("secret-masked")).toBe(true);
  });

  it("renders declared fields and emits immutable model updates", async () => {
    const state = await mountFields({ password: "secret" });
    const hostInput = document.querySelector<HTMLInputElement>("#example-connection-host");
    const passwordInput = document.querySelector<HTMLInputElement>("#example-connection-password");

    expect(hostInput?.placeholder).toBe("localhost");
    expect(passwordInput?.value).toBe("secret");

    if (!hostInput) throw new Error("host input not mounted");
    hostInput.value = "db.internal";
    hostInput.dispatchEvent(new Event("input", { bubbles: true }));
    await nextTick();

    expect(state.values).toEqual({ password: "secret", host: "db.internal" });
  });

  it('renders a null value as an empty field instead of the text "null"', async () => {
    // Hosts before the manifest serialization fix hydrated untouched fields with
    // `null`, and a null reaching an <input> is coerced to the string "null" by
    // the DOM — a password field then looked non-empty without any user input.
    const provider: PluginConnectionProviderContribution = {
      type: "connection-provider",
      id: "null.connection",
      label: "Nulls",
      database_type: "nulls",
      fields: [
        { key: "sudo_password", label: "Sudo password", type: "password", binding: "secret" },
        { key: "sudo_command", label: "Sudo command", type: "text", binding: "config" },
        { key: "set_env", label: "Env", type: "textarea", binding: "config" },
      ],
    };
    const state = await mountContribution(provider, {
      sudo_password: null,
      sudo_command: null,
      set_env: null,
    } as unknown as Record<string, PluginFormFieldValue>);

    expect(document.querySelector<HTMLInputElement>("#null-connection-sudo_password")?.value).toBe("");
    expect(document.querySelector<HTMLInputElement>("#null-connection-sudo_command")?.value).toBe("");
    expect(document.querySelector<HTMLTextAreaElement>("#null-connection-set_env")?.value).toBe("");

    // Editing still emits a real value, so a null never survives the dialog.
    const command = document.querySelector<HTMLInputElement>("#null-connection-sudo_command")!;
    command.value = "sudo -n true";
    command.dispatchEvent(new Event("input", { bubbles: true }));
    await nextTick();
    expect(state.values.sudo_command).toBe("sudo -n true");
  });

  it("can hide host-owned common bindings", async () => {
    contribution.fields[0].binding = "host";
    await mountFields({}, ["host"]);
    expect(document.querySelector("#example-connection-host")).toBeNull();
    expect(document.querySelector("#example-connection-password")).not.toBeNull();
    contribution.fields[0].binding = undefined;
  });

  it("uses the native four-column connection layout without a nested card", async () => {
    await mountFields({}, [], "connection-dialog");

    const root = document.querySelector(".contents");
    const hostInput = document.querySelector("#example-connection-host");
    const fieldRow = hostInput?.closest(".grid");

    expect(root).not.toBeNull();
    expect(root?.textContent).not.toContain("Example connection");
    expect(fieldRow?.classList.contains("grid-cols-4")).toBe(true);
    expect(document.querySelector(".rounded-lg.border")).toBeNull();
  });

  it("hides conditional fields until visible_when matches and marks required_when", async () => {
    const conditional: PluginConnectionProviderContribution = {
      type: "connection-provider",
      id: "cond.connection",
      label: "Conditional",
      database_type: "cond",
      fields: [
        { key: "mode", label: "Mode", type: "text", default: "password" },
        { key: "private_key_path", label: "Private key", type: "text", visible_when: { field: "mode", one_of: ["key"] }, required_when: { field: "mode", one_of: ["key"] } },
      ],
    };
    const state = await mountContribution(conditional, {});

    expect(document.querySelector("#cond-connection-private_key_path")).toBeNull();

    state.values = { mode: "key" };
    await nextTick();

    const keyInput = document.querySelector<HTMLInputElement>("#cond-connection-private_key_path");
    expect(keyInput).not.toBeNull();
    const label = document.querySelector('label[for="cond-connection-private_key_path"]');
    expect(label?.textContent).toContain("*");

    state.values = { mode: "password" };
    await nextTick();
    expect(document.querySelector("#cond-connection-private_key_path")).toBeNull();
  });

  it("keeps grandchild fields hidden while an intermediate default-only value would match (kafka msk_region regression)", async () => {
    // sasl_mechanism (PLAIN default, hidden without SASL) → oauth_token_source
    // (msk_iam default) → msk_region: the nested default must not surface an
    // always-required AWS region on a plain PLAINTEXT/SCRAM connection.
    const kafka: PluginConnectionProviderContribution = {
      type: "connection-provider",
      id: "kafka.connection",
      label: "Kafka",
      database_type: "kafka",
      fields: [
        { key: "bootstrap_servers", label: "Bootstrap servers", type: "textarea", required: true },
        {
          key: "security_protocol",
          label: "Security protocol",
          type: "select",
          default: "PLAINTEXT",
          options: [
            { label: "PLAINTEXT", value: "PLAINTEXT" },
            { label: "SASL_SSL", value: "SASL_SSL" },
          ],
        },
        {
          key: "sasl_mechanism",
          label: "SASL mechanism",
          type: "select",
          default: "PLAIN",
          options: [
            { label: "PLAIN", value: "PLAIN" },
            { label: "OAUTHBEARER", value: "OAUTHBEARER" },
          ],
          visible_when: { field: "security_protocol", one_of: ["SASL_PLAINTEXT", "SASL_SSL"] },
        },
        {
          key: "oauth_token_source",
          label: "OAuth token source",
          type: "select",
          default: "msk_iam",
          options: [
            { label: "MSK IAM", value: "msk_iam" },
            { label: "Static token", value: "static_token" },
          ],
          visible_when: { field: "sasl_mechanism", one_of: ["OAUTHBEARER"] },
        },
        { key: "msk_region", label: "MSK AWS region", type: "text", visible_when: { field: "oauth_token_source", one_of: ["msk_iam"] }, required_when: { field: "oauth_token_source", one_of: ["msk_iam"] } },
      ],
    };
    const state = await mountContribution(kafka, {}, "io.dbx.kafka");

    expect(document.querySelector("#kafka-connection-msk_region")).toBeNull();

    state.values = { security_protocol: "SASL_SSL", sasl_mechanism: "OAUTHBEARER" };
    await nextTick();
    expect(document.querySelector("#kafka-connection-msk_region")).not.toBeNull();
    const label = document.querySelector('label[for="kafka-connection-msk_region"]');
    expect(label?.textContent).toContain("*");

    // Selecting the static token source hides the region field again.
    state.values = { sasl_mechanism: "OAUTHBEARER", oauth_token_source: "static_token" };
    await nextTick();
    expect(document.querySelector("#kafka-connection-msk_region")).toBeNull();
  });

  it("renders a field only while every clause of an all_of condition holds (sudo_source + read_only)", async () => {
    // The SSH plugin cannot express "sudo_source = custom AND read_only =
    // false" with one clause per field; all_of + a boolean literal covers it.
    const ssh: PluginConnectionProviderContribution = {
      type: "connection-provider",
      id: "ssh.connection",
      label: "SSH",
      database_type: "ssh",
      fields: [
        {
          key: "read_only",
          label: "Read only",
          type: "boolean",
          default: false,
        },
        {
          key: "sudo_source",
          label: "Sudo source",
          type: "select",
          default: "none",
          options: [
            { label: "None", value: "none" },
            { label: "Custom", value: "custom" },
          ],
        },
        {
          key: "sudo_command",
          label: "Sudo command",
          type: "text",
          visible_when: {
            all_of: [
              { field: "sudo_source", one_of: ["custom"] },
              { field: "read_only", one_of: [false] },
            ],
          },
          required_when: {
            all_of: [
              { field: "sudo_source", one_of: ["custom"] },
              { field: "read_only", one_of: [false] },
            ],
          },
        },
      ],
    };
    const state = await mountContribution(ssh, {});

    expect(document.querySelector("#ssh-connection-sudo_command")).toBeNull();

    state.values = { sudo_source: "custom", read_only: false };
    await nextTick();
    expect(document.querySelector("#ssh-connection-sudo_command")).not.toBeNull();
    expect(document.querySelector('label[for="ssh-connection-sudo_command"]')?.textContent).toContain("*");

    // Read-only sessions ignore the sudo block entirely.
    state.values = { sudo_source: "custom", read_only: true };
    await nextTick();
    expect(document.querySelector("#ssh-connection-sudo_command")).toBeNull();

    state.values = { sudo_source: "none", read_only: false };
    await nextTick();
    expect(document.querySelector("#ssh-connection-sudo_command")).toBeNull();
  });

  it("offers local SSH keys on private_key_path fields and fills the chosen path", async () => {
    const withKey: PluginConnectionProviderContribution = {
      type: "connection-provider",
      id: "keys.connection",
      label: "Keys",
      database_type: "keys",
      fields: [{ key: "private_key_path", label: "Private key", type: "text" }],
    };
    const state = await mountContribution(withKey, {});
    await flushAsync();

    const select = document.querySelector<HTMLSelectElement>("select");
    expect(select).not.toBeNull();
    expect(select?.disabled).toBe(false);
    const encryptedOption = select?.querySelector<HTMLOptionElement>('option[value="/home/dev/.ssh/id_rsa"]');
    expect(encryptedOption?.textContent).toContain("id_rsa");
    expect(encryptedOption?.textContent).toContain("ssh-rsa");
    expect(encryptedOption?.textContent).toMatch(/encrypted|已加密/);

    select!.value = "/home/dev/.ssh/id_rsa";
    select!.dispatchEvent(new Event("change", { bubbles: true }));
    await nextTick();

    expect(state.values.private_key_path).toBe("/home/dev/.ssh/id_rsa");
  });

  it("renders options_action fields as a dynamic select and keeps a stored value visible", async () => {
    const dynamic: PluginConnectionProviderContribution = {
      type: "connection-provider",
      id: "dyn.connection",
      label: "Dyn",
      database_type: "dyn",
      fields: [{ key: "sudo_profile", label: "Profile", type: "text", options_action: "sudo/profiles/options" }],
    };
    invokePluginMock.mockResolvedValueOnce({
      options: [
        { value: "p1", label: "Ops" },
        { value: "p2", label: "QA" },
      ],
    });
    // "ghost" is stored but no longer offered: the dropdown must keep it visible.
    await mountContribution(dynamic, { sudo_profile: "ghost" }, "io.dbx.ssh");
    await flushAsync();

    expect(invokePluginMock).toHaveBeenCalledWith("io.dbx.ssh", "sudo/profiles/options", { locale: "en" });
    expect(document.querySelector("input#dyn-connection-sudo_profile")).toBeNull();
    const trigger = document.querySelector<HTMLButtonElement>('#dyn-connection-sudo_profile, button[role="combobox"]');
    expect(trigger).not.toBeNull();
    expect(trigger?.textContent).toContain("ghost");
  });

  it("falls back to the text input when the options_action call fails or returns nothing", async () => {
    const dynamic: PluginConnectionProviderContribution = {
      type: "connection-provider",
      id: "degrade.connection",
      label: "Degrade",
      database_type: "degrade",
      fields: [{ key: "sudo_profile", label: "Profile", type: "text", options_action: "sudo/profiles/options" }],
    };
    invokePluginMock.mockRejectedValueOnce(new Error("method not registered"));
    await mountContribution(dynamic, {}, "io.dbx.ssh");
    await flushAsync();

    const input = document.querySelector<HTMLInputElement>("input#degrade-connection-sudo_profile");
    expect(input).not.toBeNull();
    expect(input?.value).toBe("");

    // An empty option list degrades the same way.
    invokePluginMock.mockResolvedValueOnce({ options: [] });
    const empty = { ...dynamic, id: "empty.connection", label: "Empty" };
    await mountContribution(empty, {}, "io.dbx.ssh");
    await flushAsync();
    expect(document.querySelector("input#empty-connection-sudo_profile")).not.toBeNull();
  });
});

async function flushAsync() {
  await nextTick();
  await new Promise((resolve) => setTimeout(resolve, 0));
}

async function mountContribution(contribution: PluginConnectionProviderContribution, initialValues: Record<string, PluginFormFieldValue>, pluginId?: string) {
  const state = reactive({ values: initialValues });
  const container = document.createElement("div");
  document.body.append(container);
  const app = createApp(
    defineComponent({
      setup() {
        return () =>
          h(PluginConnectionFields, {
            contribution,
            modelValue: state.values,
            pluginId,
            "onUpdate:modelValue": (value: Record<string, PluginFormFieldValue>) => {
              state.values = value;
            },
          });
      },
    }),
  );
  mountedApps.push(app);
  app.use(i18n);
  app.mount(container);
  await nextTick();
  return state;
}