mirror of
https://github.com/ClusterCockpit/cc-backend
synced 2026-02-28 21:37:31 +01:00
1037 lines
33 KiB
Go
1037 lines
33 KiB
Go
// Copyright (C) NHR@FAU, University Erlangen-Nuremberg.
|
|
// All rights reserved. This file is part of cc-backend.
|
|
// Use of this source code is governed by a MIT-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package metricstore
|
|
|
|
import (
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/ClusterCockpit/cc-lib/v2/schema"
|
|
)
|
|
|
|
// ─── Buffer pool ─────────────────────────────────────────────────────────────
|
|
|
|
// TestBufferPoolGetReuse verifies that Get() returns pooled buffers before
|
|
// allocating new ones, and that an empty pool allocates a fresh BufferCap buffer.
|
|
func TestBufferPoolGetReuse(t *testing.T) {
|
|
pool := NewPersistentBufferPool()
|
|
|
|
original := &buffer{data: make([]schema.Float, 0, BufferCap), lastUsed: time.Now().Unix()}
|
|
pool.Put(original)
|
|
|
|
reused := pool.Get()
|
|
if reused != original {
|
|
t.Error("Get() should return the previously pooled buffer")
|
|
}
|
|
if pool.GetSize() != 0 {
|
|
t.Errorf("pool size after Get() = %d, want 0", pool.GetSize())
|
|
}
|
|
|
|
// Empty pool must allocate a fresh buffer with the standard capacity.
|
|
fresh := pool.Get()
|
|
if fresh == nil {
|
|
t.Fatal("Get() from empty pool returned nil")
|
|
}
|
|
if cap(fresh.data) != BufferCap {
|
|
t.Errorf("fresh buffer cap = %d, want %d", cap(fresh.data), BufferCap)
|
|
}
|
|
}
|
|
|
|
// TestBufferPoolClear verifies that Clear() drains all entries.
|
|
func TestBufferPoolClear(t *testing.T) {
|
|
pool := NewPersistentBufferPool()
|
|
for i := 0; i < 10; i++ {
|
|
pool.Put(&buffer{data: make([]schema.Float, 0), lastUsed: time.Now().Unix()})
|
|
}
|
|
pool.Clear()
|
|
if pool.GetSize() != 0 {
|
|
t.Errorf("pool size after Clear() = %d, want 0", pool.GetSize())
|
|
}
|
|
}
|
|
|
|
// TestBufferPoolMaxSize verifies that Put() silently drops buffers once the
|
|
// pool reaches maxPoolSize, preventing unbounded memory growth.
|
|
func TestBufferPoolMaxSize(t *testing.T) {
|
|
pool := NewPersistentBufferPool()
|
|
for i := 0; i < maxPoolSize; i++ {
|
|
pool.Put(&buffer{data: make([]schema.Float, 0, BufferCap), lastUsed: time.Now().Unix()})
|
|
}
|
|
if pool.GetSize() != maxPoolSize {
|
|
t.Fatalf("pool size = %d, want %d", pool.GetSize(), maxPoolSize)
|
|
}
|
|
|
|
pool.Put(&buffer{data: make([]schema.Float, 0, BufferCap), lastUsed: time.Now().Unix()})
|
|
if pool.GetSize() != maxPoolSize {
|
|
t.Errorf("pool size after overflow Put = %d, want %d (should not grow)", pool.GetSize(), maxPoolSize)
|
|
}
|
|
}
|
|
|
|
// ─── Buffer helpers ───────────────────────────────────────────────────────────
|
|
|
|
// TestBufferEndFirstWrite verifies the end() and firstWrite() calculations.
|
|
func TestBufferEndFirstWrite(t *testing.T) {
|
|
// start=90, freq=10 → firstWrite = 90+5 = 95
|
|
b := &buffer{data: make([]schema.Float, 4, BufferCap), frequency: 10, start: 90}
|
|
if fw := b.firstWrite(); fw != 95 {
|
|
t.Errorf("firstWrite() = %d, want 95", fw)
|
|
}
|
|
// end = firstWrite + len(data)*freq = 95 + 4*10 = 135
|
|
if e := b.end(); e != 135 {
|
|
t.Errorf("end() = %d, want 135", e)
|
|
}
|
|
}
|
|
|
|
// ─── Buffer write ─────────────────────────────────────────────────────────────
|
|
|
|
// TestBufferWriteNaNFill verifies that skipped timestamps are filled with NaN.
|
|
func TestBufferWriteNaNFill(t *testing.T) {
|
|
b := newBuffer(100, 10)
|
|
b.write(100, schema.Float(1.0))
|
|
// skip 110 and 120
|
|
b.write(130, schema.Float(4.0))
|
|
|
|
if len(b.data) != 4 {
|
|
t.Fatalf("len(data) = %d, want 4 (1 value + 2 NaN + 1 value)", len(b.data))
|
|
}
|
|
if b.data[0] != schema.Float(1.0) {
|
|
t.Errorf("data[0] = %v, want 1.0", b.data[0])
|
|
}
|
|
if !b.data[1].IsNaN() {
|
|
t.Errorf("data[1] should be NaN (gap), got %v", b.data[1])
|
|
}
|
|
if !b.data[2].IsNaN() {
|
|
t.Errorf("data[2] should be NaN (gap), got %v", b.data[2])
|
|
}
|
|
if b.data[3] != schema.Float(4.0) {
|
|
t.Errorf("data[3] = %v, want 4.0", b.data[3])
|
|
}
|
|
}
|
|
|
|
// TestBufferWriteCapacityOverflow verifies that exceeding capacity creates and
|
|
// links a new buffer rather than panicking or silently dropping data.
|
|
func TestBufferWriteCapacityOverflow(t *testing.T) {
|
|
// Cap=2 so the third write must overflow into a new buffer.
|
|
b := &buffer{data: make([]schema.Float, 0, 2), frequency: 10, start: 95}
|
|
|
|
nb, _ := b.write(100, schema.Float(1.0))
|
|
nb, _ = nb.write(110, schema.Float(2.0))
|
|
nb, err := nb.write(120, schema.Float(3.0))
|
|
if err != nil {
|
|
t.Fatalf("write() error = %v", err)
|
|
}
|
|
if nb == b {
|
|
t.Fatal("write() should have returned a new buffer after overflow")
|
|
}
|
|
if nb.prev != b {
|
|
t.Error("new buffer should link back to old via prev")
|
|
}
|
|
if b.next != nb {
|
|
t.Error("old buffer should link forward to new via next")
|
|
}
|
|
if len(b.data) != 2 {
|
|
t.Errorf("old buffer len = %d, want 2 (full)", len(b.data))
|
|
}
|
|
if nb.data[0] != schema.Float(3.0) {
|
|
t.Errorf("new buffer data[0] = %v, want 3.0", nb.data[0])
|
|
}
|
|
}
|
|
|
|
// TestBufferWriteOverwrite verifies that writing to an already-occupied index
|
|
// replaces the value rather than appending.
|
|
func TestBufferWriteOverwrite(t *testing.T) {
|
|
b := newBuffer(100, 10)
|
|
b.write(100, schema.Float(1.0))
|
|
b.write(110, schema.Float(2.0))
|
|
|
|
// Overwrite the first slot.
|
|
b.write(100, schema.Float(99.0))
|
|
if len(b.data) != 2 {
|
|
t.Errorf("len(data) after overwrite = %d, want 2 (no append)", len(b.data))
|
|
}
|
|
if b.data[0] != schema.Float(99.0) {
|
|
t.Errorf("data[0] after overwrite = %v, want 99.0", b.data[0])
|
|
}
|
|
}
|
|
|
|
// ─── Buffer read ──────────────────────────────────────────────────────────────
|
|
|
|
// TestBufferReadBeforeFirstWrite verifies that 'from' is clamped to firstWrite
|
|
// when the requested range starts before any data in the chain.
|
|
func TestBufferReadBeforeFirstWrite(t *testing.T) {
|
|
b := newBuffer(100, 10) // firstWrite = 100
|
|
b.write(100, schema.Float(1.0))
|
|
b.write(110, schema.Float(2.0))
|
|
|
|
data := make([]schema.Float, 10)
|
|
result, adjustedFrom, _, err := b.read(50, 120, data)
|
|
if err != nil {
|
|
t.Fatalf("read() error = %v", err)
|
|
}
|
|
if adjustedFrom != 100 {
|
|
t.Errorf("adjustedFrom = %d, want 100 (clamped to firstWrite)", adjustedFrom)
|
|
}
|
|
if len(result) != 2 {
|
|
t.Errorf("len(result) = %d, want 2", len(result))
|
|
}
|
|
}
|
|
|
|
// TestBufferReadChain verifies that read() traverses a multi-buffer chain and
|
|
// returns contiguous values from both buffers.
|
|
//
|
|
// The switch to b.next in read() triggers on idx >= cap(b.data), so b1 must
|
|
// be full (len == cap) for the loop to advance to b2 without producing NaN.
|
|
func TestBufferReadChain(t *testing.T) {
|
|
// b1: cap=3, covers t=100..120. b2: covers t=130..150. b2 is head.
|
|
b1 := &buffer{data: make([]schema.Float, 0, 3), frequency: 10, start: 95}
|
|
b1.data = append(b1.data, 1.0, 2.0, 3.0) // fills b1: len=cap=3
|
|
|
|
b2 := &buffer{data: make([]schema.Float, 0, 3), frequency: 10, start: 125}
|
|
b2.data = append(b2.data, 4.0, 5.0, 6.0) // t=130,140,150
|
|
b2.prev = b1
|
|
b1.next = b2
|
|
|
|
data := make([]schema.Float, 6)
|
|
result, from, to, err := b2.read(100, 160, data)
|
|
if err != nil {
|
|
t.Fatalf("read() error = %v", err)
|
|
}
|
|
if from != 100 || to != 160 {
|
|
t.Errorf("read() from/to = %d/%d, want 100/160", from, to)
|
|
}
|
|
if len(result) != 6 {
|
|
t.Fatalf("len(result) = %d, want 6", len(result))
|
|
}
|
|
for i, want := range []schema.Float{1, 2, 3, 4, 5, 6} {
|
|
if result[i] != want {
|
|
t.Errorf("result[%d] = %v, want %v", i, result[i], want)
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestBufferReadIdxAfterSwitch is a regression test for the index recalculation
|
|
// bug after switching to b.next during a read.
|
|
//
|
|
// When both buffers share the same start time (can happen with checkpoint-loaded
|
|
// chains), the old code hardcoded idx=0 after the switch, causing reads at time t
|
|
// to return the wrong element from the next buffer.
|
|
func TestBufferReadIdxAfterSwitch(t *testing.T) {
|
|
// b1: cap=2, both buffers start at 0 (firstWrite=5).
|
|
// b1 carries t=5 and t=15; b2 carries t=5,15,25,35 with the same start.
|
|
// When reading reaches t=25 the loop overflows b1 (idx=2 >= cap=2) and
|
|
// switches to b2. The correct index in b2 is (25-0)/10=2 → b2.data[2]=30.0.
|
|
// The old code set idx=0 → b2.data[0]=10.0 (wrong).
|
|
b1 := &buffer{data: make([]schema.Float, 0, 2), frequency: 10, start: 0}
|
|
b1.data = append(b1.data, schema.Float(1.0), schema.Float(2.0)) // t=5, t=15
|
|
|
|
b2 := &buffer{data: make([]schema.Float, 0, 10), frequency: 10, start: 0}
|
|
b2.data = append(b2.data,
|
|
schema.Float(10.0), schema.Float(20.0),
|
|
schema.Float(30.0), schema.Float(40.0)) // t=5,15,25,35
|
|
b2.prev = b1
|
|
b1.next = b2
|
|
|
|
// from=0 triggers the walkback to b1 (from < b2.firstWrite=5).
|
|
// After clamping, the loop runs t=5,15,25,35.
|
|
data := make([]schema.Float, 4)
|
|
result, _, _, err := b2.read(0, 36, data)
|
|
if err != nil {
|
|
t.Fatalf("read() error = %v", err)
|
|
}
|
|
if len(result) < 3 {
|
|
t.Fatalf("len(result) = %d, want >= 3", len(result))
|
|
}
|
|
if result[0] != schema.Float(1.0) {
|
|
t.Errorf("result[0] (t=5) = %v, want 1.0 (from b1)", result[0])
|
|
}
|
|
if result[1] != schema.Float(2.0) {
|
|
t.Errorf("result[1] (t=15) = %v, want 2.0 (from b1)", result[1])
|
|
}
|
|
// This is the critical assertion: old code returned 10.0 (b2.data[0]).
|
|
if result[2] != schema.Float(30.0) {
|
|
t.Errorf("result[2] (t=25) = %v, want 30.0 (idx recalculation fix)", result[2])
|
|
}
|
|
}
|
|
|
|
// TestBufferReadNaNValues verifies that NaN slots written to the buffer are
|
|
// returned as NaN during read.
|
|
func TestBufferReadNaNValues(t *testing.T) {
|
|
b := newBuffer(100, 10)
|
|
b.write(100, schema.Float(1.0))
|
|
b.write(110, schema.NaN)
|
|
b.write(120, schema.Float(3.0))
|
|
|
|
data := make([]schema.Float, 3)
|
|
result, _, _, err := b.read(100, 130, data)
|
|
if err != nil {
|
|
t.Fatalf("read() error = %v", err)
|
|
}
|
|
if len(result) != 3 {
|
|
t.Fatalf("len(result) = %d, want 3", len(result))
|
|
}
|
|
if result[0] != schema.Float(1.0) {
|
|
t.Errorf("result[0] = %v, want 1.0", result[0])
|
|
}
|
|
if !result[1].IsNaN() {
|
|
t.Errorf("result[1] should be NaN, got %v", result[1])
|
|
}
|
|
if result[2] != schema.Float(3.0) {
|
|
t.Errorf("result[2] = %v, want 3.0", result[2])
|
|
}
|
|
}
|
|
|
|
// TestBufferReadAccumulation verifies the += accumulation pattern used for
|
|
// aggregation: values are added to whatever was already in the data slice.
|
|
func TestBufferReadAccumulation(t *testing.T) {
|
|
b := newBuffer(100, 10)
|
|
b.write(100, schema.Float(3.0))
|
|
b.write(110, schema.Float(5.0))
|
|
|
|
// Pre-populate data slice (simulates a second metric being summed in).
|
|
data := []schema.Float{2.0, 1.0, 0.0}
|
|
result, _, _, err := b.read(100, 120, data)
|
|
if err != nil {
|
|
t.Fatalf("read() error = %v", err)
|
|
}
|
|
// 2.0+3.0=5.0, 1.0+5.0=6.0
|
|
if result[0] != schema.Float(5.0) {
|
|
t.Errorf("result[0] = %v, want 5.0 (2+3)", result[0])
|
|
}
|
|
if result[1] != schema.Float(6.0) {
|
|
t.Errorf("result[1] = %v, want 6.0 (1+5)", result[1])
|
|
}
|
|
}
|
|
|
|
// ─── Buffer free ─────────────────────────────────────────────────────────────
|
|
|
|
// newTestPool swaps out the package-level bufferPool for a fresh isolated one
|
|
// and returns a cleanup function that restores the original.
|
|
func newTestPool(t *testing.T) *PersistentBufferPool {
|
|
t.Helper()
|
|
pool := NewPersistentBufferPool()
|
|
saved := bufferPool
|
|
bufferPool = pool
|
|
t.Cleanup(func() { bufferPool = saved })
|
|
return pool
|
|
}
|
|
|
|
// TestBufferFreeRetention verifies that free() removes buffers whose entire
|
|
// time range falls before the retention threshold and returns them to the pool.
|
|
func TestBufferFreeRetention(t *testing.T) {
|
|
pool := newTestPool(t)
|
|
|
|
// b1: firstWrite=5, end=25 b2: firstWrite=25, end=45 b3: firstWrite=45, end=65
|
|
b1 := &buffer{data: make([]schema.Float, 0, BufferCap), frequency: 10, start: 0}
|
|
b1.data = append(b1.data, 1.0, 2.0)
|
|
|
|
b2 := &buffer{data: make([]schema.Float, 0, BufferCap), frequency: 10, start: 20}
|
|
b2.data = append(b2.data, 3.0, 4.0)
|
|
b2.prev = b1
|
|
b1.next = b2
|
|
|
|
b3 := &buffer{data: make([]schema.Float, 0, BufferCap), frequency: 10, start: 40}
|
|
b3.data = append(b3.data, 5.0, 6.0)
|
|
b3.prev = b2
|
|
b2.next = b3
|
|
|
|
// Threshold=30: b1.end()=25 < 30 → freed; b2.end()=45 >= 30 → kept.
|
|
delme, n := b3.free(30)
|
|
if delme {
|
|
t.Error("head buffer b3 should not be marked for deletion")
|
|
}
|
|
if n != 1 {
|
|
t.Errorf("freed count = %d, want 1", n)
|
|
}
|
|
if b2.prev != nil {
|
|
t.Error("b1 should have been unlinked from b2.prev")
|
|
}
|
|
if b3.prev != b2 {
|
|
t.Error("b3 should still reference b2")
|
|
}
|
|
if pool.GetSize() != 1 {
|
|
t.Errorf("pool size = %d, want 1 (b1 returned)", pool.GetSize())
|
|
}
|
|
}
|
|
|
|
// TestBufferFreeAll verifies that free() removes all buffers and signals the
|
|
// caller to delete the head when the entire chain is older than the threshold.
|
|
func TestBufferFreeAll(t *testing.T) {
|
|
pool := newTestPool(t)
|
|
|
|
b1 := &buffer{data: make([]schema.Float, 0, BufferCap), frequency: 10, start: 0}
|
|
b1.data = append(b1.data, 1.0, 2.0) // end=25
|
|
|
|
b2 := &buffer{data: make([]schema.Float, 0, BufferCap), frequency: 10, start: 20}
|
|
b2.data = append(b2.data, 3.0, 4.0) // end=45
|
|
b2.prev = b1
|
|
b1.next = b2
|
|
|
|
// Threshold=100 > both ends → both should be freed.
|
|
delme, n := b2.free(100)
|
|
if !delme {
|
|
t.Error("head buffer b2 should be marked for deletion when all data is stale")
|
|
}
|
|
if n != 2 {
|
|
t.Errorf("freed count = %d, want 2", n)
|
|
}
|
|
// b1 was freed inside free(); b2 is returned with delme=true for the caller.
|
|
if pool.GetSize() != 1 {
|
|
t.Errorf("pool size = %d, want 1 (b1 returned; b2 returned by caller)", pool.GetSize())
|
|
}
|
|
}
|
|
|
|
// ─── forceFreeOldest ─────────────────────────────────────────────────────────
|
|
|
|
// TestForceFreeOldestPoolReturn verifies that forceFreeOldest() returns the
|
|
// freed buffer to the pool (regression: previously it was just dropped).
|
|
func TestForceFreeOldestPoolReturn(t *testing.T) {
|
|
pool := newTestPool(t)
|
|
|
|
b1 := &buffer{data: make([]schema.Float, 0, BufferCap), frequency: 10, start: 0}
|
|
b2 := &buffer{data: make([]schema.Float, 0, BufferCap), frequency: 10, start: 20}
|
|
b3 := &buffer{data: make([]schema.Float, 0, BufferCap), frequency: 10, start: 40}
|
|
b1.data = append(b1.data, 1.0)
|
|
b2.data = append(b2.data, 2.0)
|
|
b3.data = append(b3.data, 3.0)
|
|
b2.prev = b1
|
|
b1.next = b2
|
|
b3.prev = b2
|
|
b2.next = b3
|
|
|
|
delme, n := b3.forceFreeOldest()
|
|
if delme {
|
|
t.Error("head b3 should not be marked for deletion (chain has 3 buffers)")
|
|
}
|
|
if n != 1 {
|
|
t.Errorf("freed count = %d, want 1", n)
|
|
}
|
|
if b2.prev != nil {
|
|
t.Error("b1 should have been unlinked from b2.prev after forceFreeOldest")
|
|
}
|
|
if b3.prev != b2 {
|
|
t.Error("b3 should still link to b2")
|
|
}
|
|
if pool.GetSize() != 1 {
|
|
t.Errorf("pool size = %d, want 1 (b1 returned to pool)", pool.GetSize())
|
|
}
|
|
}
|
|
|
|
// TestForceFreeOldestSingleBuffer verifies that forceFreeOldest() returns
|
|
// delme=true when the buffer is the only one in the chain.
|
|
func TestForceFreeOldestSingleBuffer(t *testing.T) {
|
|
b := newBuffer(100, 10)
|
|
b.write(100, schema.Float(1.0))
|
|
|
|
delme, n := b.forceFreeOldest()
|
|
if !delme {
|
|
t.Error("single-buffer chain: expected delme=true (the buffer IS the oldest)")
|
|
}
|
|
if n != 1 {
|
|
t.Errorf("freed count = %d, want 1", n)
|
|
}
|
|
}
|
|
|
|
// ─── iterFromTo ───────────────────────────────────────────────────────────────
|
|
|
|
// TestBufferIterFromToOrder verifies that iterFromTo invokes the callback in
|
|
// chronological order (oldest → newest).
|
|
func TestBufferIterFromToOrder(t *testing.T) {
|
|
// Each buffer has 2 data points so end() = firstWrite + 2*freq.
|
|
b1 := &buffer{data: make([]schema.Float, 2, BufferCap), frequency: 10, start: 0} // end=25
|
|
b2 := &buffer{data: make([]schema.Float, 2, BufferCap), frequency: 10, start: 20} // end=45
|
|
b3 := &buffer{data: make([]schema.Float, 2, BufferCap), frequency: 10, start: 40} // end=65
|
|
b2.prev = b1
|
|
b1.next = b2
|
|
b3.prev = b2
|
|
b2.next = b3
|
|
|
|
var order []*buffer
|
|
err := b3.iterFromTo(0, 100, func(b *buffer) error {
|
|
order = append(order, b)
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("iterFromTo() error = %v", err)
|
|
}
|
|
if len(order) != 3 {
|
|
t.Fatalf("callback count = %d, want 3", len(order))
|
|
}
|
|
if order[0] != b1 || order[1] != b2 || order[2] != b3 {
|
|
t.Error("iterFromTo() did not call callbacks in chronological (oldest→newest) order")
|
|
}
|
|
}
|
|
|
|
// TestBufferIterFromToFiltered verifies that iterFromTo only calls the callback
|
|
// for buffers whose time range overlaps [from, to].
|
|
func TestBufferIterFromToFiltered(t *testing.T) {
|
|
// b1: end=25 b2: start=20, end=45 b3: start=40, end=65
|
|
b1 := &buffer{data: make([]schema.Float, 2, BufferCap), frequency: 10, start: 0}
|
|
b2 := &buffer{data: make([]schema.Float, 2, BufferCap), frequency: 10, start: 20}
|
|
b3 := &buffer{data: make([]schema.Float, 2, BufferCap), frequency: 10, start: 40}
|
|
b2.prev = b1
|
|
b1.next = b2
|
|
b3.prev = b2
|
|
b2.next = b3
|
|
|
|
// [30,50]: b1.end=25 < 30 → excluded; b2 and b3 overlap → included.
|
|
var visited []*buffer
|
|
b3.iterFromTo(30, 50, func(b *buffer) error {
|
|
visited = append(visited, b)
|
|
return nil
|
|
})
|
|
if len(visited) != 2 {
|
|
t.Fatalf("visited count = %d, want 2 (b2 and b3)", len(visited))
|
|
}
|
|
if visited[0] != b2 || visited[1] != b3 {
|
|
t.Errorf("visited = %v, want [b2, b3]", visited)
|
|
}
|
|
}
|
|
|
|
// TestBufferIterFromToNilBuffer verifies that iterFromTo on a nil buffer is a
|
|
// safe no-op.
|
|
func TestBufferIterFromToNilBuffer(t *testing.T) {
|
|
var b *buffer
|
|
called := false
|
|
err := b.iterFromTo(0, 100, func(_ *buffer) error {
|
|
called = true
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
t.Errorf("iterFromTo(nil) error = %v, want nil", err)
|
|
}
|
|
if called {
|
|
t.Error("callback should not be called for a nil buffer")
|
|
}
|
|
}
|
|
|
|
// ─── count ────────────────────────────────────────────────────────────────────
|
|
|
|
// TestBufferCount verifies that count() sums data-point lengths across the
|
|
// entire chain, including all prev links.
|
|
func TestBufferCount(t *testing.T) {
|
|
b1 := &buffer{data: make([]schema.Float, 3, BufferCap), frequency: 10, start: 0}
|
|
b2 := &buffer{data: make([]schema.Float, 2, BufferCap), frequency: 10, start: 35}
|
|
b3 := &buffer{data: make([]schema.Float, 5, BufferCap), frequency: 10, start: 60}
|
|
b2.prev = b1
|
|
b1.next = b2
|
|
b3.prev = b2
|
|
b2.next = b3
|
|
|
|
if got := b3.count(); got != 10 {
|
|
t.Errorf("count() = %d, want 10 (3+2+5)", got)
|
|
}
|
|
|
|
// Single buffer.
|
|
lone := &buffer{data: make([]schema.Float, 7, BufferCap)}
|
|
if got := lone.count(); got != 7 {
|
|
t.Errorf("count() single buffer = %d, want 7", got)
|
|
}
|
|
}
|
|
|
|
// ─── Existing tests below ────────────────────────────────────────────────────
|
|
|
|
func TestAssignAggregationStrategy(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
input string
|
|
expected AggregationStrategy
|
|
wantErr bool
|
|
}{
|
|
{"empty string", "", NoAggregation, false},
|
|
{"sum", "sum", SumAggregation, false},
|
|
{"avg", "avg", AvgAggregation, false},
|
|
{"invalid", "invalid", NoAggregation, true},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
result, err := AssignAggregationStrategy(tt.input)
|
|
if (err != nil) != tt.wantErr {
|
|
t.Errorf("AssignAggregationStrategy(%q) error = %v, wantErr %v", tt.input, err, tt.wantErr)
|
|
return
|
|
}
|
|
if result != tt.expected {
|
|
t.Errorf("AssignAggregationStrategy(%q) = %v, want %v", tt.input, result, tt.expected)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestBufferWrite(t *testing.T) {
|
|
b := newBuffer(100, 10)
|
|
|
|
// Test writing value
|
|
nb, err := b.write(100, schema.Float(42.0))
|
|
if err != nil {
|
|
t.Errorf("buffer.write() error = %v", err)
|
|
}
|
|
if nb != b {
|
|
t.Error("buffer.write() created new buffer unexpectedly")
|
|
}
|
|
if len(b.data) != 1 {
|
|
t.Errorf("buffer.write() len(data) = %d, want 1", len(b.data))
|
|
}
|
|
if b.data[0] != schema.Float(42.0) {
|
|
t.Errorf("buffer.write() data[0] = %v, want 42.0", b.data[0])
|
|
}
|
|
|
|
// Test writing value from past (should error)
|
|
_, err = b.write(50, schema.Float(10.0))
|
|
if err == nil {
|
|
t.Error("buffer.write() expected error for past timestamp")
|
|
}
|
|
}
|
|
|
|
func TestBufferRead(t *testing.T) {
|
|
b := newBuffer(100, 10)
|
|
|
|
// Write some test data
|
|
b.write(100, schema.Float(1.0))
|
|
b.write(110, schema.Float(2.0))
|
|
b.write(120, schema.Float(3.0))
|
|
|
|
// Read data
|
|
data := make([]schema.Float, 3)
|
|
result, from, to, err := b.read(100, 130, data)
|
|
if err != nil {
|
|
t.Errorf("buffer.read() error = %v", err)
|
|
}
|
|
// Buffer read should return from as firstWrite (start + freq/2)
|
|
if from != 100 {
|
|
t.Errorf("buffer.read() from = %d, want 100", from)
|
|
}
|
|
if to != 130 {
|
|
t.Errorf("buffer.read() to = %d, want 130", to)
|
|
}
|
|
if len(result) != 3 {
|
|
t.Errorf("buffer.read() len(result) = %d, want 3", len(result))
|
|
}
|
|
}
|
|
|
|
func TestHealthCheck(t *testing.T) {
|
|
// Create a test MemoryStore with some metrics
|
|
metrics := map[string]MetricConfig{
|
|
"load": {Frequency: 10, Aggregation: AvgAggregation, offset: 0},
|
|
"mem_used": {Frequency: 10, Aggregation: AvgAggregation, offset: 1},
|
|
"cpu_user": {Frequency: 10, Aggregation: AvgAggregation, offset: 2},
|
|
"cpu_system": {Frequency: 10, Aggregation: AvgAggregation, offset: 3},
|
|
}
|
|
|
|
ms := &MemoryStore{
|
|
Metrics: metrics,
|
|
root: Level{
|
|
metrics: make([]*buffer, len(metrics)),
|
|
children: make(map[string]*Level),
|
|
},
|
|
}
|
|
|
|
// Use recent timestamps (current time minus a small offset)
|
|
now := time.Now().Unix()
|
|
startTime := now - 100 // Start 100 seconds ago to have enough data points
|
|
|
|
// Setup test data for node001 - all metrics healthy (recent data)
|
|
node001 := ms.root.findLevelOrCreate([]string{"testcluster", "node001"}, len(metrics))
|
|
for i := 0; i < len(metrics); i++ {
|
|
node001.metrics[i] = newBuffer(startTime, 10)
|
|
// Write recent data up to now
|
|
for ts := startTime; ts <= now; ts += 10 {
|
|
node001.metrics[i].write(ts, schema.Float(float64(i+1)))
|
|
}
|
|
}
|
|
|
|
// Setup test data for node002 - some metrics stale (old data beyond MaxMissingDataPoints threshold)
|
|
node002 := ms.root.findLevelOrCreate([]string{"testcluster", "node002"}, len(metrics))
|
|
// MaxMissingDataPoints = 5, frequency = 10, so threshold is 50 seconds
|
|
staleTime := now - 100 // Data ends 100 seconds ago (well beyond 50 second threshold)
|
|
for i := 0; i < len(metrics); i++ {
|
|
node002.metrics[i] = newBuffer(staleTime-50, 10)
|
|
if i < 2 {
|
|
// First two metrics: healthy (recent data)
|
|
for ts := startTime; ts <= now; ts += 10 {
|
|
node002.metrics[i].write(ts, schema.Float(float64(i+1)))
|
|
}
|
|
} else {
|
|
// Last two metrics: stale (data ends 100 seconds ago)
|
|
for ts := staleTime - 50; ts <= staleTime; ts += 10 {
|
|
node002.metrics[i].write(ts, schema.Float(float64(i+1)))
|
|
}
|
|
}
|
|
}
|
|
|
|
// Setup test data for node003 - some metrics missing (no buffer)
|
|
node003 := ms.root.findLevelOrCreate([]string{"testcluster", "node003"}, len(metrics))
|
|
// Only create buffers for first two metrics
|
|
for i := range 2 {
|
|
node003.metrics[i] = newBuffer(startTime, 10)
|
|
for ts := startTime; ts <= now; ts += 10 {
|
|
node003.metrics[i].write(ts, schema.Float(float64(i+1)))
|
|
}
|
|
}
|
|
// Leave metrics[2] and metrics[3] as nil (missing)
|
|
|
|
// Setup test data for node005 - all metrics stale
|
|
node005 := ms.root.findLevelOrCreate([]string{"testcluster", "node005"}, len(metrics))
|
|
for i := 0; i < len(metrics); i++ {
|
|
node005.metrics[i] = newBuffer(staleTime-50, 10)
|
|
// All metrics have stale data (ends 100 seconds ago)
|
|
for ts := staleTime - 50; ts <= staleTime; ts += 10 {
|
|
node005.metrics[i].write(ts, schema.Float(float64(i+1)))
|
|
}
|
|
}
|
|
|
|
// node004 doesn't exist at all
|
|
|
|
tests := []struct {
|
|
name string
|
|
cluster string
|
|
nodes []string
|
|
expectedMetrics []string
|
|
wantStates map[string]schema.MonitoringState
|
|
}{
|
|
{
|
|
name: "all metrics healthy",
|
|
cluster: "testcluster",
|
|
nodes: []string{"node001"},
|
|
expectedMetrics: []string{"load", "mem_used", "cpu_user", "cpu_system"},
|
|
wantStates: map[string]schema.MonitoringState{
|
|
"node001": schema.MonitoringStateFull,
|
|
},
|
|
},
|
|
{
|
|
name: "some metrics stale",
|
|
cluster: "testcluster",
|
|
nodes: []string{"node002"},
|
|
expectedMetrics: []string{"load", "mem_used", "cpu_user", "cpu_system"},
|
|
wantStates: map[string]schema.MonitoringState{
|
|
"node002": schema.MonitoringStatePartial,
|
|
},
|
|
},
|
|
{
|
|
name: "some metrics missing",
|
|
cluster: "testcluster",
|
|
nodes: []string{"node003"},
|
|
expectedMetrics: []string{"load", "mem_used", "cpu_user", "cpu_system"},
|
|
wantStates: map[string]schema.MonitoringState{
|
|
"node003": schema.MonitoringStatePartial,
|
|
},
|
|
},
|
|
{
|
|
name: "node not found",
|
|
cluster: "testcluster",
|
|
nodes: []string{"node004"},
|
|
expectedMetrics: []string{"load", "mem_used", "cpu_user", "cpu_system"},
|
|
wantStates: map[string]schema.MonitoringState{
|
|
"node004": schema.MonitoringStateFailed,
|
|
},
|
|
},
|
|
{
|
|
name: "all metrics stale",
|
|
cluster: "testcluster",
|
|
nodes: []string{"node005"},
|
|
expectedMetrics: []string{"load", "mem_used", "cpu_user", "cpu_system"},
|
|
wantStates: map[string]schema.MonitoringState{
|
|
"node005": schema.MonitoringStateFailed,
|
|
},
|
|
},
|
|
{
|
|
name: "multiple nodes mixed states",
|
|
cluster: "testcluster",
|
|
nodes: []string{"node001", "node002", "node003", "node004", "node005"},
|
|
expectedMetrics: []string{"load", "mem_used"},
|
|
wantStates: map[string]schema.MonitoringState{
|
|
"node001": schema.MonitoringStateFull,
|
|
"node002": schema.MonitoringStateFull, // Only checking first 2 metrics which are healthy
|
|
"node003": schema.MonitoringStateFull, // Only checking first 2 metrics which exist
|
|
"node004": schema.MonitoringStateFailed, // Node doesn't exist
|
|
"node005": schema.MonitoringStateFailed, // Both metrics are stale
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
results, err := ms.HealthCheck(tt.cluster, tt.nodes, tt.expectedMetrics)
|
|
if err != nil {
|
|
t.Errorf("HealthCheck() error = %v", err)
|
|
return
|
|
}
|
|
|
|
// Check that we got results for all nodes
|
|
if len(results) != len(tt.nodes) {
|
|
t.Errorf("HealthCheck() returned %d results, want %d", len(results), len(tt.nodes))
|
|
}
|
|
|
|
// Check each node's state
|
|
for _, node := range tt.nodes {
|
|
state, ok := results[node]
|
|
if !ok {
|
|
t.Errorf("HealthCheck() missing result for node %s", node)
|
|
continue
|
|
}
|
|
|
|
// Check status
|
|
if wantStatus, ok := tt.wantStates[node]; ok {
|
|
if state.State != wantStatus {
|
|
t.Errorf("HealthCheck() node %s status = %v, want %v", node, state.State, wantStatus)
|
|
}
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestGetHealthyMetrics tests the GetHealthyMetrics function which returns lists of missing and degraded metrics
|
|
func TestGetHealthyMetrics(t *testing.T) {
|
|
metrics := map[string]MetricConfig{
|
|
"load": {Frequency: 10, Aggregation: AvgAggregation, offset: 0},
|
|
"mem_used": {Frequency: 10, Aggregation: AvgAggregation, offset: 1},
|
|
"cpu_user": {Frequency: 10, Aggregation: AvgAggregation, offset: 2},
|
|
}
|
|
|
|
ms := &MemoryStore{
|
|
Metrics: metrics,
|
|
root: Level{
|
|
metrics: make([]*buffer, len(metrics)),
|
|
children: make(map[string]*Level),
|
|
},
|
|
}
|
|
|
|
now := time.Now().Unix()
|
|
startTime := now - 100
|
|
staleTime := now - 100
|
|
|
|
// Setup node with mixed health states
|
|
node := ms.root.findLevelOrCreate([]string{"testcluster", "testnode"}, len(metrics))
|
|
|
|
// Metric 0 (load): healthy - recent data
|
|
node.metrics[0] = newBuffer(startTime, 10)
|
|
for ts := startTime; ts <= now; ts += 10 {
|
|
node.metrics[0].write(ts, schema.Float(1.0))
|
|
}
|
|
|
|
// Metric 1 (mem_used): degraded - stale data
|
|
node.metrics[1] = newBuffer(staleTime-50, 10)
|
|
for ts := staleTime - 50; ts <= staleTime; ts += 10 {
|
|
node.metrics[1].write(ts, schema.Float(2.0))
|
|
}
|
|
|
|
// Metric 2 (cpu_user): missing - no buffer (nil)
|
|
|
|
tests := []struct {
|
|
name string
|
|
selector []string
|
|
expectedMetrics []string
|
|
wantDegraded []string
|
|
wantMissing []string
|
|
wantErr bool
|
|
}{
|
|
{
|
|
name: "mixed health states",
|
|
selector: []string{"testcluster", "testnode"},
|
|
expectedMetrics: []string{"load", "mem_used", "cpu_user"},
|
|
wantDegraded: []string{"mem_used"},
|
|
wantMissing: []string{"cpu_user"},
|
|
wantErr: false,
|
|
},
|
|
{
|
|
name: "node not found",
|
|
selector: []string{"testcluster", "nonexistent"},
|
|
expectedMetrics: []string{"load"},
|
|
wantDegraded: nil,
|
|
wantMissing: nil,
|
|
wantErr: true,
|
|
},
|
|
{
|
|
name: "check only healthy metric",
|
|
selector: []string{"testcluster", "testnode"},
|
|
expectedMetrics: []string{"load"},
|
|
wantDegraded: []string{},
|
|
wantMissing: []string{},
|
|
wantErr: false,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
degraded, missing, err := ms.GetHealthyMetrics(tt.selector, tt.expectedMetrics)
|
|
|
|
if (err != nil) != tt.wantErr {
|
|
t.Errorf("GetHealthyMetrics() error = %v, wantErr %v", err, tt.wantErr)
|
|
return
|
|
}
|
|
|
|
if tt.wantErr {
|
|
return
|
|
}
|
|
|
|
// Check degraded list
|
|
if len(degraded) != len(tt.wantDegraded) {
|
|
t.Errorf("GetHealthyMetrics() degraded = %v, want %v", degraded, tt.wantDegraded)
|
|
} else {
|
|
for i, d := range tt.wantDegraded {
|
|
if degraded[i] != d {
|
|
t.Errorf("GetHealthyMetrics() degraded[%d] = %v, want %v", i, degraded[i], d)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check missing list
|
|
if len(missing) != len(tt.wantMissing) {
|
|
t.Errorf("GetHealthyMetrics() missing = %v, want %v", missing, tt.wantMissing)
|
|
} else {
|
|
for i, m := range tt.wantMissing {
|
|
if missing[i] != m {
|
|
t.Errorf("GetHealthyMetrics() missing[%d] = %v, want %v", i, missing[i], m)
|
|
}
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestBufferHealthChecks tests the buffer-level health check functions
|
|
func TestBufferHealthChecks(t *testing.T) {
|
|
now := time.Now().Unix()
|
|
|
|
tests := []struct {
|
|
name string
|
|
setupBuffer func() *buffer
|
|
wantExists bool
|
|
wantHealthy bool
|
|
description string
|
|
}{
|
|
{
|
|
name: "nil buffer",
|
|
setupBuffer: func() *buffer {
|
|
return nil
|
|
},
|
|
wantExists: false,
|
|
wantHealthy: false,
|
|
description: "nil buffer should not exist and not be healthy",
|
|
},
|
|
{
|
|
name: "empty buffer",
|
|
setupBuffer: func() *buffer {
|
|
b := newBuffer(now, 10)
|
|
b.data = nil
|
|
return b
|
|
},
|
|
wantExists: false,
|
|
wantHealthy: false,
|
|
description: "empty buffer should not exist and not be healthy",
|
|
},
|
|
{
|
|
name: "healthy buffer with recent data",
|
|
setupBuffer: func() *buffer {
|
|
b := newBuffer(now-30, 10)
|
|
// Write data up to now (within MaxMissingDataPoints * frequency = 50 seconds)
|
|
for ts := now - 30; ts <= now; ts += 10 {
|
|
b.write(ts, schema.Float(1.0))
|
|
}
|
|
return b
|
|
},
|
|
wantExists: true,
|
|
wantHealthy: true,
|
|
description: "buffer with recent data should be healthy",
|
|
},
|
|
{
|
|
name: "stale buffer beyond threshold",
|
|
setupBuffer: func() *buffer {
|
|
b := newBuffer(now-200, 10)
|
|
// Write data that ends 100 seconds ago (beyond MaxMissingDataPoints * frequency = 50 seconds)
|
|
for ts := now - 200; ts <= now-100; ts += 10 {
|
|
b.write(ts, schema.Float(1.0))
|
|
}
|
|
return b
|
|
},
|
|
wantExists: true,
|
|
wantHealthy: false,
|
|
description: "buffer with stale data should exist but not be healthy",
|
|
},
|
|
{
|
|
name: "buffer at threshold boundary",
|
|
setupBuffer: func() *buffer {
|
|
b := newBuffer(now-50, 10)
|
|
// Write data that ends exactly at threshold (MaxMissingDataPoints * frequency = 50 seconds)
|
|
for ts := now - 50; ts <= now-50; ts += 10 {
|
|
b.write(ts, schema.Float(1.0))
|
|
}
|
|
return b
|
|
},
|
|
wantExists: true,
|
|
wantHealthy: true,
|
|
description: "buffer at threshold boundary should still be healthy",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
b := tt.setupBuffer()
|
|
|
|
exists := b.bufferExists()
|
|
if exists != tt.wantExists {
|
|
t.Errorf("bufferExists() = %v, want %v: %s", exists, tt.wantExists, tt.description)
|
|
}
|
|
|
|
if b != nil && b.data != nil && len(b.data) > 0 {
|
|
healthy := b.isBufferHealthy()
|
|
if healthy != tt.wantHealthy {
|
|
t.Errorf("isBufferHealthy() = %v, want %v: %s", healthy, tt.wantHealthy, tt.description)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestBufferPoolClean(t *testing.T) {
|
|
// Use a fresh pool for testing
|
|
pool := NewPersistentBufferPool()
|
|
|
|
now := time.Now().Unix()
|
|
|
|
// Create some buffers and put them in the pool with different lastUsed times
|
|
b1 := &buffer{lastUsed: now - 3600, data: make([]schema.Float, 0)} // 1 hour ago
|
|
b2 := &buffer{lastUsed: now - 7200, data: make([]schema.Float, 0)} // 2 hours ago
|
|
b3 := &buffer{lastUsed: now - 180000, data: make([]schema.Float, 0)} // 50 hours ago
|
|
b4 := &buffer{lastUsed: now - 200000, data: make([]schema.Float, 0)} // 55 hours ago
|
|
b5 := &buffer{lastUsed: now, data: make([]schema.Float, 0)}
|
|
|
|
pool.Put(b1)
|
|
pool.Put(b2)
|
|
pool.Put(b3)
|
|
pool.Put(b4)
|
|
pool.Put(b5)
|
|
|
|
if pool.GetSize() != 5 {
|
|
t.Fatalf("Expected pool size 5, got %d", pool.GetSize())
|
|
}
|
|
|
|
// Clean buffers older than 48 hours
|
|
timeUpdate := time.Now().Add(-48 * time.Hour).Unix()
|
|
pool.Clean(timeUpdate)
|
|
|
|
// Expected: b1, b2, b5 should remain. b3, b4 should be cleaned.
|
|
if pool.GetSize() != 3 {
|
|
t.Fatalf("Expected pool size 3 after clean, got %d", pool.GetSize())
|
|
}
|
|
|
|
validBufs := map[int64]bool{
|
|
b1.lastUsed: true,
|
|
b2.lastUsed: true,
|
|
b5.lastUsed: true,
|
|
}
|
|
|
|
for i := 0; i < 3; i++ {
|
|
b := pool.Get()
|
|
if !validBufs[b.lastUsed] {
|
|
t.Errorf("Found unexpected buffer with lastUsed %d", b.lastUsed)
|
|
}
|
|
}
|
|
|
|
if pool.GetSize() != 0 {
|
|
t.Fatalf("Expected pool to be empty, got %d", pool.GetSize())
|
|
}
|
|
}
|