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

+135
View File
@@ -0,0 +1,135 @@
package server
import (
"context"
"fmt"
"sync"
"testing"
"time"
"pageswiki/internal/db"
"pageswiki/internal/dregarnuhr"
"pageswiki/internal/store"
)
func TestDregarnuhrBuiltinsRemainRegistered(t *testing.T) {
s := &Server{}
registry := s.registeredEventHandlers()
// Duplicate registration proves presence without executing a business handler
// or reading any external calendar/source content.
for _, kind := range []string{
store.NotificationPushEventType, store.TaskFocusEventType, store.TaskReminderEventType,
store.TaskActivityBridgeEventType, calendarSweepType, calendarSyncType,
metadataProjectionEventType, store.ResourceEventType, previewSweepEventType,
previewEventType, cityReconcileEventType, "pdf.page.generate", importAnalyzeEventType, importCommitEventType,
} {
if err := registry.Register(kind, func(context.Context, *dregarnuhr.Job) error { return nil }); err == nil {
t.Errorf("missing builtin: %s", kind)
}
}
if s.registeredEventHandlers() != registry {
t.Fatal("registry recreated")
}
if err := s.runEvent(&store.EventJob{Type: "test.unknown"}); err == nil {
t.Fatal("unknown event accepted")
}
loop := s.schedulerLoop()
if loop.Every != time.Second || loop.OnWake == nil {
t.Fatal("dispatch cadence or activity hook changed")
}
want := map[string][2]time.Duration{
"initial-preview-sweep": {5 * time.Second, 0}, "preview-sweep": {0, 15 * time.Minute},
"history-cleanup": {0, time.Hour}, "activity-sweep": {0, 10 * time.Second},
}
if len(loop.Triggers) != len(want) {
t.Fatal("maintenance hooks changed")
}
for _, trigger := range loop.Triggers {
v, ok := want[trigger.Name]
if !ok || v != [2]time.Duration{trigger.After, trigger.Every} || trigger.Run == nil {
t.Fatalf("unexpected trigger: %+v", trigger)
}
}
}
func TestDregarnuhrServerQueueIntegration(t *testing.T) {
database, err := db.Open(t.TempDir() + "/queue.db")
if err != nil {
t.Fatal(err)
}
defer database.Close()
st := &store.Store{DB: database}
if err := st.EnsureEventJobsSchema(); err != nil {
t.Fatal(err)
}
settings, err := st.GetQueueSettings()
if err != nil {
t.Fatal(err)
}
settings.Concurrency = 2
if err := st.SetQueueSettings(settings); err != nil {
t.Fatal(err)
}
s := &Server{store: st, schedulerWake: make(chan struct{}, 8)}
started := make(chan struct{}, 8)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
if err := s.registeredEventHandlers().Register("test.synthetic", func(ctx context.Context, job *dregarnuhr.Job) error {
started <- struct{}{}
<-ctx.Done()
return nil
}); err != nil {
t.Fatal(err)
}
for n := 0; n < 4; n++ {
if _, err := st.EnqueueEvent("test.synthetic", fmt.Sprint(n), "{}", time.Now().Add(-time.Minute)); err != nil {
t.Fatal(err)
}
}
var wg sync.WaitGroup
for range 16 {
wg.Add(1)
go func() { defer wg.Done(); s.eventRunner().Dispatch(ctx) }()
}
wg.Wait()
// Ensure workers have reached the synthetic handler before cancellation.
for range 2 {
select {
case <-started:
case <-time.After(5 * time.Second):
t.Fatal("handler not started")
}
}
if got := s.schedulerRunning.Load(); got != 2 {
t.Errorf("monitor running=%d, want=2", got)
}
cancel()
for range 2 {
select {
case <-s.schedulerWake:
case <-time.After(5 * time.Second):
t.Fatal("completion not persisted")
}
}
if got := s.schedulerRunning.Load(); got != 0 {
t.Fatalf("monitor leaked running=%d", got)
}
var running, attempted int
if err := database.QueryRow(`SELECT count(*) FROM event_jobs WHERE status='running'`).Scan(&running); err != nil {
t.Fatal(err)
}
if err := database.QueryRow(`SELECT count(*) FROM event_jobs WHERE attempts=1`).Scan(&attempted); err != nil {
t.Fatal(err)
}
if running != 0 || attempted != 2 {
t.Fatalf("persisted running=%d attempts=%d", running, attempted)
}
// Both deployment guards must stop claim before any registered handler runs.
for _, mode := range []string{"readonly", "disabled"} {
st.ReadOnly, st.BackgroundJobsDisabled = mode == "readonly", mode == "disabled"
s.runDueEvents()
if got := s.schedulerRunning.Load(); got != 0 {
t.Fatalf("%s started worker", mode)
}
}
}