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