package main import ( "context" "errors" "sync" "testing" "time" ) type fakeClaimer struct { mu sync.Mutex calls []time.Time claimed [2]int err error } func (f *fakeClaimer) ClaimDueSourceRefreshes(_ context.Context, now time.Time) (int, int, error) { f.mu.Lock() defer f.mu.Unlock() f.calls = append(f.calls, now) if f.err != nil { return 0, 0, f.err } return f.claimed[0], f.claimed[1], nil } func TestRunSourceRefreshTickSurfacesErrors(t *testing.T) { claim := &fakeClaimer{claimed: [2]int{3, 2}} if err := runSourceRefreshTick(context.Background(), claim, time.Now()); err != nil { t.Fatal(err) } if len(claim.calls) != 1 { t.Fatalf("calls=%d want 1", len(claim.calls)) } sentinel := errors.New("boom") failing := &fakeClaimer{err: sentinel} if err := runSourceRefreshTick(context.Background(), failing, time.Now()); !errors.Is(err, sentinel) { t.Fatalf("error=%v want sentinel", err) } } func TestRunSourceRefreshSchedulerTicksAndStops(t *testing.T) { claim := &fakeClaimer{} ctx, cancel := context.WithCancel(context.Background()) done := make(chan struct{}) go func() { defer close(done) runSourceRefreshScheduler(ctx, claim, 10*time.Millisecond, nil) }() deadline := time.Now().Add(2 * time.Second) for time.Now().Before(deadline) { claim.mu.Lock() count := len(claim.calls) claim.mu.Unlock() if count >= 2 { break } time.Sleep(5 * time.Millisecond) } cancel() select { case <-done: case <-time.After(2 * time.Second): t.Fatal("scheduler did not stop on context cancel") } claim.mu.Lock() defer claim.mu.Unlock() if len(claim.calls) < 2 { t.Fatalf("calls=%d want at least 2", len(claim.calls)) } for _, stamp := range claim.calls { if stamp.Location() != time.UTC { t.Fatalf("tick stamp %v not UTC", stamp) } } } func TestRunSourceRefreshSchedulerSurvivesTickErrors(t *testing.T) { claim := &fakeClaimer{err: errors.New("database is offline")} var errorsSeen int var mu sync.Mutex ctx, cancel := context.WithCancel(context.Background()) done := make(chan struct{}) go func() { defer close(done) runSourceRefreshScheduler(ctx, claim, 10*time.Millisecond, func(error) { mu.Lock() errorsSeen++ mu.Unlock() }) }() deadline := time.Now().Add(2 * time.Second) for time.Now().Before(deadline) { mu.Lock() seen := errorsSeen mu.Unlock() if seen >= 2 { break } time.Sleep(5 * time.Millisecond) } cancel() <-done mu.Lock() defer mu.Unlock() if errorsSeen < 2 { t.Fatalf("errorsSeen=%d want >=2 (loop must not die on failures)", errorsSeen) } } func TestRunSourceRefreshSchedulerIgnoresNilClaims(t *testing.T) { // guards against misconfiguration killing the process runSourceRefreshScheduler(context.Background(), nil, time.Second, nil) runSourceRefreshScheduler(context.Background(), &fakeClaimer{}, 0, nil) }