xiaoxue_admin
/
dbx
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

chore(test): remove fragile database-type mapping tests

This commit is contained in:
t8y2 2026-06-18 12:15:10 +08:00
parent a2d4d52113
commit 4ebf041601
4 changed files with 1 additions and 236 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
packages/app-tests/databaseOptions.test.ts
View File

@ -1,35 +0,0 @@
import assert from "node:assert/strict";
import { test } from "vitest";
import { databaseOptionsForConnection } from "../../apps/desktop/src/composables/useDatabaseOptions.ts";
test("tree-schema connections include the default database when no catalogs are returned", () => {
assert.deepEqual(databaseOptionsForConnection([], { db_type: "saphana" }), [""]);
});
test("non tree-schema connections keep an empty database option list", () => {
assert.deepEqual(databaseOptionsForConnection([], { db_type: "mysql" }), []);
});
test("database options preserve returned catalogs when available", () => {
assert.deepEqual(databaseOptionsForConnection(["app", "analytics"], { db_type: "jdbc" }), ["app", "analytics"]);
});
test("database options respect visible database filters", () => {
assert.deepEqual(
databaseOptionsForConnection(["app", "analytics", "billing"], {
db_type: "mysql",
visible_databases: ["billing", "missing"],
}),
["billing"],
);
});
test("redis database options respect visible database filters", () => {
assert.deepEqual(
databaseOptionsForConnection(["0", "1", "2"], {
db_type: "redis",
visible_databases: ["2"],
}),
["2"],
);
});

49
packages/app-tests/databaseTree.test.ts
View File

@ -1,6 +1,6 @@
import assert from "node:assert/strict";
import { test } from "vitest";
import { buildDatabaseTreeNodes, buildDuckDbConnectionTreeNodes, sortSidebarNames, shouldIncludeDefaultDatabaseNode } from "../../apps/desktop/src/lib/databaseTree.ts";
import { buildDatabaseTreeNodes, sortSidebarNames } from "../../apps/desktop/src/lib/databaseTree.ts";
test("数据库节点按自然名称排序", () => {
const nodes = buildDatabaseTreeNodes("conn-1", [{ name: "db10" }, { name: "db2" }, { name: "campaign_data" }, { name: "cms" }, { name: "mk_campaign" }]);
@ -12,53 +12,6 @@ test("数据库节点按自然名称排序", () => {
assert.equal(nodes.find((node) => node.database === "mk_campaign")?.id, "conn-1:mk_campaign");
});
test("catalogless database metadata gets a visible default node", () => {
const nodes = buildDatabaseTreeNodes("conn-1", [{ name: " " }], { includeDefaultWhenEmpty: true });
assert.deepEqual(nodes, [
{
id: "conn-1:",
label: "tree.defaultDatabase",
type: "database",
connectionId: "conn-1",
database: "",
isExpanded: false,
children: [],
},
]);
});
test("tree schema mode can show a default node when no catalog is returned", () => {
const nodes = buildDatabaseTreeNodes("conn-1", [], { includeDefaultWhenEmpty: true });
assert.equal(nodes.length, 1);
assert.equal(nodes[0].database, "");
assert.equal(nodes[0].label, "tree.defaultDatabase");
});
test("MySQL-compatible catalogless services can opt into the default database node", () => {
assert.equal(shouldIncludeDefaultDatabaseNode({ db_type: "mysql" }, [{ name: "" }]), true);
assert.equal(shouldIncludeDefaultDatabaseNode({ db_type: "mysql" }, [{ name: "app" }]), false);
assert.equal(shouldIncludeDefaultDatabaseNode({ db_type: "postgres" }, [{ name: "" }]), false);
});
test("DuckDB shows primary catalog schemas directly under the connection", () => {
const nodes = buildDuckDbConnectionTreeNodes("conn-1", [{ name: "main" }, { name: "attached_reports" }, { name: "analytics_20" }, { name: "analytics_3" }], ["prod_sales", "main", "mysql"]);
assert.deepEqual(
nodes.map((node) => [node.type, node.label, node.database, node.schema]),
[
["schema", "main", "main", "main"],
["schema", "mysql", "main", "mysql"],
["schema", "prod_sales", "main", "prod_sales"],
["database", "analytics_3", "analytics_3", undefined],
["database", "analytics_20", "analytics_20", undefined],
["database", "attached_reports", "attached_reports", undefined],
],
);
assert.equal(nodes.find((node) => node.label === "mysql")?.id, "conn-1:main:mysql");
});
test("sidebar name sorting uses numeric-aware ordering", () => {
assert.deepEqual(sortSidebarNames(["db10", "db2", "db1"]), ["db1", "db2", "db10"]);
});

93
packages/app-tests/jdbcDialect.test.ts
View File

@ -1,93 +0,0 @@
import assert from "node:assert/strict";
import { test } from "vitest";
import { connectionObjectTreeNodeSchema, connectionObjectTreeQuerySchema, connectionUsesSchemaExecutionContext, connectionUsesDatabaseObjectTreeMode, effectiveDatabaseTypeForConnection, inferJdbcDialect, tableStructureDatabaseTypeForConnection } from "../../apps/desktop/src/lib/jdbcDialect.ts";
import { supportsTableStructureEditing } from "../../apps/desktop/src/lib/databaseFeatureSupport.ts";
import { qualifiedTableName } from "../../apps/desktop/src/lib/tableSelectSql.ts";
test("infers JDBC dialect from URL, driver class, and driver jar path", () => {
assert.equal(inferJdbcDialect({ db_type: "jdbc", connection_string: "jdbc:mysql://db.example.com:9030/demo" }), "mysql");
assert.equal(inferJdbcDialect({ db_type: "jdbc", jdbc_driver_class: "org.apache.kyuubi.jdbc.KyuubiHiveDriver" }), "mysql");
assert.equal(inferJdbcDialect({ db_type: "jdbc", jdbc_driver_class: "org.apache.hive.jdbc.HiveDriver" }), "hive");
assert.equal(inferJdbcDialect({ db_type: "jdbc", jdbc_driver_paths: ["/drivers/starrocks-jdbc.jar"] }), "starrocks");
assert.equal(inferJdbcDialect({ db_type: "jdbc", connection_string: "jdbc:databend://db.example.com:8000/default" }), "databend");
});
test("effective database type keeps non-JDBC types and enables compatible JDBC structure editing", () => {
assert.equal(effectiveDatabaseTypeForConnection({ db_type: "postgres" }), "postgres");
assert.equal(effectiveDatabaseTypeForConnection({ db_type: "jdbc" }), "jdbc");
assert.equal(effectiveDatabaseTypeForConnection({ db_type: "gbase", driver_profile: "gbase8s" }), "informix");
assert.equal(effectiveDatabaseTypeForConnection({ db_type: "gbase", driver_profile: "gbase8a" }), "mysql");
assert.equal(tableStructureDatabaseTypeForConnection({ db_type: "gbase", driver_profile: "gbase8a" }), "gbase");
assert.equal(tableStructureDatabaseTypeForConnection({ db_type: "gbase", driver_profile: "gbase8s" }), "informix");
assert.equal(
effectiveDatabaseTypeForConnection({
db_type: "jdbc",
jdbc_driver_class: "org.apache.kyuubi.jdbc.KyuubiHiveDriver",
}),
"mysql",
);
assert.equal(
supportsTableStructureEditing(
effectiveDatabaseTypeForConnection({
db_type: "jdbc",
jdbc_driver_class: "org.apache.kyuubi.jdbc.KyuubiHiveDriver",
}),
),
true,
);
assert.equal(supportsTableStructureEditing(effectiveDatabaseTypeForConnection({ db_type: "jdbc" })), false);
});
test("JDBC tree shape follows the inferred driver dialect", () => {
const kyuubi = { db_type: "jdbc" as const, jdbc_driver_class: "org.apache.kyuubi.jdbc.KyuubiHiveDriver" };
const hive = { db_type: "jdbc" as const, jdbc_driver_class: "org.apache.hive.jdbc.HiveDriver" };
const db2 = { db_type: "jdbc" as const, connection_string: "jdbc:db2://db.example.com:50000/SAMPLE" };
assert.equal(connectionUsesDatabaseObjectTreeMode(kyuubi), true);
assert.equal(connectionObjectTreeQuerySchema(kyuubi, "test", undefined), "");
assert.equal(connectionUsesDatabaseObjectTreeMode(hive), false);
assert.equal(connectionObjectTreeQuerySchema(hive, "spark_catalog", "test"), "test");
assert.equal(connectionUsesDatabaseObjectTreeMode(db2), false);
assert.equal(connectionObjectTreeQuerySchema(db2, "SAMPLE", "APP"), "APP");
assert.equal(connectionObjectTreeNodeSchema(db2, "SAMPLE", "APP"), "APP");
assert.equal(
qualifiedTableName({
databaseType: effectiveDatabaseTypeForConnection(hive),
schema: connectionObjectTreeQuerySchema(hive, "spark_catalog", "test"),
tableName: "dws_event_analyse",
}),
"`test`.`dws_event_analyse`",
);
});
test("GBase profiles use their compatible object tree shapes", () => {
const gbase8a = { db_type: "gbase" as const, driver_profile: "gbase8a" };
const gbase8s = { db_type: "gbase" as const, driver_profile: "gbase8s" };
assert.equal(connectionUsesDatabaseObjectTreeMode(gbase8a), false);
assert.equal(connectionObjectTreeQuerySchema(gbase8a, "testdb", undefined), "testdb");
assert.equal(connectionObjectTreeNodeSchema(gbase8a, "testdb", undefined), "testdb");
assert.equal(connectionUsesDatabaseObjectTreeMode(gbase8s), false);
assert.equal(connectionObjectTreeQuerySchema(gbase8s, "testdb", "gbasedbt"), "gbasedbt");
assert.equal(connectionObjectTreeNodeSchema(gbase8s, "testdb", "gbasedbt"), "gbasedbt");
assert.equal(connectionObjectTreeQuerySchema(gbase8s, "testdb", undefined), "testdb");
assert.equal(connectionObjectTreeNodeSchema(gbase8s, "testdb", undefined), "testdb");
});
test("Databend JDBC keeps database as schema context for table data", () => {
const databend = { db_type: "jdbc" as const, connection_string: "jdbc:databend://db.example.com:8000/dbx_test" };
assert.equal(effectiveDatabaseTypeForConnection(databend), "databend");
assert.equal(connectionUsesDatabaseObjectTreeMode(databend), true);
assert.equal(connectionUsesSchemaExecutionContext(databend), true);
assert.equal(connectionObjectTreeQuerySchema(databend, "dbx_test", undefined), "dbx_test");
assert.equal(connectionObjectTreeNodeSchema(databend, "dbx_test", undefined), "dbx_test");
assert.equal(
qualifiedTableName({
databaseType: effectiveDatabaseTypeForConnection(databend),
schema: connectionObjectTreeNodeSchema(databend, "dbx_test", undefined),
tableName: "jdbc_probe",
}),
"`dbx_test`.`jdbc_probe`",
);
});

60
packages/app-tests/visibleDatabases.test.ts
View File

@ -1,60 +0,0 @@
import { strict as assert } from "node:assert";
import { test } from "vitest";
import { filterDatabaseNamesForConnection, filterVisibleDatabaseNames, isSystemDatabaseName, canSaveVisibleDatabaseSelection, normalizeVisibleDatabaseSelection, visibleDatabaseFilterIsEnabled } from "../../apps/desktop/src/lib/visibleDatabases.ts";
test("undefined visible database filter keeps every database", () => {
assert.deepEqual(filterVisibleDatabaseNames(["app", "analytics"], undefined), ["app", "analytics"]);
assert.equal(visibleDatabaseFilterIsEnabled(undefined), false);
});
test("configured visible database filter keeps selected databases in source order", () => {
assert.deepEqual(filterVisibleDatabaseNames(["app", "analytics", "billing"], ["billing", "app"]), ["app", "billing"]);
assert.equal(visibleDatabaseFilterIsEnabled(["billing", "app"]), true);
});
test("empty configured visible database filter hides every database", () => {
assert.deepEqual(filterVisibleDatabaseNames(["app", "analytics"], []), []);
assert.equal(visibleDatabaseFilterIsEnabled([]), true);
});
test("empty visible database selection cannot be saved", () => {
assert.equal(canSaveVisibleDatabaseSelection(["app"]), true);
assert.equal(canSaveVisibleDatabaseSelection([]), false);
});
test("normalizes selected database names against fresh database names", () => {
assert.deepEqual(normalizeVisibleDatabaseSelection(["billing", "missing", "app", "app"], ["app", "billing"]), ["billing", "app"]);
});
test("mysql system databases are hidden by default but can be explicitly selected", () => {
const databases = ["app", "information_schema", "mysql", "performance_schema", "sys"];
assert.deepEqual(filterDatabaseNamesForConnection(databases, { db_type: "mysql" }), ["app"]);
assert.deepEqual(filterDatabaseNamesForConnection(databases, { db_type: "manticoresearch" }), ["app"]);
assert.deepEqual(filterDatabaseNamesForConnection(databases, { db_type: "mysql", visible_databases: ["app", "sys"] }), ["app", "sys"]);
assert.equal(isSystemDatabaseName("mysql", "performance_schema"), true);
assert.equal(isSystemDatabaseName("manticoresearch", "information_schema"), true);
assert.equal(isSystemDatabaseName("postgres", "information_schema"), false);
});
test("gbase8s does not inherit base gbase system database filtering", () => {
const databases = ["app", "information_schema", "mysql", "performance_schema", "sys"];
assert.deepEqual(filterDatabaseNamesForConnection(databases, { db_type: "gbase" }), ["app"]);
assert.deepEqual(filterDatabaseNamesForConnection(databases, { db_type: "gbase", driver_profile: "gbase8s" }), databases);
});
test("system database detection is registered per database type", () => {
assert.deepEqual(filterDatabaseNamesForConnection(["default", "system"], { db_type: "clickhouse" }), ["default"]);
assert.deepEqual(filterDatabaseNamesForConnection(["master", "app", "tempdb"], { db_type: "sqlserver" }), ["app"]);
assert.equal(isSystemDatabaseName("clickhouse", "INFORMATION_SCHEMA"), true);
assert.equal(isSystemDatabaseName("sqlserver", "msdb"), true);
});
test("system database registry covers common database families", () => {
assert.deepEqual(filterDatabaseNamesForConnection(["template0", "app"], { db_type: "postgres" }), ["app"]);
assert.deepEqual(filterDatabaseNamesForConnection(["admin", "shop", "local"], { db_type: "mongodb" }), ["shop"]);
assert.deepEqual(filterDatabaseNamesForConnection(["SYS", "HR", "SYSTEM"], { db_type: "oracle" }), ["HR"]);
assert.deepEqual(filterDatabaseNamesForConnection(["_SYS_BIC", "SALES"], { db_type: "saphana" }), ["SALES"]);
assert.deepEqual(filterDatabaseNamesForConnection(["system_schema", "app"], { db_type: "cassandra" }), ["app"]);
assert.deepEqual(filterDatabaseNamesForConnection(["system", "neo4j"], { db_type: "neo4j" }), ["neo4j"]);
assert.deepEqual(filterDatabaseNamesForConnection(["SNOWFLAKE", "ANALYTICS"], { db_type: "snowflake" }), ["ANALYTICS"]);
});