sub-cli/internal/format/lrc/parser_test.go

package lrc

import (
	"os"
	"path/filepath"
	"testing"
)

func TestParse(t *testing.T) {
	// Create a temporary test file
	content := `[ti:Test LRC File]
[ar:Test Artist]
[al:Test Album]
[by:Test Creator]

[00:01.00]This is the first line.
[00:05.00]This is the second line.
[00:09.50]This is the third line.
`
	tempDir := t.TempDir()
	testFile := filepath.Join(tempDir, "test.lrc")
	if err := os.WriteFile(testFile, []byte(content), 0644); err != nil {
		t.Fatalf("Failed to create test file: %v", err)
	}

	// Test parsing
	lyrics, err := Parse(testFile)
	if err != nil {
		t.Fatalf("Parse failed: %v", err)
	}

	// Verify results
	if len(lyrics.Timeline) != 3 {
		t.Errorf("Expected 3 timeline entries, got %d", len(lyrics.Timeline))
	}

	if len(lyrics.Content) != 3 {
		t.Errorf("Expected 3 content entries, got %d", len(lyrics.Content))
	}

	// Check metadata
	if lyrics.Metadata["ti"] != "Test LRC File" {
		t.Errorf("Expected title 'Test LRC File', got '%s'", lyrics.Metadata["ti"])
	}
	if lyrics.Metadata["ar"] != "Test Artist" {
		t.Errorf("Expected artist 'Test Artist', got '%s'", lyrics.Metadata["ar"])
	}
	if lyrics.Metadata["al"] != "Test Album" {
		t.Errorf("Expected album 'Test Album', got '%s'", lyrics.Metadata["al"])
	}
	if lyrics.Metadata["by"] != "Test Creator" {
		t.Errorf("Expected creator 'Test Creator', got '%s'", lyrics.Metadata["by"])
	}

	// Check first timeline entry
	if lyrics.Timeline[0].Hours != 0 || lyrics.Timeline[0].Minutes != 0 ||
		lyrics.Timeline[0].Seconds != 1 || lyrics.Timeline[0].Milliseconds != 0 {
		t.Errorf("First entry time: expected 00:01.00, got %+v", lyrics.Timeline[0])
	}

	// Check third timeline entry
	if lyrics.Timeline[2].Hours != 0 || lyrics.Timeline[2].Minutes != 0 ||
		lyrics.Timeline[2].Seconds != 9 || lyrics.Timeline[2].Milliseconds != 500 {
		t.Errorf("Third entry time: expected 00:09.50, got %+v", lyrics.Timeline[2])
	}

	// Check content
	if lyrics.Content[0] != "This is the first line." {
		t.Errorf("First entry content: expected 'This is the first line.', got '%s'", lyrics.Content[0])
	}
}

func TestParse_FileErrors(t *testing.T) {
	// Test with non-existent file
	_, err := Parse("/nonexistent/file.lrc")
	if err == nil {
		t.Error("Expected error when parsing non-existent file, got nil")
	}
}

func TestParse_EdgeCases(t *testing.T) {
	// Test with empty file
	tempDir := t.TempDir()
	emptyFile := filepath.Join(tempDir, "empty.lrc")
	if err := os.WriteFile(emptyFile, []byte(""), 0644); err != nil {
		t.Fatalf("Failed to create empty file: %v", err)
	}

	lyrics, err := Parse(emptyFile)
	if err != nil {
		t.Fatalf("Parse failed with empty file: %v", err)
	}
	if len(lyrics.Timeline) != 0 || len(lyrics.Content) != 0 {
		t.Errorf("Expected empty lyrics for empty file, got %d timeline and %d content",
			len(lyrics.Timeline), len(lyrics.Content))
	}

	// Test with metadata only
	metadataFile := filepath.Join(tempDir, "metadata.lrc")
	metadataContent := `[ti:Test Title]
[ar:Test Artist]
[al:Test Album]
`
	if err := os.WriteFile(metadataFile, []byte(metadataContent), 0644); err != nil {
		t.Fatalf("Failed to create metadata file: %v", err)
	}

	lyrics, err = Parse(metadataFile)
	if err != nil {
		t.Fatalf("Parse failed with metadata-only file: %v", err)
	}
	if lyrics.Metadata["ti"] != "Test Title" {
		t.Errorf("Expected title 'Test Title', got '%s'", lyrics.Metadata["ti"])
	}
	if len(lyrics.Timeline) != 0 || len(lyrics.Content) != 0 {
		t.Errorf("Expected empty timeline/content for metadata-only file, got %d timeline and %d content",
			len(lyrics.Timeline), len(lyrics.Content))
	}

	// Test with invalid metadata
	invalidMetadataFile := filepath.Join(tempDir, "invalid_metadata.lrc")
	invalidMetadata := `[ti:Test Title
[ar:Test Artist]
[00:01.00]This is a valid line.
`
	if err := os.WriteFile(invalidMetadataFile, []byte(invalidMetadata), 0644); err != nil {
		t.Fatalf("Failed to create invalid metadata file: %v", err)
	}

	lyrics, err = Parse(invalidMetadataFile)
	if err != nil {
		t.Fatalf("Parse failed with invalid metadata file: %v", err)
	}
	if lyrics.Metadata["ti"] != "" { // Should ignore invalid metadata
		t.Errorf("Expected empty title for invalid metadata, got '%s'", lyrics.Metadata["ti"])
	}
	if len(lyrics.Timeline) != 1 || len(lyrics.Content) != 1 {
		t.Errorf("Expected 1 timeline/content entry for file with invalid metadata, got %d timeline and %d content",
			len(lyrics.Timeline), len(lyrics.Content))
	}

	// Test with invalid timestamp format
	invalidFile := filepath.Join(tempDir, "invalid.lrc")
	content := `[ti:Test LRC File]
[ar:Test Artist]

[invalidtime]This should be ignored.
[00:01.00]This is a valid line.
`
	if err := os.WriteFile(invalidFile, []byte(content), 0644); err != nil {
		t.Fatalf("Failed to create invalid test file: %v", err)
	}

	lyrics, err = Parse(invalidFile)
	if err != nil {
		t.Fatalf("Parse failed on file with invalid timestamps: %v", err)
	}

	if len(lyrics.Timeline) != 1 || len(lyrics.Content) != 1 {
		t.Errorf("Expected 1 valid timeline entry, got %d timeline entries and %d content entries",
			len(lyrics.Timeline), len(lyrics.Content))
	}

	// Test with timestamp-only lines (no content)
	timestampOnlyFile := filepath.Join(tempDir, "timestamp_only.lrc")
	content = `[ti:Test LRC File]
[ar:Test Artist]

[00:01.00]
[00:05.00]This has content.
`
	if err := os.WriteFile(timestampOnlyFile, []byte(content), 0644); err != nil {
		t.Fatalf("Failed to create timestamp-only test file: %v", err)
	}

	lyrics, err = Parse(timestampOnlyFile)
	if err != nil {
		t.Fatalf("Parse failed on file with timestamp-only lines: %v", err)
	}

	if len(lyrics.Timeline) != 1 || len(lyrics.Content) != 1 {
		t.Errorf("Expected 1 valid entry (ignoring empty content), got %d timeline entries and %d content entries",
			len(lyrics.Timeline), len(lyrics.Content))
	}
}