128 revival complete test coverage

tests/tests_legacy/__init__.py

@@ -0,0 +1 @@
+"""Tests for legacy functionality."""

tests/tests_legacy/tests_search/__init__.py

@@ -0,0 +1 @@
+"""Tests for legacy search functionality."""

tests/tests_monggregate/__init__.py

@@ -1 +1,7 @@
-"""Tests for the monggregate package."""
+"""Tests for `monggregate` package."""
+
+from monggregate.base import BaseModel, Expression, Singleton, express, isbasemodel
+from monggregate.dollar import (AggregationVariableEnum,Dollar,DollarDollar,CLUSTER_TIME,NOW,ROOT,CURRENT,REMOVE,DESCEND,PRUNE,KEEP,CONSTANTS,S,SS,)
+from monggregate.fields import FieldName, FieldPath, Variable
+from monggregate.pipeline import Pipeline, Match, Project
+from monggregate.utils import (to_unique_list,validate_field_path,validate_field_paths,StrEnum,)

tests/tests_monggregate/tests_operators/__init__.py

@@ -0,0 +1,3 @@
+"""Tests for `monggregate.operators` subpackage."""
+
+from monggregate.operators.operator import Operator

tests/tests_monggregate/tests_operators/test_operator.py

@@ -0,0 +1,3 @@
+"""Tests for `monggregate.operators.operator`."""
+
+# TODO

tests/tests_monggregate/tests_operators/tests_accumulators/__init__.py

@@ -0,0 +1,11 @@
+"""Tests for `monggregate.operators.accumulators` subpackage."""
+
+from monggregate.operators.accumulators.accumulator import Accumulator, AccumulatorEnum
+from monggregate.operators.accumulators.avg import Average, avg
+from monggregate.operators.accumulators.count import Count, count
+from monggregate.operators.accumulators.first import First, first
+from monggregate.operators.accumulators.last import Last, last
+from monggregate.operators.accumulators.max import Max, max
+from monggregate.operators.accumulators.min import Min, min
+from monggregate.operators.accumulators.push import Push, push
+from monggregate.operators.accumulators.sum import Sum, sum

tests/tests_monggregate/tests_operators/tests_arithmetic/__init__.py

@@ -0,0 +1,8 @@
+"""Tests for `monggregate.operators.arithmetic` subpackage."""
+
+from monggregate.operators.arithmetic.add import Add
+from monggregate.operators.arithmetic.arithmetic import ArithmeticOperatorEnum
+from monggregate.operators.arithmetic.divide import Divide
+from monggregate.operators.arithmetic.multiply import Multiply
+from monggregate.operators.arithmetic.pow import Pow
+from monggregate.operators.arithmetic.subtract import Subtract

tests/tests_monggregate/tests_operators/tests_arithmetic/test_arithmetic.py

@@ -0,0 +1,3 @@
+"""Tests for `monggregate.operators.arithmetic.arithmetic`."""
+
+# TODO

tests/tests_monggregate/tests_operators/tests_array/__init__.py

@@ -0,0 +1,13 @@
+"""Tests for `monggregate.operators.array` subpackage."""
+
+from monggregate.operators.array.array_to_object import ArrayToObject
+from monggregate.operators.array.array import Operator
+from monggregate.operators.array.filter import Filter
+from monggregate.operators.array.first import First
+from monggregate.operators.array.in_ import In
+from monggregate.operators.array.is_array import IsArray
+from monggregate.operators.array.last import Last
+from monggregate.operators.array.max_n import MaxN
+from monggregate.operators.array.min_n import MinN
+from monggregate.operators.array.size import Size
+from monggregate.operators.array.sort_array import SortArray

tests/tests_monggregate/tests_operators/tests_array/test_array.py

@@ -0,0 +1,3 @@
+"""Tests for `monggregate.operators.array.array`."""
+
+# TODO

tests/tests_monggregate/tests_operators/tests_array/test_first.py

@@ -1,16 +1,15 @@
 """Tests for `monggregate.operators.array.first` module."""
 
-from monggregate.operators.array.first import First
+from monggregate.operators.array.first import First, first
 
-from monggregate.operators.array.first import First
 
-def test_first_expression():
+def test_first_expression() -> None:
     # Setup
     array = [10, 20, 30]
     expected_expression = {"$first": array}
 
     # Act
-    first_op = First(operand=array)
+    first_op = first(array=array)
     result_expression = first_op.expression
 
     # Assert

tests/tests_monggregate/tests_operators/tests_boolean/__init__.py

@@ -0,0 +1,6 @@
+"""Tests for `monggregate.operators.boolean` subpackage."""
+
+from monggregate.operators.boolean.and_ import And
+from monggregate.operators.boolean.boolean import BooleanOperator
+from monggregate.operators.boolean.not_ import Not
+from monggregate.operators.boolean.or_ import Or

tests/tests_monggregate/tests_operators/tests_boolean/test_boolean.py

@@ -0,0 +1,4 @@
+"""Tests for `monggregate.operators.boolean.boolean`."""
+
+
+# TODO

tests/tests_monggregate/tests_operators/tests_comparison/__init__.py

@@ -0,0 +1,10 @@
+"""Tests for `monggregate.operators.comparison` subpackage."""
+
+from monggregate.operators.comparison.cmp import Compare
+from monggregate.operators.comparison.comparator import Comparator
+from monggregate.operators.comparison.eq import Equal
+from monggregate.operators.comparison.gt import GreatherThan
+from monggregate.operators.comparison.gte import GreatherThanOrEqual
+from monggregate.operators.comparison.lt import LowerThan
+from monggregate.operators.comparison.lte import LowerThanOrEqual
+from monggregate.operators.comparison.ne import NotEqual

tests/tests_monggregate/tests_operators/tests_comparison/test_comparator.py

@@ -0,0 +1,3 @@
+"""Tests for `monggregate.operators.comparison`."""
+
+# TODO

tests/tests_monggregate/tests_operators/tests_comparison/test_gte.py

@@ -2,8 +2,6 @@
 
 from monggregate.operators.comparison.gte import GreatherThanOrEqual
 
-from monggregate.operators.comparison.gte import GreatherThanOrEqual
-
 def test_greather_than_or_equal_expression():
     # Setup
     left = "$field"

tests/tests_monggregate/tests_operators/tests_comparison/test_lt.py

@@ -2,8 +2,6 @@
 
 from monggregate.operators.comparison.lt import LowerThan
 
-from monggregate.operators.comparison.lt import LowerThan
-
 def test_lower_than_expression():
     # Setup
     left = "$field"

tests/tests_monggregate/tests_operators/tests_conditional/__init__.py

@@ -0,0 +1,6 @@
+"""Tests for `monggregate.operators.conditional` subpackage."""
+
+from monggregate.operators.conditional.cond import Cond
+from monggregate.operators.conditional.conditional import ConditionalOperator
+from monggregate.operators.conditional.if_null import IfNull
+from monggregate.operators.conditional.switch import Switch

tests/tests_monggregate/tests_operators/tests_conditional/test_conditional.py

@@ -0,0 +1,3 @@
+"""Tests for `monggregate.operators.conditional.conditional`."""
+
+# TODO

tests/tests_monggregate/tests_operators/tests_custom/__init__.py

@@ -0,0 +1,4 @@
+"""Tests for `monggregate.operators.custom.custom`."""
+
+from monggregate.operators.custom.custom import CustomOperator
+# TODO

tests/tests_monggregate/tests_operators/tests_custom/test_custom.py

@@ -0,0 +1,3 @@
+"""Tests for `monggregate.operators.custom.custom`."""
+
+# TODO

tests/tests_monggregate/tests_operators/tests_data_size/__init__.py

@@ -0,0 +1,3 @@
+"""Tests for `monggregate.operators.data_size`."""
+
+from monggregate.operators.data_size.data_size import DataSizeOperator

tests/tests_monggregate/tests_operators/tests_data_size/test_data_size.py

@@ -0,0 +1,3 @@
+"""Tests for `monggregate.operators.data_size.data_size`."""
+
+# TODO

tests/tests_monggregate/tests_operators/tests_date/__init__.py

@@ -0,0 +1,4 @@
+"""Tests for `monggregate.operators.date` subpackage."""
+
+from monggregate.operators.date.date import DateOperator
+from monggregate.operators.date.millisecond import Millisecond

tests/tests_monggregate/tests_operators/tests_date/test_date.py

@@ -0,0 +1,3 @@
+"""Tests for `monggregate.operators.date.date`."""
+
+# TODO

tests/tests_monggregate/tests_operators/tests_objects/__init__.py

@@ -0,0 +1,5 @@
+"""Tests for `monggregate.operators.objects` subpackage."""
+
+from monggregate.operators.objects.merge_objects import MergeObjects
+from monggregate.operators.objects.object_ import ObjectOperator
+from monggregate.operators.objects.object_to_array import ObjectToArray

tests/tests_monggregate/tests_operators/tests_objects/test_object_.py

@@ -0,0 +1,4 @@
+"""Tests for `monggregate.operators.objects.objects`."""
+
+
+# TODO

tests/tests_monggregate/tests_operators/tests_strings/__init__.py

@@ -0,0 +1,6 @@
+"""Tests for `monggregate.operators.strings` subpackage."""
+
+from monggregate.operators.strings.concat import Concat
+from monggregate.operators.strings.date_from_string import DateFromString
+from monggregate.operators.strings.date_to_string import DateToString
+from monggregate.operators.strings.string import StringOperator

tests/tests_monggregate/tests_operators/tests_strings/test_string.py

@@ -0,0 +1,3 @@
+"""Tests for `monggregate.operators.strings.string`."""
+
+# TODO

tests/tests_monggregate/tests_operators/tests_type_/__init__.py

@@ -0,0 +1,3 @@
+"""Test for 'monggregate.operators.type_.type_'"""
+
+from monggregate.operators.type_.type_ import Type_

tests/tests_monggregate/tests_search/tests_collectors/__init__.py

@@ -0,0 +1 @@
+"""Tests for `monggregate.search.collectors`"""

tests/tests_monggregate/tests_search/tests_collectors/test_facet.py

@@ -0,0 +1 @@
+# TODO

tests/tests_monggregate/tests_search/tests_commons/test_count.py

@@ -0,0 +1 @@
+# TODO

tests/tests_monggregate/tests_search/tests_commons/test_fuzzy.py

@@ -0,0 +1 @@
+# TODO

tests/tests_monggregate/tests_search/tests_commons/test_highlight.py

@@ -0,0 +1 @@
+# TODO

tests/tests_monggregate/tests_search/tests_operators/__init__.py

@@ -0,0 +1,13 @@
+"""Tests for `monggregate.search.operators` subpackage."""
+
+from monggregate.search.operators.autocomplete import Autocomplete
+from monggregate.search.operators.clause import Clause
+from monggregate.search.operators.compound import Compound
+from monggregate.search.operators.equals import Equals
+from monggregate.search.operators.exists import Exists
+from monggregate.search.operators.more_like_this import MoreLikeThis
+from monggregate.search.operators.operator import SearchOperator
+from monggregate.search.operators.range import Range
+from monggregate.search.operators.regex import Regex
+from monggregate.search.operators.text import Text
+from monggregate.search.operators.wildcard import Wildcard

tests/tests_monggregate/tests_search/tests_operators/test_autocomplete.py

@@ -0,0 +1,37 @@
+import pytest
+from monggregate.search.operators.autocomplete import Autocomplete
+from monggregate.search.commons import FuzzyOptions
+
+def test_autocomplete_expression():
+    # Setup
+    query = "test"
+    path = "field"
+    fuzzy_options = FuzzyOptions(maxEdits=1, prefixLength=1, maxExpansions=10)
+
+    autocomplete = Autocomplete(
+        query=query,
+        path=path,
+        token_order="any",
+        fuzzy=fuzzy_options,
+        score={"boost": 2}
+    )
+
+    expected_expression = {
+        "autocomplete": {
+            "query": query,
+            "path": path,
+            "tokenOrder": "any",
+            "fuzzy": {
+                "maxEdits": 1,
+                "prefixLength": 1,
+                "maxExpansions": 10
+            },
+            "score": {"boost": 2}
+        }
+    }
+
+    # Act
+    actual_expression = autocomplete.expression
+
+    # Assert
+    assert actual_expression == expected_expression

tests/tests_monggregate/tests_search/tests_operators/test_clause.py

@@ -0,0 +1,27 @@
+"""Tests for `monggregate.search.operators.clause` module."""
+
+from monggregate.search.operators.clause import Clause
+from monggregate.search.operators.compound import Compound
+from monggregate.search.operators import OperatorMap
+
+
+def test_consistency_with_operator_map() -> None:
+    """Tests that all operators are present in the clause type."""
+
+    # Setup
+    operators_in_clause = set(Clause.__args__) | {Compound}
+    # Compoound should be in Clause but it seems complex to implement right now
+    # TODO : Fix this when fully migrating to pydantic v2.
+    operators_in_operator_map = set(OperatorMap.values())
+
+    # Act
+    missing_operators_in_clause = operators_in_operator_map - operators_in_clause
+    missing_operators_in_operator_map = operators_in_clause - operators_in_operator_map
+
+    # Assert
+    assert not missing_operators_in_clause, (
+        f"Operators in operator map but not in clause: {missing_operators_in_clause}"
+    )
+    assert not missing_operators_in_operator_map, (
+        f"Operators in clause but not in operator map: {missing_operators_in_operator_map}"
+    )

tests/tests_monggregate/tests_search/tests_operators/test_compound.py

@@ -0,0 +1,25 @@
+"""Tests for `monggregate.search.operators.compound` module."""
+
+from monggregate.search.operators.compound import Compound
+
+
+def test_compound_expression_with_must_equals() -> None:
+    """Tests that the compound expression is correct when using the must equals operator."""
+
+    # Setup
+    compound = Compound()
+    path = "field"
+    value = "test"
+    compound.equals("must", path=path, value=value)
+
+    expected_expression = {
+        "compound": {
+            "must": [{"equals": {"path": path, "score": None, "value": value}}]
+        }
+    }
+
+    # Act
+    actual_expression = compound.expression
+
+    # Assert
+    assert actual_expression == expected_expression

tests/tests_monggregate/tests_search/tests_operators/test_equals.py

@@ -0,0 +1,24 @@
+import pytest
+from monggregate.search.operators.equals import Equals
+
+def test_equals_expression():
+    # Setup
+    path = "status"
+    value = True
+    score = {"boost": 3}
+
+    equals_op = Equals(path=path, value=value, score=score)
+
+    expected_expression = {
+        "equals": {
+            "path": path,
+            "value": value,
+            "score": score
+        }
+    }
+
+    # Act
+    actual_expression = equals_op.expression
+
+    # Assert
+    assert actual_expression == expected_expression

tests/tests_monggregate/tests_search/tests_operators/test_exists.py

@@ -0,0 +1,19 @@
+from monggregate.search.operators.exists import Exists
+
+def test_exists_expression():
+    # Setup
+    path = "email"
+
+    exists_op = Exists(path=path)
+
+    expected_expression = {
+        "exists": {
+            "path": path
+        }
+    }
+
+    # Act
+    actual_expression = exists_op.expression
+
+    # Assert
+    assert actual_expression == expected_expression

tests/tests_monggregate/tests_search/tests_operators/test_more_like_this.py

@@ -0,0 +1,19 @@
+from monggregate.search.operators.more_like_this import MoreLikeThis
+
+def test_more_like_this_expression():
+    # Setup
+    like_docs = [{"title": "Introduction to MongoDB"}, {"title": "Advanced MongoDB Usage"}]
+
+    more_like_this = MoreLikeThis(like=like_docs)
+
+    expected_expression = {
+        "moreLikeThis": {
+            "like": like_docs
+        }
+    }
+
+    # Act
+    actual_expression = more_like_this.expression
+
+    # Assert
+    assert actual_expression == expected_expression