Netpulse_SasS/server/internal/store/queues_detail_test.go

package store

import (
	"strings"
	"testing"
	"time"
)

// Тут перевіряється не SQL, а рішення, які він обслуговує: чи не бреше
// перелік про власний масштаб, коли спрацювала стеля, і чи не мовчить
// він про зонди, які взагалі нічого не рахують.
//
// Помилка в цих двох місцях не впаде складанням і не з'явиться в логах.
// Вона просто одного разу покаже «10 перевірок» замість двохсот або
// зелений перелік замість «ніхто не міряє».

func detailGroup(t *testing.T, det *QueueDetail, key string) QueueDetailGroup {
	t.Helper()
	for _, g := range det.Groups {
		if g.Key == key {
			return g
		}
	}
	t.Fatalf("групи %q немає в переліку %q", key, det.Key)
	return QueueDetailGroup{}
}

// Стеля рядків не має применшувати проблему.
//
// Двісті перевірок з однією причиною — це «200» у заголовку й десяток
// прикладів під ним. Якщо кількість почне рахуватись по показаних
// рядках, сторінка мовчки перетворить аварію на дрібницю.
func TestDetailKeepsTrueCountWhenRowsAreCapped(t *testing.T) {
	det := &QueueDetail{Key: "test"}
	g := QueueDetailGroup{Key: "g", Level: LevelCrit, Count: 200}
	for i := 0; i < detailRowsPerGroup*3; i++ {
		g.Rows = append(g.Rows, QueueDetailRow{Title: "перевірка"})
	}
	det.Groups = append(det.Groups, g)
	finishDetail(det)

	got := detailGroup(t, det, "g")
	if got.Count != 200 {
		t.Fatalf("кількість у групі: %d, очікували 200", got.Count)
	}
	if len(got.Rows) != detailRowsPerGroup {
		t.Fatalf("показано рядків: %d, стеля — %d", len(got.Rows), detailRowsPerGroup)
	}
	if got.More != 200-detailRowsPerGroup {
		t.Fatalf("«ще N» = %d, очікували %d", got.More, 200-detailRowsPerGroup)
	}
	if det.Total != 200 {
		t.Fatalf("підсумок: %d, очікували 200", det.Total)
	}
}

// Кількість не може бути меншою за показане.
//
// Кількості й рядки беруться двома різними запитами, і між ними минає
// час. Група, у якій «ще -3», означала б, що читати можна лише одне з
// двох чисел, а яке саме — невідомо.
func TestDetailNeverPromisesFewerThanItShows(t *testing.T) {
	det := &QueueDetail{Key: "test", Groups: []QueueDetailGroup{{
		Key: "g", Level: LevelWarn, Count: 1,
		Rows: []QueueDetailRow{{Title: "a"}, {Title: "b"}, {Title: "c"}},
	}}}
	finishDetail(det)

	got := detailGroup(t, det, "g")
	if got.Count != 3 || got.More != 0 {
		t.Fatalf("кількість %d, «ще» %d — очікували 3 і 0", got.Count, got.More)
	}
}

// Порядок груп — за тяжкістю, і він не має стрибати.
//
// Групи збираються по мапі, а обхід мапи в Go випадковий. Перелік, що
// перетасовується на кожному оновленні, доводиться читати щоразу
// заново — тобто він перестає бути переліком.
func TestDetailOrdersBySeverityAndIsStable(t *testing.T) {
	build := func() *QueueDetail {
		return &QueueDetail{Key: "test", Groups: []QueueDetailGroup{
			{Key: "ok-b", Level: LevelOK, Count: 5},
			{Key: "crit", Level: LevelCrit, Count: 1},
			{Key: "ok-a", Level: LevelOK, Count: 5},
			{Key: "warn", Level: LevelWarn, Count: 99},
		}}
	}
	want := []string{"crit", "warn", "ok-a", "ok-b"}
	for range 5 {
		det := build()
		finishDetail(det)
		for i, key := range want {
			if det.Groups[i].Key != key {
				t.Fatalf("порядок груп: %d-та — %q, очікували %q", i, det.Groups[i].Key, key)
			}
		}
	}
}

// Зонд, який не рахує втрат, має бути названий вголос.
//
// Порожнє місце на сторінці про втрати читається як нуль. Це та сама
// помилка, від якої стереже блок «чого ця сторінка не бачить», тільки
// на рівень нижче — у самому переліку.
func TestBufferDetailNamesAgentsThatCountNothing(t *testing.T) {
	depth, dropped := 0, int64(0)
	f := &QueueFacts{At: time.Now(), WindowSec: 3600, Agents: []AgentQueueFacts{
		{ID: "a1", Name: "Мовчун", Status: "online"},
		{ID: "a2", Name: "Рахує", Status: "online", QueueDepth: &depth, Dropped: &dropped},
	}}
	det := &QueueDetail{Key: "agents.buffer"}
	buildBufferDetail(det, f, QueueDeltas{ObservedSec: 120})

	g := detailGroup(t, det, "silent")
	if g.Level != LevelUnknown {
		t.Fatalf("рівень групи мовчунів: %q", g.Level)
	}
	if g.Count != 1 || g.Rows[0].Title != "Мовчун" {
		t.Fatalf("у групі мовчунів %d рядків: %+v", g.Count, g.Rows)
	}
	if detailGroup(t, det, "quiet").Count != 1 {
		t.Fatal("зонд, що чесно доповідає нуль, має бути окремо від того, хто мовчить")
	}
}

// Свіжі втрати — окрема група, і в рядку має стояти скільки саме.
func TestBufferDetailSeparatesFreshLoss(t *testing.T) {
	dropped := int64(4200)
	f := &QueueFacts{At: time.Now(), WindowSec: 3600, Agents: []AgentQueueFacts{
		{ID: "a1", Name: "Зонд", Status: "online", Dropped: &dropped},
	}}
	det := &QueueDetail{Key: "agents.buffer"}
	buildBufferDetail(det, f, QueueDeltas{ObservedSec: 120,
		AgentDropped: map[string]int64{"a1": 17}})

	g := detailGroup(t, det, "dropping")
	if g.Level != LevelCrit || g.Count != 1 {
		t.Fatalf("рівень %q, рядків %d", g.Level, g.Count)
	}
	var found bool
	for _, fl := range g.Rows[0].Fields {
		if strings.HasPrefix(fl.Label, "викинуто за ") && fl.Value == "17" {
			found = true
		}
	}
	if !found {
		t.Fatalf("у рядку немає числа щойно викинутого: %+v", g.Rows[0].Fields)
	}
}

// Черга, для якої переліку не існує, мусить це сказати.
//
// Порожній перелік без пояснення читається як «проблем немає». У пулу
// з'єднань перелік не існує в природі, і мовчати про це — гірше, ніж
// не показувати картку взагалі.
func TestPoolDetailExplainsWhyThereIsNoList(t *testing.T) {
	det := &QueueDetail{Key: "db.pool"}
	buildPoolDetail(det, &QueueFacts{At: time.Now()}, QueueDeltas{ObservedSec: 120})

	if det.Intro == "" || !strings.Contains(strings.ToLower(det.Intro), "переліку") {
		t.Fatalf("вступ не пояснює відсутність переліку: %q", det.Intro)
	}
	if det.Note == "" || !strings.Contains(det.Note, "колектора") {
		t.Fatalf("не сказано, що пул колектора звідси не видно: %q", det.Note)
	}
	if len(det.Groups) == 0 || len(det.Groups[0].Rows) == 0 {
		t.Fatal("навіть без переліку числа пулу мають бути показані")
	}
}

// Ключі переліків мають збігатися з ключами карток.
//
// Розійшовшись, вони дадуть картку, яка відкривається в порожнечу, —
// і помітно це стане лише кліком по ній.
func TestDetailKeysMatchCardKeys(t *testing.T) {
	r := BuildQueueReport(&QueueFacts{At: time.Now(), WindowSec: 3600}, QueueDeltas{})
	known := map[string]bool{}
	for _, k := range QueueDetailKeys() {
		known[k] = true
	}
	for _, c := range r.Cards {
		if !known[c.Key] {
			t.Fatalf("картка %q не має переліку", c.Key)
		}
	}
	if len(QueueDetailKeys()) != len(r.Cards) {
		t.Fatalf("переліків %d, карток %d", len(QueueDetailKeys()), len(r.Cards))
	}
}