Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.
Go aialertsdashboarddockerdocker-monitoringgohomelabinfrastructure-monitoringkubernetesmonitoringmspproxmoxproxmox-backup-serverproxmox-mail-gatewayproxmox-veself-hostedtruenastypescriptvspherewebhooks
package patterns
import (
"encoding/json"
"math"
"os"
"path/filepath"
"testing"
"time"
)
func TestNewDetector_LoadFromDiskSuccess(t *testing.T) {
tmpDir := t.TempDir()
now := time.Now()
data := struct {
Events []HistoricalEvent `json:"events"`
Patterns map[string]*Pattern `json:"patterns"`
}{
Events: []HistoricalEvent{
{
ID: "event-1",
ResourceID: "vm-1",
EventType: EventHighCPU,
Timestamp: now,
},
},
Patterns: map[string]*Pattern{
"vm-1:high_cpu": {
ResourceID: "vm-1",
EventType: EventHighCPU,
Occurrences: 3,
LastOccurrence: now,
NextPredicted: now.Add(24 * time.Hour),
Confidence: 0.5,
},
},
}
blob, err := json.Marshal(data)
if err != nil {
t.Fatalf("marshal data: %v", err)
}
path := filepath.Join(tmpDir, "ai_patterns.json")
if err := os.WriteFile(path, blob, 0600); err != nil {
t.Fatalf("write data: %v", err)
}
d := NewDetector(DetectorConfig{DataDir: tmpDir})
if len(d.events) == 0 {
t.Fatal("expected events to be loaded")
}
if len(d.patterns) == 0 {
t.Fatal("expected patterns to be loaded")
}
}
func TestNewDetector_LoadFromDiskError(t *testing.T) {
tmpDir := t.TempDir()
path := filepath.Join(tmpDir, "ai_patterns.json")
if err := os.WriteFile(path, []byte("{bad"), 0600); err != nil {
t.Fatalf("write invalid json: %v", err)
}
d := NewDetector(DetectorConfig{DataDir: tmpDir})
if len(d.events) != 0 {
t.Error("expected no events on load error")
}
}
func TestRecordEvent_SaveError(t *testing.T) {
tmpFile, err := os.CreateTemp("", "patterns-dir")
if err != nil {
t.Fatalf("create temp file: %v", err)
}
path := tmpFile.Name()
if err := tmpFile.Close(); err != nil {
t.Fatalf("close temp file: %v", err)
}
defer os.Remove(path)
d := NewDetector(DetectorConfig{DataDir: path, MinOccurrences: 1})
d.RecordEvent(HistoricalEvent{
ResourceID: "vm-1",
EventType: EventHighCPU,
Timestamp: time.Now(),
})
time.Sleep(20 * time.Millisecond)
}
func TestGetPredictions_FiltersAndSorts(t *testing.T) {
d := NewDetector(DetectorConfig{MinOccurrences: 2, PredictionLimit: 48 * time.Hour})
now := time.Now()
d.patterns["nil"] = nil
d.patterns["low-confidence"] = &Pattern{
ResourceID: "vm-1",
EventType: EventHighCPU,
Occurrences: 2,
Confidence: 0.2,
NextPredicted: now.Add(2 * time.Hour),
}
d.patterns["low-occurrences"] = &Pattern{
ResourceID: "vm-2",
EventType: EventHighMemory,
Occurrences: 1,
Confidence: 0.9,
NextPredicted: now.Add(2 * time.Hour),
}
d.patterns["past"] = &Pattern{
ResourceID: "vm-3",
EventType: EventDiskFull,
Occurrences: 2,
Confidence: 0.9,
NextPredicted: now.Add(-2 * time.Hour),
}
d.patterns["future"] = &Pattern{
ResourceID: "vm-4",
EventType: EventOOM,
Occurrences: 2,
Confidence: 0.9,
NextPredicted: now.Add(72 * time.Hour),
}
d.patterns["soon"] = &Pattern{
ResourceID: "vm-5",
EventType: EventRestart,
Occurrences: 2,
Confidence: 0.9,
NextPredicted: now.Add(4 * time.Hour),
}
d.patterns["later"] = &Pattern{
ResourceID: "vm-6",
EventType: EventUnresponsive,
Occurrences: 2,
Confidence: 0.9,
NextPredicted: now.Add(12 * time.Hour),
}
predictions := d.GetPredictions()
if len(predictions) != 2 {
t.Fatalf("expected 2 predictions, got %d", len(predictions))
}
if predictions[0].DaysUntil > predictions[1].DaysUntil {
t.Fatalf("expected predictions sorted by days until")
}
}
func TestGetPatterns_SkipsNil(t *testing.T) {
d := NewDetector(DefaultConfig())
d.patterns["nil"] = nil
d.patterns["ok"] = &Pattern{ResourceID: "vm-1", EventType: EventHighCPU}
result := d.GetPatterns()
if len(result) != 1 {
t.Fatalf("expected 1 pattern, got %d", len(result))
}
if result["ok"] == nil {
t.Fatal("expected non-nil pattern")
}
}
func TestComputePattern_AverageDuration(t *testing.T) {
d := NewDetector(DetectorConfig{MinOccurrences: 2, PatternWindow: 24 * time.Hour})
now := time.Now()
d.events = []HistoricalEvent{
{
ResourceID: "vm-1",
EventType: EventHighCPU,
Timestamp: now.Add(-4 * time.Hour),
Duration: 10 * time.Minute,
},
{
ResourceID: "vm-1",
EventType: EventHighCPU,
Timestamp: now.Add(-2 * time.Hour),
Duration: 20 * time.Minute,
},
{
ResourceID: "vm-1",
EventType: EventHighCPU,
Timestamp: now,
},
}
pattern := d.computePattern("vm-1", EventHighCPU)
if pattern == nil {
t.Fatal("expected pattern")
}
if pattern.AverageDuration == 0 {
t.Fatal("expected average duration to be set")
}
}
func TestSaveToDisk_Errors(t *testing.T) {
tmpDir := t.TempDir()
d := NewDetector(DetectorConfig{DataDir: tmpDir})
d.patterns["bad"] = &Pattern{Confidence: math.NaN()}
if err := d.saveToDisk(); err == nil {
t.Fatal("expected json marshal error")
}
tmpFile, err := os.CreateTemp("", "patterns-dir")
if err != nil {
t.Fatalf("create temp file: %v", err)
}
path := tmpFile.Name()
if err := tmpFile.Close(); err != nil {
t.Fatalf("close temp file: %v", err)
}
defer os.Remove(path)
d = NewDetector(DetectorConfig{DataDir: path})
if err := d.saveToDisk(); err == nil {
t.Fatal("expected write error")
}
tmpDir = t.TempDir()
path = filepath.Join(tmpDir, "ai_patterns.json")
if err := os.Mkdir(path, 0700); err != nil {
t.Fatalf("create dir: %v", err)
}
d = NewDetector(DetectorConfig{DataDir: tmpDir})
if err := d.saveToDisk(); err == nil {
t.Fatal("expected rename error")
}
}
func TestLoadFromDisk_ErrorsAndPrune(t *testing.T) {
d := &Detector{}
if err := d.loadFromDisk(); err != nil {
t.Fatalf("expected empty dataDir to return nil, got %v", err)
}
tmpDir := t.TempDir()
path := filepath.Join(tmpDir, "ai_patterns.json")
blob := make([]byte, (10<<20)+1)
if err := os.WriteFile(path, blob, 0600); err != nil {
t.Fatalf("write large file: %v", err)
}
d = &Detector{dataDir: tmpDir}
if err := d.loadFromDisk(); err == nil {
t.Fatal("expected size error")
}
tmpDir = t.TempDir()
path = filepath.Join(tmpDir, "ai_patterns.json")
if err := os.Mkdir(path, 0700); err != nil {
t.Fatalf("create dir: %v", err)
}
d = &Detector{dataDir: tmpDir}
if err := d.loadFromDisk(); err == nil {
t.Fatal("expected read error")
}
tmpDir = t.TempDir()
path = filepath.Join(tmpDir, "ai_patterns.json")
if err := os.WriteFile(path, []byte("{bad"), 0600); err != nil {
t.Fatalf("write invalid json: %v", err)
}
d = &Detector{dataDir: tmpDir}
if err := d.loadFromDisk(); err == nil {
t.Fatal("expected json error")
}
tmpDir = t.TempDir()
now := time.Now()
data := struct {
Events []HistoricalEvent `json:"events"`
Patterns map[string]*Pattern `json:"patterns"`
}{
Events: []HistoricalEvent{
{
ID: "old",
ResourceID: "vm-1",
EventType: EventHighCPU,
Timestamp: now.Add(-2 * time.Hour),
},
{
ID: "new",
ResourceID: "vm-1",
EventType: EventHighCPU,
Timestamp: now,
},
},
Patterns: map[string]*Pattern{
"old": {
ResourceID: "vm-1",
EventType: EventHighCPU,
Occurrences: 1,
LastOccurrence: now.Add(-2 * time.Hour),
Confidence: 0.5,
},
"nil": nil,
"new": {
ResourceID: "vm-1",
EventType: EventHighCPU,
Occurrences: 3,
LastOccurrence: now,
Confidence: 0.5,
},
},
}
blob, err := json.Marshal(data)
if err != nil {
t.Fatalf("marshal data: %v", err)
}
path = filepath.Join(tmpDir, "ai_patterns.json")
if err := os.WriteFile(path, blob, 0600); err != nil {
t.Fatalf("write data: %v", err)
}
d = &Detector{
dataDir: tmpDir,
maxEvents: 10,
minOccurrences: 2,
patternWindow: time.Hour,
}
if err := d.loadFromDisk(); err != nil {
t.Fatalf("loadFromDisk failed: %v", err)
}
if _, ok := d.patterns["old"]; ok {
t.Fatal("expected old pattern to be pruned")
}
if _, ok := d.patterns["nil"]; ok {
t.Fatal("expected nil pattern to be pruned")
}
if _, ok := d.patterns["new"]; !ok {
t.Fatal("expected new pattern to remain")
}
if len(d.events) != 1 {
t.Fatalf("expected trimmed events, got %d", len(d.events))
}
}
func TestFormatForContext_Limits(t *testing.T) {
d := NewDetector(DetectorConfig{MinOccurrences: 1, PredictionLimit: 365 * 24 * time.Hour})
now := time.Now()
for i := 0; i < 50; i++ {
key := "res-" + intToStr(i)
d.patterns[key] = &Pattern{
ResourceID: key,
EventType: EventHighCPU,
Occurrences: 3,
Confidence: 0.9,
LastOccurrence: now.Add(-24 * time.Hour),
NextPredicted: now.Add(2 * time.Hour),
}
}
result := d.FormatForContext("")
if result == "" {
t.Fatal("expected non-empty context")
}
if !contains(result, "... and more") {
t.Fatalf("expected truncation marker, got %q", result)
}
}
func TestFormatPatternBasis_EventNames(t *testing.T) {
now := time.Now()
tests := []struct {
eventType EventType
expected string
overdue bool
}{
{EventDiskFull, "disk space critical", true},
{EventUnresponsive, "unresponsive periods", false},
{EventBackupFailed, "backup failures", false},
}
for _, tt := range tests {
next := now.Add(2 * time.Hour)
if tt.overdue {
next = now.Add(-2 * time.Hour)
}
result := formatPatternBasis(&Pattern{
EventType: tt.eventType,
AverageInterval: 24 * time.Hour,
LastOccurrence: now.Add(-48 * time.Hour),
NextPredicted: next,
})
if !contains(result, tt.expected) {
t.Fatalf("expected %q in result, got %q", tt.expected, result)
}
if tt.overdue && !contains(result, "overdue") {
t.Fatalf("expected overdue wording, got %q", result)
}
}
}