fix: ruff fix

Author: dori

tests/test_conversation_history_lifecycle.py

@@ -50,12 +50,16 @@ async def test_save_retrieve_fifo_cleanup_lifecycle(self):
         # Records should be in reverse chronological order (newest first)
         sources = [r.source for r in records]
         expected_sources = ["tool_2", "tool_1", "tool_0"]  # Newest first
-        assert sources == expected_sources, f"Expected {expected_sources}, got {sources}"
+        assert sources == expected_sources, (
+            f"Expected {expected_sources}, got {sources}"
+        )
 
         # Verify timestamps are in descending order
         timestamps = [r.timestamp for r in records]
         for i in range(len(timestamps) - 1):
-            assert timestamps[i] >= timestamps[i + 1], "Records should be ordered newest first"
+            assert timestamps[i] >= timestamps[i + 1], (
+                "Records should be ordered newest first"
+            )
 
         print(f"✅ Phase 2: Records retrieved in correct order: {sources}")
 
@@ -74,12 +78,16 @@ async def test_save_retrieve_fifo_cleanup_lifecycle(self):
 
         # Verify FIFO cleanup worked
         records = await db.get_session_conversations(session_id)
-        assert len(records) == 3, f"Expected 3 records after cleanup, got {len(records)}"
+        assert len(records) == 3, (
+            f"Expected 3 records after cleanup, got {len(records)}"
+        )
 
         # Should have the 3 most recent records
         sources = [r.source for r in records]
         expected_sources = ["tool_4", "tool_3", "tool_2"]  # Most recent 3
-        assert sources == expected_sources, f"Expected {expected_sources}, got {sources}"
+        assert sources == expected_sources, (
+            f"Expected {expected_sources}, got {sources}"
+        )
 
         print(f"✅ Phase 3: FIFO cleanup worked correctly: {sources}")
 
@@ -186,7 +194,9 @@ async def test_time_based_cleanup_integration(self):
         # Records should still exist (within retention period)
         records_after = await db.get_session_conversations("time_test_session")
         assert len(records_after) == 4
-        print(f"✅ After time-based cleanup: {len(records_after)} records (within retention)")
+        print(
+            f"✅ After time-based cleanup: {len(records_after)} records (within retention)"
+        )
 
     @pytest.mark.asyncio
     async def test_lru_session_cleanup_lifecycle(self):
@@ -247,7 +257,9 @@ async def test_lru_session_cleanup_lifecycle(self):
         # Should be sessions B and C (oldest last activity)
         assert "session_B" in lru_sessions, "Session B should be LRU"
         assert "session_C" in lru_sessions, "Session C should be LRU"
-        assert "session_A" not in lru_sessions, "Session A should NOT be LRU (recent activity)"
+        assert "session_A" not in lru_sessions, (
+            "Session A should NOT be LRU (recent activity)"
+        )
         print("✅ Phase 2: LRU detection working correctly")
 
         # PHASE 3: Trigger LRU cleanup
@@ -269,7 +281,13 @@ async def test_lru_session_cleanup_lifecycle(self):
         # PHASE 4: Verify which sessions remain
         print("\n🔍 PHASE 4: Verifying remaining sessions...")
 
-        sessions_to_check = ["session_A", "session_B", "session_C", "session_D", "session_E"]
+        sessions_to_check = [
+            "session_A",
+            "session_B",
+            "session_C",
+            "session_D",
+            "session_E",
+        ]
         remaining_sessions = []
         deleted_sessions = []
 
@@ -278,15 +296,23 @@ async def test_lru_session_cleanup_lifecycle(self):
             if records:
                 remaining_sessions.append(session_id)
                 last_activity = max(r.timestamp for r in records)
-                print(f"   ✅ {session_id}: {len(records)} records, last activity: {last_activity}")
+                print(
+                    f"   ✅ {session_id}: {len(records)} records, last activity: {last_activity}"
+                )
             else:
                 deleted_sessions.append(session_id)
                 print(f"   ❌ {session_id}: DELETED (was least recently used)")
 
         # Verify correct sessions were kept/deleted
-        assert "session_A" in remaining_sessions, "Session A should remain (most recent activity)"
-        assert "session_D" in remaining_sessions, "Session D should remain (recent creation)"
-        assert "session_E" in remaining_sessions, "Session E should remain (most recent creation)"
+        assert "session_A" in remaining_sessions, (
+            "Session A should remain (most recent activity)"
+        )
+        assert "session_D" in remaining_sessions, (
+            "Session D should remain (recent creation)"
+        )
+        assert "session_E" in remaining_sessions, (
+            "Session E should remain (most recent creation)"
+        )
         assert "session_B" in deleted_sessions, "Session B should be deleted (LRU)"
         assert "session_C" in deleted_sessions, "Session C should be deleted (LRU)"
 
@@ -296,7 +322,9 @@ async def test_lru_session_cleanup_lifecycle(self):
         print("\n📊 PHASE 5: Verifying session record preservation...")
 
         session_a_records = await db.get_session_conversations("session_A")
-        assert len(session_a_records) == 2, f"Session A should have 2 records, got {len(session_a_records)}"
+        assert len(session_a_records) == 2, (
+            f"Session A should have 2 records, got {len(session_a_records)}"
+        )
 
         # Check that both records exist
         sources = [r.source for r in session_a_records]