test: PineconeDocumentStore use Mixin tests (#3020)

* adding Mixin tests

* removing redundant/duplicated test and small fixes to make other tests pass

* chore: update haystack-ai dependency to >=2.26.1

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* isort

* removing duplicated tests

* removing duplicated tests

---------

Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: davidsbatista

integrations/pinecone/pyproject.toml

@@ -24,7 +24,7 @@ classifiers = [
   "Programming Language :: Python :: Implementation :: PyPy",
 ]
 dependencies = [
-  "haystack-ai>=2.24.0",
+  "haystack-ai>=2.26.1",
   "pinecone[asyncio]>=7.0.0",
 ]
 

integrations/pinecone/src/haystack_integrations/document_stores/pinecone/document_store.py

@@ -852,10 +852,11 @@ def _get_metadata_fields_info_impl(documents: list[Document]) -> dict[str, dict[
     @staticmethod
     def _get_metadata_field_min_max_impl(documents: list[Document], metadata_field: str) -> dict[str, Any]:
         """Helper method to get min/max values for a metadata field (supports numeric, boolean, and string types)."""
+        field_name = metadata_field.removeprefix("meta.")
         values: list[bool | int | float | str] = []
         for doc in documents:
-            if doc.meta and metadata_field in doc.meta:
-                value = doc.meta[metadata_field]
+            if doc.meta and field_name in doc.meta:
+                value = doc.meta[field_name]
                 # Note: bool check must come before numeric because bool is subclass of int
                 if isinstance(value, bool):
                     values.append(value)

integrations/pinecone/tests/test_document_store.py

@@ -12,11 +12,16 @@
 from haystack.components.preprocessors import DocumentSplitter
 from haystack.components.retrievers import SentenceWindowRetriever
 from haystack.testing.document_store import (
+    CountDocumentsByFilterTest,
     CountDocumentsTest,
+    CountUniqueMetadataByFilterTest,
     DeleteAllTest,
     DeleteByFilterTest,
     DeleteDocumentsTest,
     FilterableDocsFixtureMixin,
+    GetMetadataFieldMinMaxTest,
+    GetMetadataFieldsInfoTest,
+    GetMetadataFieldUniqueValuesTest,
     UpdateByFilterTest,
     WriteDocumentsTest,
 )
@@ -276,6 +281,11 @@ class TestDocumentStore(
     UpdateByFilterTest,
     DeleteAllTest,
     DeleteByFilterTest,
+    CountDocumentsByFilterTest,
+    CountUniqueMetadataByFilterTest,
+    GetMetadataFieldsInfoTest,
+    GetMetadataFieldMinMaxTest,
+    GetMetadataFieldUniqueValuesTest,
 ):
     def test_write_documents(self, document_store: PineconeDocumentStore):
         docs = [Document(id="1")]
@@ -353,108 +363,6 @@ def test_sentence_window_retriever(self, document_store: PineconeDocumentStore):
 
         assert len(result["context_windows"]) == 1
 
-    def test_count_documents_by_filter(self, document_store: PineconeDocumentStore):
-        docs = [
-            Document(content="Doc 1", meta={"category": "A", "status": "draft"}),
-            Document(content="Doc 2", meta={"category": "B", "status": "published"}),
-            Document(content="Doc 3", meta={"category": "A", "status": "published"}),
-            Document(content="Doc 4", meta={"category": "A", "status": "draft"}),
-        ]
-        document_store.write_documents(docs)
-
-        # Count documents with category="A"
-        count = document_store.count_documents_by_filter(
-            filters={"field": "meta.category", "operator": "==", "value": "A"}
-        )
-        assert count == 3
-
-        # Count documents with status="published"
-        count = document_store.count_documents_by_filter(
-            filters={"field": "meta.status", "operator": "==", "value": "published"}
-        )
-        assert count == 2
-
-        # Count with complex filter
-        count = document_store.count_documents_by_filter(
-            filters={
-                "operator": "AND",
-                "conditions": [
-                    {"field": "meta.category", "operator": "==", "value": "A"},
-                    {"field": "meta.status", "operator": "==", "value": "draft"},
-                ],
-            }
-        )
-        assert count == 2
-
-    def test_count_unique_metadata_by_filter(self, document_store: PineconeDocumentStore):
-        docs = [
-            Document(content="Doc 1", meta={"category": "A", "author": "Alice", "priority": 1}),
-            Document(content="Doc 2", meta={"category": "B", "author": "Bob", "priority": 2}),
-            Document(content="Doc 3", meta={"category": "A", "author": "Alice", "priority": 1}),
-            Document(content="Doc 4", meta={"category": "C", "author": "Charlie", "priority": 3}),
-            Document(content="Doc 5", meta={"category": "A", "author": "Bob", "priority": 2}),
-        ]
-        document_store.write_documents(docs)
-
-        # Count unique values without filter
-        counts = document_store.count_unique_metadata_by_filter(
-            filters={}, metadata_fields=["category", "author", "priority"]
-        )
-        assert counts["category"] == 3  # A, B, C
-        assert counts["author"] == 3  # Alice, Bob, Charlie
-        assert counts["priority"] == 3  # 1, 2, 3
-
-        # Count unique values with filter
-        counts = document_store.count_unique_metadata_by_filter(
-            filters={"field": "meta.category", "operator": "==", "value": "A"},
-            metadata_fields=["author", "priority"],
-        )
-        assert counts["author"] == 2  # Alice, Bob
-        assert counts["priority"] == 2  # 1, 2
-
-    def test_get_metadata_fields_info(self, document_store: PineconeDocumentStore):
-        docs = [
-            Document(
-                content="Doc 1",
-                meta={
-                    "category": "A",
-                    "author": "Alice",
-                    "priority": 1,
-                    "is_published": True,
-                    "tags": ["tag1", "tag2"],
-                },
-            ),
-            Document(content="Doc 2", meta={"category": "B", "author": "Bob", "priority": 2, "is_published": False}),
-        ]
-        document_store.write_documents(docs)
-
-        field_info = document_store.get_metadata_fields_info()
-
-        # Check content field
-        assert "content" in field_info
-        assert field_info["content"]["type"] == "text"
-
-        # Check metadata fields
-        assert "category" in field_info
-        assert field_info["category"]["type"] == "keyword"
-
-        assert "author" in field_info
-        assert field_info["author"]["type"] == "keyword"
-
-        assert "priority" in field_info
-        assert field_info["priority"]["type"] == "long"
-
-        assert "is_published" in field_info
-        assert field_info["is_published"]["type"] == "boolean"
-
-        assert "tags" in field_info
-        assert field_info["tags"]["type"] == "keyword"
-
-    def test_get_metadata_fields_info_empty(self, document_store: PineconeDocumentStore):
-        # Test with no documents
-        field_info = document_store.get_metadata_fields_info()
-        assert field_info == {}
-
     def test_get_metadata_fields_info_consistent_types(self, document_store: PineconeDocumentStore):
         # Test that all documents are checked for type consistency
         docs = [
@@ -468,7 +376,7 @@ def test_get_metadata_fields_info_consistent_types(self, document_store: Pinecon
         assert "score" in field_info
         assert field_info["score"]["type"] == "long"
 
-    def test_get_metadata_field_min_max(self, document_store: PineconeDocumentStore):
+    def test_get_metadata_field_min_max_boolean_and_string(self, document_store: PineconeDocumentStore):
         docs = [
             Document(content="Doc 1", meta={"priority": 1, "score": 85.5, "active": True, "category": "Zebra"}),
             Document(content="Doc 2", meta={"priority": 5, "score": 92.3, "active": False, "category": "Alpha"}),
@@ -477,16 +385,6 @@ def test_get_metadata_field_min_max(self, document_store: PineconeDocumentStore)
         ]
         document_store.write_documents(docs)
 
-        # Get min/max for numeric field (int)
-        min_max = document_store.get_metadata_field_min_max("priority")
-        assert min_max["min"] == 1
-        assert min_max["max"] == 7
-
-        # Get min/max for numeric field (float)
-        min_max = document_store.get_metadata_field_min_max("score")
-        assert min_max["min"] == 78.9
-        assert min_max["max"] == 95.1
-
         # Get min/max for boolean field
         min_max = document_store.get_metadata_field_min_max("active")
         assert min_max["min"] is False
@@ -497,6 +395,11 @@ def test_get_metadata_field_min_max(self, document_store: PineconeDocumentStore)
         assert min_max["min"] == "Alpha"
         assert min_max["max"] == "Zebra"
 
+    def test_get_metadata_field_min_max_empty_collection(self, document_store: PineconeDocumentStore):
+        assert document_store.count_documents() == 0
+        with pytest.raises(ValueError, match="No values found"):
+            document_store.get_metadata_field_min_max("priority")
+
     def test_get_metadata_field_min_max_no_values(self, document_store: PineconeDocumentStore):
         docs = [
             Document(content="Doc 1", meta={"tags": ["tag1", "tag2"]}),