fixing filter tests and removing unit tests covered by integration tests

Author: davidsbatista

integrations/supabase/src/haystack_integrations/document_stores/supabase/groonga_document_store.py

@@ -217,24 +217,46 @@ def _apply_filters(query: Any, filters: dict[str, Any]) -> Any:
                 query = SupabaseGroongaDocumentStore._apply_filters(query, cond)
             return query
 
-        if op in ("OR", "NOT"):
-            neg_map = {"==": "neq", "!=": "eq", ">": "lte", ">=": "lt", "<": "gte", "<=": "gt"}
+        if op == "OR":
             pg_op_map = {"==": "eq", "!=": "neq", ">": "gt", ">=": "gte", "<": "lt", "<=": "lte"}
-            op_map = neg_map if op == "NOT" else pg_op_map
             parts = []
             for cond in conditions:
                 if "field" not in cond:
-                    msg = f"Nested logical operators inside {op} are not supported."
+                    msg = "Nested logical operators inside OR are not supported."
+                    raise FilterError(msg)
+                cond_field = cond.get("field", "")
+                cond_op = cond.get("operator", "")
+                cond_value = cond.get("value")
+                if cond_op not in pg_op_map:
+                    msg = f"Operator '{cond_op}' inside OR filter is not supported."
+                    raise FilterError(msg)
+                # Use text accessor (->>): PostgREST OR strings don't support JSONB (->) expressions.
+                col = f"meta->>{cond_field[len('meta.'):]}" if cond_field.startswith("meta.") else cond_field
+                norm = SupabaseGroongaDocumentStore._normalize_value(cond_value)
+                parts.append(f"{col}.{pg_op_map[cond_op]}.{norm}")
+            return query.or_(",".join(parts))
+
+        if op == "NOT":
+            # NOT(A AND B) = NOT_A OR NOT_B, with null-inclusive semantics.
+            # Use text accessor: PostgREST OR strings don't support JSONB (->) expressions.
+            neg_map = {"==": "neq", "!=": "eq", ">": "lte", ">=": "lt", "<": "gte", "<=": "gt"}
+            parts = []
+            for cond in conditions:
+                if "field" not in cond:
+                    msg = "Nested logical operators inside NOT are not supported."
                     raise FilterError(msg)
                 cond_field = cond.get("field", "")
                 cond_op = cond.get("operator", "")
                 cond_value = cond.get("value")
-                if cond_op not in op_map:
-                    msg = f"Operator '{cond_op}' inside {op} filter is not supported."
+                if cond_op not in neg_map:
+                    msg = f"Operator '{cond_op}' inside NOT filter is not supported."
                     raise FilterError(msg)
-                col = SupabaseGroongaDocumentStore._meta_col(cond_field, cond_value)
+                col = f"meta->>{cond_field[len('meta.'):]}" if cond_field.startswith("meta.") else cond_field
                 norm = SupabaseGroongaDocumentStore._normalize_value(cond_value)
-                parts.append(f"{col}.{op_map[cond_op]}.{norm}")
+                parts.append(f"{col}.{neg_map[cond_op]}.{norm}")
+                if cond_op == "==" and cond_field.startswith("meta."):
+                    # NOT(field==value) also covers docs where the field is absent (SQL NULL semantics)
+                    parts.append(f"{col}.is.null")
             return query.or_(",".join(parts))
 
         msg = f"Filter operator '{op}' is not supported. Supported logical operators: AND, OR, NOT."
@@ -262,7 +284,13 @@ def _apply_condition(query: Any, condition: dict[str, Any]) -> Any:
             return query.is_(col, "null") if norm is None else query.eq(col, norm)
 
         if op == "!=":
-            return query.not_.is_(col, "null") if norm is None else query.neq(col, norm)
+            if norm is None:
+                return query.not_.is_(col, "null")
+            if field.startswith("meta."):
+                # SQL: NULL != value returns NULL (not TRUE), so include docs where the field is absent.
+                key = field[len("meta."):]
+                return query.or_(f"{col}.neq.{norm},meta->>{key}.is.null")
+            return query.neq(col, norm)
 
         if op in (">", ">=", "<", "<="):
             if isinstance(value, list):
@@ -294,6 +322,12 @@ def _apply_condition(query: Any, condition: dict[str, Any]) -> Any:
             if not isinstance(value, list):
                 msg = "Filter operator 'not in' requires a list value."
                 raise FilterError(msg)
+            if field.startswith("meta."):
+                # SQL: NULL NOT IN (...) returns NULL, so include docs where the field is absent.
+                key = field[len("meta."):]
+                non_none = [v for v in value if v is not None]
+                vals = ",".join(str(v) for v in non_none)
+                return query.or_(f"{col}.not.in.({vals}),meta->>{key}.is.null")
             return query.not_.in_(col, value)
 
         return query

integrations/supabase/tests/test_groonga_document_store.py

@@ -134,51 +134,6 @@ def test_write_documents_fail_on_duplicate(self, groonga_store, mock_supabase_cl
         with pytest.raises(DuplicateDocumentError):
             groonga_store.write_documents([Document(content="duplicate doc")], policy=DuplicatePolicy.FAIL)
 
-    def test_delete_by_filter(self, groonga_store, mock_supabase_client):
-        mock_table = mock_supabase_client.table.return_value
-        mock_table.select.return_value.execute.return_value = MagicMock(
-            data=[{"id": "1", "content": "doc one", "meta": {"lang": "en"}, "score": None}]
-        )
-        mock_table.delete.return_value.in_.return_value.execute.return_value = MagicMock(data=[])
-
-        deleted = groonga_store.delete_by_filter(
-            filters={"conditions": [{"field": "meta.lang", "operator": "==", "value": "en"}]}
-        )
-        assert deleted == 1
-
-    def test_delete_by_filter_no_matches(self, groonga_store, mock_supabase_client):
-        mock_supabase_client.table.return_value.select.return_value.execute.return_value = MagicMock(data=[])
-
-        deleted = groonga_store.delete_by_filter(
-            filters={"conditions": [{"field": "meta.lang", "operator": "==", "value": "fr"}]}
-        )
-        assert deleted == 0
-
-    def test_update_by_filter(self, groonga_store, mock_supabase_client):
-        mock_table = mock_supabase_client.table.return_value
-        mock_table.select.return_value.execute.return_value = MagicMock(
-            data=[{"id": "1", "content": "doc one", "meta": {"lang": "en"}, "score": None}]
-        )
-        mock_table.upsert.return_value.execute.return_value = MagicMock(data=[{}])
-
-        updated = groonga_store.update_by_filter(
-            filters={"conditions": [{"field": "meta.lang", "operator": "==", "value": "en"}]},
-            meta={"reviewed": True},
-        )
-        assert updated == 1
-        mock_table.upsert.assert_called_once()
-        upserted_row = mock_table.upsert.call_args[0][0]
-        assert upserted_row["meta"] == {"lang": "en", "reviewed": True}
-
-    def test_update_by_filter_no_matches(self, groonga_store, mock_supabase_client):
-        mock_supabase_client.table.return_value.select.return_value.execute.return_value = MagicMock(data=[])
-
-        updated = groonga_store.update_by_filter(
-            filters={"conditions": [{"field": "meta.lang", "operator": "==", "value": "fr"}]},
-            meta={"reviewed": True},
-        )
-        assert updated == 0
-
     def test_delete_all_documents(self, groonga_store, mock_supabase_client):
         mock_table = mock_supabase_client.table.return_value
         mock_table.delete.return_value.neq.return_value.execute.return_value = MagicMock(data=[])
@@ -214,7 +169,7 @@ def test_filter_documents_with_filters(self, groonga_store, mock_supabase_client
         mock_table.select.return_value.eq.return_value.execute.return_value = MagicMock(
             data=[{"id": "1", "content": "Python is great", "meta": {"language": "en"}, "score": None}]
         )
-        filters = {"conditions": [{"field": "meta.language", "operator": "==", "value": "en"}]}
+        filters = {"operator": "AND", "conditions": [{"field": "meta.language", "operator": "==", "value": "en"}]}
         docs = groonga_store.filter_documents(filters=filters)
         assert len(docs) == 1