migrated tests to lookup_ and added data

Author: Jibola

tests/expression_converter_/models.py

@@ -17,3 +17,10 @@ class Meta:
 
     def __str__(self):
         return str(self.num)
+
+
+class NullableJSONModel(models.Model):
+    value = models.JSONField(blank=True, null=True)
+
+    class Meta:
+        required_db_features = {"supports_json_field"}

tests/expression_converter_/test_filter_conversion.py

@@ -1,8 +1,10 @@
+from bson import ObjectId
+from django.db import connection
 from django.test import TestCase
 
 from django_mongodb_backend.test import MongoTestCaseMixin
 
-from .models import Book, Number
+from .models import Book, NullableJSONModel, Number
 
 
 class NumericLookupTests(TestCase):
@@ -66,3 +68,70 @@ def test_eq_and_in(self):
             "lookup__book",
             [{"$match": {"$and": [{"isbn": {"$in": ("12345", "56789")}}, {"title": "Moby Dick"}]}}],
         )
+
+
+class NullValueLookupTests(MongoTestCaseMixin, TestCase):
+    _OPERATOR_PREDICATE_MAP = {
+        "eq": lambda field: {field: None},
+        "in": lambda field: {field: {"$in": [None]}},
+    }
+
+    @classmethod
+    def setUpTestData(cls):
+        cls.book_objs = Book.objects.bulk_create(
+            Book(title=f"Book {i}", isbn=str(i)) for i in range(5)
+        )
+
+        cls.null_objs = NullableJSONModel.objects.bulk_create(NullableJSONModel() for _ in range(5))
+        cls.null_objs.append(NullableJSONModel.objects.create(value={"name": None}))
+        cls.unique_id = ObjectId()
+
+    def _test_none_filter_nullable_json(self, op, predicate, field):
+        with self.assertNumQueries(1) as ctx:
+            list(NullableJSONModel.objects.filter(**{f"{field}__{op}": None}))
+        self.assertAggregateQuery(
+            ctx.captured_queries[0]["sql"],
+            "lookup__nullablejsonmodel",
+            [{"$match": {"$and": [{"$exists": False}, predicate(field)]}}],
+        )
+        self.assertQuerySetEqual(
+            NullableJSONModel.objects.filter(**{f"{field}__{op}": None}),
+            [],
+        )
+
+    def _test_none_filter_binary_operator(self, op, predicate, field):
+        with self.assertNumQueries(1) as ctx:
+            list(Book.objects.filter(**{f"{field}__{op}": None}))
+        self.assertAggregateQuery(
+            ctx.captured_queries[0]["sql"],
+            "lookup__book",
+            [
+                {
+                    "$match": {
+                        "$or": [
+                            {"$and": [{field: {"$exists": True}}, predicate(field)]},
+                            {"$expr": {"$eq": [{"$type": f"${field}"}, "missing"]}},
+                        ]
+                    }
+                }
+            ],
+        )
+        self.assertQuerySetEqual(Book.objects.filter(**{f"{field}__{op}": None}), [])
+
+    def _test_with_raw_data(self, model, test_function):
+        collection = connection.database.get_collection(model._meta.db_table)
+        try:
+            collection.insert_one({"_id": self.unique_id})
+
+            for op, predicate in self._OPERATOR_PREDICATE_MAP.items():
+                with self.subTest(op=op):
+                    test_function(op, predicate)
+
+        finally:
+            collection.delete_one({"_id": self.unique_id})
+
+    def test_none_filter_nullable_json(self):
+        self._test_with_raw_data(NullableJSONModel, self._test_none_filter_nullable_json)
+
+    def test_none_filter_binary_operator(self):
+        self._test_with_raw_data(Book, self._test_none_filter_binary_operator)