194 lines
8.8 KiB
Go
194 lines
8.8 KiB
Go
package inventory
|
|
|
|
import (
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func size(n int64) *int64 { return &n }
|
|
|
|
func at(t time.Time) *time.Time { return &t }
|
|
|
|
// What a machine declares is kept with what its holder measured; an irreplaceable item it no longer
|
|
// declares — its module unassigned — is RETIRED and kept, never forgotten, and comes back as it was when
|
|
// declared again; anything else no longer declared is forgotten (novox/hq ADR 0233).
|
|
func TestAnUndeclaredIrreplaceableItemIsRetiredNotForgotten(t *testing.T) {
|
|
inv := fresh(t)
|
|
ctx := t.Context()
|
|
now := time.Date(2026, 10, 6, 12, 0, 0, 0, time.UTC)
|
|
declared := []DeclaredData{
|
|
{Module: "home-assistant", Item: "config", Class: "irreplaceable", Owned: true},
|
|
{Module: "searxng", Item: "valkey", Class: "cache"},
|
|
{Module: "ollama", Item: "models", Class: "rebuildable"},
|
|
}
|
|
measured := map[string]map[string]Measurement{"home-assistant": {"config": {Path: "/var/lib/home-assistant/config",
|
|
Size: size(900 << 20), LastWrite: at(now.Add(-time.Minute)), MeasuredAt: at(now), LastBackup: at(now.Add(-6 * time.Hour))}}}
|
|
if _, err := inv.RecordData(ctx, "home", declared, measured, "", now); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
all, err := inv.Data(ctx)
|
|
if err != nil || len(all) != 3 {
|
|
t.Fatalf("%+v, %v", all, err)
|
|
}
|
|
|
|
// Unassigned: nothing of it is declared any more.
|
|
later := now.Add(time.Hour)
|
|
change, err := inv.RecordData(ctx, "home", nil, nil, "home-assistant unassigned", later)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(change.Retired) != 1 || change.Retired[0].Item != "config" {
|
|
t.Fatalf("retired %+v", change.Retired)
|
|
}
|
|
all, err = inv.Data(ctx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(all) != 1 || !all[0].Retired() || all[0].Path != "/var/lib/home-assistant/config" ||
|
|
*all[0].Size != 900<<20 || all[0].RetiredWhy != "home-assistant unassigned" {
|
|
t.Fatalf("the irreplaceable item is not kept retired with where it is: %+v", all)
|
|
}
|
|
|
|
// A second run that still does not declare it changes nothing: retired once, not again.
|
|
change, err = inv.RecordData(ctx, "home", nil, nil, "again", later.Add(time.Hour))
|
|
if err != nil || len(change.Retired) != 0 {
|
|
t.Fatalf("retired twice: %+v, %v", change, err)
|
|
}
|
|
|
|
// Deleting needs it retired; assigned again it is not retired any more, and its history stays.
|
|
if err := inv.MarkDataDeleted(ctx, "home", "searxng", "valkey", "p", "w", later); err == nil {
|
|
t.Fatal("deleting something the mesh does not hold retired was recorded")
|
|
}
|
|
change, err = inv.RecordData(ctx, "home", declared[:1], nil, "", later.Add(2*time.Hour))
|
|
if err != nil || len(change.Reenabled) != 1 {
|
|
t.Fatalf("declared again: %+v, %v", change, err)
|
|
}
|
|
r, err := inv.DataOf(ctx, "home", "home-assistant", "config")
|
|
if err != nil || r.Retired() || !r.FirstSeen.Equal(now) || r.Size == nil {
|
|
t.Fatalf("declared again lost what was known: %+v, %v", r, err)
|
|
}
|
|
|
|
// Retired and then deleted by a person: recorded, never by dropping the row.
|
|
if _, err := inv.RecordData(ctx, "home", nil, nil, "unassigned again", later.Add(3*time.Hour)); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := inv.MarkDataDeleted(ctx, "home", "home-assistant", "config", "jochen", "moved to the anchor", later.Add(4*time.Hour)); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
r, err = inv.DataOf(ctx, "home", "home-assistant", "config")
|
|
if err != nil || r.DeletedAt == nil || r.DeletedBy != "jochen" || r.Retired() {
|
|
t.Fatalf("a deletion is not on record: %+v, %v", r, err)
|
|
}
|
|
}
|
|
|
|
// A reading is kept at most once an hour, and the peak is read over the window asked.
|
|
func TestReadingsAreHourlyAndThePeakIsTheLargest(t *testing.T) {
|
|
inv := fresh(t)
|
|
ctx := t.Context()
|
|
now := time.Date(2026, 10, 6, 0, 0, 0, 0, time.UTC)
|
|
declared := []DeclaredData{{Module: "grafana", Item: "data", Class: "valuable", Owned: true}}
|
|
for i, s := range []int64{100, 120, 999, 130, 40} {
|
|
when := now.Add(time.Duration(i) * 20 * time.Minute)
|
|
if _, err := inv.RecordData(ctx, "ace", declared, map[string]map[string]Measurement{"grafana": {"data": {
|
|
Path: "/var/lib/grafana/data", Size: size(s), MeasuredAt: at(when)}}}, "", when); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
var n int
|
|
if err := inv.store.Pool().QueryRow(ctx, `select count(*) from data_reading`).Scan(&n); err != nil || n != 2 {
|
|
t.Fatalf("%d readings kept for five measurements over 80 minutes, want 2 (one an hour): %v", n, err)
|
|
}
|
|
peaks, err := inv.DataPeaks(ctx, now.Add(-time.Hour))
|
|
if err != nil || peaks["ace/grafana/data"] != 130 {
|
|
t.Fatalf("peak %v, %v", peaks, err)
|
|
}
|
|
r, _ := inv.DataOf(ctx, "ace", "grafana", "data")
|
|
if r.Size == nil || *r.Size != 40 {
|
|
t.Fatalf("the newest measurement is not the one on record: %+v", r)
|
|
}
|
|
}
|
|
|
|
// A partial walk's lower bound is kept as the newest measurement, said as partial, and never kept as a
|
|
// reading a shrink would be read against.
|
|
func TestAPartialMeasurementIsNeverAReading(t *testing.T) {
|
|
inv := fresh(t)
|
|
ctx := t.Context()
|
|
now := time.Date(2026, 10, 6, 0, 0, 0, 0, time.UTC)
|
|
declared := []DeclaredData{{Module: "big", Item: "data", Class: "valuable", Owned: true}}
|
|
if _, err := inv.RecordData(ctx, "home", declared, map[string]map[string]Measurement{"big": {"data": {
|
|
Path: "/srv/big", Size: size(5), MeasuredAt: at(now), Precision: "partial: stopped"}}}, "", now); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var n int
|
|
if err := inv.store.Pool().QueryRow(ctx, `select count(*) from data_reading`).Scan(&n); err != nil || n != 0 {
|
|
t.Fatalf("%d readings from a partial measurement: %v", n, err)
|
|
}
|
|
r, err := inv.DataOf(ctx, "home", "big", "data")
|
|
if err != nil || r.Precision != "partial: stopped" || Comparable(r.Precision) {
|
|
t.Fatalf("%+v, %v", r, err)
|
|
}
|
|
}
|
|
|
|
// A shrink is read against what the same directory held (novox/hq issue 368): an item whose path moved
|
|
// — an agent's home moved to its own account — starts its size history again at the new path, and a
|
|
// genuine shrink at the new path is still read against what that path held.
|
|
func TestThePeakIsReadAtTheItemsPathOnly(t *testing.T) {
|
|
inv := fresh(t)
|
|
ctx := t.Context()
|
|
now := time.Date(2026, 10, 10, 0, 0, 0, 0, time.UTC)
|
|
declared := []DeclaredData{{Module: "claude-code", Item: "agent-home", Class: "valuable", Owned: true}}
|
|
measure := func(when time.Time, path string, s int64) {
|
|
t.Helper()
|
|
if _, err := inv.RecordData(ctx, "novox", declared, map[string]map[string]Measurement{"claude-code": {
|
|
"agent-home": {Path: path, Size: size(s), MeasuredAt: at(when)}}}, "", when); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
measure(now, "/home/operator/.claude", 94_700_000)
|
|
// The path moves ten minutes later: the new directory is measured at once, not an hour on.
|
|
measure(now.Add(10*time.Minute), "/home/agent/.claude", 490)
|
|
peaks, err := inv.DataPeaks(ctx, now.Add(-time.Hour))
|
|
if err != nil || peaks["novox/claude-code/agent-home"] != 490 {
|
|
t.Fatalf("after the path moved the peak is %v (%v), want 490: the old directory's size is no shrink "+
|
|
"of the new one", peaks, err)
|
|
}
|
|
// The new directory grows, then genuinely loses most of it: that is read against the new path's peak.
|
|
measure(now.Add(2*time.Hour), "/home/agent/.claude", 80_000_000)
|
|
measure(now.Add(4*time.Hour), "/home/agent/.claude", 1_000)
|
|
peaks, err = inv.DataPeaks(ctx, now.Add(-time.Hour))
|
|
if err != nil || peaks["novox/claude-code/agent-home"] != 80_000_000 {
|
|
t.Fatalf("a shrink at the new path is read against %v (%v), want 80000000", peaks, err)
|
|
}
|
|
// A measurement that names no path is the item's last known path's, not a new history.
|
|
measure(now.Add(6*time.Hour), "", 2_000)
|
|
peaks, err = inv.DataPeaks(ctx, now.Add(-time.Hour))
|
|
if err != nil || peaks["novox/claude-code/agent-home"] != 80_000_000 {
|
|
t.Fatalf("a measurement with no path started a new history: peak %v (%v)", peaks, err)
|
|
}
|
|
// Moving back to a directory measured before reads it against what it held then.
|
|
measure(now.Add(8*time.Hour), "/home/operator/.claude", 94_000_000)
|
|
peaks, err = inv.DataPeaks(ctx, now.Add(-time.Hour))
|
|
if err != nil || peaks["novox/claude-code/agent-home"] != 94_700_000 {
|
|
t.Fatalf("back at the first path the peak is %v (%v), want 94700000", peaks, err)
|
|
}
|
|
}
|
|
|
|
// Two measurements at the same moment at two paths keep one reading and fail nothing: the second
|
|
// would otherwise break the reading's key and lose the machine's whole record (issue 368 review).
|
|
func TestTwoPathsAtOneMomentFailNothing(t *testing.T) {
|
|
inv := fresh(t)
|
|
ctx := t.Context()
|
|
now := time.Date(2026, 10, 10, 0, 0, 0, 0, time.UTC)
|
|
declared := []DeclaredData{{Module: "claude-code", Item: "agent-home", Class: "valuable", Owned: true}}
|
|
for _, path := range []string{"/home/operator/.claude", "/home/agent/.claude"} {
|
|
if _, err := inv.RecordData(ctx, "novox", declared, map[string]map[string]Measurement{"claude-code": {
|
|
"agent-home": {Path: path, Size: size(100), MeasuredAt: at(now)}}}, "", now); err != nil {
|
|
t.Fatalf("a measurement at %s failed: %v", path, err)
|
|
}
|
|
}
|
|
r, err := inv.DataOf(ctx, "novox", "claude-code", "agent-home")
|
|
if err != nil || r.Path != "/home/agent/.claude" {
|
|
t.Fatalf("%+v, %v", r, err)
|
|
}
|
|
}
|