Hein
d84306934a
Existing databases that already ran an old migration kept stale NOT NULL constraints and mismatched column types/defaults, because the schema writer only emitted idempotent ADD COLUMN IF NOT EXISTS guards and never altered columns that already existed. - Emit guarded ALTER COLUMN ... SET/DROP NOT NULL when a column's nullability differs from the model. - Emit guarded ALTER COLUMN ... TYPE, falling back to renaming the old column and adding a fresh one when the in-place conversion fails. - Emit guarded ALTER COLUMN ... SET/DROP DEFAULT for default drift. - Collapse the previously duplicated plain/guarded templates so WriteSchema (full-schema, live-state-checking) and WriteMigration (diff-based) share the same guarded SQL templates and Go helpers instead of maintaining the logic twice.
815 lines
26 KiB
Go
815 lines
26 KiB
Go
package pgsql
|
|
|
|
import (
|
|
"bytes"
|
|
"strings"
|
|
"testing"
|
|
|
|
"git.warky.dev/wdevs/relspecgo/pkg/models"
|
|
"git.warky.dev/wdevs/relspecgo/pkg/writers"
|
|
)
|
|
|
|
func TestWriteMigration_NewTable(t *testing.T) {
|
|
// Current database (empty)
|
|
current := models.InitDatabase("testdb")
|
|
currentSchema := models.InitSchema("public")
|
|
current.Schemas = append(current.Schemas, currentSchema)
|
|
|
|
// Model database (with new table)
|
|
model := models.InitDatabase("testdb")
|
|
modelSchema := models.InitSchema("public")
|
|
|
|
table := models.InitTable("users", "public")
|
|
idCol := models.InitColumn("id", "users", "public")
|
|
idCol.Type = "integer"
|
|
idCol.NotNull = true
|
|
table.Columns["id"] = idCol
|
|
|
|
nameCol := models.InitColumn("name", "users", "public")
|
|
nameCol.Type = "text"
|
|
table.Columns["name"] = nameCol
|
|
|
|
modelSchema.Tables = append(modelSchema.Tables, table)
|
|
model.Schemas = append(model.Schemas, modelSchema)
|
|
|
|
// Generate migration
|
|
var buf bytes.Buffer
|
|
writer, err := NewMigrationWriter(&writers.WriterOptions{})
|
|
if err != nil {
|
|
t.Fatalf("Failed to create writer: %v", err)
|
|
}
|
|
writer.writer = &buf
|
|
|
|
err = writer.WriteMigration(model, current)
|
|
if err != nil {
|
|
t.Fatalf("WriteMigration failed: %v", err)
|
|
}
|
|
|
|
output := buf.String()
|
|
t.Logf("Generated migration:\n%s", output)
|
|
|
|
// Verify CREATE TABLE is present
|
|
if !strings.Contains(output, "CREATE TABLE") {
|
|
t.Error("Migration missing CREATE TABLE statement")
|
|
}
|
|
if !strings.Contains(output, "users") {
|
|
t.Error("Migration missing table name 'users'")
|
|
}
|
|
}
|
|
|
|
func TestWriteMigration_ArrayDefault(t *testing.T) {
|
|
current := models.InitDatabase("testdb")
|
|
currentSchema := models.InitSchema("public")
|
|
current.Schemas = append(current.Schemas, currentSchema)
|
|
|
|
model := models.InitDatabase("testdb")
|
|
modelSchema := models.InitSchema("public")
|
|
|
|
table := models.InitTable("plans", "public")
|
|
|
|
tagsCol := models.InitColumn("tags", "plans", "public")
|
|
tagsCol.Type = "text[]"
|
|
tagsCol.NotNull = true
|
|
tagsCol.Default = "''{}''"
|
|
table.Columns["tags"] = tagsCol
|
|
|
|
modelSchema.Tables = append(modelSchema.Tables, table)
|
|
model.Schemas = append(model.Schemas, modelSchema)
|
|
|
|
var buf bytes.Buffer
|
|
writer, err := NewMigrationWriter(&writers.WriterOptions{})
|
|
if err != nil {
|
|
t.Fatalf("Failed to create writer: %v", err)
|
|
}
|
|
writer.writer = &buf
|
|
|
|
err = writer.WriteMigration(model, current)
|
|
if err != nil {
|
|
t.Fatalf("WriteMigration failed: %v", err)
|
|
}
|
|
|
|
output := buf.String()
|
|
if !strings.Contains(output, "tags text[] DEFAULT '{}' NOT NULL") {
|
|
t.Fatalf("expected normalized array default in migration, got:\n%s", output)
|
|
}
|
|
if strings.Contains(output, "'''{}'''") {
|
|
t.Fatalf("migration still contains triple-quoted array default:\n%s", output)
|
|
}
|
|
}
|
|
|
|
func TestWriteMigration_AltersColumnTypeWhenActualTypeDiffers(t *testing.T) {
|
|
current := models.InitDatabase("testdb")
|
|
currentSchema := models.InitSchema("public")
|
|
currentTable := models.InitTable("learnings", "public")
|
|
currentDetails := models.InitColumn("details", "learnings", "public")
|
|
currentDetails.Type = "jsonb"
|
|
currentTable.Columns["details"] = currentDetails
|
|
currentSchema.Tables = append(currentSchema.Tables, currentTable)
|
|
current.Schemas = append(current.Schemas, currentSchema)
|
|
|
|
model := models.InitDatabase("testdb")
|
|
modelSchema := models.InitSchema("public")
|
|
modelTable := models.InitTable("learnings", "public")
|
|
modelDetails := models.InitColumn("details", "learnings", "public")
|
|
modelDetails.Type = "text"
|
|
modelTable.Columns["details"] = modelDetails
|
|
modelSchema.Tables = append(modelSchema.Tables, modelTable)
|
|
model.Schemas = append(model.Schemas, modelSchema)
|
|
|
|
var buf bytes.Buffer
|
|
writer, err := NewMigrationWriter(&writers.WriterOptions{})
|
|
if err != nil {
|
|
t.Fatalf("Failed to create writer: %v", err)
|
|
}
|
|
writer.writer = &buf
|
|
|
|
if err := writer.WriteMigration(model, current); err != nil {
|
|
t.Fatalf("WriteMigration failed: %v", err)
|
|
}
|
|
|
|
output := buf.String()
|
|
if !strings.Contains(output, "ALTER TABLE public.learnings") || !strings.Contains(output, "ALTER COLUMN details TYPE text") {
|
|
t.Fatalf("expected migration to alter mismatched column type, got:\n%s", output)
|
|
}
|
|
if !strings.Contains(output, `ALTER COLUMN details TYPE text USING details::text;`) {
|
|
t.Fatalf("expected migration type alter to include USING cast, got:\n%s", output)
|
|
}
|
|
}
|
|
|
|
func TestWriteMigration_AltersColumnTypeFallsBackToRenameAndAddOnConversionFailure(t *testing.T) {
|
|
current := models.InitDatabase("testdb")
|
|
currentSchema := models.InitSchema("public")
|
|
currentTable := models.InitTable("learnings", "public")
|
|
currentDetails := models.InitColumn("details", "learnings", "public")
|
|
currentDetails.Type = "varchar(50)"
|
|
currentTable.Columns["details"] = currentDetails
|
|
currentSchema.Tables = append(currentSchema.Tables, currentTable)
|
|
current.Schemas = append(current.Schemas, currentSchema)
|
|
|
|
model := models.InitDatabase("testdb")
|
|
modelSchema := models.InitSchema("public")
|
|
modelTable := models.InitTable("learnings", "public")
|
|
modelDetails := models.InitColumn("details", "learnings", "public")
|
|
modelDetails.Type = "integer"
|
|
modelTable.Columns["details"] = modelDetails
|
|
modelSchema.Tables = append(modelSchema.Tables, modelTable)
|
|
model.Schemas = append(model.Schemas, modelSchema)
|
|
|
|
var buf bytes.Buffer
|
|
writer, err := NewMigrationWriter(&writers.WriterOptions{})
|
|
if err != nil {
|
|
t.Fatalf("Failed to create writer: %v", err)
|
|
}
|
|
writer.writer = &buf
|
|
|
|
if err := writer.WriteMigration(model, current); err != nil {
|
|
t.Fatalf("WriteMigration failed: %v", err)
|
|
}
|
|
|
|
output := buf.String()
|
|
if !strings.Contains(output, "EXCEPTION WHEN OTHERS THEN") {
|
|
t.Fatalf("expected migration to guard the type conversion with an exception handler, got:\n%s", output)
|
|
}
|
|
if !strings.Contains(output, "RENAME COLUMN details TO %I") {
|
|
t.Fatalf("expected migration to rename the old column (derived from the live type) on conversion failure, got:\n%s", output)
|
|
}
|
|
if !strings.Contains(output, "renamed_column := 'details_' || trim(both '_' from regexp_replace(lower(current_type)") {
|
|
t.Fatalf("expected migration to derive the renamed column name from the live type, got:\n%s", output)
|
|
}
|
|
if !strings.Contains(output, "ADD COLUMN details integer") {
|
|
t.Fatalf("expected migration to add a fresh column with the new type on conversion failure, got:\n%s", output)
|
|
}
|
|
}
|
|
|
|
func TestWriteMigration_AltersColumnNullabilityWhenNotNullDiffers(t *testing.T) {
|
|
current := models.InitDatabase("testdb")
|
|
currentSchema := models.InitSchema("public")
|
|
currentTable := models.InitTable("service_instance", "public")
|
|
currentType := models.InitColumn("rid_service_instance_type", "service_instance", "public")
|
|
currentType.Type = "text"
|
|
currentType.NotNull = true
|
|
currentTable.Columns["rid_service_instance_type"] = currentType
|
|
currentSchema.Tables = append(currentSchema.Tables, currentTable)
|
|
current.Schemas = append(current.Schemas, currentSchema)
|
|
|
|
model := models.InitDatabase("testdb")
|
|
modelSchema := models.InitSchema("public")
|
|
modelTable := models.InitTable("service_instance", "public")
|
|
modelType := models.InitColumn("rid_service_instance_type", "service_instance", "public")
|
|
modelType.Type = "text"
|
|
modelType.NotNull = false
|
|
modelTable.Columns["rid_service_instance_type"] = modelType
|
|
modelSchema.Tables = append(modelSchema.Tables, modelTable)
|
|
model.Schemas = append(model.Schemas, modelSchema)
|
|
|
|
var buf bytes.Buffer
|
|
writer, err := NewMigrationWriter(&writers.WriterOptions{})
|
|
if err != nil {
|
|
t.Fatalf("Failed to create writer: %v", err)
|
|
}
|
|
writer.writer = &buf
|
|
|
|
if err := writer.WriteMigration(model, current); err != nil {
|
|
t.Fatalf("WriteMigration failed: %v", err)
|
|
}
|
|
|
|
output := buf.String()
|
|
if !strings.Contains(output, "ALTER COLUMN rid_service_instance_type DROP NOT NULL") {
|
|
t.Fatalf("expected migration to drop NOT NULL on existing column, got:\n%s", output)
|
|
}
|
|
}
|
|
|
|
func TestWriteMigration_UsesStorageTypeForSerialAlterStatements(t *testing.T) {
|
|
current := models.InitDatabase("testdb")
|
|
currentSchema := models.InitSchema("public")
|
|
currentTable := models.InitTable("learnings", "public")
|
|
currentID := models.InitColumn("id", "learnings", "public")
|
|
currentID.Type = "uuid"
|
|
currentTable.Columns["id"] = currentID
|
|
currentSchema.Tables = append(currentSchema.Tables, currentTable)
|
|
current.Schemas = append(current.Schemas, currentSchema)
|
|
|
|
model := models.InitDatabase("testdb")
|
|
modelSchema := models.InitSchema("public")
|
|
modelTable := models.InitTable("learnings", "public")
|
|
modelID := models.InitColumn("id", "learnings", "public")
|
|
modelID.Type = "bigserial"
|
|
modelTable.Columns["id"] = modelID
|
|
modelSchema.Tables = append(modelSchema.Tables, modelTable)
|
|
model.Schemas = append(model.Schemas, modelSchema)
|
|
|
|
var buf bytes.Buffer
|
|
writer, err := NewMigrationWriter(&writers.WriterOptions{})
|
|
if err != nil {
|
|
t.Fatalf("Failed to create writer: %v", err)
|
|
}
|
|
writer.writer = &buf
|
|
|
|
if err := writer.WriteMigration(model, current); err != nil {
|
|
t.Fatalf("WriteMigration failed: %v", err)
|
|
}
|
|
|
|
output := buf.String()
|
|
if !strings.Contains(output, "ALTER COLUMN id TYPE bigint") {
|
|
t.Fatalf("expected serial alter to use bigint storage type, got:\n%s", output)
|
|
}
|
|
if strings.Contains(output, "ALTER COLUMN id TYPE bigserial;") {
|
|
t.Fatalf("did not expect invalid bigserial alter statement, got:\n%s", output)
|
|
}
|
|
if !strings.Contains(output, `ALTER COLUMN id TYPE bigint USING id::bigint;`) {
|
|
t.Fatalf("expected serial alter to include USING cast, got:\n%s", output)
|
|
}
|
|
}
|
|
|
|
func TestWriteMigration_ArrayAlterIncludesUsingCast(t *testing.T) {
|
|
current := models.InitDatabase("testdb")
|
|
currentSchema := models.InitSchema("public")
|
|
currentTable := models.InitTable("learnings", "public")
|
|
currentTags := models.InitColumn("tags", "learnings", "public")
|
|
currentTags.Type = "text"
|
|
currentTable.Columns["tags"] = currentTags
|
|
currentSchema.Tables = append(currentSchema.Tables, currentTable)
|
|
current.Schemas = append(current.Schemas, currentSchema)
|
|
|
|
model := models.InitDatabase("testdb")
|
|
modelSchema := models.InitSchema("public")
|
|
modelTable := models.InitTable("learnings", "public")
|
|
modelTags := models.InitColumn("tags", "learnings", "public")
|
|
modelTags.Type = "text[]"
|
|
modelTable.Columns["tags"] = modelTags
|
|
modelSchema.Tables = append(modelSchema.Tables, modelTable)
|
|
model.Schemas = append(model.Schemas, modelSchema)
|
|
|
|
var buf bytes.Buffer
|
|
writer, err := NewMigrationWriter(&writers.WriterOptions{})
|
|
if err != nil {
|
|
t.Fatalf("Failed to create writer: %v", err)
|
|
}
|
|
writer.writer = &buf
|
|
|
|
if err := writer.WriteMigration(model, current); err != nil {
|
|
t.Fatalf("WriteMigration failed: %v", err)
|
|
}
|
|
|
|
output := buf.String()
|
|
if !strings.Contains(output, `ALTER COLUMN tags TYPE text[] USING tags::text[];`) {
|
|
t.Fatalf("expected array alter to include USING cast, got:\n%s", output)
|
|
}
|
|
}
|
|
|
|
func TestWriteMigration_DoesNotAlterEquivalentNormalizedColumnType(t *testing.T) {
|
|
current := models.InitDatabase("testdb")
|
|
currentSchema := models.InitSchema("public")
|
|
currentTable := models.InitTable("users", "public")
|
|
currentEmail := models.InitColumn("email", "users", "public")
|
|
currentEmail.Type = "character varying"
|
|
currentEmail.Length = 255
|
|
currentTable.Columns["email"] = currentEmail
|
|
currentSchema.Tables = append(currentSchema.Tables, currentTable)
|
|
current.Schemas = append(current.Schemas, currentSchema)
|
|
|
|
model := models.InitDatabase("testdb")
|
|
modelSchema := models.InitSchema("public")
|
|
modelTable := models.InitTable("users", "public")
|
|
modelEmail := models.InitColumn("email", "users", "public")
|
|
modelEmail.Type = "varchar(255)"
|
|
modelTable.Columns["email"] = modelEmail
|
|
modelSchema.Tables = append(modelSchema.Tables, modelTable)
|
|
model.Schemas = append(model.Schemas, modelSchema)
|
|
|
|
var buf bytes.Buffer
|
|
writer, err := NewMigrationWriter(&writers.WriterOptions{})
|
|
if err != nil {
|
|
t.Fatalf("Failed to create writer: %v", err)
|
|
}
|
|
writer.writer = &buf
|
|
|
|
if err := writer.WriteMigration(model, current); err != nil {
|
|
t.Fatalf("WriteMigration failed: %v", err)
|
|
}
|
|
|
|
output := buf.String()
|
|
if strings.Contains(output, "ALTER COLUMN email TYPE") {
|
|
t.Fatalf("did not expect alter type for equivalent normalized types, got:\n%s", output)
|
|
}
|
|
}
|
|
|
|
func TestWriteMigration_GinIndexOnTextUsesTrigramOperatorClass(t *testing.T) {
|
|
current := models.InitDatabase("testdb")
|
|
currentSchema := models.InitSchema("public")
|
|
current.Schemas = append(current.Schemas, currentSchema)
|
|
|
|
model := models.InitDatabase("testdb")
|
|
modelSchema := models.InitSchema("public")
|
|
|
|
table := models.InitTable("articles", "public")
|
|
titleCol := models.InitColumn("title", "articles", "public")
|
|
titleCol.Type = "text"
|
|
table.Columns["title"] = titleCol
|
|
|
|
index := &models.Index{
|
|
Name: "idx_articles_title_gin",
|
|
Type: "gin",
|
|
Columns: []string{"title"},
|
|
}
|
|
table.Indexes[index.Name] = index
|
|
|
|
modelSchema.Tables = append(modelSchema.Tables, table)
|
|
model.Schemas = append(model.Schemas, modelSchema)
|
|
|
|
var buf bytes.Buffer
|
|
writer, err := NewMigrationWriter(&writers.WriterOptions{})
|
|
if err != nil {
|
|
t.Fatalf("Failed to create writer: %v", err)
|
|
}
|
|
writer.writer = &buf
|
|
|
|
if err := writer.WriteMigration(model, current); err != nil {
|
|
t.Fatalf("WriteMigration failed: %v", err)
|
|
}
|
|
|
|
output := buf.String()
|
|
if !strings.Contains(output, "CREATE EXTENSION IF NOT EXISTS pg_trgm;") {
|
|
t.Fatalf("expected trigram extension for text GIN migration index, got:\n%s", output)
|
|
}
|
|
if !strings.Contains(output, "USING gin (title gin_trgm_ops)") {
|
|
t.Fatalf("expected GIN text index to include gin_trgm_ops, got:\n%s", output)
|
|
}
|
|
}
|
|
|
|
func TestWriteMigration_GinIndexOnQuotedTextColumnUsesTrigramOperatorClass(t *testing.T) {
|
|
current := models.InitDatabase("testdb")
|
|
currentSchema := models.InitSchema("public")
|
|
current.Schemas = append(current.Schemas, currentSchema)
|
|
|
|
model := models.InitDatabase("testdb")
|
|
modelSchema := models.InitSchema("public")
|
|
|
|
table := models.InitTable("agent_personas", "public")
|
|
nameCol := models.InitColumn("name", "agent_personas", "public")
|
|
nameCol.Type = "text"
|
|
table.Columns["name"] = nameCol
|
|
|
|
index := &models.Index{
|
|
Name: "idx_agent_personas_name_gin",
|
|
Type: "gin",
|
|
Columns: []string{`"name"`},
|
|
}
|
|
table.Indexes[index.Name] = index
|
|
|
|
modelSchema.Tables = append(modelSchema.Tables, table)
|
|
model.Schemas = append(model.Schemas, modelSchema)
|
|
|
|
var buf bytes.Buffer
|
|
writer, err := NewMigrationWriter(&writers.WriterOptions{})
|
|
if err != nil {
|
|
t.Fatalf("Failed to create writer: %v", err)
|
|
}
|
|
writer.writer = &buf
|
|
|
|
if err := writer.WriteMigration(model, current); err != nil {
|
|
t.Fatalf("WriteMigration failed: %v", err)
|
|
}
|
|
|
|
output := buf.String()
|
|
if !strings.Contains(output, "USING gin (name gin_trgm_ops)") {
|
|
t.Fatalf("expected quoted text column GIN index to include gin_trgm_ops, got:\n%s", output)
|
|
}
|
|
}
|
|
|
|
func TestWriteMigration_GinIndexOnTextArrayDoesNotUseTrigramOperatorClass(t *testing.T) {
|
|
current := models.InitDatabase("testdb")
|
|
currentSchema := models.InitSchema("public")
|
|
current.Schemas = append(current.Schemas, currentSchema)
|
|
|
|
model := models.InitDatabase("testdb")
|
|
modelSchema := models.InitSchema("public")
|
|
|
|
table := models.InitTable("plans", "public")
|
|
tagsCol := models.InitColumn("tags", "plans", "public")
|
|
tagsCol.Type = "text[]"
|
|
table.Columns["tags"] = tagsCol
|
|
|
|
index := &models.Index{
|
|
Name: "idx_plans_tags",
|
|
Type: "gin",
|
|
Columns: []string{"tags"},
|
|
}
|
|
table.Indexes[index.Name] = index
|
|
|
|
modelSchema.Tables = append(modelSchema.Tables, table)
|
|
model.Schemas = append(model.Schemas, modelSchema)
|
|
|
|
var buf bytes.Buffer
|
|
writer, err := NewMigrationWriter(&writers.WriterOptions{})
|
|
if err != nil {
|
|
t.Fatalf("Failed to create writer: %v", err)
|
|
}
|
|
writer.writer = &buf
|
|
|
|
if err := writer.WriteMigration(model, current); err != nil {
|
|
t.Fatalf("WriteMigration failed: %v", err)
|
|
}
|
|
|
|
output := buf.String()
|
|
if !strings.Contains(output, "USING gin (tags array_ops)") {
|
|
t.Fatalf("expected GIN array index with array_ops, got:\n%s", output)
|
|
}
|
|
if strings.Contains(output, "gin_trgm_ops") {
|
|
t.Fatalf("did not expect gin_trgm_ops for text[] migration index, got:\n%s", output)
|
|
}
|
|
}
|
|
|
|
func TestWriteMigration_GinIndexOnJSONBUsesJSONBOperatorClass(t *testing.T) {
|
|
current := models.InitDatabase("testdb")
|
|
currentSchema := models.InitSchema("public")
|
|
current.Schemas = append(current.Schemas, currentSchema)
|
|
|
|
model := models.InitDatabase("testdb")
|
|
modelSchema := models.InitSchema("public")
|
|
|
|
table := models.InitTable("learnings", "public")
|
|
detailsCol := models.InitColumn("details", "learnings", "public")
|
|
detailsCol.Type = "jsonb"
|
|
table.Columns["details"] = detailsCol
|
|
|
|
index := &models.Index{
|
|
Name: "idx_learnings_details",
|
|
Type: "gin",
|
|
Columns: []string{"details"},
|
|
}
|
|
table.Indexes[index.Name] = index
|
|
|
|
modelSchema.Tables = append(modelSchema.Tables, table)
|
|
model.Schemas = append(model.Schemas, modelSchema)
|
|
|
|
var buf bytes.Buffer
|
|
writer, err := NewMigrationWriter(&writers.WriterOptions{})
|
|
if err != nil {
|
|
t.Fatalf("Failed to create writer: %v", err)
|
|
}
|
|
writer.writer = &buf
|
|
|
|
if err := writer.WriteMigration(model, current); err != nil {
|
|
t.Fatalf("WriteMigration failed: %v", err)
|
|
}
|
|
|
|
output := buf.String()
|
|
if !strings.Contains(output, "USING gin (details jsonb_ops)") {
|
|
t.Fatalf("expected GIN jsonb index to include jsonb_ops, got:\n%s", output)
|
|
}
|
|
if strings.Contains(output, "gin_trgm_ops") {
|
|
t.Fatalf("did not expect gin_trgm_ops for jsonb migration index, got:\n%s", output)
|
|
}
|
|
}
|
|
|
|
func TestWriteMigration_GinIndexOnJSONBIgnoresIncompatibleTrigramOperatorClass(t *testing.T) {
|
|
current := models.InitDatabase("testdb")
|
|
currentSchema := models.InitSchema("public")
|
|
current.Schemas = append(current.Schemas, currentSchema)
|
|
|
|
model := models.InitDatabase("testdb")
|
|
modelSchema := models.InitSchema("public")
|
|
|
|
table := models.InitTable("learnings", "public")
|
|
detailsCol := models.InitColumn("details", "learnings", "public")
|
|
detailsCol.Type = "jsonb"
|
|
table.Columns["details"] = detailsCol
|
|
|
|
index := &models.Index{
|
|
Name: "idx_learnings_details",
|
|
Type: "gin",
|
|
Columns: []string{"details"},
|
|
Comment: "gin_trgm_ops",
|
|
}
|
|
table.Indexes[index.Name] = index
|
|
|
|
modelSchema.Tables = append(modelSchema.Tables, table)
|
|
model.Schemas = append(model.Schemas, modelSchema)
|
|
|
|
var buf bytes.Buffer
|
|
writer, err := NewMigrationWriter(&writers.WriterOptions{})
|
|
if err != nil {
|
|
t.Fatalf("Failed to create writer: %v", err)
|
|
}
|
|
writer.writer = &buf
|
|
|
|
if err := writer.WriteMigration(model, current); err != nil {
|
|
t.Fatalf("WriteMigration failed: %v", err)
|
|
}
|
|
|
|
output := buf.String()
|
|
if !strings.Contains(output, "USING gin (details jsonb_ops)") {
|
|
t.Fatalf("expected incompatible trigram hint on jsonb to fall back to jsonb_ops, got:\n%s", output)
|
|
}
|
|
}
|
|
|
|
func TestWriteMigration_WithAudit(t *testing.T) {
|
|
// Current database (empty)
|
|
current := models.InitDatabase("testdb")
|
|
currentSchema := models.InitSchema("public")
|
|
current.Schemas = append(current.Schemas, currentSchema)
|
|
|
|
// Model database (with table to audit)
|
|
model := models.InitDatabase("testdb")
|
|
modelSchema := models.InitSchema("public")
|
|
|
|
table := models.InitTable("users", "public")
|
|
|
|
idCol := models.InitColumn("id", "users", "public")
|
|
idCol.Type = "integer"
|
|
idCol.IsPrimaryKey = true
|
|
table.Columns["id"] = idCol
|
|
|
|
nameCol := models.InitColumn("name", "users", "public")
|
|
nameCol.Type = "text"
|
|
table.Columns["name"] = nameCol
|
|
|
|
passwordCol := models.InitColumn("password", "users", "public")
|
|
passwordCol.Type = "text"
|
|
table.Columns["password"] = passwordCol
|
|
|
|
modelSchema.Tables = append(modelSchema.Tables, table)
|
|
model.Schemas = append(model.Schemas, modelSchema)
|
|
|
|
// Configure audit
|
|
auditConfig := NewAuditConfig()
|
|
auditConfig.AuditSchema = "public"
|
|
tableConfig := auditConfig.EnableTableAudit("public", "users")
|
|
tableConfig.EncryptedColumns = []string{"password"}
|
|
|
|
// Generate migration with audit
|
|
var buf bytes.Buffer
|
|
options := &writers.WriterOptions{
|
|
Metadata: map[string]interface{}{
|
|
"audit_config": auditConfig,
|
|
},
|
|
}
|
|
writer, err := NewMigrationWriter(options)
|
|
if err != nil {
|
|
t.Fatalf("Failed to create writer: %v", err)
|
|
}
|
|
writer.writer = &buf
|
|
|
|
err = writer.WriteMigration(model, current)
|
|
if err != nil {
|
|
t.Fatalf("WriteMigration failed: %v", err)
|
|
}
|
|
|
|
output := buf.String()
|
|
t.Logf("Generated migration with audit:\n%s", output)
|
|
|
|
// Verify audit tables
|
|
if !strings.Contains(output, "CREATE TABLE IF NOT EXISTS public.atevent") {
|
|
t.Error("Migration missing atevent table")
|
|
}
|
|
if !strings.Contains(output, "CREATE TABLE IF NOT EXISTS public.atdetail") {
|
|
t.Error("Migration missing atdetail table")
|
|
}
|
|
|
|
// Verify audit function
|
|
if !strings.Contains(output, "CREATE OR REPLACE FUNCTION public.tf_audit_users()") {
|
|
t.Error("Migration missing audit function")
|
|
}
|
|
|
|
// Verify audit trigger
|
|
if !strings.Contains(output, "CREATE TRIGGER t_audit_users") {
|
|
t.Error("Migration missing audit trigger")
|
|
}
|
|
|
|
// Verify encrypted column handling
|
|
if !strings.Contains(output, "'****************'") {
|
|
t.Error("Migration missing encrypted column handling")
|
|
}
|
|
}
|
|
|
|
func TestTemplateExecutor_CreateTable(t *testing.T) {
|
|
executor, err := NewTemplateExecutor(false)
|
|
if err != nil {
|
|
t.Fatalf("Failed to create executor: %v", err)
|
|
}
|
|
|
|
data := CreateTableData{
|
|
SchemaName: "public",
|
|
TableName: "test_table",
|
|
Columns: []ColumnData{
|
|
{Name: "id", Type: "integer", NotNull: true},
|
|
{Name: "name", Type: "text", Default: "'unknown'"},
|
|
},
|
|
}
|
|
|
|
sql, err := executor.ExecuteCreateTable(data)
|
|
if err != nil {
|
|
t.Fatalf("Failed to execute template: %v", err)
|
|
}
|
|
|
|
t.Logf("Generated SQL:\n%s", sql)
|
|
|
|
if !strings.Contains(sql, "CREATE TABLE IF NOT EXISTS public.test_table") {
|
|
t.Error("SQL missing CREATE TABLE statement")
|
|
}
|
|
if !strings.Contains(sql, "id integer NOT NULL") {
|
|
t.Error("SQL missing id column definition")
|
|
}
|
|
if !strings.Contains(sql, "name text DEFAULT 'unknown'") {
|
|
t.Error("SQL missing name column definition")
|
|
}
|
|
}
|
|
|
|
func TestTemplateExecutor_AuditFunction(t *testing.T) {
|
|
executor, err := NewTemplateExecutor(false)
|
|
if err != nil {
|
|
t.Fatalf("Failed to create executor: %v", err)
|
|
}
|
|
|
|
data := AuditFunctionData{
|
|
SchemaName: "public",
|
|
FunctionName: "tf_audit_users",
|
|
TableName: "users",
|
|
TablePrefix: "NULL",
|
|
PrimaryKey: "id",
|
|
AuditSchema: "public",
|
|
UserFunction: "current_user",
|
|
AuditInsert: true,
|
|
AuditUpdate: true,
|
|
AuditDelete: true,
|
|
UpdateCondition: "old.name IS DISTINCT FROM new.name",
|
|
UpdateColumns: []AuditColumnData{
|
|
{Name: "name", OldValue: "old.name::text", NewValue: "new.name::text"},
|
|
},
|
|
DeleteColumns: []AuditColumnData{
|
|
{Name: "name", OldValue: "old.name::text"},
|
|
},
|
|
}
|
|
|
|
sql, err := executor.ExecuteAuditFunction(data)
|
|
if err != nil {
|
|
t.Fatalf("Failed to execute template: %v", err)
|
|
}
|
|
|
|
t.Logf("Generated SQL:\n%s", sql)
|
|
|
|
if !strings.Contains(sql, "CREATE OR REPLACE FUNCTION public.tf_audit_users()") {
|
|
t.Error("SQL missing function definition")
|
|
}
|
|
if !strings.Contains(sql, "IF TG_OP = 'INSERT'") {
|
|
t.Error("SQL missing INSERT handling")
|
|
}
|
|
if !strings.Contains(sql, "ELSIF TG_OP = 'UPDATE'") {
|
|
t.Error("SQL missing UPDATE handling")
|
|
}
|
|
if !strings.Contains(sql, "ELSIF TG_OP = 'DELETE'") {
|
|
t.Error("SQL missing DELETE handling")
|
|
}
|
|
}
|
|
|
|
func TestWriteMigration_NumericConstraintNames(t *testing.T) {
|
|
// Current database (empty)
|
|
current := models.InitDatabase("testdb")
|
|
currentSchema := models.InitSchema("entity")
|
|
current.Schemas = append(current.Schemas, currentSchema)
|
|
|
|
// Model database (with constraint starting with number)
|
|
model := models.InitDatabase("testdb")
|
|
modelSchema := models.InitSchema("entity")
|
|
|
|
// Create individual_actor_relationship table
|
|
table := models.InitTable("individual_actor_relationship", "entity")
|
|
idCol := models.InitColumn("id", "individual_actor_relationship", "entity")
|
|
idCol.Type = "integer"
|
|
idCol.IsPrimaryKey = true
|
|
table.Columns["id"] = idCol
|
|
|
|
actorIDCol := models.InitColumn("actor_id", "individual_actor_relationship", "entity")
|
|
actorIDCol.Type = "integer"
|
|
table.Columns["actor_id"] = actorIDCol
|
|
|
|
// Add constraint with name starting with number
|
|
constraint := &models.Constraint{
|
|
Name: "215162_fk_actor",
|
|
Type: models.ForeignKeyConstraint,
|
|
Columns: []string{"actor_id"},
|
|
ReferencedSchema: "entity",
|
|
ReferencedTable: "actor",
|
|
ReferencedColumns: []string{"id"},
|
|
OnDelete: "CASCADE",
|
|
OnUpdate: "NO ACTION",
|
|
}
|
|
table.Constraints["215162_fk_actor"] = constraint
|
|
|
|
modelSchema.Tables = append(modelSchema.Tables, table)
|
|
model.Schemas = append(model.Schemas, modelSchema)
|
|
|
|
// Generate migration
|
|
var buf bytes.Buffer
|
|
writer, err := NewMigrationWriter(&writers.WriterOptions{})
|
|
if err != nil {
|
|
t.Fatalf("Failed to create writer: %v", err)
|
|
}
|
|
writer.writer = &buf
|
|
|
|
err = writer.WriteMigration(model, current)
|
|
if err != nil {
|
|
t.Fatalf("WriteMigration failed: %v", err)
|
|
}
|
|
|
|
output := buf.String()
|
|
t.Logf("Generated migration:\n%s", output)
|
|
|
|
// Verify constraint name is properly quoted
|
|
if !strings.Contains(output, `"215162_fk_actor"`) {
|
|
t.Error("Constraint name starting with number should be quoted")
|
|
}
|
|
|
|
// Verify the SQL is syntactically correct (contains required keywords)
|
|
if !strings.Contains(output, "ADD CONSTRAINT") {
|
|
t.Error("Migration missing ADD CONSTRAINT")
|
|
}
|
|
if !strings.Contains(output, "FOREIGN KEY") {
|
|
t.Error("Migration missing FOREIGN KEY")
|
|
}
|
|
}
|
|
|
|
func TestNewMigrationWriter_NilOptions(t *testing.T) {
|
|
writer, err := NewMigrationWriter(nil)
|
|
if err != nil {
|
|
t.Fatalf("NewMigrationWriter(nil) returned error: %v", err)
|
|
}
|
|
if writer == nil {
|
|
t.Fatal("expected writer instance")
|
|
}
|
|
if writer.options == nil {
|
|
t.Fatal("expected default writer options to be initialized")
|
|
}
|
|
}
|
|
|
|
func TestWriteMigration_NilCurrentTreatsDatabaseAsEmpty(t *testing.T) {
|
|
model := models.InitDatabase("testdb")
|
|
modelSchema := models.InitSchema("public")
|
|
|
|
table := models.InitTable("users", "public")
|
|
idCol := models.InitColumn("id", "users", "public")
|
|
idCol.Type = "integer"
|
|
idCol.NotNull = true
|
|
table.Columns["id"] = idCol
|
|
|
|
modelSchema.Tables = append(modelSchema.Tables, table)
|
|
model.Schemas = append(model.Schemas, modelSchema)
|
|
|
|
var buf bytes.Buffer
|
|
writer, err := NewMigrationWriter(nil)
|
|
if err != nil {
|
|
t.Fatalf("Failed to create writer: %v", err)
|
|
}
|
|
writer.writer = &buf
|
|
|
|
if err := writer.WriteMigration(model, nil); err != nil {
|
|
t.Fatalf("WriteMigration with nil current failed: %v", err)
|
|
}
|
|
|
|
output := buf.String()
|
|
if !strings.Contains(output, "CREATE TABLE") {
|
|
t.Fatalf("expected CREATE TABLE in migration output, got:\n%s", output)
|
|
}
|
|
}
|