added tests for filter conditions

Author: daniel-sanche

google/cloud/firestore_v1/pipeline_expressions.py

@@ -385,9 +385,11 @@ def __init__(
         self,
         *args,
         use_infix_repr:bool = True,
+        infix_name_override:str | None= None,
         **kwargs,
     ):
         self._use_infix_repr = use_infix_repr
+        self._infix_name_override = infix_name_override
         super().__init__(*args, **kwargs)
 
     def __repr__(self):
@@ -397,10 +399,11 @@ def __repr__(self):
         Display them this way in the repr string where possible
         """
         if self._use_infix_repr:
+            infix_name = self._infix_name_override or self.name
             if len(self.params) == 1:
-                return f"{self.params[0]!r}.{self.name}()"
+                return f"{self.params[0]!r}.{infix_name}()"
             elif len(self.params) == 2:
-                return f"{self.params[0]!r}.{self.name}({self.params[1]!r})"
+                return f"{self.params[0]!r}.{infix_name}({self.params[1]!r})"
         return super().__repr__()
 
     @staticmethod
@@ -518,7 +521,7 @@ class In(FilterCondition):
     """Represents checking if an expression's value is within a list of values."""
 
     def __init__(self, left: Expr, others: List[Expr]):
-        super().__init__("in", [left, ListOfExprs(others)])
+        super().__init__("in", [left, ListOfExprs(others)], infix_name_override="in_any")
 
 
 class IsNaN(FilterCondition):

tests/unit/v1/test_pipeline_expressions.py

@@ -22,7 +22,7 @@
 from google.cloud.firestore_v1.types.document import Value
 from google.cloud.firestore_v1.vector import Vector
 from google.cloud.firestore_v1._helpers import GeoPoint
-from google.cloud.firestore_v1.pipeline_expressions import FilterCondition
+from google.cloud.firestore_v1.pipeline_expressions import FilterCondition, ListOfExprs
 import google.cloud.firestore_v1.pipeline_expressions as expr
 
 
@@ -41,29 +41,6 @@ def test_ctor(self):
         with pytest.raises(TypeError):
             expr.Expr()
 
-    @pytest.mark.parametrize("method,args,result_cls", [
-        ("eq", (None,), expr.Eq),
-        ("neq", (None,), expr.Neq),
-        ("lt", (None,), expr.Lt),
-        ("lte", (None,), expr.Lte),
-        ("gt", (None,), expr.Gt),
-        ("gte", (None,), expr.Gte),
-        ("in_any", ([None],), expr.In),
-        ("not_in_any", ([None],),expr.Not),
-        ("array_contains", (None,), expr.ArrayContains),
-        ("array_contains_any", ([None],), expr.ArrayContainsAny),
-        ("is_nan", (), expr.IsNaN),
-        ("exists", (), expr.Exists),
-    ])
-    def test_methods(self, method, args, result_cls):
-        """
-        base expr should have methods for certain stages
-        """
-        method_ptr = getattr(expr.Expr, method)
-        result = method_ptr(mock.Mock(), *args)
-        assert isinstance(result, result_cls)
-
-
 
 class TestConstant:
     @pytest.mark.parametrize(
@@ -442,3 +419,148 @@ def test__from_query_filter_pb_unknown_filter_type(self, mock_client):
         # Test with an unexpected protobuf type
         with pytest.raises(TypeError, match="Unexpected filter type"):
             FilterCondition._from_query_filter_pb(document_pb.Value(), mock_client)
+
+
+    @pytest.mark.parametrize("method,args,result_cls", [
+        ("eq", (2,), expr.Eq),
+        ("neq", (2,), expr.Neq),
+        ("lt", (2,), expr.Lt),
+        ("lte", (2,), expr.Lte),
+        ("gt", (2,), expr.Gt),
+        ("gte", (2,), expr.Gte),
+        ("in_any", ([None],), expr.In),
+        ("not_in_any", ([None],), expr.Not),
+        ("array_contains", (None,), expr.ArrayContains),
+        ("array_contains_any", ([None],), expr.ArrayContainsAny),
+        ("is_nan", (), expr.IsNaN),
+        ("exists", (), expr.Exists),
+    ])
+    def test_infix_call(self, method, args, result_cls):
+        """
+        most FilterExpressions should support infix execution
+        """
+        base_instance = expr.Constant(1)
+        method_ptr = getattr(base_instance, method)
+
+        result = method_ptr(*args)
+        assert isinstance(result, result_cls)
+
+    def _make_arg(self, name="Mock"):
+        arg = mock.Mock()
+        arg.__repr__ = lambda x: name
+        return arg
+
+    def test_and(self):
+        arg1 = self._make_arg()
+        arg2 = self._make_arg()
+        instance = expr.And(arg1, arg2)
+        assert instance.name == "and"
+        assert instance.params == [arg1, arg2]
+        assert repr(instance) == "And(Mock, Mock)"
+
+    def test_or(self):
+        arg1 = self._make_arg("Arg1")
+        arg2 = self._make_arg("Arg2")
+        instance = expr.Or(arg1, arg2)
+        assert instance.name == "or"
+        assert instance.params == [arg1, arg2]
+        assert repr(instance) == "Or(Arg1, Arg2)"
+
+    def test_array_contains(self):
+        arg1 = self._make_arg("ArrayField")
+        arg2 = self._make_arg("Element")
+        instance = expr.ArrayContains(arg1, arg2)
+        assert instance.name == "array_contains"
+        assert instance.params == [arg1, arg2]
+        assert repr(instance) == "ArrayField.array_contains(Element)"
+
+    def test_array_contains_any(self):
+        arg1 = self._make_arg("ArrayField")
+        arg2 = self._make_arg("Element1")
+        arg3 = self._make_arg("Element2")
+        instance = expr.ArrayContainsAny(arg1, [arg2, arg3])
+        assert instance.name == "array_contains_any"
+        assert isinstance(instance.params[1], ListOfExprs)
+        assert instance.params[0] == arg1
+        assert instance.params[1].exprs == [arg2, arg3]
+        assert repr(instance) == "ArrayField.array_contains_any(ListOfExprs([Element1, Element2]))"
+
+    def test_exists(self):
+        arg1 = self._make_arg("Field")
+        instance = expr.Exists(arg1)
+        assert instance.name == "exists"
+        assert instance.params == [arg1]
+        assert repr(instance) == "Field.exists()"
+
+    def test_eq(self):
+        arg1 = self._make_arg("Left")
+        arg2 = self._make_arg("Right")
+        instance = expr.Eq(arg1, arg2)
+        assert instance.name == "eq"
+        assert instance.params == [arg1, arg2]
+        assert repr(instance) == "Left.eq(Right)"
+
+    def test_gte(self):
+        arg1 = self._make_arg("Left")
+        arg2 = self._make_arg("Right")
+        instance = expr.Gte(arg1, arg2)
+        assert instance.name == "gte"
+        assert instance.params == [arg1, arg2]
+        assert repr(instance) == "Left.gte(Right)"
+
+    def test_gt(self):
+        arg1 = self._make_arg("Left")
+        arg2 = self._make_arg("Right")
+        instance = expr.Gt(arg1, arg2)
+        assert instance.name == "gt"
+        assert instance.params == [arg1, arg2]
+        assert repr(instance) == "Left.gt(Right)"
+
+    def test_lte(self):
+        arg1 = self._make_arg("Left")
+        arg2 = self._make_arg("Right")
+        instance = expr.Lte(arg1, arg2)
+        assert instance.name == "lte"
+        assert instance.params == [arg1, arg2]
+        assert repr(instance) == "Left.lte(Right)"
+
+    def test_lt(self):
+        arg1 = self._make_arg("Left")
+        arg2 = self._make_arg("Right")
+        instance = expr.Lt(arg1, arg2)
+        assert instance.name == "lt"
+        assert instance.params == [arg1, arg2]
+        assert repr(instance) == "Left.lt(Right)"
+
+    def test_neq(self):
+        arg1 = self._make_arg("Left")
+        arg2 = self._make_arg("Right")
+        instance = expr.Neq(arg1, arg2)
+        assert instance.name == "neq"
+        assert instance.params == [arg1, arg2]
+        assert repr(instance) == "Left.neq(Right)"
+
+    def test_in(self):
+        arg1 = self._make_arg("Field")
+        arg2 = self._make_arg("Value1")
+        arg3 = self._make_arg("Value2")
+        instance = expr.In(arg1, [arg2, arg3])
+        assert instance.name == "in"
+        assert isinstance(instance.params[1], ListOfExprs)
+        assert instance.params[0] == arg1
+        assert instance.params[1].exprs == [arg2, arg3]
+        assert repr(instance) == "Field.in_any(ListOfExprs([Value1, Value2]))"
+
+    def test_is_nan(self):
+        arg1 = self._make_arg("Value")
+        instance = expr.IsNaN(arg1)
+        assert instance.name == "is_nan"
+        assert instance.params == [arg1]
+        assert repr(instance) == "Value.is_nan()"
+
+    def test_not(self):
+        arg1 = self._make_arg("Condition")
+        instance = expr.Not(arg1)
+        assert instance.name == "not"
+        assert instance.params == [arg1]
+        assert repr(instance) == "Not(Condition)"