refactor: add session parameter to ICSSyncService.sync_room_calendar

- Updated sync_room_calendar method to accept AsyncSession as first parameter
- Removed internal get_session_factory() calls from the service
- Updated all callers (views/rooms.py, worker/ics_sync.py) to pass session
- Fixed all test files to remove mocking of get_session_factory
- Consistent with @with_session decorator pattern used elsewhere

server/reflector/services/ics_sync.py

@@ -55,8 +55,8 @@ import httpx
 import pytz
 import structlog
 from icalendar import Calendar, Event
+from sqlalchemy.ext.asyncio import AsyncSession
 
-from reflector.db import get_session_factory
 from reflector.db.calendar_events import CalendarEvent, calendar_events_controller
 from reflector.db.rooms import Room, rooms_controller
 from reflector.redis_cache import RedisAsyncLock
@@ -295,7 +295,7 @@ class ICSSyncService:
     def __init__(self):
         self.fetch_service = ICSFetchService()
 
-    async def sync_room_calendar(self, room: Room) -> SyncResult:
+    async def sync_room_calendar(self, session: AsyncSession, room: Room) -> SyncResult:
         async with RedisAsyncLock(
             f"ics_sync_room:{room.id}", skip_if_locked=True
         ) as lock:
@@ -306,9 +306,11 @@ class ICSSyncService:
                     "reason": "Sync already in progress",
                 }
 
-            return await self._sync_room_calendar(room)
+            return await self._sync_room_calendar(session, room)
 
-    async def _sync_room_calendar(self, room: Room) -> SyncResult:
+    async def _sync_room_calendar(
+        self, session: AsyncSession, room: Room
+    ) -> SyncResult:
         if not room.ics_enabled or not room.ics_url:
             return {"status": SyncStatus.SKIPPED, "reason": "ICS not configured"}
 
@@ -341,11 +343,9 @@ class ICSSyncService:
             events, total_events = self.fetch_service.extract_room_events(
                 calendar, room.name, room_url
             )
-            sync_result = await self._sync_events_to_database(room.id, events)
+            sync_result = await self._sync_events_to_database(session, room.id, events)
 
             # Update room sync metadata
-            session_factory = get_session_factory()
-            async with session_factory() as session:
             await rooms_controller.update(
                 session,
                 room,
@@ -376,15 +376,13 @@ class ICSSyncService:
         return time_since_sync.total_seconds() >= room.ics_fetch_interval
 
     async def _sync_events_to_database(
-        self, room_id: str, events: list[EventData]
+        self, session: AsyncSession, room_id: str, events: list[EventData]
     ) -> SyncStats:
         created = 0
         updated = 0
 
         current_ics_uids = []
 
-        session_factory = get_session_factory()
-        async with session_factory() as session:
         for event_data in events:
             calendar_event = CalendarEvent(room_id=room_id, **event_data)
             existing = await calendar_events_controller.get_by_ics_uid(

server/reflector/views/rooms.py

@@ -387,7 +387,7 @@ async def rooms_sync_ics(
     if not room.ics_enabled or not room.ics_url:
         raise HTTPException(status_code=400, detail="ICS not configured for this room")
 
-    result = await ics_sync_service.sync_room_calendar(room)
+    result = await ics_sync_service.sync_room_calendar(session, room)
 
     if result["status"] == "error":
         raise HTTPException(

server/reflector/worker/ics_sync.py

@@ -32,7 +32,7 @@ async def sync_room_ics(session: AsyncSession, room_id: str):
             return
 
         logger.info("Starting ICS sync for room", room_id=room_id, room_name=room.name)
-        result = await ics_sync_service.sync_room_calendar(room)
+        result = await ics_sync_service.sync_room_calendar(session, room)
 
         if result["status"] == SyncStatus.SUCCESS:
             logger.info(

server/tests/test_attendee_parsing_bug.py

@@ -54,22 +54,8 @@ async def test_attendee_parsing_bug(db_session):
     ics_content = ics_content.replace("20250910T174000Z", dtstamp)
 
     sync_service = ICSSyncService()
-    from contextlib import asynccontextmanager
     from unittest.mock import AsyncMock
 
-    @asynccontextmanager
-    async def mock_session_context():
-        yield db_session
-
-    class MockSessionMaker:
-        def __call__(self):
-            return mock_session_context()
-
-    mock_session_factory = MockSessionMaker()
-
-    with patch("reflector.services.ics_sync.get_session_factory") as mock_get_factory:
-        mock_get_factory.return_value = mock_session_factory
-
     with patch.object(
         sync_service.fetch_service, "fetch_ics", new_callable=AsyncMock
     ) as mock_fetch:
@@ -90,7 +76,7 @@ async def test_attendee_parsing_bug(db_session):
         print(f"Total events in calendar: {total_events}")
         print(f"Events matching room: {len(events)}")
 
-            result = await sync_service.sync_room_calendar(room)
+        result = await sync_service.sync_room_calendar(db_session, room)
 
         assert result.get("status") == "success"
         assert result.get("events_found", 0) >= 0

server/tests/test_ics_background_tasks.py

@@ -45,28 +45,13 @@ async def test_sync_room_ics_task(db_session):
     cal.add_component(event)
     ics_content = cal.to_ical().decode("utf-8")
 
-    from contextlib import asynccontextmanager
-
-    @asynccontextmanager
-    async def mock_session_context():
-        yield db_session
-
-    class MockSessionMaker:
-        def __call__(self):
-            return mock_session_context()
-
-    mock_session_factory = MockSessionMaker()
-
-    with patch("reflector.services.ics_sync.get_session_factory") as mock_get_factory:
-        mock_get_factory.return_value = mock_session_factory
-
     with patch(
         "reflector.services.ics_sync.ICSFetchService.fetch_ics",
         new_callable=AsyncMock,
     ) as mock_fetch:
         mock_fetch.return_value = ics_content
 
-            await ics_sync_service.sync_room_calendar(room)
+        await ics_sync_service.sync_room_calendar(db_session, room)
 
         events = await calendar_events_controller.get_by_room(db_session, room.id)
         assert len(events) == 1
@@ -90,7 +75,7 @@ async def test_sync_room_ics_disabled(db_session):
         ics_enabled=False,
     )
 
-    result = await ics_sync_service.sync_room_calendar(room)
+    result = await ics_sync_service.sync_room_calendar(db_session, room)
 
     events = await calendar_events_controller.get_by_room(db_session, room.id)
     assert len(events) == 0
@@ -259,7 +244,7 @@ async def test_sync_handles_errors_gracefully(db_session):
     ) as mock_fetch:
         mock_fetch.side_effect = Exception("Network error")
 
-        result = await ics_sync_service.sync_room_calendar(room)
+        result = await ics_sync_service.sync_room_calendar(db_session, room)
         assert result["status"] == "error"
 
         events = await calendar_events_controller.get_by_room(db_session, room.id)

server/tests/test_ics_sync.py

@@ -168,31 +168,16 @@ async def test_ics_sync_service_sync_room_calendar(db_session):
     cal.add_component(event)
     ics_content = cal.to_ical().decode("utf-8")
 
-    from contextlib import asynccontextmanager
-
-    @asynccontextmanager
-    async def mock_session_context():
-        yield db_session
-
-    class MockSessionMaker:
-        def __call__(self):
-            return mock_session_context()
-
-    mock_session_factory = MockSessionMaker()
-
     # Create sync service and mock fetch
     sync_service = ICSSyncService()
 
-    with patch("reflector.services.ics_sync.get_session_factory") as mock_get_factory:
-        mock_get_factory.return_value = mock_session_factory
-
     with patch.object(
         sync_service.fetch_service, "fetch_ics", new_callable=AsyncMock
     ) as mock_fetch:
         mock_fetch.return_value = ics_content
 
         # First sync
-            result = await sync_service.sync_room_calendar(room)
+        result = await sync_service.sync_room_calendar(db_session, room)
 
         assert result["status"] == "success"
         assert result["events_found"] == 1
@@ -214,7 +199,7 @@ async def test_ics_sync_service_sync_room_calendar(db_session):
             room,
             {"ics_last_sync": datetime.now(timezone.utc) - timedelta(minutes=10)},
         )
-            result = await sync_service.sync_room_calendar(room)
+        result = await sync_service.sync_room_calendar(db_session, room)
         assert result["status"] == "unchanged"
 
         # Third sync with updated event
@@ -227,7 +212,7 @@ async def test_ics_sync_service_sync_room_calendar(db_session):
         # Force sync by clearing etag
         await rooms_controller.update(db_session, room, {"ics_last_etag": None})
 
-            result = await sync_service.sync_room_calendar(room)
+        result = await sync_service.sync_room_calendar(db_session, room)
         assert result["status"] == "success"
         assert result["events_created"] == 0
         assert result["events_updated"] == 1
@@ -266,7 +251,7 @@ async def test_ics_sync_service_skip_disabled():
     room.ics_enabled = False
     room.ics_url = "https://calendar.example.com/test.ics"
 
-    result = await service.sync_room_calendar(room)
+    result = await service.sync_room_calendar(MagicMock(), room)
     assert result["status"] == "skipped"
     assert result["reason"] == "ICS not configured"
 
@@ -274,7 +259,7 @@ async def test_ics_sync_service_skip_disabled():
     room.ics_enabled = True
     room.ics_url = None
 
-    result = await service.sync_room_calendar(room)
+    result = await service.sync_room_calendar(MagicMock(), room)
     assert result["status"] == "skipped"
     assert result["reason"] == "ICS not configured"
 
@@ -299,28 +284,13 @@ async def test_ics_sync_service_error_handling(db_session):
     )
     await db_session.flush()
 
-    from contextlib import asynccontextmanager
-
-    @asynccontextmanager
-    async def mock_session_context():
-        yield db_session
-
-    class MockSessionMaker:
-        def __call__(self):
-            return mock_session_context()
-
-    mock_session_factory = MockSessionMaker()
-
     sync_service = ICSSyncService()
 
-    with patch("reflector.services.ics_sync.get_session_factory") as mock_get_factory:
-        mock_get_factory.return_value = mock_session_factory
-
     with patch.object(
         sync_service.fetch_service, "fetch_ics", new_callable=AsyncMock
     ) as mock_fetch:
         mock_fetch.side_effect = Exception("Network error")
 
-            result = await sync_service.sync_room_calendar(room)
+        result = await sync_service.sync_room_calendar(db_session, room)
         assert result["status"] == "error"
         assert "Network error" in result["error"]