rate_test.go

package main

import (
	"net/http"
	"net/http/httptest"
	"sync"
	"testing"
	"time"
)

func fapprox(a, b float64) bool {
	d := a - b
	if d < 0 {
		d = -d
	}
	return d < 1e-9
}

func TestComputeEnergyWatts(t *testing.T) {
	t0 := time.Unix(1_000_000, 0)
	const maxRange = 262143328850 // realistic max_energy_range_uj

	tests := []struct {
		name     string
		prev     energySample
		cur      energySample
		max      uint64
		wantNil  bool
		wantWatt float64
	}{
		{
			name:     "steady 15W over 1s",
			prev:     energySample{uj: 1_000_000, ts: t0},
			cur:      energySample{uj: 1_000_000 + 15_000_000, ts: t0.Add(time.Second)},
			max:      maxRange,
			wantWatt: 15,
		},
		{
			name:    "interval too short -> nil",
			prev:    energySample{uj: 1_000_000, ts: t0},
			cur:     energySample{uj: 2_000_000, ts: t0.Add(50 * time.Millisecond)},
			max:     maxRange,
			wantNil: true,
		},
		{
			name:    "zero prev (unseeded) -> nil",
			prev:    energySample{},
			cur:     energySample{uj: 2_000_000, ts: t0.Add(time.Second)},
			max:     maxRange,
			wantNil: true,
		},
		{
			name:     "rollover with valid max",
			prev:     energySample{uj: maxRange - 1_000_000, ts: t0},
			cur:      energySample{uj: 2_000_000, ts: t0.Add(time.Second)},
			max:      maxRange,
			wantWatt: 3, // (max - prev + cur) = 1e6 + 2e6 = 3e6 uJ over 1s
		},
		{
			name:    "backwards counter, max unknown (0) -> nil",
			prev:    energySample{uj: 2_000_000, ts: t0},
			cur:     energySample{uj: 500_000, ts: t0.Add(time.Second)},
			max:     0,
			wantNil: true,
		},
		{
			name:    "backwards counter, implausible max<=prev -> nil",
			prev:    energySample{uj: 2_000_000, ts: t0},
			cur:     energySample{uj: 500_000, ts: t0.Add(time.Second)},
			max:     1_000_000,
			wantNil: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := computeEnergyWatts(tt.prev, tt.cur, tt.max)
			if tt.wantNil {
				if got != nil {
					t.Fatalf("expected nil, got %v", *got)
				}
				return
			}
			if got == nil {
				t.Fatalf("expected %v W, got nil", tt.wantWatt)
			}
			if !fapprox(*got, tt.wantWatt) {
				t.Errorf("got %v W, want %v W", *got, tt.wantWatt)
			}
		})
	}
}

func TestComputeNetRates(t *testing.T) {
	t0 := time.Unix(1_000_000, 0)
	tests := []struct {
		name           string
		prev, cur      netSample
		wantNil        bool
		wantRx, wantTx float64
	}{
		{
			name:   "2000 rx / 1000 tx over 2s",
			prev:   netSample{rx: 1000, tx: 500, ts: t0},
			cur:    netSample{rx: 5000, tx: 2500, ts: t0.Add(2 * time.Second)},
			wantRx: 2000,
			wantTx: 1000,
		},
		{
			name:    "interval too short -> nil",
			prev:    netSample{rx: 1000, tx: 500, ts: t0},
			cur:     netSample{rx: 5000, tx: 2500, ts: t0.Add(50 * time.Millisecond)},
			wantNil: true,
		},
		{
			name:    "rx counter reset (backwards) -> nil",
			prev:    netSample{rx: 5000, tx: 500, ts: t0},
			cur:     netSample{rx: 1000, tx: 2500, ts: t0.Add(time.Second)},
			wantNil: true,
		},
		{
			name:    "zero prev (unseeded) -> nil",
			prev:    netSample{},
			cur:     netSample{rx: 5000, tx: 2500, ts: t0.Add(time.Second)},
			wantNil: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := computeNetRates(tt.prev, tt.cur)
			if tt.wantNil {
				if got.rxBytesPerSec != nil || got.txBytesPerSec != nil {
					t.Fatalf("expected null rates, got rx=%v tx=%v", got.rxBytesPerSec, got.txBytesPerSec)
				}
				return
			}
			if got.rxBytesPerSec == nil || got.txBytesPerSec == nil {
				t.Fatalf("expected rates, got nil")
			}
			if !fapprox(*got.rxBytesPerSec, tt.wantRx) || !fapprox(*got.txBytesPerSec, tt.wantTx) {
				t.Errorf("got rx=%v tx=%v, want rx=%v tx=%v",
					*got.rxBytesPerSec, *got.txBytesPerSec, tt.wantRx, tt.wantTx)
			}
		})
	}
}

// TestMetricsHandlerConcurrentSnapshot exercises the cache under concurrent
// writes (sampler) and reads (handlers). Run with -race to catch any
// unsynchronized access to `latest`.
func TestMetricsHandlerConcurrentSnapshot(t *testing.T) {
	storeMetrics(Metrics{}) // ensure a valid snapshot exists so readers get 200

	stop := make(chan struct{})
	var writer sync.WaitGroup
	writer.Add(1)
	go func() {
		defer writer.Done()
		for {
			select {
			case <-stop:
				return
			default:
				var m Metrics
				v := 1.5
				m.CPU.UsagePercent = &v // fresh pointer each store, as in production
				storeMetrics(m)
			}
		}
	}()

	var readers sync.WaitGroup
	for i := 0; i < 50; i++ {
		readers.Add(1)
		go func() {
			defer readers.Done()
			req := httptest.NewRequest(http.MethodGet, "/api/metrics", nil)
			rec := httptest.NewRecorder()
			metricsHandler(rec, req)
			if rec.Code != http.StatusOK {
				t.Errorf("status = %d, want 200", rec.Code)
			}
		}()
	}
	readers.Wait()
	close(stop)
	writer.Wait()
}