Extract Grammaratur, Dregarnuhr, Geduldh, Mestionora, Ordoschnellic, Schutzaria, Kunstzeal and Seheweit behind compatible application contracts. Include accumulated editor resilience, navigation and theme UX, remote CLI, storage/schema and DR groundwork, tests and design/operations documentation. Verified: uncached full Go suite; go vet ./...; race tests for all eight components; 11 targeted Chromium tests; Node suites; 19 Python CLI tests; reproducible editor build. No push, release tag or deployment in this checkpoint.
295 lines
8.9 KiB
Go
295 lines
8.9 KiB
Go
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")
|
|
}
|
|
}
|