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