mermaid-go/pkg/parser/main_test.go

package parser

import (
	"mermaid-go/pkg/detector"
	"testing"
)

func TestMermaidParser_GetDiagramType(t *testing.T) {
	parser := NewMermaidParser()

	tests := []struct {
		name     string
		input    string
		expected detector.DiagramType
	}{
		{
			name:     "Sequence Diagram",
			input:    "sequenceDiagram\n    A -> B : hello",
			expected: detector.DiagramTypeSequence,
		},
		{
			name:     "State Diagram V2",
			input:    "stateDiagram-v2\n    [*] --> State1",
			expected: detector.DiagramTypeStateV2,
		},
		{
			name:     "State Diagram",
			input:    "stateDiagram\n    [*] --> State1",
			expected: detector.DiagramTypeState,
		},
		{
			name:     "Flowchart",
			input:    "flowchart TD\n    A --> B",
			expected: detector.DiagramTypeFlowchart,
		},
		{
			name:     "Class Diagram",
			input:    "classDiagram\n    class Animal",
			expected: detector.DiagramTypeClass,
		},
		{
			name:     "Unknown Diagram",
			input:    "unknownDiagram\n    some content",
			expected: detector.DiagramTypeUnknown,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := parser.GetDiagramType(tt.input)
			if result != tt.expected {
				t.Errorf("Expected %v, got %v", tt.expected, result)
			}
		})
	}
}

func TestMermaidParser_Parse(t *testing.T) {
	parser := NewMermaidParser()

	tests := []struct {
		name        string
		input       string
		expectError bool
	}{
		{
			name:        "Valid Sequence Diagram",
			input:       "sequenceDiagram\n    A -> B : hello",
			expectError: false,
		},
		{
			name:        "Valid State Diagram",
			input:       "stateDiagram-v2\n    [*] --> State1",
			expectError: false,
		},
		{
			name:        "Unsupported Diagram Type",
			input:       "flowchart TD\n    A --> B",
			expectError: true,
		},
		{
			name:        "Unknown Diagram Type",
			input:       "unknownDiagram\n    some content",
			expectError: true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			_, err := parser.Parse(tt.input)
			if tt.expectError && err == nil {
				t.Errorf("Expected error but got none")
			}
			if !tt.expectError && err != nil {
				t.Errorf("Expected no error but got: %v", err)
			}
		})
	}
}

func TestMermaidParser_Parse_SequenceDiagram(t *testing.T) {
	parser := NewMermaidParser()

	input := `sequenceDiagram
    participant A
    participant B
    A -> B : hello
    B --> A : response`

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

	if diagram == nil {
		t.Fatal("Diagram is nil")
	}

	if diagram.Type() != "sequence" {
		t.Errorf("Expected diagram type 'sequence', got '%s'", diagram.Type())
	}
}

func TestMermaidParser_Parse_StateDiagram(t *testing.T) {
	parser := NewMermaidParser()

	input := `stateDiagram-v2
    [*] --> State1
    State1 --> State2 : transition
    State2 --> [*]`

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

	if diagram == nil {
		t.Fatal("Diagram is nil")
	}

	if diagram.Type() != "state" {
		t.Errorf("Expected diagram type 'state', got '%s'", diagram.Type())
	}
}