go-garminconnect/internal/api/user_test.go

package api

import (
	"context"
	"fmt"
	"net/http"
	"testing"
	"time"

	"github.com/stretchr/testify/assert"
)

func TestGetUserProfile(t *testing.T) {
	// Define test cases
	tests := []struct {
		name          string
		mockResponse  interface{}
		mockStatus    int
		expected      *UserProfile
		expectedError string
	}{
		{
			name: "successful profile retrieval",
			mockResponse: map[string]interface{}{
				"displayName":          "John Doe",
				"fullName":             "John Michael Doe",
				"emailAddress":         "john.doe@example.com",
				"username":             "johndoe",
				"profileId":            "123456",
				"profileImageUrlLarge": "https://example.com/profile.jpg",
				"location":             "San Francisco, CA",
				"fitnessLevel":         "INTERMEDIATE",
				"height":               180.0,
				"weight":               75.0,
				"birthDate":            "1985-01-01",
			},
			mockStatus: http.StatusOK,
			expected: &UserProfile{
				DisplayName:  "John Doe",
				FullName:     "John Michael Doe",
				EmailAddress: "john.doe@example.com",
				Username:     "johndoe",
				ProfileID:    "123456",
				ProfileImage: "https://example.com/profile.jpg",
				Location:     "San Francisco, CA",
				FitnessLevel: "INTERMEDIATE",
				Height:       180.0,
				Weight:       75.0,
				Birthdate:    "1985-01-01",
			},
		},
		{
			name: "profile not found",
			mockResponse: map[string]interface{}{
				"error": "Profile not found",
			},
			mockStatus:    http.StatusNotFound,
			expectedError: "user profile not found",
		},
		{
			name: "invalid response format",
			mockResponse: map[string]interface{}{
				"invalid": "data",
			},
			mockStatus:    http.StatusOK,
			expectedError: "failed to parse user profile",
		},
		{
			name: "server error",
			mockResponse: map[string]interface{}{
				"error": "Internal server error",
			},
			mockStatus:    http.StatusInternalServerError,
			expectedError: "API request failed with status 500",
		},
	}

	// Create test server
	mockServer := NewMockServer()
	defer mockServer.Close()

	// Create client
	client := NewClientWithBaseURL(mockServer.URL)

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Configure mock server
			mockServer.Reset()
			mockServer.SetResponse("/userprofile-service/socialProfile", tt.mockStatus, tt.mockResponse)

			// Execute test
			profile, err := client.GetUserProfile(context.Background())

			// Assert results
			if tt.expectedError != "" {
				assert.Error(t, err)
				assert.Contains(t, err.Error(), tt.expectedError)
				assert.Nil(t, profile)
			} else {
				assert.NoError(t, err)
				assert.Equal(t, tt.expected, profile)
			}
		})
	}
}

// BenchmarkGetUserProfile measures performance of GetUserProfile method
func BenchmarkGetUserProfile(b *testing.B) {
	// Create test server
	mockServer := NewMockServer()
	defer mockServer.Close()

	// Setup successful response
	mockResponse := map[string]interface{}{
		"displayName":          "Benchmark User",
		"fullName":             "Benchmark User Full",
		"emailAddress":         "benchmark@example.com",
		"username":             "benchmark",
		"profileId":            "benchmark-123",
		"profileImageUrlLarge": "https://example.com/benchmark.jpg",
		"location":             "Benchmark City",
		"fitnessLevel":         "ADVANCED",
		"height":               185.0,
		"weight":               80.0,
		"birthDate":            "1990-01-01",
	}
	mockServer.SetResponse("/userprofile-service/socialProfile", http.StatusOK, mockResponse)

	// Create client
	client := NewClientWithBaseURL(mockServer.URL)

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		_, _ = client.GetUserProfile(context.Background())
	}
}

// BenchmarkGetUserStats measures performance of GetUserStats method
func BenchmarkGetUserStats(b *testing.B) {
	now := time.Now()
	testDate := now.Format("2006-01-02")

	// Create test server
	mockServer := NewMockServer()
	defer mockServer.Close()

	// Setup successful response
	mockResponse := map[string]interface{}{
		"totalSteps":       15000,
		"totalDistance":    12000.0,
		"totalCalories":    3000,
		"activeMinutes":    60,
		"restingHeartRate": 50,
		"date":             testDate,
	}
	path := fmt.Sprintf("/stats-service/stats/daily/%s", now.Format("2006-01-02"))
	mockServer.SetResponse(path, http.StatusOK, mockResponse)

	// Create client
	client := NewClientWithBaseURL(mockServer.URL)

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		_, _ = client.GetUserStats(context.Background(), now)
	}
}

func TestGetUserStats(t *testing.T) {
	now := time.Now()
	testDate := now.Format("2006-01-02")

	// Define test cases
	tests := []struct {
		name          string
		date          time.Time
		mockResponse  interface{}
		mockStatus    int
		expected      *UserStats
		expectedError string
	}{
		{
			name: "successful stats retrieval",
			date: now,
			mockResponse: map[string]interface{}{
				"totalSteps":       10000,
				"totalDistance":    8500.5,
				"totalCalories":    2200,
				"activeMinutes":    45,
				"restingHeartRate": 55,
				"date":             testDate,
			},
			mockStatus: http.StatusOK,
			expected: &UserStats{
				TotalSteps:    10000,
				TotalDistance: 8500.5,
				TotalCalories: 2200,
				ActiveMinutes: 45,
				RestingHR:     55,
				Date:          now.Truncate(24 * time.Hour), // Date without time component
			},
		},
		{
			name: "stats not found for date",
			date: now,
			mockResponse: map[string]interface{}{
				"error": "No stats found",
			},
			mockStatus:    http.StatusNotFound,
			expectedError: "failed to get user stats",
		},
		{
			name: "future date error",
			date: now.AddDate(0, 0, 1),
			mockResponse: map[string]interface{}{
				"error": "Date cannot be in the future",
			},
			mockStatus:    http.StatusBadRequest,
			expectedError: "API request failed with status 400",
		},
		{
			name: "invalid stats response",
			date: now,
			mockResponse: map[string]interface{}{
				"invalid": "data",
			},
			mockStatus:    http.StatusOK,
			expectedError: "failed to parse user stats",
		},
	}

	// Create test server
	mockServer := NewMockServer()
	defer mockServer.Close()

	// Create client
	client := NewClientWithBaseURL(mockServer.URL)

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Configure mock server
			mockServer.Reset()
			path := fmt.Sprintf("/stats-service/stats/daily/%s", tt.date.Format("2006-01-02"))
			mockServer.SetResponse(path, tt.mockStatus, tt.mockResponse)

			// Execute test
			stats, err := client.GetUserStats(context.Background(), tt.date)

			// Assert results
			if tt.expectedError != "" {
				assert.Error(t, err)
				assert.Contains(t, err.Error(), tt.expectedError)
				assert.Nil(t, stats)
			} else {
				assert.NoError(t, err)
				assert.Equal(t, tt.expected, stats)
			}
		})
	}
}