The cluster page's usage table showed session:usr-... and proj-... ids; it now shows the person's email, whether it came through a key or the chat page, and the project's path or "personal". Times read "3 hours ago" rather than "3h7m25s ago", everywhere. The usage page's legend gave each line's latest slice, which was 0 beside a table of hundreds; it gives the window's total, and the table's numbers are right-aligned like everywhere else. The PostgreSQL placeholder rewriting skips line comments. An apostrophe in one opened a string that swallowed every placeholder after it. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
199 lines
6.2 KiB
Go
199 lines
6.2 KiB
Go
package web
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"gitea.mynodes.xyz/ilker/llmgw/internal/promq"
|
|
)
|
|
|
|
func ts(name string, vals ...float64) promq.Series {
|
|
s := promq.Series{Name: name}
|
|
base := time.Unix(1700000000, 0)
|
|
for i, v := range vals {
|
|
s.Points = append(s.Points, promq.Point{At: base.Add(time.Duration(i) * time.Minute), Value: v})
|
|
}
|
|
return s
|
|
}
|
|
|
|
func TestEveryLineGetsItsOwnColourAndALegend(t *testing.T) {
|
|
c := LineChart([]promq.Series{ts("a", 1, 2), ts("b", 2, 1), ts("c", 3, 3)}, "", 4)
|
|
|
|
if len(c.Legend) != 3 {
|
|
t.Fatalf("expected a legend entry per line, got %+v", c.Legend)
|
|
}
|
|
seen := map[string]bool{}
|
|
for _, e := range c.Legend {
|
|
if seen[e.Colour] {
|
|
// Two lines in one colour is two lines nobody can tell apart.
|
|
t.Errorf("colour %s used twice", e.Colour)
|
|
}
|
|
seen[e.Colour] = true
|
|
}
|
|
}
|
|
|
|
func TestATailIsFoldedRatherThanGivenNewColours(t *testing.T) {
|
|
in := []promq.Series{
|
|
ts("big", 10, 10), ts("m2", 5, 5), ts("m3", 4, 4),
|
|
ts("m4", 1, 1), ts("m5", 2, 2), ts("m6", 3, 3),
|
|
}
|
|
c := LineChart(in, "", 4)
|
|
|
|
// The palette has four colours and a fifth line does not get a generated
|
|
// hue. The tail is summed so the chart still adds up.
|
|
if len(c.Legend) != 4 {
|
|
t.Fatalf("expected four lines, got %d: %+v", len(c.Legend), c.Legend)
|
|
}
|
|
last := c.Legend[3]
|
|
if last.Name != "other" {
|
|
t.Errorf("the tail should be named, got %q", last.Name)
|
|
}
|
|
// m4+m5+m6 at the same instant is 6, not any one of them.
|
|
if last.Last != "6" {
|
|
t.Errorf("the tail should be summed, got %q", last.Last)
|
|
}
|
|
}
|
|
|
|
func TestTheTailIsSummedByTimestampNotByPosition(t *testing.T) {
|
|
// Two tail series sampled at different times. Added by index their points
|
|
// would slide sideways onto each other's clock.
|
|
a := promq.Series{Name: "a", Points: []promq.Point{{At: time.Unix(100, 0), Value: 1}}}
|
|
b := promq.Series{Name: "b", Points: []promq.Point{{At: time.Unix(200, 0), Value: 2}}}
|
|
big := ts("big", 9, 9, 9)
|
|
|
|
c := LineChart([]promq.Series{big, ts("x", 8, 8), ts("y", 7, 7), a, b}, "", 4)
|
|
if c.Legend[3].Name != "other" || c.Legend[3].Last != "2" {
|
|
t.Errorf("expected the latest tail point alone, got %+v", c.Legend[3])
|
|
}
|
|
}
|
|
|
|
func TestAFlatZeroIsDrawnRatherThanLeftBlank(t *testing.T) {
|
|
c := LineChart([]promq.Series{ts("idle", 0, 0, 0)}, "", 4)
|
|
|
|
// Nothing happening is a real answer, and a line along the bottom says so
|
|
// where an empty frame reads as a broken chart.
|
|
if c.Empty {
|
|
t.Fatal("a quiet series is not an absent one")
|
|
}
|
|
if !strings.Contains(string(c.SVG), "polyline") {
|
|
t.Error("the line should be drawn")
|
|
}
|
|
}
|
|
|
|
func TestNothingToDrawSaysSoInsteadOfDrawingAFrame(t *testing.T) {
|
|
if got := LineChart(nil, "", 4); !got.Empty {
|
|
t.Error("no series is empty")
|
|
}
|
|
// One instant is not a line: drawn, it is a dot in the corner.
|
|
one := promq.Series{Name: "a", Points: []promq.Point{{At: time.Unix(1, 0), Value: 5}}}
|
|
if got := LineChart([]promq.Series{one}, "", 4); !got.Empty {
|
|
t.Error("a single sample is not a line")
|
|
}
|
|
}
|
|
|
|
func TestTheAxisTopsOutAtANumberAPersonWouldChoose(t *testing.T) {
|
|
c := LineChart([]promq.Series{ts("a", 0.1, 0.8347)}, "", 4)
|
|
// 0.8347 as the top makes every gridline unreadable, and the shape of the
|
|
// data is what the chart is for.
|
|
if c.Peak != "1" {
|
|
t.Errorf("expected a rounded ceiling, got %q", c.Peak)
|
|
}
|
|
}
|
|
|
|
func TestPercentagesAndSecondsReadAsThemselves(t *testing.T) {
|
|
if got := formatValue(0.42, "%"); got != "42%" {
|
|
t.Errorf("percent: %q", got)
|
|
}
|
|
if got := formatValue(0.035, "s"); got != "35ms" {
|
|
t.Errorf("sub-second latency should read in ms, got %q", got)
|
|
}
|
|
if got := formatValue(12.5, "s"); got != "12.5s" {
|
|
t.Errorf("seconds: %q", got)
|
|
}
|
|
}
|
|
|
|
func TestAValueAboveTheCeilingIsClampedNotDrawnOffTheChart(t *testing.T) {
|
|
// Only reachable if a series changes between the bounds pass and drawing,
|
|
// but an SVG point outside the viewBox is a line that leaves the frame.
|
|
if got := clamp01(1.4); got != 1 {
|
|
t.Errorf("expected clamping, got %v", got)
|
|
}
|
|
if got := clamp01(-2); got != 0 {
|
|
t.Errorf("expected clamping, got %v", got)
|
|
}
|
|
}
|
|
|
|
// fakeHistory stands in for a metrics store.
|
|
type fakeHistory struct {
|
|
byExpr map[string][]promq.Series
|
|
err error
|
|
asked []string
|
|
}
|
|
|
|
func (f *fakeHistory) RangeQuery(_ context.Context, expr, _ string,
|
|
_, _ time.Duration,
|
|
) ([]promq.Series, error) {
|
|
f.asked = append(f.asked, expr)
|
|
return f.byExpr[expr], f.err
|
|
}
|
|
|
|
func TestTheFleetPanelsAreEachQueried(t *testing.T) {
|
|
h := &fakeHistory{byExpr: map[string][]promq.Series{
|
|
"llmgw_pool_saturation": {ts("qwen", 0.1, 0.4)},
|
|
"llmgw_endpoint_waiting": {ts("r1", 0, 2)},
|
|
"llmgw_endpoint_kv_cache_usage": {ts("r1", 0.1, 0.2)},
|
|
"llmgw_model_replicas_ready": {ts("qwen", 3, 3)},
|
|
}}
|
|
got := LoadFleetCharts(context.Background(), h, time.Hour, nil)
|
|
|
|
if len(h.asked) != 4 {
|
|
t.Fatalf("expected one query per panel, got %v", h.asked)
|
|
}
|
|
for name, c := range map[string]TimeSeries{
|
|
"saturation": got.Saturation, "queue": got.Queue,
|
|
"kv": got.KV, "ready": got.Ready,
|
|
} {
|
|
if c.Empty {
|
|
t.Errorf("%s came back empty", name)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestOneFailedQueryFailsThemAll(t *testing.T) {
|
|
h := &fakeHistory{err: errors.New("reaching Prometheus: refused")}
|
|
got := LoadFleetCharts(context.Background(), h, time.Hour, nil)
|
|
|
|
// Three charts drawn and one blank invites reading the blank one as
|
|
// "nothing is happening there". Either the store answered or it did not.
|
|
if got.Err == "" {
|
|
t.Fatal("the failure should be reported")
|
|
}
|
|
if !strings.Contains(got.Err, "refused") {
|
|
t.Errorf("the reason should survive: %q", got.Err)
|
|
}
|
|
}
|
|
|
|
func TestWithNoMetricsStoreThereAreNoPanels(t *testing.T) {
|
|
// A deployment with no Prometheus leaves them off rather than showing
|
|
// empty frames where charts should be.
|
|
if got := LoadFleetCharts(context.Background(), nil, time.Hour, nil); got != nil {
|
|
t.Errorf("expected nothing, got %+v", got)
|
|
}
|
|
}
|
|
|
|
func TestAUsageLegendGivesTotalsNotTheLastSlice(t *testing.T) {
|
|
// A counter's latest slice is usually quiet; "0" beside a line that
|
|
// carried hundreds read as a broken chart.
|
|
c := LineChartTotals([]promq.Series{ts("ml", 5, 7, 0), ts("vision", 1, 2, 0)}, "", 4)
|
|
got := map[string]string{}
|
|
for _, l := range c.Legend {
|
|
got[l.Name] = l.Last
|
|
}
|
|
if got["ml"] != "12" || got["vision"] != "3" {
|
|
t.Errorf("legend = %v, expected the totals", got)
|
|
}
|
|
}
|