Refactor architecture into eight components and consolidate reliability work
Build and publish container images / images (push) Successful in 9m34s
Release container images / release (push) Successful in 36s

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.
This commit is contained in:
Anya Tokugawa committed 2026-11-01 15:23:31 +09:00
1 parent 9dd425f765
commit d5d21b7841
302 files changed
+20037 -3492

No files matched your search

+294
View File
@@ -0,0 +1,294 @@
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")
}
}