From 69f74b7b4fd25880ec5cea012bd20e1a93b3aa84 Mon Sep 17 00:00:00 2001
From: Zegthor91 <zegthorthechazz@gmail.com>
Date: Thu, 5 Jun 2025 16:43:41 +0200
Subject: [PATCH 01/10] tests included in the test_operators /
 tests_accumulators forder

---
 .../tests_accumulators/test_count.py             | 15 +++++++++++++++
 .../tests_accumulators/test_first.py             | 16 ++++++++++++++++
 .../tests_accumulators/test_last.py              | 16 ++++++++++++++++
 .../tests_accumulators/test_max.py               | 16 ++++++++++++++++
 .../tests_accumulators/test_min.py               | 16 ++++++++++++++++
 .../tests_accumulators/test_push.py              | 16 ++++++++++++++++
 .../tests_accumulators/test_sum.py               |  0
 7 files changed, 95 insertions(+)
 create mode 100644 tests/tests_operators/tests_accumulators/test_count.py
 create mode 100644 tests/tests_operators/tests_accumulators/test_first.py
 create mode 100644 tests/tests_operators/tests_accumulators/test_last.py
 create mode 100644 tests/tests_operators/tests_accumulators/test_max.py
 create mode 100644 tests/tests_operators/tests_accumulators/test_min.py
 create mode 100644 tests/tests_operators/tests_accumulators/test_push.py
 create mode 100644 tests/tests_operators/tests_accumulators/test_sum.py

diff --git a/tests/tests_operators/tests_accumulators/test_count.py b/tests/tests_operators/tests_accumulators/test_count.py
new file mode 100644
index 00000000..cbe123ef
--- /dev/null
+++ b/tests/tests_operators/tests_accumulators/test_count.py
@@ -0,0 +1,15 @@
+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
\ No newline at end of file
diff --git a/tests/tests_operators/tests_accumulators/test_first.py b/tests/tests_operators/tests_accumulators/test_first.py
new file mode 100644
index 00000000..ac892353
--- /dev/null
+++ b/tests/tests_operators/tests_accumulators/test_first.py
@@ -0,0 +1,16 @@
+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
\ No newline at end of file
diff --git a/tests/tests_operators/tests_accumulators/test_last.py b/tests/tests_operators/tests_accumulators/test_last.py
new file mode 100644
index 00000000..0425a030
--- /dev/null
+++ b/tests/tests_operators/tests_accumulators/test_last.py
@@ -0,0 +1,16 @@
+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
\ No newline at end of file
diff --git a/tests/tests_operators/tests_accumulators/test_max.py b/tests/tests_operators/tests_accumulators/test_max.py
new file mode 100644
index 00000000..44c628eb
--- /dev/null
+++ b/tests/tests_operators/tests_accumulators/test_max.py
@@ -0,0 +1,16 @@
+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
\ No newline at end of file
diff --git a/tests/tests_operators/tests_accumulators/test_min.py b/tests/tests_operators/tests_accumulators/test_min.py
new file mode 100644
index 00000000..5232d06a
--- /dev/null
+++ b/tests/tests_operators/tests_accumulators/test_min.py
@@ -0,0 +1,16 @@
+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
\ No newline at end of file
diff --git a/tests/tests_operators/tests_accumulators/test_push.py b/tests/tests_operators/tests_accumulators/test_push.py
new file mode 100644
index 00000000..2b165698
--- /dev/null
+++ b/tests/tests_operators/tests_accumulators/test_push.py
@@ -0,0 +1,16 @@
+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
\ No newline at end of file
diff --git a/tests/tests_operators/tests_accumulators/test_sum.py b/tests/tests_operators/tests_accumulators/test_sum.py
new file mode 100644
index 00000000..e69de29b

From f031b1e026c22dfe933c7ad3960033f9d7e80972 Mon Sep 17 00:00:00 2001
From: Zegthor91 <zegthorthechazz@gmail.com>
Date: Thu, 5 Jun 2025 16:58:34 +0200
Subject: [PATCH 02/10] testing functions in the accumulator folder

---
 tests/tests_operators/tests_accumulators/test_sum.py | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/tests/tests_operators/tests_accumulators/test_sum.py b/tests/tests_operators/tests_accumulators/test_sum.py
index e69de29b..f6efa713 100644
--- a/tests/tests_operators/tests_accumulators/test_sum.py
+++ b/tests/tests_operators/tests_accumulators/test_sum.py
@@ -0,0 +1,10 @@
+def test_sum_operand():
+    # Setup
+    operand = "$amount"
+    
+    #Act
+    result_op = {"$sum": operand}
+    expected_expression = {"$sum": "$amount"}
+    
+    #Assert
+    assert result_op == expected_expression
\ No newline at end of file

From 9148341962eb36f25ce60aa81de7ae782fb32c41 Mon Sep 17 00:00:00 2001
From: Zegthor91 <zegthorthechazz@gmail.com>
Date: Fri, 6 Jun 2025 11:41:08 +0200
Subject: [PATCH 03/10] tests arithmetic folder passed and completed

---
 .../tests_accumulators/test_avg.py               | 16 ++++++++++++++--
 .../tests_operators/tests_arithmetic/test_add.py | 12 ++++++++++++
 .../tests_arithmetic/test_divide.py              | 13 +++++++++++++
 .../tests_arithmetic/test_multiply.py            | 12 ++++++++++++
 .../tests_operators/tests_arithmetic/test_pow.py | 13 +++++++++++++
 .../tests_arithmetic/test_subtract.py            | 13 +++++++++++++
 6 files changed, 77 insertions(+), 2 deletions(-)

diff --git a/tests/tests_monggregate/tests_operators/tests_accumulators/test_avg.py b/tests/tests_monggregate/tests_operators/tests_accumulators/test_avg.py
index e21e9b78..f8409e6e 100644
--- a/tests/tests_monggregate/tests_operators/tests_accumulators/test_avg.py
+++ b/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}
\ No newline at end of file
diff --git a/tests/tests_monggregate/tests_operators/tests_arithmetic/test_add.py b/tests/tests_monggregate/tests_operators/tests_arithmetic/test_add.py
index f10f5feb..882c4db7 100644
--- a/tests/tests_monggregate/tests_operators/tests_arithmetic/test_add.py
+++ b/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."""
diff --git a/tests/tests_monggregate/tests_operators/tests_arithmetic/test_divide.py b/tests/tests_monggregate/tests_operators/tests_arithmetic/test_divide.py
index 9b4a5421..a3c46910 100644
--- a/tests/tests_monggregate/tests_operators/tests_arithmetic/test_divide.py
+++ b/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."""
diff --git a/tests/tests_monggregate/tests_operators/tests_arithmetic/test_multiply.py b/tests/tests_monggregate/tests_operators/tests_arithmetic/test_multiply.py
index 60ee2979..8e87509c 100644
--- a/tests/tests_monggregate/tests_operators/tests_arithmetic/test_multiply.py
+++ b/tests/tests_monggregate/tests_operators/tests_arithmetic/test_multiply.py
@@ -2,6 +2,18 @@
 
 from monggregate.operators.arithmetic.multiply import Multiply
 
+def test_multiply_expression():
+    # Setup
+    operands = [2, 3, 4]
+    expected_expression = {"$multiply": operands}
+
+    # Act
+    multiply_op = Multiply(operands=operands)
+    result_expression = multiply_op.expression
+
+    # Assert
+    assert result_expression == expected_expression
+
 
 class TestMultiply:
     """Tests for `Multiply` class."""
diff --git a/tests/tests_monggregate/tests_operators/tests_arithmetic/test_pow.py b/tests/tests_monggregate/tests_operators/tests_arithmetic/test_pow.py
index 390b8b13..c6484099 100644
--- a/tests/tests_monggregate/tests_operators/tests_arithmetic/test_pow.py
+++ b/tests/tests_monggregate/tests_operators/tests_arithmetic/test_pow.py
@@ -2,6 +2,19 @@
 
 from monggregate.operators.arithmetic.pow import Pow
 
+def test_pow_expression():
+    # Setup
+    number = 2
+    exponent = 3
+    expected_expression = {"$pow": [number, exponent]}
+
+    # Act
+    pow_op = Pow(number=number, exponent=exponent)
+    result_expression = pow_op.expression
+
+    # Assert
+    assert result_expression == expected_expression
+
 
 class TestPow:
     """Tests for `Pow` class."""
diff --git a/tests/tests_monggregate/tests_operators/tests_arithmetic/test_subtract.py b/tests/tests_monggregate/tests_operators/tests_arithmetic/test_subtract.py
index 700e869a..b5414d65 100644
--- a/tests/tests_monggregate/tests_operators/tests_arithmetic/test_subtract.py
+++ b/tests/tests_monggregate/tests_operators/tests_arithmetic/test_subtract.py
@@ -2,6 +2,19 @@
 
 from monggregate.operators.arithmetic.subtract import Subtract
 
+def test_subtract_expression():
+    # Setup
+    left = 10
+    right = 4
+    expected_expression = {"$substract": [left, right]}
+
+    # Act
+    subtract_op = Subtract(left=left, right=right)
+    result_expression = subtract_op.expression
+
+    # Assert
+    assert result_expression == expected_expression
+
 
 class TestSubtract:
     """Tests for `Subtract` class."""

From 608a1d4a12e0cb8e11a30f271340a774c89bf57f Mon Sep 17 00:00:00 2001
From: Zegthor91 <zegthorthechazz@gmail.com>
Date: Fri, 6 Jun 2025 12:24:59 +0200
Subject: [PATCH 04/10] tests_array folder passed and completed

---
 .../tests_array/test_array_to_object.py       | 14 +++++++++++-
 .../tests_array/test_filter.py                | 22 +++++++++++++++++++
 .../tests_operators/tests_array/test_first.py | 14 ++++++++++++
 .../tests_operators/tests_array/test_in.py    | 13 +++++++++++
 .../tests_array/test_is_array.py              | 12 ++++++++++
 .../tests_operators/tests_array/test_last.py  | 14 ++++++++++++
 .../tests_operators/tests_array/test_max_n.py | 20 ++++++++++++++++-
 .../tests_operators/tests_array/test_min_n.py | 20 ++++++++++++++++-
 .../tests_operators/tests_array/test_size.py  | 12 ++++++++++
 .../tests_array/test_sort_array.py            | 18 +++++++++++++++
 10 files changed, 156 insertions(+), 3 deletions(-)

diff --git a/tests/tests_monggregate/tests_operators/tests_array/test_array_to_object.py b/tests/tests_monggregate/tests_operators/tests_array/test_array_to_object.py
index ba280e8a..aef67ebc 100644
--- a/tests/tests_monggregate/tests_operators/tests_array/test_array_to_object.py
+++ b/tests/tests_monggregate/tests_operators/tests_array/test_array_to_object.py
@@ -2,6 +2,18 @@
 
 from monggregate.operators.array.array_to_object import ArrayToObject
 
+def test_array_to_object_expression():
+    # Setup
+    operand = [ { "k": "item", "v": "abc123"}, { "k": "qty", "v": 25 } ]
+    expected_expression = { "$arrayToObject": operand }
+
+    # Act
+    array_to_object_op = ArrayToObject(operand=operand)
+    result_expression = array_to_object_op.expression
+
+    # Assert
+    assert result_expression == expected_expression
+
 
 class TestArrayToObject:
     """Tests for `ArrayToObject` class."""
@@ -16,4 +28,4 @@ def test_expression(self) -> None:
         array_to_object_op = ArrayToObject(operand=[["item", "abc123"], ["qty", 25]])
         assert array_to_object_op.expression == {
             "$arrayToObject": [["item", "abc123"], ["qty", 25]]
-        }
+        }
\ No newline at end of file
diff --git a/tests/tests_monggregate/tests_operators/tests_array/test_filter.py b/tests/tests_monggregate/tests_operators/tests_array/test_filter.py
index 5d55d2ef..0b2e9d07 100644
--- a/tests/tests_monggregate/tests_operators/tests_array/test_filter.py
+++ b/tests/tests_monggregate/tests_operators/tests_array/test_filter.py
@@ -2,6 +2,28 @@
 
 from monggregate.operators.array.filter import Filter
 
+def test_filter_expression():
+    # Setup
+    operand = [1, 2, 3, 4, 5]
+    let = "num"
+    query = {"$gt": ["$$num", 5]}
+    limit = None
+    expected_expression = {
+        "$filter": {
+            "input": operand,
+            "cond": query,
+            "as": let,
+            "limit": limit
+        }
+    }
+
+    # Act
+    filter_op = Filter(operand=operand, query=query, let=let, limit=limit)
+    result_expression = filter_op.expression
+
+    # Assert
+    assert result_expression == expected_expression
+
 
 class TestFilter:
     """Tests for `Filter` class."""
diff --git a/tests/tests_monggregate/tests_operators/tests_array/test_first.py b/tests/tests_monggregate/tests_operators/tests_array/test_first.py
index 4f5d441e..ff5438bc 100644
--- a/tests/tests_monggregate/tests_operators/tests_array/test_first.py
+++ b/tests/tests_monggregate/tests_operators/tests_array/test_first.py
@@ -2,6 +2,20 @@
 
 from monggregate.operators.array.first import First
 
+from monggregate.operators.array.first import First
+
+def test_first_expression():
+    # Setup
+    array = [10, 20, 30]
+    expected_expression = {"$first": array}
+
+    # Act
+    first_op = First(operand=array)
+    result_expression = first_op.expression
+
+    # Assert
+    assert result_expression == expected_expression
+
 
 class TestFirst:
     """Tests for `First` class."""
diff --git a/tests/tests_monggregate/tests_operators/tests_array/test_in.py b/tests/tests_monggregate/tests_operators/tests_array/test_in.py
index 160d8e33..dc749583 100644
--- a/tests/tests_monggregate/tests_operators/tests_array/test_in.py
+++ b/tests/tests_monggregate/tests_operators/tests_array/test_in.py
@@ -2,6 +2,19 @@
 
 from monggregate.operators.array.in_ import In
 
+def test_in_expression():
+    # Setup
+    left = 5
+    right = [1, 2, 3, 4, 5]
+    expected_expression = {"$in": [left, right]}
+
+    # Act
+    in_op = In(left=left, right=right)
+    result_expression = in_op.expression
+
+    # Assert
+    assert result_expression == expected_expression
+
 
 class TestIn:
     """Tests for `In` class."""
diff --git a/tests/tests_monggregate/tests_operators/tests_array/test_is_array.py b/tests/tests_monggregate/tests_operators/tests_array/test_is_array.py
index c80a3168..25aeba7a 100644
--- a/tests/tests_monggregate/tests_operators/tests_array/test_is_array.py
+++ b/tests/tests_monggregate/tests_operators/tests_array/test_is_array.py
@@ -2,6 +2,18 @@
 
 from monggregate.operators.array.is_array import IsArray
 
+def test_is_array_expression():
+    # Setup
+    operand = [1, 2, 3]
+    expected_expression = {"$isArray": operand}
+
+    # Act
+    is_array_op = IsArray(operand=operand)
+    result_expression = is_array_op.expression
+
+    # Assert
+    assert result_expression == expected_expression
+
 
 class TestIsArray:
     """Tests for `IsArray` class."""
diff --git a/tests/tests_monggregate/tests_operators/tests_array/test_last.py b/tests/tests_monggregate/tests_operators/tests_array/test_last.py
index 35ef51e2..e993d7fe 100644
--- a/tests/tests_monggregate/tests_operators/tests_array/test_last.py
+++ b/tests/tests_monggregate/tests_operators/tests_array/test_last.py
@@ -2,6 +2,20 @@
 
 from monggregate.operators.array.last import Last
 
+from monggregate.operators.array.is_array import IsArray
+
+def test_is_array_expression():
+    # Setup
+    operand = [1, 2, 3]
+    expected_expression = {"$isArray": operand}
+
+    # Act
+    is_array_op = IsArray(operand=operand)
+    result_expression = is_array_op.expression
+
+    # Assert
+    assert result_expression == expected_expression
+
 
 class TestLast:
     """Tests for `Last` class."""
diff --git a/tests/tests_monggregate/tests_operators/tests_array/test_max_n.py b/tests/tests_monggregate/tests_operators/tests_array/test_max_n.py
index 0d9d97a9..1bdfc636 100644
--- a/tests/tests_monggregate/tests_operators/tests_array/test_max_n.py
+++ b/tests/tests_monggregate/tests_operators/tests_array/test_max_n.py
@@ -2,6 +2,24 @@
 
 from monggregate.operators.array.max_n import MaxN
 
+def test_maxn_expression():
+    # Setup
+    operand = [1, 2, 3]
+    limit = 3
+    expected_expression = {
+        "$maxN": {
+            "n": limit,
+            "input": operand
+        }
+    }
+
+    # Act
+    max_n_op = MaxN(operand=operand, limit=limit)
+    result_expression = max_n_op.expression
+
+    # Assert
+    assert result_expression == expected_expression
+
 
 class TestMaxN:
     """Tests for `MaxN` class."""
@@ -14,4 +32,4 @@ def test_instantiation(self) -> None:
     def test_expression(self) -> None:
         """Test that `MaxN` class returns the correct expression."""
         max_n_op = MaxN(input=[1, 2, 3], n=2)
-        assert max_n_op.expression == {"$maxN": {"input": [1, 2, 3], "n": 2}}
+        assert max_n_op.expression == {"$maxN": {"input": [1, 2, 3], "n": 2}}
\ No newline at end of file
diff --git a/tests/tests_monggregate/tests_operators/tests_array/test_min_n.py b/tests/tests_monggregate/tests_operators/tests_array/test_min_n.py
index 4490834e..9c900468 100644
--- a/tests/tests_monggregate/tests_operators/tests_array/test_min_n.py
+++ b/tests/tests_monggregate/tests_operators/tests_array/test_min_n.py
@@ -2,6 +2,24 @@
 
 from monggregate.operators.array.min_n import MinN
 
+def test_minn_expression():
+    # Setup
+    operand = [3, 1, 4, 1, 5]
+    limit = 2
+    expected_expression = {
+        "$minN": {
+            "n": limit,
+            "input": operand
+        }
+    }
+
+    # Act
+    min_n_op = MinN(operand=operand, limit=limit)
+    result_expression = min_n_op.expression
+
+    # Assert
+    assert result_expression == expected_expression
+
 
 class TestMinN:
     """Tests for `MinN` class."""
@@ -14,4 +32,4 @@ def test_instantiation(self) -> None:
     def test_expression(self) -> None:
         """Test that `MinN` class returns the correct expression."""
         min_n_op = MinN(operand=[3, 1, 4, 1, 5], limit=2)
-        assert min_n_op.expression == {"$minN": {"n": 2, "input": [3, 1, 4, 1, 5]}}
+        assert min_n_op.expression == {"$minN": {"n": 2, "input": [3, 1, 4, 1, 5]}}
\ No newline at end of file
diff --git a/tests/tests_monggregate/tests_operators/tests_array/test_size.py b/tests/tests_monggregate/tests_operators/tests_array/test_size.py
index c84c0739..e61fd566 100644
--- a/tests/tests_monggregate/tests_operators/tests_array/test_size.py
+++ b/tests/tests_monggregate/tests_operators/tests_array/test_size.py
@@ -2,6 +2,18 @@
 
 from monggregate.operators.array.size import Size
 
+def test_size_expression():
+    # Setup
+    array = ["a", "b", "c"]
+    expected_expression = {"$size": array}
+
+    # Act
+    size_op = Size(operand=array)
+    result_expression = size_op.expression
+
+    # Assert
+    assert result_expression == expected_expression
+
 
 class TestSize:
     """Tests for `Size` class."""
diff --git a/tests/tests_monggregate/tests_operators/tests_array/test_sort_array.py b/tests/tests_monggregate/tests_operators/tests_array/test_sort_array.py
index 0b573459..893a8ab1 100644
--- a/tests/tests_monggregate/tests_operators/tests_array/test_sort_array.py
+++ b/tests/tests_monggregate/tests_operators/tests_array/test_sort_array.py
@@ -2,6 +2,24 @@
 
 from monggregate.operators.array.sort_array import SortArray
 
+def test_sort_array_expression():
+    # Setup
+    array = [{"score": 10}, {"score": 20}, {"score": 30}]
+    sort_by = {"score": 1}
+    expected_expression = {
+        "$sortArray": {
+            "input": array,
+            "sortBy": sort_by
+        }
+    }
+
+    # Act
+    sort_op = SortArray(operand=array, by=sort_by)
+    result_expression = sort_op.expression
+
+    # Assert
+    assert result_expression == expected_expression
+
 
 class TestSortArray:
     """Tests for `SortArray` class."""

From 22b85a18e88c2ec43388c1ed92147d0aa2492af5 Mon Sep 17 00:00:00 2001
From: Zegthor91 <zegthorthechazz@gmail.com>
Date: Fri, 6 Jun 2025 14:31:00 +0200
Subject: [PATCH 05/10] tests_boolean folder passed and completed

---
 .../tests_operators/tests_boolean/test_and.py      | 12 ++++++++++++
 .../tests_operators/tests_boolean/test_not.py      | 12 ++++++++++++
 .../tests_operators/tests_boolean/test_or.py       | 14 ++++++++++++++
 3 files changed, 38 insertions(+)

diff --git a/tests/tests_monggregate/tests_operators/tests_boolean/test_and.py b/tests/tests_monggregate/tests_operators/tests_boolean/test_and.py
index e172409c..ac26d244 100644
--- a/tests/tests_monggregate/tests_operators/tests_boolean/test_and.py
+++ b/tests/tests_monggregate/tests_operators/tests_boolean/test_and.py
@@ -2,6 +2,18 @@
 
 from monggregate.operators.boolean.and_ import And
 
+def test_and_expression():
+    # Setup
+    expressions = [{"$gt": 18}, {"$lt": 65}]
+    expected_expression = {"$and": expressions}
+
+    # Act
+    and_op = And(operands=expressions)
+    result_expression = and_op.expression
+
+    # Assert
+    assert result_expression == expected_expression
+
 
 class TestAnd:
     """Tests for `And` class."""
diff --git a/tests/tests_monggregate/tests_operators/tests_boolean/test_not.py b/tests/tests_monggregate/tests_operators/tests_boolean/test_not.py
index 27d6180c..b36d9404 100644
--- a/tests/tests_monggregate/tests_operators/tests_boolean/test_not.py
+++ b/tests/tests_monggregate/tests_operators/tests_boolean/test_not.py
@@ -2,6 +2,18 @@
 
 from monggregate.operators.boolean.not_ import Not
 
+def test_not_expression():
+    # Setup
+    operand = {"$eq": ["inactive"]}
+    expected_expression = {"$not": [operand]}
+
+    # Act
+    not_op = Not(operand=operand)
+    result_expression = not_op.expression
+
+    # Assert
+    assert result_expression == expected_expression
+
 
 class TestNot:
     """Tests for `Not` class."""
diff --git a/tests/tests_monggregate/tests_operators/tests_boolean/test_or.py b/tests/tests_monggregate/tests_operators/tests_boolean/test_or.py
index 817bb9b1..a86ef41e 100644
--- a/tests/tests_monggregate/tests_operators/tests_boolean/test_or.py
+++ b/tests/tests_monggregate/tests_operators/tests_boolean/test_or.py
@@ -2,6 +2,20 @@
 
 from monggregate.operators.boolean.or_ import Or
 
+from monggregate.operators.boolean.or_ import Or
+
+def test_or_expression():
+    # Setup
+    operands = [{"$gt": 5}, {"$eq": "active"}]
+    expected_expression = {"$or": operands}
+
+    # Act
+    or_op = Or(operands=operands)
+    result_expression = or_op.expression
+
+    # Assert
+    assert result_expression == expected_expression
+
 
 class TestOr:
     """Tests for `Or` class."""

From e3fd0ab7a8f46b2b58bc193fd6b1e8906e2249a1 Mon Sep 17 00:00:00 2001
From: Zegthor91 <zegthorthechazz@gmail.com>
Date: Fri, 6 Jun 2025 14:51:29 +0200
Subject: [PATCH 06/10] tests_comparison folder passed and completed

---
 .../tests_operators/tests_comparison/test_cmp.py  | 13 +++++++++++++
 .../tests_operators/tests_comparison/test_eq.py   | 13 +++++++++++++
 .../tests_operators/tests_comparison/test_gt.py   | 14 ++++++++++++++
 .../tests_operators/tests_comparison/test_gte.py  | 15 +++++++++++++++
 .../tests_operators/tests_comparison/test_lt.py   | 15 +++++++++++++++
 .../tests_operators/tests_comparison/test_lte.py  | 13 +++++++++++++
 .../tests_operators/tests_comparison/test_ne.py   | 13 +++++++++++++
 7 files changed, 96 insertions(+)

diff --git a/tests/tests_monggregate/tests_operators/tests_comparison/test_cmp.py b/tests/tests_monggregate/tests_operators/tests_comparison/test_cmp.py
index b81c5059..9c849484 100644
--- a/tests/tests_monggregate/tests_operators/tests_comparison/test_cmp.py
+++ b/tests/tests_monggregate/tests_operators/tests_comparison/test_cmp.py
@@ -2,6 +2,19 @@
 
 from monggregate.operators.comparison.cmp import Compare
 
+def test_compare_expression():
+    # Setup
+    left = "$field"
+    right = 10
+    expected_expression = {"$cmp": [left, right]}
+
+    # Act
+    cmp_op = Compare(left=left, right=right)
+    result_expression = cmp_op.expression
+
+    # Assert
+    assert result_expression == expected_expression
+
 
 class TestCompare:
     """Tests for `Compare` class."""
diff --git a/tests/tests_monggregate/tests_operators/tests_comparison/test_eq.py b/tests/tests_monggregate/tests_operators/tests_comparison/test_eq.py
index 8e3cb4f2..4a38a342 100644
--- a/tests/tests_monggregate/tests_operators/tests_comparison/test_eq.py
+++ b/tests/tests_monggregate/tests_operators/tests_comparison/test_eq.py
@@ -2,6 +2,19 @@
 
 from monggregate.operators.comparison.eq import Equal
 
+def test_equal_expression():
+    # Setup
+    left = "$field"
+    right = 10
+    expected_expression = {"$eq": [left, right]}
+
+    # Act
+    equal_op = Equal(left=left, right=right)
+    result_expression = equal_op.expression
+
+    # Assert
+    assert result_expression == expected_expression
+
 
 class TestEqual:
     """Tests for `Equal` class."""
diff --git a/tests/tests_monggregate/tests_operators/tests_comparison/test_gt.py b/tests/tests_monggregate/tests_operators/tests_comparison/test_gt.py
index cabeaa10..2ea79d69 100644
--- a/tests/tests_monggregate/tests_operators/tests_comparison/test_gt.py
+++ b/tests/tests_monggregate/tests_operators/tests_comparison/test_gt.py
@@ -2,6 +2,19 @@
 
 from monggregate.operators.comparison.gt import GreatherThan
 
+def test_greather_than_expression():
+    # Setup
+    left = "$field"
+    right = 10
+    expected_expression = {"$gt": [left, right]}
+
+    # Act
+    gt_op = GreatherThan(left=left, right=right)
+    result_expression = gt_op.expression
+
+    # Assert
+    assert result_expression == expected_expression
+
 
 class TestGreatherThan:
     """Tests for `GreatherThan` class."""
@@ -15,3 +28,4 @@ def test_expression(self) -> None:
         """Test that `GreatherThan` class returns the correct expression."""
         gt_op = GreatherThan(left="$field", right=10)
         assert gt_op.expression == {"$gt": ["$field", 10]}
+        
diff --git a/tests/tests_monggregate/tests_operators/tests_comparison/test_gte.py b/tests/tests_monggregate/tests_operators/tests_comparison/test_gte.py
index 72721a76..098489c6 100644
--- a/tests/tests_monggregate/tests_operators/tests_comparison/test_gte.py
+++ b/tests/tests_monggregate/tests_operators/tests_comparison/test_gte.py
@@ -2,6 +2,21 @@
 
 from monggregate.operators.comparison.gte import GreatherThanOrEqual
 
+from monggregate.operators.comparison.gte import GreatherThanOrEqual
+
+def test_greather_than_or_equal_expression():
+    # Setup
+    left = "$field"
+    right = 10
+    expected_expression = {"$gte": [left, right]}
+
+    # Act
+    gte_op = GreatherThanOrEqual(left=left, right=right)
+    result_expression = gte_op.expression
+
+    # Assert
+    assert result_expression == expected_expression
+
 
 class TestGreatherThanOrEqual:
     """Tests for `GreatherThanOrEqual` class."""
diff --git a/tests/tests_monggregate/tests_operators/tests_comparison/test_lt.py b/tests/tests_monggregate/tests_operators/tests_comparison/test_lt.py
index 506db97f..9206bfee 100644
--- a/tests/tests_monggregate/tests_operators/tests_comparison/test_lt.py
+++ b/tests/tests_monggregate/tests_operators/tests_comparison/test_lt.py
@@ -2,6 +2,21 @@
 
 from monggregate.operators.comparison.lt import LowerThan
 
+from monggregate.operators.comparison.lt import LowerThan
+
+def test_lower_than_expression():
+    # Setup
+    left = "$field"
+    right = 10
+    expected_expression = {"$lt": [left, right]}
+
+    # Act
+    lt_op = LowerThan(left=left, right=right)
+    result_expression = lt_op.expression
+
+    # Assert
+    assert result_expression == expected_expression
+
 
 class TestLowerThan:
     """Tests for `LowerThan` class."""
diff --git a/tests/tests_monggregate/tests_operators/tests_comparison/test_lte.py b/tests/tests_monggregate/tests_operators/tests_comparison/test_lte.py
index 3d3bd593..540da778 100644
--- a/tests/tests_monggregate/tests_operators/tests_comparison/test_lte.py
+++ b/tests/tests_monggregate/tests_operators/tests_comparison/test_lte.py
@@ -2,6 +2,19 @@
 
 from monggregate.operators.comparison.lte import LowerThanOrEqual
 
+def test_lower_than_or_equal_expression():
+    # Setup
+    left = "$field"
+    right = 10
+    expected_expression = {"$lte": [left, right]}
+
+    # Act
+    lte_op = LowerThanOrEqual(left=left, right=right)
+    result_expression = lte_op.expression
+
+    # Assert
+    assert result_expression == expected_expression
+
 
 class TestLowerThanOrEqual:
     """Tests for `LowerThanOrEqual` class."""
diff --git a/tests/tests_monggregate/tests_operators/tests_comparison/test_ne.py b/tests/tests_monggregate/tests_operators/tests_comparison/test_ne.py
index 6fe9457b..80d59eee 100644
--- a/tests/tests_monggregate/tests_operators/tests_comparison/test_ne.py
+++ b/tests/tests_monggregate/tests_operators/tests_comparison/test_ne.py
@@ -2,6 +2,19 @@
 
 from monggregate.operators.comparison.ne import NotEqual
 
+def test_not_equal_expression():
+    # Setup
+    left = "$field"
+    right = 10
+    expected_expression = {"$ne": [left, right]}
+
+    # Act
+    ne_op = NotEqual(left=left, right=right)
+    result_expression = ne_op.expression
+
+    # Assert
+    assert result_expression == expected_expression
+
 
 class TestNotEqual:
     """Tests for `NotEqual` class."""

From 6e0d3b6d8e26eb4f49d7a6e490a7bdb507ba8c7a Mon Sep 17 00:00:00 2001
From: Zegthor91 <zegthorthechazz@gmail.com>
Date: Fri, 6 Jun 2025 15:03:10 +0200
Subject: [PATCH 07/10] tests_conditional folder passed and completed

---
 .../tests_conditional/test_cond.py            | 20 ++++++++++++++++++
 .../tests_conditional/test_if_null.py         | 13 ++++++++++++
 .../tests_conditional/test_switch.py          | 21 +++++++++++++++++++
 3 files changed, 54 insertions(+)

diff --git a/tests/tests_monggregate/tests_operators/tests_conditional/test_cond.py b/tests/tests_monggregate/tests_operators/tests_conditional/test_cond.py
index 810aaff2..67023162 100644
--- a/tests/tests_monggregate/tests_operators/tests_conditional/test_cond.py
+++ b/tests/tests_monggregate/tests_operators/tests_conditional/test_cond.py
@@ -2,6 +2,26 @@
 
 from monggregate.operators.conditional.cond import Cond
 
+def test_cond_expression():
+    # Setup
+    if_ = {"$gt": ["$age", 18]}
+    then_ = "Passed"
+    else_ = "Failed"
+    expected_expression = {
+        "$cond": {
+            "if": if_,
+            "then": then_,
+            "else": else_
+        }
+    }
+
+    # Act
+    cond_op = Cond(if_=if_, then_=then_, else_=else_)
+    result_expression = cond_op.expression
+
+    # Assert
+    assert result_expression == expected_expression
+
 
 class TestCond:
     """Tests for `Cond` class."""
diff --git a/tests/tests_monggregate/tests_operators/tests_conditional/test_if_null.py b/tests/tests_monggregate/tests_operators/tests_conditional/test_if_null.py
index f63e1bcb..c458800a 100644
--- a/tests/tests_monggregate/tests_operators/tests_conditional/test_if_null.py
+++ b/tests/tests_monggregate/tests_operators/tests_conditional/test_if_null.py
@@ -2,6 +2,19 @@
 
 from monggregate.operators.conditional.if_null import IfNull
 
+def test_if_null_expression():
+    # Setup
+    operand = "$optional_field"
+    output = "default_value"
+    expected_expression = {"$ifNull": [operand, output]}
+
+    # Act
+    ifnull_op = IfNull(operand=operand, output=output)
+    result_expression = ifnull_op.expression
+
+    # Assert
+    assert result_expression == expected_expression
+
 
 class TestIfNull:
     """Tests for `IfNull` class."""
diff --git a/tests/tests_monggregate/tests_operators/tests_conditional/test_switch.py b/tests/tests_monggregate/tests_operators/tests_conditional/test_switch.py
index 56d71785..d6fd15da 100644
--- a/tests/tests_monggregate/tests_operators/tests_conditional/test_switch.py
+++ b/tests/tests_monggregate/tests_operators/tests_conditional/test_switch.py
@@ -2,6 +2,27 @@
 
 from monggregate.operators.conditional.switch import Switch
 
+def test_switch_expression():
+    # Setup
+    branches = [
+        {"case": {"$eq": ["$grade", "A"]}, "then": "Type A"},
+        {"case": {"$eq": ["$grade", "B"]}, "then": "Type B"},
+    ]
+    default = "Unknown Type"
+    expected_expression = {
+        "$switch": {
+            "branches": branches,
+            "default": default
+        }
+    }
+
+    # Act
+    switch_op = Switch(branches=branches, default=default)
+    result_expression = switch_op.expression
+
+    # Assert
+    assert result_expression == expected_expression
+
 
 class TestSwitch:
     """Tests for `Switch` class."""

From a6981f6b2de37a05b60dfca7657d5f41d4b5966a Mon Sep 17 00:00:00 2001
From: Zegthor91 <zegthorthechazz@gmail.com>
Date: Fri, 6 Jun 2025 15:08:48 +0200
Subject: [PATCH 08/10] tests_date folder passed and completed

---
 .../tests_date/test_millisecond.py               | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/tests/tests_monggregate/tests_operators/tests_date/test_millisecond.py b/tests/tests_monggregate/tests_operators/tests_date/test_millisecond.py
index c923ed6e..d98cf1e6 100644
--- a/tests/tests_monggregate/tests_operators/tests_date/test_millisecond.py
+++ b/tests/tests_monggregate/tests_operators/tests_date/test_millisecond.py
@@ -2,6 +2,22 @@
 
 from monggregate.operators.date.millisecond import Millisecond
 
+def test_millisecond_expression():
+    # Setup
+    operand = "$date"
+    timezone = "America/New_York"
+    expected_expression = {
+        "$millisecond": {"date": operand, "timezone": timezone}
+    }
+
+    # Act
+    millisecond_op = Millisecond(operand=operand, timezone=timezone)
+    result_expression = millisecond_op.expression
+
+    # Assert
+    assert result_expression == expected_expression
+
+
 
 class TestMillisecond:
     """Tests for `Millisecond` class."""

From 2f38e87ccb41ce30ed6411e1d637f62c3066515c Mon Sep 17 00:00:00 2001
From: Zegthor91 <zegthorthechazz@gmail.com>
Date: Fri, 6 Jun 2025 15:25:52 +0200
Subject: [PATCH 09/10] tests_objects folder passed and completed

---
 .../tests_objects/test_merge_objects.py              | 12 ++++++++++++
 .../tests_objects/test_object_to_array.py            | 12 ++++++++++++
 2 files changed, 24 insertions(+)

diff --git a/tests/tests_monggregate/tests_operators/tests_objects/test_merge_objects.py b/tests/tests_monggregate/tests_operators/tests_objects/test_merge_objects.py
index 7a96f33b..3af91899 100644
--- a/tests/tests_monggregate/tests_operators/tests_objects/test_merge_objects.py
+++ b/tests/tests_monggregate/tests_operators/tests_objects/test_merge_objects.py
@@ -2,6 +2,18 @@
 
 from monggregate.operators.objects.merge_objects import MergeObjects
 
+def test_merge_objects_expression():
+    # Setup
+    operand = [{"field1": 1}, {"field2": 2}]
+    expected_expression = {"$mergeObjects": operand}
+
+    # Act
+    merge_objects_op = MergeObjects(operand=operand)
+    result_expression = merge_objects_op.expression
+
+    # Assert
+    assert result_expression == expected_expression
+
 
 class TestMergeObjects:
     """Tests for `MergeObjects` class."""
diff --git a/tests/tests_monggregate/tests_operators/tests_objects/test_object_to_array.py b/tests/tests_monggregate/tests_operators/tests_objects/test_object_to_array.py
index d9a44683..eab3dfa8 100644
--- a/tests/tests_monggregate/tests_operators/tests_objects/test_object_to_array.py
+++ b/tests/tests_monggregate/tests_operators/tests_objects/test_object_to_array.py
@@ -2,6 +2,18 @@
 
 from monggregate.operators.objects.object_to_array import ObjectToArray
 
+def test_object_to_array_expression():
+    # Setup
+    operand = "$document"
+    expected_expression = {"$objectToArray": "$document"}
+
+    # Act
+    object_to_array_op = ObjectToArray(operand=operand)
+    result_expression = object_to_array_op.expression
+
+    # Assert
+    assert result_expression == expected_expression
+
 
 class TestObjectToArray:
     """Tests for `ObjectToArray` class."""

From 6dfc3b3c1f9a1df0a3fac183c1d7b9aa32fa24e7 Mon Sep 17 00:00:00 2001
From: Zegthor91 <zegthorthechazz@gmail.com>
Date: Fri, 6 Jun 2025 15:40:00 +0200
Subject: [PATCH 10/10] tests_type_ & tests_strings passed and completed

---
 .../tests_strings/test_concat.py              | 12 ++++++++
 .../tests_strings/test_date_from_string.py    | 30 +++++++++++++++++++
 .../tests_strings/test_date_to_string.py      | 27 +++++++++++++++++
 .../tests_operators/tests_type_/test_type.py  | 12 ++++++++
 4 files changed, 81 insertions(+)

diff --git a/tests/tests_monggregate/tests_operators/tests_strings/test_concat.py b/tests/tests_monggregate/tests_operators/tests_strings/test_concat.py
index 6f7b87e1..b8611c8d 100644
--- a/tests/tests_monggregate/tests_operators/tests_strings/test_concat.py
+++ b/tests/tests_monggregate/tests_operators/tests_strings/test_concat.py
@@ -2,6 +2,18 @@
 
 from monggregate.operators.strings.concat import Concat
 
+def test_concat_expression():
+    # Setup
+    operands = ["$firstName", " ", "$lastName"]
+    expected_expression = {"$concat": ["$firstName", " ", "$lastName"]}
+
+    # Act
+    concat_op = Concat(operands=operands)
+    result_expression = concat_op.expression
+
+    # Assert
+    assert result_expression == expected_expression
+
 
 class TestConcat:
     """Tests for `Concat` class."""
diff --git a/tests/tests_monggregate/tests_operators/tests_strings/test_date_from_string.py b/tests/tests_monggregate/tests_operators/tests_strings/test_date_from_string.py
index 1a27b7ad..416af215 100644
--- a/tests/tests_monggregate/tests_operators/tests_strings/test_date_from_string.py
+++ b/tests/tests_monggregate/tests_operators/tests_strings/test_date_from_string.py
@@ -2,6 +2,36 @@
 
 from monggregate.operators.strings.date_from_string import DateFromString
 
+def test_date_from_string_expression_full():
+    # Setup
+    date_string = "2023-01-01"
+    format_ = "%Y-%m-%d"
+    timezone = "America/New_York"
+    on_error = "Invalid date"
+    on_null = "No date provided"
+    expected_expression = {
+        "$dateFromString": {
+            "dateString": "2023-01-01",
+            "format": "%Y-%m-%d",
+            "timezone": "America/New_York",
+            "onError": "Invalid date",
+            "onNull": "No date provided",
+        }
+    }
+
+    # Act
+    date_from_string_op = DateFromString(
+        date_string=date_string,
+        format_=format_,
+        timezone=timezone,
+        on_error=on_error,
+        on_null=on_null,
+    )
+    result_expression = date_from_string_op.expression
+
+    # Assert
+    assert result_expression == expected_expression
+
 
 class TestDateFromString:
     """Tests for `DateFromString` class."""
diff --git a/tests/tests_monggregate/tests_operators/tests_strings/test_date_to_string.py b/tests/tests_monggregate/tests_operators/tests_strings/test_date_to_string.py
index b9c886e5..932e78b6 100644
--- a/tests/tests_monggregate/tests_operators/tests_strings/test_date_to_string.py
+++ b/tests/tests_monggregate/tests_operators/tests_strings/test_date_to_string.py
@@ -2,6 +2,33 @@
 
 from monggregate.operators.strings.date_to_string import DateToString
 
+def test_date_to_string_expression_full():
+    # Setup
+    date = "$date"
+    format_ = "%Y-%m-%d"
+    timezone = "America/New_York"
+    on_null = "No date available"
+    expected_expression = {
+        "$dateToString": {
+            "date": "$date",
+            "format": "%Y-%m-%d",
+            "timezone": "America/New_York",
+            "onNull": "No date available",
+        }
+    }
+
+    # Act
+    date_to_string_op = DateToString(
+        date=date,
+        format_=format_,
+        timezone=timezone,
+        on_null=on_null,
+    )
+    result_expression = date_to_string_op.expression
+
+    # Assert
+    assert result_expression == expected_expression
+
 
 class TestDateToString:
     """Tests for `DateToString` class."""
diff --git a/tests/tests_monggregate/tests_operators/tests_type_/test_type.py b/tests/tests_monggregate/tests_operators/tests_type_/test_type.py
index 52b809d1..1bc65351 100644
--- a/tests/tests_monggregate/tests_operators/tests_type_/test_type.py
+++ b/tests/tests_monggregate/tests_operators/tests_type_/test_type.py
@@ -2,6 +2,18 @@
 
 from monggregate.operators.type_.type_ import Type_
 
+def test_type_expression():
+    # Setup
+    operand = "$field"
+    expected_expression = {"$type": "$field"}
+
+    # Act
+    type_op = Type_(operand=operand)
+    result_expression = type_op.expression
+
+    # Assert
+    assert result_expression == expected_expression
+
 
 class TestType:
     """Tests for `Type_` class."""