feat: Implement Garmin sync, login improvements, and utility scripts

backend/tests/api/test_garmin_auth_api.py

@@ -0,0 +1,169 @@
+from datetime import datetime, timedelta
+from unittest.mock import AsyncMock, patch
+
+import pytest
+from backend.src.main import app
+from backend.src.schemas import GarminCredentials
+from httpx import AsyncClient
+
+
+@pytest.fixture
+def mock_garmin_auth_service():
+    with patch('backend.src.api.garmin_auth.GarminAuthService') as MockGarminAuthService:
+        service_instance = MockGarminAuthService.return_value
+        yield service_instance
+
+@pytest.fixture
+def mock_central_db_service():
+    with patch('backend.src.api.garmin_auth.CentralDBService') as MockCentralDBService:
+        service_instance = MockCentralDBService.return_value
+        yield service_instance
+
+@pytest.mark.asyncio
+async def test_garmin_login_success_new_credentials(mock_garmin_auth_service, mock_central_db_service):
+    username = "test@example.com"
+    password = "password123"
+
+    mock_garmin_auth_service.initial_login.return_value = GarminCredentials(
+        garmin_username=username,
+        garmin_password_plaintext=password,
+        access_token="mock_access_token",
+        access_token_secret="mock_access_token_secret",
+        token_expiration_date=datetime.utcnow() + timedelta(hours=1)
+    )
+    mock_central_db_service.get_garmin_credentials.return_value = None # No existing credentials
+    mock_central_db_service.create_garmin_credentials.return_value = AsyncMock() # Simulate successful creation
+
+    async with AsyncClient(app=app, base_url="http://test") as client:
+        response = await client.post(
+            "/api/garmin/login",
+            json={
+                "username": username,
+                "password": password
+            }
+        )
+
+    assert response.status_code == 200
+    assert response.json() == {"message": "Garmin account linked successfully."}
+    mock_garmin_auth_service.initial_login.assert_called_once_with(username, password)
+    mock_central_db_service.get_garmin_credentials.assert_called_once_with(1) # Assuming user_id 1
+    mock_central_db_service.create_garmin_credentials.assert_called_once()
+
+@pytest.mark.asyncio
+async def test_garmin_login_success_update_credentials(mock_garmin_auth_service, mock_central_db_service):
+    username = "test@example.com"
+    password = "password123"
+
+    mock_garmin_auth_service.initial_login.return_value = GarminCredentials(
+        garmin_username=username,
+        garmin_password_plaintext=password,
+        access_token="mock_access_token_new",
+        access_token_secret="mock_access_token_secret_new",
+        token_expiration_date=datetime.utcnow() + timedelta(hours=1)
+    )
+    mock_central_db_service.get_garmin_credentials.return_value = GarminCredentials(
+        garmin_username=username,
+        garmin_password_plaintext="old_password",
+        access_token="old_access_token",
+        access_token_secret="old_access_token_secret",
+        token_expiration_date=datetime.utcnow() - timedelta(hours=1)
+    ) # Existing credentials
+    mock_central_db_service.update_garmin_credentials.return_value = AsyncMock() # Simulate successful update
+
+    async with AsyncClient(app=app, base_url="http://test") as client:
+        response = await client.post(
+            "/api/garmin/login",
+            json={
+                "username": username,
+                "password": password
+            }
+        )
+
+    assert response.status_code == 200
+    assert response.json() == {"message": "Garmin account linked successfully."}
+    mock_garmin_auth_service.initial_login.assert_called_once_with(username, password)
+    mock_central_db_service.get_garmin_credentials.assert_called_once_with(1)
+    mock_central_db_service.update_garmin_credentials.assert_called_once()
+
+@pytest.mark.asyncio
+async def test_garmin_login_failure_invalid_credentials(mock_garmin_auth_service, mock_central_db_service):
+    username = "invalid@example.com"
+    password = "wrongpassword"
+
+    mock_garmin_auth_service.initial_login.return_value = None # Simulate failed Garmin login
+
+    async with AsyncClient(app=app, base_url="http://test") as client:
+        response = await client.post(
+            "/api/garmin/login",
+            json={
+                "username": username,
+                "password": password
+            }
+        )
+
+    assert response.status_code == 401
+    assert response.json() == {"detail": "Invalid Garmin credentials provided."}
+    mock_garmin_auth_service.initial_login.assert_called_once_with(username, password)
+    mock_central_db_service.get_garmin_credentials.assert_not_called()
+    mock_central_db_service.create_garmin_credentials.assert_not_called()
+    mock_central_db_service.update_garmin_credentials.assert_not_called()
+
+@pytest.mark.asyncio
+async def test_garmin_login_failure_central_db_create_error(mock_garmin_auth_service, mock_central_db_service):
+    username = "test@example.com"
+    password = "password123"
+
+    mock_garmin_auth_service.initial_login.return_value = GarminCredentials(
+        garmin_username=username,
+        garmin_password_plaintext=password,
+        access_token="mock_access_token",
+        access_token_secret="mock_access_token_secret",
+        token_expiration_date=datetime.utcnow() + timedelta(hours=1)
+    )
+    mock_central_db_service.get_garmin_credentials.return_value = None
+    mock_central_db_service.create_garmin_credentials.return_value = None # Simulate CentralDB create failure
+
+    async with AsyncClient(app=app, base_url="http://test") as client:
+        response = await client.post(
+            "/api/garmin/login",
+            json={
+                "username": username,
+                "password": password
+            }
+        )
+
+    assert response.status_code == 500
+    assert response.json() == {"detail": "Failed to store Garmin credentials in CentralDB."}
+
+@pytest.mark.asyncio
+async def test_garmin_login_failure_central_db_update_error(mock_garmin_auth_service, mock_central_db_service):
+    username = "test@example.com"
+    password = "password123"
+
+    mock_garmin_auth_service.initial_login.return_value = GarminCredentials(
+        garmin_username=username,
+        garmin_password_plaintext=password,
+        access_token="mock_access_token_new",
+        access_token_secret="mock_access_token_secret_new",
+        token_expiration_date=datetime.utcnow() + timedelta(hours=1)
+    )
+    mock_central_db_service.get_garmin_credentials.return_value = GarminCredentials(
+        garmin_username=username,
+        garmin_password_plaintext="old_password",
+        access_token="old_access_token",
+        access_token_secret="old_access_token_secret",
+        token_expiration_date=datetime.utcnow() - timedelta(hours=1)
+    )
+    mock_central_db_service.update_garmin_credentials.return_value = None # Simulate CentralDB update failure
+
+    async with AsyncClient(app=app, base_url="http://test") as client:
+        response = await client.post(
+            "/api/garmin/login",
+            json={
+                "username": username,
+                "password": password
+            }
+        )
+
+    assert response.status_code == 500
+    assert response.json() == {"detail": "Failed to update Garmin credentials in CentralDB."}

backend/tests/api/test_garmin_sync_api.py

@@ -0,0 +1,80 @@
+from datetime import date
+from unittest.mock import AsyncMock, patch
+
+import pytest
+from backend.src.main import app
+from backend.src.schemas import User
+from fastapi import HTTPException
+from httpx import AsyncClient
+
+
+@pytest.fixture
+def mock_garmin_activity_service():
+    with patch('backend.src.api.garmin_sync.GarminActivityService') as MockGarminActivityService:
+        service_instance = MockGarminActivityService.return_value
+        yield service_instance
+
+@pytest.fixture
+def mock_get_current_user():
+    with patch('backend.src.api.garmin_sync.get_current_user') as mock_current_user:
+        mock_current_user.return_value = User(id=1, name="Test User", email="test@example.com")
+        yield mock_current_user
+
+@pytest.mark.asyncio
+async def test_trigger_garmin_activity_sync_success(mock_garmin_activity_service, mock_get_current_user):
+    mock_garmin_activity_service.sync_activities_in_background = AsyncMock()
+    mock_garmin_activity_service.sync_activities_in_background.return_value = None
+
+    async with AsyncClient(app=app, base_url="http://test") as client:
+        response = await client.post(
+            "/api/sync/garmin/activities",
+            json={
+                "force_resync": False,
+                "start_date": "2023-01-01",
+                "end_date": "2023-01-31"
+            }
+        )
+
+    assert response.status_code == 202
+    response_json = response.json()
+    assert "job_id" in response_json
+    assert "status" in response_json
+    assert response_json["status"] == "pending"
+    mock_garmin_activity_service.sync_activities_in_background.assert_called_once()
+    args, kwargs = mock_garmin_activity_service.sync_activities_in_background.call_args
+    assert not args[1] # force_resync
+    assert args[2] == date(2023, 1, 1) # start_date
+    assert args[3] == date(2023, 1, 31) # end_date
+
+@pytest.mark.asyncio
+async def test_trigger_garmin_activity_sync_no_dates(mock_garmin_activity_service, mock_get_current_user):
+    mock_garmin_activity_service.sync_activities_in_background = AsyncMock()
+    mock_garmin_activity_service.sync_activities_in_background.return_value = None
+
+    async with AsyncClient(app=app, base_url="http://test") as client:
+        response = await client.post(
+            "/api/sync/garmin/activities",
+            json={}
+        )
+
+    assert response.status_code == 202
+    response_json = response.json()
+    assert "job_id" in response_json
+    assert "status" in response_json
+    assert response_json["status"] == "pending"
+    mock_garmin_activity_service.sync_activities_in_background.assert_called_once()
+    args, kwargs = mock_garmin_activity_service.sync_activities_in_background.call_args
+    assert not args[1] # force_resync
+    assert args[2] is None # start_date
+    assert args[3] is None # end_date
+
+@pytest.mark.asyncio
+async def test_trigger_garmin_activity_sync_unauthorized():
+    with patch('backend.src.api.garmin_sync.get_current_user', side_effect=HTTPException(status_code=401)):
+        async with AsyncClient(app=app, base_url="http://test") as client:
+            response = await client.post(
+                "/api/sync/garmin/activities",
+                json={}
+            )
+        assert response.status_code == 401
+        assert response.json() == {"detail": "Not Authenticated"} # Default FastAPI 401 detail

backend/tests/integration/test_garmin_authentication_flow.py

@@ -0,0 +1,116 @@
+from unittest.mock import AsyncMock, patch
+
+import pytest
+from backend.src.schemas import GarminCredentials
+from backend.src.services.garmin_activity_service import GarminActivityService
+from backend.src.services.garmin_health_service import GarminHealthService
+
+
+@pytest.fixture
+def mock_garmin_auth_service_instance():
+    with patch(
+        'backend.src.services.garmin_activity_service.GarminAuthService'
+    ) as MockGarminAuthService:
+        instance = MockGarminAuthService.return_value
+        yield instance
+
+@pytest.fixture
+def mock_central_db_service_instance():
+    with patch(
+        'backend.src.services.garmin_activity_service.CentralDBService'
+    ) as MockCentralDBService:
+        service_instance = MockCentralDBService.return_value
+        yield service_instance
+
+@pytest.fixture
+def mock_garmin_client_service_instance():
+    with patch(
+        'backend.src.services.garmin_activity_service.GarminClientService'
+    ) as MockGarminClientService:
+        instance = MockGarminClientService.return_value
+        yield instance
+
+@pytest.mark.asyncio
+async def test_garmin_activity_sync_authentication_flow(
+    mock_garmin_auth_service_instance,
+    mock_central_db_service_instance,
+    mock_garmin_client_service_instance
+):
+    user_id = 1
+    username = "test@example.com"
+    password = "password123"
+
+    # Mock GarminCredentials from CentralDB
+    mock_credentials = GarminCredentials(
+        garmin_username=username,
+        garmin_password_plaintext=password
+    )
+    mock_central_db_service_instance.get_garmin_credentials.return_value = mock_credentials
+
+    # Mock GarminClientService authentication
+    mock_garmin_client_service_instance.is_authenticated.return_value = False
+    mock_garmin_client_service_instance.authenticate.return_value = True
+
+    # Mock GarminClientService.get_client().get_activities
+    mock_garmin_client_instance = AsyncMock()
+    mock_garmin_client_service_instance.get_client.return_value = mock_garmin_client_instance
+    mock_garmin_client_instance.get_activities.return_value = [] # Simulate no activities
+
+    activity_service = GarminActivityService(
+        garmin_client_service=mock_garmin_client_service_instance,
+        activity_download_service=AsyncMock(), # Mock this dependency
+        garmin_auth_service=mock_garmin_auth_service_instance, # Still needed for init, but methods not called
+        central_db_service=mock_central_db_service_instance
+    )
+
+    # Call sync_activities_in_background, which will trigger authentication
+    await activity_service.sync_activities_in_background(job_id="test_job")
+
+    # Assertions
+    mock_central_db_service_instance.get_garmin_credentials.assert_called_once_with(user_id)
+    mock_garmin_client_service_instance.update_credentials.assert_called_once_with(username, password)
+    mock_garmin_client_service_instance.is_authenticated.assert_called_once()
+    mock_garmin_client_service_instance.authenticate.assert_called_once()
+    mock_garmin_client_instance.get_activities.assert_called_once()
+
+@pytest.mark.asyncio
+async def test_garmin_health_sync_authentication_flow(
+    mock_garmin_auth_service_instance,
+    mock_central_db_service_instance,
+    mock_garmin_client_service_instance
+):
+    user_id = 1
+    username = "test@example.com"
+    password = "password123"
+
+    # Mock GarminCredentials from CentralDB
+    mock_credentials = GarminCredentials(
+        garmin_username=username,
+        garmin_password_plaintext=password
+    )
+    mock_central_db_service_instance.get_garmin_credentials.return_value = mock_credentials
+
+    # Mock GarminClientService authentication
+    mock_garmin_client_service_instance.is_authenticated.return_value = False
+    mock_garmin_client_service_instance.authenticate.return_value = True
+
+    # Mock GarminClientService.get_client().get_daily_summary
+    mock_garmin_client_instance = AsyncMock()
+    mock_garmin_client_service_instance.get_client.return_value = mock_garmin_client_instance
+    mock_garmin_client_instance.get_daily_summary.return_value = [] # Simulate no summaries
+
+    health_service = GarminHealthService(
+        garmin_client_service=mock_garmin_client_service_instance,
+        central_db_service=mock_central_db_service_instance,
+        garmin_auth_service=mock_garmin_auth_service_instance # Still needed for init, but methods not called
+    )
+
+    # Call sync_health_metrics_in_background, which will trigger authentication
+    await health_service.sync_health_metrics_in_background(job_id="test_job")
+
+    # Assertions
+    mock_central_db_service_instance.get_garmin_credentials.assert_called_once_with(user_id)
+    mock_garmin_client_service_instance.update_credentials.assert_called_once_with(username, password)
+    mock_garmin_client_service_instance.is_authenticated.assert_called_once()
+    mock_garmin_client_service_instance.authenticate.assert_called_once()
+    mock_garmin_client_instance.get_daily_summary.assert_called_once()

backend/tests/unit/test_auth_service.py

@@ -1,8 +1,11 @@
-import pytest
-from unittest.mock import AsyncMock, patch
-from src.services.auth_service import AuthService
-from src.schemas import UserCreate, User, TokenCreate, TokenUpdate
 import uuid
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from src.schemas import TokenCreate, User
+from src.services.auth_service import AuthService
+
 
 @pytest.fixture
 def auth_service():
@@ -34,7 +37,9 @@ def mock_garth_client():
         yield mock_client
 
 @pytest.mark.asyncio
-async def test_authenticate_garmin_connect_new_user_success(auth_service, mock_garth_login, mock_garth_client):
+async def test_authenticate_garmin_connect_new_user_success(
+    auth_service, mock_garth_login, mock_garth_client
+):
     """Test successful Garmin authentication with a new user."""
     email = "new_user@example.com"
     password = "password123"
@@ -55,7 +60,9 @@ async def test_authenticate_garmin_connect_new_user_success(auth_service, mock_g
     assert result == {"message": "Garmin Connect authentication successful", "user_id": str(mock_user.id)}
 
 @pytest.mark.asyncio
-async def test_authenticate_garmin_connect_existing_user_success(auth_service, mock_garth_login, mock_garth_client):
+async def test_authenticate_garmin_connect_existing_user_success(
+    auth_service, mock_garth_login, mock_garth_client
+):
     """Test successful Garmin authentication with an existing user and no existing token."""
     email = "existing_user@example.com"
     password = "password123"
@@ -75,7 +82,9 @@ async def test_authenticate_garmin_connect_existing_user_success(auth_service, m
     assert result == {"message": "Garmin Connect authentication successful", "user_id": str(mock_user.id)}
 
 @pytest.mark.asyncio
-async def test_authenticate_garmin_connect_existing_user_existing_token_success(auth_service, mock_garth_login, mock_garth_client):
+async def test_authenticate_garmin_connect_existing_user_existing_token_success(
+    auth_service, mock_garth_login, mock_garth_client
+):
     """Test successful Garmin authentication with an existing user and existing token."""
     email = "existing_user_token@example.com"
     password = "password123"
@@ -117,7 +126,9 @@ async def test_authenticate_garmin_connect_garmin_failure(auth_service, mock_gar
     assert result is None
 
 @pytest.mark.asyncio
-async def test_authenticate_garmin_connect_central_db_user_creation_failure(auth_service, mock_garth_login, mock_garth_client):
+async def test_authenticate_garmin_connect_central_db_user_creation_failure(
+    auth_service, mock_garth_login, mock_garth_client
+):
     """Test CentralDB user creation failure."""
     email = "fail_user_create@example.com"
     password = "password123"

backend/tests/unit/test_central_db_service.py

@@ -0,0 +1 @@
+

backend/tests/unit/test_garmin_auth_service.py

@@ -0,0 +1,91 @@
+from datetime import datetime, timedelta
+from unittest.mock import AsyncMock, patch
+
+import pytest
+from backend.src.schemas import GarminCredentials
+from backend.src.services.garmin_auth_service import GarminAuthService
+
+
+@pytest.fixture
+def garmin_auth_service():
+    return GarminAuthService()
+
+@pytest.mark.asyncio
+async def test_initial_login_success(garmin_auth_service):
+    username = "test@example.com"
+    password = "password123"
+
+    with patch('backend.src.services.garmin_auth_service.garth') as mock_garth:
+        mock_garth.Client.return_value = AsyncMock()
+        mock_garth.Client.return_value.login.return_value = None # garth.login doesn't return anything directly
+        # Mock the attributes that would be set on the client after login
+        mock_garth.Client.return_value.access_token = f"mock_access_token_for_{username}"
+        mock_garth.Client.return_value.access_token_secret = f"mock_access_token_secret_for_{username}"
+        mock_garth.Client.return_value.expires_in = 300
+
+        credentials = await garmin_auth_service.initial_login(username, password)
+
+        assert credentials is not None
+        assert credentials.garmin_username == username
+        assert credentials.garmin_password_plaintext == password
+        assert credentials.access_token.startswith("mock_access_token")
+        assert credentials.access_token_secret.startswith("mock_access_token_secret")
+        assert isinstance(credentials.token_expiration_date, datetime)
+        assert credentials.token_expiration_date > datetime.utcnow()
+
+@pytest.mark.asyncio
+async def test_initial_login_failure(garmin_auth_service):
+    username = "invalid@example.com"
+    password = "wrongpassword"
+
+    with patch('backend.src.services.garmin_auth_service.garth') as mock_garth:
+        mock_garth.Client.return_value = AsyncMock()
+        mock_garth.Client.return_value.login.side_effect = Exception("Garmin login failed")
+
+        credentials = await garmin_auth_service.initial_login(username, password)
+
+        assert credentials is None
+
+@pytest.mark.asyncio
+async def test_refresh_tokens_success(garmin_auth_service):
+    credentials = GarminCredentials(
+        garmin_username="test@example.com",
+        garmin_password_plaintext="password123",
+        access_token="old_access_token",
+        access_token_secret="old_access_token_secret",
+        token_expiration_date=datetime.utcnow() - timedelta(minutes=1) # Expired token
+    )
+
+    with patch('backend.src.services.garmin_auth_service.garth') as mock_garth:
+        mock_garth.Client.return_value = AsyncMock()
+        mock_garth.Client.return_value.reauthorize.return_value = None
+        mock_garth.Client.return_value.access_token = "refreshed_access_token"
+        mock_garth.Client.return_value.access_token_secret = "refreshed_access_token_secret"
+        mock_garth.Client.return_value.expires_in = 300
+
+        refreshed_credentials = await garmin_auth_service.refresh_tokens(credentials)
+
+        assert refreshed_credentials is not None
+        assert refreshed_credentials.garmin_username == credentials.garmin_username
+        assert refreshed_credentials.access_token == "refreshed_access_token"
+        assert refreshed_credentials.access_token_secret == "refreshed_access_token_secret"
+        assert isinstance(refreshed_credentials.token_expiration_date, datetime)
+        assert refreshed_credentials.token_expiration_date > datetime.utcnow()
+
+@pytest.mark.asyncio
+async def test_refresh_tokens_failure(garmin_auth_service):
+    credentials = GarminCredentials(
+        garmin_username="test@example.com",
+        garmin_password_plaintext="invalid_password",
+        access_token="old_access_token",
+        access_token_secret="old_access_token_secret",
+        token_expiration_date=datetime.utcnow() - timedelta(minutes=1)
+    )
+
+    with patch('backend.src.services.garmin_auth_service.garth') as mock_garth:
+        mock_garth.Client.return_value = AsyncMock()
+        mock_garth.Client.return_value.reauthorize.side_effect = Exception("Garmin reauthorize failed")
+
+        refreshed_credentials = await garmin_auth_service.refresh_tokens(credentials)
+
+        assert refreshed_credentials is None

backend/tests/unit/test_rate_limiter.py

@@ -1,8 +1,10 @@
-import pytest
 from unittest.mock import MagicMock, patch
+
+import pytest
 from fastapi import HTTPException
+
 from src.services.rate_limiter import RateLimiter
-import asyncio
+
 
 @pytest.mark.asyncio
 async def test_rate_limiter_allows_requests_within_limit():

backend/tests/unit/test_sync_status_service.py

@@ -3,8 +3,10 @@ from datetime import datetime
 from unittest.mock import MagicMock
 
 import pytest
+
+from src.jobs import JobStore, SyncJob
 from src.services.sync_status_service import SyncStatusService
-from src.jobs import SyncJob, JobStore
+
 
 @pytest.fixture
 def mock_job_store():