8000 added tests for expressions · googleapis/python-firestore@aabcf33 · GitHub
[go: up one dir, main page]
Skip to content

Commit aabcf33

Browse files
daniel-sanchedaniel-sanche
committed
added tests for expressions
1 parent 40612ac commit aabcf33

File tree

2 files changed

+216
-41
lines changed

2 files changed

+216
-41
lines changed

‎google/cloud/firestore_v1/pipeline_expressions.py

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1518,4 +1518,4 @@ class Xor(FilterCondition):
15181518
"""Represents the logical XOR of multiple filter conditions."""
15191519

15201520
def __init__(self, conditions: List["FilterCondition"]):
1521-
super().__init__("or", conditions, use_infix_repr=False)
1521+
super().__init__("xor", conditions, use_infix_repr=False)

‎tests/unit/v1/test_pipeline_expressions.py

Lines changed: 215 additions & 40 deletions
< F438 /tr>
Original file line numberDiff line numberDiff line change
@@ -743,115 +743,290 @@ def test_not(self):
743743
assert repr(instance) == "Not(Condition)"
744744

745745
def test_divide(self):
746-
pass
746+
arg1 = self._make_arg("Left")
747+
arg2 = self._make_arg("Right")
748+
instance = expr.Divide(arg1, arg2)
749+
assert instance.name == "divide"
750+
assert instance.params == [arg1, arg2]
751+
assert repr(instance) == "Divide(Left, Right)"
747752

748753
def test_logical_max(self):
749-
pass
754+
arg1 = self._make_arg("Left")
755+
arg2 = self._make_arg("Right")
756+
instance = expr.LogicalMax(arg1, arg2)
757+
assert instance.name == "logical_maximum"
758+
assert instance.params == [arg1, arg2]
759+
assert repr(instance) == "LogicalMax(Left, Right)"
750760

751761
def test_logical_min(self):
752-
pass
762+
arg1 = self._make_arg("Left")
763+
arg2 = self._make_arg("Right")
764+
instance = expr.LogicalMin(arg1, arg2)
765+
assert instance.name == "logical_minimum"
766+
assert instance.params == [arg1, arg2]
767+
assert repr(instance) == "LogicalMin(Left, Right)"
753768

754769
def test_map_get(self):
755-
pass
770+
arg1 = self._make_arg("Map")
771+
arg2 = expr.Constant("Key")
772+
instance = expr.MapGet(arg1, arg2)
773+
assert instance.name == "map_get"
774+
assert instance.params == [arg1, arg2]
775+
assert repr(instance) == "MapGet(Map, Constant.of('Key'))"
756776

757777
def test_mod(self):
758-
pass
778+
arg1 = self._make_arg("Left")
779+
arg2 = self._make_arg("Right")
780+
instance = expr.Mod(arg1, arg2)
781+
assert instance.name == "mod"
782+
assert instance.params == [arg1, arg2]
783+
assert repr(instance) == "Mod(Left, Right)"
759784

760785
def test_multiply(self):
761-
pass
786+
arg1 = self._make_arg("Left")
787+
arg2 = self._make_arg("Right")
788+
instance = expr.Multiply(arg1, arg2)
789+
assert instance.name == "multiply"
790+
assert instance.params == [arg1, arg2]
791+
assert repr(instance) == "Multiply(Left, Right)"
762792

763793
def test_parent(self):
764-
pass
794+
arg1 = self._make_arg("Value")
795+
instance = expr.Parent(arg1)
796+
assert instance.name == "parent"
797+
assert instance.params == [arg1]
798+
assert repr(instance) == "Parent(Value)"
765799

766800
def test_str_concat(self):
767-
pass
801+
arg1 = self._make_arg("Str1")
802+
arg2 = self._make_arg("Str2")
803+
instance = expr.StrConcat(arg1, arg2)
804+
assert instance.name == "str_concat"
805+
assert instance.params == [arg1, arg2]
806+
assert repr(instance) == "StrConcat(Str1, Str2)"
768807

769808
def test_subtract(self):
770-
pass
809+
arg1 = self._make_arg("Left")
810+
arg2 = self._make_arg("Right")
811+
instance = expr.Subtract(arg1, arg2)
812+
assert instance.name == "subtract"
813+
assert instance.params == [arg1, arg2]
814+
assert repr(instance) == "Subtract(Left, Right)"
771815

772816
def test_timestamp_add(self):
773-
pass
817+
arg1 = self._make_arg("Timestamp")
818+
arg2 = self._make_arg("Unit")
819+
arg3 = self._make_arg("Amount")
820+
instance = expr.TimestampAdd(arg1, arg2, arg3)
821+
assert instance.name == "timestamp_add"
822+
assert instance.params == [arg1, arg2, arg3]
823+
assert repr(instance) == "TimestampAdd(Timestamp, Unit, Amount)"
774824

775825
def test_timestamp_sub(self):
776-
pass
826+
arg1 = self._make_arg("Timestamp")
827+
arg2 = self._make_arg("Unit")
828+
arg3 = self._make_arg("Amount")
829+
instance = expr.TimestampSub(arg1, arg2, arg3)
830+
assert instance.name == "timestamp_sub"
831+
assert instance.params == [arg1, arg2, arg3]
832+
assert repr(instance) == "TimestampSub(Timestamp, Unit, Amount)"
777833

778834
def test_timestamp_to_unix_micros(self):
779-
pass
835+
arg1 = self._make_arg("Input")
836+
instance = expr.TimestampToUnixMicros(arg1)
837+
assert instance.name == "timestamp_to_unix_micros"
838+
assert instance.params == [arg1]
839+
assert repr(instance) == "TimestampToUnixMicros(Input)"
780840

781841
def test_timestamp_to_unix_millis(self):
782-
pass
842+
arg1 = self._make_arg("Input")
843+
instance = expr.TimestampToUnixMillis(arg1)
844+
assert instance.name == "timestamp_to_unix_millis"
845+
assert instance.params == [arg1]
846+
assert repr(instance) == "TimestampToUnixMillis(Input)"
783847

784848
def test_timestamp_to_unix_seconds(self):
785-
pass
849+
arg1 = self._make_arg("Input")
850+
instance = expr.TimestampToUnixSeconds(arg1)
851+
assert instance.name == "timestamp_to_unix_seconds"
852+
assert instance.params == [arg1]
853+
assert repr(instance) == "TimestampToUnixSeconds(Input)"
786854

787855
def test_unix_micros_to_timestamp(self):
788-
pass
856+
arg1 = self._make_arg("Input")
857+
instance = expr.UnixMicrosToTimestamp(arg1)
858+
assert instance.name == "unix_micros_to_timestamp"
859+
assert instance.params == [arg1]
860+
assert repr(instance) == "UnixMicrosToTimestamp(Input)"
789861

790862
def test_unix_millis_to_timestamp(self):
791-
pass
863+
arg1 = self._make_arg("Input")
864+
instance = expr.UnixMillisToTimestamp(arg1)
865+
assert instance.name == "unix_millis_to_timestamp"
866+
assert instance.params == [arg1]
867+
assert repr(instance) == "UnixMillisToTimestamp(Input)"
792868

793869
def test_unix_seconds_to_timestamp(self):
794-
pass
870+
arg1 = self._make_arg("Input")
871+
instance = expr.UnixSecondsToTimestamp(arg1)
872+
assert instance.name == "unix_seconds_to_timestamp"
873+
assert instance.params == [arg1]
874+
assert repr(instance) == "UnixSecondsToTimestamp(Input)"
795875

796876
def test_vector_length(self):
797-
pass
877+
arg1 = self._make_arg("Array")
878+
instance = expr.VectorLength(arg1)
879+
assert instance.name == "vector_length"
880+
assert instance.params == [arg1]
881+
assert repr(instance) == "VectorLength(Array)"
798882

799883
def test_add(self):
800-
pass
884+
arg1 = self._make_arg("Left")
885+
arg2 = self._make_arg("Right")
886+
instance = expr.Add(arg1, arg2)
887+
assert instance.name == "add"
888+
assert instance.params == [arg1, arg2]
889+
assert repr(instance) == "Add(Left, Right)"
801890

802891
def test_array_element(self):
803-
pass
892+
instance = expr.ArrayElement()
893+
assert instance.name == "array_element"
894+
assert instance.params == []
895+
assert repr(instance) == "ArrayElement()"
804896

805897
def test_array_filter(self):
806-
pass
898+
arg1 = self._make_arg("Array")
899+
arg2 = self._make_arg("FilterCond")
900+
instance = expr.ArrayFilter(arg1, arg2)
901+
assert instance.name == "array_filter"
902+
assert instance.params == [arg1, arg2]
903+
assert repr(instance) == "ArrayFilter(Array, FilterCond)"
807904

808905
def test_array_length(self):
809-
pass
906+
arg1 = self._make_arg("Array")
907+
instance = expr.ArrayLength(arg1)
908+
assert instance.name == "array_length"
909+
assert instance.params == [arg1]
910+
assert repr(instance) == "ArrayLength(Array)"
810911

811912
def test_array_reverse(self):
812-
pass
913+
arg1 = self._make_arg("Array")
914+
instance = expr.ArrayReverse(arg1)
915+
assert instance.name == "array_reverse"
916+
assert instance.params == [arg1]
917+
assert repr(instance) == "ArrayReverse(Array)"
813918

814919
def test_array_transform(self):
815-
pass
920+
arg1 = self._make_arg("Array")
921+
arg2 = self._make_arg("TransformFunc")
922+
instance = expr.ArrayTransform(arg1, arg2)
923+
assert instance.name == "array_transform"
924+
assert instance.params == [arg1, arg2]
925+
assert repr(instance) == "ArrayTransform(Array, TransformFunc)"
816926

817927
def test_byte_length(self):
818-
pass
928+
arg1 = self._make_arg("Expr")
929+
instance = expr.ByteLength(arg1)
930+
assert instance.name == "byte_length"
931+
assert instance.params == [arg1]
932+
assert repr(instance) == "ByteLength(Expr)"
819933

820934
def test_char_length(self):
821-
pass
935+
arg1 = self._make_arg("Expr")
936+
instance = expr.CharLength(arg1)
937+
assert instance.name == "char_length"
938+
assert instance.params == [arg1]
939+
assert repr(instance) == "CharLength(Expr)"
822940

823941
def test_collection_id(self):
824-
pass
825-
826-
def test_accumulator(self):
827-
pass
942+
arg1 = self._make_arg("Value")
943+
instance = expr.CollectionId(arg1)
944+
assert instance.name == "collection_id"
945+
assert instance.params == [arg1]
946+
assert repr(instance) == "CollectionId(Value)"
828947

829948
def test_max(self):
830-
pass
949+
arg1 = self._make_arg("Value")
950+
instance = expr.Max(arg1)
951+
assert instance.name == "maximum"
952+
assert instance.params == [arg1]
953+
assert repr(instance) == "Max(Value)"
831954

832955
def test_array_contains_all(self):
833-
pass
956+
arg1 = self._make_arg("ArrayField")
957+
arg2 = self._make_arg("Element1")
958+
arg3 = self._make_arg("Element2")
959+
instance = expr.ArrayContainsAll(arg1, [arg2, arg3])
960+
assert instance.name == "array_contains_all"
961+
assert isinstance(instance.params[1], ListOfExprs)
962+
assert instance.params[0] == arg1
963+
assert instance.params[1].exprs == [arg2, arg3]
964+
assert (
965+
repr(instance)
966+
== "ArrayField.array_contains_all(ListOfExprs([Element1, Element2]))"
967+
)
834968

835969
def test_ends_with(self):
836-
pass
970+
arg1 = self._make_arg("Expr")
971+
arg2 = self._make_arg("Postfix")
972+
instance = expr.EndsWith(arg1, arg2)
973+
assert instance.name == "ends_with"
974+
assert instance.params == [arg1, arg2]
975+
assert repr(instance) == "Expr.ends_with(Postfix)"
837976

838977
def test_if(self):
839-
pass
978+
arg1 = self._make_arg("Condition")
979+
arg2 = self._make_arg("TrueExpr")
980+
arg3 = self._make_arg("FalseExpr")
981+
instance = expr.If(arg1, arg2, arg3)
982+
assert instance.name == "if"
983+
assert instance.params == [arg1, arg2, arg3]
984+
assert repr(instance) == "If(Condition, TrueExpr, FalseExpr)"
840985

841986
def test_like(self):
842-
pass
987+
arg1 = self._make_arg("Expr")
988+
arg2 = self._make_arg("Pattern")
989+
instance = expr.Like(arg1, arg2)
990+
assert instance.name == "like"
991+
assert instance.params == [arg1, arg2]
992+
assert repr(instance) == "Expr.like(Pattern)"
843993

844994
def test_regex_contains(self):
845-
pass
995+
arg1 = self._make_arg("Expr")
996+
arg2 = self._make_arg("Regex")
997+
instance = expr.RegexContains(arg1, arg2)
998+
assert instance.name == "regex_contains"
999+
assert instance.params == [arg1, arg2]
1000+
assert repr(instance) == "Expr.regex_contains(Regex)"
8461001

8471002
def test_regex_match(self):
848-
pass
1003+
arg1 = self._make_arg("Expr")
1004+
arg2 = self._make_arg("Regex")
1005+
instance = expr.RegexMatch(arg1, arg2)
1006+
assert instance.name == "regex_match"
1007+
assert instance.params == [arg1, arg2]
1008+
assert repr(instance) == "Expr.regex_match(Regex)"
8491009

8501010
def test_starts_with(self):
851-
pass
1011+
arg1 = self._make_arg("Expr")
1012+
arg2 = self._make_arg("Prefix")
1013+
instance = expr.StartsWith(arg1, arg2)
1014+
assert instance.name == "starts_with"
1015+
assert instance.params == [arg1, arg2]
1016+
assert repr(instance) == "Expr.starts_with(Prefix)"
8521017

8531018
def test_str_contains(self):
854-
pass
1019+
arg1 = self._make_arg("Expr")
1020+
arg2 = self._make_arg("Substring")
1021+
instance = expr.StrContains(arg1, arg2)
1022+
assert instance.name == "str_contains"
1023+
assert instance.params == [arg1, arg2]
1024+
assert repr(instance) == "Expr.str_contains(Substring)"
8551025

8561026
def test_xor(self):
857-
pass
1027+
arg1 = self._make_arg("Condition1")
1028+
arg2 = self._make_arg("Condition2")
1029+
instance = expr.Xor([arg1, arg2])
1030+
assert instance.name == "xor"
1031+
assert instance.params == [arg1, arg2]
1032+
assert repr(instance) == "Xor(Condition1, Condition2)"

0 commit comments

Comments
 (0)
0