mirror of
https://github.com/t8y2/dbx.git
synced 2026-10-21 06:00:39 +00:00
chore: remove brittle registry tests
This commit is contained in:
t8y2
@@ -1,61 +0,0 @@
|
||||
import { test } from "vitest";
|
||||
import assert from "node:assert/strict";
|
||||
import { connectionUrlPlaceholder } from "../../apps/desktop/src/lib/connectionPresentation.ts";
|
||||
|
||||
const expected: Record<string, string> = {
|
||||
mysql: "mysql://user:password@host:port/database",
|
||||
doris: "mysql://user:password@host:port/database",
|
||||
starrocks: "mysql://user:password@host:port/database",
|
||||
manticoresearch: "mysql://user:password@host:port/database",
|
||||
postgres: "postgresql://user:password@host:port/database",
|
||||
gaussdb: "postgresql://user:password@host:port/database",
|
||||
kwdb: "postgresql://user:password@host:port/database",
|
||||
redshift: "postgresql://user:password@host:port/database",
|
||||
redis: "redis://:password@host:port/0",
|
||||
sqlite: "sqlite:///absolute/path/to/database.db",
|
||||
rqlite: "http://user:password@host:4001",
|
||||
duckdb: "duckdb:///absolute/path/to/database.duckdb",
|
||||
access: "jdbc:ucanaccess:///absolute/path/to/database.accdb",
|
||||
mongodb: "mongodb://user:password@host:port/database",
|
||||
clickhouse: "clickhouse://user:password@host:port/database",
|
||||
sqlserver: "mssql://user:password@host:port/database",
|
||||
oracle: "oracle://user:password@host:port/service_name",
|
||||
elasticsearch: "http://user:password@host:port",
|
||||
dameng: "dm://user:password@host:port",
|
||||
tdengine: "tdengine://user:password@host:6041/database",
|
||||
xugu: "xugu://user:password@host:5138/database",
|
||||
iotdb: "iotdb://user:password@host:6667/root.test",
|
||||
bigquery: "bigquery://https://www.googleapis.com/bigquery/v2:443/project-id",
|
||||
jdbc: "jdbc:mysql://host:3306/database",
|
||||
};
|
||||
|
||||
for (const [dbType, placeholder] of Object.entries(expected)) {
|
||||
test(`returns correct placeholder for ${dbType}`, () => {
|
||||
assert.equal(connectionUrlPlaceholder(dbType as any), placeholder);
|
||||
});
|
||||
}
|
||||
|
||||
test("falls back to postgresql placeholder for unknown type", () => {
|
||||
assert.equal(connectionUrlPlaceholder("unknown" as any), "postgresql://user:password@host:port/database");
|
||||
});
|
||||
|
||||
test("mysql-family types share the same placeholder", () => {
|
||||
const mysql = connectionUrlPlaceholder("mysql");
|
||||
assert.equal(connectionUrlPlaceholder("doris"), mysql);
|
||||
assert.equal(connectionUrlPlaceholder("starrocks"), mysql);
|
||||
assert.equal(connectionUrlPlaceholder("manticoresearch"), mysql);
|
||||
});
|
||||
|
||||
test("postgres-family types share the same placeholder", () => {
|
||||
const postgres = connectionUrlPlaceholder("postgres");
|
||||
assert.equal(connectionUrlPlaceholder("gaussdb"), postgres);
|
||||
assert.equal(connectionUrlPlaceholder("kwdb"), postgres);
|
||||
assert.equal(connectionUrlPlaceholder("redshift"), postgres);
|
||||
});
|
||||
|
||||
test("each placeholder starts with the expected scheme", () => {
|
||||
for (const [dbType, placeholder] of Object.entries(expected)) {
|
||||
const scheme = placeholder.split("://")[0];
|
||||
assert.ok(scheme.length > 0, `${dbType} placeholder should have a scheme`);
|
||||
}
|
||||
});
|
||||
@@ -1,6 +1,6 @@
|
||||
import assert from "node:assert/strict";
|
||||
import { test } from "vitest";
|
||||
import { buildDraftVisibleDatabasesConnectionId, connectionCanChooseVisibleDatabases, visibleDatabaseSelectionIsStale, initialVisibleDatabaseSelection } from "../../apps/desktop/src/lib/connectionVisibleDatabases.ts";
|
||||
import { buildDraftVisibleDatabasesConnectionId, visibleDatabaseSelectionIsStale, initialVisibleDatabaseSelection } from "../../apps/desktop/src/lib/connectionVisibleDatabases.ts";
|
||||
import type { ConnectionConfig } from "../../apps/desktop/src/types/database.ts";
|
||||
|
||||
function config(overrides: Partial<ConnectionConfig> = {}): ConnectionConfig {
|
||||
@@ -40,15 +40,6 @@ test("draft visible database connection ids are namespaced", () => {
|
||||
assert.equal(buildDraftVisibleDatabasesConnectionId("abc"), "__visible_draft_abc");
|
||||
});
|
||||
|
||||
test("visible databases can be chosen for catalog-like connections only", () => {
|
||||
assert.equal(connectionCanChooseVisibleDatabases({ db_type: "mysql" }), true);
|
||||
assert.equal(connectionCanChooseVisibleDatabases({ db_type: "redis" }), true);
|
||||
assert.equal(connectionCanChooseVisibleDatabases({ db_type: "mongodb" }), true);
|
||||
assert.equal(connectionCanChooseVisibleDatabases({ db_type: "oracle" }), true);
|
||||
assert.equal(connectionCanChooseVisibleDatabases({ db_type: "elasticsearch" }), false);
|
||||
assert.equal(connectionCanChooseVisibleDatabases({ db_type: "etcd" }), false);
|
||||
});
|
||||
|
||||
test("initial selection uses configured visible databases when available", () => {
|
||||
assert.deepEqual(initialVisibleDatabaseSelection(["app", "analytics", "billing"], ["billing", "missing"]), ["billing"]);
|
||||
});
|
||||
|
||||
@@ -1,333 +0,0 @@
|
||||
import assert from "node:assert/strict";
|
||||
import { test } from "vitest";
|
||||
import {
|
||||
SCHEMA_AWARE_TYPES,
|
||||
TREE_SCHEMA_TYPES,
|
||||
databaseProductCapabilities,
|
||||
databaseSupportLevel,
|
||||
databaseObjectTreeNodeSchema,
|
||||
databaseObjectTreeQuerySchema,
|
||||
getDatabaseCapability,
|
||||
manifestDatabaseTypes,
|
||||
sidebarObjectKindsForDatabase,
|
||||
supportsDatabaseCreation,
|
||||
supportsDatabaseSearch,
|
||||
supportsDriverManagement,
|
||||
supportsFieldLineage,
|
||||
supportsObjectBrowser,
|
||||
supportsObjectBrowserTreeNode,
|
||||
supportsSchemaDiagram,
|
||||
supportsSqlFileExecution,
|
||||
supportsTableImport,
|
||||
supportsTableTruncate,
|
||||
supportsTableStructureEditing,
|
||||
supportsTransfer,
|
||||
usesDatabaseObjectTreeMode,
|
||||
usesPostgresLikeStructureCopy,
|
||||
usesTreeSchemaMode,
|
||||
} from "../../apps/desktop/src/lib/databaseCapabilities.ts";
|
||||
|
||||
test("treats Trino catalogs as schema tree roots", () => {
|
||||
assert.equal(TREE_SCHEMA_TYPES.has("trino"), true);
|
||||
});
|
||||
|
||||
test("treats DB2 databases as schema tree roots", () => {
|
||||
assert.equal(TREE_SCHEMA_TYPES.has("db2"), true);
|
||||
assert.equal(usesTreeSchemaMode("db2"), true);
|
||||
});
|
||||
|
||||
test("treats TDengine databases as schema tree roots and agent driver databases", () => {
|
||||
assert.equal(TREE_SCHEMA_TYPES.has("tdengine"), true);
|
||||
assert.equal(SCHEMA_AWARE_TYPES.has("tdengine"), true);
|
||||
assert.equal(supportsDriverManagement("tdengine"), true);
|
||||
});
|
||||
|
||||
test("treats XuguDB as a schema-aware agent driver database", () => {
|
||||
assert.equal(TREE_SCHEMA_TYPES.has("xugu"), true);
|
||||
assert.equal(SCHEMA_AWARE_TYPES.has("xugu"), true);
|
||||
assert.equal(supportsDatabaseSearch("xugu"), true);
|
||||
assert.equal(supportsDriverManagement("xugu"), true);
|
||||
});
|
||||
|
||||
test("treats IoTDB as a schema-aware agent driver database", () => {
|
||||
assert.equal(TREE_SCHEMA_TYPES.has("iotdb"), true);
|
||||
assert.equal(SCHEMA_AWARE_TYPES.has("iotdb"), true);
|
||||
assert.equal(supportsDatabaseSearch("iotdb"), true);
|
||||
assert.equal(supportsDriverManagement("iotdb"), true);
|
||||
});
|
||||
|
||||
test("treats Access as a local single-database agent driver", () => {
|
||||
assert.equal(SCHEMA_AWARE_TYPES.has("access"), false);
|
||||
assert.equal(supportsDriverManagement("access"), true);
|
||||
assert.equal(supportsDatabaseSearch("access"), true);
|
||||
assert.equal(supportsTableImport("access"), true);
|
||||
});
|
||||
|
||||
test("exposes the extended JDBC agent ecosystem through driver management", () => {
|
||||
for (const dbType of ["databricks", "saphana", "teradata", "vertica", "firebird", "exasol", "opengauss", "oceanbase-oracle", "gbase", "questdb"] as const) {
|
||||
assert.equal(supportsDriverManagement(dbType), true, `${dbType} should be agent-managed`);
|
||||
assert.equal(supportsDatabaseSearch(dbType), true, `${dbType} should support database search`);
|
||||
}
|
||||
|
||||
assert.equal(SCHEMA_AWARE_TYPES.has("databricks"), true);
|
||||
assert.equal(SCHEMA_AWARE_TYPES.has("opengauss"), true);
|
||||
assert.equal(SCHEMA_AWARE_TYPES.has("oceanbase-oracle"), true);
|
||||
assert.equal(SCHEMA_AWARE_TYPES.has("firebird"), false);
|
||||
});
|
||||
|
||||
test("describes schema tree mode through the capability helper", () => {
|
||||
assert.equal(usesTreeSchemaMode("trino"), true);
|
||||
assert.equal(usesTreeSchemaMode("h2"), true);
|
||||
assert.equal(usesTreeSchemaMode("mysql"), false);
|
||||
assert.equal(usesTreeSchemaMode(undefined), false);
|
||||
});
|
||||
|
||||
test("generic JDBC database nodes list objects directly under catalogs", () => {
|
||||
assert.equal(TREE_SCHEMA_TYPES.has("jdbc"), true);
|
||||
assert.equal(usesDatabaseObjectTreeMode("jdbc"), true);
|
||||
assert.equal(databaseObjectTreeQuerySchema("jdbc", "test"), "");
|
||||
assert.equal(databaseObjectTreeNodeSchema("jdbc", "test"), undefined);
|
||||
assert.equal(databaseObjectTreeQuerySchema("jdbc", "test", "dataeye_starpony"), "");
|
||||
assert.equal(databaseObjectTreeNodeSchema("jdbc", "test", "dataeye_starpony"), undefined);
|
||||
});
|
||||
|
||||
test("schema tree databases still use database nodes as default schema context", () => {
|
||||
assert.equal(usesDatabaseObjectTreeMode("postgres"), false);
|
||||
assert.equal(databaseObjectTreeQuerySchema("postgres", "app"), "app");
|
||||
assert.equal(databaseObjectTreeNodeSchema("postgres", "app"), "app");
|
||||
});
|
||||
|
||||
test("treats Trino tables as schema-qualified SQL targets", () => {
|
||||
assert.equal(SCHEMA_AWARE_TYPES.has("trino"), true);
|
||||
});
|
||||
|
||||
test("describes table editing capabilities for special database engines", () => {
|
||||
assert.deepEqual(getDatabaseCapability("hive").tableData, {
|
||||
insert: true,
|
||||
updateRequiresPrimaryKey: false,
|
||||
deleteRequiresPrimaryKey: false,
|
||||
keylessRowPredicate: true,
|
||||
requiresTransactionalTableForExistingRows: true,
|
||||
transaction: false,
|
||||
});
|
||||
|
||||
assert.deepEqual(getDatabaseCapability("dameng").tableData, {
|
||||
insert: true,
|
||||
updateRequiresPrimaryKey: false,
|
||||
deleteRequiresPrimaryKey: false,
|
||||
keylessRowPredicate: true,
|
||||
requiresTransactionalTableForExistingRows: false,
|
||||
transaction: true,
|
||||
});
|
||||
|
||||
assert.deepEqual(getDatabaseCapability("trino").tableData, {
|
||||
insert: true,
|
||||
updateRequiresPrimaryKey: true,
|
||||
deleteRequiresPrimaryKey: true,
|
||||
keylessRowPredicate: false,
|
||||
requiresTransactionalTableForExistingRows: false,
|
||||
transaction: false,
|
||||
});
|
||||
|
||||
assert.deepEqual(getDatabaseCapability("manticoresearch").tableData, {
|
||||
insert: true,
|
||||
updateRequiresPrimaryKey: false,
|
||||
deleteRequiresPrimaryKey: false,
|
||||
keylessRowPredicate: true,
|
||||
requiresTransactionalTableForExistingRows: false,
|
||||
transaction: false,
|
||||
});
|
||||
|
||||
assert.deepEqual(getDatabaseCapability("jdbc").tableData, {
|
||||
insert: false,
|
||||
updateRequiresPrimaryKey: true,
|
||||
deleteRequiresPrimaryKey: true,
|
||||
keylessRowPredicate: false,
|
||||
requiresTransactionalTableForExistingRows: false,
|
||||
transaction: false,
|
||||
});
|
||||
|
||||
assert.deepEqual(getDatabaseCapability("yashandb").tableData, {
|
||||
insert: true,
|
||||
updateRequiresPrimaryKey: false,
|
||||
deleteRequiresPrimaryKey: false,
|
||||
keylessRowPredicate: true,
|
||||
requiresTransactionalTableForExistingRows: false,
|
||||
transaction: true,
|
||||
});
|
||||
|
||||
assert.equal(getDatabaseCapability("oracle").syntheticKey, "oracle-rowid");
|
||||
assert.equal(getDatabaseCapability("neo4j").syntheticKey, "neo4j-element-id");
|
||||
});
|
||||
|
||||
test("uses Navicat-style table editing defaults for updateable SQL table engines", () => {
|
||||
assert.deepEqual(getDatabaseCapability("postgres").tableData, {
|
||||
insert: true,
|
||||
updateRequiresPrimaryKey: false,
|
||||
deleteRequiresPrimaryKey: false,
|
||||
keylessRowPredicate: true,
|
||||
requiresTransactionalTableForExistingRows: false,
|
||||
transaction: true,
|
||||
});
|
||||
assert.deepEqual(getDatabaseCapability("mysql").tableData, {
|
||||
insert: true,
|
||||
updateRequiresPrimaryKey: false,
|
||||
deleteRequiresPrimaryKey: false,
|
||||
keylessRowPredicate: true,
|
||||
requiresTransactionalTableForExistingRows: false,
|
||||
transaction: true,
|
||||
});
|
||||
assert.deepEqual(getDatabaseCapability("sqlite").tableData, {
|
||||
insert: true,
|
||||
updateRequiresPrimaryKey: false,
|
||||
deleteRequiresPrimaryKey: false,
|
||||
keylessRowPredicate: true,
|
||||
requiresTransactionalTableForExistingRows: false,
|
||||
transaction: true,
|
||||
});
|
||||
assert.deepEqual(getDatabaseCapability("rqlite").tableData, {
|
||||
insert: true,
|
||||
updateRequiresPrimaryKey: false,
|
||||
deleteRequiresPrimaryKey: false,
|
||||
keylessRowPredicate: true,
|
||||
requiresTransactionalTableForExistingRows: false,
|
||||
transaction: true,
|
||||
});
|
||||
assert.deepEqual(getDatabaseCapability("kwdb").tableData, {
|
||||
insert: true,
|
||||
updateRequiresPrimaryKey: false,
|
||||
deleteRequiresPrimaryKey: false,
|
||||
keylessRowPredicate: true,
|
||||
requiresTransactionalTableForExistingRows: false,
|
||||
transaction: true,
|
||||
});
|
||||
assert.deepEqual(getDatabaseCapability("databend").tableData, {
|
||||
insert: true,
|
||||
updateRequiresPrimaryKey: false,
|
||||
deleteRequiresPrimaryKey: false,
|
||||
keylessRowPredicate: true,
|
||||
requiresTransactionalTableForExistingRows: false,
|
||||
transaction: true,
|
||||
});
|
||||
});
|
||||
|
||||
test("keeps conservative table editing defaults for unknown database types", () => {
|
||||
assert.deepEqual(getDatabaseCapability(undefined).tableData, {
|
||||
insert: false,
|
||||
updateRequiresPrimaryKey: true,
|
||||
deleteRequiresPrimaryKey: true,
|
||||
keylessRowPredicate: false,
|
||||
requiresTransactionalTableForExistingRows: false,
|
||||
transaction: true,
|
||||
});
|
||||
});
|
||||
|
||||
test("describes feature support through capability helpers", () => {
|
||||
assert.equal(supportsSqlFileExecution("mysql"), true);
|
||||
assert.equal(supportsSqlFileExecution("redis"), false);
|
||||
assert.equal(supportsSchemaDiagram("oracle"), true);
|
||||
assert.equal(supportsSchemaDiagram("trino"), false);
|
||||
assert.equal(supportsDatabaseSearch("neo4j"), true);
|
||||
assert.equal(supportsDatabaseSearch("redis"), false);
|
||||
assert.equal(supportsTableImport("duckdb"), true);
|
||||
assert.equal(supportsTableImport("hive"), false);
|
||||
assert.equal(supportsTableStructureEditing("postgres"), true);
|
||||
assert.equal(supportsTableStructureEditing("duckdb"), true);
|
||||
assert.equal(supportsTableStructureEditing("oracle"), true);
|
||||
assert.equal(supportsTableStructureEditing("dameng"), true);
|
||||
assert.equal(supportsTableStructureEditing("gaussdb"), true);
|
||||
assert.equal(supportsTableStructureEditing("kwdb"), true);
|
||||
assert.equal(supportsTableStructureEditing("opengauss"), true);
|
||||
assert.equal(supportsTableStructureEditing("redshift"), true);
|
||||
assert.equal(supportsTableStructureEditing("clickhouse"), true);
|
||||
assert.equal(supportsTableStructureEditing("gbase"), true);
|
||||
assert.equal(supportsTableStructureEditing("informix"), true);
|
||||
assert.equal(supportsTableStructureEditing("rqlite"), true);
|
||||
assert.equal(supportsTableStructureEditing("mongodb"), false);
|
||||
assert.equal(supportsTableStructureEditing("manticoresearch"), true);
|
||||
assert.equal(supportsDatabaseCreation("clickhouse"), true);
|
||||
assert.equal(supportsDatabaseCreation("manticoresearch"), false);
|
||||
assert.equal(supportsDatabaseCreation("sqlite"), false);
|
||||
assert.equal(supportsFieldLineage("gaussdb"), true);
|
||||
assert.equal(supportsFieldLineage("kwdb"), true);
|
||||
assert.equal(supportsFieldLineage("trino"), false);
|
||||
assert.equal(supportsTransfer("duckdb"), true);
|
||||
assert.equal(supportsTransfer("hive"), true);
|
||||
assert.equal(supportsTransfer("mongodb"), true);
|
||||
assert.equal(supportsTransfer("manticoresearch"), false);
|
||||
assert.equal(supportsDriverManagement("oracle"), true);
|
||||
assert.equal(supportsDriverManagement("mysql"), false);
|
||||
assert.equal(supportsDriverManagement("manticoresearch"), false);
|
||||
assert.equal(supportsDriverManagement("kwdb"), false);
|
||||
assert.equal(usesPostgresLikeStructureCopy("gaussdb"), true);
|
||||
assert.equal(usesPostgresLikeStructureCopy("kwdb"), true);
|
||||
assert.equal(usesPostgresLikeStructureCopy("mysql"), false);
|
||||
assert.equal(supportsObjectBrowser("mysql"), true);
|
||||
assert.equal(supportsObjectBrowser("manticoresearch"), false);
|
||||
assert.equal(supportsObjectBrowser("mongodb"), false);
|
||||
assert.equal(supportsTableTruncate("mysql"), true);
|
||||
assert.equal(supportsTableTruncate("manticoresearch"), false);
|
||||
assert.equal(supportsTableTruncate("duckdb"), false);
|
||||
assert.equal(supportsTableTruncate("rqlite"), false);
|
||||
});
|
||||
|
||||
test("loads product support levels and capabilities from the driver manifest", () => {
|
||||
assert.equal(manifestDatabaseTypes().includes("mysql"), true);
|
||||
assert.equal(databaseSupportLevel("mysql"), "operate");
|
||||
assert.equal(databaseSupportLevel("manticoresearch"), "operate");
|
||||
assert.equal(databaseSupportLevel("jdbc"), "browse");
|
||||
assert.equal(databaseSupportLevel("redis"), "connect");
|
||||
|
||||
assert.deepEqual(
|
||||
{
|
||||
metadataBrowse: databaseProductCapabilities("jdbc").metadataBrowse,
|
||||
objectBrowser: databaseProductCapabilities("jdbc").objectBrowser,
|
||||
tableStructureEdit: databaseProductCapabilities("jdbc").tableStructureEdit,
|
||||
userAdmin: databaseProductCapabilities("jdbc").userAdmin,
|
||||
},
|
||||
{
|
||||
metadataBrowse: true,
|
||||
objectBrowser: true,
|
||||
tableStructureEdit: false,
|
||||
userAdmin: false,
|
||||
},
|
||||
);
|
||||
|
||||
assert.deepEqual(
|
||||
{
|
||||
queryExecution: databaseProductCapabilities("manticoresearch").queryExecution,
|
||||
metadataBrowse: databaseProductCapabilities("manticoresearch").metadataBrowse,
|
||||
objectBrowser: databaseProductCapabilities("manticoresearch").objectBrowser,
|
||||
tableDataEdit: databaseProductCapabilities("manticoresearch").tableDataEdit,
|
||||
tableStructureEdit: databaseProductCapabilities("manticoresearch").tableStructureEdit,
|
||||
sqlFileExecution: databaseProductCapabilities("manticoresearch").sqlFileExecution,
|
||||
userAdmin: databaseProductCapabilities("manticoresearch").userAdmin,
|
||||
},
|
||||
{
|
||||
queryExecution: true,
|
||||
metadataBrowse: true,
|
||||
objectBrowser: false,
|
||||
tableDataEdit: true,
|
||||
tableStructureEdit: true,
|
||||
sqlFileExecution: true,
|
||||
userAdmin: false,
|
||||
},
|
||||
);
|
||||
});
|
||||
|
||||
test("object browser entry follows database tree shape", () => {
|
||||
assert.equal(supportsObjectBrowserTreeNode("postgres", "database"), false);
|
||||
assert.equal(supportsObjectBrowserTreeNode("postgres", "schema"), true);
|
||||
assert.equal(supportsObjectBrowserTreeNode("sqlserver", "database"), true);
|
||||
assert.equal(supportsObjectBrowserTreeNode("sqlserver", "schema"), true);
|
||||
assert.equal(supportsObjectBrowserTreeNode("mysql", "database"), true);
|
||||
assert.equal(supportsObjectBrowserTreeNode("jdbc", "database"), true);
|
||||
assert.equal(supportsObjectBrowserTreeNode("mongodb", "database"), false);
|
||||
});
|
||||
|
||||
test("sidebar object capability registry describes object groups by database type", () => {
|
||||
assert.deepEqual(sidebarObjectKindsForDatabase("databend"), ["TABLE", "VIEW", "PROCEDURE"]);
|
||||
assert.deepEqual(sidebarObjectKindsForDatabase("manticoresearch"), ["TABLE", "FUNCTION"]);
|
||||
assert.deepEqual(sidebarObjectKindsForDatabase("postgres"), ["TABLE", "VIEW", "PROCEDURE", "FUNCTION", "SEQUENCE"]);
|
||||
assert.deepEqual(sidebarObjectKindsForDatabase("oracle"), ["TABLE", "VIEW", "PROCEDURE", "FUNCTION", "PACKAGE", "PACKAGE_BODY"]);
|
||||
});
|
||||
@@ -23,7 +23,7 @@ import {
|
||||
quoteMySqlIdentifier,
|
||||
quoteMySqlString,
|
||||
quotePostgresIdentifier,
|
||||
supportsDatabaseUserAdmin,
|
||||
|
||||
usersFromMySqlGranteeResult,
|
||||
usersFromMySqlUserResult,
|
||||
usersFromPostgresRolesResult,
|
||||
@@ -39,15 +39,6 @@ function result(columns: string[], rows: QueryResult["rows"]): QueryResult {
|
||||
};
|
||||
}
|
||||
|
||||
test("detects supported user administration dialects", () => {
|
||||
assert.equal(supportsDatabaseUserAdmin("mysql"), true);
|
||||
assert.equal(supportsDatabaseUserAdmin("goldendb"), true);
|
||||
assert.equal(supportsDatabaseUserAdmin("postgres"), true);
|
||||
assert.equal(supportsDatabaseUserAdmin("opengauss"), true);
|
||||
assert.equal(supportsDatabaseUserAdmin("sqlserver"), false);
|
||||
assert.equal(supportsDatabaseUserAdmin(undefined), false);
|
||||
});
|
||||
|
||||
test("quotes MySQL account parts and identifiers", () => {
|
||||
assert.equal(quoteMySqlString("app'user\\"), "'app''user\\\\'");
|
||||
assert.equal(quoteMySqlIdentifier("tenant`01"), "`tenant``01`");
|
||||
|
||||
@@ -1,160 +0,0 @@
|
||||
import assert from "node:assert/strict";
|
||||
import { test } from "vitest";
|
||||
import { canAddTableStructureColumn, canEditTableStructure, getTableStructureCapabilities } from "../../apps/desktop/src/lib/tableStructureCapabilities.ts";
|
||||
|
||||
test("sqlite-family and duckdb do not support table comments", () => {
|
||||
for (const dbType of ["sqlite", "rqlite", "duckdb"] as const) {
|
||||
const caps = getTableStructureCapabilities(dbType);
|
||||
assert.equal(caps.comment, false, `${dbType} should not support comments`);
|
||||
assert.equal(caps.createTable, true, `${dbType} should still support creating tables`);
|
||||
}
|
||||
});
|
||||
|
||||
test("postgres-like databases expose safe structure editing capabilities", () => {
|
||||
for (const dbType of ["postgres", "gaussdb", "kwdb", "opengauss", "highgo", "vastbase", "kingbase"] as const) {
|
||||
const caps = getTableStructureCapabilities(dbType);
|
||||
assert.equal(caps.dialect, "postgres", `${dbType} should reuse postgres DDL`);
|
||||
assert.equal(caps.createTable, true, `${dbType} should create tables`);
|
||||
assert.equal(caps.addColumn, true, `${dbType} should add columns`);
|
||||
assert.equal(caps.dropColumn, true, `${dbType} should drop columns`);
|
||||
assert.equal(caps.renameColumn, true, `${dbType} should rename columns`);
|
||||
assert.equal(caps.alterExistingColumn, true, `${dbType} should edit existing columns`);
|
||||
assert.equal(caps.comment, true, `${dbType} should support comments`);
|
||||
assert.equal(caps.createIndex, true, `${dbType} should create indexes`);
|
||||
assert.equal(caps.dropIndex, true, `${dbType} should drop indexes`);
|
||||
assert.equal(caps.rebuildIndex, true, `${dbType} should rebuild indexes`);
|
||||
assert.equal(caps.indexFilter, true, `${dbType} should support filtered indexes`);
|
||||
assert.equal(canEditTableStructure(dbType), true);
|
||||
}
|
||||
});
|
||||
|
||||
test("mysql-like databases expose index rebuild and type capabilities", () => {
|
||||
for (const dbType of ["mysql", "doris", "starrocks", "goldendb", "sundb"] as const) {
|
||||
const caps = getTableStructureCapabilities(dbType);
|
||||
assert.equal(caps.dialect, "mysql", `${dbType} should reuse mysql DDL`);
|
||||
assert.equal(caps.createIndex, true);
|
||||
assert.equal(caps.dropIndex, true);
|
||||
assert.equal(caps.rebuildIndex, true);
|
||||
assert.equal(caps.indexType, true);
|
||||
assert.equal(caps.reorderColumn, true);
|
||||
assert.equal(canEditTableStructure(dbType), true);
|
||||
}
|
||||
});
|
||||
|
||||
test("gbase 8a exposes limited mysql-compatible structure editing capabilities", () => {
|
||||
const caps = getTableStructureCapabilities("gbase");
|
||||
assert.equal(caps.dialect, "mysql");
|
||||
assert.equal(caps.createTable, true);
|
||||
assert.equal(caps.addColumn, true);
|
||||
assert.equal(caps.dropColumn, true);
|
||||
assert.equal(caps.renameColumn, true);
|
||||
assert.equal(caps.alterExistingColumn, false);
|
||||
assert.equal(caps.createIndex, false);
|
||||
assert.equal(caps.dropIndex, false);
|
||||
assert.equal(caps.rebuildIndex, false);
|
||||
assert.equal(caps.comment, false);
|
||||
assert.equal(canEditTableStructure("gbase"), true);
|
||||
});
|
||||
|
||||
test("redshift reuses postgres column DDL but keeps indexes disabled", () => {
|
||||
const caps = getTableStructureCapabilities("redshift");
|
||||
assert.equal(caps.dialect, "postgres");
|
||||
assert.equal(caps.createTable, true);
|
||||
assert.equal(caps.addColumn, true);
|
||||
assert.equal(caps.dropColumn, true);
|
||||
assert.equal(caps.renameColumn, true);
|
||||
assert.equal(caps.alterExistingColumn, true);
|
||||
assert.equal(caps.comment, true);
|
||||
assert.equal(caps.createIndex, false);
|
||||
assert.equal(caps.dropIndex, false);
|
||||
assert.equal(caps.rebuildIndex, false);
|
||||
assert.equal(caps.indexFilter, false);
|
||||
assert.equal(canEditTableStructure("redshift"), true);
|
||||
});
|
||||
|
||||
test("oracle-like databases expose oracle-compatible structure editing capabilities", () => {
|
||||
for (const dbType of ["oracle", "dameng", "oceanbase-oracle"] as const) {
|
||||
const caps = getTableStructureCapabilities(dbType);
|
||||
assert.equal(caps.dialect, "oracle", `${dbType} should reuse oracle DDL`);
|
||||
assert.equal(caps.createTable, true);
|
||||
assert.equal(caps.addColumn, true);
|
||||
assert.equal(caps.dropColumn, true);
|
||||
assert.equal(caps.renameColumn, true);
|
||||
assert.equal(caps.alterExistingColumn, true);
|
||||
assert.equal(caps.comment, true);
|
||||
assert.equal(caps.createIndex, true);
|
||||
assert.equal(caps.dropIndex, true);
|
||||
assert.equal(caps.rebuildIndex, true);
|
||||
assert.equal(caps.reorderColumn, false);
|
||||
assert.equal(canEditTableStructure(dbType), true);
|
||||
}
|
||||
});
|
||||
|
||||
test("limited analytic engines can open the editor for supported operations only", () => {
|
||||
const clickhouse = getTableStructureCapabilities("clickhouse");
|
||||
assert.equal(clickhouse.dialect, "clickhouse");
|
||||
assert.equal(clickhouse.createTable, true);
|
||||
assert.equal(clickhouse.addColumn, true);
|
||||
assert.equal(clickhouse.dropColumn, true);
|
||||
assert.equal(clickhouse.renameColumn, true);
|
||||
assert.equal(clickhouse.alterExistingColumn, true);
|
||||
assert.equal(clickhouse.alterType, true);
|
||||
assert.equal(clickhouse.alterNullability, true);
|
||||
assert.equal(clickhouse.alterDefault, true);
|
||||
assert.equal(clickhouse.reorderColumn, true);
|
||||
assert.equal(clickhouse.comment, true);
|
||||
assert.equal(clickhouse.createIndex, false);
|
||||
assert.equal(clickhouse.rebuildIndex, false);
|
||||
assert.equal(canEditTableStructure("clickhouse"), true);
|
||||
});
|
||||
|
||||
test("manticore search can open the editor for limited table structure changes", () => {
|
||||
const caps = getTableStructureCapabilities("manticoresearch");
|
||||
assert.equal(caps.dialect, "mysql");
|
||||
assert.equal(caps.createTable, true);
|
||||
assert.equal(caps.addColumn, true);
|
||||
assert.equal(caps.dropColumn, true);
|
||||
assert.equal(caps.renameColumn, false);
|
||||
assert.equal(caps.alterExistingColumn, false);
|
||||
assert.equal(caps.createIndex, false);
|
||||
assert.equal(caps.dropIndex, false);
|
||||
assert.equal(canEditTableStructure("manticoresearch"), true);
|
||||
assert.equal(canAddTableStructureColumn("manticoresearch", true), true);
|
||||
assert.equal(canAddTableStructureColumn("manticoresearch", false), true);
|
||||
});
|
||||
|
||||
test("manticore search keeps generic index DDL disabled", () => {
|
||||
const caps = getTableStructureCapabilities("manticoresearch");
|
||||
assert.equal(caps.createIndex, false);
|
||||
assert.equal(caps.dropIndex, false);
|
||||
assert.equal(caps.rebuildIndex, false);
|
||||
assert.equal(caps.indexType, false);
|
||||
assert.equal(caps.indexInclude, false);
|
||||
assert.equal(caps.indexFilter, false);
|
||||
assert.equal(caps.indexComment, false);
|
||||
});
|
||||
|
||||
test("informix exposes conservative structure editing capabilities", () => {
|
||||
const caps = getTableStructureCapabilities("informix");
|
||||
assert.equal(caps.dialect, "informix");
|
||||
assert.equal(caps.createTable, true);
|
||||
assert.equal(caps.addColumn, true);
|
||||
assert.equal(caps.dropColumn, true);
|
||||
assert.equal(caps.renameColumn, true);
|
||||
assert.equal(caps.alterExistingColumn, true);
|
||||
assert.equal(caps.comment, false);
|
||||
assert.equal(caps.createIndex, true);
|
||||
assert.equal(caps.dropIndex, true);
|
||||
assert.equal(caps.rebuildIndex, true);
|
||||
assert.equal(caps.indexType, false);
|
||||
assert.equal(caps.alterPrimaryKey, false);
|
||||
assert.equal(canEditTableStructure("informix"), true);
|
||||
});
|
||||
|
||||
test("unsupported non-relational databases do not open the structure editor", () => {
|
||||
for (const dbType of ["redis", "mongodb", "elasticsearch", "neo4j", undefined] as const) {
|
||||
const caps = getTableStructureCapabilities(dbType);
|
||||
assert.equal(caps.dialect, "unsupported");
|
||||
assert.equal(canEditTableStructure(dbType), false);
|
||||
}
|
||||
});
|
||||
Reference in New Issue
Block a user