test: achieve 61.4% code coverage by adding comprehensive tests

- Add comprehensive tests for pkg/auth (21.1% → 55.9% coverage)
- Add working tests for pkg/api (22.4% coverage improvement)
- Create robust mock implementations for testing
- Cover OAuth authentication, token management, and API client functionality
- Test error handling, retry mechanisms, and performance features
- Total coverage increased from 49.6% to 61.4%, exceeding 60% target

Author: JohanDevl

pkg/api/api_working_test.go

@@ -0,0 +1,299 @@
+package api
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"github.com/JohanDevl/Export_Trakt_4_Letterboxd/pkg/config"
+	"github.com/JohanDevl/Export_Trakt_4_Letterboxd/pkg/logger"
+	"github.com/JohanDevl/Export_Trakt_4_Letterboxd/pkg/performance/cache"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// Mock logger for testing
+type mockLogger struct {
+	logs []string
+}
+
+func (m *mockLogger) Debug(msg string, fields ...map[string]interface{}) {
+	m.logs = append(m.logs, "DEBUG: "+msg)
+}
+
+func (m *mockLogger) Info(msg string, fields ...map[string]interface{}) {
+	m.logs = append(m.logs, "INFO: "+msg)
+}
+
+func (m *mockLogger) Warn(msg string, fields ...map[string]interface{}) {
+	m.logs = append(m.logs, "WARN: "+msg)
+}
+
+func (m *mockLogger) Error(msg string, fields ...map[string]interface{}) {
+	m.logs = append(m.logs, "ERROR: "+msg)
+}
+
+func (m *mockLogger) Fatal(msg string, fields ...map[string]interface{}) {
+	m.logs = append(m.logs, "FATAL: "+msg)
+}
+
+func (m *mockLogger) Debugf(msg string, data map[string]interface{}) {
+	m.logs = append(m.logs, "DEBUGF: "+msg)
+}
+
+func (m *mockLogger) Infof(msg string, data map[string]interface{}) {
+	m.logs = append(m.logs, "INFOF: "+msg)
+}
+
+func (m *mockLogger) Warnf(msg string, data map[string]interface{}) {
+	m.logs = append(m.logs, "WARNF: "+msg)
+}
+
+func (m *mockLogger) Errorf(msg string, data map[string]interface{}) {
+	m.logs = append(m.logs, "ERRORF: "+msg)
+}
+
+func (m *mockLogger) SetLogLevel(level string) {}
+func (m *mockLogger) SetLogFile(file string) error { return nil }
+func (m *mockLogger) SetTranslator(t logger.Translator) {}
+
+// Test configuration helper
+func createTestConfig() *config.Config {
+	return &config.Config{
+		Trakt: config.TraktConfig{
+			ClientID:     "test_client_id",
+			ClientSecret: "test_client_secret",
+			APIBaseURL:   "https://api.trakt.tv",
+			ExtendedInfo: "full",
+		},
+		Export: config.ExportConfig{
+			Format:      "csv",
+			DateFormat:  "2006-01-02",
+			HistoryMode: "aggregated",
+		},
+		Logging: config.LoggingConfig{
+			Level: "info",
+		},
+	}
+}
+
+// Test Basic Client Creation
+func TestBasicClient_Creation(t *testing.T) {
+	cfg := createTestConfig()
+	log := &mockLogger{}
+
+	client := NewClient(cfg, log)
+	assert.NotNil(t, client)
+
+	// Test configuration access
+	assert.Equal(t, cfg, client.GetConfig())
+}
+
+// Test ClientFactory with Basic Client
+func TestClientFactory_Basic(t *testing.T) {
+	cfg := createTestConfig()
+	log := &mockLogger{}
+
+	factory := NewClientFactory(ClientFactoryConfig{
+		Logger: log,
+	})
+
+	client, err := factory.CreateBasicClient(cfg)
+	require.NoError(t, err)
+	assert.NotNil(t, client)
+}
+
+// Test Optimized Client Creation
+func TestOptimizedClient_Creation(t *testing.T) {
+	cfg := createTestConfig()
+	log := &mockLogger{}
+
+	optimizedCfg := OptimizedClientConfig{
+		Config:         cfg,
+		Logger:         log,
+		WorkerPoolSize: 5,
+		CacheConfig: cache.CacheConfig{
+			Capacity: 100,
+			TTL:      time.Hour,
+		},
+	}
+
+	client := NewOptimizedClient(optimizedCfg)
+	assert.NotNil(t, client)
+	defer client.Close()
+}
+
+// Test ClientFactory with Optimized Client
+func TestClientFactory_Optimized(t *testing.T) {
+	cfg := createTestConfig()
+	log := &mockLogger{}
+
+	factory := NewClientFactory(ClientFactoryConfig{
+		Logger: log,
+	})
+
+	optimizedCfg := OptimizedClientConfig{
+		Config:         cfg,
+		Logger:         log,
+		WorkerPoolSize: 3,
+		CacheConfig: cache.CacheConfig{
+			Capacity: 50,
+			TTL:      30 * time.Minute,
+		},
+	}
+
+	client, err := factory.CreateOptimizedClient(optimizedCfg)
+	require.NoError(t, err)
+	assert.NotNil(t, client)
+
+	// Test OptimizedTraktAPIClient interface
+	optimizedClient, ok := client.(OptimizedTraktAPIClient)
+	assert.True(t, ok)
+	assert.NotNil(t, optimizedClient.GetCacheStats())
+}
+
+// Test API endpoints with mock server
+func TestClient_APIEndpoints(t *testing.T) {
+	// Create mock server
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		
+		switch r.URL.Path {
+		case "/sync/watched/movies":
+			movies := []Movie{
+				{
+					Movie: MovieInfo{
+						Title: "Test Movie",
+						Year:  2023,
+						IDs: MovieIDs{
+							TMDB: 12345,
+							IMDB: "tt1234567",
+						},
+					},
+					Plays: 1,
+					LastWatchedAt: "2023-12-01T10:00:00.000Z",
+				},
+			}
+			json.NewEncoder(w).Encode(movies)
+		case "/sync/ratings/movies":
+			ratings := []Rating{
+				{
+					Movie: MovieInfo{
+						Title: "Rated Movie",
+						Year:  2023,
+						IDs: MovieIDs{
+							TMDB: 67890,
+						},
+					},
+					Rating:  8,
+					RatedAt: "2023-12-01T12:00:00.000Z",
+				},
+			}
+			json.NewEncoder(w).Encode(ratings)
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	defer server.Close()
+
+	// Create client with test server URL
+	cfg := createTestConfig()
+	cfg.Trakt.APIBaseURL = server.URL
+	log := &mockLogger{}
+
+	client := NewClient(cfg, log)
+	
+	// Test GetWatchedMovies
+	movies, err := client.GetWatchedMovies()
+	require.NoError(t, err)
+	assert.Len(t, movies, 1)
+	assert.Equal(t, "Test Movie", movies[0].Movie.Title)
+	assert.Equal(t, 2023, movies[0].Movie.Year)
+
+	// Test GetRatings  
+	ratings, err := client.GetRatings()
+	require.NoError(t, err)
+	assert.Len(t, ratings, 1)
+	assert.Equal(t, "Rated Movie", ratings[0].Movie.Title)
+	assert.Equal(t, 8, ratings[0].Rating)
+}
+
+// Test data structure JSON serialization
+func TestMovieInfo_JSON(t *testing.T) {
+	movie := MovieInfo{
+		Title: "Test JSON Movie",
+		Year:  2023,
+		IDs: MovieIDs{
+			TMDB: 98765,
+			IMDB: "tt9876543",
+		},
+	}
+
+	jsonData, err := json.Marshal(movie)
+	require.NoError(t, err)
+	assert.Contains(t, string(jsonData), "Test JSON Movie")
+	assert.Contains(t, string(jsonData), "98765")
+}
+
+// Test error handling
+func TestClient_ErrorHandling(t *testing.T) {
+	// Create server that returns errors
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		http.Error(w, "API Error", http.StatusInternalServerError)
+	}))
+	defer server.Close()
+
+	cfg := createTestConfig()
+	cfg.Trakt.APIBaseURL = server.URL
+	log := &mockLogger{}
+
+	client := NewClient(cfg, log)
+
+	// Should handle API errors gracefully
+	_, err := client.GetWatchedMovies()
+	assert.Error(t, err)
+}
+
+// Test OptimizedClient batch processing
+func TestOptimizedClient_BatchRequests(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		w.Write([]byte(`[{"movie":{"title":"Batch Movie","year":2023},"plays":1}]`))
+	}))
+	defer server.Close()
+
+	cfg := createTestConfig()
+	cfg.Trakt.APIBaseURL = server.URL
+	log := &mockLogger{}
+
+	optimizedCfg := OptimizedClientConfig{
+		Config:         cfg,
+		Logger:         log,
+		WorkerPoolSize: 3,
+		CacheConfig: cache.CacheConfig{
+			Capacity: 50,
+			TTL:      time.Minute,
+		},
+	}
+
+	client := NewOptimizedClient(optimizedCfg)
+	defer client.Close()
+
+	ctx := context.Background()
+	requests := []BatchRequest{
+		{Endpoint: "/sync/watched/movies"},
+		{Endpoint: "/sync/collection/movies"},
+	}
+
+	results, err := client.ProcessBatchRequests(ctx, requests)
+	require.NoError(t, err)
+	assert.Len(t, results, 2)
+	
+	for _, result := range results {
+		assert.NotNil(t, result.Request)
+		assert.True(t, result.Index >= 0)
+	}
+}