refactor(pgvector): use async DocumentStore mixin tests

integrations/pgvector/pyproject.toml

@@ -24,7 +24,7 @@ classifiers = [
   "Programming Language :: Python :: Implementation :: PyPy",
 ]
 dependencies = [
-  "haystack-ai>=2.26.1",
+  "haystack-ai>=2.27.0",
   "pgvector>=0.3.0",
   "psycopg[binary]"
 ]

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

@@ -1669,7 +1669,7 @@ def _analyze_metadata_fields_from_records(records: list[dict[str, Any]]) -> dict
         :param records: List of database records containing 'meta' field.
         :returns: A dictionary mapping field names to their type information.
         """
-        fields_info: dict[str, dict[str, str]] = {"content": {"type": "text"}}
+        fields_info: dict[str, dict[str, str]] = {}
 
         # Analyze metadata from all documents
         for record in records:
@@ -1846,15 +1846,14 @@ def get_metadata_field_min_max(self, metadata_field: str) -> dict[str, Any]:
         :returns: A dictionary with 'min' and 'max' keys containing the minimum and maximum values.
             For numeric fields (integer, real), returns numeric min/max.
             For text fields, returns lexicographic min/max based on database collation.
-        :raises ValueError: If the field doesn't exist or has no values.
+            Returns ``{"min": None, "max": None}`` when the field has no values or the store is empty.
         """
         normalized_field = PgvectorDocumentStore._normalize_metadata_field_name(metadata_field)
 
         # Get field type information from metadata fields info
         fields_info = self.get_metadata_fields_info()
         if normalized_field not in fields_info:
-            msg = f"Metadata field '{metadata_field}' not found in document store"
-            raise ValueError(msg)
+            return {"min": None, "max": None}
 
         field_type = fields_info[normalized_field]["type"]
         sql_query = self._build_min_max_query(normalized_field, field_type)
@@ -1879,15 +1878,14 @@ async def get_metadata_field_min_max_async(self, metadata_field: str) -> dict[st
         :returns: A dictionary with 'min' and 'max' keys containing the minimum and maximum values.
             For numeric fields (integer, real), returns numeric min/max.
             For text fields, returns lexicographic min/max based on database collation.
-        :raises ValueError: If the field doesn't exist or has no values.
+            Returns ``{"min": None, "max": None}`` when the field has no values or the store is empty.
         """
         normalized_field = PgvectorDocumentStore._normalize_metadata_field_name(metadata_field)
 
         # Get field type information from metadata fields info
         fields_info = await self.get_metadata_fields_info_async()
         if normalized_field not in fields_info:
-            msg = f"Metadata field '{metadata_field}' not found in document store"
-            raise ValueError(msg)
+            return {"min": None, "max": None}
 
         field_type = fields_info[normalized_field]["type"]
         sql_query = self._build_min_max_query(normalized_field, field_type)

integrations/pgvector/tests/test_document_store.py

@@ -44,18 +44,19 @@ class TestDocumentStore(
     GetMetadataFieldUniqueValuesTest,
 ):
     def test_get_metadata_fields_info_empty_collection(self, document_store: PgvectorDocumentStore):
-        """PgvectorDocumentStore always includes 'content' in fields info, even for empty stores."""
+        """Returns empty dict when the store has no documents."""
         assert document_store.count_documents() == 0
 
         fields_info = document_store.get_metadata_fields_info()
-        assert fields_info == {"content": {"type": "text"}}
+        assert fields_info == {}
 
     def test_get_metadata_field_min_max_empty_collection(self, document_store: PgvectorDocumentStore):
-        """PgvectorDocumentStore raises ValueError when the field doesn't exist in the store."""
+        """Returns None min/max when the field doesn't exist in the store."""
         assert document_store.count_documents() == 0
 
-        with pytest.raises(ValueError, match="not found in document store"):
-            document_store.get_metadata_field_min_max("priority")
+        result = document_store.get_metadata_field_min_max("priority")
+        assert result["min"] is None
+        assert result["max"] is None
 
     def test_write_documents(self, document_store: PgvectorDocumentStore):
         docs = [Document(id="1")]