Tests legacy (#135)

* tests included in the test_operators / tests_accumulators forder

* testing functions in the accumulator folder

* tests arithmetic folder passed and completed

* tests_array folder passed and completed

* tests_boolean folder passed and completed

* tests_comparison folder passed and completed

* tests_conditional folder passed and completed

* tests_date folder passed and completed

* tests_objects folder passed and completed

* tests_type_ & tests_strings passed and completed

Author: Zegthor91

tests/tests_monggregate/tests_operators/tests_accumulators/test_avg.py

@@ -1,7 +1,19 @@
 """Tests for `monggregate.operators.accumulators.avg` module."""
 
-from monggregate.operators.accumulators.avg import Average
+from monggregate.operators.accumulators.avg import Average, avg
 
+def test_avg_expression():
+    # Setup
+    expected_expression = {
+        "$avg": None
+    }
+
+    # Act
+    avg_op = Average()            
+    result_expression = avg_op.expression
+
+    # Assert
+    assert result_expression == expected_expression
 
 class TestAverage:
     """Tests for `Average` class."""
@@ -15,4 +27,4 @@ def test_expression(self) -> None:
         """Test that `Average` class returns the correct expression."""
 
         average = Average(operand=1)
-        assert average.expression == {"$avg": 1}
+        assert average.expression == {"$avg": 1}

tests/tests_monggregate/tests_operators/tests_accumulators/test_count.py

@@ -1,7 +1,20 @@
 """Tests for `monggregate.operators.accumulators.count` module."""
 
-from monggregate.operators.accumulators.count import Count
+import pytest
+from monggregate.operators.accumulators.count import Count, count
 
+def test_count_expression():
+    # Setup
+    expected_expression = {
+        "$count": {}
+    }
+
+    # Act
+    count_op = count()            
+    result_expression = count_op.expression
+
+    # Assert
+    assert result_expression == expected_expression
 
 class TestCount:
     """Tests for `Count` class."""
@@ -14,4 +27,4 @@ def test_instantiation(self) -> None:
     def test_expression(self) -> None:
         """Test that `Count` class returns the correct expression."""
         count_op = Count()
-        assert count_op.expression == {"$count": {}}
+        assert count_op.expression == {"$count": {}}

tests/tests_monggregate/tests_operators/tests_accumulators/test_first.py

@@ -1,6 +1,21 @@
 """Tests for `monggregate.operators.accumulators.first` module."""
 
-from monggregate.operators.accumulators.first import First
+import pytest
+from monggregate.operators.accumulators.first import First, first
+
+def test_first_expression():
+    # Setup
+    operand = "$someField"
+    expected_expression = {
+        "$first": operand
+    }
+
+    # Act
+    first_op = first(operand)
+    result_expression = first_op.expression
+
+    # Assert
+    assert result_expression == expected_expression
 
 
 class TestFirst:
@@ -14,4 +29,4 @@ def test_instantiation(self) -> None:
     def test_expression(self) -> None:
         """Test that `First` class returns the correct expression."""
         first_op = First(operand=1)
-        assert first_op.expression == {"$first": 1}
+        assert first_op.expression == {"$first": 1}

tests/tests_monggregate/tests_operators/tests_accumulators/test_last.py

@@ -1,6 +1,21 @@
 """Tests for `monggregate.operators.accumulators.last` module."""
 
-from monggregate.operators.accumulators.last import Last
+import pytest
+from monggregate.operators.accumulators.last import Last, last
+
+def test_last_expression():
+    # Setup
+    operand = "$someField"
+    expected_expression = {
+        "$last": operand
+    }
+
+    # Act
+    last_op = last(operand)
+    result_expression = last_op.expression
+
+    # Assert
+    assert result_expression == expected_expression
 
 
 class TestLast:
@@ -14,4 +29,4 @@ def test_instantiation(self) -> None:
     def test_expression(self) -> None:
         """Test that `Last` class returns the correct expression."""
         last_op = Last(operand=1)
-        assert last_op.expression == {"$last": 1}
+        assert last_op.expression == {"$last": 1}

tests/tests_monggregate/tests_operators/tests_accumulators/test_max.py

@@ -1,6 +1,21 @@
 """Tests for `monggregate.operators.accumulators.max` module."""
 
-from monggregate.operators.accumulators.max import Max
+import pytest
+from monggregate.operators.accumulators.max import Max, max
+
+def test_max_expression():
+    # Setup
+    operand = "$someNumericField"
+    expected_expression = {
+        "$max": operand
+    }
+
+    # Act
+    max_op = max(operand)
+    result_expression = max_op.expression
+
+    # Assert
+    assert result_expression == expected_expression
 
 
 class TestMax:
@@ -14,4 +29,4 @@ def test_instantiation(self) -> None:
     def test_expression(self) -> None:
         """Test that `Max` class returns the correct expression."""
         max_op = Max(operand=1)
-        assert max_op.expression == {"$max": 1}
+        assert max_op.expression == {"$max": 1}

tests/tests_monggregate/tests_operators/tests_accumulators/test_min.py

@@ -1,6 +1,21 @@
 """Tests for `monggregate.operators.accumulators.min` module."""
 
-from monggregate.operators.accumulators.min import Min
+import pytest
+from monggregate.operators.accumulators.min import Min, min
+
+def test_min_expression():
+    # Setup
+    operand = "$someNumericField"
+    expected_expression = {
+        "$min": operand
+    }
+
+    # Act
+    min_op = min(operand)
+    result_expression = min_op.expression
+
+    # Assert
+    assert result_expression == expected_expression
 
 
 class TestMin:
@@ -14,4 +29,4 @@ def test_instantiation(self) -> None:
     def test_expression(self) -> None:
         """Test that `Min` class returns the correct expression."""
         min_op = Min(operand=1)
-        assert min_op.expression == {"$min": 1}
+        assert min_op.expression == {"$min": 1}

tests/tests_monggregate/tests_operators/tests_accumulators/test_push.py

@@ -1,6 +1,21 @@
 """Tests for `monggregate.operators.accumulators.push` module."""
 
-from monggregate.operators.accumulators.push import Push
+import pytest
+from monggregate.operators.accumulators.push import Push, push
+
+def test_push_expression():
+    # Setup
+    operand = "$someField"
+    expected_expression = {
+        "$push": operand
+    }
+
+    # Act
+    push_op = push(operand)
+    result_expression = push_op.expression
+
+    # Assert
+    assert result_expression == expected_expression
 
 
 class TestPush:
@@ -14,4 +29,4 @@ def test_instantiation(self) -> None:
     def test_expression(self) -> None:
         """Test that `Push` class returns the correct expression."""
         push_op = Push(operand=1)
-        assert push_op.expression == {"$push": 1}
+        assert push_op.expression == {"$push": 1}

tests/tests_monggregate/tests_operators/tests_accumulators/test_sum.py

@@ -1,6 +1,18 @@
 """Tests for `monggregate.operators.accumulators.sum` module."""
 
-from monggregate.operators.accumulators.sum import Sum
+import pytest
+from monggregate.operators.accumulators.sum import Sum, sum
+
+def test_sum_operand():
+    # Setup
+    operand = "$amount"
+
+    # Act
+    result_op = {"$sum": operand}
+    expected_expression = {"$sum": "$amount"}
+
+    # Assert
+    assert result_op == expected_expression
 
 
 class TestSum:
@@ -14,4 +26,4 @@ def test_instantiation(self) -> None:
     def test_expression(self) -> None:
         """Test that `Sum` class returns the correct expression."""
         sum_op = Sum(operand=1)
-        assert sum_op.expression == {"$sum": 1}
+        assert sum_op.expression == {"$sum": 1}

tests/tests_monggregate/tests_operators/tests_arithmetic/test_add.py

@@ -2,6 +2,18 @@
 
 from monggregate.operators.arithmetic.add import Add
 
+def test_add_expression():
+    # Setup
+    operands = [1, 2, 3]
+    expected_expression = {"$add": operands}
+
+    # Act
+    add_op = Add(operands=operands)
+    result_expression = add_op.expression
+
+    # Assert
+    assert result_expression == expected_expression
+
 
 class TestAdd:
     """Tests for `Add` class."""

tests/tests_monggregate/tests_operators/tests_arithmetic/test_divide.py

@@ -2,6 +2,19 @@
 
 from monggregate.operators.arithmetic.divide import Divide
 
+def test_divide_expression():
+    # Setup
+    numerator = 10
+    denominator = 2
+    expected_expression = {"$divide": [numerator, denominator]}
+
+    # Act
+    divide_op = Divide(numerator=numerator, denominator=denominator)
+    result_expression = divide_op.expression
+
+    # Assert
+    assert result_expression == expected_expression
+
 
 class TestDivide:
     """Tests for `Divide` class."""