fixed match and op conversion tests

Author: Jibola

django_mongodb_backend/query_conversion/expression_converters.py

@@ -65,7 +65,7 @@ class BinaryConverter(BaseConverter):
             {"$gt": ["$price", 100]}
         }
     is converted to:
-        {"$gt": ["price", 100]}
+        {"price": {"$gt": 100}}
     """
 
     operator: str
@@ -79,6 +79,10 @@ def convert(cls, args):
                 if cls.operator == "$eq":
                     return {field_name: value}
                 return {field_name: {cls.operator: value}}
+            # If simple getFields are found, still mutate the original args list
+            for i, arg in enumerate(args):
+                if cls.is_simple_get_field(arg):
+                    args[i] = "$" + cls.convert_field_name(arg)
         return None
 
 
@@ -136,6 +140,15 @@ def convert(cls, in_args):
                 and all(cls.is_simple_value(v) for v in values)
             ):
                 return {field_name: {"$in": values}}
+            # Mutate the original list
+            for i, arg in enumerate(in_args):
+                if cls.is_simple_get_field(arg):
+                    in_args[i] = "$" + cls.convert_field_name(arg)
+                if isinstance(arg, list | tuple | set):
+                    arg[i] = [
+                        "$" + cls.convert_field_name(v) if cls.is_simple_get_field(v) else v
+                        for v in arg
+                    ]
         return None
 
 

tests/expression_converter_/test_match_conversion.py

@@ -223,24 +223,13 @@ def test_getfield_usage_on_dual_binary_operator(self):
                 ]
             }
         }
-        expected = [
-            {
-                "$match": {
-                    "$expr": {
-                        "$gt": [
-                            {"$getField": {"input": "$price", "field": "value"}},
-                            {"$getField": {"input": "$discounted_price", "field": "value"}},
-                        ]
-                    }
-                }
-            }
-        ]
+        expected = [{"$match": {"$expr": {"$gt": ["$price.value", "$discounted_price.value"]}}}]
         self.assertOptimizerEqual(expr, expected)
 
     def test_getfield_usage_on_onesided_binary_operator(self):
         expr = {"$expr": {"$gt": [{"$getField": {"input": "$price", "field": "value"}}, 100]}}
         # This should create a proper match condition with no $expr
-        expected = {"price.value": {"$gt": 100}}
+        expected = [{"$match": {"price.value": {"$gt": 100}}}]
         self.assertOptimizerEqual(expr, expected)
 
     def test_nested_getfield_usage_on_onesided_binary(self):
@@ -257,25 +246,5 @@ def test_nested_getfield_usage_on_onesided_binary(self):
                 ]
             }
         }
-        expected = {"item.price.value": {"$gt": 100}}
+        expected = [{"$match": {"item.price.value": {"$gt": 100}}}]
         self.assertOptimizerEqual(expr, expected)
-
-    def test_getfield_with_non_constant_field(self):
-        expr = {"$expr": {"$gt": [{"$getField": {"input": "$price", "field": "$field_name"}}, 100]}}
-        self.assertOptimizerEqual(expr, expr)
-
-    def test_getfield_with_object_non_simple_input(self):
-        expr = {
-            "$expr": {
-                "$gt": [
-                    {
-                        "$getField": {
-                            "input": {"$literal": "$item"},
-                            "field": "price",
-                        }
-                    },
-                    100,
-                ]
-            }
-        }
-        self.assertOptimizerEqual(expr, expr)

tests/expression_converter_/test_op_expressions.py

@@ -33,13 +33,13 @@ def _test_conversion_various_types(self, conversion_test):
             with self.subTest(_type=_type, val=val):
                 conversion_test(val)
 
-    def _test_conversion_getfield(self, logical_op):
-        expr = {logical_op: [{"$getField": {"input": "$item", "field": "age"}}, 10]}
+    def _test_conversion_getfield(self, logical_op, value=10):
+        expr = {logical_op: [{"$getField": {"input": "$item", "field": "age"}}, value]}
         self.assertConversionEqual(
-            expr, {"item.age": 10} if logical_op == "eq" else {"item.age": {logical_op: 10}}
+            expr, {"item.age": value} if logical_op == "$eq" else {"item.age": {logical_op: value}}
         )
 
-    def _test_conversion_nested_getfield(self, logical_op):
+    def _test_conversion_nested_getfield(self, logical_op, value=10):
         expr = {
             logical_op: [
                 {
@@ -48,14 +48,14 @@ def _test_conversion_nested_getfield(self, logical_op):
                         "field": "age",
                     }
                 },
-                10,
+                value,
             ]
         }
         self.assertConversionEqual(
             expr,
-            {"item.shel_life.age": 10}
-            if logical_op == "eq"
-            else {"item.shelf_life.age": {logical_op: 10}},
+            {"item.shelf_life.age": value}
+            if logical_op == "$eq"
+            else {"item.shelf_life.age": {logical_op: value}},
         )
 
     def _test_conversion_dual_getfield_ineligible(self, logical_op):
@@ -75,7 +75,9 @@ def _test_conversion_dual_getfield_ineligible(self, logical_op):
                 },
             ]
         }
-        self.assertNotOptimizable(expr)
+        # Not optimized but should still convert getFields
+        expected = {logical_op: ["$root.age", "$value.age"]}
+        self.assertConversionEqual(expr, expected)
 
 
 class ExpressionTests(ConversionTestCase):
@@ -139,10 +141,10 @@ def test_conversion_various_types(self):
                 self._test_conversion_valid_type(val)
 
     def test_conversion_getfield(self):
-        self._test_conversion_getfield("$in")
+        self._test_conversion_getfield("$in", [10])
 
     def test_conversion_nested_getfield(self):
-        self._test_conversion_nested_getfield("$in")
+        self._test_conversion_nested_getfield("$in", [10])
 
     def test_conversion_dual_getfield_ineligible(self):
         expr = {
@@ -163,7 +165,9 @@ def test_conversion_dual_getfield_ineligible(self):
                 ],
             ]
         }
-        self.assertNotOptimizable(expr)
+        # Not optimized but should still convert getFields
+        expected = {"$in": ["$root.age", ["$value.age"]]}
+        self.assertConversionEqual(expr, expected)
 
 
 class LogicalTests(ConversionTestCase):