449 lines
12 KiB
Go
449 lines
12 KiB
Go
package json
|
|
|
|
import (
|
|
"encoding/json"
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
|
|
"git.warky.dev/wdevs/relspecgo/pkg/models"
|
|
"git.warky.dev/wdevs/relspecgo/pkg/writers"
|
|
)
|
|
|
|
func TestWriter_WriteTable(t *testing.T) {
|
|
table := models.InitTable("users", "public")
|
|
table.Description = "User accounts table"
|
|
|
|
idCol := models.InitColumn("id", "users", "public")
|
|
idCol.Type = "bigint"
|
|
idCol.IsPrimaryKey = true
|
|
idCol.AutoIncrement = true
|
|
idCol.NotNull = true
|
|
table.Columns["id"] = idCol
|
|
|
|
emailCol := models.InitColumn("email", "users", "public")
|
|
emailCol.Type = "varchar"
|
|
emailCol.Length = 255
|
|
emailCol.NotNull = true
|
|
emailCol.Comment = "User email address"
|
|
table.Columns["email"] = emailCol
|
|
|
|
tmpDir := t.TempDir()
|
|
outputPath := filepath.Join(tmpDir, "test.json")
|
|
|
|
opts := &writers.WriterOptions{
|
|
OutputPath: outputPath,
|
|
}
|
|
|
|
writer := NewWriter(opts)
|
|
err := writer.WriteTable(table)
|
|
if err != nil {
|
|
t.Fatalf("WriteTable() error = %v", err)
|
|
}
|
|
|
|
content, err := os.ReadFile(outputPath)
|
|
if err != nil {
|
|
t.Fatalf("Failed to read output file: %v", err)
|
|
}
|
|
|
|
var result models.Table
|
|
if err := json.Unmarshal(content, &result); err != nil {
|
|
t.Fatalf("Failed to unmarshal JSON: %v", err)
|
|
}
|
|
|
|
if result.Name != "users" {
|
|
t.Errorf("Expected table name 'users', got '%s'", result.Name)
|
|
}
|
|
|
|
if result.Description != "User accounts table" {
|
|
t.Errorf("Expected description 'User accounts table', got '%s'", result.Description)
|
|
}
|
|
|
|
if len(result.Columns) != 2 {
|
|
t.Errorf("Expected 2 columns, got %d", len(result.Columns))
|
|
}
|
|
|
|
// Verify id column
|
|
idColResult, exists := result.Columns["id"]
|
|
if !exists {
|
|
t.Fatal("Column 'id' not found")
|
|
}
|
|
if !idColResult.IsPrimaryKey {
|
|
t.Error("Column 'id' should be primary key")
|
|
}
|
|
if !idColResult.AutoIncrement {
|
|
t.Error("Column 'id' should be auto-increment")
|
|
}
|
|
|
|
// Verify email column
|
|
emailColResult, exists := result.Columns["email"]
|
|
if !exists {
|
|
t.Fatal("Column 'email' not found")
|
|
}
|
|
if emailColResult.Length != 255 {
|
|
t.Errorf("Expected email length 255, got %d", emailColResult.Length)
|
|
}
|
|
if emailColResult.Comment != "User email address" {
|
|
t.Errorf("Expected email comment 'User email address', got '%s'", emailColResult.Comment)
|
|
}
|
|
}
|
|
|
|
func TestWriter_WriteDatabase_WithRelationships(t *testing.T) {
|
|
db := models.InitDatabase("test_db")
|
|
db.Description = "Test database"
|
|
db.DatabaseType = models.PostgresqlDatabaseType
|
|
|
|
schema := models.InitSchema("public")
|
|
|
|
// Create users table
|
|
usersTable := models.InitTable("users", "public")
|
|
idCol := models.InitColumn("id", "users", "public")
|
|
idCol.Type = "bigint"
|
|
idCol.IsPrimaryKey = true
|
|
idCol.AutoIncrement = true
|
|
idCol.NotNull = true
|
|
usersTable.Columns["id"] = idCol
|
|
|
|
emailCol := models.InitColumn("email", "users", "public")
|
|
emailCol.Type = "varchar"
|
|
emailCol.Length = 255
|
|
emailCol.NotNull = true
|
|
usersTable.Columns["email"] = emailCol
|
|
|
|
// Add index
|
|
emailIdx := models.InitIndex("idx_users_email", "users", "public")
|
|
emailIdx.Columns = []string{"email"}
|
|
emailIdx.Unique = true
|
|
emailIdx.Type = "btree"
|
|
emailIdx.Table = "users"
|
|
emailIdx.Schema = "public"
|
|
usersTable.Indexes["idx_users_email"] = emailIdx
|
|
|
|
// Create posts table
|
|
postsTable := models.InitTable("posts", "public")
|
|
postIdCol := models.InitColumn("id", "posts", "public")
|
|
postIdCol.Type = "bigint"
|
|
postIdCol.IsPrimaryKey = true
|
|
postIdCol.NotNull = true
|
|
postsTable.Columns["id"] = postIdCol
|
|
|
|
userIdCol := models.InitColumn("user_id", "posts", "public")
|
|
userIdCol.Type = "bigint"
|
|
userIdCol.NotNull = true
|
|
postsTable.Columns["user_id"] = userIdCol
|
|
|
|
titleCol := models.InitColumn("title", "posts", "public")
|
|
titleCol.Type = "varchar"
|
|
titleCol.Length = 200
|
|
titleCol.NotNull = true
|
|
postsTable.Columns["title"] = titleCol
|
|
|
|
// Add foreign key constraint
|
|
fk := models.InitConstraint("fk_posts_user", models.ForeignKeyConstraint)
|
|
fk.Table = "posts"
|
|
fk.Schema = "public"
|
|
fk.Columns = []string{"user_id"}
|
|
fk.ReferencedTable = "users"
|
|
fk.ReferencedSchema = "public"
|
|
fk.ReferencedColumns = []string{"id"}
|
|
fk.OnDelete = "CASCADE"
|
|
fk.OnUpdate = "CASCADE"
|
|
postsTable.Constraints["fk_posts_user"] = fk
|
|
|
|
schema.Tables = append(schema.Tables, usersTable, postsTable)
|
|
db.Schemas = append(db.Schemas, schema)
|
|
|
|
tmpDir := t.TempDir()
|
|
outputPath := filepath.Join(tmpDir, "test.json")
|
|
|
|
opts := &writers.WriterOptions{
|
|
OutputPath: outputPath,
|
|
}
|
|
|
|
writer := NewWriter(opts)
|
|
err := writer.WriteDatabase(db)
|
|
if err != nil {
|
|
t.Fatalf("WriteDatabase() error = %v", err)
|
|
}
|
|
|
|
content, err := os.ReadFile(outputPath)
|
|
if err != nil {
|
|
t.Fatalf("Failed to read output file: %v", err)
|
|
}
|
|
|
|
var result models.Database
|
|
if err := json.Unmarshal(content, &result); err != nil {
|
|
t.Fatalf("Failed to unmarshal JSON: %v", err)
|
|
}
|
|
|
|
if result.Name != "test_db" {
|
|
t.Errorf("Expected database name 'test_db', got '%s'", result.Name)
|
|
}
|
|
|
|
if result.DatabaseType != models.PostgresqlDatabaseType {
|
|
t.Errorf("Expected database type 'pgsql', got '%s'", result.DatabaseType)
|
|
}
|
|
|
|
if len(result.Schemas) != 1 {
|
|
t.Fatalf("Expected 1 schema, got %d", len(result.Schemas))
|
|
}
|
|
|
|
resultSchema := result.Schemas[0]
|
|
if len(resultSchema.Tables) != 2 {
|
|
t.Fatalf("Expected 2 tables, got %d", len(resultSchema.Tables))
|
|
}
|
|
|
|
// Find posts table and verify foreign key
|
|
var postsTableResult *models.Table
|
|
for _, table := range resultSchema.Tables {
|
|
if table.Name == "posts" {
|
|
postsTableResult = table
|
|
break
|
|
}
|
|
}
|
|
|
|
if postsTableResult == nil {
|
|
t.Fatal("Posts table not found")
|
|
}
|
|
|
|
if len(postsTableResult.Constraints) != 1 {
|
|
t.Errorf("Expected 1 constraint, got %d", len(postsTableResult.Constraints))
|
|
}
|
|
|
|
fkResult, exists := postsTableResult.Constraints["fk_posts_user"]
|
|
if !exists {
|
|
t.Fatal("Foreign key 'fk_posts_user' not found")
|
|
}
|
|
|
|
if fkResult.Type != models.ForeignKeyConstraint {
|
|
t.Error("Expected foreign key constraint type")
|
|
}
|
|
if fkResult.ReferencedTable != "users" {
|
|
t.Errorf("Expected referenced table 'users', got '%s'", fkResult.ReferencedTable)
|
|
}
|
|
if fkResult.OnDelete != "CASCADE" {
|
|
t.Errorf("Expected ON DELETE CASCADE, got '%s'", fkResult.OnDelete)
|
|
}
|
|
if fkResult.OnUpdate != "CASCADE" {
|
|
t.Errorf("Expected ON UPDATE CASCADE, got '%s'", fkResult.OnUpdate)
|
|
}
|
|
|
|
// Verify index
|
|
var usersTableResult *models.Table
|
|
for _, table := range resultSchema.Tables {
|
|
if table.Name == "users" {
|
|
usersTableResult = table
|
|
break
|
|
}
|
|
}
|
|
|
|
if usersTableResult == nil {
|
|
t.Fatal("Users table not found")
|
|
}
|
|
|
|
if len(usersTableResult.Indexes) != 1 {
|
|
t.Errorf("Expected 1 index, got %d", len(usersTableResult.Indexes))
|
|
}
|
|
|
|
idxResult, exists := usersTableResult.Indexes["idx_users_email"]
|
|
if !exists {
|
|
t.Fatal("Index 'idx_users_email' not found")
|
|
}
|
|
if !idxResult.Unique {
|
|
t.Error("Email index should be unique")
|
|
}
|
|
if idxResult.Type != "btree" {
|
|
t.Errorf("Expected index type 'btree', got '%s'", idxResult.Type)
|
|
}
|
|
}
|
|
|
|
func TestWriter_WriteSchema(t *testing.T) {
|
|
schema := models.InitSchema("public")
|
|
schema.Description = "Public schema"
|
|
|
|
table := models.InitTable("users", "public")
|
|
idCol := models.InitColumn("id", "users", "public")
|
|
idCol.Type = "bigint"
|
|
idCol.IsPrimaryKey = true
|
|
table.Columns["id"] = idCol
|
|
|
|
usernameCol := models.InitColumn("username", "users", "public")
|
|
usernameCol.Type = "varchar"
|
|
usernameCol.Length = 50
|
|
usernameCol.NotNull = true
|
|
table.Columns["username"] = usernameCol
|
|
|
|
schema.Tables = append(schema.Tables, table)
|
|
|
|
tmpDir := t.TempDir()
|
|
outputPath := filepath.Join(tmpDir, "test.json")
|
|
|
|
opts := &writers.WriterOptions{
|
|
OutputPath: outputPath,
|
|
}
|
|
|
|
writer := NewWriter(opts)
|
|
err := writer.WriteSchema(schema)
|
|
if err != nil {
|
|
t.Fatalf("WriteSchema() error = %v", err)
|
|
}
|
|
|
|
content, err := os.ReadFile(outputPath)
|
|
if err != nil {
|
|
t.Fatalf("Failed to read output file: %v", err)
|
|
}
|
|
|
|
var result models.Schema
|
|
if err := json.Unmarshal(content, &result); err != nil {
|
|
t.Fatalf("Failed to unmarshal JSON: %v", err)
|
|
}
|
|
|
|
if result.Name != "public" {
|
|
t.Errorf("Expected schema name 'public', got '%s'", result.Name)
|
|
}
|
|
|
|
if result.Description != "Public schema" {
|
|
t.Errorf("Expected description 'Public schema', got '%s'", result.Description)
|
|
}
|
|
|
|
if len(result.Tables) != 1 {
|
|
t.Errorf("Expected 1 table, got %d", len(result.Tables))
|
|
}
|
|
}
|
|
|
|
func TestWriter_WriteTable_EmptyPath(t *testing.T) {
|
|
table := models.InitTable("users", "public")
|
|
idCol := models.InitColumn("id", "users", "public")
|
|
idCol.Type = "bigint"
|
|
table.Columns["id"] = idCol
|
|
|
|
// When OutputPath is empty, it should print to stdout (not error)
|
|
opts := &writers.WriterOptions{
|
|
OutputPath: "",
|
|
}
|
|
|
|
writer := NewWriter(opts)
|
|
err := writer.WriteTable(table)
|
|
if err != nil {
|
|
t.Fatalf("WriteTable() with empty path should not error, got: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestWriter_WriteDatabase_WithDefaults(t *testing.T) {
|
|
db := models.InitDatabase("test_db")
|
|
schema := models.InitSchema("public")
|
|
|
|
table := models.InitTable("products", "public")
|
|
|
|
idCol := models.InitColumn("id", "products", "public")
|
|
idCol.Type = "bigint"
|
|
idCol.IsPrimaryKey = true
|
|
table.Columns["id"] = idCol
|
|
|
|
isActiveCol := models.InitColumn("is_active", "products", "public")
|
|
isActiveCol.Type = "boolean"
|
|
isActiveCol.Default = "true"
|
|
table.Columns["is_active"] = isActiveCol
|
|
|
|
createdCol := models.InitColumn("created_at", "products", "public")
|
|
createdCol.Type = "timestamp"
|
|
createdCol.Default = "CURRENT_TIMESTAMP"
|
|
table.Columns["created_at"] = createdCol
|
|
|
|
schema.Tables = append(schema.Tables, table)
|
|
db.Schemas = append(db.Schemas, schema)
|
|
|
|
tmpDir := t.TempDir()
|
|
outputPath := filepath.Join(tmpDir, "test.json")
|
|
|
|
opts := &writers.WriterOptions{
|
|
OutputPath: outputPath,
|
|
}
|
|
|
|
writer := NewWriter(opts)
|
|
err := writer.WriteDatabase(db)
|
|
if err != nil {
|
|
t.Fatalf("WriteDatabase() error = %v", err)
|
|
}
|
|
|
|
content, err := os.ReadFile(outputPath)
|
|
if err != nil {
|
|
t.Fatalf("Failed to read output file: %v", err)
|
|
}
|
|
|
|
var result models.Database
|
|
if err := json.Unmarshal(content, &result); err != nil {
|
|
t.Fatalf("Failed to unmarshal JSON: %v", err)
|
|
}
|
|
|
|
tableResult := result.Schemas[0].Tables[0]
|
|
|
|
// Verify default values
|
|
isActiveColResult, exists := tableResult.Columns["is_active"]
|
|
if !exists {
|
|
t.Fatal("Column 'is_active' not found")
|
|
}
|
|
if isActiveColResult.Default != "true" {
|
|
t.Errorf("Expected is_active default 'true', got '%v'", isActiveColResult.Default)
|
|
}
|
|
|
|
createdColResult, exists := tableResult.Columns["created_at"]
|
|
if !exists {
|
|
t.Fatal("Column 'created_at' not found")
|
|
}
|
|
if createdColResult.Default != "CURRENT_TIMESTAMP" {
|
|
t.Errorf("Expected created_at default 'CURRENT_TIMESTAMP', got '%v'", createdColResult.Default)
|
|
}
|
|
}
|
|
|
|
func TestGetPrimaryKey(t *testing.T) {
|
|
table := models.InitTable("users", "public")
|
|
|
|
idCol := models.InitColumn("id", "users", "public")
|
|
idCol.Type = "bigint"
|
|
idCol.IsPrimaryKey = true
|
|
table.Columns["id"] = idCol
|
|
|
|
emailCol := models.InitColumn("email", "users", "public")
|
|
emailCol.Type = "varchar"
|
|
table.Columns["email"] = emailCol
|
|
|
|
pk := table.GetPrimaryKey()
|
|
if pk == nil {
|
|
t.Fatal("Expected primary key, got nil")
|
|
}
|
|
|
|
if pk.Name != "id" {
|
|
t.Errorf("Expected primary key name 'id', got '%s'", pk.Name)
|
|
}
|
|
}
|
|
|
|
func TestGetForeignKeys(t *testing.T) {
|
|
table := models.InitTable("posts", "public")
|
|
|
|
idCol := models.InitColumn("id", "posts", "public")
|
|
idCol.Type = "bigint"
|
|
idCol.IsPrimaryKey = true
|
|
table.Columns["id"] = idCol
|
|
|
|
userIdCol := models.InitColumn("user_id", "posts", "public")
|
|
userIdCol.Type = "bigint"
|
|
table.Columns["user_id"] = userIdCol
|
|
|
|
// Add foreign key constraint
|
|
fk := models.InitConstraint("fk_posts_user", models.ForeignKeyConstraint)
|
|
fk.Columns = []string{"user_id"}
|
|
fk.ReferencedTable = "users"
|
|
fk.ReferencedColumns = []string{"id"}
|
|
table.Constraints["fk_posts_user"] = fk
|
|
|
|
fks := table.GetForeignKeys()
|
|
if len(fks) != 1 {
|
|
t.Errorf("Expected 1 foreign key, got %d", len(fks))
|
|
}
|
|
|
|
if fks[0].Type != models.ForeignKeyConstraint {
|
|
t.Error("Expected foreign key constraint type")
|
|
}
|
|
}
|