add token manager construct tests

Author: ndyakov

entraid.go

@@ -1 +1,10 @@
 package entraid
+
+const (
+	DefaultExpirationRefreshRatio        = 0.7
+	DefaultRetryOptionsMaxAttempts       = 3
+	DefaultRetryOptionsInitialDelayMs    = 1000
+	DefaultRetryOptionsBackoffMultiplier = 2.0
+	DefaultRetryOptionsMaxDelayMs        = 10000
+	MinTokenTTL                          = 60 * 1000 // 1 minute
+)

entraid_test.go

@@ -0,0 +1,19 @@
+package entraid
+
+import (
+	"github.com/stretchr/testify/mock"
+)
+
+type mockIdentityProvider struct {
+	// Mock implementation of the IdentityProvider interface
+	// Add any necessary fields or methods for the mock identity provider here
+	mock.Mock
+}
+
+func (m *mockIdentityProvider) RequestToken() (IdentityProviderResponse, error) {
+	args := m.Called()
+	return args.Get(0).(IdentityProviderResponse), args.Error(1)
+}
+
+// Ensure mockIdentityProvider implements the IdentityProvider interface
+var _ IdentityProvider = (*mockIdentityProvider)(nil)

go.mod

@@ -11,6 +11,7 @@ require (
 require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/stretchr/objx v0.5.2 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
 

go.sum

@@ -26,6 +26,8 @@ github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZN
 github.com/redis/go-redis/v9 v9.5.3-0.20250331212737-c248425ade4a h1:R5xgk8m+CF7lVE0EGr+tLkT1eM3Zfd39BJfnANQqpKA=
 github.com/redis/go-redis/v9 v9.5.3-0.20250331212737-c248425ade4a/go.mod h1:huWgSWd8mW6+m0VPhJjSSQ+d6Nh1VICQ6Q5lHuCH/Iw=
 github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8=
+github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=
+github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
 github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
 github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 golang.org/x/crypto v0.33.0 h1:IOBPskki6Lysi0lo9qQvbxiQ+FvsCC/YWOecCHAixus=

token_manager.go

@@ -11,8 +11,6 @@ import (
 	"github.com/golang-jwt/jwt/v5"
 )
 
-const MinTokenTTL = 30 * time.Minute
-
 // TokenManagerOptions is a struct that contains the options for the TokenManager.
 type TokenManagerOptions struct {
 	// ExpirationRefreshRatio is the ratio of the token expiration time to refresh the token.
@@ -62,12 +60,10 @@ type RetryOptions struct {
 	//
 	// default: 1000 ms
 	InitialDelayMs int
-
 	// MaxDelayMs is the maximum delay in milliseconds between retry attempts.
 	//
 	// default: 10000 ms
 	MaxDelayMs int
-
 	// BackoffMultiplier is the multiplier for the backoff delay.
 	// default: 2.0
 	BackoffMultiplier float64
@@ -143,7 +139,7 @@ var defaultIdentityProviderResponseParser = func(response IdentityProviderRespon
 		return nil, fmt.Errorf("expires on is in the past")
 	}
 	if time.Until(expiresOn) < MinTokenTTL {
-		return nil, fmt.Errorf("expires on is less than minimum token TTL")
+		return nil, fmt.Errorf("expires on is less than minimum token TTL which is %d", MinTokenTTL)
 	}
 	// parse token as jwt token and get claims
 
@@ -162,10 +158,10 @@ var defaultIdentityProviderResponseParser = func(response IdentityProviderRespon
 // The IdentityProvider is used to obtain the token, and the TokenManagerOptions contains options for the TokenManager.
 // The TokenManager is responsible for managing the token and refreshing it when necessary.
 func NewTokenManager(idp IdentityProvider, options TokenManagerOptions) (TokenManager, error) {
-	options = defaultTokenManagerOptionsOr(options)
-	if options.ExpirationRefreshRatio <= 0 || options.ExpirationRefreshRatio > 1 {
+	if options.ExpirationRefreshRatio < 0 || options.ExpirationRefreshRatio > 1 {
 		return nil, fmt.Errorf("expiration refresh ratio must be between 0 and 1")
 	}
+	options = defaultTokenManagerOptionsOr(options)
 
 	if idp == nil {
 		return nil, fmt.Errorf("identity provider is required")
@@ -397,16 +393,16 @@ func defaultRetryOptionsOr(retryOptions RetryOptions) RetryOptions {
 	}
 
 	if retryOptions.MaxAttempts <= 0 {
-		retryOptions.MaxAttempts = 3
+		retryOptions.MaxAttempts = DefaultRetryOptionsMaxAttempts
 	}
 	if retryOptions.InitialDelayMs == 0 {
-		retryOptions.InitialDelayMs = 1000
+		retryOptions.InitialDelayMs = DefaultRetryOptionsInitialDelayMs
 	}
 	if retryOptions.BackoffMultiplier == 0 {
-		retryOptions.BackoffMultiplier = 2.0
+		retryOptions.BackoffMultiplier = DefaultRetryOptionsBackoffMultiplier
 	}
 	if retryOptions.MaxDelayMs == 0 {
-		retryOptions.MaxDelayMs = 10000
+		retryOptions.MaxDelayMs = DefaultRetryOptionsMaxDelayMs
 	}
 	return retryOptions
 }
@@ -424,8 +420,8 @@ func defaultIdentityProviderResponseParserOr(idpResponseParser IdentityProviderR
 func defaultTokenManagerOptionsOr(options TokenManagerOptions) TokenManagerOptions {
 	options.RetryOptions = defaultRetryOptionsOr(options.RetryOptions)
 	options.IdentityProviderResponseParser = defaultIdentityProviderResponseParserOr(options.IdentityProviderResponseParser)
-	if options.ExpirationRefreshRatio <= 0 || options.ExpirationRefreshRatio > 1 {
-		options.ExpirationRefreshRatio = 0.7
+	if options.ExpirationRefreshRatio == 0 {
+		options.ExpirationRefreshRatio = DefaultExpirationRefreshRatio
 	}
 	return options
 }

token_manager_test.go

@@ -0,0 +1,77 @@
+package entraid
+
+import (
+	"reflect"
+	"runtime"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+var assertFuncNameMatches = func(t *testing.T, func1, func2 interface{}) {
+	funcName1 := runtime.FuncForPC(reflect.ValueOf(func1).Pointer()).Name()
+	funcName2 := runtime.FuncForPC(reflect.ValueOf(func2).Pointer()).Name()
+	assert.Equal(t, funcName1, funcName2)
+}
+
+func TestTokenManager(t *testing.T) {
+	t.Parallel()
+	t.Run("Without IDP", func(t *testing.T) {
+		tokenManager, err := NewTokenManager(nil,
+			TokenManagerOptions{},
+		)
+		assert.Error(t, err)
+		assert.Nil(t, tokenManager)
+	})
+
+	t.Run("With IDP", func(t *testing.T) {
+		idp := &mockIdentityProvider{}
+		tokenManager, err := NewTokenManager(idp,
+			TokenManagerOptions{},
+		)
+		assert.NoError(t, err)
+		assert.NotNil(t, tokenManager)
+	})
+}
+
+func TestTokenManagerWithOptions(t *testing.T) {
+	t.Parallel()
+	t.Run("Bad Expiration Refresh Ration", func(t *testing.T) {
+		idp := &mockIdentityProvider{}
+		options := TokenManagerOptions{
+			ExpirationRefreshRatio: 5,
+		}
+		tokenManager, err := NewTokenManager(idp, options)
+		assert.Error(t, err)
+		assert.Nil(t, tokenManager)
+	})
+	t.Run("With IDP and Options", func(t *testing.T) {
+		idp := &mockIdentityProvider{}
+		options := TokenManagerOptions{
+			ExpirationRefreshRatio: 0.5,
+		}
+		tokenManager, err := NewTokenManager(idp, options)
+		assert.NoError(t, err)
+		assert.NotNil(t, tokenManager)
+		tm, ok := tokenManager.(*entraidTokenManager)
+		assert.True(t, ok)
+		assert.Equal(t, 0.5, tm.expirationRefreshRatio)
+	})
+	t.Run("Default Options", func(t *testing.T) {
+		idp := &mockIdentityProvider{}
+		options := TokenManagerOptions{}
+		tokenManager, err := NewTokenManager(idp, options)
+		assert.NoError(t, err)
+		assert.NotNil(t, tokenManager)
+		tm, ok := tokenManager.(*entraidTokenManager)
+		assert.True(t, ok)
+		assert.Equal(t, DefaultExpirationRefreshRatio, tm.expirationRefreshRatio)
+		assert.NotNil(t, tm.retryOptions.IsRetryable)
+		assertFuncNameMatches(t, tm.retryOptions.IsRetryable, defaultRetryableFunc)
+		assert.Equal(t, DefaultRetryOptionsMaxAttempts, tm.retryOptions.MaxAttempts)
+		assert.Equal(t, DefaultRetryOptionsInitialDelayMs, tm.retryOptions.InitialDelayMs)
+		assert.Equal(t, DefaultRetryOptionsMaxDelayMs, tm.retryOptions.MaxDelayMs)
+		assert.Equal(t, DefaultRetryOptionsBackoffMultiplier, tm.retryOptions.BackoffMultiplier)
+
+	})
+}