test: update test fixtures to use @with_session decorator

- Replace manual session management in test fixtures with @with_session decorator
- Simplify async test fixtures by removing explicit session handling
- Update dependencies in pyproject.toml and uv.lock

server/tests/test_cleanup.py

@@ -15,19 +15,19 @@ from reflector.worker.cleanup import cleanup_old_public_data
 
 
 @pytest.mark.asyncio
-async def test_cleanup_old_public_data_skips_when_not_public(session):
+async def test_cleanup_old_public_data_skips_when_not_public(db_session):
     """Test that cleanup is skipped when PUBLIC_MODE is False."""
     with patch("reflector.worker.cleanup.settings") as mock_settings:
         mock_settings.PUBLIC_MODE = False
 
-        result = await cleanup_old_public_data(session)
+        result = await cleanup_old_public_data(db_session)
 
         # Should return early without doing anything
         assert result is None
 
 
 @pytest.mark.asyncio
-async def test_cleanup_old_public_data_deletes_old_anonymous_transcripts(session):
+async def test_cleanup_old_public_data_deletes_old_anonymous_transcripts(db_session):
     """Test that old anonymous transcripts are deleted."""
     # Create old and new anonymous transcripts
     old_date = datetime.now(timezone.utc) - timedelta(days=8)
@@ -35,23 +35,23 @@ async def test_cleanup_old_public_data_deletes_old_anonymous_transcripts(session
 
     # Create old anonymous transcript (should be deleted)
     old_transcript = await transcripts_controller.add(
-        session,
+        db_session,
         name="Old Anonymous Transcript",
         source_kind=SourceKind.FILE,
         user_id=None,  # Anonymous
     )
 
     # Manually update created_at to be old
-    await session.execute(
+    await db_session.execute(
         update(TranscriptModel)
         .where(TranscriptModel.id == old_transcript.id)
         .values(created_at=old_date)
     )
-    await session.commit()
+    await db_session.commit()
 
     # Create new anonymous transcript (should NOT be deleted)
     new_transcript = await transcripts_controller.add(
-        session,
+        db_session,
         name="New Anonymous Transcript",
         source_kind=SourceKind.FILE,
         user_id=None,  # Anonymous
@@ -59,17 +59,17 @@ async def test_cleanup_old_public_data_deletes_old_anonymous_transcripts(session
 
     # Create old transcript with user (should NOT be deleted)
     old_user_transcript = await transcripts_controller.add(
-        session,
+        db_session,
         name="Old User Transcript",
         source_kind=SourceKind.FILE,
         user_id="user-123",
     )
-    await session.execute(
+    await db_session.execute(
         update(TranscriptModel)
         .where(TranscriptModel.id == old_user_transcript.id)
         .values(created_at=old_date)
     )
-    await session.commit()
+    await db_session.commit()
 
     # Mock settings for public mode
     with patch("reflector.worker.cleanup.settings") as mock_settings:
@@ -81,7 +81,7 @@ async def test_cleanup_old_public_data_deletes_old_anonymous_transcripts(session
             mock_delete.return_value = None
 
             # Run cleanup with test session
-            await cleanup_old_public_data(session)
+            await cleanup_old_public_data(db_session)
 
             # Verify only old anonymous transcript was deleted
             assert mock_delete.call_count == 1
@@ -92,27 +92,27 @@ async def test_cleanup_old_public_data_deletes_old_anonymous_transcripts(session
 
 
 @pytest.mark.asyncio
-async def test_cleanup_deletes_associated_meeting_and_recording(session):
+async def test_cleanup_deletes_associated_meeting_and_recording(db_session):
     """Test that cleanup deletes associated meetings and recordings."""
     old_date = datetime.now(timezone.utc) - timedelta(days=8)
 
     # Create an old transcript with both meeting and recording
     old_transcript = await transcripts_controller.add(
-        session,
+        db_session,
         name="Old Transcript with Meeting and Recording",
         source_kind=SourceKind.FILE,
         user_id=None,
     )
-    await session.execute(
+    await db_session.execute(
         update(TranscriptModel)
         .where(TranscriptModel.id == old_transcript.id)
         .values(created_at=old_date)
     )
-    await session.commit()
+    await db_session.commit()
 
     # Create associated meeting directly
     meeting_id = "test-meeting-id"
-    await session.execute(
+    await db_session.execute(
         insert(MeetingModel).values(
             id=meeting_id,
             room_id=None,
@@ -132,7 +132,7 @@ async def test_cleanup_deletes_associated_meeting_and_recording(session):
 
     # Create associated recording directly
     recording_id = "test-recording-id"
-    await session.execute(
+    await db_session.execute(
         insert(RecordingModel).values(
             id=recording_id,
             meeting_id=meeting_id,
@@ -142,15 +142,15 @@ async def test_cleanup_deletes_associated_meeting_and_recording(session):
             created_at=old_date,
         )
     )
-    await session.commit()
+    await db_session.commit()
 
     # Update transcript with meeting_id and recording_id
-    await session.execute(
+    await db_session.execute(
         update(TranscriptModel)
         .where(TranscriptModel.id == old_transcript.id)
         .values(meeting_id=meeting_id, recording_id=recording_id)
     )
-    await session.commit()
+    await db_session.commit()
 
     # Mock settings
     with patch("reflector.worker.cleanup.settings") as mock_settings:
@@ -162,24 +162,24 @@ async def test_cleanup_deletes_associated_meeting_and_recording(session):
             mock_storage.return_value.delete_file = AsyncMock()
 
             # Run cleanup with test session
-            await cleanup_old_public_data(session)
+            await cleanup_old_public_data(db_session)
 
             # Verify transcript was deleted
-            result = await session.execute(
+            result = await db_session.execute(
                 select(TranscriptModel).where(TranscriptModel.id == old_transcript.id)
             )
             transcript = result.scalar_one_or_none()
             assert transcript is None
 
             # Verify meeting was deleted
-            result = await session.execute(
+            result = await db_session.execute(
                 select(MeetingModel).where(MeetingModel.id == meeting_id)
             )
             meeting = result.scalar_one_or_none()
             assert meeting is None
 
             # Verify recording was deleted
-            result = await session.execute(
+            result = await db_session.execute(
                 select(RecordingModel).where(RecordingModel.id == recording_id)
             )
             recording = result.scalar_one_or_none()
@@ -187,35 +187,35 @@ async def test_cleanup_deletes_associated_meeting_and_recording(session):
 
 
 @pytest.mark.asyncio
-async def test_cleanup_handles_errors_gracefully(session):
+async def test_cleanup_handles_errors_gracefully(db_session):
     """Test that cleanup continues even if individual deletions fail."""
     old_date = datetime.now(timezone.utc) - timedelta(days=8)
 
     # Create multiple old transcripts
     transcript1 = await transcripts_controller.add(
-        session,
+        db_session,
         name="Transcript 1",
         source_kind=SourceKind.FILE,
         user_id=None,
     )
-    await session.execute(
+    await db_session.execute(
         update(TranscriptModel)
         .where(TranscriptModel.id == transcript1.id)
         .values(created_at=old_date)
     )
 
     transcript2 = await transcripts_controller.add(
-        session,
+        db_session,
         name="Transcript 2",
         source_kind=SourceKind.FILE,
         user_id=None,
     )
-    await session.execute(
+    await db_session.execute(
         update(TranscriptModel)
         .where(TranscriptModel.id == transcript2.id)
         .values(created_at=old_date)
     )
-    await session.commit()
+    await db_session.commit()
 
     with patch("reflector.worker.cleanup.settings") as mock_settings:
         mock_settings.PUBLIC_MODE = True
@@ -226,34 +226,34 @@ async def test_cleanup_handles_errors_gracefully(session):
             mock_delete.side_effect = [Exception("Delete failed"), None]
 
             # Run cleanup with test session - should not raise exception
-            await cleanup_old_public_data(session)
+            await cleanup_old_public_data(db_session)
 
             # Both transcripts should have been attempted to delete
             assert mock_delete.call_count == 2
 
 
 @pytest.mark.asyncio
-async def test_meeting_consent_cascade_delete(session):
+async def test_meeting_consent_cascade_delete(db_session):
     """Test that meeting_consent entries are cascade deleted with meetings."""
     old_date = datetime.now(timezone.utc) - timedelta(days=8)
 
     # Create an old transcript
     transcript = await transcripts_controller.add(
-        session,
+        db_session,
         name="Transcript with Meeting",
         source_kind=SourceKind.FILE,
         user_id=None,
     )
-    await session.execute(
+    await db_session.execute(
         update(TranscriptModel)
         .where(TranscriptModel.id == transcript.id)
         .values(created_at=old_date)
     )
-    await session.commit()
+    await db_session.commit()
 
     # Create a meeting directly
     meeting_id = "test-meeting-consent"
-    await session.execute(
+    await db_session.execute(
         insert(MeetingModel).values(
             id=meeting_id,
             room_id=None,
@@ -270,18 +270,18 @@ async def test_meeting_consent_cascade_delete(session):
             recording_trigger="automatic",
         )
     )
-    await session.commit()
+    await db_session.commit()
 
     # Update transcript with meeting_id
-    await session.execute(
+    await db_session.execute(
         update(TranscriptModel)
         .where(TranscriptModel.id == transcript.id)
         .values(meeting_id=meeting_id)
     )
-    await session.commit()
+    await db_session.commit()
 
     # Create meeting_consent entries
-    await session.execute(
+    await db_session.execute(
         insert(MeetingConsentModel).values(
             id="consent-1",
             meeting_id=meeting_id,
@@ -290,7 +290,7 @@ async def test_meeting_consent_cascade_delete(session):
             consent_timestamp=old_date,
         )
     )
-    await session.execute(
+    await db_session.execute(
         insert(MeetingConsentModel).values(
             id="consent-2",
             meeting_id=meeting_id,
@@ -299,26 +299,26 @@ async def test_meeting_consent_cascade_delete(session):
             consent_timestamp=old_date,
         )
     )
-    await session.commit()
+    await db_session.commit()
 
     # Verify consent entries exist
-    result = await session.execute(
+    result = await db_session.execute(
         select(MeetingConsentModel).where(MeetingConsentModel.meeting_id == meeting_id)
     )
     consents = result.scalars().all()
     assert len(consents) == 2
 
     # Delete the transcript and meeting
-    await session.execute(
+    await db_session.execute(
         TranscriptModel.__table__.delete().where(TranscriptModel.id == transcript.id)
     )
-    await session.execute(
+    await db_session.execute(
         MeetingModel.__table__.delete().where(MeetingModel.id == meeting_id)
     )
-    await session.commit()
+    await db_session.commit()
 
     # Verify consent entries were cascade deleted
-    result = await session.execute(
+    result = await db_session.execute(
         select(MeetingConsentModel).where(MeetingConsentModel.meeting_id == meeting_id)
     )
     consents = result.scalars().all()