Files
nmon/internal/backup/backup_test.go
Vibe Coder c4d14a67d1 Add the optional IEEE vendor registry for MAC addresses and the l2/oui settings
The owner asked to see the vendor of each MAC where the IEEE registry can be
fetched, and never to depend on it. internal/oui downloads MA-L, MA-M and MA-S
weekly through the outbound allow-list (timeouts, a size cap and a row-count
sanity check, so a truncated or wrong download keeps the previous file), stores
one checksummed, atomically written file in <data-dir>/oui that nmon backup
includes, and looks MACs up by the longest prefix. A missing registry only
leaves the vendor empty. `nmon oui import DIR|FILE` loads the CSVs offline, and
the Ansible role can ship them next to the MIB sidecar.

internal/hostaddr parses the MAC, prefix, IP and CIDR forms the lookup accepts
and classifies a MAC as global, local or multicast. config gains the l2 and oui
sections (validated here; the L2 job that reads l2 follows).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01T4PdJUPrakM8fHvN8jYv2x
2026-10-24 01:30:11 +00:00

239 lines
7.7 KiB
Go

package backup
import (
"bytes"
"context"
"errors"
"os"
"path/filepath"
"strings"
"testing"
"time"
)
func TestBackupRestoreRoundTripWithMetricStores(t *testing.T) {
f := newFixture(t)
hotDir := filepath.Join(f.dir, "vm-hot")
vm := newFakeVM(t, hotDir)
out := filepath.Join(t.TempDir(), "b.tar")
var log bytes.Buffer
o := f.options(out)
o.Log = &log
o.Stores = []VMStore{{Name: "hot", URL: vm.URL, DataDir: hotDir}, {Name: "long", DataDir: ""}}
res, err := Backup(context.Background(), o)
if err != nil {
t.Fatal(err)
}
if res.KeyIncluded || !strings.Contains(log.String(), "NOT included") {
t.Fatalf("key notice missing: %q", log.String())
}
if vm.created != 1 || len(vm.deleted) != 1 || vm.deleted[0] != "snap-1" {
t.Fatalf("snapshot lifecycle: created %d deleted %v", vm.created, vm.deleted)
}
m := res.Manifest
if m.Rows["devices"] != 3 || m.Inventory != inventoryDB || len(m.Stores) != 1 || len(m.Stores[0].Series) != 1 || len(m.Notes) != 1 {
t.Fatalf("manifest %+v", m)
}
if want := f.clk.Now().Add(-DefaultSettle); !m.Boundary.Equal(want) {
t.Fatalf("boundary %v want %v", m.Boundary, want)
}
target := filepath.Join(t.TempDir(), "restored")
sv := &stubVerifier{}
rr, err := Restore(context.Background(), RestoreOptions{File: out, DataDir: target, Verifier: sv, Clock: f.clk})
if err != nil {
t.Fatal(err)
}
if rr.RowsVerified == 0 || rr.SeriesVerified != 1 || !sv.called {
t.Fatalf("result %+v verifier %+v", rr, sv)
}
for _, p := range []string{"inventory.db", "config.yaml", "profiles/custom.yaml", "oui/registry.gz", "hot/indexdb/idx-1"} {
want := p
if strings.HasPrefix(p, "hot/") {
want = "vm-" + p
}
if _, err := os.Stat(filepath.Join(target, want)); err != nil {
t.Errorf("restored tree is missing %s: %v", want, err)
}
}
if _, err := os.Stat(filepath.Join(target, stagingDir)); !errors.Is(err, os.ErrNotExist) {
t.Errorf("staging dir left behind: %v", err)
}
if _, err := os.Stat(filepath.Join(target, "secret.key")); !errors.Is(err, os.ErrNotExist) {
t.Error("key restored although the backup excluded it")
}
}
func TestBackupWithKeyStatesItAndRestoresIt(t *testing.T) {
f := newFixture(t)
out := filepath.Join(t.TempDir(), "b.tar")
var log bytes.Buffer
o := f.options(out)
o.IncludeKey, o.Log = true, &log
res, err := Backup(context.Background(), o)
if err != nil {
t.Fatal(err)
}
if !res.KeyIncluded || !strings.Contains(log.String(), "INCLUDED") || strings.Contains(log.String(), "NOT included") {
t.Fatalf("key notice: %q", log.String())
}
keyOut := filepath.Join(t.TempDir(), "k", "secret.key")
rr, err := Restore(context.Background(), RestoreOptions{File: out, DataDir: filepath.Join(t.TempDir(), "r"), KeyFile: keyOut})
if err != nil {
t.Fatal(err)
}
want, _ := os.ReadFile(f.keyFile)
got, err := os.ReadFile(keyOut)
if err != nil || !bytes.Equal(got, want) || rr.KeyRestoredTo != keyOut {
t.Fatalf("key restore: %v", err)
}
}
func TestBackupRefusesBelowReserveAndWritesNothing(t *testing.T) {
f := newFixture(t)
outDir := t.TempDir()
o := f.options(filepath.Join(outDir, "b.tar"))
o.ReserveCheck = func() error { return errors.New("3.1% free") }
_, err := Backup(context.Background(), o)
if !errors.Is(err, ErrReserve) || !strings.Contains(err.Error(), "3.1% free") {
t.Fatalf("got %v", err)
}
if ents, _ := os.ReadDir(outDir); len(ents) != 0 {
t.Fatalf("files left after a refused backup: %v", ents)
}
}
func TestFailedBackupLeavesNoPartialFileAndDeletesNoSnapshotItDidNotMake(t *testing.T) {
f := newFixture(t)
vm := newFakeVM(t, filepath.Join(f.dir, "vm-hot"))
vm.failSnap = true
outDir := t.TempDir()
o := f.options(filepath.Join(outDir, "b.tar"))
o.Stores = []VMStore{{Name: "hot", URL: vm.URL, DataDir: filepath.Join(f.dir, "vm-hot")}}
if _, err := Backup(context.Background(), o); err == nil {
t.Fatal("want an error")
}
if ents, _ := os.ReadDir(outDir); len(ents) != 0 {
t.Fatalf("partial output left: %v", ents)
}
if left, _ := filepath.Glob(filepath.Join(f.dir, ".backup-*")); len(left) != 0 {
t.Fatalf("scratch left: %v", left)
}
}
func TestTruncatedArchiveIsDetected(t *testing.T) {
f := newFixture(t)
out := filepath.Join(t.TempDir(), "b.tar")
if _, err := Backup(context.Background(), f.options(out)); err != nil {
t.Fatal(err)
}
full, err := os.ReadFile(out)
if err != nil {
t.Fatal(err)
}
for _, cut := range []int{0, 100, len(full) / 2, len(full) - 2048, len(full) - 1024 - 10} {
cutFile := filepath.Join(t.TempDir(), "cut.tar")
if err := os.WriteFile(cutFile, full[:cut], 0o600); err != nil {
t.Fatal(err)
}
target := filepath.Join(t.TempDir(), "r")
_, err := Restore(context.Background(), RestoreOptions{File: cutFile, DataDir: target})
if !errors.Is(err, ErrTruncated) {
t.Errorf("cut at %d of %d: got %v", cut, len(full), err)
}
if ents, _ := os.ReadDir(target); len(ents) != 0 {
t.Errorf("cut at %d left %d files in the data dir", cut, len(ents))
}
}
}
func TestDamagedEntryIsDetected(t *testing.T) {
f := newFixture(t)
out := filepath.Join(t.TempDir(), "b.tar")
if _, err := Backup(context.Background(), f.options(out)); err != nil {
t.Fatal(err)
}
b, _ := os.ReadFile(out)
i := bytes.Index(b, []byte("timezone: UTC"))
b[i] = 'T'
bad := filepath.Join(t.TempDir(), "bad.tar")
if err := os.WriteFile(bad, b, 0o600); err != nil {
t.Fatal(err)
}
_, err := Restore(context.Background(), RestoreOptions{File: bad, DataDir: filepath.Join(t.TempDir(), "r")})
if !errors.Is(err, ErrTruncated) {
t.Fatalf("got %v", err)
}
}
func TestRestoreRefusesNonEmptyDirectory(t *testing.T) {
f := newFixture(t)
out := filepath.Join(t.TempDir(), "b.tar")
if _, err := Backup(context.Background(), f.options(out)); err != nil {
t.Fatal(err)
}
target := t.TempDir()
writeFile(t, filepath.Join(target, "precious"), "x")
_, err := Restore(context.Background(), RestoreOptions{File: out, DataDir: target})
if !errors.Is(err, ErrNotEmpty) {
t.Fatalf("got %v", err)
}
if _, err := os.Stat(filepath.Join(target, "precious")); err != nil {
t.Fatalf("restore touched a non-empty directory: %v", err)
}
}
func TestRestoreFailsWhenSeriesDoNotVerifyAndCleansUp(t *testing.T) {
f := newFixture(t)
vm := newFakeVM(t, filepath.Join(f.dir, "vm-hot"))
out := filepath.Join(t.TempDir(), "b.tar")
o := f.options(out)
o.Stores = []VMStore{{Name: "hot", URL: vm.URL, DataDir: filepath.Join(f.dir, "vm-hot")}}
if _, err := Backup(context.Background(), o); err != nil {
t.Fatal(err)
}
target := filepath.Join(t.TempDir(), "r")
_, err := Restore(context.Background(), RestoreOptions{File: out, DataDir: target, Verifier: &stubVerifier{err: errors.New("sha differs")}})
if !errors.Is(err, ErrVerify) {
t.Fatalf("got %v", err)
}
if ents, _ := os.ReadDir(target); len(ents) != 0 {
t.Fatalf("failed restore left files: %v", ents)
}
}
func TestSchedulerRunsDailyAtConfiguredTime(t *testing.T) {
f := newFixture(t)
var runs []time.Time
ran := make(chan struct{}, 4)
s := &Scheduler{
Clock: f.clk, At: "03:30",
Job: func(context.Context) error { return nil },
OnResult: func(at time.Time, _ error) { runs = append(runs, at); ran <- struct{}{} },
}
next, err := s.NextRun(f.clk.Now())
if err != nil || !next.Equal(time.Date(2026, 10, 23, 3, 30, 0, 0, time.UTC)) {
t.Fatalf("next %v %v", next, err)
}
ctx, cancel := context.WithCancel(context.Background())
done := make(chan error)
go func() { done <- s.Run(ctx) }()
for f.clk.Waiters() == 0 {
time.Sleep(time.Millisecond)
}
f.clk.Advance(16*time.Hour + 30*time.Minute)
<-ran
for f.clk.Waiters() == 0 {
time.Sleep(time.Millisecond)
}
f.clk.Advance(24 * time.Hour)
<-ran
cancel()
if err := <-done; err != nil || len(runs) != 2 {
t.Fatalf("runs %v err %v", runs, err)
}
if _, err := (&Scheduler{At: "25:00"}).NextRun(f.clk.Now()); err == nil {
t.Fatal("bad time accepted")
}
}