Files
pages/internal/server/lifecycle_test.go
T
2026-11-15 05:47:14 +09:00

101 lines
2.4 KiB
Go

package server
import (
"context"
"errors"
"pageswiki/internal/db"
"pageswiki/internal/dregarnuhr"
"pageswiki/internal/store"
"testing"
"time"
)
func lifecycleFixture(t *testing.T) *store.Store {
t.Helper()
t.Chdir("../..")
database, err := db.Open(t.TempDir() + "/pages.db")
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { database.Close() })
if err = db.Migrate(database); err != nil {
t.Fatal(err)
}
s := store.NewWithDocumentRoot(database, t.TempDir()+"/documents")
if err = s.EnsureConfigTable(); err != nil {
t.Fatal(err)
}
return s
}
func TestServerCloseRetainsOwnershipUntilHandlersExit(t *testing.T) {
st := lifecycleFixture(t)
st.BackgroundJobsDisabled = true
s, err := NewChecked(st)
if err != nil {
t.Fatal(err)
}
// Admission is driven manually: avoid unrelated timed triggers in this test.
st.BackgroundJobsDisabled = false
released := make(chan struct{})
s.workerRelease = func() error { close(released); return nil }
started := make(chan struct{})
cancelled := make(chan struct{})
exit := make(chan struct{})
if err = s.registeredEventHandlers().Register("synthetic.stop", func(ctx context.Context, _ *dregarnuhr.Job) error {
close(started)
<-ctx.Done()
close(cancelled)
<-exit
return ctx.Err()
}); err != nil {
t.Fatal(err)
}
if _, err = st.EnqueueEvent("synthetic.stop", "one", "", time.Now()); err != nil {
t.Fatal(err)
}
s.eventRunner().Dispatch(s.backgroundCtx)
select {
case <-started:
case <-time.After(time.Second):
t.Fatal("handler not started")
}
ctx, cancel := context.WithCancel(context.Background())
cancel()
if err = s.Close(ctx); !errors.Is(err, context.Canceled) {
t.Fatal(err)
}
select {
case <-cancelled:
case <-time.After(time.Second):
t.Fatal("handler not cancelled")
}
select {
case <-released:
t.Fatal("ownership released while handler lives")
default:
}
close(exit)
ctx, cancel = context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
if err = s.Close(ctx); err != nil {
t.Fatal(err)
}
select {
case <-released:
default:
t.Fatal("ownership retained after stop")
}
}
func TestServerRefusesSchedulerInitializationFailure(t *testing.T) {
st := lifecycleFixture(t)
if _, err := st.DB.Exec(`DROP TABLE event_definitions`); err != nil {
t.Fatal(err)
}
s, err := NewChecked(st)
if err == nil || s != nil {
t.Fatal("partial server accepted", err)
}
}