602 lines
28 KiB
TypeScript
Vendored
602 lines
28 KiB
TypeScript
Vendored
import { describe, expect, it } from "vitest";
|
|
import type { InstalledPlugin, PluginConnectionProviderContribution, PluginFormFieldValue } from "@/types/database";
|
|
import {
|
|
buildPluginConnectionConfig,
|
|
createFrontendPluginRegistry,
|
|
initialPluginFormValues,
|
|
parsePluginConnectionProviderOptionValue,
|
|
pluginConnectionActionsForDialog,
|
|
pluginConnectionConnectTimeoutDefault,
|
|
pluginConnectionFormValues,
|
|
pluginConnectionProviderIcon,
|
|
pluginConnectionProviderOptionValue,
|
|
} from "./frontendPlugin";
|
|
|
|
function installedPlugin(id: string, contributions: InstalledPlugin["manifest"]["contributions"] = []): InstalledPlugin {
|
|
return {
|
|
compatibility: { compatible: true },
|
|
manifest: {
|
|
id,
|
|
name: id,
|
|
version: "1.0.0",
|
|
drivers: [],
|
|
contributions,
|
|
},
|
|
};
|
|
}
|
|
|
|
function connectionProvider(overrides: Partial<PluginConnectionProviderContribution> = {}): PluginConnectionProviderContribution {
|
|
return {
|
|
type: "connection-provider",
|
|
id: "connection",
|
|
label: "Example",
|
|
database_type: "example",
|
|
fields: [
|
|
{ key: "host", label: "Host", type: "text", required: true },
|
|
{ key: "port", label: "Port", type: "number", default: 1234 },
|
|
{ key: "tls", label: "TLS", type: "boolean", default: false },
|
|
],
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
describe("FrontendPluginRegistry", () => {
|
|
it("migrates a config-bound secret on edit, preserves multiline values and removes the plaintext copy", () => {
|
|
const provider = connectionProvider({ fields: [{ key: "key", label: "Private key", type: "textarea", binding: "secret" }] });
|
|
const pem = "-----BEGIN PRIVATE KEY-----\nexample\n-----END PRIVATE KEY-----\n";
|
|
const existing = buildPluginConnectionConfig("example.plugin", connectionProvider({ fields: [] }), {});
|
|
existing.external_config = { key: pem, root: "/files" };
|
|
const values = pluginConnectionFormValues(provider, existing);
|
|
expect(values.key).toBe(pem);
|
|
|
|
const saved = buildPluginConnectionConfig("example.plugin", provider, values, existing);
|
|
expect(saved.connection_secrets?.key).toBe(pem);
|
|
expect(saved.external_config).toEqual({ root: "/files" });
|
|
expect(existing.external_config).toEqual({ key: pem, root: "/files" });
|
|
expect(pluginConnectionFormValues(provider, saved).key).toBe(pem);
|
|
|
|
existing.connection_secrets = { key: "newer secret" };
|
|
expect(pluginConnectionFormValues(provider, existing).key).toBe("newer secret");
|
|
const cleared = buildPluginConnectionConfig("example.plugin", provider, { key: "" }, existing);
|
|
expect(cleared.connection_secrets?.key).toBeUndefined();
|
|
expect(cleared.external_config).toEqual({ root: "/files" });
|
|
});
|
|
|
|
it("round-trips automatic ports as an empty input and preserves explicit custom ports", () => {
|
|
const provider = connectionProvider({ fields: [{ key: "port", label: "Port", type: "number", binding: "port" }] });
|
|
const automatic = buildPluginConnectionConfig("example.plugin", provider, {});
|
|
expect(automatic.port).toBe(0);
|
|
expect(pluginConnectionFormValues(provider, automatic).port).toBeUndefined();
|
|
const explicit = buildPluginConnectionConfig("example.plugin", provider, { port: 1636 });
|
|
expect(pluginConnectionFormValues(provider, explicit).port).toBe(1636);
|
|
});
|
|
|
|
it("preserves the save-password preference for plugin connections", () => {
|
|
const provider = connectionProvider({ fields: [] });
|
|
const defaultConfig = buildPluginConnectionConfig("example.plugin", provider, {});
|
|
expect(defaultConfig.save_password).toBe(true);
|
|
|
|
const transient = buildPluginConnectionConfig("example.plugin", provider, {}, { ...defaultConfig, save_password: false });
|
|
expect(transient.save_password).toBe(false);
|
|
});
|
|
|
|
it("materializes the provider's connect_timeout_secs default into the typed timeout", () => {
|
|
const provider = connectionProvider({
|
|
fields: [{ key: "connect_timeout_secs", label: "Connect timeout", type: "number", default: 30 }],
|
|
});
|
|
expect(pluginConnectionConnectTimeoutDefault(provider)).toBe(30);
|
|
expect(buildPluginConnectionConfig("example.plugin", provider, {}).connect_timeout_secs).toBe(30);
|
|
// An advanced-form value the user tuned is mirrored into the typed field too.
|
|
expect(buildPluginConnectionConfig("example.plugin", provider, { connect_timeout_secs: 60 }).connect_timeout_secs).toBe(60);
|
|
|
|
// Once the provider declares the field, its resolved value is the single
|
|
// source of truth: a stale typed value from before the declaration is
|
|
// healed to the declared default.
|
|
const existing = buildPluginConnectionConfig("example.plugin", connectionProvider({ fields: [] }), {});
|
|
existing.connect_timeout_secs = 7;
|
|
expect(buildPluginConnectionConfig("example.plugin", provider, {}, existing).connect_timeout_secs).toBe(30);
|
|
|
|
// Providers without the well-known field keep the generic 10s default.
|
|
const generic = connectionProvider({ fields: [] });
|
|
expect(pluginConnectionConnectTimeoutDefault(generic)).toBeUndefined();
|
|
expect(buildPluginConnectionConfig("example.plugin", generic, {}).connect_timeout_secs).toBe(10);
|
|
});
|
|
|
|
it("round-trips plugin connection provider picker values", () => {
|
|
const value = pluginConnectionProviderOptionValue("example/plugin", "ssh:main");
|
|
expect(parsePluginConnectionProviderOptionValue(value)).toEqual({ pluginId: "example/plugin", providerId: "ssh:main" });
|
|
expect(parsePluginConnectionProviderOptionValue("mysql")).toBeNull();
|
|
});
|
|
|
|
it("indexes declarative connection providers", () => {
|
|
const registry = createFrontendPluginRegistry([installedPlugin("com.example.plugin", [connectionProvider()])]);
|
|
|
|
expect(registry.listConnectionProviders()).toHaveLength(1);
|
|
expect(registry.listConnectionProviders()[0]?.contribution.database_type).toBe("example");
|
|
});
|
|
|
|
it("indexes workbench, connection provider, and filesystem contributions", () => {
|
|
const registry = createFrontendPluginRegistry([
|
|
installedPlugin("com.example.plugin", [
|
|
{
|
|
type: "connection-provider",
|
|
id: "example.connection",
|
|
label: "Example",
|
|
database_type: "example",
|
|
fields: [],
|
|
workbench: "example.main",
|
|
filesystem_provider: "example.files",
|
|
},
|
|
{ type: "workbench", id: "example.main", label: "Example Workbench" },
|
|
{ type: "filesystem-provider", id: "example.files", label: "Example Files", schemes: ["example"], root_uri: "example:/home", capabilities: ["read", "write"] },
|
|
]),
|
|
]);
|
|
|
|
expect(registry.listConnectionProviders()).toHaveLength(1);
|
|
expect(registry.listWorkbenches()[0]?.contribution.id).toBe("example.main");
|
|
expect(registry.listFilesystemProviders()[0]?.contribution.schemes).toEqual(["example"]);
|
|
expect(registry.listFilesystemProviders()[0]?.contribution.root_uri).toBe("example:/home");
|
|
expect(registry.listConnectionProviders()[0]?.contribution.filesystem_provider).toBe("example.files");
|
|
});
|
|
|
|
it("indexes result-view contributions", () => {
|
|
const registry = createFrontendPluginRegistry([installedPlugin("com.example.plugin", [{ type: "result-view", id: "example.graph", label: "Graph" }])]);
|
|
|
|
const views = registry.listResultViews();
|
|
expect(views).toHaveLength(1);
|
|
expect(views[0]?.contribution.id).toBe("example.graph");
|
|
expect(views[0]?.contribution.label).toBe("Graph");
|
|
});
|
|
|
|
it("resolves the plugin UI contribution behind a workbench or result-view tab", () => {
|
|
const registry = createFrontendPluginRegistry([
|
|
installedPlugin("com.example.plugin", [
|
|
{ type: "workbench", id: "example.main", label: "Example Workbench", icon: "assets/main.svg" },
|
|
{ type: "result-view", id: "example.graph", label: "Graph", icon: "assets/graph.svg" },
|
|
]),
|
|
]);
|
|
|
|
const workbench = registry.findUiContribution("com.example.plugin", "example.main");
|
|
expect(workbench?.contribution).toMatchObject({ type: "workbench", id: "example.main", label: "Example Workbench", icon: "assets/main.svg" });
|
|
|
|
// The result-view keeps its own id and display metadata: the plugin UI is
|
|
// told which declared contribution the user opened, and it is not a workbench.
|
|
const resultView = registry.findUiContribution("com.example.plugin", "example.graph");
|
|
expect(resultView?.contribution).toMatchObject({ type: "result-view", id: "example.graph", label: "Graph", icon: "assets/graph.svg" });
|
|
});
|
|
|
|
it("keeps workbench lookups scoped to workbench contributions", () => {
|
|
const registry = createFrontendPluginRegistry([
|
|
installedPlugin("com.example.plugin", [
|
|
{ type: "workbench", id: "example.main", label: "Example Workbench" },
|
|
{ type: "result-view", id: "example.graph", label: "Graph" },
|
|
]),
|
|
]);
|
|
|
|
// `findWorkbench` answers `host.openWorkbench` and `connection-provider.workbench`:
|
|
// a result-view id must never satisfy it.
|
|
expect(registry.findWorkbench("com.example.plugin", "example.graph")).toBeUndefined();
|
|
expect(registry.findWorkbench("com.example.plugin", "example.main")?.contribution.id).toBe("example.main");
|
|
});
|
|
|
|
it("does not resolve unknown, foreign, or non-UI contributions as plugin UI", () => {
|
|
const registry = createFrontendPluginRegistry([
|
|
installedPlugin("com.example.plugin", [
|
|
{ type: "result-view", id: "example.graph", label: "Graph" },
|
|
{ type: "context-menu", id: "example.inspect", label: "Inspect", menu: "connection" },
|
|
{ type: "filesystem-provider", id: "example.files", label: "Files", schemes: ["example"] },
|
|
]),
|
|
installedPlugin("com.example.other", []),
|
|
]);
|
|
|
|
expect(registry.findUiContribution("com.example.plugin", "example.graph")?.contribution.type).toBe("result-view");
|
|
expect(registry.findUiContribution("com.example.plugin", "example.missing")).toBeUndefined();
|
|
expect(registry.findUiContribution("com.example.other", "example.graph")).toBeUndefined();
|
|
// Context menus render natively and filesystem providers own their tab mode.
|
|
expect(registry.findUiContribution("com.example.plugin", "example.inspect")).toBeUndefined();
|
|
expect(registry.findUiContribution("com.example.plugin", "example.files")).toBeUndefined();
|
|
});
|
|
|
|
it("does not resolve plugin UI contributions of incompatible plugins", () => {
|
|
const plugin = installedPlugin("com.example.plugin", [
|
|
{ type: "workbench", id: "example.main", label: "Example Workbench" },
|
|
{ type: "result-view", id: "example.graph", label: "Graph" },
|
|
]);
|
|
plugin.compatibility = { compatible: false, errors: ["Unsupported host API"] };
|
|
|
|
const registry = createFrontendPluginRegistry([plugin]);
|
|
|
|
expect(registry.findUiContribution("com.example.plugin", "example.main")).toBeUndefined();
|
|
expect(registry.findUiContribution("com.example.plugin", "example.graph")).toBeUndefined();
|
|
});
|
|
|
|
it("keeps declarative context-menu actions as context-menu metadata, not commands", () => {
|
|
const registry = createFrontendPluginRegistry([
|
|
installedPlugin("com.example.plugin", [
|
|
{ type: "workbench", id: "example.main", label: "Example Workbench" },
|
|
{
|
|
type: "context-menu",
|
|
id: "example.open",
|
|
label: "Open Example",
|
|
menu: "connection",
|
|
action: { type: "open-workbench", workbench: "example.main" },
|
|
},
|
|
]),
|
|
]);
|
|
|
|
const item = registry.listContextMenuItems("connection")[0];
|
|
expect(item?.contribution.action).toEqual({ type: "open-workbench", workbench: "example.main" });
|
|
expect(registry.findWorkbench("com.example.plugin", "example.main")?.contribution.id).toBe("example.main");
|
|
expect(registry.findCommand("com.example.plugin", "example.open")).toBeUndefined();
|
|
expect(registry.listCommands()).toHaveLength(0);
|
|
});
|
|
|
|
it("indexes context-menu contributions per menu surface", () => {
|
|
const registry = createFrontendPluginRegistry([
|
|
installedPlugin("com.example.plugin", [
|
|
{ type: "context-menu", id: "example.inspect", label: "Inspect endpoint", menu: "connection" },
|
|
{ type: "context-menu", id: "example.inspect-table", label: "Inspect table", menu: "table" },
|
|
]),
|
|
]);
|
|
|
|
const connectionItems = registry.listContextMenuItems("connection");
|
|
expect(connectionItems).toHaveLength(1);
|
|
expect(connectionItems[0]?.contribution.id).toBe("example.inspect");
|
|
expect(connectionItems[0]?.contribution.action).toBeUndefined();
|
|
expect(connectionItems[0]?.plugin.manifest.id).toBe("com.example.plugin");
|
|
|
|
const tableItems = registry.listContextMenuItems("table");
|
|
expect(tableItems).toHaveLength(1);
|
|
expect(tableItems[0]?.contribution.id).toBe("example.inspect-table");
|
|
|
|
const emptyRegistry = createFrontendPluginRegistry([installedPlugin("com.example.empty")]);
|
|
expect(emptyRegistry.listContextMenuItems("table")).toHaveLength(0);
|
|
expect(registry.listContextMenuItems("missing")).toHaveLength(0);
|
|
});
|
|
|
|
it("prefers provider display metadata and falls back to plugin metadata", () => {
|
|
const explicit = installedPlugin("com.example.explicit", [
|
|
{
|
|
type: "connection-provider",
|
|
id: "explicit.connection",
|
|
label: "Explicit connection",
|
|
icon: "assets/provider.svg",
|
|
database_type: "explicit",
|
|
fields: [],
|
|
},
|
|
]);
|
|
explicit.manifest.name = "Explicit plugin";
|
|
explicit.manifest.icon = "assets/plugin.svg";
|
|
const fallback = installedPlugin("com.example.fallback", [
|
|
{
|
|
type: "connection-provider",
|
|
id: "fallback.connection",
|
|
label: "",
|
|
database_type: "fallback",
|
|
fields: [],
|
|
},
|
|
]);
|
|
fallback.manifest.name = "Fallback plugin";
|
|
fallback.manifest.icon = "assets/fallback.svg";
|
|
|
|
const registry = createFrontendPluginRegistry([explicit, fallback]);
|
|
const [explicitEntry, fallbackEntry] = registry.listConnectionProviders();
|
|
|
|
expect(explicitEntry?.contribution.label).toBe("Explicit connection");
|
|
expect(pluginConnectionProviderIcon(explicitEntry!)).toBe("assets/provider.svg");
|
|
expect(fallbackEntry?.contribution.label).toBe("Fallback plugin");
|
|
expect(pluginConnectionProviderIcon(fallbackEntry!)).toBe("assets/fallback.svg");
|
|
});
|
|
|
|
it("falls back to provider id and the generic icon when metadata is absent", () => {
|
|
const plugin = installedPlugin("com.example.minimal", [
|
|
{
|
|
type: "connection-provider",
|
|
id: "minimal.connection",
|
|
label: "",
|
|
database_type: "minimal",
|
|
fields: [],
|
|
},
|
|
]);
|
|
plugin.manifest.name = "";
|
|
|
|
const entry = createFrontendPluginRegistry([plugin]).listConnectionProviders()[0]!;
|
|
|
|
expect(entry.contribution.label).toBe("minimal.connection");
|
|
expect(pluginConnectionProviderIcon(entry)).toBeUndefined();
|
|
});
|
|
|
|
it("drops unsafe icon paths before rendering", () => {
|
|
const plugin = installedPlugin("com.example.unsafe", [
|
|
{
|
|
type: "connection-provider",
|
|
id: "unsafe.connection",
|
|
label: "Unsafe",
|
|
icon: "../outside.svg",
|
|
database_type: "unsafe",
|
|
fields: [],
|
|
},
|
|
// Every contribution the host renders through the plugin UI entrypoint
|
|
// resolves its icon asset path the same way.
|
|
{ type: "workbench", id: "unsafe.main", label: "Unsafe workbench", icon: "../outside.svg" },
|
|
{ type: "result-view", id: "unsafe.graph", label: "Unsafe graph", icon: "/outside.svg" },
|
|
]);
|
|
plugin.manifest.icon = "\\outside.svg";
|
|
|
|
const definition = createFrontendPluginRegistry([plugin]).listPlugins()[0]!;
|
|
const entry = createFrontendPluginRegistry([plugin]).listConnectionProviders()[0]!;
|
|
|
|
expect(definition.plugin.manifest.icon).toBeUndefined();
|
|
expect(pluginConnectionProviderIcon(entry)).toBeUndefined();
|
|
expect(createFrontendPluginRegistry([plugin]).listWorkbenches()[0]?.contribution.icon).toBeUndefined();
|
|
expect(createFrontendPluginRegistry([plugin]).listResultViews()[0]?.contribution.icon).toBeUndefined();
|
|
});
|
|
|
|
it("localizes plugin metadata, contributions, and form fields", () => {
|
|
const plugin = installedPlugin("com.example.plugin", [connectionProvider({ id: "example.connection", description: "English description" })]);
|
|
plugin.manifest.localizations = {
|
|
"zh-CN": {
|
|
name: "示例插件",
|
|
description: "插件说明",
|
|
contributions: {
|
|
"example.connection": {
|
|
label: "示例连接",
|
|
description: "连接说明",
|
|
fields: {
|
|
host: { label: "主机", placeholder: "请输入主机" },
|
|
},
|
|
},
|
|
},
|
|
},
|
|
};
|
|
|
|
const registry = createFrontendPluginRegistry([plugin], "zh-CN");
|
|
const definition = registry.listPlugins()[0]!;
|
|
const contribution = registry.listConnectionProviders()[0]!.contribution;
|
|
|
|
expect(definition.plugin.manifest.name).toBe("示例插件");
|
|
expect(definition.plugin.manifest.description).toBe("插件说明");
|
|
expect(contribution.label).toBe("示例连接");
|
|
expect(contribution.description).toBe("连接说明");
|
|
expect(contribution.fields[0]).toMatchObject({ label: "主机", placeholder: "请输入主机" });
|
|
expect(plugin.manifest.name).toBe("com.example.plugin");
|
|
});
|
|
|
|
it("normalizes connection actions in manifest order and localizes their labels", () => {
|
|
const plugin = installedPlugin("com.example.actions", [
|
|
{
|
|
type: "connection-provider",
|
|
id: "example.connection",
|
|
label: "Example",
|
|
database_type: "example",
|
|
fields: [],
|
|
capabilities: ["test"],
|
|
actions: [
|
|
{
|
|
id: "discover",
|
|
label: "Discover",
|
|
description: "Discover an endpoint",
|
|
variant: "outline",
|
|
requires_valid_form: false,
|
|
},
|
|
{ id: "edit", label: "Edit", variant: "secondary", when: "edit" },
|
|
],
|
|
},
|
|
]);
|
|
plugin.manifest.localizations = {
|
|
"zh-CN": {
|
|
contributions: {
|
|
"example.connection": {
|
|
actions: {
|
|
discover: { label: "发现地址", description: "自动发现连接地址" },
|
|
},
|
|
},
|
|
},
|
|
},
|
|
};
|
|
|
|
const actions = createFrontendPluginRegistry([plugin], "zh-CN").listConnectionProviders()[0]?.contribution.actions;
|
|
|
|
expect(actions?.map((action) => action.id)).toEqual(["discover", "edit"]);
|
|
expect(actions?.[0]).toMatchObject({
|
|
label: "发现地址",
|
|
description: "自动发现连接地址",
|
|
requires_valid_form: false,
|
|
});
|
|
expect(actions?.[1]).toMatchObject({ label: "Edit", variant: "secondary", when: "edit" });
|
|
});
|
|
|
|
it("treats omitted and explicitly empty custom action lists equivalently", () => {
|
|
const registry = createFrontendPluginRegistry([
|
|
installedPlugin("com.example.defaults", [{ type: "connection-provider", id: "default.connection", label: "Default", database_type: "default", fields: [] }]),
|
|
installedPlugin("com.example.empty", [{ type: "connection-provider", id: "empty.connection", label: "Empty", database_type: "empty", fields: [], actions: [] }]),
|
|
]);
|
|
|
|
const [defaults, empty] = registry.listConnectionProviders();
|
|
expect(defaults?.contribution.actions).toBeUndefined();
|
|
expect(empty?.contribution.actions).toEqual([]);
|
|
expect(pluginConnectionActionsForDialog(defaults!.contribution, false)).toEqual(pluginConnectionActionsForDialog(empty!.contribution, false));
|
|
});
|
|
|
|
it("builds compatible default footer actions and filters create/edit actions", () => {
|
|
const provider: PluginConnectionProviderContribution = {
|
|
type: "connection-provider",
|
|
id: "example.connection",
|
|
label: "Example",
|
|
database_type: "example",
|
|
fields: [],
|
|
capabilities: ["test"],
|
|
};
|
|
|
|
expect(pluginConnectionActionsForDialog(provider, false).map((action) => action.kind)).toEqual(["test", "save-and-connect"]);
|
|
expect(pluginConnectionActionsForDialog(provider, true).map((action) => action.kind)).toEqual(["test", "save"]);
|
|
expect(
|
|
pluginConnectionActionsForDialog(
|
|
{
|
|
...provider,
|
|
actions: [
|
|
{ id: "create", label: "Create", when: "create" },
|
|
{ id: "edit", label: "Edit", when: "edit" },
|
|
{ id: "always", label: "Always", when: "always" },
|
|
],
|
|
},
|
|
true,
|
|
).map((action) => action.id),
|
|
).toEqual(["edit", "always", "test", "save"]);
|
|
});
|
|
|
|
it("creates initial values only from declared defaults", () => {
|
|
const values = initialPluginFormValues(connectionProvider());
|
|
|
|
expect(values).toEqual({ port: 1234, tls: false });
|
|
expect(values).not.toHaveProperty("host");
|
|
});
|
|
|
|
it("treats a host-serialized null default as unset instead of a value", () => {
|
|
// Hosts before the manifest serialization fix sent `"default": null` for
|
|
// every field that declares no default, so an untouched password field
|
|
// turned into the four-character string "null" once it was saved.
|
|
const provider = connectionProvider({
|
|
fields: [
|
|
{ key: "sudo_password", label: "Sudo password", type: "password", binding: "secret", default: null },
|
|
{ key: "mode", label: "Mode", type: "text", binding: "config", default: null },
|
|
{ key: "read_only", label: "Read only", type: "boolean", binding: "config", default: false },
|
|
],
|
|
});
|
|
|
|
expect(initialPluginFormValues(provider)).toEqual({ read_only: false });
|
|
|
|
const config = buildPluginConnectionConfig("io.dbx.ssh", provider, {
|
|
sudo_password: null,
|
|
mode: null,
|
|
read_only: false,
|
|
} as unknown as Record<string, string>);
|
|
|
|
expect(config.connection_secrets?.sudo_password).toBeUndefined();
|
|
expect(config.external_config).toEqual({ read_only: false });
|
|
});
|
|
|
|
it("preserves opaque 'null' credentials when reopening and saving connections", () => {
|
|
const provider = connectionProvider({
|
|
fields: [
|
|
{ key: "sudo_password", label: "Sudo password", type: "password", binding: "secret" },
|
|
{ key: "totp_secret", label: "TOTP secret", type: "textarea", binding: "secret" },
|
|
{ key: "sudo_source", label: "Sudo source", type: "text", binding: "config" },
|
|
],
|
|
});
|
|
const existing = buildPluginConnectionConfig("io.dbx.ssh", provider, {});
|
|
existing.connection_secrets = { sudo_password: "null", totp_secret: "JBSWY3DPEHPK3PXP" };
|
|
existing.external_config = { sudo_source: "custom", stale: null };
|
|
|
|
const values = pluginConnectionFormValues(provider, existing);
|
|
|
|
expect(values.sudo_password).toBe("null");
|
|
expect(values.totp_secret).toBe("JBSWY3DPEHPK3PXP");
|
|
expect(values.stale).toBeUndefined();
|
|
expect(values.sudo_source).toBe("custom");
|
|
|
|
const saved = buildPluginConnectionConfig("io.dbx.ssh", provider, values, existing);
|
|
expect(saved.connection_secrets?.sudo_password).toBe("null");
|
|
expect(saved.connection_secrets?.totp_secret).toBe("JBSWY3DPEHPK3PXP");
|
|
});
|
|
|
|
it.each([undefined, "secret", "password"] as const)("round-trips explicit 'null' credentials with binding %s", (binding) => {
|
|
const provider = connectionProvider({ fields: [{ key: "credential", label: "Credential", type: "password", binding }] });
|
|
const saved = buildPluginConnectionConfig("example.plugin", provider, { credential: "null" });
|
|
expect(binding === "password" ? saved.password : saved.connection_secrets?.credential).toBe("null");
|
|
expect(pluginConnectionFormValues(provider, saved)).toEqual({ credential: "null" });
|
|
const reopened = buildPluginConnectionConfig("example.plugin", provider, pluginConnectionFormValues(provider, saved), saved);
|
|
expect(pluginConnectionFormValues(provider, reopened)).toEqual({ credential: "null" });
|
|
});
|
|
|
|
it("migrates an opaque 'null' credential from config to secret storage without losing it", () => {
|
|
const provider = connectionProvider({ fields: [{ key: "credential", label: "Credential", type: "password" }] });
|
|
const existing = buildPluginConnectionConfig("example.plugin", provider, {});
|
|
existing.external_config = { credential: "null" };
|
|
const values = pluginConnectionFormValues(provider, existing);
|
|
expect(values).toEqual({ credential: "null" });
|
|
const saved = buildPluginConnectionConfig("example.plugin", provider, values, existing);
|
|
expect(saved.connection_secrets).toEqual({ credential: "null" });
|
|
expect(saved.external_config).toEqual({});
|
|
});
|
|
|
|
it.each([null, undefined, ""])("keeps an unset credential %s absent without a default", (credential) => {
|
|
const provider = connectionProvider({ fields: [{ key: "credential", label: "Credential", type: "password" }] });
|
|
const existing = buildPluginConnectionConfig("example.plugin", provider, {});
|
|
existing.connection_secrets = { credential: "old-secret" };
|
|
const saved = buildPluginConnectionConfig("example.plugin", provider, { credential } as unknown as Record<string, PluginFormFieldValue>, existing);
|
|
expect(saved.connection_secrets).toEqual({});
|
|
expect(pluginConnectionFormValues(provider, saved)).toEqual({});
|
|
});
|
|
|
|
it("uses an explicit string default only for missing input, not a cleared input", () => {
|
|
const provider = connectionProvider({ fields: [{ key: "credential", label: "Credential", type: "password", default: "null" }] });
|
|
expect(initialPluginFormValues(provider)).toEqual({ credential: "null" });
|
|
expect(buildPluginConnectionConfig("example.plugin", provider, {}).connection_secrets).toEqual({ credential: "null" });
|
|
expect(buildPluginConnectionConfig("example.plugin", provider, { credential: null } as unknown as Record<string, PluginFormFieldValue>).connection_secrets).toEqual({});
|
|
expect(buildPluginConnectionConfig("example.plugin", provider, { credential: "" }).connection_secrets).toEqual({});
|
|
});
|
|
|
|
it("maps provider fields into common, config, and secret storage", () => {
|
|
const provider: PluginConnectionProviderContribution = {
|
|
type: "connection-provider",
|
|
id: "example.ssh",
|
|
label: "SSH",
|
|
database_type: "ssh",
|
|
fields: [
|
|
{ key: "display_name", label: "Name", type: "text", binding: "name" },
|
|
{ key: "host", label: "Host", type: "text", binding: "host" },
|
|
{ key: "port", label: "Port", type: "number", binding: "port", default: 22 },
|
|
{ key: "private_key", label: "Private key", type: "password" },
|
|
{ key: "keepalive", label: "Keepalive", type: "boolean", default: true },
|
|
],
|
|
};
|
|
|
|
const config = buildPluginConnectionConfig("example.plugin", provider, {
|
|
display_name: "Production SSH",
|
|
host: "example.com",
|
|
port: 2222,
|
|
private_key: "secret-key",
|
|
keepalive: false,
|
|
});
|
|
|
|
expect(config).toMatchObject({
|
|
name: "Production SSH",
|
|
db_type: "plugin",
|
|
host: "example.com",
|
|
port: 2222,
|
|
plugin_id: "example.plugin",
|
|
plugin_connection_provider: "example.ssh",
|
|
plugin_connection_type: "ssh",
|
|
external_config: { keepalive: false },
|
|
connection_secrets: { private_key: "secret-key" },
|
|
});
|
|
expect(pluginConnectionFormValues(provider, config)).toMatchObject({
|
|
display_name: "Production SSH",
|
|
host: "example.com",
|
|
port: 2222,
|
|
private_key: "secret-key",
|
|
keepalive: false,
|
|
});
|
|
});
|
|
|
|
it("builds from a reactive (non-structured-cloneable) existing config", () => {
|
|
// Connection configs reach the builder through props as Vue reactive
|
|
// proxies; structuredClone refuses them ("The object can not be cloned.").
|
|
const provider = connectionProvider({
|
|
id: "example.ssh",
|
|
database_type: "ssh",
|
|
fields: [{ key: "authentication", label: "Authentication", type: "select", binding: "config", default: "password", options: [] }],
|
|
});
|
|
const existing = {
|
|
id: "ssh-1",
|
|
external_config: new Proxy({ authentication: "private-key" }, {}),
|
|
} as unknown as Parameters<typeof buildPluginConnectionConfig>[3];
|
|
|
|
const config = buildPluginConnectionConfig("example.plugin", provider, { authentication: "private-key" }, existing);
|
|
|
|
expect(config.external_config).toEqual({ authentication: "private-key" });
|
|
expect(config.id).toBe("ssh-1");
|
|
});
|
|
});
|