Skip to content

armgit / Pulse

Public Imported from GitHub
0

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.

8.6 KB
Raw Blame
package eventlog

import (
	"database/sql"
	"encoding/json"
	"fmt"
	"math"
	"testing"
	"time"

	pdb "github.com/rcourtman/pulse-go-rewrite/pkg/db"
)

func newTestStore(t *testing.T) *Store {
	t.Helper()
	store, err := OpenInMemory()
	if err != nil {
		t.Fatalf("open in-memory store: %v", err)
	}
	t.Cleanup(store.Close)
	return store
}

func TestAppendAndQueryRoundTrip(t *testing.T) {
	store := newTestStore(t)
	occurred := time.Date(2026, 8, 26, 10, 0, 0, 0, time.UTC)

	store.Append(Event{
		OccurredAt:   occurred,
		Type:         TypeNotificationSuppressed,
		AlertID:      "alert-1",
		ResourceID:   "node/pve-1",
		ResourceName: "pve-1",
		AlertType:    "cpu",
		Level:        "warning",
		Reason:       "flapping",
		Message:      "Alert suppressed due to flapping",
		Details:      map[string]string{"trackingKey": "node/pve-1/cpu"},
	})
	store.Flush()

	events, err := store.Query(Filter{AlertID: "alert-1"})
	if err != nil {
		t.Fatalf("query: %v", err)
	}
	if len(events) != 1 {
		t.Fatalf("len(events) = %d, want 1", len(events))
	}
	event := events[0]
	if event.Type != TypeNotificationSuppressed || event.Reason != "flapping" {
		t.Fatalf("event = %+v, want suppressed/flapping", event)
	}
	if !event.OccurredAt.Equal(occurred) {
		t.Fatalf("OccurredAt = %v, want %v", event.OccurredAt, occurred)
	}
	if event.Details["trackingKey"] != "node/pve-1/cpu" {
		t.Fatalf("Details = %v, want trackingKey preserved", event.Details)
	}
}

func TestQueryFiltersByTypeAndTime(t *testing.T) {
	store := newTestStore(t)
	base := time.Date(2026, 8, 26, 10, 0, 0, 0, time.UTC)

	store.Append(Event{OccurredAt: base, Type: TypeResolved, AlertID: "a1"})
	store.Append(Event{OccurredAt: base.Add(time.Minute), Type: TypeAcknowledged, AlertID: "a1"})
	store.Append(Event{OccurredAt: base.Add(2 * time.Minute), Type: TypeResolved, AlertID: "a2"})
	store.Flush()

	byType, err := store.Query(Filter{Types: []string{TypeResolved}})
	if err != nil {
		t.Fatalf("query by type: %v", err)
	}
	if len(byType) != 2 {
		t.Fatalf("len(byType) = %d, want 2", len(byType))
	}
	// Newest first.
	if byType[0].AlertID != "a2" || byType[1].AlertID != "a1" {
		t.Fatalf("order = %s,%s, want a2,a1", byType[0].AlertID, byType[1].AlertID)
	}

	windowed, err := store.Query(Filter{Since: base.Add(30 * time.Second), Until: base.Add(90 * time.Second)})
	if err != nil {
		t.Fatalf("query by window: %v", err)
	}
	if len(windowed) != 1 || windowed[0].Type != TypeAcknowledged {
		t.Fatalf("windowed = %+v, want the acknowledged event only", windowed)
	}
}

func TestQueryLimitCaps(t *testing.T) {
	store := newTestStore(t)
	base := time.Date(2026, 8, 26, 10, 0, 0, 0, time.UTC)
	for i := 0; i < 10; i++ {
		store.Append(Event{OccurredAt: base.Add(time.Duration(i) * time.Second), Type: TypeResolved, AlertID: "a1"})
	}
	store.Flush()

	events, err := store.Query(Filter{Limit: 3})
	if err != nil {
		t.Fatalf("query: %v", err)
	}
	if len(events) != 3 {
		t.Fatalf("len(events) = %d, want 3", len(events))
	}
}

func TestQueryOversizedLimitDoesNotControlAllocation(t *testing.T) {
	store := newTestStore(t)
	store.Append(Event{OccurredAt: time.Now(), Type: TypeResolved, AlertID: "a1"})
	store.Flush()

	events, err := store.Query(Filter{Limit: math.MaxInt})
	if err != nil {
		t.Fatalf("query with oversized limit: %v", err)
	}
	if len(events) != 1 || events[0].AlertID != "a1" {
		t.Fatalf("events = %+v, want the one stored event", events)
	}
}

func TestWalkOldestTraversesBeyondQueryLimitInBoundedPages(t *testing.T) {
	store := newTestStore(t)
	base := time.Now().Add(-time.Hour).UTC()
	batch := make([]Event, 0, maxQueryLimit+205)
	for i := 0; i < maxQueryLimit+205; i++ {
		batch = append(batch, Event{
			// Keep every row on the same timestamp to prove the ID tie-breaker
			// crosses a page boundary without skipping or repeating rows.
			OccurredAt: base,
			Type:       TypeResolved,
			AlertID:    fmt.Sprintf("walk-%04d", i),
		})
	}
	if err := store.ImportEvents(batch); err != nil {
		t.Fatalf("import walk fixtures: %v", err)
	}

	visited := make([]string, 0, len(batch))
	if err := store.WalkOldest(Filter{Types: []string{TypeResolved}}, func(event Event) error {
		visited = append(visited, event.AlertID)
		return nil
	}); err != nil {
		t.Fatalf("walk: %v", err)
	}
	if len(visited) != len(batch) {
		t.Fatalf("visited %d events, want %d", len(visited), len(batch))
	}
	if visited[0] != "walk-0000" || visited[len(visited)-1] != "walk-1204" {
		t.Fatalf("walk order = %q ... %q, want oldest through newest", visited[0], visited[len(visited)-1])
	}
}

func TestImportEventsDeduplicatesLegacyHistoryRetriesOnly(t *testing.T) {
	store := newTestStore(t)
	occurred := time.Now().UTC()
	legacy := Event{
		OccurredAt: occurred,
		Type:       TypeHistoryImported,
		AlertID:    "legacy-alert",
		Snapshot:   json.RawMessage(`{"id":"legacy-alert","startTime":"2026-08-27T08:00:00Z"}`),
	}
	if err := store.ImportEvents([]Event{legacy}); err != nil {
		t.Fatalf("first import: %v", err)
	}
	if err := store.ImportEvents([]Event{legacy}); err != nil {
		t.Fatalf("retry import: %v", err)
	}

	imported, err := store.Query(Filter{Types: []string{TypeHistoryImported}, Limit: 10})
	if err != nil {
		t.Fatalf("query imported events: %v", err)
	}
	if len(imported) != 1 {
		t.Fatalf("legacy import retry produced %d events, want 1", len(imported))
	}

	clear := Event{OccurredAt: occurred, Type: TypeHistoryCleared, AlertID: "history"}
	if err := store.ImportEvents([]Event{clear, clear}); err != nil {
		t.Fatalf("import ordinary events: %v", err)
	}
	cleared, err := store.Query(Filter{Types: []string{TypeHistoryCleared}, Limit: 10})
	if err != nil {
		t.Fatalf("query clear events: %v", err)
	}
	if len(cleared) != 2 {
		t.Fatalf("ordinary synchronous imports were deduplicated: got %d, want 2", len(cleared))
	}
}

func TestNilStoreIsSafe(t *testing.T) {
	var store *Store
	store.Append(Event{Type: TypeResolved, AlertID: "a1"})
	store.Flush()
	store.Close()
	if got := store.Dropped(); got != 0 {
		t.Fatalf("Dropped() = %d, want 0", got)
	}
	events, err := store.Query(Filter{})
	if err != nil || events != nil {
		t.Fatalf("Query = %v, %v, want nil, nil", events, err)
	}
}

func TestCloseDrainsBufferedEvents(t *testing.T) {
	store, err := OpenInMemory()
	if err != nil {
		t.Fatalf("open in-memory store: %v", err)
	}
	for i := 0; i < 50; i++ {
		store.Append(Event{Type: TypeNotificationDispatched, AlertID: "a1"})
	}
	store.Close()

	// Query after Close is not supported; reopen semantics do not apply to
	// the in-memory store, so assert via the counters instead.
	if store.Dropped() != 0 {
		t.Fatalf("Dropped() = %d, want 0", store.Dropped())
	}
	if store.written.Load() != 50 {
		t.Fatalf("written = %d, want 50", store.written.Load())
	}
}

func TestOpenRequiresExistingDirectory(t *testing.T) {
	if _, err := Open(""); err == nil {
		t.Fatal("Open(\"\") should fail")
	}
	if _, err := Open(t.TempDir() + "/missing"); err == nil {
		t.Fatal("Open on a missing directory should fail")
	}

	dir := t.TempDir()
	store, err := Open(dir)
	if err != nil {
		t.Fatalf("Open(%q): %v", dir, err)
	}
	store.Append(Event{Type: TypeResolved, AlertID: "a1"})
	store.Flush()
	events, err := store.Query(Filter{})
	if err != nil || len(events) != 1 {
		t.Fatalf("Query = %v, %v, want one event", events, err)
	}
	store.Close()
}

func TestDurableAppendAndFlushReportDatabaseFailure(t *testing.T) {
	store := newTestStore(t)
	if err := store.db.Close(); err != nil {
		t.Fatalf("close database: %v", err)
	}

	if err := store.AppendDurable(Event{Type: TypeFired, AlertID: "durable-failure"}); err == nil {
		t.Fatal("AppendDurable reported success after the database closed")
	}

	store.Append(Event{Type: TypeNotificationSuppressed, AlertID: "async-failure"})
	if err := store.Flush(); err == nil {
		t.Fatal("Flush reported success after the async batch failed")
	}
}

// The writer and both read-only connections each hold their own page cache,
// so all of them must take the shared bound instead of a private 16 MB cache
// held outside the Go heap (#1803).
func TestEventLogConnectionsUseSharedPageCacheBound(t *testing.T) {
	store, err := Open(t.TempDir())
	if err != nil {
		t.Fatalf("Open: %v", err)
	}
	defer store.Close()
	assertSharedPageCacheBound(t, "event log writer", store.db)
	assertSharedPageCacheBound(t, "event log reader", store.readDB)
}

func assertSharedPageCacheBound(t *testing.T, name string, conn interface {
	QueryRow(query string, args ...any) *sql.Row
}) {
	t.Helper()
	var size int
	if err := conn.QueryRow(`PRAGMA cache_size`).Scan(&size); err != nil {
		t.Fatalf("%s: read cache_size: %v", name, err)
	}
	if size != -pdb.MaxPageCacheKiB {
		t.Fatalf("%s: cache_size = %d, want %d from pdb.PageCachePragma", name, size, -pdb.MaxPageCacheKiB)
	}
}