MyGoNavi/internal/app/db_context_test.go

package app

import (
	"testing"

	"GoNavi-Wails/internal/connection"
)

func TestNormalizeSchemaAndTable_SQLServerKeepsDatabaseAndQualifiedTable(t *testing.T) {
	t.Parallel()

	schemaOrDb, table := normalizeSchemaAndTable(connection.ConnectionConfig{
		Type:     "sqlserver",
		Database: "master",
	}, "biz_db", "dbo.users")

	if schemaOrDb != "biz_db" {
		t.Fatalf("expected sqlserver first return value as database name, got %q", schemaOrDb)
	}
	if table != "dbo.users" {
		t.Fatalf("expected sqlserver table name keep qualified form, got %q", table)
	}
}

func TestNormalizeSchemaAndTable_SQLServerFallbackToConfigDatabase(t *testing.T) {
	t.Parallel()

	schemaOrDb, table := normalizeSchemaAndTable(connection.ConnectionConfig{
		Type:     "sqlserver",
		Database: "biz_db",
	}, "", "dbo.users")

	if schemaOrDb != "biz_db" {
		t.Fatalf("expected sqlserver fallback database from config, got %q", schemaOrDb)
	}
	if table != "dbo.users" {
		t.Fatalf("expected sqlserver table name keep qualified form, got %q", table)
	}
}

func TestNormalizeSchemaAndTable_PostgresStillSplitsQualifiedName(t *testing.T) {
	t.Parallel()

	schema, table := normalizeSchemaAndTable(connection.ConnectionConfig{
		Type: "postgres",
	}, "demo_db", "public.orders")

	if schema != "public" || table != "orders" {
		t.Fatalf("expected postgres qualified split to public.orders, got %q.%q", schema, table)
	}
}

func TestNormalizeSchemaAndTable_KingbaseNormalizesEscapedQualifiedName(t *testing.T) {
	t.Parallel()

	schema, table := normalizeSchemaAndTable(connection.ConnectionConfig{
		Type: "kingbase",
	}, "demo_db", `\"Idf_server\".\"mes_bip_wip_finished\"`)

	if schema != "Idf_server" || table != "mes_bip_wip_finished" {
		t.Fatalf("expected kingbase qualified split to Idf_server.mes_bip_wip_finished, got %q.%q", schema, table)
	}
}

func TestNormalizeRunConfig_OceanBaseOracleKeepsServiceName(t *testing.T) {
	t.Parallel()

	config := connection.ConnectionConfig{
		Type:              "oceanbase",
		Database:          "OBORCL",
		OceanBaseProtocol: "oracle",
	}
	runConfig := normalizeRunConfig(config, "SYS")

	if runConfig.Database != "OBORCL" {
		t.Fatalf("expected OceanBase Oracle service name to stay OBORCL, got %q", runConfig.Database)
	}
}

func TestNormalizeRunConfig_StarRocksUsesDatabaseFromTree(t *testing.T) {
	t.Parallel()

	runConfig := normalizeRunConfig(connection.ConnectionConfig{
		Type:     "starrocks",
		Database: "default_cluster",
	}, "analytics")

	if runConfig.Database != "analytics" {
		t.Fatalf("expected StarRocks database from tree, got %q", runConfig.Database)
	}
}

func TestNormalizeRunConfig_IRISUsesNamespaceFromTree(t *testing.T) {
	t.Parallel()

	runConfig := normalizeRunConfig(connection.ConnectionConfig{
		Type:     "iris",
		Database: "USER",
	}, "APP")

	if runConfig.Database != "APP" {
		t.Fatalf("expected IRIS namespace from tree, got %q", runConfig.Database)
	}
}

func TestNormalizeSchemaAndTable_IRISDoesNotTreatNamespaceAsSchema(t *testing.T) {
	t.Parallel()

	schema, table := normalizeSchemaAndTable(connection.ConnectionConfig{
		Type: "iris",
	}, "USER", "Person")

	if schema != "" || table != "Person" {
		t.Fatalf("expected IRIS pure table to omit schema, got %q.%q", schema, table)
	}
}

func TestNormalizeSchemaAndTable_IRISSplitsQualifiedTable(t *testing.T) {
	t.Parallel()

	schema, table := normalizeSchemaAndTable(connection.ConnectionConfig{
		Type: "iris",
	}, "USER", `"Sample.Schema"."Person.Table"`)

	if schema != "Sample.Schema" || table != "Person.Table" {
		t.Fatalf("expected IRIS qualified table split, got %q.%q", schema, table)
	}
}

func TestNormalizeSchemaAndTable_OceanBaseOracleUsesSchemaFromDatabaseTree(t *testing.T) {
	t.Parallel()

	schema, table := normalizeSchemaAndTable(connection.ConnectionConfig{
		Type:              "oceanbase",
		OceanBaseProtocol: "oracle",
	}, "SYS", "ORDERS")

	if schema != "SYS" || table != "ORDERS" {
		t.Fatalf("expected OceanBase Oracle schema/table SYS.ORDERS, got %q.%q", schema, table)
	}
}

func TestNormalizeSchemaAndTable_DuckDBPreservesQuotedQualifiedName(t *testing.T) {
	t.Parallel()

	schemaOrDb, table := normalizeSchemaAndTable(connection.ConnectionConfig{
		Type: "duckdb",
	}, `"analytics.catalog"."main.schema"`, `"daily.events"."2026.06"`)

	if schemaOrDb != `"analytics.catalog"."main.schema"` {
		t.Fatalf("expected duckdb dbName/catalog path preserved, got %q", schemaOrDb)
	}
	if table != `"daily.events"."2026.06"` {
		t.Fatalf("expected duckdb qualified table preserved, got %q", table)
	}
}

func TestQuoteTableIdentByType_KingbaseNormalizesQuotedQualifiedTable(t *testing.T) {
	t.Parallel()

	schema, table := normalizeSchemaAndTableByType("kingbase", "", `\"Idf_server\".\"mes_bip_wip_finished\"`)
	if schema != "Idf_server" || table != "mes_bip_wip_finished" {
		t.Fatalf("expected kingbase qualified split to Idf_server.mes_bip_wip_finished, got %q.%q", schema, table)
	}

	if got := quoteTableIdentByType("kingbase", schema, table); got != `"Idf_server".mes_bip_wip_finished` {
		t.Fatalf("unexpected kingbase table identifier: %s", got)
	}
}