mermaid-go/pkg/parser/er_test.go

package parser

import (
	"strings"
	"testing"

	"mermaid-go/pkg/ast"
	"mermaid-go/pkg/renderer"
)

func TestERParser_BasicFunctionality(t *testing.T) {
	tests := []struct {
		name     string
		input    string
		expected string
	}{
		{
			name: "Simple Relationship",
			input: `erDiagram
    CUSTOMER ||--o{ ORDER : places
    ORDER ||--|{ LINE-ITEM : contains`,
			expected: `erDiagram
    CUSTOMER ||--o{ ORDER : places
    ORDER ||--|{ LINE-ITEM : contains
`,
		},
		{
			name: "Entity with Attributes",
			input: `erDiagram
    CUSTOMER {
        string name
        string custNumber
        string sector
    }
    CUSTOMER ||--o{ ORDER : places`,
			expected: `erDiagram
    CUSTOMER {
        string name
        string custNumber
        string sector
    }
    CUSTOMER ||--o{ ORDER : places
`,
		},
		{
			name: "Attributes with Keys",
			input: `erDiagram
    ORDER {
        int orderNumber PK
        string deliveryAddress
        float total FK
    }`,
			expected: `erDiagram
    ORDER {
        int orderNumber PK
        string deliveryAddress
        float total FK
    }
`,
		},
		{
			name: "Non-identifying Relationship",
			input: `erDiagram
    CUSTOMER }|..|{ DELIVERY-ADDRESS : uses`,
			expected: `erDiagram
    CUSTOMER }|..|{ DELIVERY-ADDRESS : uses
`,
		},
		{
			name: "Complex Example",
			input: `erDiagram
    CUSTOMER ||--o{ ORDER : places
    CUSTOMER {
        string name
        string custNumber
        string sector
    }
    ORDER ||--|{ LINE-ITEM : contains
    ORDER {
        int orderNumber
        string deliveryAddress
    }
    LINE-ITEM {
        string productCode
        int quantity
        float pricePerUnit
    }`,
			expected: `erDiagram
    CUSTOMER {
        string name
        string custNumber
        string sector
    }
    ORDER {
        int orderNumber
        string deliveryAddress
    }
    LINE-ITEM {
        string productCode
        int quantity
        float pricePerUnit
    }
    CUSTOMER ||--o{ ORDER : places
    ORDER ||--|{ LINE-ITEM : contains
`,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			parser := NewERParser()
			diagram, err := parser.Parse(tt.input)
			if err != nil {
				t.Fatalf("Failed to parse: %v", err)
			}

			// Test rendering
			renderer := renderer.NewERRenderer()
			output, err := renderer.Render(diagram)
			if err != nil {
				t.Fatalf("Failed to render: %v", err)
			}

			// Normalize whitespace for comparison
			expected := strings.TrimSpace(tt.expected)
			actual := strings.TrimSpace(output)

			if expected != actual {
				t.Errorf("Expected:\n%s\n\nGot:\n%s", expected, actual)
			}
		})
	}
}

func TestERParser_EntityParsing(t *testing.T) {
	input := `erDiagram
    CUSTOMER {
        string name
        string custNumber
        string sector
    }`

	parser := NewERParser()
	diagram, err := parser.Parse(input)
	if err != nil {
		t.Fatalf("Failed to parse: %v", err)
	}

	// Check entity was parsed
	if len(diagram.Entities) != 1 {
		t.Fatalf("Expected 1 entity, got %d", len(diagram.Entities))
	}

	var customer *ast.EREntity
	for _, entity := range diagram.Entities {
		if entity.Name == "CUSTOMER" {
			customer = entity
			break
		}
	}
	if customer == nil {
		t.Fatal("CUSTOMER entity not found")
	}

	if len(customer.Attributes) != 3 {
		t.Fatalf("Expected 3 attributes, got %d", len(customer.Attributes))
	}

	// Check attributes
	expectedAttrs := []struct {
		Type string
		Name string
	}{
		{"string", "name"},
		{"string", "custNumber"},
		{"string", "sector"},
	}

	for i, expected := range expectedAttrs {
		attr := customer.Attributes[i]
		if attr.Type != expected.Type {
			t.Errorf("Attribute %d: expected type %s, got %s", i, expected.Type, attr.Type)
		}
		if attr.Name != expected.Name {
			t.Errorf("Attribute %d: expected name %s, got %s", i, expected.Name, attr.Name)
		}
	}
}

func TestERParser_RelationshipParsing(t *testing.T) {
	input := `erDiagram
    CUSTOMER ||--o{ ORDER : places
    ORDER }|..|{ LINE-ITEM : contains`

	parser := NewERParser()
	diagram, err := parser.Parse(input)
	if err != nil {
		t.Fatalf("Failed to parse: %v", err)
	}

	// Check relationships were parsed
	if len(diagram.Relations) != 2 {
		t.Fatalf("Expected 2 relationships, got %d", len(diagram.Relations))
	}

	// Check first relationship (one-to-many)
	rel1 := diagram.Relations[0]
	if rel1.From != "CUSTOMER" || rel1.To != "ORDER" {
		t.Errorf("First relationship: expected CUSTOMER -> ORDER, got %s -> %s", rel1.From, rel1.To)
	}
	if rel1.Label == nil || *rel1.Label != "places" {
		t.Errorf("First relationship: expected label 'places', got %v", rel1.Label)
	}
	if rel1.Type != ast.ERRelationOneToMany {
		t.Errorf("First relationship: expected one-to-many type, got %s", rel1.Type)
	}

	// Check second relationship (many-to-many with dots)
	rel2 := diagram.Relations[1]
	if rel2.From != "ORDER" || rel2.To != "LINE-ITEM" {
		t.Errorf("Second relationship: expected ORDER -> LINE-ITEM, got %s -> %s", rel2.From, rel2.To)
	}
	if rel2.Label == nil || *rel2.Label != "contains" {
		t.Errorf("Second relationship: expected label 'contains', got %v", rel2.Label)
	}
	if rel2.Type != ast.ERRelationManyToManyAlt {
		t.Errorf("Second relationship: expected many-to-many-alt type, got %s", rel2.Type)
	}
}