felhom-agent/internal/backup/backup_state_test.go

package backup

import (
	"os"
	"path/filepath"
	"testing"
	"time"

	"gitea.dooplex.hu/admin/felhom-agent/internal/hub"
)

// R-894: the on-disk newest success per tier survives a restart (a new state from the same file).
func TestBackupSuccessState_SurvivesRestart(t *testing.T) {
	path := filepath.Join(t.TempDir(), "backup-success-state.json")
	s := NewBackupSuccessState(path)
	at := time.Date(2026, 10, 1, 20, 15, 0, 0, time.UTC)
	if err := s.RecordBackupSuccess("felhom-pbs", hub.Backup{VMID: 9201, Success: true, StartedAt: at.Format(time.RFC3339)}); err != nil {
		t.Fatal(err)
	}
	got, ok := NewBackupSuccessState(path).LastKnownSuccess("felhom-pbs", 9201)
	if !ok || !got.Equal(at) {
		t.Fatalf("after a restart the saved copy must read back; got %v ok=%v", got, ok)
	}
	if _, ok := NewBackupSuccessState(path).LastKnownSuccess("local", 9201); ok {
		t.Fatal("another tier must not borrow this tier's copy")
	}
}

// Only a NEWER success replaces the saved one; failures and unparseable times are ignored.
func TestBackupSuccessState_KeepsNewestSuccessOnly(t *testing.T) {
	path := filepath.Join(t.TempDir(), "s.json")
	s := NewBackupSuccessState(path)
	newer := time.Date(2026, 10, 5, 0, 0, 0, 0, time.UTC)
	older := newer.Add(-48 * time.Hour)
	for _, b := range []hub.Backup{
		{VMID: 1, Success: true, StartedAt: newer.Format(time.RFC3339)},
		{VMID: 1, Success: true, StartedAt: older.Format(time.RFC3339)},                 // older: ignored
		{VMID: 1, Success: false, StartedAt: newer.Add(time.Hour).Format(time.RFC3339)}, // failure: ignored
		{VMID: 1, Success: true, StartedAt: "not-a-time"},                               // unparseable: ignored
	} {
		if err := s.RecordBackupSuccess("t", b); err != nil {
			t.Fatal(err)
		}
	}
	if got, _ := NewBackupSuccessState(path).LastKnownSuccess("t", 1); !got.Equal(newer) {
		t.Fatalf("want the newest success %v, got %v", newer, got)
	}
}

// A corrupt file degrades to "nothing known" (the pre-R-894 DUE answer), never a crash.
func TestBackupSuccessState_CorruptFileIsEmpty(t *testing.T) {
	path := filepath.Join(t.TempDir(), "s.json")
	if err := os.WriteFile(path, []byte("{not json"), 0o600); err != nil {
		t.Fatal(err)
	}
	if _, ok := NewBackupSuccessState(path).LastKnownSuccess("t", 1); ok {
		t.Fatal("a corrupt file must read as nothing known")
	}
}

// The saved successes come back as host-report records: success, tier, guest, start time (R-894 → the
// host report, 2026-10-09). A new state read from the same file gives the same records (the restart case).
func TestBackupSuccessState_KnownBackupSuccessesSurviveAReopen(t *testing.T) {
	path := filepath.Join(t.TempDir(), "backup-success-state.json")
	s := NewBackupSuccessState(path)
	if err := s.RecordBackupSuccess("felhom-backup", hub.Backup{VMID: 9201, Success: true, StartedAt: "2026-10-09T02:40:16Z"}); err != nil {
		t.Fatal(err)
	}
	got := NewBackupSuccessState(path).KnownBackupSuccesses()
	if len(got) != 1 || !got[0].Success || got[0].TargetID != "felhom-backup" || got[0].VMID != 9201 || got[0].StartedAt != "2026-10-09T02:40:16Z" {
		t.Fatalf("got %+v", got)
	}
	if got[0].UncoveredVolumes == nil {
		t.Fatal("uncovered_volumes must marshal as [], not null")
	}
}

// R-973: the cadence cap's history and refusals survive a reopen; the history is bounded; a file
// written before R-973 counts its one known success (never "no history" for a tier that has a copy).
func TestBackupSuccessState_R973_RecentHistoryAndRefusalSurviveAReopen(t *testing.T) {
	path := filepath.Join(t.TempDir(), "backup-success-state.json")
	s := NewBackupSuccessState(path)
	base := time.Date(2026, 10, 18, 2, 30, 0, 0, time.UTC)
	for i := 0; i < 10; i++ {
		at := base.Add(time.Duration(i) * time.Hour)
		if err := s.RecordBackupSuccess("local", hub.Backup{VMID: 9201, Success: true, StartedAt: at.Format(time.RFC3339)}); err != nil {
			t.Fatal(err)
		}
	}
	refused := base.Add(11 * time.Hour)
	if err := s.RecordBackupRefusal("local", 9201, refused); err != nil {
		t.Fatal(err)
	}
	r := NewBackupSuccessState(path)
	all := r.RecentBackupSuccesses("local", 9201, time.Time{})
	if len(all) != maxRecentSuccesses || !all[len(all)-1].Equal(base.Add(9*time.Hour)) {
		t.Fatalf("recent history after a reopen: %v (want the newest %d, ending at +9h)", all, maxRecentSuccesses)
	}
	if got := r.RecentBackupSuccesses("local", 9201, base.Add(7*time.Hour)); len(got) != 3 {
		t.Fatalf("successes since +7h: %d, want 3", len(got))
	}
	if tg, vm, at, ok := r.LastBackupRefusal(); !ok || tg != "local" || vm != 9201 || !at.Equal(refused) {
		t.Fatalf("refusal after a reopen: %q %d %v %v", tg, vm, at, ok)
	}

	old := filepath.Join(t.TempDir(), "old.json")
	if err := os.WriteFile(old, []byte(`[{"target":"felhom-pbs","vmid":9201,"started_at":"2026-10-17T03:00:00Z"}]`), 0o600); err != nil {
		t.Fatal(err)
	}
	if got := NewBackupSuccessState(old).RecentBackupSuccesses("felhom-pbs", 9201, time.Time{}); len(got) != 1 {
		t.Fatalf("a pre-R-973 file must count its one success: %v", got)
	}
}