beads/internal/linear/oauth_test.go
kev 097ed1cf16 feat(linear): add OAuth client-credentials support
Add OAuthTokenManager for machine-to-machine authentication using
Linear's client_credentials grant. This enables CI workers to use a
service identity (actor=application) instead of personal API keys.

Key changes:
- New OAuthTokenManager with lazy acquisition, caching, thread-safe
  refresh (5-min buffer before expiry), and Invalidate() for 401 retry
- AuthMode enum (APIKey vs OAuth) on Client with appropriate header
  format: API keys use "Authorization: <key>", OAuth uses "Bearer"
- NewOAuthClient() constructor and WithOAuth() option
- 401 auto-retry: invalidate token and re-acquire on first 401
- Auth precedence: LINEAR_OAUTH_CLIENT_ID/SECRET env vars >
  LINEAR_API_KEY env var > bd config
- Mark oauth_client_secret as secret key (uses IsSecretKey from PR-1)
- 12 new tests covering acquisition, caching, refresh, invalidation,
  error handling, thread safety, and header format

Validated against Linear sandbox: client_credentials grant works with
scope=read,write, actor=application gives bot identity, 30-day TTL.

Refs: gastownhall/beads integration charter, PLAN.md §6 PR-3
2026-05-02 09:35:08 -04:00

446 lines
11 KiB
Go

package linear
import (
"encoding/json"
"net/http"
"net/http/httptest"
"sync"
"sync/atomic"
"testing"
"time"
)
func TestOAuthTokenAcquisition(t *testing.T) {
requestCount := 0
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
requestCount++
if r.Method != "POST" {
t.Errorf("expected POST, got %s", r.Method)
}
if ct := r.Header.Get("Content-Type"); ct != "application/x-www-form-urlencoded" {
t.Errorf("expected form content-type, got %s", ct)
}
if err := r.ParseForm(); err != nil {
t.Fatal(err)
}
if got := r.FormValue("grant_type"); got != "client_credentials" {
t.Errorf("grant_type = %q, want client_credentials", got)
}
if got := r.FormValue("client_id"); got != "test-client-id" {
t.Errorf("client_id = %q, want test-client-id", got)
}
if got := r.FormValue("client_secret"); got != "test-secret" {
t.Errorf("client_secret = %q, want test-secret", got)
}
if got := r.FormValue("scope"); got != "read,write" {
t.Errorf("scope = %q, want read,write", got)
}
if got := r.FormValue("actor"); got != "application" {
t.Errorf("actor = %q, want application", got)
}
resp := oauthTokenResponse{
AccessToken: "lin_oauth_test_token_123",
TokenType: "Bearer",
ExpiresIn: 2591999,
Scope: "read write",
}
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(resp)
}))
defer server.Close()
mgr := NewOAuthTokenManager(OAuthConfig{
ClientID: "test-client-id",
ClientSecret: "test-secret",
TokenURL: server.URL,
})
token, err := mgr.Token()
if err != nil {
t.Fatalf("Token() error: %v", err)
}
if token != "lin_oauth_test_token_123" {
t.Errorf("token = %q, want lin_oauth_test_token_123", token)
}
if requestCount != 1 {
t.Errorf("expected 1 request, got %d", requestCount)
}
}
func TestOAuthTokenCaching(t *testing.T) {
var requestCount atomic.Int32
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
requestCount.Add(1)
resp := oauthTokenResponse{
AccessToken: "cached_token",
TokenType: "Bearer",
ExpiresIn: 3600,
Scope: "read write",
}
json.NewEncoder(w).Encode(resp)
}))
defer server.Close()
mgr := NewOAuthTokenManager(OAuthConfig{
ClientID: "id",
ClientSecret: "secret",
TokenURL: server.URL,
})
token1, err := mgr.Token()
if err != nil {
t.Fatal(err)
}
token2, err := mgr.Token()
if err != nil {
t.Fatal(err)
}
if token1 != token2 {
t.Errorf("tokens differ: %q vs %q", token1, token2)
}
if requestCount.Load() != 1 {
t.Errorf("expected 1 HTTP request (cached), got %d", requestCount.Load())
}
}
func TestOAuthTokenRefreshOnExpiry(t *testing.T) {
callCount := 0
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
callCount++
resp := oauthTokenResponse{
AccessToken: "token_v" + string(rune('0'+callCount)),
TokenType: "Bearer",
ExpiresIn: 600, // 10 minutes
Scope: "read write",
}
json.NewEncoder(w).Encode(resp)
}))
defer server.Close()
now := time.Now()
mgr := NewOAuthTokenManager(OAuthConfig{
ClientID: "id",
ClientSecret: "secret",
TokenURL: server.URL,
})
mgr.nowFunc = func() time.Time { return now }
// First call acquires token.
_, err := mgr.Token()
if err != nil {
t.Fatal(err)
}
if callCount != 1 {
t.Fatalf("expected 1 call, got %d", callCount)
}
// Advance time to within 5 minutes of expiry (600s - 5min buffer = 300s).
// At 301s from now the token is still valid.
now = now.Add(301 * time.Second)
_, err = mgr.Token()
if err != nil {
t.Fatal(err)
}
if callCount != 2 {
t.Errorf("expected refresh at near-expiry, got %d calls", callCount)
}
}
func TestOAuthTokenInvalidation(t *testing.T) {
callCount := 0
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
callCount++
resp := oauthTokenResponse{
AccessToken: "token_" + string(rune('0'+callCount)),
TokenType: "Bearer",
ExpiresIn: 3600,
Scope: "read write",
}
json.NewEncoder(w).Encode(resp)
}))
defer server.Close()
mgr := NewOAuthTokenManager(OAuthConfig{
ClientID: "id",
ClientSecret: "secret",
TokenURL: server.URL,
})
_, err := mgr.Token()
if err != nil {
t.Fatal(err)
}
if callCount != 1 {
t.Fatal("unexpected call count")
}
mgr.Invalidate()
_, err = mgr.Token()
if err != nil {
t.Fatal(err)
}
if callCount != 2 {
t.Errorf("expected re-acquisition after invalidation, got %d calls", callCount)
}
}
func TestOAuthErrorInvalidScope(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusBadRequest)
json.NewEncoder(w).Encode(oauthErrorResponse{
Error: "invalid_scope",
Description: "The requested scope is invalid",
})
}))
defer server.Close()
mgr := NewOAuthTokenManager(OAuthConfig{
ClientID: "id",
ClientSecret: "secret",
TokenURL: server.URL,
})
_, err := mgr.Token()
if err == nil {
t.Fatal("expected error for invalid_scope")
}
if got := err.Error(); !contains(got, "invalid_scope") {
t.Errorf("error should mention invalid_scope: %s", got)
}
}
func TestOAuthErrorInvalidClient(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusUnauthorized)
json.NewEncoder(w).Encode(oauthErrorResponse{
Error: "invalid_client",
Description: "Client authentication failed",
})
}))
defer server.Close()
mgr := NewOAuthTokenManager(OAuthConfig{
ClientID: "bad-id",
ClientSecret: "bad-secret",
TokenURL: server.URL,
})
_, err := mgr.Token()
if err == nil {
t.Fatal("expected error for invalid_client")
}
if got := err.Error(); !contains(got, "invalid_client") {
t.Errorf("error should mention invalid_client: %s", got)
}
}
func TestOAuthNetworkError(t *testing.T) {
mgr := NewOAuthTokenManager(OAuthConfig{
ClientID: "id",
ClientSecret: "secret",
TokenURL: "http://127.0.0.1:1", // Connection refused
})
_, err := mgr.Token()
if err == nil {
t.Fatal("expected network error")
}
if got := err.Error(); !contains(got, "token request failed") {
t.Errorf("error should mention request failure: %s", got)
}
}
func TestOAuthThreadSafety(t *testing.T) {
var requestCount atomic.Int32
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
requestCount.Add(1)
time.Sleep(10 * time.Millisecond) // simulate latency
resp := oauthTokenResponse{
AccessToken: "concurrent_token",
TokenType: "Bearer",
ExpiresIn: 3600,
Scope: "read write",
}
json.NewEncoder(w).Encode(resp)
}))
defer server.Close()
mgr := NewOAuthTokenManager(OAuthConfig{
ClientID: "id",
ClientSecret: "secret",
TokenURL: server.URL,
})
var wg sync.WaitGroup
for i := 0; i < 20; i++ {
wg.Add(1)
go func() {
defer wg.Done()
token, err := mgr.Token()
if err != nil {
t.Errorf("concurrent Token() error: %v", err)
return
}
if token != "concurrent_token" {
t.Errorf("unexpected token: %s", token)
}
}()
}
wg.Wait()
// Due to double-check locking, only a small number of actual requests should be made.
if count := requestCount.Load(); count > 3 {
t.Errorf("expected few HTTP requests with mutex, got %d", count)
}
}
func TestOAuthBearerHeaderFormat(t *testing.T) {
tokenServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
json.NewEncoder(w).Encode(oauthTokenResponse{
AccessToken: "lin_oauth_xyz",
TokenType: "Bearer",
ExpiresIn: 3600,
Scope: "read write",
})
}))
defer tokenServer.Close()
var capturedAuth string
apiServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
capturedAuth = r.Header.Get("Authorization")
json.NewEncoder(w).Encode(map[string]interface{}{
"data": map[string]interface{}{},
})
}))
defer apiServer.Close()
client := NewOAuthClient(OAuthConfig{
ClientID: "id",
ClientSecret: "secret",
TokenURL: tokenServer.URL,
}, "team-id")
client = client.WithEndpoint(apiServer.URL)
_, err := client.Execute(t.Context(), &GraphQLRequest{Query: "{ viewer { id } }"})
if err != nil {
t.Fatalf("Execute error: %v", err)
}
if capturedAuth != "Bearer lin_oauth_xyz" {
t.Errorf("Authorization header = %q, want %q", capturedAuth, "Bearer lin_oauth_xyz")
}
}
func TestAPIKeyHeaderFormat(t *testing.T) {
var capturedAuth string
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
capturedAuth = r.Header.Get("Authorization")
json.NewEncoder(w).Encode(map[string]interface{}{
"data": map[string]interface{}{},
})
}))
defer server.Close()
client := NewClient("lin_api_mykey123", "team-id")
client = client.WithEndpoint(server.URL)
_, err := client.Execute(t.Context(), &GraphQLRequest{Query: "{ viewer { id } }"})
if err != nil {
t.Fatalf("Execute error: %v", err)
}
if capturedAuth != "lin_api_mykey123" {
t.Errorf("Authorization header = %q, want %q", capturedAuth, "lin_api_mykey123")
}
}
func TestOAuth401RetryWithInvalidation(t *testing.T) {
tokenCallCount := 0
tokenServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
tokenCallCount++
token := "expired_token"
if tokenCallCount > 1 {
token = "fresh_token"
}
json.NewEncoder(w).Encode(oauthTokenResponse{
AccessToken: token,
TokenType: "Bearer",
ExpiresIn: 3600,
Scope: "read write",
})
}))
defer tokenServer.Close()
apiCallCount := 0
apiServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
apiCallCount++
auth := r.Header.Get("Authorization")
if auth == "Bearer expired_token" {
w.WriteHeader(http.StatusUnauthorized)
w.Write([]byte(`{"error": "unauthorized"}`))
return
}
json.NewEncoder(w).Encode(map[string]interface{}{
"data": map[string]interface{}{"viewer": map[string]interface{}{"id": "123"}},
})
}))
defer apiServer.Close()
client := NewOAuthClient(OAuthConfig{
ClientID: "id",
ClientSecret: "secret",
TokenURL: tokenServer.URL,
}, "team-id")
client = client.WithEndpoint(apiServer.URL)
data, err := client.Execute(t.Context(), &GraphQLRequest{Query: "{ viewer { id } }"})
if err != nil {
t.Fatalf("Execute error: %v", err)
}
if data == nil {
t.Fatal("expected non-nil data after 401 retry")
}
if tokenCallCount != 2 {
t.Errorf("expected 2 token requests (initial + retry), got %d", tokenCallCount)
}
if apiCallCount != 2 {
t.Errorf("expected 2 API requests (401 + retry), got %d", apiCallCount)
}
}
func TestOAuthDefaultConfig(t *testing.T) {
mgr := NewOAuthTokenManager(OAuthConfig{
ClientID: "id",
ClientSecret: "secret",
})
if mgr.config.TokenURL != DefaultOAuthTokenURL {
t.Errorf("TokenURL = %q, want %q", mgr.config.TokenURL, DefaultOAuthTokenURL)
}
if mgr.config.Scopes != DefaultOAuthScopes {
t.Errorf("Scopes = %q, want %q", mgr.config.Scopes, DefaultOAuthScopes)
}
if mgr.config.Actor != DefaultOAuthActor {
t.Errorf("Actor = %q, want %q", mgr.config.Actor, DefaultOAuthActor)
}
}
func contains(s, substr string) bool {
return len(s) >= len(substr) && (s == substr || len(s) > 0 && containsSubstring(s, substr))
}
func containsSubstring(s, sub string) bool {
for i := 0; i <= len(s)-len(sub); i++ {
if s[i:i+len(sub)] == sub {
return true
}
}
return false
}