package dr import ( "context" "crypto/sha256" "encoding/hex" "encoding/json" "os" "path/filepath" "testing" "time" "pageswiki/internal/db" ) func fixture(t *testing.T) string { t.Helper() root := t.TempDir() database, err := db.Open(filepath.Join(root, "pages.db")) if err != nil { t.Fatal(err) } if _, err = database.Exec("CREATE TABLE revisions(document_hash TEXT); INSERT INTO revisions(rowid,document_hash) VALUES(42,'')"); err != nil { t.Fatal(err) } if err = database.Close(); err != nil { t.Fatal(err) } if _, err = Init(root); err != nil { t.Fatal(err) } if err = os.WriteFile(filepath.Join(root, "auth.key"), make([]byte, 32), 0600); err != nil { t.Fatal(err) } return root } func TestSnapshotRestorePromote(t *testing.T) { root := fixture(t) ctx := context.Background() dest := filepath.Join(t.TempDir(), "snapshot") body := []byte("synthetic DR test document") sum := sha256.Sum256(body) hash := hex.EncodeToString(sum[:]) path := filepath.Join(root, "documents", "sha256", hash[:2], hash) if err := os.MkdirAll(filepath.Dir(path), 0700); err != nil { t.Fatal(err) } if err := os.WriteFile(path, body, 0600); err != nil { t.Fatal(err) } database, err := db.Open(filepath.Join(root, "pages.db")) if err != nil { t.Fatal(err) } // Hold a connection open to keep committed WAL pages present. No writer is // active during snapshot; this covers recovery after an uncheckpointed stop. if _, err = database.Exec("PRAGMA wal_autocheckpoint=0; UPDATE revisions SET document_hash=? WHERE rowid=42", hash); err != nil { t.Fatal(err) } defer database.Close() if err = os.MkdirAll(filepath.Join(root, "previews"), 0700); err != nil { t.Fatal(err) } os.WriteFile(filepath.Join(root, "previews", "ignored"), []byte("cache"), 0600) m, digest, err := Snapshot(ctx, root, dest) if err != nil { t.Fatal(err) } if _, err = Verify(ctx, dest, digest); err != nil { t.Fatal(err) } if _, err = Verify(ctx, dest, digest); err != nil { t.Fatalf("verification must not mutate snapshot: %v", err) } restored := filepath.Join(t.TempDir(), "standby") node, err := Restore(ctx, dest, digest, restored) if err != nil { t.Fatal(err) } if node.Role != "standby" || node.NodeID == node.PrimaryNodeID || node.SnapshotID != m.ID || !node.Readable(time.Now()) { t.Fatalf("bad standby: %+v", node) } if _, err = os.Stat(filepath.Join(restored, "previews")); !os.IsNotExist(err) { t.Fatal("copied cache") } ro, err := db.OpenReadOnly(filepath.Join(restored, "pages.db")) if err != nil { t.Fatal(err) } defer ro.Close() var got string if err = ro.QueryRow("SELECT document_hash FROM revisions WHERE rowid=42").Scan(&got); err != nil || got != hash { t.Fatalf("WAL or rowid lost: %s %v", got, err) } if _, err = ro.Exec("DELETE FROM revisions"); err == nil { t.Fatal("standby accepted write") } shared, err := Lock(restored, false) if err != nil { t.Fatal(err) } if _, err = Promote(restored, node.PrimaryNodeID, "test fence", true); err == nil { t.Fatal("promoted running standby") } shared.Close() if _, err = Promote(restored, "wrong", "test fence", true); err == nil { t.Fatal("accepted wrong primary") } if _, err = Promote(restored, node.PrimaryNodeID, "test fence", false); err == nil { t.Fatal("accepted implicit data loss") } promoted, err := Promote(restored, node.PrimaryNodeID, "test fence", true) if err != nil { t.Fatal(err) } if promoted.Role != "primary" || promoted.Epoch != node.Epoch+1 || len(promoted.History) != 1 { t.Fatalf("bad promotion: %+v", promoted) } if promoted.WorkersEnabled { t.Fatal("promotion replayed jobs without review") } if _, err = ResumeWorkers(restored, false); err == nil { t.Fatal("resumed jobs without review") } resumed, err := ResumeWorkers(restored, true) if err != nil { t.Fatal(err) } if !resumed.WorkersEnabled || resumed.WorkersResumedAt.IsZero() { t.Fatal("worker resumption not audited") } if _, err = Restore(ctx, dest, digest, restored); err == nil { t.Fatal("overwrote existing restore") } } func TestSnapshotCalendarReferencesAndRestoreSafety(t *testing.T) { root := fixture(t) dir := filepath.Join(root, "documents", "calendars", "synthetic-domain", "synthetic-calendar") if err := os.MkdirAll(dir, 0700); err != nil { t.Fatal(err) } body := []byte("synthetic opaque monthly generation; no external calendar data") sum := sha256.Sum256(body) hash := hex.EncodeToString(sum[:]) metadata, _ := json.Marshal(map[string]any{"months": map[string]string{"2026-09": hash}}) if err := os.WriteFile(filepath.Join(dir, "calendar.json"), metadata, 0600); err != nil { t.Fatal(err) } dest := filepath.Join(t.TempDir(), "snapshot") if _, _, err := Snapshot(context.Background(), root, dest); err == nil { t.Fatal("accepted missing calendar month") } if err := os.WriteFile(filepath.Join(dir, "2026-09."+hash+".ics"), body, 0600); err != nil { t.Fatal(err) } _, digest, err := Snapshot(context.Background(), root, dest) if err != nil { t.Fatal(err) } if _, err = Verify(context.Background(), dest, digest); err != nil { t.Fatal(err) } if _, _, err = Snapshot(context.Background(), root, filepath.Join(root, "inside")); err == nil { t.Fatal("snapshot inside source accepted") } if _, err = Restore(context.Background(), dest, digest, root); err == nil { t.Fatal("restore overwrote existing data") } if _, err = Restore(context.Background(), dest, digest, filepath.Join(dest, "nested")); err == nil { t.Fatal("restore corrupted source snapshot") } ctx, cancel := context.WithCancel(context.Background()) cancel() if _, err = Verify(ctx, dest, digest); err == nil { t.Fatal("verification ignored cancellation") } } func TestSnapshotRefusesActiveMissingAndSymlink(t *testing.T) { root := fixture(t) dest := filepath.Join(t.TempDir(), "snapshot") ctx := context.Background() shared, err := Lock(root, false) if err != nil { t.Fatal(err) } if _, _, err = Snapshot(ctx, root, dest); err == nil { t.Fatal("snapshotted running instance") } shared.Close() database, err := db.Open(filepath.Join(root, "pages.db")) if err != nil { t.Fatal(err) } _, err = database.Exec("UPDATE revisions SET document_hash=?", string(make([]byte, 64))) if err != nil { t.Fatal(err) } database.Close() if _, _, err = Snapshot(ctx, root, dest); err == nil { t.Fatal("accepted missing canonical document") } if _, err = os.Stat(dest); !os.IsNotExist(err) { t.Fatal("published failed snapshot") } if err = os.Symlink(t.TempDir(), filepath.Join(root, "themes")); err != nil { t.Fatal(err) } if _, _, err = Snapshot(ctx, root, dest); err == nil { t.Fatal("followed source symlink") } } func TestSnapshotTamperAndPathValidation(t *testing.T) { root := fixture(t) dest := filepath.Join(t.TempDir(), "snapshot") ctx := context.Background() _, digest, err := Snapshot(ctx, root, dest) if err != nil { t.Fatal(err) } if _, err = Verify(ctx, dest, ""); err == nil { t.Fatal("accepted unauthenticated manifest") } manifestPath := filepath.Join(dest, "manifest.json") encoded, err := os.ReadFile(manifestPath) if err != nil { t.Fatal(err) } var m Manifest if err = json.Unmarshal(encoded, &m); err != nil { t.Fatal(err) } m.Files[0].Path = "../outside" altered, _ := json.Marshal(m) sum := sha256.Sum256(altered) os.WriteFile(manifestPath, altered, 0600) if _, err = Verify(ctx, dest, digest); err == nil { t.Fatal("accepted changed manifest") } if _, err = Verify(ctx, dest, hex.EncodeToString(sum[:])); err == nil { t.Fatal("accepted traversal even with matching manifest digest") } os.WriteFile(manifestPath, encoded, 0600) os.WriteFile(filepath.Join(dest, "data", "auth.key"), []byte("tampered"), 0600) if _, err = Verify(ctx, dest, digest); err == nil { t.Fatal("accepted payload tamper") } for _, path := range []string{"/etc/passwd", "documents/../auth.key", "documents\\foo", "dr-node.json", "pages.db-wal", "cache/foo"} { if canonical(path) { t.Errorf("accepted %q", path) } } } func TestConfigFailsClosedAndExpiry(t *testing.T) { root := fixture(t) c, err := Load(root) if err != nil { t.Fatal(err) } c.Role = "standby" if err = Save(root, *c); err == nil { t.Fatal("accepted inconsistent role") } os.WriteFile(filepath.Join(root, ConfigFile), []byte(`{"role":"broken"}`), 0600) if _, err = Load(root); err == nil { t.Fatal("invalid config accepted") } c.Role = "standby" c.CapturedAt = time.Now().Add(-2 * time.Hour) c.MaxReadAgeSeconds = 3600 if c.Readable(time.Now()) { t.Fatal("stale snapshot is readable") } c.CapturedAt = time.Now().Add(time.Hour) if c.Readable(time.Now()) { t.Fatal("future snapshot is readable") } if err = RequireRole(nil, "standby"); err == nil { t.Fatal("empty standby volume would start writable") } if err = RequireRole(c, "primary"); err == nil { t.Fatal("mismatched deployment role accepted") } if err = RequireRole(c, "standby"); err != nil { t.Fatal(err) } if err = RequireRole(nil, ""); err != nil { t.Fatal("legacy startup broken") } }