* 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>
898 lines
27 KiB
Go
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.
|