Files
2026-11-15 05:47:14 +09:00

233 lines
5.9 KiB
Go

package dregarnuhr
import (
"context"
"errors"
"fmt"
"sync"
"testing"
"time"
)
type finishedJob struct {
id string
err error
at time.Time
}
func TestRunnerStopWaitsAndClosesAdmission(t *testing.T) {
q := newFakeQueue(1)
reg := &Registry{}
started := make(chan struct{})
cancelled := make(chan struct{})
exit := make(chan struct{})
if err := reg.Register("synthetic", func(ctx context.Context, _ *Job) error {
close(started)
<-ctx.Done()
close(cancelled)
<-exit // simulate cleanup that cannot be interrupted
return ctx.Err()
}); err != nil {
t.Fatal(err)
}
r := NewRunner(q, reg, RunnerOptions{})
r.Dispatch(context.Background())
receive(t, started)
ctx, cancel := context.WithCancel(context.Background())
cancel()
if err := r.Stop(ctx); !errors.Is(err, context.Canceled) {
t.Fatal(err)
}
receive(t, cancelled)
if r.Running() != 1 {
t.Fatal("worker exited before cleanup")
}
r.Dispatch(context.Background())
if q.claimed != 1 {
t.Fatal("admission remained open")
}
close(exit)
ctx, cancel = context.WithTimeout(context.Background(), time.Second)
defer cancel()
if err := r.Stop(ctx); err != nil {
t.Fatal(err)
}
receive(t, q.finished)
if r.Running() != 0 {
t.Fatal("worker slot retained after stop")
}
if err := r.Stop(ctx); err != nil {
t.Fatal("idempotent stop", err)
}
}
type fakeQueue struct {
mu sync.Mutex
settings Settings
jobs []Job
claimed int
cancelled bool
cancelErr error
finished chan finishedJob
claimAt time.Time
}
func newFakeQueue(concurrency int) *fakeQueue {
q := &fakeQueue{settings: Settings{Concurrency: concurrency}, finished: make(chan finishedJob, 100)}
for n := 0; n < 64; n++ {
q.jobs = append(q.jobs, Job{UUID: fmt.Sprint(n), Type: "synthetic"})
}
return q
}
func (q *fakeQueue) Settings(context.Context) (Settings, error) {
q.mu.Lock()
defer q.mu.Unlock()
return q.settings, nil
}
func (q *fakeQueue) Claim(_ context.Context, at time.Time) (*Job, error) {
q.mu.Lock()
defer q.mu.Unlock()
if len(q.jobs) == 0 {
return nil, ErrNoJob
}
j := q.jobs[0]
q.jobs = q.jobs[1:]
q.claimed++
q.claimAt = at
return &j, nil
}
func (q *fakeQueue) Cancellation(context.Context, string) (bool, error) {
q.mu.Lock()
defer q.mu.Unlock()
return q.cancelled, q.cancelErr
}
func (q *fakeQueue) Started(context.Context, *Job) error { return nil }
func (q *fakeQueue) Finish(ctx context.Context, j *Job, err error, at time.Time) error {
if ctx.Err() != nil {
return ctx.Err()
}
q.finished <- finishedJob{j.UUID, err, at}
return nil
}
func TestRunnerConcurrentAdmission(t *testing.T) {
for _, foreground := range []bool{false, true} {
t.Run(fmt.Sprint(foreground), func(t *testing.T) {
q := newFakeQueue(4)
reg := &Registry{}
block := make(chan struct{})
started := make(chan struct{}, 4)
wakes := make(chan struct{}, 4)
clock := newFakeClock()
defer close(block)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
if err := reg.Register("synthetic", func(ctx context.Context, _ *Job) error {
started <- struct{}{}
select {
case <-ctx.Done():
return ctx.Err()
case <-block:
return nil
}
}); err != nil {
t.Fatal(err)
}
r := NewRunner(q, reg, RunnerOptions{Clock: clock, Foreground: func() bool { return foreground }, Wake: func() { wakes <- struct{}{} }})
var wg sync.WaitGroup
for n := 0; n < 16; n++ {
wg.Add(1)
go func() { defer wg.Done(); r.Dispatch(ctx) }()
}
wg.Wait()
want := 4
if foreground {
want = 1
}
for n := 0; n < want; n++ {
receive(t, started)
}
if r.Running() != int64(want) || q.claimed != want || !q.claimAt.Equal(clock.Now()) {
t.Fatalf("active=%d claimed=%d want=%d", r.Running(), q.claimed, want)
}
cancel()
for n := 0; n < want; n++ {
receive(t, q.finished)
receive(t, wakes)
}
if r.Running() != 0 {
t.Fatal("worker slots leaked")
}
})
}
}
func TestRunnerOutcomesAndCancellation(t *testing.T) {
for _, mode := range []string{"success", "cancel-before", "cancel-after", "cancellation-read-error", "panic", "unknown", "failure"} {
t.Run(mode, func(t *testing.T) {
q := newFakeQueue(1)
q.jobs = q.jobs[:1]
q.cancelled = mode == "cancel-before"
if mode == "cancellation-read-error" {
q.cancelErr = errors.New("database unavailable")
}
reg := &Registry{}
called := false
if mode != "unknown" {
if err := reg.Register("synthetic", func(context.Context, *Job) error {
called = true
if mode == "panic" {
panic("sensitive panic payload")
}
if mode == "failure" {
return errors.New("handler failure")
}
if mode == "cancel-after" {
q.mu.Lock()
q.cancelled = true
q.mu.Unlock()
}
return nil
}); err != nil {
t.Fatal(err)
}
}
wakes := make(chan struct{}, 1)
clock := newFakeClock()
r := NewRunner(q, reg, RunnerOptions{Clock: clock, Wake: func() { wakes <- struct{}{} }})
r.Dispatch(context.Background())
out := receive(t, q.finished)
receive(t, wakes)
if (out.err == nil) != (mode == "success") {
t.Fatal(mode, out.err)
}
if (mode == "cancel-before" || mode == "cancellation-read-error") && called {
t.Fatal("handler ran without cancellation check")
}
if mode == "panic" && out.err.Error() != "event handler panicked" {
t.Fatal("panic payload leaked")
}
if r.Running() != 0 || !out.at.Equal(clock.Now()) {
t.Fatal("completion/clock failure")
}
})
}
}
func TestRegistryAndPausedRunner(t *testing.T) {
r := &Registry{}
h := func(context.Context, *Job) error { return nil }
if r.Register("", h) == nil || r.Register("nil", nil) == nil {
t.Fatal("invalid registration")
}
if r.Register("synthetic", h) != nil || r.Register("synthetic", h) == nil {
t.Fatal("duplicate replaced")
}
q := newFakeQueue(3)
q.settings.Paused = true
NewRunner(q, r, RunnerOptions{}).Dispatch(context.Background())
if q.claimed != 0 {
t.Fatal("paused claim")
}
}