Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

feat(postgres): parallelize testcontainer tests with shared container pattern (#18907)

Danny Xue58858326ada
diff --git a/backend/plugin/schema/mssql/generate_migration_testcontainer_test.go b/backend/plugin/schema/mssql/generate_migration_testcontainer_test.go
index 95fa352ceb..0a893b9a0d 100644
--- a/backend/plugin/schema/mssql/generate_migration_testcontainer_test.go
+++ b/backend/plugin/schema/mssql/generate_migration_testcontainer_test.go
@@ -36,10 +36,6 @@ func TestGenerateMigrationWithTestcontainer(t *testing.T) {
container := testcontainer.GetTestMSSQLContainer(ctx, t)
t.Cleanup(func() { container.Close(ctx) })
- // Get connection details
- host := container.GetHost()
- port := container.GetPort()
-
// Test cases with various schema changes
testCases := []struct {
name string
@@ -2360,7 +2356,7 @@ GO
require.NoError(t, err, "failed to create test database")
// Connect to test database
- driver, err := createMSSQLDriver(ctx, host, port, testDB)
+ driver, err := createMSSQLDriver(ctx, container.GetHost(), container.GetPort(), testDB)
require.NoError(t, err, "failed to connect to test database")
defer driver.Close(ctx)
diff --git a/backend/plugin/schema/mssql/get_database_definition_testcontainer_test.go b/backend/plugin/schema/mssql/get_database_definition_testcontainer_test.go
index 1917b92742..ae6bf6ed0e 100644
--- a/backend/plugin/schema/mssql/get_database_definition_testcontainer_test.go
+++ b/backend/plugin/schema/mssql/get_database_definition_testcontainer_test.go
@@ -20,9 +20,6 @@ func TestGetDatabaseDefinitionWithTestcontainer(t *testing.T) {
container := testcontainer.GetTestMSSQLContainer(ctx, t)
t.Cleanup(func() { container.Close(ctx) })
- host := container.GetHost()
- port := container.GetPort()
-
testCases := []struct {
name string
setupSQL string
@@ -407,7 +404,7 @@ GO
require.NoError(t, err)
// Connect to test database
- testDriver, err := createMSSQLDriver(ctx, host, port, databaseName)
+ testDriver, err := createMSSQLDriver(ctx, container.GetHost(), container.GetPort(), databaseName)
require.NoError(t, err)
defer testDriver.Close(ctx)
@@ -431,7 +428,7 @@ GO
require.NoError(t, err)
// Connect to the new database
- newDriver, err := createMSSQLDriver(ctx, host, port, newDatabaseName)
+ newDriver, err := createMSSQLDriver(ctx, container.GetHost(), container.GetPort(), newDatabaseName)
require.NoError(t, err)
defer newDriver.Close(ctx)
diff --git a/backend/plugin/schema/mssql/get_database_metadata_testcontainer_test.go b/backend/plugin/schema/mssql/get_database_metadata_testcontainer_test.go
index 7fe866f560..3b40347d0b 100644
--- a/backend/plugin/schema/mssql/get_database_metadata_testcontainer_test.go
+++ b/backend/plugin/schema/mssql/get_database_metadata_testcontainer_test.go
@@ -19,9 +19,6 @@ func TestGetDatabaseMetadataWithTestcontainer(t *testing.T) {
container := testcontainer.GetTestMSSQLContainer(ctx, t)
t.Cleanup(func() { container.Close(ctx) })
- host := container.GetHost()
- port := container.GetPort()
-
testCases := []struct {
name string
setupSQL string
@@ -656,7 +653,7 @@ GO
require.NoError(t, err)
// Connect to the test database
- driver, err := createMSSQLDriver(ctx, host, port, databaseName)
+ driver, err := createMSSQLDriver(ctx, container.GetHost(), container.GetPort(), databaseName)
require.NoError(t, err)
defer driver.Close(ctx)
diff --git a/backend/plugin/schema/mysql/generate_migration_testcontainer_test.go b/backend/plugin/schema/mysql/generate_migration_testcontainer_test.go
index 99cd3892f0..88be2e76b7 100644
--- a/backend/plugin/schema/mysql/generate_migration_testcontainer_test.go
+++ b/backend/plugin/schema/mysql/generate_migration_testcontainer_test.go
@@ -37,10 +37,6 @@ func TestGenerateMigrationWithTestcontainer(t *testing.T) {
require.NoError(t, err)
t.Cleanup(func() { container.Close(ctx) })
- // Get connection details
- host := container.GetHost()
- port := container.GetPort()
-
// Test cases with various schema changes
testCases := []struct {
name string
@@ -1644,7 +1640,7 @@ CREATE TABLE some_table (
require.NoError(t, err)
// Create MySQL driver for this test's database
- driver, err := createMySQLDriver(ctx, host, port, testDBName)
+ driver, err := createMySQLDriver(ctx, container.GetHost(), container.GetPort(), testDBName)
require.NoError(t, err)
defer driver.Close(ctx)
diff --git a/backend/plugin/schema/mysql/get_database_definition_testcontainer_test.go b/backend/plugin/schema/mysql/get_database_definition_testcontainer_test.go
index 84d25a3cdd..775f485cf8 100644
--- a/backend/plugin/schema/mysql/get_database_definition_testcontainer_test.go
+++ b/backend/plugin/schema/mysql/get_database_definition_testcontainer_test.go
@@ -32,9 +32,6 @@ func TestGetDatabaseDefinition(t *testing.T) {
require.NoError(t, err)
t.Cleanup(func() { container.Close(ctx) })
- host := container.GetHost()
- port := container.GetPort()
-
type testCase struct {
description string
originalDDL string
@@ -303,7 +300,7 @@ CREATE TABLE translations (
require.NoError(t, err)
// Step 1: Initialize the database schema and get metadata A
- driverA, err := createMySQLDriver(ctx, host, port, testDBName)
+ driverA, err := createMySQLDriver(ctx, container.GetHost(), container.GetPort(), testDBName)
require.NoError(t, err)
defer driverA.Close(ctx)
@@ -326,7 +323,7 @@ CREATE TABLE translations (
_, err = container.GetDB().Exec(fmt.Sprintf("CREATE DATABASE `%s`", newDBName))
require.NoError(t, err)
- driverB, err := createMySQLDriver(ctx, host, port, newDBName)
+ driverB, err := createMySQLDriver(ctx, container.GetHost(), container.GetPort(), newDBName)
require.NoError(t, err)
defer driverB.Close(ctx)
@@ -456,11 +453,8 @@ CREATE TABLE project_member (
_, err = container.GetDB().Exec(fmt.Sprintf("CREATE DATABASE IF NOT EXISTS `%s`", databaseName))
require.NoError(t, err)
- host := container.GetHost()
- port := container.GetPort()
-
// Step 1: Initialize the database schema
- driverA, err := createMySQLDriver(ctx, host, port, databaseName)
+ driverA, err := createMySQLDriver(ctx, container.GetHost(), container.GetPort(), databaseName)
require.NoError(t, err)
defer driverA.Close(ctx)
@@ -483,7 +477,7 @@ CREATE TABLE project_member (
_, err = container.GetDB().Exec(fmt.Sprintf("CREATE DATABASE `%s`", newDBName))
require.NoError(t, err)
- driverB, err := createMySQLDriver(ctx, host, port, newDBName)
+ driverB, err := createMySQLDriver(ctx, container.GetHost(), container.GetPort(), newDBName)
require.NoError(t, err)
defer driverB.Close(ctx)
diff --git a/backend/plugin/schema/mysql/get_database_metadata_testcontainer_test.go b/backend/plugin/schema/mysql/get_database_metadata_testcontainer_test.go
index 93e4cc2e6f..37b1893076 100644
--- a/backend/plugin/schema/mysql/get_database_metadata_testcontainer_test.go
+++ b/backend/plugin/schema/mysql/get_database_metadata_testcontainer_test.go
@@ -28,9 +28,6 @@ func TestGetDatabaseMetadataWithTestcontainer(t *testing.T) {
require.NoError(t, err)
t.Cleanup(func() { container.Close(ctx) })
- host := container.GetHost()
- port := container.GetPort()
-
// Test cases with various MySQL features
testCases := []struct {
name string
@@ -522,7 +519,7 @@ CREATE TABLE json_features (
require.NoError(t, err)
// Create MySQL driver for this test's database
- driver, err := createMySQLDriver(ctx, host, port, testDBName)
+ driver, err := createMySQLDriver(ctx, container.GetHost(), container.GetPort(), testDBName)
require.NoError(t, err)
defer driver.Close(ctx)
diff --git a/backend/plugin/schema/pg/generate_migration_testcontainer_test.go b/backend/plugin/schema/pg/generate_migration_testcontainer_test.go
index 9aae472e52..dfe2c4ff8f 100644
--- a/backend/plugin/schema/pg/generate_migration_testcontainer_test.go
+++ b/backend/plugin/schema/pg/generate_migration_testcontainer_test.go
@@ -2,7 +2,6 @@ package pg
import (
"context"
- "errors"
"fmt"
"slices"
"strings"
@@ -10,54 +9,25 @@ import (
"time"
"github.com/google/go-cmp/cmp"
- "github.com/jackc/pgx/v5"
- "github.com/jackc/pgx/v5/stdlib"
"github.com/stretchr/testify/require"
- "github.com/testcontainers/testcontainers-go"
- "github.com/testcontainers/testcontainers-go/modules/postgres"
- "github.com/testcontainers/testcontainers-go/wait"
"google.golang.org/protobuf/testing/protocmp"
+ "github.com/bytebase/bytebase/backend/common/testcontainer"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
- "github.com/bytebase/bytebase/backend/plugin/db"
- pgdb "github.com/bytebase/bytebase/backend/plugin/db/pg"
"github.com/bytebase/bytebase/backend/plugin/schema"
"github.com/bytebase/bytebase/backend/store/model"
)
// TestGenerateMigrationWithTestcontainer tests the generate migration function
// by applying migrations and rollback to verify the schema can be restored.
+//
+//nolint:tparallel
func TestGenerateMigrationWithTestcontainer(t *testing.T) {
ctx := context.Background()
- // Start PostgreSQL container
- pgContainer, err := postgres.Run(ctx,
- "postgres:16-alpine",
- postgres.WithDatabase("test_db"),
- postgres.WithUsername("postgres"),
- postgres.WithPassword("test"),
- testcontainers.WithWaitStrategy(
- wait.ForLog("database system is ready to accept connections").
- WithOccurrence(2).
- WithStartupTimeout(5*time.Minute),
- ),
- )
- require.NoError(t, err)
- defer func() {
- if err := pgContainer.Terminate(ctx); err != nil {
- t.Logf("failed to terminate container: %s", err)
- }
- }()
-
- // Get connection string
- connectionString, err := pgContainer.ConnectionString(ctx, "sslmode=disable")
- require.NoError(t, err)
-
- // Connect to the database
- connConfig, err := pgx.ParseConfig(connectionString)
- require.NoError(t, err)
- db := stdlib.OpenDB(*connConfig)
- defer db.Close()
+ // Start shared PostgreSQL container for all subtests
+ container := testcontainer.GetTestPgContainer(ctx, t)
+ t.Cleanup(func() { container.Close(ctx) })
// Test cases with various schema changes
testCases := []struct {
@@ -2146,29 +2116,30 @@ $$ LANGUAGE plpgsql;
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
- // Create a new database for each test case
- dbName := fmt.Sprintf("test_%s", tc.name)
- _, err := db.Exec(fmt.Sprintf("CREATE DATABASE %s", dbName))
+ t.Parallel()
+
+ // Create a new database for each test case with unique name
+ dbName := fmt.Sprintf("test_%s_%s", strings.ReplaceAll(tc.name, "-", "_"), strings.ReplaceAll(fmt.Sprintf("%d", time.Now().UnixNano()%1000000), "-", "_"))
+ _, err := container.GetDB().Exec(fmt.Sprintf("CREATE DATABASE %s", dbName))
require.NoError(t, err)
- // Connect to the test database
- testConnConfig := *connConfig
- testConnConfig.Database = dbName
- testDB := stdlib.OpenDB(testConnConfig)
- defer testDB.Close()
+ // Create driver for the test database
+ driver, err := createPgDriver(ctx, container.GetHost(), container.GetPort(), dbName)
+ require.NoError(t, err)
+ defer driver.Close(ctx)
// Step 1: Initialize the database schema and get schema result A
- _, err = testDB.Exec(tc.initialSchema)
+ _, err = driver.GetDB().ExecContext(ctx, tc.initialSchema)
require.NoError(t, err)
- schemaA, err := getSyncMetadataForGenerateMigration(ctx, &testConnConfig, dbName)
+ schemaA, err := driver.SyncDBSchema(ctx)
require.NoError(t, err)
// Step 2: Do some migration and get schema result B
- _, err = testDB.Exec(tc.migrationDDL)
+ _, err = driver.GetDB().ExecContext(ctx, tc.migrationDDL)
require.NoError(t, err)
- schemaB, err := getSyncMetadataForGenerateMigration(ctx, &testConnConfig, dbName)
+ schemaB, err := driver.SyncDBSchema(ctx)
require.NoError(t, err)
// Step 3: Call generate migration to get the rollback DDL
@@ -2221,10 +2192,10 @@ $$ LANGUAGE plpgsql;
t.Logf("Rollback DDL:\n%s", rollbackDDL)
// Step 4: Run rollback DDL and get schema result C
- _, err = testDB.Exec(rollbackDDL)
+ _, err = driver.GetDB().ExecContext(ctx, rollbackDDL)
require.NoError(t, err)
- schemaC, err := getSyncMetadataForGenerateMigration(ctx, &testConnConfig, dbName)
+ schemaC, err := driver.SyncDBSchema(ctx)
require.NoError(t, err)
// Step 5: Compare schema result A and C to ensure they are the same
@@ -2239,48 +2210,6 @@ $$ LANGUAGE plpgsql;
}
}
-// getSyncMetadataForGenerateMigration retrieves metadata from the live database using Driver.SyncDBSchema
-func getSyncMetadataForGenerateMigration(ctx context.Context, connConfig *pgx.ConnConfig, dbName string) (*storepb.DatabaseSchemaMetadata, error) {
- // Create a driver instance using the pg package
- driver := &pgdb.Driver{}
-
- // Create connection config
- config := db.ConnectionConfig{
- DataSource: &storepb.DataSource{
- Type: storepb.DataSourceType_ADMIN,
- Username: connConfig.User,
- Host: connConfig.Host,
- Port: fmt.Sprintf("%d", connConfig.Port),
- Database: dbName,
- },
- Password: connConfig.Password,
- ConnectionContext: db.ConnectionContext{
- EngineVersion: "16.0", // PostgreSQL 16
- DatabaseName: dbName,
- },
- }
-
- // Open connection using the driver
- openedDriver, err := driver.Open(ctx, storepb.Engine_POSTGRES, config)
- if err != nil {
- return nil, err
- }
- defer openedDriver.Close(ctx)
-
- // Use SyncDBSchema to get the metadata
- pgDriver, ok := openedDriver.(*pgdb.Driver)
- if !ok {
- return nil, errors.New("failed to cast to pg.Driver")
- }
-
- metadata, err := pgDriver.SyncDBSchema(ctx)
- if err != nil {
- return nil, err
- }
-
- return metadata, nil
-}
-
// normalizeMetadataForComparison normalizes metadata to ignore differences that don't affect schema equality
func normalizeMetadataForComparison(metadata *storepb.DatabaseSchemaMetadata) {
// Clear database name as it might differ
@@ -2416,34 +2345,18 @@ func sortExtensionsByName(extensions []*storepb.ExtensionMetadata) {
func TestSDLForeignKeyDependencyOrder(t *testing.T) {
ctx := context.Background()
- // Start PostgreSQL container
- pgContainer, err := postgres.Run(ctx,
- "postgres:16-alpine",
- postgres.WithDatabase("test_db"),
- postgres.WithUsername("postgres"),
- postgres.WithPassword("test"),
- testcontainers.WithWaitStrategy(
- wait.ForLog("database system is ready to accept connections").
- WithOccurrence(2).
- WithStartupTimeout(5*time.Minute),
- ),
- )
- require.NoError(t, err)
- defer func() {
- if err := pgContainer.Terminate(ctx); err != nil {
- t.Logf("failed to terminate container: %s", err)
- }
- }()
+ container := testcontainer.GetTestPgContainer(ctx, t)
+ t.Cleanup(func() {
+ container.Close(ctx)
+ })
- // Get connection string
- connectionString, err := pgContainer.ConnectionString(ctx, "sslmode=disable")
+ dbName := fmt.Sprintf("test_fk_dep_order_%d", time.Now().Unix())
+ _, err := container.GetDB().Exec(fmt.Sprintf("CREATE DATABASE %s", dbName))
require.NoError(t, err)
- // Connect to the database
- connConfig, err := pgx.ParseConfig(connectionString)
+ driver, err := createPgDriver(ctx, container.GetHost(), container.GetPort(), dbName)
require.NoError(t, err)
- testDB := stdlib.OpenDB(*connConfig)
- defer testDB.Close()
+ defer driver.Close(ctx)
// This SDL text simulates multi-file SDL where files are merged in alphabetical order
// table1.sql comes before table2.sql, but table1 has FK to table2
@@ -2468,7 +2381,7 @@ CREATE TABLE table2 (
previousSDL := ``
// Get current schema (empty database)
- currentSchema, err := getSyncMetadataForGenerateMigration(ctx, connConfig, connConfig.Database)
+ currentSchema, err := driver.SyncDBSchema(ctx)
require.NoError(t, err)
dbMetadata := model.NewDatabaseMetadata(currentSchema, nil, nil, storepb.Engine_POSTGRES, false)
@@ -2484,14 +2397,20 @@ CREATE TABLE table2 (
// Execute the generated migration SQL
// This should work because generateMigration should have sorted tables by FK dependencies
- _, err = testDB.Exec(migrationSQL)
+ _, err = driver.GetDB().ExecContext(ctx, migrationSQL)
require.NoError(t, err, "Migration SQL should execute successfully with correct FK dependency order")
+ // Connect to the test database for verification queries
+ verifyDriver, err := createPgDriver(ctx, container.GetHost(), container.GetPort(), dbName)
+ require.NoError(t, err)
+ defer verifyDriver.Close(ctx)
+
// Verify both tables were created
+ verifyDB := verifyDriver.GetDB()
var table1Exists, table2Exists bool
- err = testDB.QueryRow("SELECT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'table1')").Scan(&table1Exists)
+ err = verifyDB.QueryRowContext(ctx, "SELECT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'table1')").Scan(&table1Exists)
require.NoError(t, err)
- err = testDB.QueryRow("SELECT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'table2')").Scan(&table2Exists)
+ err = verifyDB.QueryRowContext(ctx, "SELECT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'table2')").Scan(&table2Exists)
require.NoError(t, err)
require.True(t, table1Exists, "table1 should be created")
@@ -2499,9 +2418,9 @@ CREATE TABLE table2 (
// Verify FK constraint exists
var fkExists bool
- err = testDB.QueryRow(`
+ err = verifyDB.QueryRowContext(ctx, `
SELECT EXISTS (
- SELECT 1 FROM information_schema.table_constraints
+ SELECT 1 FROM information_schema.table_constraints
WHERE constraint_name = 'fk_table1_name' AND table_name = 'table1'
)
`).Scan(&fkExists)
@@ -2514,34 +2433,18 @@ CREATE TABLE table2 (
func TestSDLViewDependencyChain(t *testing.T) {
ctx := context.Background()
- // Start PostgreSQL container
- pgContainer, err := postgres.Run(ctx,
- "postgres:16-alpine",
- postgres.WithDatabase("test_db"),
- postgres.WithUsername("postgres"),
- postgres.WithPassword("test"),
- testcontainers.WithWaitStrategy(
- wait.ForLog("database system is ready to accept connections").
- WithOccurrence(2).
- WithStartupTimeout(5*time.Minute),
- ),
- )
- require.NoError(t, err)
- defer func() {
- if err := pgContainer.Terminate(ctx); err != nil {
- t.Logf("failed to terminate container: %s", err)
- }
- }()
+ container := testcontainer.GetTestPgContainer(ctx, t)
+ t.Cleanup(func() {
+ container.Close(ctx)
+ })
- // Get connection string
- connectionString, err := pgContainer.ConnectionString(ctx, "sslmode=disable")
+ dbName := fmt.Sprintf("test_view_dep_chain_%d", time.Now().Unix())
+ _, err := container.GetDB().Exec(fmt.Sprintf("CREATE DATABASE %s", dbName))
require.NoError(t, err)
- // Connect to the database
- connConfig, err := pgx.ParseConfig(connectionString)
+ driver, err := createPgDriver(ctx, container.GetHost(), container.GetPort(), dbName)
require.NoError(t, err)
- testDB := stdlib.OpenDB(*connConfig)
- defer testDB.Close()
+ defer driver.Close(ctx)
// This SDL text simulates the REAL multi-file scenario where files are merged alphabetically:
// Files: table_base.sql, test_view_0.sql, test_view2.sql
@@ -2567,7 +2470,7 @@ SELECT id, info, created_at, updated_at FROM table_base;
previousSDL := ``
// Get current schema (empty database)
- currentSchema, err := getSyncMetadataForGenerateMigration(ctx, connConfig, connConfig.Database)
+ currentSchema, err := driver.SyncDBSchema(ctx)
require.NoError(t, err)
dbMetadata := model.NewDatabaseMetadata(currentSchema, nil, nil, storepb.Engine_POSTGRES, false)
@@ -2581,24 +2484,31 @@ SELECT id, info, created_at, updated_at FROM table_base;
// Execute the generated migration SQL
// This should work because generateMigration should have sorted objects by dependencies
- _, err = testDB.Exec(migrationSQL)
+ _, err = driver.GetDB().ExecContext(ctx, migrationSQL)
require.NoError(t, err, "Migration SQL should execute successfully with correct view dependency order")
+ // Connect to the test database for verification queries
+ verifyDriver, err := createPgDriver(ctx, container.GetHost(), container.GetPort(), dbName)
+ require.NoError(t, err)
+ defer verifyDriver.Close(ctx)
+
+ verifyDB := verifyDriver.GetDB()
+
// Verify table was created
var tableExists bool
- err = testDB.QueryRow("SELECT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'table_base')").Scan(&tableExists)
+ err = verifyDB.QueryRowContext(ctx, "SELECT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'table_base')").Scan(&tableExists)
require.NoError(t, err)
require.True(t, tableExists, "table_base should be created")
// Verify test_view2 was created (depends on table_base)
var view2Exists bool
- err = testDB.QueryRow("SELECT EXISTS (SELECT 1 FROM information_schema.views WHERE table_name = 'test_view2')").Scan(&view2Exists)
+ err = verifyDB.QueryRowContext(ctx, "SELECT EXISTS (SELECT 1 FROM information_schema.views WHERE table_name = 'test_view2')").Scan(&view2Exists)
require.NoError(t, err)
require.True(t, view2Exists, "test_view2 should be created")
// Verify test_view_0 was created (depends on test_view2)
var view0Exists bool
- err = testDB.QueryRow("SELECT EXISTS (SELECT 1 FROM information_schema.views WHERE table_name = 'test_view_0')").Scan(&view0Exists)
+ err = verifyDB.QueryRowContext(ctx, "SELECT EXISTS (SELECT 1 FROM information_schema.views WHERE table_name = 'test_view_0')").Scan(&view0Exists)
require.NoError(t, err)
require.True(t, view0Exists, "test_view_0 should be created")
}
diff --git a/backend/plugin/schema/pg/get_database_definition_testcontainer_test.go b/backend/plugin/schema/pg/get_database_definition_testcontainer_test.go
index 099ea2d2ff..7e85fd85e9 100644
--- a/backend/plugin/schema/pg/get_database_definition_testcontainer_test.go
+++ b/backend/plugin/schema/pg/get_database_definition_testcontainer_test.go
@@ -2,34 +2,29 @@ package pg
import (
"context"
- "database/sql"
- "errors"
"fmt"
"strings"
"testing"
+ "time"
- _ "github.com/jackc/pgx/v5/stdlib"
"github.com/stretchr/testify/require"
"github.com/bytebase/bytebase/backend/common/testcontainer"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
- "github.com/bytebase/bytebase/backend/plugin/db"
- pgdb "github.com/bytebase/bytebase/backend/plugin/db/pg"
"github.com/bytebase/bytebase/backend/plugin/schema"
)
// TestGetDatabaseDefinitionWithTestcontainer tests the get_database_definition function
// by comparing metadata from a database created using the original DDL versus
// metadata from a database created using the generated DDL.
+//
+//nolint:tparallel
func TestGetDatabaseDefinitionWithTestcontainer(t *testing.T) {
ctx := context.Background()
// Get PostgreSQL container from testcontainer.go
pgContainer := testcontainer.GetTestPgContainer(ctx, t)
- defer pgContainer.Close(ctx)
-
- // Get the database connection
- db := pgContainer.GetDB()
+ t.Cleanup(func() { pgContainer.Close(ctx) })
// Test cases with various PostgreSQL features
testCases := []struct {
@@ -407,23 +402,24 @@ CREATE TABLE cities (
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
- // Create first database with original DDL
- dbNameA := fmt.Sprintf("test_a_%s", tc.name)
- _, err := db.Exec(fmt.Sprintf("CREATE DATABASE %s", dbNameA))
+ t.Parallel()
+
+ // Create first database with original DDL using unique name
+ dbNameA := fmt.Sprintf("test_a_%s_%d", strings.ReplaceAll(tc.name, "-", "_"), time.Now().UnixNano()%1000000)
+ _, err := pgContainer.GetDB().Exec(fmt.Sprintf("CREATE DATABASE %s", dbNameA))
require.NoError(t, err)
- // Connect to database A
- testDBA, err := sql.Open("pgx", fmt.Sprintf("host=%s port=%s user=postgres password=root-password database=%s sslmode=disable",
- pgContainer.GetHost(), pgContainer.GetPort(), dbNameA))
+ // Create driver for database A
+ driverA, err := createPgDriver(ctx, pgContainer.GetHost(), pgContainer.GetPort(), dbNameA)
require.NoError(t, err)
- defer testDBA.Close()
+ defer driverA.Close(ctx)
// Execute the original DDL
- _, err = testDBA.Exec(tc.ddl)
+ _, err = driverA.GetDB().ExecContext(ctx, tc.ddl)
require.NoError(t, err)
// Get metadata A using Driver.SyncDBSchema
- metadataA, err := getDBSyncMetadata(ctx, pgContainer, dbNameA)
+ metadataA, err := driverA.SyncDBSchema(ctx)
require.NoError(t, err)
// Generate database definition using GetDatabaseDefinition
@@ -431,23 +427,22 @@ CREATE TABLE cities (
require.NoError(t, err)
require.NotEmpty(t, generatedDDL, "generated DDL should not be empty")
- // Create second database and apply generated DDL
- dbNameB := fmt.Sprintf("test_b_%s", tc.name)
- _, err = db.Exec(fmt.Sprintf("CREATE DATABASE %s", dbNameB))
+ // Create second database and apply generated DDL using unique name
+ dbNameB := fmt.Sprintf("test_b_%s_%d", strings.ReplaceAll(tc.name, "-", "_"), time.Now().UnixNano()%1000000)
+ _, err = pgContainer.GetDB().Exec(fmt.Sprintf("CREATE DATABASE %s", dbNameB))
require.NoError(t, err)
- // Connect to database B
- testDBB, err := sql.Open("pgx", fmt.Sprintf("host=%s port=%s user=postgres password=root-password database=%s sslmode=disable",
- pgContainer.GetHost(), pgContainer.GetPort(), dbNameB))
+ // Create driver for database B
+ driverB, err := createPgDriver(ctx, pgContainer.GetHost(), pgContainer.GetPort(), dbNameB)
require.NoError(t, err)
- defer testDBB.Close()
+ defer driverB.Close(ctx)
// Execute the generated DDL
- _, err = testDBB.Exec(generatedDDL)
+ _, err = driverB.GetDB().ExecContext(ctx, generatedDDL)
require.NoError(t, err, "failed to execute generated DDL: %s", generatedDDL)
// Get metadata B using Driver.SyncDBSchema
- metadataB, err := getDBSyncMetadata(ctx, pgContainer, dbNameB)
+ metadataB, err := driverB.SyncDBSchema(ctx)
require.NoError(t, err)
// Compare metadata A and B
@@ -456,48 +451,6 @@ CREATE TABLE cities (
}
}
-// getDBSyncMetadata retrieves metadata from the live database using Driver.SyncDBSchema
-func getDBSyncMetadata(ctx context.Context, container *testcontainer.Container, dbName string) (*storepb.DatabaseSchemaMetadata, error) {
- // Create a driver instance using the pg package
- driver := &pgdb.Driver{}
-
- // Create connection config
- config := db.ConnectionConfig{
- DataSource: &storepb.DataSource{
- Type: storepb.DataSourceType_ADMIN,
- Username: "postgres",
- Host: container.GetHost(),
- Port: container.GetPort(),
- Database: dbName,
- },
- Password: "root-password",
- ConnectionContext: db.ConnectionContext{
- EngineVersion: "16.0", // PostgreSQL 16
- DatabaseName: dbName,
- },
- }
-
- // Open connection using the driver
- openedDriver, err := driver.Open(ctx, storepb.Engine_POSTGRES, config)
- if err != nil {
- return nil, err
- }
- defer openedDriver.Close(ctx)
-
- // Use SyncDBSchema to get the metadata
- pgDriver, ok := openedDriver.(*pgdb.Driver)
- if !ok {
- return nil, errors.New("failed to cast to pg.Driver")
- }
-
- metadata, err := pgDriver.SyncDBSchema(ctx)
- if err != nil {
- return nil, err
- }
-
- return metadata, nil
-}
-
// compareFullMetadata compares all aspects of database metadata
func compareFullMetadata(t *testing.T, metaA, metaB *storepb.DatabaseSchemaMetadata) {
// Compare extensions
diff --git a/backend/plugin/schema/pg/get_database_metadata_testcontainer_test.go b/backend/plugin/schema/pg/get_database_metadata_testcontainer_test.go
index 6bdf60a5bb..3ca50ec23b 100644
--- a/backend/plugin/schema/pg/get_database_metadata_testcontainer_test.go
+++ b/backend/plugin/schema/pg/get_database_metadata_testcontainer_test.go
@@ -2,22 +2,15 @@ package pg
import (
"context"
- "errors"
"fmt"
"strings"
"testing"
"time"
- "github.com/jackc/pgx/v5"
- "github.com/jackc/pgx/v5/stdlib"
"github.com/stretchr/testify/require"
- "github.com/testcontainers/testcontainers-go"
- "github.com/testcontainers/testcontainers-go/modules/postgres"
- "github.com/testcontainers/testcontainers-go/wait"
+ "github.com/bytebase/bytebase/backend/common/testcontainer"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
- "github.com/bytebase/bytebase/backend/plugin/db"
- pgdb "github.com/bytebase/bytebase/backend/plugin/db/pg"
"github.com/bytebase/bytebase/backend/plugin/schema"
"github.com/bytebase/bytebase/backend/plugin/schema/pg/ast"
"github.com/bytebase/bytebase/backend/store/model"
@@ -25,37 +18,14 @@ import (
// TestGetDatabaseMetadataWithTestcontainer tests the get_database_metadata function
// by comparing its output with the metadata retrieved from a real PostgreSQL instance.
+//
+//nolint:tparallel
func TestGetDatabaseMetadataWithTestcontainer(t *testing.T) {
ctx := context.Background()
- // Start PostgreSQL container
- pgContainer, err := postgres.Run(ctx,
- "postgres:16-alpine",
- postgres.WithDatabase("test_db"),
- postgres.WithUsername("postgres"),
- postgres.WithPassword("test"),
- testcontainers.WithWaitStrategy(
- wait.ForLog("database system is ready to accept connections").
- WithOccurrence(2).
- WithStartupTimeout(5*time.Minute),
- ),
- )
- require.NoError(t, err)
- defer func() {
- if err := pgContainer.Terminate(ctx); err != nil {
- t.Logf("failed to terminate container: %s", err)
- }
- }()
-
- // Get connection string
- connectionString, err := pgContainer.ConnectionString(ctx, "sslmode=disable")
- require.NoError(t, err)
-
- // Connect to the database
- connConfig, err := pgx.ParseConfig(connectionString)
- require.NoError(t, err)
- db := stdlib.OpenDB(*connConfig)
- defer db.Close()
+ // Start shared PostgreSQL container for all subtests
+ container := testcontainer.GetTestPgContainer(ctx, t)
+ t.Cleanup(func() { container.Close(ctx) })
// Test cases with various PostgreSQL features
testCases := []struct {
@@ -870,23 +840,24 @@ INSERT INTO array_types_test (
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
- // Create a new database for each test case
- dbName := fmt.Sprintf("test_%s", tc.name)
- _, err := db.Exec(fmt.Sprintf("CREATE DATABASE %s", dbName))
+ t.Parallel()
+
+ // Create a new database for each test case with unique name
+ dbName := fmt.Sprintf("test_%s_%d", strings.ReplaceAll(tc.name, "-", "_"), time.Now().UnixNano()%1000000)
+ _, err := container.GetDB().Exec(fmt.Sprintf("CREATE DATABASE %s", dbName))
require.NoError(t, err)
- // Connect to the test database
- testConnConfig := *connConfig
- testConnConfig.Database = dbName
- testDB := stdlib.OpenDB(testConnConfig)
- defer testDB.Close()
+ // Create driver for the test database
+ driver, err := createPgDriver(ctx, container.GetHost(), container.GetPort(), dbName)
+ require.NoError(t, err)
+ defer driver.Close(ctx)
// Execute the DDL
- _, err = testDB.Exec(tc.ddl)
+ _, err = driver.GetDB().ExecContext(ctx, tc.ddl)
require.NoError(t, err)
// Get metadata using Driver.SyncDBSchema
- syncMetadata, err := getSyncMetadata(ctx, &testConnConfig, dbName)
+ syncMetadata, err := driver.SyncDBSchema(ctx)
require.NoError(t, err)
// Get metadata using get_database_metadata
@@ -910,48 +881,6 @@ INSERT INTO array_types_test (
}
}
-// getSyncMetadata retrieves metadata from the live database using Driver.SyncDBSchema
-func getSyncMetadata(ctx context.Context, connConfig *pgx.ConnConfig, dbName string) (*storepb.DatabaseSchemaMetadata, error) {
- // Create a driver instance using the pg package
- driver := &pgdb.Driver{}
-
- // Create connection config
- config := db.ConnectionConfig{
- DataSource: &storepb.DataSource{
- Type: storepb.DataSourceType_ADMIN,
- Username: connConfig.User,
- Host: connConfig.Host,
- Port: fmt.Sprintf("%d", connConfig.Port),
- Database: dbName,
- },
- Password: connConfig.Password,
- ConnectionContext: db.ConnectionContext{
- EngineVersion: "16.0", // PostgreSQL 16
- DatabaseName: dbName,
- },
- }
-
- // Open connection using the driver
- openedDriver, err := driver.Open(ctx, storepb.Engine_POSTGRES, config)
- if err != nil {
- return nil, err
- }
- defer openedDriver.Close(ctx)
-
- // Use SyncDBSchema to get the metadata
- pgDriver, ok := openedDriver.(*pgdb.Driver)
- if !ok {
- return nil, errors.New("failed to cast to pg.Driver")
- }
-
- metadata, err := pgDriver.SyncDBSchema(ctx)
- if err != nil {
- return nil, err
- }
-
- return metadata, nil
-}
-
// compareMetadata compares metadata from sync.go and get_database_metadata
func compareMetadata(t *testing.T, syncMeta, parseMeta *storepb.DatabaseSchemaMetadata) {
// Compare schemas
diff --git a/backend/plugin/schema/pg/sdl_validation_testcontainer_test.go b/backend/plugin/schema/pg/sdl_validation_testcontainer_test.go
index 0dd64153f8..ad1b96f595 100644
--- a/backend/plugin/schema/pg/sdl_validation_testcontainer_test.go
+++ b/backend/plugin/schema/pg/sdl_validation_testcontainer_test.go
@@ -10,19 +10,11 @@ import (
"testing"
"time"
- "database/sql"
-
- "github.com/jackc/pgx/v5"
- "github.com/jackc/pgx/v5/stdlib"
"github.com/pkg/errors"
"github.com/stretchr/testify/require"
- "github.com/testcontainers/testcontainers-go"
- "github.com/testcontainers/testcontainers-go/modules/postgres"
- "github.com/testcontainers/testcontainers-go/wait"
+ "github.com/bytebase/bytebase/backend/common/testcontainer"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
- "github.com/bytebase/bytebase/backend/plugin/db"
- pgdb "github.com/bytebase/bytebase/backend/plugin/db/pg"
"github.com/bytebase/bytebase/backend/plugin/schema"
"github.com/bytebase/bytebase/backend/store/model"
)
@@ -34,37 +26,14 @@ import (
// 3. Define expected schema C, use getDatabaseMetadata to get its metadata, generate diff from B to C, then generate migration DDL
// 4. Apply generated DDL to database, then sync to get schema D
// 5. Verify schema D and schema C metadata have no diff and validate each member consistently
+//
+//nolint:tparallel
func TestSDLValidationWithTestcontainer(t *testing.T) {
ctx := context.Background()
- // Start PostgreSQL container
- pgContainer, err := postgres.Run(ctx,
- "postgres:16-alpine",
- postgres.WithDatabase("test_db"),
- postgres.WithUsername("postgres"),
- postgres.WithPassword("test"),
- testcontainers.WithWaitStrategy(
- wait.ForLog("database system is ready to accept connections").
- WithOccurrence(2).
- WithStartupTimeout(5*time.Minute),
- ),
- )
- require.NoError(t, err)
- defer func() {
- if err := pgContainer.Terminate(ctx); err != nil {
- t.Logf("failed to terminate container: %s", err)
- }
- }()
-
- // Get connection string
- connectionString, err := pgContainer.ConnectionString(ctx, "sslmode=disable")
- require.NoError(t, err)
-
- // Connect to the database
- connConfig, err := pgx.ParseConfig(connectionString)
- require.NoError(t, err)
- db := stdlib.OpenDB(*connConfig)
- defer db.Close()
+ // Start shared PostgreSQL container for all subtests
+ container := testcontainer.GetTestPgContainer(ctx, t)
+ t.Cleanup(func() { container.Close(ctx) })
// Test cases following the 5-step SDL validation process
testCases := []struct {
@@ -914,135 +883,73 @@ CREATE TABLE employees (
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
- // Create a new database for each test case
- dbName := fmt.Sprintf("sdl_test_%s", tc.name)
- _, err := db.Exec(fmt.Sprintf("CREATE DATABASE %s", dbName))
+ t.Parallel()
+
+ // Create a new database for each test case with unique name
+ dbName := fmt.Sprintf("sdl_test_%s_%d", strings.ReplaceAll(tc.name, "-", "_"), time.Now().UnixNano()%1000000)
+ _, err := container.GetDB().Exec(fmt.Sprintf("CREATE DATABASE %s", dbName))
require.NoError(t, err)
- // Connect to the test database
- testConnConfig := *connConfig
- testConnConfig.Database = dbName
- testDB := stdlib.OpenDB(testConnConfig)
- defer testDB.Close()
+ // Create driver for the test database
+ driver, err := createPgDriver(ctx, container.GetHost(), container.GetPort(), dbName)
+ require.NoError(t, err)
+ defer driver.Close(ctx)
// Execute the 5-step SDL validation process
- err = executeSDLValidationProcess(ctx, t, &testConnConfig, testDB, dbName, tc.initialSchema, tc.expectedSchema, tc.description)
- require.NoError(t, err, "SDL validation process should complete successfully for test case: %s", tc.description)
- })
- }
-}
+ t.Logf("Starting SDL validation process for: %s", tc.description)
-// executeSDLValidationProcess implements the 5-step SDL validation workflow
-func executeSDLValidationProcess(ctx context.Context, t *testing.T, connConfig *pgx.ConnConfig, testDB *sql.DB, dbName, initialSchema, expectedSchema, description string) error {
- t.Logf("Starting SDL validation process for: %s", description)
-
- // Step 1: Apply initial schema A to database
- t.Log("Step 1: Applying initial schema A to database")
- if strings.TrimSpace(initialSchema) != "" {
- _, err := testDB.Exec(initialSchema)
- if err != nil {
- return errors.Wrapf(err, "failed to apply initial schema")
- }
- }
+ // Step 1: Apply initial schema A to database
+ t.Log("Step 1: Applying initial schema A to database")
+ if strings.TrimSpace(tc.initialSchema) != "" {
+ _, err = driver.GetDB().ExecContext(ctx, tc.initialSchema)
+ require.NoError(t, err, "failed to apply initial schema")
+ }
- // Step 2: Sync to get schema B from database
- t.Log("Step 2: Syncing to get schema B from database")
- schemaB, err := getSyncMetadataForSDL(ctx, connConfig, dbName)
- if err != nil {
- return errors.Wrapf(err, "failed to sync schema B")
- }
+ // Step 2: Sync to get schema B from database
+ t.Log("Step 2: Syncing to get schema B from database")
+ schemaB, err := driver.SyncDBSchema(ctx)
+ require.NoError(t, err, "failed to sync schema B")
- // Step 3: Define expected schema C, use getDatabaseMetadata to get its metadata, generate diff from B to C, then generate migration DDL
- t.Log("Step 3: Define expected schema C, use getDatabaseMetadata to get its metadata, generate diff from B to C, then generate migration DDL")
+ // Step 3: Define expected schema C, use getDatabaseMetadata to get its metadata, generate diff from B to C, then generate migration DDL
+ t.Log("Step 3: Define expected schema C, use getDatabaseMetadata to get its metadata, generate diff from B to C, then generate migration DDL")
- // Get metadata for expected schema C using GetDatabaseMetadata
- // Note: Empty expectedSchema means we expect an empty database (all objects dropped)
- schemaCMetadata, err := GetDatabaseMetadata(expectedSchema)
- if err != nil {
- return errors.Wrapf(err, "failed to get expected schema C metadata")
- }
+ // Get metadata for expected schema C using GetDatabaseMetadata
+ // Note: Empty expectedSchema means we expect an empty database (all objects dropped)
+ schemaCMetadata, err := GetDatabaseMetadata(tc.expectedSchema)
+ require.NoError(t, err, "failed to get expected schema C metadata")
- // Generate migration DDL from schema B to schema C using the differ
- migrationDDL, actualDiff, err := generateMigrationDDLFromMetadata(schemaB, schemaCMetadata)
- require.NoError(t, err, "Failed to generate migration DDL from metadata")
+ // Generate migration DDL from schema B to schema C using the differ
+ migrationDDL, actualDiff, err := generateMigrationDDLFromMetadata(schemaB, schemaCMetadata)
+ require.NoError(t, err, "Failed to generate migration DDL from metadata")
- t.Logf("Generated migration DDL (%d characters):\n%s", len(migrationDDL), migrationDDL)
+ t.Logf("Generated migration DDL (%d characters):\n%s", len(migrationDDL), migrationDDL)
- // Save or validate the actual diff (B to C) and DDL files
- testName := strings.ReplaceAll(t.Name(), "/", "_")
- err = validateOrSaveTestFiles(t, actualDiff, testName, migrationDDL)
- if err != nil {
- return errors.Wrapf(err, "test file validation/creation failed")
- }
+ // Save or validate the actual diff (B to C) and DDL files
+ testName := strings.ReplaceAll(t.Name(), "/", "_")
+ err = validateOrSaveTestFiles(t, actualDiff, testName, migrationDDL)
+ require.NoError(t, err, "test file validation/creation failed")
- // Step 4: Apply generated DDL to database, then sync to get schema D
- t.Log("Step 4: Apply generated DDL to database, then sync to get schema D")
- if strings.TrimSpace(migrationDDL) != "" {
- _, err := testDB.Exec(migrationDDL)
- if err != nil {
- return errors.Wrapf(err, "failed to apply migration DDL")
- }
- }
-
- // Sync to get schema D after migration
- schemaD, err := getSyncMetadataForSDL(ctx, connConfig, dbName)
- if err != nil {
- return errors.Wrapf(err, "failed to sync schema D after migration")
- }
-
- // Step 5: Verify schema D and schema C metadata have no diff and validate each member consistently
- t.Log("Step 5: Verify schema D and schema C metadata have no diff and validate each member consistently")
-
- // Compare schema D with schema C metadata to ensure they match
- err = validateSchemaConsistency(schemaD, schemaCMetadata)
- if err != nil {
- return errors.Wrapf(err, "schema validation failed - schema D does not match expected schema C")
- }
-
- t.Logf("✓ SDL validation process completed successfully for: %s", description)
- return nil
-}
+ // Step 4: Apply generated DDL to database, then sync to get schema D
+ t.Log("Step 4: Apply generated DDL to database, then sync to get schema D")
+ if strings.TrimSpace(migrationDDL) != "" {
+ _, err = driver.GetDB().ExecContext(ctx, migrationDDL)
+ require.NoError(t, err, "failed to apply migration DDL")
+ }
-// getSyncMetadataForSDL retrieves metadata from the live database using Driver.SyncDBSchema
-func getSyncMetadataForSDL(ctx context.Context, connConfig *pgx.ConnConfig, dbName string) (*storepb.DatabaseSchemaMetadata, error) {
- // Create a driver instance using the pg package
- driver := &pgdb.Driver{}
-
- // Create connection config
- config := db.ConnectionConfig{
- DataSource: &storepb.DataSource{
- Type: storepb.DataSourceType_ADMIN,
- Username: connConfig.User,
- Host: connConfig.Host,
- Port: fmt.Sprintf("%d", connConfig.Port),
- Database: dbName,
- },
- Password: connConfig.Password,
- ConnectionContext: db.ConnectionContext{
- EngineVersion: "16.0", // PostgreSQL 16
- DatabaseName: dbName,
- },
- }
+ // Sync to get schema D after migration
+ schemaD, err := driver.SyncDBSchema(ctx)
+ require.NoError(t, err, "failed to sync schema D after migration")
- // Open connection using the driver
- openedDriver, err := driver.Open(ctx, storepb.Engine_POSTGRES, config)
- if err != nil {
- return nil, err
- }
- defer openedDriver.Close(ctx)
+ // Step 5: Verify schema D and schema C metadata have no diff and validate each member consistently
+ t.Log("Step 5: Verify schema D and schema C metadata have no diff and validate each member consistently")
- // Use SyncDBSchema to get the metadata
- pgDriver, ok := openedDriver.(*pgdb.Driver)
- if !ok {
- return nil, errors.New("failed to cast to pg.Driver")
- }
+ // Compare schema D with schema C metadata to ensure they match
+ err = validateSchemaConsistency(schemaD, schemaCMetadata)
+ require.NoError(t, err, "schema validation failed - schema D does not match expected schema C")
- metadata, err := pgDriver.SyncDBSchema(ctx)
- if err != nil {
- return nil, err
+ t.Logf("✓ SDL validation process completed successfully for: %s", tc.description)
+ })
}
-
- return metadata, nil
}
// generateMigrationDDLFromMetadata generates migration DDL from schema B to schema C using schema.differ
diff --git a/backend/plugin/schema/pg/testutil_test.go b/backend/plugin/schema/pg/testutil_test.go
new file mode 100644
index 0000000000..1f793bde49
--- /dev/null
+++ b/backend/plugin/schema/pg/testutil_test.go
@@ -0,0 +1,34 @@
+package pg
+
+import (
+ "context"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/db"
+ pgdb "github.com/bytebase/bytebase/backend/plugin/db/pg"
+)
+
+// createPgDriver creates and opens a PostgreSQL driver for the specified database.
+// This is a shared helper function for tests.
+func createPgDriver(ctx context.Context, host, port, database string) (*pgdb.Driver, error) {
+ driver := &pgdb.Driver{}
+ config := db.ConnectionConfig{
+ DataSource: &storepb.DataSource{
+ Type: storepb.DataSourceType_ADMIN,
+ Username: "postgres",
+ Host: host,
+ Port: port,
+ Database: database,
+ },
+ Password: "root-password",
+ ConnectionContext: db.ConnectionContext{
+ EngineVersion: "16.0",
+ DatabaseName: database,
+ },
+ }
+ _, err := driver.Open(ctx, storepb.Engine_POSTGRES, config)
+ if err != nil {
+ return nil, err
+ }
+ return driver, nil
+}
diff --git a/backend/plugin/schema/tidb/generate_migration_testcontainer_test.go b/backend/plugin/schema/tidb/generate_migration_testcontainer_test.go
index 6635f16274..c432e7a404 100644
--- a/backend/plugin/schema/tidb/generate_migration_testcontainer_test.go
+++ b/backend/plugin/schema/tidb/generate_migration_testcontainer_test.go
@@ -33,9 +33,6 @@ func TestGenerateMigrationWithTestcontainer(t *testing.T) {
container := testcontainer.GetTestTiDBContainer(ctx, t)
t.Cleanup(func() { container.Close(ctx) })
- host := container.GetHost()
- port := container.GetPort()
-
// Test cases with various schema changes
testCases := []struct {
name string
@@ -1367,7 +1364,7 @@ ALTER TABLE test_table COMMENT = '';
require.NoError(t, err, "failed to create test database")
// Create driver for this test database
- driver, err := createTiDBDriver(ctx, host, port, testDB)
+ driver, err := createTiDBDriver(ctx, container.GetHost(), container.GetPort(), testDB)
require.NoError(t, err, "failed to create driver")
defer driver.Close(ctx)
diff --git a/backend/plugin/schema/tidb/get_database_definition_testcontainer_test.go b/backend/plugin/schema/tidb/get_database_definition_testcontainer_test.go
index fa035fed05..77f93d1542 100644
--- a/backend/plugin/schema/tidb/get_database_definition_testcontainer_test.go
+++ b/backend/plugin/schema/tidb/get_database_definition_testcontainer_test.go
@@ -29,9 +29,6 @@ func TestGetDatabaseDefinition(t *testing.T) {
container := testcontainer.GetTestTiDBContainer(ctx, t)
t.Cleanup(func() { container.Close(ctx) })
- host := container.GetHost()
- port := container.GetPort()
-
type testCase struct {
description string
originalDDL string
@@ -197,7 +194,7 @@ CREATE TABLE nonclustered_pk (
require.NoError(t, err)
// Get the original database metadata using SyncDBSchema
- driver, err := createTiDBDriver(ctx, host, port, testDB)
+ driver, err := createTiDBDriver(ctx, container.GetHost(), container.GetPort(), testDB)
require.NoError(t, err)
defer driver.Close(ctx)
// Execute original DDL
@@ -218,7 +215,7 @@ CREATE TABLE nonclustered_pk (
require.NoError(t, err)
// Get the new database metadata
- newDriver, err := createTiDBDriver(ctx, host, port, newTestDB)
+ newDriver, err := createTiDBDriver(ctx, container.GetHost(), container.GetPort(), newTestDB)
require.NoError(t, err)
defer newDriver.Close(ctx)
@@ -250,9 +247,6 @@ func TestGetDatabaseDefinitionWithConnectedDeps(t *testing.T) {
container := testcontainer.GetTestTiDBContainer(ctx, t)
t.Cleanup(func() { container.Close(ctx) })
- host := container.GetHost()
- port := container.GetPort()
-
// Create unique test database using UUID
testDB := fmt.Sprintf("test_%s", strings.ReplaceAll(uuid.New().String(), "-", "_"))
@@ -304,7 +298,7 @@ CREATE TABLE project_members (
require.NoError(t, err)
// Get the original database metadata
- driver, err := createTiDBDriver(ctx, host, port, testDB)
+ driver, err := createTiDBDriver(ctx, container.GetHost(), container.GetPort(), testDB)
require.NoError(t, err)
// Execute original DDL
_, err = driver.GetDB().Exec(originalDDL)
@@ -325,7 +319,7 @@ CREATE TABLE project_members (
require.NoError(t, err)
// Get the new database metadata
- newDriver, err := createTiDBDriver(ctx, host, port, newTestDB)
+ newDriver, err := createTiDBDriver(ctx, container.GetHost(), container.GetPort(), newTestDB)
require.NoError(t, err)
defer newDriver.Close(ctx)
diff --git a/backend/plugin/schema/tidb/get_database_metadata_testcontainer_test.go b/backend/plugin/schema/tidb/get_database_metadata_testcontainer_test.go
index 8bb5b11f47..41f7f73ab4 100644
--- a/backend/plugin/schema/tidb/get_database_metadata_testcontainer_test.go
+++ b/backend/plugin/schema/tidb/get_database_metadata_testcontainer_test.go
@@ -26,9 +26,6 @@ func TestGetDatabaseMetadataWithTestcontainer(t *testing.T) {
container := testcontainer.GetTestTiDBContainer(ctx, t)
t.Cleanup(func() { container.Close(ctx) })
- host := container.GetHost()
- port := container.GetPort()
-
// Test cases with various TiDB features
testCases := []struct {
name string
@@ -210,7 +207,7 @@ CREATE TABLE non_clustered_test (
require.NoError(t, err)
// Create TiDB driver for this test database
- driver, err := createTiDBDriver(ctx, host, port, testDB)
+ driver, err := createTiDBDriver(ctx, container.GetHost(), container.GetPort(), testDB)
require.NoError(t, err)
defer driver.Close(ctx)
diff --git a/go.mod b/go.mod
index 4550d1593f..951d444ccc 100644
--- a/go.mod
+++ b/go.mod
@@ -85,7 +85,6 @@ require (
github.com/spf13/cobra v1.10.2
github.com/stretchr/testify v1.11.1
github.com/testcontainers/testcontainers-go v0.40.0
- github.com/testcontainers/testcontainers-go/modules/postgres v0.40.0
github.com/tmc/grpc-websocket-proxy v0.0.0-20220101234140-673ab2c3ae75
github.com/trinodb/trino-go-client v0.333.0
github.com/vjeantet/ldapserver v1.0.1
diff --git a/go.sum b/go.sum
index 0e19185013..02d0945897 100644
--- a/go.sum
+++ b/go.sum
@@ -1504,8 +1504,6 @@ github.com/mattn/go-sqlite3 v1.14.6/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A
github.com/mattn/go-sqlite3 v1.14.14/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU=
github.com/mattn/go-sqlite3 v1.14.32 h1:JD12Ag3oLy1zQA+BNn74xRgaBbdhbNIDYvQUEuuErjs=
github.com/mattn/go-sqlite3 v1.14.32/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
-github.com/mdelapenya/tlscert v0.2.0 h1:7H81W6Z/4weDvZBNOfQte5GpIMo0lGYEeWbkGp5LJHI=
-github.com/mdelapenya/tlscert v0.2.0/go.mod h1:O4njj3ELLnJjGdkN7M/vIVCpZ+Cf0L6muqOG4tLSl8o=
github.com/minio/asm2plan9s v0.0.0-20200509001527-cdd76441f9d8 h1:AMFGa4R4MiIpspGNG7Z948v4n35fFGB3RR3G/ry4FWs=
github.com/minio/asm2plan9s v0.0.0-20200509001527-cdd76441f9d8/go.mod h1:mC1jAcsrzbxHt8iiaC+zU4b1ylILSosueou12R++wfY=
github.com/minio/c2goasm v0.0.0-20190812172519-36a3d3bbc4f3 h1:+n/aFZefKZp7spd8DFdX7uMikMLXX4oubIzJF4kv/wI=
@@ -1767,8 +1765,6 @@ github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu
github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
github.com/testcontainers/testcontainers-go v0.40.0 h1:pSdJYLOVgLE8YdUY2FHQ1Fxu+aMnb6JfVz1mxk7OeMU=
github.com/testcontainers/testcontainers-go v0.40.0/go.mod h1:FSXV5KQtX2HAMlm7U3APNyLkkap35zNLxukw9oBi/MY=
-github.com/testcontainers/testcontainers-go/modules/postgres v0.40.0 h1:s2bIayFXlbDFexo96y+htn7FzuhpXLYJNnIuglNKqOk=
-github.com/testcontainers/testcontainers-go/modules/postgres v0.40.0/go.mod h1:h+u/2KoREGTnTl9UwrQ/g+XhasAT8E6dClclAADeXoQ=
github.com/the42/cartconvert v0.0.0-20131203171324-aae784c392b8 h1:I4DY8wLxJXCrMYzDM6lKCGc3IQwJX0PlTLsd3nQqI3c=
github.com/the42/cartconvert v0.0.0-20131203171324-aae784c392b8/go.mod h1:fWO/msnJVhHqN1yX6OBoxSyfj7TEj1hHiL8bJSQsK30=
github.com/tiancaiamao/gp v0.0.0-20221230034425-4025bc8a4d4a h1:J/YdBZ46WKpXsxsW93SG+q0F8KI+yFrcIDT4c/RNoc4=