display_test.go

package main

import (
	"os"
	"testing"
)

func TestColorize(t *testing.T) {
	// When not a terminal, colorize should return plain text
	// (In tests, stdout is typically not a terminal)
	result := colorize("hello", Red)
	// The behavior depends on whether stdout is a terminal
	if isTerminal() {
		if result != Red+"hello"+Reset {
			t.Errorf("expected colored output, got %q", result)
		}
	} else {
		if result != "hello" {
			t.Errorf("expected plain text, got %q", result)
		}
	}
}

func TestIsTerminal(t *testing.T) {
	// In test environment, stdout is typically not a terminal
	fi, err := os.Stdout.Stat()
	if err != nil {
		t.Skip("cannot stat stdout")
	}
	expected := fi.Mode()&os.ModeCharDevice != 0
	if isTerminal() != expected {
		t.Errorf("isTerminal() = %v, expected %v", isTerminal(), expected)
	}
}

func TestTruncate(t *testing.T) {
	tests := []struct {
		input    string
		maxLen   int
		expected string
	}{
		{"hello", 10, "hello"},
		{"hello world", 5, "hell…"},
		{"hi", 2, "hi"},
		{"a", 1, "a"},
		{"hello", 3, "he…"},
	}

	for _, tt := range tests {
		result := truncate(tt.input, tt.maxLen)
		if result != tt.expected {
			t.Errorf("truncate(%q, %d) = %q, expected %q",
				tt.input, tt.maxLen, result, tt.expected)
		}
	}
}

func TestPadRight(t *testing.T) {
	tests := []struct {
		input    string
		width    int
		expected string
	}{
		{"hello", 10, "hello     "},
		{"hello", 5, "hello"},
		{"hello", 3, "hello"},
	}

	for _, tt := range tests {
		result := padRight(tt.input, tt.width)
		if result != tt.expected {
			t.Errorf("padRight(%q, %d) = %q, expected %q",
				tt.input, tt.width, result, tt.expected)
		}
	}
}

func TestMakeBar(t *testing.T) {
	tests := []struct {
		value    int
		maxVal   int
		width    int
		filledLen int
	}{
		{10, 10, 10, 10}, // Full bar
		{5, 10, 10, 5},   // Half bar
		{0, 10, 10, 0},   // Empty bar
		{1, 100, 10, 1},  // Minimum 1 when value > 0
	}

	for _, tt := range tests {
		bar := makeBar(tt.value, tt.maxVal, tt.width)
		filled := 0
		for _, r := range bar {
			if r == '█' {
				filled++
			}
		}
		if filled != tt.filledLen {
			t.Errorf("makeBar(%d, %d, %d) filled=%d, expected %d (bar=%q)",
				tt.value, tt.maxVal, tt.width, filled, tt.filledLen, bar)
		}
		if len([]rune(bar)) != tt.width {
			t.Errorf("makeBar(%d, %d, %d) width=%d, expected %d",
				tt.value, tt.maxVal, tt.width, len([]rune(bar)), tt.width)
		}
	}
}

func TestMakeBarZeroMax(t *testing.T) {
	bar := makeBar(0, 0, 10)
	filled := 0
	for _, r := range bar {
		if r == '█' {
			filled++
		}
	}
	if filled != 0 {
		t.Errorf("makeBar with maxVal=0 should have no filled chars, got %d", filled)
	}
}

func TestMin(t *testing.T) {
	if min(3, 5) != 3 {
		t.Error("min(3, 5) should be 3")
	}
	if min(7, 2) != 2 {
		t.Error("min(7, 2) should be 2")
	}
	if min(4, 4) != 4 {
		t.Error("min(4, 4) should be 4")
	}
}

func TestMax(t *testing.T) {
	if max(3, 5) != 5 {
		t.Error("max(3, 5) should be 5")
	}
	if max(7, 2) != 7 {
		t.Error("max(7, 2) should be 7")
	}
	if max(4, 4) != 4 {
		t.Error("max(4, 4) should be 4")
	}
}

func TestContributionCell(t *testing.T) {
	// Zero count should return dim block
	cell := contributionCell(0, 10)
	if cell == "" {
		t.Error("contributionCell(0, 10) should not be empty")
	}

	// High count should return bold green block
	cell = contributionCell(10, 10)
	if cell == "" {
		t.Error("contributionCell(10, 10) should not be empty")
	}

	// Mid count
	cell = contributionCell(5, 10)
	if cell == "" {
		t.Error("contributionCell(5, 10) should not be empty")
	}
}

func TestHourColor(t *testing.T) {
	tests := []struct {
		hour     int
		expected string
	}{
		{3, Magenta},   // Night
		{8, Yellow},    // Morning
		{14, Green},    // Afternoon
		{20, Cyan},     // Evening
	}

	for _, tt := range tests {
		result := hourColor(tt.hour)
		if result != tt.expected {
			t.Errorf("hourColor(%d) = %q, expected %q", tt.hour, result, tt.expected)
		}
	}
}

func TestBarColor(t *testing.T) {
	// High ratio -> Red
	if barColor(90, 100) != Red {
		t.Error("expected Red for high ratio")
	}
	// Medium ratio -> Yellow
	if barColor(60, 100) != Yellow {
		t.Error("expected Yellow for medium ratio")
	}
	// Low ratio -> Green
	if barColor(30, 100) != Green {
		t.Error("expected Green for low ratio")
	}
	// Very low -> Cyan
	if barColor(10, 100) != Cyan {
		t.Error("expected Cyan for very low ratio")
	}
}