beads/internal/linear/client_test.go
Kevin Glynn 50b0617405
fix(linear): arm rate-limit breaker after successful calls (#4778)
* fix(linear): arm rate-limit breaker after successful calls

Co-authored-by: Medhaug <Medhaug@users.noreply.github.com>

* fix(linear): expire rate limit breaker after reset

Agent-Signature: codex-gpt-5.6-sol-medium on behalf of matt wilkie

* fix(linear): parse reset header as epoch milliseconds

Agent-Signature: codex-gpt-5.6-sol-medium on behalf of matt wilkie

* fix(linear): require valid reset to arm breaker

Agent-Signature: codex-gpt-5.6-sol-medium on behalf of matt wilkie

* fix(linear): bound rate limit reset horizon

Agent-Signature: codex-gpt-5.6-sol-medium on behalf of matt wilkie

* test(linear): send valid reset header so breaker arms in reconcile mock

The breaker arming contract now requires a valid future
X-RateLimit-Requests-Reset alongside low remaining quota (48b0c6725).
The parent-reconcile mock only sent the remaining header, so the
breaker never armed and TestReconcileParents_AbortsOnRateLimit got no
abort error.

Co-authored-by: Cursor <cursoragent@cursor.com>

---------

Co-authored-by: Cursor Agent <cursoragent@cursor.com>
Co-authored-by: Medhaug <Medhaug@users.noreply.github.com>
Co-authored-by: matt wilkie <maphew@gmail.com>
2026-07-14 13:13:52 -07:00

898 lines
27 KiB
Go

package linear
import (
"context"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"net/http/httptest"
"strconv"
"strings"
"testing"
"time"
)
func TestCanonicalizeLinearExternalRef(t *testing.T) {
tests := []struct {
name string
externalRef string
want string
ok bool
}{
{
name: "slugged url",
externalRef: "https://linear.app/crown-dev/issue/BEA-93/updated-title-for-beads",
want: "https://linear.app/crown-dev/issue/BEA-93",
ok: true,
},
{
name: "canonical url",
externalRef: "https://linear.app/crown-dev/issue/BEA-93",
want: "https://linear.app/crown-dev/issue/BEA-93",
ok: true,
},
{
name: "not linear",
externalRef: "https://example.com/issues/BEA-93",
want: "",
ok: false,
},
}
for _, tt := range tests {
got, ok := CanonicalizeLinearExternalRef(tt.externalRef)
if ok != tt.ok {
t.Fatalf("%s: ok=%v, want %v", tt.name, ok, tt.ok)
}
if got != tt.want {
t.Fatalf("%s: got %q, want %q", tt.name, got, tt.want)
}
}
}
func TestNewClient(t *testing.T) {
client := NewClient("test-api-key", "test-team-id")
if client.APIKey != "test-api-key" {
t.Errorf("APIKey = %q, want %q", client.APIKey, "test-api-key")
}
if client.TeamID != "test-team-id" {
t.Errorf("TeamID = %q, want %q", client.TeamID, "test-team-id")
}
if client.Endpoint != DefaultAPIEndpoint {
t.Errorf("Endpoint = %q, want %q", client.Endpoint, DefaultAPIEndpoint)
}
if client.HTTPClient == nil {
t.Error("HTTPClient should not be nil")
}
}
func TestWithEndpoint(t *testing.T) {
client := NewClient("key", "team")
customEndpoint := "https://custom.linear.app/graphql"
newClient := client.WithEndpoint(customEndpoint)
if newClient.Endpoint != customEndpoint {
t.Errorf("Endpoint = %q, want %q", newClient.Endpoint, customEndpoint)
}
// Original should be unchanged
if client.Endpoint != DefaultAPIEndpoint {
t.Errorf("Original endpoint changed: %q", client.Endpoint)
}
// Other fields preserved
if newClient.APIKey != "key" {
t.Errorf("APIKey not preserved: %q", newClient.APIKey)
}
}
func TestWithHTTPClient(t *testing.T) {
client := NewClient("key", "team")
customHTTPClient := &http.Client{Timeout: 60 * time.Second}
newClient := client.WithHTTPClient(customHTTPClient)
if newClient.HTTPClient != customHTTPClient {
t.Error("HTTPClient not set correctly")
}
// Other fields preserved
if newClient.APIKey != "key" {
t.Errorf("APIKey not preserved: %q", newClient.APIKey)
}
if newClient.Endpoint != DefaultAPIEndpoint {
t.Errorf("Endpoint not preserved: %q", newClient.Endpoint)
}
}
func TestExtractLinearIdentifier(t *testing.T) {
tests := []struct {
name string
externalRef string
want string
}{
{
name: "standard URL",
externalRef: "https://linear.app/team/issue/PROJ-123",
want: "PROJ-123",
},
{
name: "URL with slug",
externalRef: "https://linear.app/team/issue/PROJ-456/some-title-here",
want: "PROJ-456",
},
{
name: "URL with trailing slash",
externalRef: "https://linear.app/team/issue/ABC-789/",
want: "ABC-789",
},
{
name: "non-linear URL",
externalRef: "https://jira.example.com/browse/PROJ-123",
want: "",
},
{
name: "empty string",
externalRef: "",
want: "",
},
{
name: "malformed URL",
externalRef: "not-a-url",
want: "",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got := ExtractLinearIdentifier(tt.externalRef)
if got != tt.want {
t.Errorf("ExtractLinearIdentifier(%q) = %q, want %q", tt.externalRef, got, tt.want)
}
})
}
}
func TestIsLinearExternalRef(t *testing.T) {
tests := []struct {
ref string
want bool
}{
{"https://linear.app/team/issue/PROJ-123", true},
{"https://linear.app/team/issue/PROJ-123/slug", true},
{"https://jira.example.com/browse/PROJ-123", false},
{"https://github.com/org/repo/issues/123", false},
{"", false},
}
for _, tt := range tests {
t.Run(tt.ref, func(t *testing.T) {
got := IsLinearExternalRef(tt.ref)
if got != tt.want {
t.Errorf("IsLinearExternalRef(%q) = %v, want %v", tt.ref, got, tt.want)
}
})
}
}
func TestBatchCreateIssues_SingleBatch(t *testing.T) {
mutationCount := 0
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
mutationCount++
body, _ := io.ReadAll(r.Body)
var req GraphQLRequest
if err := json.Unmarshal(body, &req); err != nil {
t.Fatalf("failed to unmarshal request: %v", err)
}
if !strings.Contains(req.Query, "issueBatchCreate") {
t.Fatalf("expected issueBatchCreate mutation, got: %s", req.Query)
}
// Validate the correct GraphQL variable shape: IssueBatchCreateInput
// wraps the array in an "issues" field.
if !strings.Contains(req.Query, "IssueBatchCreateInput!") {
t.Fatalf("mutation must declare $input as IssueBatchCreateInput!, got: %s", req.Query)
}
inputWrapper, ok := req.Variables["input"].(map[string]interface{})
if !ok {
t.Fatal("expected input variable to be an object with 'issues' field")
}
inputArr, ok := inputWrapper["issues"].([]interface{})
if !ok {
t.Fatal("expected input.issues to be an array")
}
issues := make([]Issue, 0)
for i := range inputArr {
issues = append(issues, Issue{
ID: fmt.Sprintf("id-%d", i),
Identifier: fmt.Sprintf("TEAM-%d", i+1),
Title: fmt.Sprintf("Issue %d", i+1),
URL: fmt.Sprintf("https://linear.app/team/issue/TEAM-%d", i+1),
})
}
resp := map[string]interface{}{
"data": map[string]interface{}{
"issueBatchCreate": map[string]interface{}{
"success": true,
"issues": issues,
},
},
}
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(resp)
}))
defer server.Close()
client := NewClient("test-key", "test-team").WithEndpoint(server.URL)
inputs := make([]IssueCreateInput, 50)
for i := range inputs {
inputs[i] = IssueCreateInput{
TeamID: "test-team",
Title: fmt.Sprintf("Issue %d", i+1),
}
}
issues, err := client.BatchCreateIssues(context.Background(), inputs)
if err != nil {
t.Fatalf("BatchCreateIssues failed: %v", err)
}
if mutationCount != 1 {
t.Errorf("expected 1 mutation call, got %d", mutationCount)
}
if len(issues) != 50 {
t.Errorf("expected 50 issues, got %d", len(issues))
}
}
func TestBatchCreateIssues_Chunking(t *testing.T) {
mutationCount := 0
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
mutationCount++
body, _ := io.ReadAll(r.Body)
var req GraphQLRequest
json.Unmarshal(body, &req)
inputWrapper := req.Variables["input"].(map[string]interface{})
inputs := inputWrapper["issues"].([]interface{})
issues := make([]Issue, len(inputs))
for i := range inputs {
issues[i] = Issue{
ID: fmt.Sprintf("id-%d-%d", mutationCount, i),
Identifier: fmt.Sprintf("TEAM-%d", i+1),
Title: fmt.Sprintf("Issue %d", i+1),
URL: fmt.Sprintf("https://linear.app/team/issue/TEAM-%d", i+1),
}
}
resp := map[string]interface{}{
"data": map[string]interface{}{
"issueBatchCreate": map[string]interface{}{
"success": true,
"issues": issues,
},
},
}
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(resp)
}))
defer server.Close()
client := NewClient("test-key", "test-team").WithEndpoint(server.URL)
inputs := make([]IssueCreateInput, 120)
for i := range inputs {
inputs[i] = IssueCreateInput{
TeamID: "test-team",
Title: fmt.Sprintf("Issue %d", i+1),
}
}
issues, err := client.BatchCreateIssues(context.Background(), inputs)
if err != nil {
t.Fatalf("BatchCreateIssues failed: %v", err)
}
if mutationCount != 3 {
t.Errorf("expected 3 batch calls (50+50+20), got %d", mutationCount)
}
if len(issues) != 120 {
t.Errorf("expected 120 issues, got %d", len(issues))
}
}
// TestBatchCreateIssues_AmbiguousFailureSearchesMarkers verifies that on batch
// failure (success=false), the client searches for idempotency markers to find
// which issues were partially created, instead of blindly retrying the full chunk.
func TestBatchCreateIssues_AmbiguousFailureSearchesMarkers(t *testing.T) {
var searchCount int
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
body, _ := io.ReadAll(r.Body)
var req GraphQLRequest
json.Unmarshal(body, &req)
w.Header().Set("Content-Type", "application/json")
if strings.Contains(req.Query, "issueBatchCreate") {
json.NewEncoder(w).Encode(map[string]interface{}{
"data": map[string]interface{}{
"issueBatchCreate": map[string]interface{}{
"success": false,
"issues": []Issue{},
},
},
})
return
}
if strings.Contains(req.Query, "FindByDescription") {
searchCount++
// Simulate: first issue was partially created, second was not.
filter := req.Variables["filter"].(map[string]interface{})
desc := filter["description"].(map[string]interface{})
searchText := desc["contains"].(string)
if strings.Contains(searchText, "marker-a") {
json.NewEncoder(w).Encode(map[string]interface{}{
"data": map[string]interface{}{
"issues": map[string]interface{}{
"nodes": []interface{}{
map[string]interface{}{
"id": "found-uuid", "identifier": "TEAM-1",
"title": "Issue A", "url": "https://linear.app/team/issue/TEAM-1",
"priority": 0, "createdAt": "2026-01-01T00:00:00Z", "updatedAt": "2026-01-01T00:00:00Z",
},
},
"pageInfo": map[string]interface{}{"hasNextPage": false, "endCursor": ""},
},
},
})
} else {
json.NewEncoder(w).Encode(map[string]interface{}{
"data": map[string]interface{}{
"issues": map[string]interface{}{
"nodes": []interface{}{},
"pageInfo": map[string]interface{}{"hasNextPage": false, "endCursor": ""},
},
},
})
}
return
}
}))
defer server.Close()
client := NewClient("test-key", "test-team").WithEndpoint(server.URL)
markerA := "<!-- bd-idempotency: marker-a -->"
markerB := "<!-- bd-idempotency: marker-b -->"
inputs := []IssueCreateInput{
{TeamID: "test-team", Title: "Issue A", Description: "desc\n" + markerA},
{TeamID: "test-team", Title: "Issue B", Description: "desc\n" + markerB},
}
issues, err := client.BatchCreateIssues(context.Background(), inputs)
// Should get an error about unconfirmed issues, but not panic or do a blind retry.
if err == nil {
t.Fatal("expected error about unconfirmed issues after ambiguous batch failure")
}
if !strings.Contains(err.Error(), "unconfirmed") {
t.Errorf("expected 'unconfirmed' in error, got: %v", err)
}
// Issue A was found via marker search.
if len(issues) != 1 {
t.Errorf("expected 1 recovered issue, got %d", len(issues))
}
if searchCount != 2 {
t.Errorf("expected 2 marker searches, got %d", searchCount)
}
}
// TestBatchCreateIssues_NoMarkersReturnsError verifies that if batch inputs have
// no idempotency markers and the batch fails, no blind retry occurs.
func TestBatchCreateIssues_NoMarkersReturnsError(t *testing.T) {
var singleCreateCalled bool
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
body, _ := io.ReadAll(r.Body)
var req GraphQLRequest
json.Unmarshal(body, &req)
w.Header().Set("Content-Type", "application/json")
if strings.Contains(req.Query, "issueBatchCreate") {
json.NewEncoder(w).Encode(map[string]interface{}{
"data": map[string]interface{}{
"issueBatchCreate": map[string]interface{}{
"success": false,
"issues": []Issue{},
},
},
})
return
}
if strings.Contains(req.Query, "issueCreate") {
singleCreateCalled = true
}
}))
defer server.Close()
client := NewClient("test-key", "test-team").WithEndpoint(server.URL)
inputs := []IssueCreateInput{
{TeamID: "test-team", Title: "No Marker Issue", Description: "plain description"},
}
_, err := client.BatchCreateIssues(context.Background(), inputs)
if err == nil {
t.Fatal("expected error when batch fails with no markers for recovery")
}
if singleCreateCalled {
t.Error("single-issue create should NOT be called as blind fallback")
}
}
func TestBatchUpdateIssues_Chunking(t *testing.T) {
mutationCount := 0
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
mutationCount++
body, _ := io.ReadAll(r.Body)
var req GraphQLRequest
json.Unmarshal(body, &req)
ids := req.Variables["ids"].([]interface{})
issues := make([]Issue, len(ids))
for i, id := range ids {
issues[i] = Issue{
ID: id.(string),
Identifier: fmt.Sprintf("TEAM-%d", i+1),
URL: fmt.Sprintf("https://linear.app/team/issue/TEAM-%d", i+1),
}
}
resp := map[string]interface{}{
"data": map[string]interface{}{
"issueBatchUpdate": map[string]interface{}{
"success": true,
"issues": issues,
},
},
}
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(resp)
}))
defer server.Close()
client := NewClient("test-key", "test-team").WithEndpoint(server.URL)
ids := make([]string, 120)
for i := range ids {
ids[i] = fmt.Sprintf("uuid-%d", i)
}
updates := map[string]interface{}{"stateId": "done-state-id"}
issues, err := client.BatchUpdateIssues(context.Background(), ids, updates)
if err != nil {
t.Fatalf("BatchUpdateIssues failed: %v", err)
}
if mutationCount != 3 {
t.Errorf("expected 3 batch calls (50+50+20), got %d", mutationCount)
}
if len(issues) != 120 {
t.Errorf("expected 120 issues, got %d", len(issues))
}
}
func TestBatchCreateIssues_Empty(t *testing.T) {
client := NewClient("test-key", "test-team")
issues, err := client.BatchCreateIssues(context.Background(), nil)
if err != nil {
t.Fatalf("expected no error for empty input, got: %v", err)
}
if issues != nil {
t.Errorf("expected nil result for empty input, got %d issues", len(issues))
}
}
func TestBatchUpdateIssues_Empty(t *testing.T) {
client := NewClient("test-key", "test-team")
issues, err := client.BatchUpdateIssues(context.Background(), nil, map[string]interface{}{"title": "x"})
if err != nil {
t.Fatalf("expected no error for empty input, got: %v", err)
}
if issues != nil {
t.Errorf("expected nil result for empty input, got %d issues", len(issues))
}
}
func TestParseRetryAfter(t *testing.T) {
tests := []struct {
name string
value string
wantExact time.Duration // used when non-zero
wantPos bool // just check > 0 (for HTTP-date forms)
}{
{name: "integer seconds", value: "30", wantExact: 30 * time.Second},
{name: "zero", value: "0", wantExact: 0},
{name: "negative", value: "-5", wantExact: 0},
{name: "empty", value: "", wantExact: 0},
{name: "non-numeric", value: "abc", wantExact: 0},
// HTTP-date form (RFC 1123): a timestamp in the future should yield a positive delay.
{name: "http-date future", value: time.Now().Add(2 * time.Minute).UTC().Format(http.TimeFormat), wantPos: true},
// HTTP-date form in the past should yield zero.
{name: "http-date past", value: time.Now().Add(-1 * time.Minute).UTC().Format(http.TimeFormat), wantExact: 0},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got := parseRetryAfter(tt.value)
if tt.wantPos {
if got <= 0 {
t.Errorf("parseRetryAfter(%q) = %v, want > 0", tt.value, got)
}
return
}
if got != tt.wantExact {
t.Errorf("parseRetryAfter(%q) = %v, want %v", tt.value, got, tt.wantExact)
}
})
}
}
func TestParseRateLimitHeaders(t *testing.T) {
t.Run("all headers present", func(t *testing.T) {
h := http.Header{}
h.Set("Retry-After", "45")
h.Set("X-RateLimit-Requests-Remaining", "80")
h.Set("X-RateLimit-Requests-Reset", "1767225600000")
info := parseRateLimitHeaders(h)
if info.RetryAfter != 45*time.Second {
t.Errorf("RetryAfter = %v, want 45s", info.RetryAfter)
}
if info.RequestsRemaining != 80 {
t.Errorf("RequestsRemaining = %d, want 80", info.RequestsRemaining)
}
wantReset := time.Date(2026, time.January, 1, 0, 0, 0, 0, time.UTC)
if !info.RequestsReset.Equal(wantReset) {
t.Errorf("RequestsReset = %v, want %v", info.RequestsReset, wantReset)
}
})
t.Run("no headers", func(t *testing.T) {
info := parseRateLimitHeaders(http.Header{})
if info.RetryAfter != 0 {
t.Errorf("RetryAfter = %v, want 0", info.RetryAfter)
}
if info.RequestsRemaining != -1 {
t.Errorf("RequestsRemaining = %d, want -1", info.RequestsRemaining)
}
if !info.RequestsReset.IsZero() {
t.Errorf("RequestsReset should be zero, got %v", info.RequestsReset)
}
})
for _, value := range []string{"not-a-timestamp", "-1", "9223372036854775808"} {
t.Run("invalid reset "+value, func(t *testing.T) {
h := http.Header{}
h.Set("X-RateLimit-Requests-Reset", value)
if got := parseRateLimitHeaders(h).RequestsReset; !got.IsZero() {
t.Errorf("RequestsReset = %v, want zero", got)
}
})
}
}
// mockServer returns an httptest.Server and a function to set the handler per request.
func mockServer(t *testing.T, handler http.HandlerFunc) *httpTestServer {
t.Helper()
s := &httpTestServer{}
s.Server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
s.requestCount++
handler(w, r)
}))
t.Cleanup(s.Server.Close)
return s
}
type httpTestServer struct {
Server *httptest.Server
requestCount int
}
func TestExecute_RetryAfterHeader(t *testing.T) {
attempt := 0
srv := mockServer(t, func(w http.ResponseWriter, r *http.Request) {
attempt++
if attempt == 1 {
w.Header().Set("Retry-After", "1")
w.WriteHeader(http.StatusTooManyRequests)
return
}
w.WriteHeader(http.StatusOK)
_, _ = w.Write([]byte(`{"data":{"ok":true}}`))
})
client := NewClient("key", "team").WithEndpoint(srv.Server.URL)
ctx := context.Background()
data, err := client.Execute(ctx, &GraphQLRequest{Query: "{ viewer { id } }"})
if err != nil {
t.Fatalf("Execute returned error: %v", err)
}
if data == nil {
t.Fatal("Execute returned nil data")
}
if srv.requestCount != 2 {
t.Errorf("expected 2 requests (1 retry), got %d", srv.requestCount)
}
}
func TestExecute_NoRetryAfterFallsBackToExponential(t *testing.T) {
attempt := 0
srv := mockServer(t, func(w http.ResponseWriter, r *http.Request) {
attempt++
if attempt == 1 {
w.WriteHeader(http.StatusTooManyRequests)
return
}
w.WriteHeader(http.StatusOK)
_, _ = w.Write([]byte(`{"data":{"ok":true}}`))
})
client := NewClient("key", "team").WithEndpoint(srv.Server.URL)
ctx := context.Background()
start := time.Now()
data, err := client.Execute(ctx, &GraphQLRequest{Query: "{ viewer { id } }"})
elapsed := time.Since(start)
if err != nil {
t.Fatalf("Execute returned error: %v", err)
}
if data == nil {
t.Fatal("Execute returned nil data")
}
// First attempt exponential backoff: RetryDelay * 2^0 = 1s, plus up to 500ms jitter.
// Should be at least ~1s but we allow some slack.
if elapsed < 800*time.Millisecond {
t.Errorf("expected exponential backoff of ~1s, got %v", elapsed)
}
}
func TestExecute_CircuitBreakerTripsOnSubsequentRequest(t *testing.T) {
requestCount := 0
resetAt := strconv.FormatInt(time.Now().Add(time.Hour).UnixMilli(), 10)
srv := mockServer(t, func(w http.ResponseWriter, r *http.Request) {
requestCount++
w.Header().Set("X-RateLimit-Requests-Remaining", "50")
w.Header().Set("X-RateLimit-Requests-Reset", resetAt)
w.WriteHeader(http.StatusOK)
_, _ = w.Write([]byte(`{"data":{"ok":true}}`))
})
client := NewClient("key", "team").WithEndpoint(srv.Server.URL)
ctx := context.Background()
data, err := client.Execute(ctx, &GraphQLRequest{Query: "{ viewer { id } }"})
if err != nil {
t.Fatalf("first Execute returned error: %v", err)
}
if data == nil {
t.Fatal("first Execute returned nil data")
}
clone := client.WithProjectID("project-id")
_, err = clone.Execute(ctx, &GraphQLRequest{Query: "{ viewer { id } }"})
if err == nil {
t.Fatal("expected ErrRateLimitExhausted, got nil")
}
var rlErr *ErrRateLimitExhausted
if !errors.As(err, &rlErr) {
t.Fatalf("expected ErrRateLimitExhausted, got %T: %v", err, err)
}
if rlErr.Remaining != 50 {
t.Errorf("Remaining = %d, want 50", rlErr.Remaining)
}
if rlErr.Floor != DefaultRateLimitFloor {
t.Errorf("Floor = %d, want %d", rlErr.Floor, DefaultRateLimitFloor)
}
if requestCount != 1 {
t.Errorf("requestCount = %d, want 1 (second call should trip locally)", requestCount)
}
}
func TestExecute_CircuitBreakerAllowsRequestAfterResetThenRearms(t *testing.T) {
requestCount := 0
pastReset := strconv.FormatInt(time.Now().Add(-time.Hour).UnixMilli(), 10)
futureReset := strconv.FormatInt(time.Now().Add(time.Hour).UnixMilli(), 10)
srv := mockServer(t, func(w http.ResponseWriter, r *http.Request) {
requestCount++
w.Header().Set("X-RateLimit-Requests-Remaining", "50")
if requestCount == 1 {
w.Header().Set("X-RateLimit-Requests-Reset", pastReset)
} else {
w.Header().Set("X-RateLimit-Requests-Reset", futureReset)
}
w.WriteHeader(http.StatusOK)
_, _ = w.Write([]byte(`{"data":{"ok":true}}`))
})
client := NewClient("key", "team").WithEndpoint(srv.Server.URL)
ctx := context.Background()
request := &GraphQLRequest{Query: "{ viewer { id } }"}
if _, err := client.Execute(ctx, request); err != nil {
t.Fatalf("first Execute returned error: %v", err)
}
if _, err := client.WithRateLimitFloor(DefaultRateLimitFloor).Execute(ctx, request); err != nil {
t.Fatalf("Execute after reset returned error: %v", err)
}
if _, err := client.Execute(ctx, request); err == nil {
t.Fatal("expected re-armed breaker to block after future reset was recorded")
}
if requestCount != 2 {
t.Errorf("requestCount = %d, want 2 (expired breaker should allow one request, then re-arm)", requestCount)
}
}
func TestExecute_CircuitBreakerRequiresValidFutureReset(t *testing.T) {
futureReset := strconv.FormatInt(time.Now().Add(maxRateLimitResetHorizon-time.Hour).UnixMilli(), 10)
beyondHorizon := strconv.FormatInt(time.Now().Add(maxRateLimitResetHorizon+time.Minute).UnixMilli(), 10)
tests := []struct {
name string
reset string
wantArmed bool
}{
{name: "missing reset"},
{name: "malformed reset", reset: "not-a-timestamp"},
{name: "overflow reset", reset: "9223372036854775808"},
{name: "negative reset", reset: "-1"},
{name: "maximum int64 reset", reset: "9223372036854775807"},
{name: "reset beyond maximum horizon", reset: beyondHorizon},
{name: "valid reset near maximum horizon", reset: futureReset, wantArmed: true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
requestCount := 0
srv := mockServer(t, func(w http.ResponseWriter, r *http.Request) {
requestCount++
w.Header().Set("X-RateLimit-Requests-Remaining", "50")
if tt.reset != "" {
w.Header().Set("X-RateLimit-Requests-Reset", tt.reset)
}
w.WriteHeader(http.StatusOK)
_, _ = w.Write([]byte(`{"data":{"ok":true}}`))
})
client := NewClient("key", "team").WithEndpoint(srv.Server.URL)
request := &GraphQLRequest{Query: "{ viewer { id } }"}
if data, err := client.Execute(context.Background(), request); err != nil {
t.Fatalf("first Execute returned error: %v", err)
} else if data == nil {
t.Fatal("first Execute returned nil data")
}
_, err := client.WithProjectID("project-id").Execute(context.Background(), request)
if tt.wantArmed && err == nil {
t.Fatal("expected valid future reset to arm breaker")
}
if !tt.wantArmed && err != nil {
t.Fatalf("invalid reset permanently armed breaker: %v", err)
}
wantRequests := 2
if tt.wantArmed {
wantRequests = 1
}
if requestCount != wantRequests {
t.Errorf("requestCount = %d, want %d", requestCount, wantRequests)
}
})
}
}
func TestExecute_CircuitBreakerAllowsAboveFloor(t *testing.T) {
srv := mockServer(t, func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("X-RateLimit-Requests-Remaining", "200")
w.WriteHeader(http.StatusOK)
_, _ = w.Write([]byte(`{"data":{"ok":true}}`))
})
client := NewClient("key", "team").WithEndpoint(srv.Server.URL)
ctx := context.Background()
data, err := client.Execute(ctx, &GraphQLRequest{Query: "{ viewer { id } }"})
if err != nil {
t.Fatalf("Execute returned error: %v", err)
}
if data == nil {
t.Fatal("Execute returned nil data")
}
}
func TestExecute_CircuitBreakerCustomFloor(t *testing.T) {
srv := mockServer(t, func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("X-RateLimit-Requests-Remaining", "80")
w.WriteHeader(http.StatusOK)
_, _ = w.Write([]byte(`{"data":{"ok":true}}`))
})
client := NewClient("key", "team").WithEndpoint(srv.Server.URL).WithRateLimitFloor(50)
ctx := context.Background()
data, err := client.Execute(ctx, &GraphQLRequest{Query: "{ viewer { id } }"})
if err != nil {
t.Fatalf("Execute with custom floor returned error: %v", err)
}
if data == nil {
t.Fatal("Execute returned nil data")
}
}
func TestExecute_NoRateLimitHeaders(t *testing.T) {
srv := mockServer(t, func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
_, _ = w.Write([]byte(`{"data":{"ok":true}}`))
})
client := NewClient("key", "team").WithEndpoint(srv.Server.URL)
ctx := context.Background()
data, err := client.Execute(ctx, &GraphQLRequest{Query: "{ viewer { id } }"})
if err != nil {
t.Fatalf("Execute returned error: %v", err)
}
if data == nil {
t.Fatal("Execute returned nil data")
}
}
func TestWithRateLimitFloor(t *testing.T) {
client := NewClient("key", "team")
c2 := client.WithRateLimitFloor(42)
if c2.RateLimitFloor != 42 {
t.Errorf("RateLimitFloor = %d, want 42", c2.RateLimitFloor)
}
if c2.APIKey != "key" {
t.Errorf("APIKey not preserved: %q", c2.APIKey)
}
if client.RateLimitFloor != 0 {
t.Errorf("original RateLimitFloor changed: %d", client.RateLimitFloor)
}
}
// TestExecute_RetryAfterCapApplied verifies that a Retry-After delay exceeding
// MaxRetryAfterDelay is capped rather than honoured in full.
func TestExecute_RetryAfterCapApplied(t *testing.T) {
attempt := 0
srv := mockServer(t, func(w http.ResponseWriter, r *http.Request) {
attempt++
if attempt == 1 {
// Claim the server wants us to wait 1 hour — should be capped to MaxRetryAfterDelay.
w.Header().Set("Retry-After", "3600")
w.WriteHeader(http.StatusTooManyRequests)
return
}
w.WriteHeader(http.StatusOK)
_, _ = w.Write([]byte(`{"data":{"ok":true}}`))
})
client := NewClient("key", "team").WithEndpoint(srv.Server.URL)
ctx, cancel := context.WithTimeout(context.Background(), MaxRetryAfterDelay+5*time.Second)
defer cancel()
start := time.Now()
// We can't wait 300 s in a unit test; cancel via context immediately after
// the first request confirms the cap is being applied. The practical test is
// that this does NOT block for an hour.
//
// Strategy: use a short-lived context so Execute returns quickly (context
// cancelled while sleeping), confirming the cap path was taken (otherwise
// the 429 would have used the 1-hour server hint).
ctxShort, cancelShort := context.WithTimeout(ctx, 200*time.Millisecond)
defer cancelShort()
_, err := client.Execute(ctxShort, &GraphQLRequest{Query: "{ viewer { id } }"})
elapsed := time.Since(start)
// We expect a context-cancelled error, not a 1-hour sleep.
if elapsed >= time.Hour {
t.Fatalf("Retry-After cap not applied: waited %v (should have been capped)", elapsed)
}
if err == nil {
t.Fatal("expected error (context cancelled during capped sleep), got nil")
}
}
// Note: BuildStateCache and FindStateForBeadsStatus require API calls
// and would need mocking to test. Skipping unit tests for those.