Files
pages/internal/server/dregarnuhr_queue_test.go
Anya Tokugawa d5d21b7841
Build and publish container images / images (push) Successful in 9m34s
Release container images / release (push) Successful in 36s
Refactor architecture into eight components and consolidate reliability work
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.
2026-11-01 15:23:31 +09:00

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)
}
}
}