Files
felhom-controller/controller/internal/backup/offbox_window_test.go
T
admin f628cb5082
gates / gates (push) Successful in 41s
The off-site copies of a removed app end 30 days after „delete backup data” — the box's half (felhom.eu R-1374 part 1; D72, D84)
Built, not released; no box has run it. felhom.eu `07-backup-architecture.md` §8.2f.
It does nothing without a hub that knows it: an older hub agrees to no id.

- The record: settings `offsite_ends` {app, removed_at, ends_at}. One writer
  (backup.StartOffsiteEnd), called by a removal only with „delete backup data”
  and by „Törlés 30 nap múlva” on the restore page. A second press changes
  nothing. No record, no deletion. Only on the hub-provisioned tier.
- The date is on the remove dialog before the press; the restore page shows
  „Törlésre kijelölve …” with „Mégis megtartom”, and one history line per
  carried-out end. An install of the same app deletes the record.
- The weekly window: after the guard has passed the policy's plan under the cap
  as before, it adds the snapshots whose app tags are ALL due records, that the
  hub agreed to and the box named in the same request; the result names them
  apart (removed_for_ended_apps). `_shares`, the box's own stacks and an
  installed app are never due.
- The report carries the pending records; the household gets one mail per
  press (offsite_end_scheduled), in both languages.

MinAgent unchanged (0.158.1). 143 parity fixtures gained the dialog's one new
script line (patched, not regenerated); one new parity case.
Tests TestD72_*, TestD84_*; 56 mutations seen red
(felhom.eu documentation/audits/build-release-4-2026-11-15/A/redproof-ctrl-*.txt).

Claude-Session: https://claude.ai/code/session_0159rPz1ZhFKsS53msqPYxtS
2026-11-15 14:09:47 +01:00

566 lines
24 KiB
Go

package backup
import (
"bytes"
"context"
"encoding/json"
"fmt"
"log"
"sort"
"strings"
"testing"
"time"
"gitea.dooplex.hu/admin/felhom-controller/internal/settings"
)
// ── decision 68/69 (v0.289.0): the append-only tier ─────────────────────────────────────────────────
func pinTarget(t *testing.T, sett *settings.Settings) {
t.Helper()
if err := sett.UpdateOffboxStatus(func(o *settings.OffboxTarget) {
o.Transport = settings.TransportRclonePinned
o.Port = 23
o.Host, o.User, o.RepoPath = "u1-sub4.example", "u1-sub4", "/home/felhom-repo"
}); err != nil {
t.Fatal(err)
}
}
func snapJSON(s []guardSnap) []byte { b, _ := json.Marshal(s); return b }
func planJSON(remove []guardSnap) []byte {
b, _ := json.Marshal([]map[string]any{{"tags": []string{"app1"}, "remove": remove}})
return b
}
// windowRunner fakes restic for the retention step: snapshots, the dry-run plan, and records every
// non-dry-run forget (the only call that deletes).
type windowRunner struct {
snaps []guardSnap
plan []guardSnap
forgets [][]string
}
func (w *windowRunner) run(_ context.Context, _ []string, args ...string) ([]byte, error) {
switch {
case contains(args, "forget") && contains(args, "--dry-run"):
return planJSON(w.plan), nil
case contains(args, "forget"):
w.forgets = append(w.forgets, append([]string{}, args...))
return nil, nil
case contains(args, "snapshots"):
return snapJSON(w.snaps), nil
}
return nil, nil
}
type fakeWindow struct {
claims []OffsiteEndedClaim
grant OffsiteWindow
opened int
closed []OffsiteWindowResult
}
func (f *fakeWindow) Open(_ context.Context, _ int, ended []OffsiteEndedClaim) (OffsiteWindow, error) {
f.opened++
f.claims = ended
return f.grant, nil
}
func (f *fakeWindow) Close(_ context.Context, r OffsiteWindowResult) error {
f.closed = append(f.closed, r)
return nil
}
func snap(id string, at time.Time) guardSnap {
return guardSnap{ID: id + "-full", ShortID: id, Time: at}
}
// The pinned transport: rclone over port 23, the pinned key; never sftp.
func TestOffboxBaseArgs_PinnedUsesRcloneOnPort23(t *testing.T) {
m, sett := newOffboxManager(t)
pinTarget(t, sett)
sett.UpdateOffboxStatus(func(o *settings.OffboxTarget) { o.Port = 0 })
args, _ := m.offboxBaseArgs(sett.GetOffboxTarget())
j := strings.Join(args, " ")
if !strings.Contains(j, "-r rclone:/home/felhom-repo") || !strings.Contains(j, "rclone.program=ssh -p 23 ") || strings.Contains(j, "sftp") {
t.Fatalf("pinned args = %q", j)
}
if !argsContainTimeout(args) {
t.Fatal("ConnectTimeout lost on the pinned transport")
}
// The household's NAS stays SFTP.
m2, sett2 := newOffboxManager(t)
if j2 := strings.Join(func() []string { a, _ := m2.offboxBaseArgs(sett2.GetOffboxTarget()); return a }(), " "); !strings.Contains(j2, "sftp:") {
t.Fatalf("NAS args = %q", j2)
}
}
// THE CONSEQUENCE: on the pinned tier, a run with no window deletes NOTHING — no forget reaches restic.
// RED-PROOF: the pre-v0.289.0 retention ran `forget … --prune` unconditionally after every run.
func TestRetention_PinnedWithoutWindowDeletesNothing(t *testing.T) {
m, sett := newOffboxManager(t)
pinTarget(t, sett)
wr := &windowRunner{snaps: []guardSnap{snap("a", time.Now().Add(-40*24*time.Hour))}, plan: []guardSnap{snap("a", time.Now().Add(-40*24*time.Hour))}}
m.SetOffboxRunner(wr.run)
m.offsiteWindowRetention(context.Background(), nil, nil, "after-run") // no client wired
fw := &fakeWindow{grant: OffsiteWindow{Granted: false, Reason: "not due"}}
m.SetOffsiteWindowClient(fw)
m.offsiteWindowRetention(context.Background(), nil, nil, "after-run")
if len(wr.forgets) != 0 {
t.Fatalf("a forget ran without a window: %v", wr.forgets)
}
if fw.opened != 1 || len(fw.closed) != 0 {
t.Fatalf("opened=%d closed=%d", fw.opened, len(fw.closed))
}
}
// The full run path: RunOffboxBackup on a pinned target with no window never calls forget.
func TestRunOffboxBackup_PinnedNeverForgetsWithoutWindow(t *testing.T) {
m, sett := newOffboxManager(t)
pinTarget(t, sett)
var forgets int
m.SetOffboxRunner(func(ctx context.Context, env []string, args ...string) ([]byte, error) {
if contains(args, "forget") {
forgets++
}
rr := &recordingOffboxRunner{}
return rr.run(ctx, env, args...)
})
_ = m.RunOffboxBackup(context.Background())
if forgets != 0 {
t.Fatalf("the pinned run reached forget %d time(s)", forgets)
}
}
// R-822, the lab's shape: 13 future-dated fakes. The guard REFUSES and nothing is deleted; the hub
// is told why (window closed with outcome guard-refused).
func TestOffsiteGuard_LabThirteenFutureFakes_Refused(t *testing.T) {
m, sett := newOffboxManager(t)
pinTarget(t, sett)
now := time.Now()
real := []guardSnap{snap("r1", now.Add(-2*time.Hour)), snap("r2", now.Add(-26*time.Hour)), snap("r3", now.Add(-50*time.Hour))}
all := append([]guardSnap{}, real...)
for d := 1; d <= 7; d++ {
all = append(all, snap(fmt.Sprintf("f%d", d), time.Date(2027, 1, d, 3, 0, 0, 0, time.UTC)))
}
for mth := 2; mth <= 7; mth++ {
all = append(all, snap(fmt.Sprintf("m%d", mth), time.Date(2027, time.Month(mth), 15, 3, 0, 0, 0, time.UTC)))
}
wr := &windowRunner{snaps: all, plan: real} // the poisoned policy selects every REAL snapshot
m.SetOffboxRunner(wr.run)
fw := &fakeWindow{grant: OffsiteWindow{Granted: true, ID: 7, NewestAllowed: now, MaxRemove: 50}}
m.SetOffsiteWindowClient(fw)
m.offsiteWindowRetention(context.Background(), nil, nil, "after-run")
if len(wr.forgets) != 0 {
t.Fatalf("the guard let a poisoned plan delete: %v", wr.forgets)
}
if len(fw.closed) != 1 || fw.closed[0].Outcome != "guard-refused" || !strings.Contains(fw.closed[0].Reason, "future") {
t.Fatalf("window close = %+v", fw.closed)
}
}
// Past-dated fakes that make the policy drop a RECENT real snapshot: refused too.
func TestOffsiteGuard_RecentRemovalRefused(t *testing.T) {
now := time.Now()
all := []guardSnap{snap("old", now.Add(-60*24*time.Hour)), snap("recent", now.Add(-3*24*time.Hour))}
_, why := offsiteGuard(all, []guardSnap{snap("recent", now.Add(-3*24*time.Hour))}, now, now, 50)
if !strings.Contains(why, "within the last 7 days kept daily") {
t.Fatalf("why = %q", why)
}
_, why = offsiteGuard(all, nil, now, now.Add(-10*24*time.Hour), 50)
if !strings.Contains(why, "newer than the hub allows") {
t.Fatalf("newest-allowed bound not enforced: %q", why)
}
}
// Honest retention inside a window: oldest first, the forget names ids.
func TestOffsiteGuard_HonestPlanPrunesOldestFirst(t *testing.T) {
m, sett := newOffboxManager(t)
pinTarget(t, sett)
now := time.Now()
plan := []guardSnap{snap("c", now.Add(-20*24*time.Hour)), snap("a", now.Add(-90*24*time.Hour)), snap("b", now.Add(-60*24*time.Hour))}
all := append([]guardSnap{snap("keep", now.Add(-time.Hour))}, plan...)
wr := &windowRunner{snaps: all, plan: plan}
m.SetOffboxRunner(wr.run)
fw := &fakeWindow{grant: OffsiteWindow{Granted: true, ID: 9, NewestAllowed: now, MaxRemove: 5}}
m.SetOffsiteWindowClient(fw)
m.offsiteWindowRetention(context.Background(), nil, nil, "after-run")
if len(wr.forgets) != 1 || !strings.Contains(strings.Join(wr.forgets[0], " "), "forget a-full b-full c-full --prune") {
t.Fatalf("forget = %v", wr.forgets)
}
if len(fw.closed) != 1 || fw.closed[0].Outcome != "pruned" || fw.closed[0].ID != 9 {
t.Fatalf("close = %+v", fw.closed)
}
}
// A plan larger than one week's removal REFUSES (the 2026-10-04 brief), nothing removed.
func TestOffsiteGuard_AboveWeeklyCapRefused(t *testing.T) {
now := time.Now()
var plan []guardSnap
for i := 0; i < 6; i++ {
plan = append(plan, snap(fmt.Sprintf("o%d", i), now.Add(-time.Duration(30+i)*24*time.Hour)))
}
ids, why := offsiteGuard(plan, plan, now, now, 5)
if ids != nil || !strings.Contains(why, "more than one week") {
t.Fatalf("ids=%v why=%q", ids, why)
}
}
// R-824, THE MEASURED SHAPE (demo-hp window 1, 2026-10-03): the night run's snapshots of each app were
// superseded the SAME DAY by a manual run, so the honest policy removes them while they are young.
// v0.289 refused the whole window; now they are EXCLUDED (kept for later) and the old removal goes ahead.
func TestOffsiteGuard_SameDaySupersededYoungExcluded(t *testing.T) {
m, sett := newOffboxManager(t)
pinTarget(t, sett)
now := time.Now()
day := now.Add(-26 * time.Hour).Truncate(24 * time.Hour)
night := guardSnap{ID: "night-full", ShortID: "night", Time: day.Add(2 * time.Hour), Hostname: "demo-hp", Tags: []string{"opengist"}}
manual := guardSnap{ID: "manual-full", ShortID: "manual", Time: day.Add(15 * time.Hour), Hostname: "demo-hp", Tags: []string{"opengist"}}
old := guardSnap{ID: "old-full", ShortID: "old", Time: now.Add(-40 * 24 * time.Hour), Hostname: "demo-hp", Tags: []string{"opengist"}}
wr := &windowRunner{snaps: []guardSnap{old, night, manual}, plan: []guardSnap{night, old}}
m.SetOffboxRunner(wr.run)
fw := &fakeWindow{grant: OffsiteWindow{Granted: true, ID: 2, NewestAllowed: now, MaxRemove: 5}}
m.SetOffsiteWindowClient(fw)
m.offsiteWindowRetention(context.Background(), nil, nil, "after-run")
if len(fw.closed) != 1 || fw.closed[0].Outcome != "pruned" {
t.Fatalf("the window must run, not refuse: %+v", fw.closed)
}
got := strings.Join(wr.forgets[0], " ")
if !strings.Contains(got, "old-full") || strings.Contains(got, "night-full") {
t.Fatalf("forget = %q (the young superseded copy must be KEPT for now)", got)
}
// A young removal with NO same-day successor in its group is still the poisoning signature.
lone := guardSnap{ID: "lone-full", ShortID: "lone", Time: now.Add(-50 * time.Hour), Hostname: "demo-hp", Tags: []string{"bookstack"}}
if _, why := offsiteGuard([]guardSnap{lone, manual}, []guardSnap{lone}, now, now, 5); !strings.Contains(why, "not superseded the same day") {
t.Fatalf("why = %q", why)
}
}
// The orphan reset on the pinned tier asks the HUB; no ssh `mv` from the box.
func TestResetOrphaned_PinnedAsksTheHub(t *testing.T) {
m, sett := newOffboxManager(t)
pinTarget(t, sett)
m.SetOffboxSSH(func(context.Context, string, string, int, string, string, string) ([]byte, error) {
t.Fatal("the box issued a raw ssh command on the pinned tier")
return nil, nil
})
called := 0
m.SetOffsiteMoveAside(func(context.Context) (string, error) { called++; return "/home/felhom-repo.orphaned-20261003", nil })
m.SetOffboxRunner(func(context.Context, []string, ...string) ([]byte, error) { return nil, nil })
if err := m.resetOrphanedRepo(context.Background(), nil, nil, "test"); err != nil {
t.Fatal(err)
}
if called != 1 || sett.GetOffboxTarget().OrphanedRenamedTo != "/home/felhom-repo.orphaned-20261003" {
t.Fatalf("hub move-aside called=%d recorded=%q", called, sett.GetOffboxTarget().OrphanedRenamedTo)
}
}
// R-869 (v0.294.0): the move-aside line names the destination. MEASURED 2026-10-05 03:08 UTC, Tester 1 box
// (v0.293.0): `the hub set the orphaned repo aside: /home/felhom-repo -> (nothing deleted)`.
// COMPANION RED-PROOF: move `newPath = np` below the log line → "the line names no destination".
func TestR869_MoveAsideLineNamesTheDestination(t *testing.T) {
m, sett := newOffboxManager(t)
var buf bytes.Buffer
m.logger = log.New(&buf, "", 0)
pinTarget(t, sett)
m.SetOffsiteMoveAside(func(context.Context) (string, error) { return "/home/felhom-repo.orphaned-20261005", nil })
m.SetOffboxRunner(func(context.Context, []string, ...string) ([]byte, error) { return nil, nil })
if err := m.resetOrphanedRepo(context.Background(), nil, nil, "test"); err != nil {
t.Fatal(err)
}
if !strings.Contains(buf.String(), "aside: /home/felhom-repo -> /home/felhom-repo.orphaned-20261005 (nothing deleted)") {
t.Fatalf("the line names no destination:\n%s", buf.String())
}
}
// The provider's rclone notice must not reach a JSON parser — measured live on demo-felhom (v0.289.0).
func TestStripRcloneNotice(t *testing.T) {
in := "rclone: 2026/10/03 15:05:42 NOTICE: Config file \"/home/.config/rclone/rclone.conf\" not found - using defaults\n[{\"id\":\"s1\"}]\n"
if got := string(stripRcloneNotice([]byte(in))); got != "[{\"id\":\"s1\"}]\n" {
t.Fatalf("got %q", got)
}
keep := "rclone: 2026/10/03 15:05:42 ERROR : something real\n"
if got := string(stripRcloneNotice([]byte(keep))); got != keep {
t.Fatalf("an rclone ERROR line was stripped: %q", got)
}
}
// THE CONSEQUENCE (R-331/R-431): a run whose snapshot listing cannot be read must NOT record 0 as a
// measurement. Before the fix the box reported 0 snapshots with stats_known over a store holding 12.
func TestRunOffbox_UnreadableCountIsNotZero(t *testing.T) {
m, sett := newOffboxManager(t)
sett.UpdateOffboxStatus(func(o *settings.OffboxTarget) { o.SnapshotCount, o.StatsKnown = 11, true })
m.SetOffboxRunner(func(ctx context.Context, env []string, args ...string) ([]byte, error) {
if contains(args, "snapshots") {
return []byte("rclone: 2026/10/03 15:05:42 ERROR : boom\nnot json"), nil
}
rr := &recordingOffboxRunner{}
return rr.run(ctx, env, args...)
})
_ = m.RunOffboxBackup(context.Background())
got := sett.GetOffboxTarget()
if got.StatsKnown && got.SnapshotCount == 0 {
t.Fatalf("an unreadable count was recorded as a measured zero: %+v", got.SnapshotCount)
}
}
type fakeAbandon struct {
requested []string
state string
cancels int
due time.Time
}
func (f *fakeAbandon) Request(_ context.Context, p string) (time.Time, error) {
f.requested = append(f.requested, p)
f.state = "pending"
return f.due, nil
}
func (f *fakeAbandon) Status(context.Context) (string, error) { return f.state, nil }
func (f *fakeAbandon) Cancel(context.Context) error { f.cancels++; f.state = "cancelled"; return nil }
// Decision 74 (R-823), the box side: a due abandonment on the pinned tier is HANDED to the hub (nothing
// deleted by the box), the page keeps a dated, cancellable deletion, a recovery cancels it at the hub, and
// a "deleted" from the hub completes the two-phase commit.
func TestAbandon_PinnedHandsToHubAndFollows(t *testing.T) {
m, sett := newOffboxManager(t)
pinTarget(t, sett)
setDue := func() {
sett.UpdateOffboxStatus(func(o *settings.OffboxTarget) {
o.AbandonRepoPath = "/home/felhom-repo.orphaned-20260901"
o.AbandonStartedAt = time.Now().Add(-20 * 24 * time.Hour).UTC().Format(time.RFC3339)
o.AbandonAt = time.Now().Add(-time.Hour).UTC().Format(time.RFC3339)
})
}
setDue()
m.SetOffboxSSH(func(context.Context, string, string, int, string, string, string) ([]byte, error) {
t.Fatal("the box tried to delete on the pinned tier")
return nil, nil
})
fa := &fakeAbandon{due: time.Now().Add(7 * 24 * time.Hour)}
m.SetOffsiteAbandonClient(fa)
if del, err := m.AbandonSweep(context.Background()); del || err != nil || len(fa.requested) != 1 {
t.Fatalf("del=%v err=%v requested=%v", del, err, fa.requested)
}
st := m.AbandonStatus()
if !st.Active || !st.HubPending || st.DaysLeft < 6 {
t.Fatalf("the page would lose the dated deletion: %+v", st)
}
// Still pending: nothing happens, nothing re-requested.
if del, _ := m.AbandonSweep(context.Background()); del || len(fa.requested) != 1 {
t.Fatal("re-requested or deleted while pending")
}
// The household recovers → cancelled at the hub, countdown gone.
m.CancelAbandon("recovery succeeded")
if fa.cancels != 1 || m.AbandonStatus().Active {
t.Fatalf("cancels=%d status=%+v", fa.cancels, m.AbandonStatus())
}
// Again, and this time the hub deletes.
setDue()
_, _ = m.AbandonSweep(context.Background())
fa.state = "deleted"
var evs []string
m.SetOffboxOrphanEvent(func(e, _ string) { evs = append(evs, e) })
if del, err := m.AbandonSweep(context.Background()); !del || err != nil || !m.AbandonStatus().PurgeRequested || len(evs) != 1 || evs[0] != "offbox_abandon_completed" {
t.Fatalf("del=%v err=%v status=%+v evs=%v", del, err, m.AbandonStatus(), evs)
}
}
// ── R-867 (v0.294.0): the guard against the REAL policy ─────────────────────────────────────────────────
// restic0140Plan is restic 0.14.0's `forget --group-by host,tags --keep-daily D --keep-weekly W
// --keep-monthly M` (internal/restic/snapshot_policy.go ApplyPolicy): per group, newest first, a snapshot
// is kept when it opens a new day / ISO week / month bucket while that rule still has count left; every
// other snapshot is removed. Equivalence with the real binary over the same snapshot set is recorded in
// felhom.eu/documentation/audits/night-fixes-2026-10-05/partA/ (the lab run).
func restic0140Plan(all []guardSnap, daily, weekly, monthly int) (remove []guardSnap) {
groups := map[string][]guardSnap{}
var order []string
for _, s := range all {
if _, ok := groups[s.group()]; !ok {
order = append(order, s.group())
}
groups[s.group()] = append(groups[s.group()], s)
}
for _, g := range order {
list := append([]guardSnap{}, groups[g]...)
sort.SliceStable(list, func(i, j int) bool { return list[i].Time.After(list[j].Time) })
type bucket struct {
count int
f func(time.Time) int
last int
}
b := []bucket{
{daily, func(d time.Time) int { return d.Year()*10000 + int(d.Month())*100 + d.Day() }, -1},
{weekly, func(d time.Time) int { y, w := d.ISOWeek(); return y*100 + w }, -1},
{monthly, func(d time.Time) int { return d.Year()*100 + int(d.Month()) }, -1},
}
for _, cur := range list {
keep := false
for i := range b {
if b[i].count > 0 {
if v := b[i].f(cur.Time); v != b[i].last {
keep = true
b[i].last = v
b[i].count--
}
}
}
if !keep {
remove = append(remove, cur)
}
}
}
return remove
}
func without(all []guardSnap, ids []string) []guardSnap {
gone := map[string]bool{}
for _, id := range ids {
gone[id] = true
}
var out []guardSnap
for _, s := range all {
if !gone[s.ID] {
out = append(out, s)
}
}
return out
}
// THE MEASURED SHAPE (demo-felhom window 3, 2026-10-05 02:15 UTC): the night's snapshot is taken, then the
// window runs; the policy drops the snapshot of 7 days + 5 s ago. v0.293.0's 8-day line refused it.
func TestOffsiteGuard_RealPolicyMeasuredShapeAllowed(t *testing.T) {
var all []guardSnap
for d := 0; d < 8; d++ {
at := time.Date(2026, 9, 28+d, 2, 15, 5, 0, time.UTC)
all = append(all, guardSnap{ID: fmt.Sprintf("n%d-full", d), ShortID: fmt.Sprintf("n%d", d), Time: at, Hostname: "demo-felhom", Tags: []string{"opengist"}})
}
now := time.Date(2026, 10, 5, 2, 15, 10, 0, time.UTC)
plan := restic0140Plan(all, keepDaily, keepWeekly, keepMonthly)
if len(plan) != 1 || plan[0].ShortID != "n0" {
t.Fatalf("the policy's plan = %v, want the 2026-09-28 snapshot only", plan)
}
ids, why := offsiteGuard(all, plan, now, now, 5)
if why != "" || len(ids) != 1 || ids[0] != "n0-full" {
t.Fatalf("the honest drop of a 7 d + 5 s snapshot must pass: ids=%v why=%q", ids, why)
}
}
// Sixty nights of a household with three apps, a window after every night's run (the worst case: the hub
// opens weekly), a same-day manual run on two days, and a month boundary: the real policy's plan is never
// refused, deletes happen, and the store settles at the policy's size. Weekly and monthly keeps survive.
func TestOffsiteGuard_RealPolicySixtyNightsNeverRefuses(t *testing.T) {
apps := []string{"opengist", "bookstack", "immich"}
var all []guardSnap
removedTotal, windowsWithRemoval := 0, 0
start := time.Date(2026, 8, 20, 2, 15, 0, 0, time.UTC)
for night := 0; night < 60; night++ {
at := start.AddDate(0, 0, night)
for i, a := range apps {
all = append(all, guardSnap{ID: fmt.Sprintf("%s-%d-full", a, night), ShortID: fmt.Sprintf("%s%d", a, night),
Time: at.Add(time.Duration(i) * time.Second), Hostname: "box", Tags: []string{a}})
}
if night == 20 || night == 41 { // the household pressed "back up now" in the afternoon
for _, a := range apps {
all = append(all, guardSnap{ID: fmt.Sprintf("%s-%d-manual-full", a, night), ShortID: fmt.Sprintf("%s%dm", a, night),
Time: at.Add(13 * time.Hour), Hostname: "box", Tags: []string{a}})
}
}
now := at.Add(2 * time.Minute)
if night == 20 || night == 41 {
now = at.Add(13*time.Hour + 2*time.Minute)
}
plan := restic0140Plan(all, keepDaily, keepWeekly, keepMonthly)
ids, why := offsiteGuard(all, plan, now, now, 500)
if why != "" {
t.Fatalf("night %d (%s): the guard refused the honest policy: %s", night, now.Format(time.RFC3339), why)
}
if len(ids) > 0 {
windowsWithRemoval++
removedTotal += len(ids)
}
all = without(all, ids)
}
if windowsWithRemoval < 15 || removedTotal < 45 {
t.Fatalf("too little was ever removed (%d windows, %d snapshots): the test does not exercise deletion", windowsWithRemoval, removedTotal)
}
// The store holds the policy's shape per app, never only the last 7 days: the end-of-month keeps remain.
per := map[string]int{}
monthEnds := 0
for _, s := range all {
per[s.Tags[0]]++
if s.Tags[0] == "opengist" && (s.Time.Format("01-02") == "08-31" || s.Time.Format("01-02") == "09-30") {
monthEnds++
}
}
for _, a := range apps {
if per[a] < keepDaily || per[a] > keepDaily+keepWeekly+keepMonthly {
t.Fatalf("%s holds %d snapshots after 60 nights; policy bounds %d..%d", a, per[a], keepDaily, keepDaily+keepWeekly+keepMonthly)
}
}
if monthEnds != 2 {
t.Fatalf("the monthly keeps of 31 Aug and 30 Sep must survive; found %d", monthEnds)
}
}
// A weekly window (the hub's real cadence) over the same nights: the backlog of one week is removed in one
// go and is never refused by the day line.
func TestOffsiteGuard_RealPolicyWeeklyWindows(t *testing.T) {
var all []guardSnap
start := time.Date(2026, 9, 1, 2, 15, 0, 0, time.UTC)
removed := 0
for night := 0; night < 35; night++ {
at := start.AddDate(0, 0, night)
all = append(all, guardSnap{ID: fmt.Sprintf("s%d-full", night), ShortID: fmt.Sprintf("s%d", night), Time: at, Hostname: "box", Tags: []string{"app"}})
if night%7 != 6 {
continue
}
now := at.Add(time.Minute)
plan := restic0140Plan(all, keepDaily, keepWeekly, keepMonthly)
ids, why := offsiteGuard(all, plan, now, now, 7)
if why != "" {
t.Fatalf("weekly window on %s refused: %s", now.Format("2006-01-02"), why)
}
removed += len(ids)
all = without(all, ids)
}
if removed == 0 {
t.Fatal("five weekly windows removed nothing")
}
}
// Poisoning that the day line still catches with the REAL policy: just before midnight an add-only
// attacker plants a snapshot 50 minutes ahead — inside the future-date skew, so not refused as future —
// dated TOMORROW. The policy then counts tomorrow as a day and drops the real snapshot of six days ago.
// (Past-dated fakes cannot make the policy drop a snapshot inside the last keepDaily calendar days: those
// days are at most keepDaily distinct days and keep-daily keeps them all. Past-dated gap-fills that steer
// OLDER keeps are R-822's residual, bounded by MaxRemove and the hub's count check, not by this line.)
func TestOffsiteGuard_RealPolicySkewWindowFakeRefused(t *testing.T) {
now := time.Date(2026, 10, 12, 23, 30, 0, 0, time.UTC)
var all []guardSnap
for d := 0; d < 7; d++ {
all = append(all, guardSnap{ID: fmt.Sprintf("real%d-full", d), ShortID: fmt.Sprintf("real%d", d),
Time: time.Date(2026, 10, 12-d, 2, 15, 0, 0, time.UTC), Hostname: "box", Tags: []string{"app"}})
}
all = append(all, guardSnap{ID: "fake-full", ShortID: "fake", Time: now.Add(50 * time.Minute), Hostname: "box", Tags: []string{"app"}})
plan := restic0140Plan(all, keepDaily, keepWeekly, keepMonthly)
if len(plan) != 1 || plan[0].ShortID != "real6" {
t.Fatalf("plan = %v (want the real snapshot of 6 days ago)", plan)
}
_, why := offsiteGuard(all, plan, now, now, 50)
if !strings.Contains(why, "within the last 7 days kept daily") {
t.Fatalf("why = %q — a real snapshot inside the daily window must not be removed", why)
}
}
// The policy's arguments and the guard's line come from the same constants (R-867).
func TestRetentionPolicy_BuiltFromTheGuardConstants(t *testing.T) {
got := strings.Join(retentionPolicy, " ")
want := fmt.Sprintf("--group-by host,tags --keep-daily %d --keep-weekly %d --keep-monthly %d", keepDaily, keepWeekly, keepMonthly)
if got != want || keepDaily != 7 || keepWeekly != 4 || keepMonthly != 6 {
t.Fatalf("policy = %q (want %q, the ruled 7/4/6)", got, want)
}
}