Remove cached provider tests from foundation PR

Author: madhav-db

auth/tokenprovider/authenticator_test.go

@@ -104,32 +104,4 @@ func TestTokenProviderAuthenticator(t *testing.T) {
 		require.NoError(t, err)
 		assert.Equal(t, "Bearer external-token-456", req.Header.Get("Authorization"))
 	})
-
-	t.Run("cached_provider_integration", func(t *testing.T) {
-		callCount := 0
-		baseProvider := &mockProvider{
-			tokenFunc: func() (*Token, error) {
-				callCount++
-				return &Token{
-					AccessToken: "cached-token",
-					TokenType:   "Bearer",
-				}, nil
-			},
-			name: "test",
-		}
-
-		cachedProvider := NewCachedTokenProvider(baseProvider)
-		authenticator := NewAuthenticator(cachedProvider)
-
-		// Multiple authentication attempts
-		for i := 0; i < 3; i++ {
-			req, _ := http.NewRequest("GET", "http://example.com", nil)
-			err := authenticator.Authenticate(req)
-			require.NoError(t, err)
-			assert.Equal(t, "Bearer cached-token", req.Header.Get("Authorization"))
-		}
-
-		// Should only call base provider once due to caching
-		assert.Equal(t, 1, callCount)
-	})
 }

auth/tokenprovider/provider_test.go

@@ -4,8 +4,6 @@ import (
 	"context"
 	"errors"
 	"net/http"
-	"sync"
-	"sync/atomic"
 	"testing"
 	"time"
 
@@ -228,183 +226,6 @@ func TestExternalTokenProvider(t *testing.T) {
 	})
 }
 
-func TestCachedTokenProvider(t *testing.T) {
-	t.Run("caches_valid_token", func(t *testing.T) {
-		callCount := 0
-		baseProvider := &mockProvider{
-			tokenFunc: func() (*Token, error) {
-				callCount++
-				return &Token{
-					AccessToken: "cached-token",
-					TokenType:   "Bearer",
-					ExpiresAt:   time.Now().Add(1 * time.Hour),
-				}, nil
-			},
-			name: "mock",
-		}
-
-		cachedProvider := NewCachedTokenProvider(baseProvider)
-
-		// First call - should fetch from base provider
-		token1, err1 := cachedProvider.GetToken(context.Background())
-		require.NoError(t, err1)
-		assert.Equal(t, "cached-token", token1.AccessToken)
-		assert.Equal(t, 1, callCount)
-
-		// Second call - should use cache
-		token2, err2 := cachedProvider.GetToken(context.Background())
-		require.NoError(t, err2)
-		assert.Equal(t, "cached-token", token2.AccessToken)
-		assert.Equal(t, 1, callCount) // Should still be 1
-	})
-
-	t.Run("refreshes_expired_token", func(t *testing.T) {
-		callCount := 0
-		baseProvider := &mockProvider{
-			tokenFunc: func() (*Token, error) {
-				callCount++
-				// Return token that expires soon
-				return &Token{
-					AccessToken: "token-" + string(rune(callCount)),
-					TokenType:   "Bearer",
-					ExpiresAt:   time.Now().Add(2 * time.Minute), // Within refresh threshold
-				}, nil
-			},
-			name: "mock",
-		}
-
-		cachedProvider := NewCachedTokenProvider(baseProvider)
-		cachedProvider.RefreshThreshold = 5 * time.Minute
-
-		// First call
-		token1, err1 := cachedProvider.GetToken(context.Background())
-		require.NoError(t, err1)
-		assert.Equal(t, "token-\x01", token1.AccessToken)
-		assert.Equal(t, 1, callCount)
-
-		// Second call - should refresh because token expires within threshold
-		token2, err2 := cachedProvider.GetToken(context.Background())
-		require.NoError(t, err2)
-		assert.Equal(t, "token-\x02", token2.AccessToken)
-		assert.Equal(t, 2, callCount)
-	})
-
-	t.Run("handles_provider_error", func(t *testing.T) {
-		baseProvider := &mockProvider{
-			tokenFunc: func() (*Token, error) {
-				return nil, errors.New("provider error")
-			},
-			name: "mock",
-		}
-
-		cachedProvider := NewCachedTokenProvider(baseProvider)
-		token, err := cachedProvider.GetToken(context.Background())
-
-		assert.Error(t, err)
-		assert.Nil(t, token)
-		assert.Contains(t, err.Error(), "provider error")
-	})
-
-	t.Run("no_expiry_token_not_refreshed", func(t *testing.T) {
-		callCount := 0
-		baseProvider := &mockProvider{
-			tokenFunc: func() (*Token, error) {
-				callCount++
-				return &Token{
-					AccessToken: "permanent-token",
-					TokenType:   "Bearer",
-					ExpiresAt:   time.Time{}, // No expiry
-				}, nil
-			},
-			name: "mock",
-		}
-
-		cachedProvider := NewCachedTokenProvider(baseProvider)
-
-		// Multiple calls should all use cache
-		for i := 0; i < 5; i++ {
-			token, err := cachedProvider.GetToken(context.Background())
-			require.NoError(t, err)
-			assert.Equal(t, "permanent-token", token.AccessToken)
-		}
-
-		assert.Equal(t, 1, callCount) // Should only be called once
-	})
-
-	t.Run("clear_cache", func(t *testing.T) {
-		callCount := 0
-		baseProvider := &mockProvider{
-			tokenFunc: func() (*Token, error) {
-				callCount++
-				return &Token{
-					AccessToken: "token-" + string(rune(callCount)),
-					TokenType:   "Bearer",
-					ExpiresAt:   time.Now().Add(1 * time.Hour),
-				}, nil
-			},
-			name: "mock",
-		}
-
-		cachedProvider := NewCachedTokenProvider(baseProvider)
-
-		// First call
-		token1, _ := cachedProvider.GetToken(context.Background())
-		assert.Equal(t, "token-\x01", token1.AccessToken)
-		assert.Equal(t, 1, callCount)
-
-		// Clear cache
-		cachedProvider.ClearCache()
-
-		// Next call should fetch new token
-		token2, _ := cachedProvider.GetToken(context.Background())
-		assert.Equal(t, "token-\x02", token2.AccessToken)
-		assert.Equal(t, 2, callCount)
-	})
-
-	t.Run("concurrent_access", func(t *testing.T) {
-		var callCount atomic.Int32
-		baseProvider := &mockProvider{
-			tokenFunc: func() (*Token, error) {
-				// Simulate slow token fetch
-				time.Sleep(100 * time.Millisecond)
-				callCount.Add(1)
-				return &Token{
-					AccessToken: "concurrent-token",
-					TokenType:   "Bearer",
-					ExpiresAt:   time.Now().Add(1 * time.Hour),
-				}, nil
-			},
-			name: "mock",
-		}
-
-		cachedProvider := NewCachedTokenProvider(baseProvider)
-
-		// Launch multiple goroutines
-		var wg sync.WaitGroup
-		for i := 0; i < 10; i++ {
-			wg.Add(1)
-			go func() {
-				defer wg.Done()
-				token, err := cachedProvider.GetToken(context.Background())
-				assert.NoError(t, err)
-				assert.Equal(t, "concurrent-token", token.AccessToken)
-			}()
-		}
-
-		wg.Wait()
-
-		// Should only fetch token once despite concurrent access
-		assert.Equal(t, int32(1), callCount.Load())
-	})
-
-	t.Run("provider_name", func(t *testing.T) {
-		baseProvider := &mockProvider{name: "test-provider"}
-		cachedProvider := NewCachedTokenProvider(baseProvider)
-
-		assert.Equal(t, "cached[test-provider]", cachedProvider.Name())
-	})
-}
-
 // Mock provider for testing
 type mockProvider struct {
 	tokenFunc func() (*Token, error)