preview_test.go

package main

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

func TestNewPreviewService(t *testing.T) {
	// Default max lines
	p := NewPreviewService(0)
	if p.maxLines != 500 {
		t.Errorf("expected maxLines=500 for 0 input, got %d", p.maxLines)
	}

	p = NewPreviewService(-1)
	if p.maxLines != 500 {
		t.Errorf("expected maxLines=500 for -1 input, got %d", p.maxLines)
	}

	// Custom max lines
	p = NewPreviewService(100)
	if p.maxLines != 100 {
		t.Errorf("expected maxLines=100, got %d", p.maxLines)
	}

	// Style and formatter should not be nil
	if p.style == nil {
		t.Error("style should not be nil")
	}
	if p.formatter == nil {
		t.Error("formatter should not be nil")
	}
}

func TestReadLinesLimited(t *testing.T) {
	dir := t.TempDir()

	// Create a test file with known content
	lines := []string{"line1", "line2", "line3", "line4", "line5"}
	content := strings.Join(lines, "\n")
	path := filepath.Join(dir, "test.txt")
	if err := os.WriteFile(path, []byte(content), 0644); err != nil {
		t.Fatal(err)
	}

	// Read all lines
	got, truncated, err := readLinesLimited(path, 100)
	if err != nil {
		t.Fatal(err)
	}
	if truncated {
		t.Error("should not be truncated")
	}
	if len(got) != 5 {
		t.Errorf("expected 5 lines, got %d", len(got))
	}

	// Read with limit
	got, truncated, err = readLinesLimited(path, 3)
	if err != nil {
		t.Fatal(err)
	}
	if !truncated {
		t.Error("should be truncated")
	}
	if len(got) != 3 {
		t.Errorf("expected 3 lines, got %d", len(got))
	}

	// Non-existent file
	_, _, err = readLinesLimited(filepath.Join(dir, "nonexistent.txt"), 100)
	if err == nil {
		t.Error("expected error for non-existent file")
	}
}

func TestGenerateBinaryFile(t *testing.T) {
	dir := t.TempDir()
	p := NewPreviewService(500)

	// Create a fake binary file
	path := filepath.Join(dir, "test.bin")
	if err := os.WriteFile(path, []byte{0x00, 0x01, 0x02}, 0644); err != nil {
		t.Fatal(err)
	}

	result, err := p.Generate(path, 80)
	if err != nil {
		t.Fatal(err)
	}
	if result != "[Binary file - no preview]" {
		t.Errorf("expected binary file message, got: %s", result)
	}
}

func TestGenerateTextFile(t *testing.T) {
	dir := t.TempDir()
	p := NewPreviewService(500)

	// Create a Go source file
	content := `package main

import "fmt"

func main() {
	fmt.Println("hello")
}
`
	path := filepath.Join(dir, "main.go")
	if err := os.WriteFile(path, []byte(content), 0644); err != nil {
		t.Fatal(err)
	}

	result, err := p.Generate(path, 80)
	if err != nil {
		t.Fatal(err)
	}
	if result == "" {
		t.Error("preview should not be empty")
	}
	if result == "[Binary file - no preview]" {
		t.Error("Go file should not be detected as binary")
	}
}

func TestGeneratePlainFile(t *testing.T) {
	dir := t.TempDir()
	p := NewPreviewService(500)

	// Create a plain text file (no syntax highlighting)
	content := "hello world\nfoo bar"
	path := filepath.Join(dir, "notes.txt")
	if err := os.WriteFile(path, []byte(content), 0644); err != nil {
		t.Fatal(err)
	}

	result, err := p.Generate(path, 80)
	if err != nil {
		t.Fatal(err)
	}
	if !strings.Contains(result, "hello world") {
		t.Errorf("preview should contain file content, got: %s", result)
	}
}

func TestGenerateTruncated(t *testing.T) {
	dir := t.TempDir()
	p := NewPreviewService(3) // Only 3 lines

	// Create a file with 5 lines
	content := "line1\nline2\nline3\nline4\nline5"
	path := filepath.Join(dir, "long.txt")
	if err := os.WriteFile(path, []byte(content), 0644); err != nil {
		t.Fatal(err)
	}

	result, err := p.Generate(path, 80)
	if err != nil {
		t.Fatal(err)
	}
	if !strings.Contains(result, "truncated") {
		t.Error("should contain truncation notice")
	}
}

func TestGenerateNonExistent(t *testing.T) {
	p := NewPreviewService(500)

	result, err := p.Generate("/nonexistent/path/file.txt", 80)
	if err != nil {
		t.Fatal(err)
	}
	if !strings.Contains(result, "Error") {
		t.Errorf("should contain error message, got: %s", result)
	}
}

func TestSupportedLangs(t *testing.T) {
	expected := []string{".go", ".py", ".js", ".ts", ".rs", ".c", ".cpp", ".h", ".hpp", ".java", ".md"}
	for _, lang := range expected {
		if !supportedLangs[lang] {
			t.Errorf("expected %s to be supported", lang)
		}
	}
}

func TestGenerateAsync(t *testing.T) {
	dir := t.TempDir()
	p := NewPreviewService(500)

	// Create a test file
	content := "hello world"
	path := filepath.Join(dir, "test.txt")
	if err := os.WriteFile(path, []byte(content), 0644); err != nil {
		t.Fatal(err)
	}

	// GenerateAsync should return a function
	cmd := p.GenerateAsync(path, 80)
	if cmd == nil {
		t.Error("GenerateAsync returned nil cmd")
	}
}