fix docstring backticks and add unit tests

Author: SyedShahmeerAli12

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

@@ -481,7 +481,7 @@ def update_by_filter(self, filters: dict[str, Any], meta: dict[str, Any]) -> int
         Update metadata fields on all documents that match the provided filters.
 
         :param filters: Haystack filter dict selecting which documents to update.
-        :param meta: Metadata fields to set. Keys may include or omit the ``meta.`` prefix.
+        :param meta: Metadata fields to set. Keys may include or omit the `meta.` prefix.
         :returns: Number of documents updated.
         """
         self._ensure_connected()
@@ -516,8 +516,8 @@ def count_unique_metadata_by_filter(self, filters: dict[str, Any], metadata_fiel
         Return the number of unique values for each metadata field among matching documents.
 
         :param filters: Haystack filter dict. Pass an empty dict to count across all documents.
-        :param metadata_fields: List of metadata field names. May include or omit the ``meta.`` prefix.
-        :returns: Dict mapping each field name (without ``meta.`` prefix) to its unique value count.
+        :param metadata_fields: List of metadata field names. May include or omit the `meta.` prefix.
+        :returns: Dict mapping each field name (without `meta.` prefix) to its unique value count.
         """
         self._ensure_connected()
         if filters:
@@ -542,8 +542,8 @@ def get_metadata_fields_info(self) -> dict[str, dict[str, str]]:
         """
         Return type information for each metadata field present on document nodes.
 
-        :returns: Dict mapping field names to a ``{"type": <typename>}`` dict.
-            Type names are ``"str"``, ``"int"``, ``"float"``, or ``"bool"``.
+        :returns: Dict mapping field names to a `{"type": <typename>}` dict.
+            Type names are `"str"`, `"int"`, `"float"`, or `"bool"`.
         """
         self._ensure_connected()
         standard_fields = {"id", "content", "embedding", "score", "sparse_embedding"}
@@ -574,8 +574,8 @@ def get_metadata_field_min_max(self, metadata_field: str) -> dict[str, Any]:
         """
         Return the minimum and maximum values for the given metadata field.
 
-        :param metadata_field: Metadata field name. May include or omit the ``meta.`` prefix.
-        :returns: Dict with keys ``"min"`` and ``"max"``. Values are ``None`` when no documents
+        :param metadata_field: Metadata field name. May include or omit the `meta.` prefix.
+        :returns: Dict with keys `"min"` and `"max"`. Values are `None` when no documents
             have a non-null value for the field.
         """
         self._ensure_connected()
@@ -598,11 +598,11 @@ def get_metadata_field_unique_values(
         """
         Return distinct values for the given metadata field with optional filtering and pagination.
 
-        :param metadata_field: Metadata field name. May include or omit the ``meta.`` prefix.
+        :param metadata_field: Metadata field name. May include or omit the `meta.` prefix.
         :param search_term: Optional substring filter applied to string field values.
         :param size: Maximum number of values to return per page. Defaults to 10 000.
-        :param after: Pagination cursor returned by a previous call. Pass ``None`` for the first page.
-        :returns: Tuple of ``(values, next_cursor)``. ``next_cursor`` is ``None`` on the last page.
+        :param after: Pagination cursor returned by a previous call. Pass `None` for the first page.
+        :returns: Tuple of `(values, next_cursor)`. `next_cursor` is `None` on the last page.
         """
         self._ensure_connected()
         field = metadata_field[5:] if metadata_field.startswith("meta.") else metadata_field

integrations/falkordb/tests/test_document_store.py

@@ -277,6 +277,90 @@ def test_write_documents_wraps_errors(self, mock_falkordb):
         with pytest.raises(DocumentStoreError, match="Failed to write documents"):
             FalkorDBDocumentStore().write_documents([Document(id="a", content="x")], policy=DuplicatePolicy.OVERWRITE)
 
+    def test_delete_all_documents(self, mock_falkordb):
+        _, _, graph = mock_falkordb
+        graph.query.side_effect = [_result([]), _result([]), _result([])]
+        FalkorDBDocumentStore().delete_all_documents()
+        assert "DETACH DELETE" in graph.query.call_args_list[-1].args[0]
+
+    def test_delete_by_filter_returns_count(self, mock_falkordb):
+        _, _, graph = mock_falkordb
+        graph.query.side_effect = [_result([]), _result([]), _result([[3]]), _result([])]
+        count = FalkorDBDocumentStore().delete_by_filter({"field": "year", "operator": "==", "value": 2024})
+        assert count == 3
+        assert "DETACH DELETE" in graph.query.call_args_list[-1].args[0]
+
+    def test_delete_by_filter_empty_result(self, mock_falkordb):
+        _, _, graph = mock_falkordb
+        graph.query.side_effect = [_result([]), _result([]), _result([]), _result([])]
+        assert FalkorDBDocumentStore().delete_by_filter({"field": "year", "operator": "==", "value": 2024}) == 0
+
+    def test_update_by_filter_returns_count(self, mock_falkordb):
+        _, _, graph = mock_falkordb
+        graph.query.side_effect = [_result([]), _result([]), _result([[2]])]
+        count = FalkorDBDocumentStore().update_by_filter(
+            {"field": "year", "operator": "==", "value": 2024}, {"status": "published"}
+        )
+        assert count == 2
+        assert "SET d +=" in graph.query.call_args_list[-1].args[0]
+
+    def test_update_by_filter_strips_meta_prefix(self, mock_falkordb):
+        _, _, graph = mock_falkordb
+        graph.query.side_effect = [_result([]), _result([]), _result([[1]])]
+        FalkorDBDocumentStore().update_by_filter(
+            {"field": "year", "operator": "==", "value": 2024}, {"meta.status": "published"}
+        )
+        assert graph.query.call_args_list[-1].args[1]["meta_update"] == {"status": "published"}
+
+    @pytest.mark.parametrize("rows, expected", [([[5]], 5), ([], 0)])
+    def test_count_documents_by_filter(self, mock_falkordb, rows, expected):
+        _, _, graph = mock_falkordb
+        graph.query.side_effect = [_result([]), _result([]), _result(rows)]
+        count = FalkorDBDocumentStore().count_documents_by_filter({"field": "year", "operator": "==", "value": 2024})
+        assert count == expected
+
+    def test_count_unique_metadata_by_filter(self, mock_falkordb):
+        _, _, graph = mock_falkordb
+        graph.query.side_effect = [_result([]), _result([]), _result([[3]]), _result([[2]])]
+        result = FalkorDBDocumentStore().count_unique_metadata_by_filter({}, ["category", "status"])
+        assert result == {"category": 3, "status": 2}
+
+    def test_get_metadata_fields_info(self, mock_falkordb):
+        _, _, graph = mock_falkordb
+        graph.query.side_effect = [
+            _result([]),
+            _result([]),
+            _result([[["category", "year"]]]),
+            _result([["A"]]),
+            _result([[2024]]),
+        ]
+        info = FalkorDBDocumentStore().get_metadata_fields_info()
+        assert info["category"] == {"type": "str"}
+        assert info["year"] == {"type": "int"}
+
+    @pytest.mark.parametrize(
+        "rows, expected",
+        [([[2020, 2024]], {"min": 2020, "max": 2024}), ([], {"min": None, "max": None})],
+    )
+    def test_get_metadata_field_min_max(self, mock_falkordb, rows, expected):
+        _, _, graph = mock_falkordb
+        graph.query.side_effect = [_result([]), _result([]), _result(rows)]
+        assert FalkorDBDocumentStore().get_metadata_field_min_max("year") == expected
+
+    def test_get_metadata_field_unique_values(self, mock_falkordb):
+        _, _, graph = mock_falkordb
+        graph.query.side_effect = [_result([]), _result([]), _result([["A"], ["B"], ["C"]])]
+        values, cursor = FalkorDBDocumentStore().get_metadata_field_unique_values("category", size=10)
+        assert values == ["A", "B", "C"]
+        assert cursor is None
+
+    def test_get_metadata_field_unique_values_pagination(self, mock_falkordb):
+        _, _, graph = mock_falkordb
+        graph.query.side_effect = [_result([]), _result([]), _result([["A"], ["B"], ["C"]])]
+        values, cursor = FalkorDBDocumentStore().get_metadata_field_unique_values("category", size=2)
+        assert values == ["A", "B"]
+        assert cursor == {"offset": 2}
+
 
 @pytest.mark.integration
 class TestDocumentStore(