Added 100% test coverage

Author: parshvadaftari

docs/examples/mem0-toolset.md

@@ -65,4 +65,3 @@ await agent.run('My favorite color is red', deps='user_bob')
 ## Learn More
 
 For detailed documentation on the Mem0 integration, see the [Mem0 Memory Integration](../mem0.md) guide.
-

pydantic_ai_slim/pydantic_ai/toolsets/mem0.py

@@ -18,10 +18,10 @@
 
 try:
     from mem0 import AsyncMemoryClient, MemoryClient
-except ImportError as _e:
-    _import_error = _e
-    AsyncMemoryClient = None
-    MemoryClient = None
+except ImportError as _e:  # pragma: no cover
+    _import_error = _e  # pragma: no cover
+    AsyncMemoryClient = None  # pragma: no cover
+    MemoryClient = None  # pragma: no cover
 else:
     _import_error = None
 

tests/test_mem0_toolset.py

@@ -38,8 +38,18 @@ def test_mem0_import_error():
     if _import_error is None:
         pytest.skip('mem0 is installed, skipping import error test')
 
-    with pytest.raises(ImportError, match='mem0 is not installed'):
-        Mem0Toolset(api_key='test-key')
+    with pytest.raises(ImportError, match='mem0 is not installed'):  # pragma: no cover
+        Mem0Toolset(api_key='test-key')  # pragma: no cover
+
+
+def test_mem0_import_error_mocked():
+    """Test ImportError handling by mocking the import error."""
+    from unittest.mock import patch
+
+    # Mock the import error scenario
+    with patch('pydantic_ai.toolsets.mem0._import_error', new=ImportError('Mocked import error')):
+        with pytest.raises(ImportError, match='mem0 is not installed'):
+            Mem0Toolset(api_key='test-key')
 
 
 @pytest.mark.skipif(_import_error is not None, reason='mem0 is not installed')
@@ -56,6 +66,36 @@ async def test_mem0_toolset_initialization():
     assert toolset._is_async is True
 
 
+@pytest.mark.skipif(_import_error is not None, reason='mem0 is not installed')
+async def test_mem0_toolset_initialization_without_client():
+    """Test Mem0Toolset initialization without providing a client."""
+    from unittest.mock import patch
+
+    # Mock the AsyncMemoryClient to avoid needing real API key
+    with patch('pydantic_ai.toolsets.mem0.AsyncMemoryClient') as mock_client_class:
+        mock_client = AsyncMock()
+        mock_client_class.return_value = mock_client
+
+        # Initialize toolset without client (will create AsyncMemoryClient)
+        toolset = Mem0Toolset(
+            api_key='test-key',
+            host='https://test.mem0.ai',
+            org_id='test-org',
+            project_id='test-project',
+        )
+
+        # Verify AsyncMemoryClient was called with correct params
+        mock_client_class.assert_called_once_with(
+            api_key='test-key',
+            host='https://test.mem0.ai',
+            org_id='test-org',
+            project_id='test-project',
+        )
+
+        assert toolset.client is mock_client
+        assert toolset._is_async is True
+
+
 @pytest.mark.skipif(_import_error is not None, reason='mem0 is not installed')
 async def test_mem0_toolset_tool_registration():
     """Test that Mem0Toolset registers the expected tools."""
@@ -249,6 +289,34 @@ async def test_mem0_toolset_search_memory_unexpected_response():
     assert 'Error: Unexpected response format from Mem0' in result
 
 
+@pytest.mark.skipif(_import_error is not None, reason='mem0 is not installed')
+async def test_mem0_toolset_search_memory_with_non_dict_items():
+    """Test search_memory with non-dict items in results."""
+    mock_client = AsyncMock()
+    # Mix of dict and non-dict items
+    mock_client.search = AsyncMock(
+        return_value={
+            'results': [
+                {'memory': 'Valid memory', 'score': 0.9},
+                'invalid_string_item',  # This should be skipped
+                {'memory': 'Another valid memory', 'score': 0.8},
+                None,  # This should also be skipped
+            ]
+        }
+    )
+
+    toolset = Mem0Toolset(client=mock_client)
+    context = build_run_context('user_123')
+
+    result = await toolset._search_memory_impl(context, 'test')
+
+    # Only dict items should be included in the output
+    assert 'Found relevant memories:' in result
+    assert 'Valid memory (relevance: 0.90)' in result
+    assert 'Another valid memory (relevance: 0.80)' in result
+    assert 'invalid_string_item' not in result
+
+
 @pytest.mark.skipif(_import_error is not None, reason='mem0 is not installed')
 async def test_mem0_toolset_save_memory():
     """Test the save_memory tool."""
@@ -336,6 +404,22 @@ async def test_mem0_toolset_sync_client():
     assert 'Successfully saved to memory' in result
 
 
+@pytest.mark.skipif(_import_error is not None, reason='mem0 is not installed')
+async def test_mem0_toolset_client_without_search():
+    """Test Mem0Toolset with a client that doesn't have search attribute."""
+
+    # Create a client without search attribute to test the _is_async=False path
+    class MinimalClient:
+        def add(self, messages: Any, user_id: Any) -> None:
+            pass
+
+    mock_client = MinimalClient()
+    toolset = Mem0Toolset(client=mock_client)
+
+    # Should detect it's not async because it doesn't have search method
+    assert toolset._is_async is False
+
+
 @pytest.mark.skipif(_import_error is not None, reason='mem0 is not installed')
 async def test_mem0_toolset_with_dataclass_deps():
     """Test Mem0Toolset with dataclass deps containing user_id."""