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.
136 lines
4.1 KiB
Go
136 lines
4.1 KiB
Go
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)
|
|
}
|
|
}
|
|
}
|