shater/common/urltest/board_capacity_lx_test.go

// lx:begin health-board

package urltest

import (
	"strconv"
	"strings"
	"sync"
	"testing"
	"time"

	"github.com/sagernet/sing-box/adapter"
)

// captureEvictions swaps the eviction notice sink for the duration of a test and
// returns a func that reads back everything reported.
func captureEvictions(t *testing.T) func() []string {
	t.Helper()
	var (
		mu   sync.Mutex
		msgs []string
	)
	orig := boardEvictionLog
	boardEvictionLog = func(m string) {
		mu.Lock()
		msgs = append(msgs, m)
		mu.Unlock()
	}
	t.Cleanup(func() { boardEvictionLog = orig })
	return func() []string {
		mu.Lock()
		defer mu.Unlock()
		return append([]string(nil), msgs...)
	}
}

// TestBoardHoldsAGenerationWithoutEvicting is the "what it holds" half of the
// bound. A live generation on this box is ~1200 tags (≈380 nodes plus their
// per-group egress copies and chain hops); the board must carry that — and a
// second generation's worth of overlap during a subscription rename — with no
// eviction at all, or the ceiling would be silently degrading real health data.
func TestBoardHoldsAGenerationWithoutEvicting(t *testing.T) {
	read := captureEvictions(t)
	s := NewHistoryStorage()

	const generation = 1200
	for gen := 0; gen < 2; gen++ {
		for i := 0; i < generation; i++ {
			s.StoreURLTestHistory("gen"+strconv.Itoa(gen)+"-node-"+strconv.Itoa(i),
				&adapter.URLTestHistory{LastOK: time.Now(), Delay: 20})
		}
	}
	if got := s.Evicted(); got != 0 {
		t.Fatalf("two full generations (%d tags) evicted %d entries; the board must hold them",
			2*generation, got)
	}
	if msgs := read(); len(msgs) != 0 {
		t.Fatalf("unexpected eviction notices: %v", msgs)
	}
	// Everything is still readable.
	if s.LoadURLTestHistory("gen0-node-0") == nil {
		t.Fatalf("the first tag of the first generation was lost without an eviction")
	}
}

// TestBoardEvictsOldestAndSaysSo is the "what happens when it overflows" half.
// Overflow must (a) actually bound the map, (b) drop the LEAST RECENTLY MEASURED
// tags — on this box, exactly the ones no config names any more — and (c) be
// audible: a silent eviction is a health board quietly forgetting nodes it is
// still being asked about.
func TestBoardEvictsOldestAndSaysSo(t *testing.T) {
	read := captureEvictions(t)
	s := NewHistoryStorage()

	base := time.Now().Add(-24 * time.Hour)
	// Stale generation first: measured a day ago, nothing since.
	const stale = 1500
	for i := 0; i < stale; i++ {
		s.StoreURLTestHistory("stale-"+strconv.Itoa(i),
			&adapter.URLTestHistory{LastOK: base.Add(time.Duration(i) * time.Millisecond), Delay: 30})
	}
	if s.Evicted() != 0 {
		t.Fatalf("evicted before the ceiling was reached")
	}
	// Now push past the ceiling with fresh measurements.
	for i := 0; i <= maxBoardEntries; i++ {
		s.StoreURLTestHistory("fresh-"+strconv.Itoa(i),
			&adapter.URLTestHistory{LastOK: time.Now(), Delay: 15})
	}

	if got := s.Evicted(); got == 0 {
		t.Fatalf("board grew past %d entries without evicting anything — it is still unbounded", maxBoardEntries)
	}
	s.access.RLock()
	size := len(s.delayHistory)
	s.access.RUnlock()
	if size > maxBoardEntries {
		t.Fatalf("board holds %d entries, above the %d ceiling", size, maxBoardEntries)
	}

	// The day-old generation is what went, not the fresh one.
	if s.LoadURLTestHistory("stale-0") != nil {
		t.Fatalf("the oldest observation survived while newer ones were dropped")
	}
	if s.LoadURLTestHistory("fresh-"+strconv.Itoa(maxBoardEntries)) == nil {
		t.Fatalf("the newest measurement was evicted")
	}

	msgs := read()
	if len(msgs) == 0 {
		t.Fatalf("entries were evicted with no notice — eviction must never be silent")
	}
	m := msgs[0]
	for _, want := range []string{"health board full", "evicted", "re-probed"} {
		if !strings.Contains(m, want) {
			t.Fatalf("eviction notice %q does not say %q", m, want)
		}
	}
}

// TestBoardEvictionThroughMarkFailed pins the OTHER write path. MarkFailed is how
// a dead node is recorded, and a flood of dead renamed nodes is exactly the shape
// of the leak — so it has to prune too, not just the success path.
func TestBoardEvictionThroughMarkFailed(t *testing.T) {
	captureEvictions(t)
	s := NewHistoryStorage()
	for i := 0; i <= maxBoardEntries; i++ {
		s.MarkFailed("dead-" + strconv.Itoa(i))
	}
	s.access.RLock()
	size := len(s.delayHistory)
	s.access.RUnlock()
	if size > maxBoardEntries {
		t.Fatalf("MarkFailed grew the board to %d, above the %d ceiling", size, maxBoardEntries)
	}
	if s.Evicted() == 0 {
		t.Fatalf("MarkFailed never prunes — the failure path is still unbounded")
	}
}

// lx:end health-board