fix: avoid spurious token refresh callback on first Token() call

NewCallbackTokenSource now accepts an initialToken parameter to seed
lastToken, so the callback only fires when the token actually changes.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: gonzolino

client.go

@@ -32,7 +32,7 @@ func newClient(ctx context.Context, config *oauth2.Config, token *oauth2.Token)
 // The callback will be invoked whenever the OAuth2 token is automatically refreshed.
 func newClientWithCallback(ctx context.Context, config *oauth2.Config, token *oauth2.Token, callback TokenRefreshCallback) *client {
 	tokenSrc := config.TokenSource(ctx, token)
-	callbackTokenSrc := NewCallbackTokenSource(tokenSrc, callback)
+	callbackTokenSrc := NewCallbackTokenSource(tokenSrc, callback, token)
 
 	return &client{
 		http: oauth2.NewClient(ctx, callbackTokenSrc),

tokensource.go

@@ -96,10 +96,15 @@ func (cts *callbackTokenSource) Token() (*oauth2.Token, error) {
 //	}
 //
 //	tado := gotado.NewWithTokenRefreshCallback(ctx, config, token, callback)
-func NewCallbackTokenSource(src oauth2.TokenSource, callback TokenRefreshCallback) oauth2.TokenSource {
+func NewCallbackTokenSource(src oauth2.TokenSource, callback TokenRefreshCallback, initialToken ...*oauth2.Token) oauth2.TokenSource {
+	var token *oauth2.Token
+	if len(initialToken) > 0 {
+		token = initialToken[0]
+	}
 	return &callbackTokenSource{
-		src:      src,
-		callback: callback,
+		src:       src,
+		callback:  callback,
+		lastToken: copyToken(token),
 	}
 }
 

tokensource_test.go

@@ -1,12 +1,97 @@
 package gotado
 
 import (
+	"sync/atomic"
 	"testing"
 	"time"
 
 	"golang.org/x/oauth2"
 )
 
+// staticTokenSource returns the same token every time.
+type staticTokenSource struct {
+	token *oauth2.Token
+}
+
+func (s *staticTokenSource) Token() (*oauth2.Token, error) {
+	return s.token, nil
+}
+
+func TestCallbackTokenSource(t *testing.T) {
+	t.Run("NoCallbackWhenTokenUnchanged", func(t *testing.T) {
+		token := &oauth2.Token{
+			AccessToken:  "access",
+			RefreshToken: "refresh",
+		}
+
+		var callCount atomic.Int32
+		callback := func(newToken *oauth2.Token) {
+			callCount.Add(1)
+		}
+
+		src := NewCallbackTokenSource(&staticTokenSource{token: token}, callback, token)
+
+		// First call should NOT trigger callback since token matches initialToken
+		_, err := src.Token()
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if callCount.Load() != 0 {
+			t.Errorf("callback should not fire when token unchanged, got %d calls", callCount.Load())
+		}
+	})
+
+	t.Run("CallbackWhenNilInitialToken", func(t *testing.T) {
+		token := &oauth2.Token{
+			AccessToken:  "access",
+			RefreshToken: "refresh",
+		}
+
+		var callCount atomic.Int32
+		callback := func(newToken *oauth2.Token) {
+			callCount.Add(1)
+		}
+
+		src := NewCallbackTokenSource(&staticTokenSource{token: token}, callback, nil)
+
+		// First call should trigger callback since initialToken is nil
+		_, err := src.Token()
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if callCount.Load() != 1 {
+			t.Errorf("callback should fire when initialToken is nil, got %d calls", callCount.Load())
+		}
+	})
+
+	t.Run("CallbackWhenTokenChanges", func(t *testing.T) {
+		initialToken := &oauth2.Token{
+			AccessToken:  "access1",
+			RefreshToken: "refresh1",
+		}
+		newToken := &oauth2.Token{
+			AccessToken:  "access2",
+			RefreshToken: "refresh2",
+		}
+
+		var callCount atomic.Int32
+		callback := func(token *oauth2.Token) {
+			callCount.Add(1)
+		}
+
+		src := NewCallbackTokenSource(&staticTokenSource{token: newToken}, callback, initialToken)
+
+		// Should trigger callback since source returns a different token
+		_, err := src.Token()
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if callCount.Load() != 1 {
+			t.Errorf("callback should fire when token changes, got %d calls", callCount.Load())
+		}
+	})
+}
+
 func TestCopyToken(t *testing.T) {
 	t.Run("NilToken", func(t *testing.T) {
 		copied := copyToken(nil)