added stages unit tests

Author: daniel-sanche

tests/unit/v1/test_pipeline_expressions.py

@@ -41,6 +41,29 @@ 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(

tests/unit/v1/test_pipeline_stages.py

@@ -15,7 +15,11 @@
 import pytest
 
 import google.cloud.firestore_v1.pipeline_stages as stages
-from google.cloud.firestore_v1.pipeline_expressions import Constant
+from google.cloud.firestore_v1.pipeline_expressions import (
+    Constant,
+    Field,
+    Ordering,
+)
 from google.cloud.firestore_v1.types.document import Value
 from google.cloud.firestore_v1._helpers import GeoPoint
 
@@ -119,3 +123,107 @@ def test_to_pb(self):
         assert result.args[0].boolean_value is True
         assert result.args[1].string_value == "test"
         assert len(result.options) == 0
+
+
+class TestLimit:
+    def _make_one(self, *args, **kwargs):
+        return stages.Limit(*args, **kwargs)
+
+    def test_repr(self):
+        instance = self._make_one(10)
+        repr_str = repr(instance)
+        assert repr_str == "Limit(limit=10)"
+
+    def test_to_pb(self):
+        instance = self._make_one(5)
+        result = instance._to_pb()
+        assert result.name == "limit"
+        assert len(result.args) == 1
+        assert result.args[0].integer_value == 5
+        assert len(result.options) == 0
+
+
+class TestOffset:
+    def _make_one(self, *args, **kwargs):
+        return stages.Offset(*args, **kwargs)
+
+    def test_repr(self):
+        instance = self._make_one(20)
+        repr_str = repr(instance)
+        assert repr_str == "Offset(offset=20)"
+
+    def test_to_pb(self):
+        instance = self._make_one(3)
+        result = instance._to_pb()
+        assert result.name == "offset"
+        assert len(result.args) == 1
+        assert result.args[0].integer_value == 3
+        assert len(result.options) == 0
+
+
+class TestSelect:
+    def _make_one(self, *args, **kwargs):
+        return stages.Select(*args, **kwargs)
+
+    def test_repr(self):
+        instance = self._make_one("field1", Field.of("field2"))
+        repr_str = repr(instance)
+        assert repr_str == "Select(projections=[Field.of('field1'), Field.of('field2')])"
+
+    def test_to_pb(self):
+        instance = self._make_one("field1", "field2.subfield", Field.of("field3"))
+        result = instance._to_pb()
+        assert result.name == "select"
+        assert len(result.args) == 1
+        got_map = result.args[0].map_value.fields
+        assert got_map.get("field1").field_reference_value == "field1"
+        assert got_map.get("field2.subfield").field_reference_value == "field2.subfield"
+        assert got_map.get("field3").field_reference_value == "field3"
+        assert len(result.options) == 0
+
+
+class TestSort:
+    def _make_one(self, *args, **kwargs):
+        return stages.Sort(*args, **kwargs)
+
+    def test_repr(self):
+        order1 = Ordering(Field.of("field1"), "ASCENDING")
+        instance = self._make_one(order1)
+        repr_str = repr(instance)
+        assert repr_str == "Sort(orders=[Field.of('field1').ascending()])"
+
+    def test_to_pb(self):
+        order1 = Ordering(Field.of("name"), "ASCENDING")
+        order2 = Ordering(Field.of("age"), "DESCENDING")
+        instance = self._make_one(order1, order2)
+        result = instance._to_pb()
+        assert result.name == "sort"
+        assert len(result.args) == 2
+        got_map = result.args[0].map_value.fields
+        assert got_map.get("expression").field_reference_value == "name"
+        assert got_map.get("direction").string_value == "ascending"
+        assert len(result.options) == 0
+
+
+class TestWhere:
+    def _make_one(self, *args, **kwargs):
+        return stages.Where(*args, **kwargs)
+
+    def test_repr(self):
+        condition = Field.of("age").gt(30)
+        instance = self._make_one(condition)
+        repr_str = repr(instance)
+        assert repr_str == "Where(condition=Gt(Field.of('age'), Constant.of(30)))"
+
+    def test_to_pb(self):
+        condition = Field.of("city").eq("SF")
+        instance = self._make_one(condition)
+        result = instance._to_pb()
+        assert result.name == "where"
+        assert len(result.args) == 1
+        got_fn = result.args[0].function_value
+        assert got_fn.name == "eq"
+        assert len(got_fn.args) == 2
+        assert got_fn.args[0].field_reference_value == "city"
+        assert got_fn.args[1].string_value == "SF"
+        assert len(result.options) == 0