beads/internal/github/client_ratelimit_test.go
Sean Brandt b78a62cf10
github: classify rate-limit 403s and stop the push loop when one hits (#3624)
Fix-merged for release prep: preserved the contributor rate-limit handling and added the maintainer fix to avoid sleeping after the final retry attempt. Auto-merge after CI.
2026-05-02 14:24:57 -07:00

190 lines
6.5 KiB
Go

package github
import (
"context"
"errors"
"net/http"
"net/http/httptest"
"strconv"
"strings"
"sync/atomic"
"testing"
"time"
)
func newRateLimitTestClient(baseURL string) *Client {
c := NewClient("test-token", "owner", "repo")
c.BaseURL = strings.TrimSuffix(baseURL, "/")
return c
}
func fastRetryTestClient(baseURL string) *Client {
c := newRateLimitTestClient(baseURL)
c.Retry = RetryConfig{
MaxRetries: 3,
BaseDelay: 5 * time.Millisecond,
SecondaryMinDelay: 50 * time.Millisecond,
MaxBackoff: time.Second,
}
return c
}
// A 403 with no rate-limit signal is auth, not transient — return immediately
// as *AuthError instead of retrying and burying the cause.
func TestDoRequest_Auth403_DoesNotRetry(t *testing.T) {
var attempts int32
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
atomic.AddInt32(&attempts, 1)
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusForbidden)
_, _ = w.Write([]byte(`{"message":"Bad credentials","documentation_url":"https://docs.github.com/rest"}`))
}))
defer srv.Close()
c := newRateLimitTestClient(srv.URL)
_, _, err := c.doRequest(context.Background(), http.MethodGet, srv.URL+"/repos/owner/repo/issues", nil)
if err == nil {
t.Fatal("expected auth error, got nil")
}
if got := atomic.LoadInt32(&attempts); got != 1 {
t.Errorf("expected 1 attempt for auth-403, got %d", got)
}
var authErr *AuthError
if !errors.As(err, &authErr) {
t.Errorf("expected *AuthError, got %T: %v", err, err)
}
if !strings.Contains(err.Error(), "Bad credentials") {
t.Errorf("error should preserve GitHub message, got: %v", err)
}
}
// A 403 with X-RateLimit-Remaining=0 must sleep until X-RateLimit-Reset, not
// fall back to the client's own exponential backoff.
func TestDoRequest_Primary403_HonorsResetHeader(t *testing.T) {
// X-RateLimit-Reset is whole-seconds Unix epoch; pick a reset far enough
// out that seconds-precision rounding doesn't put it in the past.
resetAt := time.Now().Add(1500 * time.Millisecond)
var attempts int32
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
n := atomic.AddInt32(&attempts, 1)
w.Header().Set("Content-Type", "application/json")
w.Header().Set("X-RateLimit-Limit", "5000")
w.Header().Set("X-RateLimit-Remaining", "0")
w.Header().Set("X-RateLimit-Reset", strconv.FormatInt(resetAt.Unix(), 10))
w.Header().Set("X-RateLimit-Resource", "core")
if n == 1 {
w.WriteHeader(http.StatusForbidden)
_, _ = w.Write([]byte(`{"message":"API rate limit exceeded for user ID 12345."}`))
return
}
w.Header().Set("X-RateLimit-Remaining", "4999")
w.WriteHeader(http.StatusOK)
_, _ = w.Write([]byte(`{"login":"octocat"}`))
}))
defer srv.Close()
c := fastRetryTestClient(srv.URL)
// Force exponential backoff to a no-op so only ResetAt could explain the wait.
c.Retry.BaseDelay = time.Microsecond
c.Retry.SecondaryMinDelay = time.Microsecond
start := time.Now()
body, _, err := c.doRequest(context.Background(), http.MethodGet, srv.URL+"/user", nil)
elapsed := time.Since(start)
if err != nil {
t.Fatalf("expected success after retry, got %v", err)
}
if !strings.Contains(string(body), "octocat") {
t.Errorf("expected octocat in body, got %s", body)
}
if got := atomic.LoadInt32(&attempts); got != 2 {
t.Errorf("expected 2 attempts, got %d", got)
}
if elapsed < 400*time.Millisecond {
t.Errorf("expected to sleep until reset (~1s), slept %v", elapsed)
}
}
// A 403 whose body mentions "secondary rate limit" without a Retry-After must
// produce a typed *RateLimitError and respect SecondaryMinDelay between retries.
func TestDoRequest_Secondary403_ReturnsTypedErrorWithMinDelay(t *testing.T) {
var attempts int32
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
atomic.AddInt32(&attempts, 1)
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusForbidden)
_, _ = w.Write([]byte(`{"message":"You have exceeded a secondary rate limit. Please wait a few minutes before you try again."}`))
}))
defer srv.Close()
c := fastRetryTestClient(srv.URL)
start := time.Now()
_, _, err := c.doRequest(context.Background(), http.MethodPost, srv.URL+"/repos/owner/repo/issues", map[string]string{"title": "x"})
elapsed := time.Since(start)
if err == nil {
t.Fatal("expected rate-limit error, got nil")
}
wantAttempts := int32(c.Retry.MaxRetries + 1)
if got := atomic.LoadInt32(&attempts); got != wantAttempts {
t.Errorf("expected %d attempts, got %d", wantAttempts, got)
}
var rlErr *RateLimitError
if !errors.As(err, &rlErr) {
t.Fatalf("expected *RateLimitError, got %T: %v", err, err)
}
if rlErr.Kind != RateLimitSecondary {
t.Errorf("expected Kind=RateLimitSecondary, got %v", rlErr.Kind)
}
if !strings.Contains(rlErr.Error(), "secondary rate limit") {
t.Errorf("error should preserve GitHub message, got: %v", rlErr)
}
if min := 3 * c.Retry.SecondaryMinDelay; elapsed < min {
t.Errorf("elapsed %v below SecondaryMinDelay floor %v", elapsed, min)
}
}
// When the final retry attempt also hits a rate limit, return the typed
// *RateLimitError immediately instead of sleeping once more.
func TestDoRequest_RateLimitFinalAttemptDoesNotSleep(t *testing.T) {
var attempts int32
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
atomic.AddInt32(&attempts, 1)
w.Header().Set("Content-Type", "application/json")
w.Header().Set("Retry-After", "1")
w.WriteHeader(http.StatusForbidden)
_, _ = w.Write([]byte(`{"message":"You have exceeded a secondary rate limit. Please wait before you try again."}`))
}))
defer srv.Close()
c := fastRetryTestClient(srv.URL)
c.Retry.MaxRetries = 0
ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
defer cancel()
start := time.Now()
_, _, err := c.doRequest(ctx, http.MethodPost, srv.URL+"/repos/owner/repo/issues", map[string]string{"title": "x"})
elapsed := time.Since(start)
if err == nil {
t.Fatal("expected rate-limit error, got nil")
}
if got := atomic.LoadInt32(&attempts); got != 1 {
t.Errorf("expected 1 attempt, got %d", got)
}
var rlErr *RateLimitError
if !errors.As(err, &rlErr) {
t.Fatalf("expected *RateLimitError, got %T: %v", err, err)
}
if errors.Is(err, context.DeadlineExceeded) {
t.Fatalf("final attempt slept until context deadline instead of returning rate-limit error: %v", err)
}
if elapsed >= 100*time.Millisecond {
t.Errorf("final rate-limit attempt should return before context timeout, took %v", elapsed)
}
}