added garmin functional tests

backend/tests/services/test_garmin_sync_functional.py

@@ -1,67 +1,86 @@
 import pytest
 from unittest.mock import AsyncMock, patch, MagicMock
-from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
-from sqlalchemy.orm import sessionmaker
+from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine, async_sessionmaker
 from sqlalchemy.pool import StaticPool
+from sqlalchemy import select
 from backend.app.database import Base
 from backend.app.services.workout_sync import WorkoutSyncService
 from backend.app.services.garmin import GarminService, GarminAPIError, GarminAuthError
 from backend.app.models.workout import Workout
-from backend.app.models.garmin_sync_log import GarminSyncLog
+from backend.app.models.garmin_sync_log import GarminSyncLog, GarminSyncStatus
 from datetime import datetime, timedelta
 import os
+from dotenv import load_dotenv
+from backend.app.config import Settings
 
-# --- Fixtures for Functional Testing ---
+# --- Completely Rewritten Fixtures ---
 
-@pytest.fixture(name="async_engine")
-def async_engine_fixture():
-    """Provides an asynchronous engine for an in-memory SQLite database."""
-    return create_async_engine(
+@pytest.fixture(scope="function")
+def test_engine():
+    """Create a test engine for each test function."""
+    engine = create_async_engine(
         "sqlite+aiosqlite:///:memory:",
         echo=False,
         poolclass=StaticPool,
         connect_args={"check_same_thread": False},
     )
+    return engine
 
-@pytest.fixture(name="async_session")
-async def async_session_fixture(async_engine):
-    """Provides an asynchronous session for an in-memory SQLite database."""
-    async with async_engine.begin() as conn:
+@pytest.fixture(scope="function")
+async def setup_database(test_engine):
+    """Set up the database schema."""
+    async with test_engine.begin() as conn:
         await conn.run_sync(Base.metadata.create_all)
-
-    AsyncSessionLocal = sessionmaker(
-        autocommit=False, autoflush=False, bind=async_engine, class_=AsyncSession
-    )
-    async with AsyncSessionLocal() as session:
-        yield session
-
-    async with async_engine.begin() as conn:
+    yield
+    async with test_engine.begin() as conn:
         await conn.run_sync(Base.metadata.drop_all)
+    await test_engine.dispose()
+
+@pytest.fixture
+async def db_session(test_engine, setup_database):
+    """Create a database session for testing."""
+    async_session_factory = async_sessionmaker(
+        bind=test_engine,
+        class_=AsyncSession,
+        expire_on_commit=False
+    )
+    
+    session = async_session_factory()
+    yield session
+    await session.close()
 
 @pytest.fixture
 def mock_garmin_service():
-    """Mocks the GarminService for functional tests."""
-    with patch('backend.app.services.workout_sync.GarminService', autospec=True) as MockGarminService:
-        mock_instance = MockGarminService.return_value
-        mock_instance.login = AsyncMock(return_value=True)
-        mock_instance.get_activities = AsyncMock(return_value=[])
-        mock_instance.get_activity_details = AsyncMock(return_value={})
-        yield mock_instance
+    """Mock the GarminService for testing."""
+    mock_service = MagicMock(spec=GarminService)
+    mock_service.authenticate = AsyncMock(return_value=True)
+    mock_service.get_activities = AsyncMock(return_value=[])
+    mock_service.get_activity_details = AsyncMock(return_value={})
+    return mock_service
 
 @pytest.fixture
-def workout_sync_service(async_session: AsyncSession, mock_garmin_service: MagicMock) -> WorkoutSyncService:
-    """Provides a WorkoutSyncService instance with a correctly resolved async session."""
-    import asyncio
-    session = asyncio.run(async_session.__anext__())
-    service = WorkoutSyncService(db=session)
-    service.garmin_service = mock_garmin_service
-    return service
+def settings() -> Settings:
+   """Load settings from .env file."""
+   load_dotenv()
+   return Settings()
+
+@pytest.fixture
+def real_garmin_service(settings: Settings) -> GarminService:
+   """Return a real GarminService instance with credentials from settings."""
+   if not settings.GARMIN_USERNAME or not settings.GARMIN_PASSWORD:
+       pytest.skip("GARMIN_USERNAME and GARMIN_PASSWORD must be set in .env for functional tests.")
+   return GarminService()
 
 # --- Test Cases ---
 
+@pytest.mark.unit
 @pytest.mark.asyncio
-async def test_successful_sync_functional(workout_sync_service: WorkoutSyncService, async_session: AsyncSession, mock_garmin_service: MagicMock):
+async def test_successful_sync_functional(db_session: AsyncSession, mock_garmin_service: MagicMock):
     """Test successful synchronization of recent activities."""
+    # Create service with the actual session
+    service = WorkoutSyncService(db=db_session)
+    service.garmin_service = mock_garmin_service
+    
     # Arrange
     mock_garmin_service.get_activities.return_value = [
         {
@@ -83,79 +102,106 @@ async def test_successful_sync_functional(workout_sync_service: WorkoutSyncServi
     }
 
     # Act
-    synced_count = await workout_sync_service.sync_recent_activities(days_back=7)
+    synced_count = await service.sync_recent_activities(days_back=7)
 
     # Assert
     assert synced_count == 1
     
     # Verify workout in DB
-    workouts = (await async_session.execute(select(Workout))).scalars().all()
+    result = await db_session.execute(select(Workout))
+    workouts = result.scalars().all()
     assert len(workouts) == 1
     assert workouts[0].garmin_activity_id == '1001'
     assert workouts[0].activity_type == 'cycling'
-    assert workouts[0].avg_power == 200
+    assert workouts[0].avg_power == 200.0
     assert 'temperature' in workouts[0].metrics
 
     # Verify sync log in DB
-    sync_logs = (await async_session.execute(select(GarminSyncLog))).scalars().all()
+    result = await db_session.execute(select(GarminSyncLog))
+    sync_logs = result.scalars().all()
     assert len(sync_logs) == 1
-    assert sync_logs[0].status == 'success'
+    assert sync_logs[0].status == GarminSyncStatus.COMPLETED
     assert sync_logs[0].activities_synced == 1
     assert sync_logs[0].error_message is None
 
+@pytest.mark.unit
 @pytest.mark.asyncio
-async def test_sync_with_no_new_activities(workout_sync_service: WorkoutSyncService, async_session: AsyncSession, mock_garmin_service: MagicMock):
+async def test_sync_with_no_new_activities(db_session: AsyncSession, mock_garmin_service: MagicMock):
     """Test synchronization when no new activities are found."""
+    # Create service with the actual session
+    service = WorkoutSyncService(db=db_session)
+    service.garmin_service = mock_garmin_service
+    
     # Arrange
-    mock_garmin_service.get_activities.return_value = [] # No activities
+    mock_garmin_service.get_activities.return_value = []  # No activities
 
     # Act
-    synced_count = await workout_sync_service.sync_recent_activities(days_back=7)
+    synced_count = await service.sync_recent_activities(days_back=7)
 
     # Assert
     assert synced_count == 0
-    workouts = (await async_session.execute(select(Workout))).scalars().all()
+    result = await db_session.execute(select(Workout))
+    workouts = result.scalars().all()
     assert len(workouts) == 0
-    sync_logs = (await async_session.execute(select(GarminSyncLog))).scalars().all()
+    
+    result = await db_session.execute(select(GarminSyncLog))
+    sync_logs = result.scalars().all()
     assert len(sync_logs) == 1
-    assert sync_logs[0].status == 'success'
+    assert sync_logs[0].status == GarminSyncStatus.COMPLETED
     assert sync_logs[0].activities_synced == 0
 
+@pytest.mark.unit
 @pytest.mark.asyncio
-async def test_sync_with_authentication_error(workout_sync_service: WorkoutSyncService, async_session: AsyncSession, mock_garmin_service: MagicMock):
+async def test_sync_with_authentication_error(db_session: AsyncSession, mock_garmin_service: MagicMock):
     """Test synchronization failure due to Garmin authentication error."""
+    # Create service with the actual session
+    service = WorkoutSyncService(db=db_session)
+    service.garmin_service = mock_garmin_service
+    
     # Arrange
     mock_garmin_service.get_activities.side_effect = GarminAuthError("Invalid credentials")
 
     # Act & Assert
     with pytest.raises(GarminAuthError):
-        await workout_sync_service.sync_recent_activities(days_back=7)
+        await service.sync_recent_activities(days_back=7)
 
     # Verify sync log in DB
-    sync_logs = (await async_session.execute(select(GarminSyncLog))).scalars().all()
+    result = await db_session.execute(select(GarminSyncLog))
+    sync_logs = result.scalars().all()
     assert len(sync_logs) == 1
-    assert sync_logs[0].status == 'auth_error'
+    assert sync_logs[0].status == GarminSyncStatus.AUTH_FAILED
     assert "Invalid credentials" in sync_logs[0].error_message
 
+@pytest.mark.unit
 @pytest.mark.asyncio
-async def test_sync_with_api_error(workout_sync_service: WorkoutSyncService, async_session: AsyncSession, mock_garmin_service: MagicMock):
+async def test_sync_with_api_error(db_session: AsyncSession, mock_garmin_service: MagicMock):
     """Test synchronization failure due to general Garmin API error."""
+    # Create service with the actual session
+    service = WorkoutSyncService(db=db_session)
+    service.garmin_service = mock_garmin_service
+    
     # Arrange
     mock_garmin_service.get_activities.side_effect = GarminAPIError("Garmin service unavailable")
 
     # Act & Assert
     with pytest.raises(GarminAPIError):
-        await workout_sync_service.sync_recent_activities(days_back=7)
+        await service.sync_recent_activities(days_back=7)
 
     # Verify sync log in DB
-    sync_logs = (await async_session.execute(select(GarminSyncLog))).scalars().all()
+    result = await db_session.execute(select(GarminSyncLog))
+    sync_logs = result.scalars().all()
     assert len(sync_logs) == 1
-    assert sync_logs[0].status == 'api_error'
+    assert sync_logs[0].status == GarminSyncStatus.FAILED
     assert "Garmin service unavailable" in sync_logs[0].error_message
 
+@pytest.mark.unit
 @pytest.mark.asyncio
-async def test_sync_with_activity_details_retry_success(workout_sync_service: WorkoutSyncService, async_session: AsyncSession, mock_garmin_service: MagicMock):
+async def test_sync_with_activity_details_retry_success(db_session: AsyncSession, mock_garmin_service: MagicMock):
     """Test successful retry of activity details fetch after initial failure."""
+    # Create service with the actual session
+    service = WorkoutSyncService(db=db_session)
+    service.garmin_service = mock_garmin_service
+    
     # Arrange
     mock_garmin_service.get_activities.return_value = [
         {
@@ -175,24 +221,31 @@ async def test_sync_with_activity_details_retry_success(workout_sync_service: Wo
     # Act
     # Mock asyncio.sleep to avoid actual delays during tests
     with patch('asyncio.sleep', new_callable=AsyncMock) as mock_sleep:
-        synced_count = await workout_sync_service.sync_recent_activities(days_back=7)
-        mock_sleep.assert_awaited_with(1) # First retry delay
+        synced_count = await service.sync_recent_activities(days_back=7)
+        mock_sleep.assert_awaited_with(1)  # First retry delay
 
     # Assert
     assert synced_count == 1
-    workouts = (await async_session.execute(select(Workout))).scalars().all()
+    result = await db_session.execute(select(Workout))
+    workouts = result.scalars().all()
     assert len(workouts) == 1
     assert workouts[0].garmin_activity_id == '1002'
     assert workouts[0].avg_hr == 160
     assert mock_garmin_service.get_activity_details.call_count == 2
     
-    sync_logs = (await async_session.execute(select(GarminSyncLog))).scalars().all()
+    result = await db_session.execute(select(GarminSyncLog))
+    sync_logs = result.scalars().all()
     assert len(sync_logs) == 1
-    assert sync_logs[0].status == 'success'
+    assert sync_logs[0].status == GarminSyncStatus.COMPLETED
 
+@pytest.mark.unit
 @pytest.mark.asyncio
-async def test_sync_with_activity_details_retry_failure(workout_sync_service: WorkoutSyncService, async_session: AsyncSession, mock_garmin_service: MagicMock):
+async def test_sync_with_activity_details_retry_failure(db_session: AsyncSession, mock_garmin_service: MagicMock):
     """Test activity details fetch eventually fails after multiple retries."""
+    # Create service with the actual session
+    service = WorkoutSyncService(db=db_session)
+    service.garmin_service = mock_garmin_service
+    
     # Arrange
     mock_garmin_service.get_activities.return_value = [
         {
@@ -213,23 +266,30 @@ async def test_sync_with_activity_details_retry_failure(workout_sync_service: Wo
     # Act & Assert
     with pytest.raises(GarminAPIError), \
          patch('asyncio.sleep', new_callable=AsyncMock) as mock_sleep:
-        await workout_sync_service.sync_recent_activities(days_back=7)
+        await service.sync_recent_activities(days_back=7)
         assert mock_garmin_service.get_activity_details.call_count == 3
-        mock_sleep.assert_awaited_with(4) # Last retry delay (2**(3-1))
+        mock_sleep.assert_awaited_with(4)  # Last retry delay (2**(3-1))
 
     # Verify sync log in DB
-    sync_logs = (await async_session.execute(select(GarminSyncLog))).scalars().all()
+    result = await db_session.execute(select(GarminSyncLog))
+    sync_logs = result.scalars().all()
     assert len(sync_logs) == 1
-    assert sync_logs[0].status == 'api_error'
+    assert sync_logs[0].status == GarminSyncStatus.FAILED
     assert "Service unavailable" in sync_logs[0].error_message
     
     # No workout should be saved
-    workouts = (await async_session.execute(select(Workout))).scalars().all()
+    result = await db_session.execute(select(Workout))
+    workouts = result.scalars().all()
     assert len(workouts) == 0
 
+@pytest.mark.unit
 @pytest.mark.asyncio
-async def test_sync_with_duplicate_activities_in_garmin_feed(workout_sync_service: WorkoutSyncService, async_session: AsyncSession, mock_garmin_service: MagicMock):
+async def test_sync_with_duplicate_activities_in_garmin_feed(db_session: AsyncSession, mock_garmin_service: MagicMock):
     """Test handling of duplicate activities appearing in the Garmin feed."""
+    # Create service with the actual session
+    service = WorkoutSyncService(db=db_session)
+    service.garmin_service = mock_garmin_service
+    
     # Arrange
     # First sync: add activity 1004
     mock_garmin_service.get_activities.return_value = [
@@ -242,7 +302,7 @@ async def test_sync_with_duplicate_activities_in_garmin_feed(workout_sync_servic
         }
     ]
     mock_garmin_service.get_activity_details.return_value = {'averageHR': 140}
-    await workout_sync_service.sync_recent_activities(days_back=7)
+    await service.sync_recent_activities(days_back=7)
 
     # Second sync: activity 1004 is present again, plus a new activity 1005
     mock_garmin_service.get_activities.return_value = [
@@ -261,18 +321,46 @@ async def test_sync_with_duplicate_activities_in_garmin_feed(workout_sync_servic
             'distance': 5000
         }
     ]
-    mock_garmin_service.get_activity_details.return_value = {'averageHR': 130} # for activity 1005
+    mock_garmin_service.get_activity_details.return_value = {'averageHR': 130}  # for activity 1005
 
     # Act
-    synced_count = await workout_sync_service.sync_recent_activities(days_back=7)
+    synced_count = await service.sync_recent_activities(days_back=7)
 
     # Assert
-    assert synced_count == 1 # Only 1005 should be synced
-    workouts = (await async_session.execute(select(Workout))).scalars().all()
+    assert synced_count == 1  # Only 1005 should be synced
+    result = await db_session.execute(select(Workout))
+    workouts = result.scalars().all()
     assert len(workouts) == 2
     assert any(w.garmin_activity_id == '1004' for w in workouts)
     assert any(w.garmin_activity_id == '1005' for w in workouts)
     
-    sync_logs = (await async_session.execute(select(GarminSyncLog))).scalars().all()
+    result = await db_session.execute(select(GarminSyncLog))
+    sync_logs = result.scalars().all()
     assert len(sync_logs) == 2
-    assert sync_logs[1].activities_synced == 1 # Second log should show 1 activity synced
+    assert sync_logs[1].activities_synced == 1  # Second log should show 1 activity synced
+
+@pytest.mark.functional
+@pytest.mark.asyncio
+async def test_garmin_sync_with_real_creds(db_session: AsyncSession, real_garmin_service: GarminService):
+   """
+   Test a real Garmin sync. This is a functional test that makes a live API call.
+   It requires GARMIN_USERNAME and GARMIN_PASSWORD to be set in the .env file.
+   """
+   # Arrange
+   service = WorkoutSyncService(db=db_session)
+   service.garmin_service = real_garmin_service
+
+   # Act
+   # We sync the last 1 day to keep the test fast
+   synced_count = await service.sync_recent_activities(days_back=1)
+
+   # Assert
+   assert synced_count >= 0  # We can't know the exact count, but it should not fail
+
+   # Verify sync log in DB
+   result = await db_session.execute(select(GarminSyncLog).order_by(GarminSyncLog.id.desc()))
+   latest_log = result.scalars().first()
+   
+   assert latest_log is not None
+   assert latest_log.status == GarminSyncStatus.COMPLETED
+   assert latest_log.activities_synced == synced_count