128-revival-add-operators-tests (#136)

* Move test_operators under tests_monggregate

* test average example

* Add accumulators tests

* tests_arithmetic and tests_arrays

* Add main operators tests

Author: VianneyMI

tests/tests_operators/tests_accumulators/test_accumulator.py renamed to tests/tests_monggregate/tests_operators/tests_accumulators/test_accumulator.py

@@ -0,0 +1,18 @@
+"""Tests for `monggregate.operators.accumulators.avg` module."""
+
+from monggregate.operators.accumulators.avg import Average
+
+
+class TestAverage:
+    """Tests for `Average` class."""
+
+    def test_instantiation(self) -> None:
+        """Test that `Average` class can be instantiated."""
+        average = Average(operand=1)
+        assert isinstance(average, Average)
+
+    def test_expression(self) -> None:
+        """Test that `Average` class returns the correct expression."""
+
+        average = Average(operand=1)
+        assert average.expression == {"$avg": 1}

tests/tests_monggregate/tests_operators/tests_accumulators/test_avg.py

@@ -0,0 +1,17 @@
+"""Tests for `monggregate.operators.accumulators.count` module."""
+
+from monggregate.operators.accumulators.count import Count
+
+
+class TestCount:
+    """Tests for `Count` class."""
+
+    def test_instantiation(self) -> None:
+        """Test that `Count` class can be instantiated."""
+        count_op = Count()
+        assert isinstance(count_op, Count)
+
+    def test_expression(self) -> None:
+        """Test that `Count` class returns the correct expression."""
+        count_op = Count()
+        assert count_op.expression == {"$count": {}}

tests/tests_monggregate/tests_operators/tests_accumulators/test_count.py

@@ -0,0 +1,17 @@
+"""Tests for `monggregate.operators.accumulators.first` module."""
+
+from monggregate.operators.accumulators.first import First
+
+
+class TestFirst:
+    """Tests for `First` class."""
+
+    def test_instantiation(self) -> None:
+        """Test that `First` class can be instantiated."""
+        first_op = First(operand=1)
+        assert isinstance(first_op, First)
+
+    def test_expression(self) -> None:
+        """Test that `First` class returns the correct expression."""
+        first_op = First(operand=1)
+        assert first_op.expression == {"$first": 1}

tests/tests_monggregate/tests_operators/tests_accumulators/test_first.py

@@ -0,0 +1,17 @@
+"""Tests for `monggregate.operators.accumulators.last` module."""
+
+from monggregate.operators.accumulators.last import Last
+
+
+class TestLast:
+    """Tests for `Last` class."""
+
+    def test_instantiation(self) -> None:
+        """Test that `Last` class can be instantiated."""
+        last_op = Last(operand=1)
+        assert isinstance(last_op, Last)
+
+    def test_expression(self) -> None:
+        """Test that `Last` class returns the correct expression."""
+        last_op = Last(operand=1)
+        assert last_op.expression == {"$last": 1}

tests/tests_monggregate/tests_operators/tests_accumulators/test_last.py

@@ -0,0 +1,17 @@
+"""Tests for `monggregate.operators.accumulators.max` module."""
+
+from monggregate.operators.accumulators.max import Max
+
+
+class TestMax:
+    """Tests for `Max` class."""
+
+    def test_instantiation(self) -> None:
+        """Test that `Max` class can be instantiated."""
+        max_op = Max(operand=1)
+        assert isinstance(max_op, Max)
+
+    def test_expression(self) -> None:
+        """Test that `Max` class returns the correct expression."""
+        max_op = Max(operand=1)
+        assert max_op.expression == {"$max": 1}

tests/tests_monggregate/tests_operators/tests_accumulators/test_max.py

@@ -0,0 +1,17 @@
+"""Tests for `monggregate.operators.accumulators.min` module."""
+
+from monggregate.operators.accumulators.min import Min
+
+
+class TestMin:
+    """Tests for `Min` class."""
+
+    def test_instantiation(self) -> None:
+        """Test that `Min` class can be instantiated."""
+        min_op = Min(operand=1)
+        assert isinstance(min_op, Min)
+
+    def test_expression(self) -> None:
+        """Test that `Min` class returns the correct expression."""
+        min_op = Min(operand=1)
+        assert min_op.expression == {"$min": 1}

tests/tests_monggregate/tests_operators/tests_accumulators/test_min.py

@@ -0,0 +1,17 @@
+"""Tests for `monggregate.operators.accumulators.push` module."""
+
+from monggregate.operators.accumulators.push import Push
+
+
+class TestPush:
+    """Tests for `Push` class."""
+
+    def test_instantiation(self) -> None:
+        """Test that `Push` class can be instantiated."""
+        push_op = Push(operand=1)
+        assert isinstance(push_op, Push)
+
+    def test_expression(self) -> None:
+        """Test that `Push` class returns the correct expression."""
+        push_op = Push(operand=1)
+        assert push_op.expression == {"$push": 1}

tests/tests_monggregate/tests_operators/tests_accumulators/test_push.py

@@ -0,0 +1,17 @@
+"""Tests for `monggregate.operators.accumulators.sum` module."""
+
+from monggregate.operators.accumulators.sum import Sum
+
+
+class TestSum:
+    """Tests for `Sum` class."""
+
+    def test_instantiation(self) -> None:
+        """Test that `Sum` class can be instantiated."""
+        sum_op = Sum(operand=1)
+        assert isinstance(sum_op, Sum)
+
+    def test_expression(self) -> None:
+        """Test that `Sum` class returns the correct expression."""
+        sum_op = Sum(operand=1)
+        assert sum_op.expression == {"$sum": 1}

tests/tests_monggregate/tests_operators/tests_accumulators/test_sum.py

@@ -0,0 +1,17 @@
+"""Tests for `monggregate.operators.arithmetic.add` module."""
+
+from monggregate.operators.arithmetic.add import Add
+
+
+class TestAdd:
+    """Tests for `Add` class."""
+
+    def test_instantiation(self) -> None:
+        """Test that `Add` class can be instantiated."""
+        add_op = Add(operands=[1, 2, 3])
+        assert isinstance(add_op, Add)
+
+    def test_expression(self) -> None:
+        """Test that `Add` class returns the correct expression."""
+        add_op = Add(operands=[1, 2, 3])
+        assert add_op.expression == {"$add": [1, 2, 3]}