kubesolo-os/update/pkg/metrics/metrics_test.go

package metrics

import (
	"io"
	"net/http"
	"net/http/httptest"
	"os"
	"path/filepath"
	"strings"
	"testing"

	"github.com/portainer/kubesolo-os/update/pkg/state"
)

func TestNewServer(t *testing.T) {
	s := NewServer(":9100", "/boot/grub/grubenv")
	if s == nil {
		t.Fatal("NewServer returned nil")
	}
	if s.listenAddr != ":9100" {
		t.Errorf("listenAddr = %q, want %q", s.listenAddr, ":9100")
	}
	if s.grubenvPath != "/boot/grub/grubenv" {
		t.Errorf("grubenvPath = %q, want %q", s.grubenvPath, "/boot/grub/grubenv")
	}
	if s.startTime.IsZero() {
		t.Error("startTime not set")
	}
}

func TestSetUpdateAvailable(t *testing.T) {
	s := NewServer(":9100", "/tmp/nonexistent")

	s.SetUpdateAvailable(true)
	s.mu.Lock()
	if s.updateAvailable != 1 {
		t.Errorf("updateAvailable = %d, want 1", s.updateAvailable)
	}
	if s.lastCheckTime == 0 {
		t.Error("lastCheckTime not updated")
	}
	s.mu.Unlock()

	s.SetUpdateAvailable(false)
	s.mu.Lock()
	if s.updateAvailable != 0 {
		t.Errorf("updateAvailable = %d, want 0", s.updateAvailable)
	}
	s.mu.Unlock()
}

func TestHandleHealthz(t *testing.T) {
	s := NewServer(":9100", "/tmp/nonexistent")

	req := httptest.NewRequest(http.MethodGet, "/healthz", nil)
	w := httptest.NewRecorder()

	s.handleHealthz(w, req)

	resp := w.Result()
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		t.Errorf("status = %d, want %d", resp.StatusCode, http.StatusOK)
	}

	body, _ := io.ReadAll(resp.Body)
	if string(body) != "ok\n" {
		t.Errorf("body = %q, want %q", string(body), "ok\n")
	}
}

func TestHandleMetrics(t *testing.T) {
	// Create a temp grubenv
	dir := t.TempDir()
	grubenv := filepath.Join(dir, "grubenv")
	content := "active_slot=A\nboot_success=1\nboot_counter=3\n"
	if err := os.WriteFile(grubenv, []byte(content), 0644); err != nil {
		t.Fatal(err)
	}

	// Create a fake version file — we'll test that missing version returns "unknown"
	s := NewServer(":9100", grubenv)
	s.SetUpdateAvailable(true)

	req := httptest.NewRequest(http.MethodGet, "/metrics", nil)
	w := httptest.NewRecorder()

	s.handleMetrics(w, req)

	resp := w.Result()
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		t.Errorf("status = %d, want %d", resp.StatusCode, http.StatusOK)
	}

	ct := resp.Header.Get("Content-Type")
	if !strings.Contains(ct, "text/plain") {
		t.Errorf("Content-Type = %q, want text/plain", ct)
	}

	body, _ := io.ReadAll(resp.Body)
	output := string(body)

	// Check expected metrics are present
	expectedMetrics := []string{
		"kubesolo_os_info{",
		"active_slot=\"A\"",
		"kubesolo_os_boot_success 1",
		"kubesolo_os_boot_counter 3",
		"kubesolo_os_uptime_seconds",
		"kubesolo_os_update_available 1",
		"kubesolo_os_update_last_check_timestamp_seconds",
		"kubesolo_os_memory_total_bytes",
		"kubesolo_os_memory_available_bytes",
	}

	for _, expected := range expectedMetrics {
		if !strings.Contains(output, expected) {
			t.Errorf("metrics output missing %q\nfull output:\n%s", expected, output)
		}
	}

	// Check HELP and TYPE comments
	expectedHelp := []string{
		"# HELP kubesolo_os_info",
		"# TYPE kubesolo_os_info gauge",
		"# HELP kubesolo_os_boot_success",
		"# HELP kubesolo_os_uptime_seconds",
		"# HELP kubesolo_os_update_available",
		"# HELP kubesolo_os_memory_total_bytes",
	}

	for _, expected := range expectedHelp {
		if !strings.Contains(output, expected) {
			t.Errorf("metrics output missing %q", expected)
		}
	}
}

func TestHandleMetricsMissingGrubenv(t *testing.T) {
	s := NewServer(":9100", "/tmp/nonexistent-grubenv-file")

	req := httptest.NewRequest(http.MethodGet, "/metrics", nil)
	w := httptest.NewRecorder()

	s.handleMetrics(w, req)

	resp := w.Result()
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	output := string(body)

	// Should still render with defaults
	if !strings.Contains(output, "kubesolo_os_boot_success 0") {
		t.Errorf("expected boot_success=0 with missing grubenv, got:\n%s", output)
	}
	if !strings.Contains(output, "kubesolo_os_boot_counter 0") {
		t.Errorf("expected boot_counter=0 with missing grubenv, got:\n%s", output)
	}
	// active_slot should be empty
	if !strings.Contains(output, `active_slot=""`) {
		t.Errorf("expected empty active_slot with missing grubenv, got:\n%s", output)
	}
}

func TestHandleMetricsUpdateNotAvailable(t *testing.T) {
	s := NewServer(":9100", "/tmp/nonexistent")
	// Don't call SetUpdateAvailable — should default to 0

	req := httptest.NewRequest(http.MethodGet, "/metrics", nil)
	w := httptest.NewRecorder()

	s.handleMetrics(w, req)

	resp := w.Result()
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	output := string(body)

	if !strings.Contains(output, "kubesolo_os_update_available 0") {
		t.Errorf("expected update_available=0 by default, got:\n%s", output)
	}
	if !strings.Contains(output, "kubesolo_os_update_last_check_timestamp_seconds 0") {
		t.Errorf("expected last_check=0 by default, got:\n%s", output)
	}
}

func TestReadGrubenvVar(t *testing.T) {
	dir := t.TempDir()
	grubenv := filepath.Join(dir, "grubenv")
	content := "active_slot=B\nboot_success=0\nboot_counter=2\nsome_other=value\n"
	if err := os.WriteFile(grubenv, []byte(content), 0644); err != nil {
		t.Fatal(err)
	}

	s := NewServer(":9100", grubenv)

	tests := []struct {
		key  string
		want string
	}{
		{"active_slot", "B"},
		{"boot_success", "0"},
		{"boot_counter", "2"},
		{"some_other", "value"},
		{"nonexistent", ""},
	}

	for _, tt := range tests {
		got := s.readGrubenvVar(tt.key)
		if got != tt.want {
			t.Errorf("readGrubenvVar(%q) = %q, want %q", tt.key, got, tt.want)
		}
	}
}

func TestReadGrubenvVarMissingFile(t *testing.T) {
	s := NewServer(":9100", "/tmp/nonexistent-grubenv")
	got := s.readGrubenvVar("active_slot")
	if got != "" {
		t.Errorf("readGrubenvVar with missing file = %q, want empty", got)
	}
}

func TestSafeInt(t *testing.T) {
	tests := []struct {
		input string
		def   string
		want  string
	}{
		{"42", "0", "42"},
		{"0", "0", "0"},
		{"3", "0", "3"},
		{"", "0", "0"},
		{"abc", "0", "0"},
		{"1.5", "0", "0"},
		{"-1", "0", "-1"},
	}

	for _, tt := range tests {
		got := safeInt(tt.input, tt.def)
		if got != tt.want {
			t.Errorf("safeInt(%q, %q) = %q, want %q", tt.input, tt.def, got, tt.want)
		}
	}
}

func TestUpdateStateMetricsAbsentStateFile(t *testing.T) {
	// No state path set — should emit Idle defaults so the metric series
	// exists from first boot.
	s := NewServer(":9100", "/tmp/nonexistent")

	req := httptest.NewRequest(http.MethodGet, "/metrics", nil)
	w := httptest.NewRecorder()
	s.handleMetrics(w, req)

	body, _ := io.ReadAll(w.Result().Body)
	output := string(body)

	if !strings.Contains(output, `kubesolo_update_phase{phase="idle"} 1`) {
		t.Errorf("expected idle=1 with no state file, got:\n%s", output)
	}
	if !strings.Contains(output, `kubesolo_update_phase{phase="checking"} 0`) {
		t.Errorf("expected checking=0 with no state file, got:\n%s", output)
	}
	if !strings.Contains(output, "kubesolo_update_attempts_total 0") {
		t.Errorf("expected attempts=0 with no state file, got:\n%s", output)
	}
}

func TestUpdateStateMetricsActivePhase(t *testing.T) {
	dir := t.TempDir()
	statePath := filepath.Join(dir, "state.json")

	st := state.New()
	if err := st.Transition(statePath, state.PhaseDownloading, "v0.3.0", ""); err != nil {
		t.Fatalf("seed state: %v", err)
	}

	s := NewServer(":9100", "/tmp/nonexistent")
	s.SetStatePath(statePath)

	req := httptest.NewRequest(http.MethodGet, "/metrics", nil)
	w := httptest.NewRecorder()
	s.handleMetrics(w, req)

	body, _ := io.ReadAll(w.Result().Body)
	output := string(body)

	if !strings.Contains(output, `kubesolo_update_phase{phase="downloading"} 1`) {
		t.Errorf("expected downloading=1, got:\n%s", output)
	}
	if !strings.Contains(output, `kubesolo_update_phase{phase="idle"} 0`) {
		t.Errorf("expected idle=0 when downloading is active, got:\n%s", output)
	}
	if !strings.Contains(output, "kubesolo_update_attempts_total 1") {
		t.Errorf("expected attempts=1 after first Transition, got:\n%s", output)
	}
	if strings.Contains(output, "kubesolo_update_last_attempt_timestamp_seconds 0\n") {
		t.Errorf("expected non-zero timestamp after state write, got:\n%s", output)
	}
}

func TestUpdateStateMetricsAllPhasesEmitted(t *testing.T) {
	// Every phase value should appear in the output, so dashboards can graph
	// the series cleanly.
	s := NewServer(":9100", "/tmp/nonexistent")

	req := httptest.NewRequest(http.MethodGet, "/metrics", nil)
	w := httptest.NewRecorder()
	s.handleMetrics(w, req)

	body, _ := io.ReadAll(w.Result().Body)
	output := string(body)

	for _, p := range []state.Phase{
		state.PhaseIdle, state.PhaseChecking, state.PhaseDownloading,
		state.PhaseStaged, state.PhaseActivated, state.PhaseVerifying,
		state.PhaseSuccess, state.PhaseRolledBack, state.PhaseFailed,
	} {
		needle := `kubesolo_update_phase{phase="` + string(p) + `"}`
		if !strings.Contains(output, needle) {
			t.Errorf("phase %q not present in metrics output", p)
		}
	}
}

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

	// Test existing file
	path := filepath.Join(dir, "version")
	if err := os.WriteFile(path, []byte("  1.2.3\n  "), 0644); err != nil {
		t.Fatal(err)
	}
	got := readFileString(path)
	if got != "1.2.3" {
		t.Errorf("readFileString = %q, want %q", got, "1.2.3")
	}

	// Test missing file
	got = readFileString("/tmp/nonexistent-file-12345")
	if got != "unknown" {
		t.Errorf("readFileString missing file = %q, want %q", got, "unknown")
	}
}