relspecgo/pkg/writers/mssql/writer_test.go

package mssql

import (
	"bytes"
	"testing"

	"git.warky.dev/wdevs/relspecgo/pkg/models"
	"git.warky.dev/wdevs/relspecgo/pkg/writers"
	"github.com/stretchr/testify/assert"
)

// TestGenerateColumnDefinition tests column definition generation
func TestGenerateColumnDefinition(t *testing.T) {
	writer := NewWriter(&writers.WriterOptions{})

	tests := []struct {
		name     string
		column   *models.Column
		expected string
	}{
		{
			name: "INT NOT NULL",
			column: &models.Column{
				Name:     "id",
				Type:     "int",
				NotNull:  true,
				Sequence: 1,
			},
			expected: "[id] INT NOT NULL",
		},
		{
			name: "VARCHAR with length",
			column: &models.Column{
				Name:     "name",
				Type:     "string",
				Length:   100,
				NotNull:  true,
				Sequence: 2,
			},
			expected: "[name] NVARCHAR(100) NOT NULL",
		},
		{
			name: "DATETIME2 with default",
			column: &models.Column{
				Name:     "created_at",
				Type:     "timestamp",
				NotNull:  true,
				Default:  "GETDATE()",
				Sequence: 3,
			},
			expected: "[created_at] DATETIME2 NOT NULL DEFAULT GETDATE()",
		},
		{
			name: "IDENTITY column",
			column: &models.Column{
				Name:          "id",
				Type:          "int",
				AutoIncrement: true,
				NotNull:       true,
				Sequence:      1,
			},
			expected: "[id] INT IDENTITY(1,1) NOT NULL",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := writer.generateColumnDefinition(tt.column)
			assert.Equal(t, tt.expected, result)
		})
	}
}

// TestWriteCreateTable tests CREATE TABLE statement generation
func TestWriteCreateTable(t *testing.T) {
	writer := NewWriter(&writers.WriterOptions{})

	// Create a test schema with a table
	schema := models.InitSchema("dbo")
	table := models.InitTable("users", "dbo")

	col1 := models.InitColumn("id", "users", "dbo")
	col1.Type = "int"
	col1.AutoIncrement = true
	col1.NotNull = true
	col1.Sequence = 1

	col2 := models.InitColumn("email", "users", "dbo")
	col2.Type = "string"
	col2.Length = 255
	col2.NotNull = true
	col2.Sequence = 2

	table.Columns["id"] = col1
	table.Columns["email"] = col2

	// Write to buffer
	buf := &bytes.Buffer{}
	writer.writer = buf

	err := writer.writeCreateTable(schema, table)
	assert.NoError(t, err)

	output := buf.String()
	assert.Contains(t, output, "CREATE TABLE [dbo].[users]")
	assert.Contains(t, output, "[id] INT IDENTITY(1,1) NOT NULL")
	assert.Contains(t, output, "[email] NVARCHAR(255) NOT NULL")
}

// TestWritePrimaryKey tests PRIMARY KEY constraint generation
func TestWritePrimaryKey(t *testing.T) {
	writer := NewWriter(&writers.WriterOptions{})

	schema := models.InitSchema("dbo")
	table := models.InitTable("users", "dbo")

	// Add primary key constraint
	pk := models.InitConstraint("PK_users_id", models.PrimaryKeyConstraint)
	pk.Columns = []string{"id"}
	table.Constraints[pk.Name] = pk

	// Add column
	col := models.InitColumn("id", "users", "dbo")
	col.Type = "int"
	col.Sequence = 1
	table.Columns["id"] = col

	// Write to buffer
	buf := &bytes.Buffer{}
	writer.writer = buf

	err := writer.writePrimaryKey(schema, table)
	assert.NoError(t, err)

	output := buf.String()
	assert.Contains(t, output, "ALTER TABLE [dbo].[users]")
	assert.Contains(t, output, "PRIMARY KEY")
	assert.Contains(t, output, "[id]")
}

// TestWriteForeignKey tests FOREIGN KEY constraint generation
func TestWriteForeignKey(t *testing.T) {
	writer := NewWriter(&writers.WriterOptions{})

	schema := models.InitSchema("dbo")
	table := models.InitTable("orders", "dbo")

	// Add foreign key constraint
	fk := models.InitConstraint("FK_orders_users", models.ForeignKeyConstraint)
	fk.Columns = []string{"user_id"}
	fk.ReferencedSchema = "dbo"
	fk.ReferencedTable = "users"
	fk.ReferencedColumns = []string{"id"}
	fk.OnDelete = "CASCADE"
	fk.OnUpdate = "NO ACTION"
	table.Constraints[fk.Name] = fk

	// Add column
	col := models.InitColumn("user_id", "orders", "dbo")
	col.Type = "int"
	col.Sequence = 1
	table.Columns["user_id"] = col

	// Write to buffer
	buf := &bytes.Buffer{}
	writer.writer = buf

	err := writer.writeForeignKeys(schema, table)
	assert.NoError(t, err)

	output := buf.String()
	assert.Contains(t, output, "ALTER TABLE [dbo].[orders]")
	assert.Contains(t, output, "FK_orders_users")
	assert.Contains(t, output, "FOREIGN KEY")
	assert.Contains(t, output, "CASCADE")
	assert.Contains(t, output, "NO ACTION")
}

// TestWriteComments tests extended property generation for comments
func TestWriteComments(t *testing.T) {
	writer := NewWriter(&writers.WriterOptions{})

	schema := models.InitSchema("dbo")
	table := models.InitTable("users", "dbo")
	table.Description = "User accounts table"

	col := models.InitColumn("id", "users", "dbo")
	col.Type = "int"
	col.Description = "Primary key"
	col.Sequence = 1
	table.Columns["id"] = col

	// Write to buffer
	buf := &bytes.Buffer{}
	writer.writer = buf

	err := writer.writeComments(schema, table)
	assert.NoError(t, err)

	output := buf.String()
	assert.Contains(t, output, "sp_addextendedproperty")
	assert.Contains(t, output, "MS_Description")
	assert.Contains(t, output, "User accounts table")
	assert.Contains(t, output, "Primary key")
}