weaviate-haystack 7.9.0__tar.gz → 8.0.0__tar.gz

{weaviate_haystack-7.9.0 → weaviate_haystack-8.0.0}/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [integrations/weaviate-v7.9.0] - 2026-09-21
+
+### 🚀 Features
+
+- Send X-Weaviate-Client-Integration telemetry header (#3954)
+
+### ⚙️ CI
+
+- Improve changelog generation; fix existing changelogs (#3883)
+
+### 🧹 Chores
+
+- Raise weaviate-client floor and test against Weaviate 1.39 (#3956)
+
+
 ## [integrations/weaviate-v7.8.0] - 2026-09-01
 
 ### 🐛 Bug Fixes

{weaviate_haystack-7.9.0 → weaviate_haystack-8.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: weaviate-haystack
-Version: 7.9.0
+Version: 8.0.0
 Summary: An integration of Weaviate vector database with Haystack
 Project-URL: Source, https://github.com/deepset-ai/haystack-core-integrations
 Project-URL: Documentation, https://github.com/deepset-ai/haystack-core-integrations/blob/main/integrations/weaviate/README.md
@@ -11,14 +11,13 @@ License-File: LICENSE.txt
 Classifier: Development Status :: 4 - Beta
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Requires-Dist: haystack-ai>=2.28.0
 Requires-Dist: python-dateutil>=2.7.0
 Requires-Dist: weaviate-client>=4.23.0

{weaviate_haystack-7.9.0 → weaviate_haystack-8.0.0}/pyproject.toml

@@ -7,7 +7,7 @@ name = "weaviate-haystack"
 dynamic = ["version"]
 description = "An integration of Weaviate vector database with Haystack"
 readme = "README.md"
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 license = "Apache-2.0"
 keywords = []
 authors = [{ name = "deepset GmbH", email = "info@deepset.ai" }]
@@ -15,7 +15,6 @@ classifiers = [
   "License :: OSI Approved :: Apache Software License",
   "Development Status :: 4 - Beta",
   "Programming Language :: Python",
-  "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: 3.13",

{weaviate_haystack-7.9.0 → weaviate_haystack-8.0.0}/src/haystack_integrations/components/retrievers/weaviate/embedding_retriever.py

@@ -143,8 +143,8 @@ class WeaviateEmbeddingRetriever:
         filters = apply_filter_policy(self._filter_policy, self._filters, filters)
         top_k = top_k or self._top_k
 
-        distance = distance or self._distance
-        certainty = certainty or self._certainty
+        distance = self._distance if distance is None else distance
+        certainty = self._certainty if certainty is None else certainty
         if distance is not None and certainty is not None:
             msg = f"Can't use 'distance' ({distance}) and 'certainty' ({certainty}) parameters together"
             raise ValueError(msg)
@@ -191,8 +191,8 @@ class WeaviateEmbeddingRetriever:
         filters = apply_filter_policy(self._filter_policy, self._filters, filters)
         top_k = top_k or self._top_k
 
-        distance = distance or self._distance
-        certainty = certainty or self._certainty
+        distance = self._distance if distance is None else distance
+        certainty = self._certainty if certainty is None else certainty
         if distance is not None and certainty is not None:
             msg = f"Can't use 'distance' ({distance}) and 'certainty' ({certainty}) parameters together"
             raise ValueError(msg)

{weaviate_haystack-7.9.0 → weaviate_haystack-8.0.0}/src/haystack_integrations/document_stores/weaviate/_filters.py

@@ -33,6 +33,10 @@ def convert_filters(filters: dict[str, Any]) -> FilterReturn:
     Note: The ``contains`` operator performs substring matching and is
     **case-sensitive**. For case-insensitive matching, normalize the value
     (e.g., lowercase) before building the filter.
+
+    Note: ``NOT`` is applied client-side by inverting its conditions (De Morgan), so it works
+    on any Weaviate version. The only exception is ``NOT`` over ``contains``, which has no
+    invertible counterpart and uses Weaviate's native ``NOT`` operator (Weaviate 1.33 or later).
     """
     if not isinstance(filters, dict):
         msg = "Filters must be a dictionary"
@@ -43,7 +47,13 @@ def convert_filters(filters: dict[str, Any]) -> FilterReturn:
     return _parse_logical_condition(filters)
 
 
-OPERATOR_INVERSE = {
+LOGICAL_OPERATORS = {
+    "AND": Filter.all_of,
+    "OR": Filter.any_of,
+}
+
+
+COMPARISON_INVERSE = {
     "==": "!=",
     "!=": "==",
     ">": "<=",
@@ -52,38 +62,10 @@ OPERATOR_INVERSE = {
     "<=": ">",
     "in": "not in",
     "not in": "in",
-    "AND": "OR",
-    "OR": "AND",
-    "NOT": "OR",
-}
-
-
-def _invert_condition(filters: dict[str, Any]) -> dict[str, Any]:
-    """
-    Invert condition recursively.
-
-    Weaviate doesn't support NOT filters so we need to invert them ourselves.
-    """
-    inverted_condition = filters.copy()
-    if "operator" not in filters:
-        # Let's not handle this stuff in here, we'll fail later on anyway.
-        return inverted_condition
-    inverted_condition["operator"] = OPERATOR_INVERSE[filters["operator"]]
-    if "conditions" in filters:
-        inverted_condition["conditions"] = []
-        for condition in filters["conditions"]:
-            inverted_condition["conditions"].append(_invert_condition(condition))
-
-    return inverted_condition
-
-
-LOGICAL_OPERATORS = {
-    "AND": Filter.all_of,
-    "OR": Filter.any_of,
 }
 
 
-def _parse_logical_condition(condition: dict[str, Any]) -> FilterReturn:
+def _validate_logical_condition(condition: dict[str, Any]) -> None:
     if "operator" not in condition:
         msg = f"'operator' key missing in {condition}"
         raise FilterError(msg)
@@ -91,23 +73,55 @@ def _parse_logical_condition(condition: dict[str, Any]) -> FilterReturn:
         msg = f"'conditions' key missing in {condition}"
         raise FilterError(msg)
 
+
+def _parse_logical_condition(condition: dict[str, Any]) -> FilterReturn:
+    _validate_logical_condition(condition)
+
     operator = condition["operator"]
     if operator in ["AND", "OR"]:
-        operands = []
-        for c in condition["conditions"]:
-            if "field" not in c:
-                operands.append(_parse_logical_condition(c))
-            else:
-                operands.append(_parse_comparison_condition(c))
-        return LOGICAL_OPERATORS[operator](operands)
+        return LOGICAL_OPERATORS[operator](_parse_operands(condition["conditions"]))
+    elif operator == "NOT":
+        # A NOT node negates the conjunction of its conditions: NOT(a AND b) == NOT(a) OR NOT(b).
+        return Filter.any_of([_negate(c) for c in condition["conditions"]])
+    else:
+        msg = f"Unknown logical operator '{operator}'"
+        raise FilterError(msg)
+
+
+def _negate(condition: dict[str, Any]) -> FilterReturn:
+    """
+    Build the negation of a condition by applying De Morgan's laws.
+
+    Negation is done client-side so that it works on Weaviate versions without a native NOT operator.
+    """
+    if "field" in condition:
+        operator = condition.get("operator")
+        if operator in COMPARISON_INVERSE:
+            return _parse_comparison_condition({**condition, "operator": COMPARISON_INVERSE[operator]})
+        # Operators like `contains` have no invertible counterpart, so we fall back to Weaviate's
+        # native NOT, which requires Weaviate 1.33 or later.
+        # Unknown operators raise a FilterError while parsing the condition.
+        return Filter.not_(_parse_comparison_condition(condition))
+
+    _validate_logical_condition(condition)
+    operator = condition["operator"]
+    conditions = condition["conditions"]
+    if operator == "AND":
+        return Filter.any_of([_negate(c) for c in conditions])
+    elif operator == "OR":
+        return Filter.all_of([_negate(c) for c in conditions])
     elif operator == "NOT":
-        inverted_conditions = _invert_condition(condition)
-        return _parse_logical_condition(inverted_conditions)
+        # The two negations cancel out, leaving the conjunction of the conditions.
+        return Filter.all_of(_parse_operands(conditions))
     else:
         msg = f"Unknown logical operator '{operator}'"
         raise FilterError(msg)
 
 
+def _parse_operands(conditions: list[dict[str, Any]]) -> list[FilterReturn]:
+    return [_parse_comparison_condition(c) if "field" in c else _parse_logical_condition(c) for c in conditions]
+
+
 def _handle_date(value: Any) -> str:
     if isinstance(value, str):
         try:
@@ -282,6 +296,10 @@ def _parse_comparison_condition(condition: dict[str, Any]) -> FilterReturn:
     operator: str = condition["operator"]
     value: Any = condition["value"]
 
+    if operator not in COMPARISON_OPERATORS:
+        msg = f"Unknown comparison operator '{operator}'. Valid operators are: {list(COMPARISON_OPERATORS.keys())}"
+        raise FilterError(msg)
+
     return COMPARISON_OPERATORS[operator](field, value)
 
 

{weaviate_haystack-7.9.0 → weaviate_haystack-8.0.0}/src/haystack_integrations/document_stores/weaviate/document_store.py

@@ -3,7 +3,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import base64
-import datetime
+import datetime as dt
 import importlib.metadata
 import json
 from contextlib import suppress
@@ -876,7 +876,7 @@ class WeaviateDocumentStore:
         document_data.pop("blob_mime_type", None)
 
         for key, value in document_data.items():
-            if isinstance(value, datetime.datetime):
+            if isinstance(value, dt.datetime):
                 document_data[key] = value.strftime("%Y-%m-%dT%H:%M:%SZ")
 
         if weaviate_meta := getattr(data, "metadata", None):
@@ -983,6 +983,9 @@ class WeaviateDocumentStore:
         matching). For case-insensitive matching, normalize the value before
         building the filter.
 
+        Note: ``NOT`` over the ``contains`` operator is translated to Weaviate's
+        native ``NOT``, which requires Weaviate 1.33 or later.
+
         :param filters: The filters to apply to the document list.
         :returns: A list of Documents that match the given filters.
         """
@@ -1006,6 +1009,9 @@ class WeaviateDocumentStore:
         matching). For case-insensitive matching, normalize the value before
         building the filter.
 
+        Note: ``NOT`` over the ``contains`` operator is translated to Weaviate's
+        native ``NOT``, which requires Weaviate 1.33 or later.
+
         :param filters: The filters to apply to the document list.
         :returns: A list of Documents that match the given filters.
         """

{weaviate_haystack-7.9.0 → weaviate_haystack-8.0.0}/tests/test_bm25_retriever.py

@@ -2,9 +2,10 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from unittest.mock import Mock, patch
+from unittest.mock import create_autospec, patch
 
 import pytest
+from haystack import Pipeline
 from haystack.document_stores.types import FilterPolicy
 
 from haystack_integrations.components.retrievers.weaviate import WeaviateBM25Retriever
@@ -12,7 +13,7 @@ from haystack_integrations.document_stores.weaviate import WeaviateDocumentStore
 
 
 def test_close():
-    mock_document_store = Mock(spec=WeaviateDocumentStore)
+    mock_document_store = create_autospec(WeaviateDocumentStore, instance=True)
     retriever = WeaviateBM25Retriever(document_store=mock_document_store)
 
     retriever.close()
@@ -22,7 +23,7 @@ def test_close():
 
 
 def test_init_default():
-    mock_document_store = Mock(spec=WeaviateDocumentStore)
+    mock_document_store = create_autospec(WeaviateDocumentStore, instance=True)
     retriever = WeaviateBM25Retriever(document_store=mock_document_store)
     assert retriever._document_store == mock_document_store
     assert retriever._filters == {}
@@ -153,10 +154,24 @@ def test_from_dict_no_filter_policy(_mock_weaviate):
     assert retriever._filter_policy == FilterPolicy.REPLACE
 
 
-@patch("haystack_integrations.components.retrievers.weaviate.bm25_retriever.WeaviateDocumentStore")
-def test_run(mock_document_store):
+def test_run():
+    mock_document_store = create_autospec(WeaviateDocumentStore, instance=True)
     retriever = WeaviateBM25Retriever(document_store=mock_document_store)
     query = "some query"
     filters = {"field": "content", "operator": "==", "value": "Some text"}
     retriever.run(query=query, filters=filters, top_k=5)
     mock_document_store._bm25_retrieval.assert_called_once_with(query=query, filters=filters, top_k=5)
+
+
+def test_pipeline_serde():
+    """A pipeline holding the retriever must survive a dumps/loads round trip, nested store included."""
+    document_store = WeaviateDocumentStore(url="http://localhost:8080")
+    pipeline = Pipeline()
+    pipeline.add_component("retriever", WeaviateBM25Retriever(document_store=document_store, top_k=3))
+
+    reloaded = Pipeline.loads(pipeline.dumps()).get_component("retriever")
+
+    assert isinstance(reloaded, WeaviateBM25Retriever)
+    assert isinstance(reloaded._document_store, WeaviateDocumentStore)
+    assert reloaded._document_store.to_dict() == document_store.to_dict()
+    assert reloaded._top_k == 3

{weaviate_haystack-7.9.0 → weaviate_haystack-8.0.0}/tests/test_bm25_retriever_async.py

@@ -2,7 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from unittest.mock import AsyncMock, Mock
+from unittest.mock import create_autospec
 
 import pytest
 
@@ -12,8 +12,7 @@ from haystack_integrations.document_stores.weaviate import WeaviateDocumentStore
 
 @pytest.mark.asyncio
 async def test_close_async():
-    mock_document_store = Mock(spec=WeaviateDocumentStore)
-    mock_document_store.close_async = AsyncMock()
+    mock_document_store = create_autospec(WeaviateDocumentStore, instance=True)
     retriever = WeaviateBM25Retriever(document_store=mock_document_store)
 
     await retriever.close_async()
@@ -24,8 +23,8 @@ async def test_close_async():
 
 @pytest.mark.asyncio
 async def test_run_async_calls_async_retrieval():
-    mock_document_store = Mock(spec=WeaviateDocumentStore)
-    mock_document_store._bm25_retrieval_async = AsyncMock(return_value=[])
+    mock_document_store = create_autospec(WeaviateDocumentStore, instance=True)
+    mock_document_store._bm25_retrieval_async.return_value = []
 
     retriever = WeaviateBM25Retriever(document_store=mock_document_store)
 

{weaviate_haystack-7.9.0 → weaviate_haystack-8.0.0}/tests/test_document_store.py

@@ -305,76 +305,8 @@ def test_close_is_exception_safe():
     assert document_store._collection is None
 
 
-@pytest.mark.integration
-class TestWeaviateDocumentStore(
-    DocumentStoreBaseExtendedTests,
-    CountDocumentsByFilterTest,
-    CountUniqueMetadataByFilterTest,
-    GetMetadataFieldsInfoTest,
-    GetMetadataFieldMinMaxTest,
-    GetMetadataFieldUniqueValuesTest,
-):
-    @pytest.fixture
-    def document_store(self, request) -> Generator[WeaviateDocumentStore, None, None]:
-        # Use a different index for each test so we can run them in parallel
-        collection_settings = {
-            "class": f"{request.node.name}",
-            "invertedIndexConfig": {"indexNullState": True},
-            "properties": [
-                *DOCUMENT_COLLECTION_PROPERTIES,
-                {"name": "number", "dataType": ["int"]},
-                {"name": "date", "dataType": ["date"]},
-                {"name": "category", "dataType": ["text"]},
-                {"name": "status", "dataType": ["text"]},
-            ],
-        }
-        store = WeaviateDocumentStore(
-            url="http://localhost:8080",
-            collection_settings=collection_settings,
-        )
-        yield store
-        store.client.collections.delete(collection_settings["class"])
-        store.close()
-
-    @pytest.fixture
-    def filterable_docs(self) -> list[Document]:
-        """
-        This fixture has been copied from haystack/testing/document_store.py and modified to
-        use a different date format.
-        Weaviate forces RFC 3339 date strings.
-        The original fixture uses ISO 8601 date strings.
-        """
-        documents = create_filterable_docs()
-        for i in range(len(documents)):
-            if date := documents[i].meta.get("date"):
-                documents[i].meta["date"] = f"{date}Z"
-        return documents
-
-    def assert_documents_are_equal(self, received: list[Document], expected: list[Document]):
-        assert len(received) == len(expected)
-        received = sorted(received, key=lambda doc: doc.id)
-        expected = sorted(expected, key=lambda doc: doc.id)
-        for received_doc, expected_doc in zip(received, expected, strict=True):
-            received_doc_dict = received_doc.to_dict(flatten=False)
-            expected_doc_dict = expected_doc.to_dict(flatten=False)
-
-            # Weaviate stores embeddings with lower precision floats so we handle that here.
-            assert np_array_equal(
-                np_array(received_doc_dict.pop("embedding", None), dtype=np_float32),
-                np_array(expected_doc_dict.pop("embedding", None), dtype=np_float32),
-                equal_nan=True,
-            )
-
-            received_meta = received_doc_dict.pop("meta", None)
-            expected_meta = expected_doc_dict.pop("meta", None)
-
-            assert received_doc_dict == expected_doc_dict
-
-            # If a meta field is not set in a saved document, it will be None when retrieved
-            # from Weaviate so we need to handle that.
-            meta_keys = set(received_meta.keys()).union(set(expected_meta.keys()))
-            for key in meta_keys:
-                assert received_meta.get(key) == expected_meta.get(key)
+class TestWeaviateDocumentStoreSerde:
+    """Unit tests that need no running Weaviate: serialization and document conversion."""
 
     @patch("haystack_integrations.document_stores.weaviate.document_store.weaviate.WeaviateClient")
     def test_connection(self, mock_weaviate_client_class, monkeypatch):
@@ -427,22 +359,6 @@ class TestWeaviateDocumentStore(
             {"class": "My_collection", "properties": DOCUMENT_COLLECTION_PROPERTIES}
         )
 
-    def test_close_and_reopen(self, document_store: WeaviateDocumentStore) -> None:
-        # Initialise client and collection
-        assert document_store.client is not None
-        assert document_store.collection is not None
-
-        document_store.close()
-
-        assert document_store._client is None
-        assert document_store._collection is None
-
-        # Initialise client and collection, then test it stills works after reopening
-        assert document_store.client is not None
-        assert document_store.collection is not None
-
-        assert document_store.count_documents() == 0
-
     @patch("haystack_integrations.document_stores.weaviate.document_store.weaviate")
     def test_to_dict(self, _mock_weaviate, monkeypatch):
         monkeypatch.setenv("WEAVIATE_API_KEY", "my_api_key")
@@ -645,6 +561,109 @@ class TestWeaviateDocumentStore(
         assert doc.score is None
         assert doc.meta == {"key": "value"}
 
+    def test_schema_class_name_conversion_preserves_pascal_case(self):
+        collection_settings = {"class": "CaseDocument"}
+        doc_score = WeaviateDocumentStore(
+            url="http://localhost:8080",
+            collection_settings=collection_settings,
+        )
+        assert doc_score._collection_settings["class"] == "CaseDocument"
+
+        collection_settings = {"class": "lower_case_name"}
+        doc_score = WeaviateDocumentStore(
+            url="http://localhost:8080",
+            collection_settings=collection_settings,
+        )
+        assert doc_score._collection_settings["class"] == "Lower_case_name"
+
+
+@pytest.mark.integration
+class TestWeaviateDocumentStore(
+    DocumentStoreBaseExtendedTests,
+    CountDocumentsByFilterTest,
+    CountUniqueMetadataByFilterTest,
+    GetMetadataFieldsInfoTest,
+    GetMetadataFieldMinMaxTest,
+    GetMetadataFieldUniqueValuesTest,
+):
+    @pytest.fixture
+    def document_store(self, request) -> Generator[WeaviateDocumentStore, None, None]:
+        # Use a different index for each test so we can run them in parallel
+        collection_settings = {
+            "class": f"{request.node.name}",
+            "invertedIndexConfig": {"indexNullState": True},
+            "properties": [
+                *DOCUMENT_COLLECTION_PROPERTIES,
+                {"name": "number", "dataType": ["int"]},
+                {"name": "date", "dataType": ["date"]},
+                {"name": "category", "dataType": ["text"]},
+                {"name": "status", "dataType": ["text"]},
+            ],
+        }
+        store = WeaviateDocumentStore(
+            url="http://localhost:8080",
+            collection_settings=collection_settings,
+        )
+        yield store
+        store.client.collections.delete(collection_settings["class"])
+        store.close()
+
+    @pytest.fixture
+    def filterable_docs(self) -> list[Document]:
+        """
+        This fixture has been copied from haystack/testing/document_store.py and modified to
+        use a different date format.
+        Weaviate forces RFC 3339 date strings.
+        The original fixture uses ISO 8601 date strings.
+        """
+        documents = create_filterable_docs()
+        for i in range(len(documents)):
+            if date := documents[i].meta.get("date"):
+                documents[i].meta["date"] = f"{date}Z"
+        return documents
+
+    def assert_documents_are_equal(self, received: list[Document], expected: list[Document]):
+        assert len(received) == len(expected)
+        received = sorted(received, key=lambda doc: doc.id)
+        expected = sorted(expected, key=lambda doc: doc.id)
+        for received_doc, expected_doc in zip(received, expected, strict=True):
+            received_doc_dict = received_doc.to_dict(flatten=False)
+            expected_doc_dict = expected_doc.to_dict(flatten=False)
+
+            # Weaviate stores embeddings with lower precision floats so we handle that here.
+            assert np_array_equal(
+                np_array(received_doc_dict.pop("embedding", None), dtype=np_float32),
+                np_array(expected_doc_dict.pop("embedding", None), dtype=np_float32),
+                equal_nan=True,
+            )
+
+            received_meta = received_doc_dict.pop("meta", None)
+            expected_meta = expected_doc_dict.pop("meta", None)
+
+            assert received_doc_dict == expected_doc_dict
+
+            # If a meta field is not set in a saved document, it will be None when retrieved
+            # from Weaviate so we need to handle that.
+            meta_keys = set(received_meta.keys()).union(set(expected_meta.keys()))
+            for key in meta_keys:
+                assert received_meta.get(key) == expected_meta.get(key)
+
+    def test_close_and_reopen(self, document_store: WeaviateDocumentStore) -> None:
+        # Initialise client and collection
+        assert document_store.client is not None
+        assert document_store.collection is not None
+
+        document_store.close()
+
+        assert document_store._client is None
+        assert document_store._collection is None
+
+        # Initialise client and collection, then test it stills works after reopening
+        assert document_store.client is not None
+        assert document_store.collection is not None
+
+        assert document_store.count_documents() == 0
+
     def test_write_documents(self, document_store):
         """
         Test write_documents() with default policy overwrites existing documents.
@@ -756,6 +775,27 @@ class TestWeaviateDocumentStore(
             ],
         )
 
+    def test_nested_not_operator(self, document_store, filterable_docs):
+        """NOT(NOT(x)) must select the same Documents as x, matching `document_matches_filter`."""
+        document_store.write_documents(filterable_docs)
+        inner = {"field": "meta.number", "operator": "==", "value": 100}
+        nested_not = {"operator": "NOT", "conditions": [{"operator": "NOT", "conditions": [inner]}]}
+
+        result = document_store.filter_documents(nested_not)
+
+        self.assert_documents_are_equal(result, [d for d in filterable_docs if d.meta.get("number") == 100])
+
+    def test_not_operator_over_contains(self, document_store, filterable_docs):
+        """`contains` has no inverted counterpart, so negating it used to raise a bare KeyError."""
+        document_store.write_documents(filterable_docs)
+        filters = {"operator": "NOT", "conditions": [{"field": "meta.name", "operator": "contains", "value": "name_0"}]}
+
+        result = document_store.filter_documents(filters)
+
+        self.assert_documents_are_equal(
+            result, [d for d in filterable_docs if "name_0" not in (d.meta.get("name") or "")]
+        )
+
     def test_split_overlap_preserved(self, document_store):
         """Split overlap meta is written and read back correctly."""
         overlap = [
@@ -1072,21 +1112,6 @@ class TestWeaviateDocumentStore(
         with pytest.raises(DocumentStoreError):
             document_store.filter_documents({"field": "content", "operator": "==", "value": "This is some content"})
 
-    def test_schema_class_name_conversion_preserves_pascal_case(self):
-        collection_settings = {"class": "CaseDocument"}
-        doc_score = WeaviateDocumentStore(
-            url="http://localhost:8080",
-            collection_settings=collection_settings,
-        )
-        assert doc_score._collection_settings["class"] == "CaseDocument"
-
-        collection_settings = {"class": "lower_case_name"}
-        doc_score = WeaviateDocumentStore(
-            url="http://localhost:8080",
-            collection_settings=collection_settings,
-        )
-        assert doc_score._collection_settings["class"] == "Lower_case_name"
-
     @pytest.mark.skipif(
         not os.environ.get("WEAVIATE_API_KEY", None) and not os.environ.get("WEAVIATE_CLOUD_CLUSTER_URL", None),
         reason="Both WEAVIATE_API_KEY and WEAVIATE_CLOUD_CLUSTER_URL are not set. Skipping test.",