fix: resolve unused variable lint warnings in tests

- Remove unused variables in test mock functions
- Clean up test code per ruff linting rules

Author: phernandez

src/basic_memory/repository/search_repository.py

@@ -458,4 +458,4 @@ async def execute_query(
             end_time = time.perf_counter()
             elapsed_time = end_time - start_time
             logger.debug(f"Query executed successfully in {elapsed_time:.2f}s.")
-            return result
+            return result

src/basic_memory/services/entity_service.py

@@ -303,8 +303,12 @@ async def create_entity_from_markdown(
             return await self.repository.add(model)
         except IntegrityError as e:
             # Handle race condition where entity was created by another process
-            if "UNIQUE constraint failed: entity.file_path" in str(e) or "UNIQUE constraint failed: entity.permalink" in str(e):
-                logger.info(f"Entity already exists for file_path={file_path} (file_path or permalink conflict), updating instead of creating")
+            if "UNIQUE constraint failed: entity.file_path" in str(
+                e
+            ) or "UNIQUE constraint failed: entity.permalink" in str(e):
+                logger.info(
+                    f"Entity already exists for file_path={file_path} (file_path or permalink conflict), updating instead of creating"
+                )
                 return await self.update_entity_and_observations(file_path, markdown)
             else:
                 # Re-raise if it's a different integrity error

src/basic_memory/sync/sync_service.py

@@ -380,21 +380,23 @@ async def sync_regular_file(self, path: str, new: bool = True) -> Tuple[Optional
             except IntegrityError as e:
                 # Handle race condition where entity was created by another process
                 if "UNIQUE constraint failed: entity.file_path" in str(e):
-                    logger.info(f"Entity already exists for file_path={path}, updating instead of creating")
+                    logger.info(
+                        f"Entity already exists for file_path={path}, updating instead of creating"
+                    )
                     # Treat as update instead of create
                     entity = await self.entity_repository.get_by_file_path(path)
                     if entity is None:  # pragma: no cover
                         logger.error(f"Entity not found after constraint violation, path={path}")
                         raise ValueError(f"Entity not found after constraint violation: {path}")
-                    
+
                     updated = await self.entity_repository.update(
                         entity.id, {"file_path": path, "checksum": checksum}
                     )
-                    
+
                     if updated is None:  # pragma: no cover
                         logger.error(f"Failed to update entity, entity_id={entity.id}, path={path}")
                         raise ValueError(f"Failed to update entity with ID {entity.id}")
-                    
+
                     return updated, checksum
                 else:
                     # Re-raise if it's a different integrity error

tests/services/test_entity_service.py

@@ -874,30 +874,32 @@ async def test_create_entity_from_markdown_race_condition_handling(
     entity_service: EntityService, file_service: FileService
 ):
     """Test that create_entity_from_markdown handles race condition with IntegrityError (lines 304-311)."""
-    from unittest.mock import patch, AsyncMock
+    from unittest.mock import patch
     from sqlalchemy.exc import IntegrityError
 
     file_path = Path("test/race-condition.md")
-    
+
     # Create a mock EntityMarkdown object
-    from basic_memory.markdown.schemas import EntityFrontmatter, EntityMarkdown as RealEntityMarkdown
+    from basic_memory.markdown.schemas import (
+        EntityFrontmatter,
+        EntityMarkdown as RealEntityMarkdown,
+    )
     from datetime import datetime, timezone
-    
+
     frontmatter = EntityFrontmatter(metadata={"title": "Race Condition Test", "type": "test"})
     markdown = RealEntityMarkdown(
-        frontmatter=frontmatter, 
-        observations=[], 
+        frontmatter=frontmatter,
+        observations=[],
         relations=[],
         created=datetime.now(timezone.utc),
-        modified=datetime.now(timezone.utc)
+        modified=datetime.now(timezone.utc),
     )
 
     # Mock the repository.add to raise IntegrityError on first call, then succeed on second
     original_add = entity_service.repository.add
-    original_update = entity_service.update_entity_and_observations
-    
+
     call_count = 0
-    
+
     async def mock_add(*args, **kwargs):
         nonlocal call_count
         call_count += 1
@@ -906,12 +908,12 @@ async def mock_add(*args, **kwargs):
             raise IntegrityError("UNIQUE constraint failed: entity.file_path", None, None)
         else:
             return await original_add(*args, **kwargs)
-    
+
     # Mock update method to return a dummy entity
     async def mock_update(*args, **kwargs):
         from basic_memory.models import Entity
         from datetime import datetime, timezone
-        
+
         return Entity(
             id=1,
             title="Race Condition Test",
@@ -923,17 +925,20 @@ async def mock_update(*args, **kwargs):
             updated_at=datetime.now(timezone.utc),
         )
 
-    with patch.object(entity_service.repository, 'add', side_effect=mock_add), \
-         patch.object(entity_service, 'update_entity_and_observations', side_effect=mock_update) as mock_update_call:
-        
+    with (
+        patch.object(entity_service.repository, "add", side_effect=mock_add),
+        patch.object(
+            entity_service, "update_entity_and_observations", side_effect=mock_update
+        ) as mock_update_call,
+    ):
         # Call the method
         result = await entity_service.create_entity_from_markdown(file_path, markdown)
-        
+
         # Verify it handled the race condition gracefully
         assert result is not None
         assert result.title == "Race Condition Test"
         assert result.file_path == str(file_path)
-        
+
         # Verify that update_entity_and_observations was called as fallback
         mock_update_call.assert_called_once_with(file_path, markdown)
 
@@ -947,28 +952,33 @@ async def test_create_entity_from_markdown_integrity_error_reraise(
     from sqlalchemy.exc import IntegrityError
 
     file_path = Path("test/integrity-error.md")
-    
+
     # Create a mock EntityMarkdown object
-    from basic_memory.markdown.schemas import EntityFrontmatter, EntityMarkdown as RealEntityMarkdown
+    from basic_memory.markdown.schemas import (
+        EntityFrontmatter,
+        EntityMarkdown as RealEntityMarkdown,
+    )
     from datetime import datetime, timezone
-    
+
     frontmatter = EntityFrontmatter(metadata={"title": "Integrity Error Test", "type": "test"})
     markdown = RealEntityMarkdown(
-        frontmatter=frontmatter, 
-        observations=[], 
+        frontmatter=frontmatter,
+        observations=[],
         relations=[],
         created=datetime.now(timezone.utc),
-        modified=datetime.now(timezone.utc)
+        modified=datetime.now(timezone.utc),
     )
 
     # Mock the repository.add to raise a different IntegrityError (not file_path/permalink constraint)
     async def mock_add(*args, **kwargs):
         # Simulate a different constraint violation
         raise IntegrityError("UNIQUE constraint failed: entity.some_other_field", None, None)
 
-    with patch.object(entity_service.repository, 'add', side_effect=mock_add):
+    with patch.object(entity_service.repository, "add", side_effect=mock_add):
         # Should re-raise the IntegrityError since it's not a file_path/permalink constraint
-        with pytest.raises(IntegrityError, match="UNIQUE constraint failed: entity.some_other_field"):
+        with pytest.raises(
+            IntegrityError, match="UNIQUE constraint failed: entity.some_other_field"
+        ):
             await entity_service.create_entity_from_markdown(file_path, markdown)
 
 

tests/sync/test_sync_service.py

@@ -1096,9 +1096,8 @@ async def test_sync_regular_file_race_condition_handling(
     sync_service: SyncService, project_config: ProjectConfig
 ):
     """Test that sync_regular_file handles race condition with IntegrityError (lines 380-401)."""
-    from unittest.mock import patch, AsyncMock
+    from unittest.mock import patch
     from sqlalchemy.exc import IntegrityError
-    from pathlib import Path
     from datetime import datetime, timezone
 
     # Create a test file
@@ -1114,11 +1113,9 @@ async def test_sync_regular_file_race_condition_handling(
 
     # Mock the entity_repository.add to raise IntegrityError on first call
     original_add = sync_service.entity_repository.add
-    original_get_by_file_path = sync_service.entity_repository.get_by_file_path
-    original_update = sync_service.entity_repository.update
-    
+
     call_count = 0
-    
+
     async def mock_add(*args, **kwargs):
         nonlocal call_count
         call_count += 1
@@ -1127,10 +1124,11 @@ async def mock_add(*args, **kwargs):
             raise IntegrityError("UNIQUE constraint failed: entity.file_path", None, None)
         else:
             return await original_add(*args, **kwargs)
-    
+
     # Mock get_by_file_path to return an existing entity (simulating the race condition result)
     async def mock_get_by_file_path(file_path):
         from basic_memory.models import Entity
+
         return Entity(
             id=1,
             title="Test Race Condition",
@@ -1142,14 +1140,15 @@ async def mock_get_by_file_path(file_path):
             created_at=datetime.now(timezone.utc),
             updated_at=datetime.now(timezone.utc),
         )
-    
+
     # Mock update to return the updated entity
     async def mock_update(entity_id, updates):
         from basic_memory.models import Entity
+
         return Entity(
             id=entity_id,
             title="Test Race Condition",
-            entity_type="knowledge", 
+            entity_type="knowledge",
             file_path=updates["file_path"],
             permalink="test-race-condition",
             content_type="text/markdown",
@@ -1158,18 +1157,25 @@ async def mock_update(entity_id, updates):
             updated_at=datetime.now(timezone.utc),
         )
 
-    with patch.object(sync_service.entity_repository, 'add', side_effect=mock_add), \
-         patch.object(sync_service.entity_repository, 'get_by_file_path', side_effect=mock_get_by_file_path) as mock_get, \
-         patch.object(sync_service.entity_repository, 'update', side_effect=mock_update) as mock_update_call:
-        
+    with (
+        patch.object(sync_service.entity_repository, "add", side_effect=mock_add),
+        patch.object(
+            sync_service.entity_repository, "get_by_file_path", side_effect=mock_get_by_file_path
+        ) as mock_get,
+        patch.object(
+            sync_service.entity_repository, "update", side_effect=mock_update
+        ) as mock_update_call,
+    ):
         # Call sync_regular_file
-        entity, checksum = await sync_service.sync_regular_file(str(test_file.relative_to(project_config.home)), new=True)
-        
+        entity, checksum = await sync_service.sync_regular_file(
+            str(test_file.relative_to(project_config.home)), new=True
+        )
+
         # Verify it handled the race condition gracefully
         assert entity is not None
         assert entity.title == "Test Race Condition"
         assert entity.file_path == str(test_file.relative_to(project_config.home))
-        
+
         # Verify that get_by_file_path and update were called as fallback
         assert mock_get.call_count >= 1  # May be called multiple times
         mock_update_call.assert_called_once()
@@ -1199,10 +1205,14 @@ async def mock_add(*args, **kwargs):
         # Simulate a different constraint violation
         raise IntegrityError("UNIQUE constraint failed: entity.some_other_field", None, None)
 
-    with patch.object(sync_service.entity_repository, 'add', side_effect=mock_add):
+    with patch.object(sync_service.entity_repository, "add", side_effect=mock_add):
         # Should re-raise the IntegrityError since it's not a file_path constraint
-        with pytest.raises(IntegrityError, match="UNIQUE constraint failed: entity.some_other_field"):
-            await sync_service.sync_regular_file(str(test_file.relative_to(project_config.home)), new=True)
+        with pytest.raises(
+            IntegrityError, match="UNIQUE constraint failed: entity.some_other_field"
+        ):
+            await sync_service.sync_regular_file(
+                str(test_file.relative_to(project_config.home)), new=True
+            )
 
 
 @pytest.mark.asyncio
@@ -1227,17 +1237,22 @@ async def test_sync_regular_file_race_condition_entity_not_found(
     # Mock the entity_repository.add to raise IntegrityError
     async def mock_add(*args, **kwargs):
         raise IntegrityError("UNIQUE constraint failed: entity.file_path", None, None)
-    
+
     # Mock get_by_file_path to return None (entity not found)
     async def mock_get_by_file_path(file_path):
         return None
 
-    with patch.object(sync_service.entity_repository, 'add', side_effect=mock_add), \
-         patch.object(sync_service.entity_repository, 'get_by_file_path', side_effect=mock_get_by_file_path):
-        
+    with (
+        patch.object(sync_service.entity_repository, "add", side_effect=mock_add),
+        patch.object(
+            sync_service.entity_repository, "get_by_file_path", side_effect=mock_get_by_file_path
+        ),
+    ):
         # Should raise ValueError when entity is not found after constraint violation
         with pytest.raises(ValueError, match="Entity not found after constraint violation"):
-            await sync_service.sync_regular_file(str(test_file.relative_to(project_config.home)), new=True)
+            await sync_service.sync_regular_file(
+                str(test_file.relative_to(project_config.home)), new=True
+            )
 
 
 @pytest.mark.asyncio
@@ -1263,10 +1278,11 @@ async def test_sync_regular_file_race_condition_update_failed(
     # Mock the entity_repository.add to raise IntegrityError
     async def mock_add(*args, **kwargs):
         raise IntegrityError("UNIQUE constraint failed: entity.file_path", None, None)
-    
+
     # Mock get_by_file_path to return an existing entity
     async def mock_get_by_file_path(file_path):
         from basic_memory.models import Entity
+
         return Entity(
             id=1,
             title="Test Update Fail",
@@ -1278,15 +1294,20 @@ async def mock_get_by_file_path(file_path):
             created_at=datetime.now(timezone.utc),
             updated_at=datetime.now(timezone.utc),
         )
-    
+
     # Mock update to return None (failure)
     async def mock_update(entity_id, updates):
         return None
 
-    with patch.object(sync_service.entity_repository, 'add', side_effect=mock_add), \
-         patch.object(sync_service.entity_repository, 'get_by_file_path', side_effect=mock_get_by_file_path), \
-         patch.object(sync_service.entity_repository, 'update', side_effect=mock_update):
-        
+    with (
+        patch.object(sync_service.entity_repository, "add", side_effect=mock_add),
+        patch.object(
+            sync_service.entity_repository, "get_by_file_path", side_effect=mock_get_by_file_path
+        ),
+        patch.object(sync_service.entity_repository, "update", side_effect=mock_update),
+    ):
         # Should raise ValueError when update fails
         with pytest.raises(ValueError, match="Failed to update entity with ID"):
-            await sync_service.sync_regular_file(str(test_file.relative_to(project_config.home)), new=True)
+            await sync_service.sync_regular_file(
+                str(test_file.relative_to(project_config.home)), new=True
+            )