Unit test reworked.

Author: WaVEV

tests/model_fields_/models.py

@@ -167,8 +167,9 @@ def __str__(self):
         return self.title
 
 
+# A review entry for a section in the museum.
 class Audit(models.Model):
-    related_section_number = models.IntegerField()
+    section_number = models.IntegerField()
     reviewed = models.BooleanField()
 
 

tests/model_fields_/test_embedded_model_array.py

@@ -2,10 +2,11 @@
 
 from django.core.exceptions import FieldDoesNotExist
 from django.db import connection, models
+from django.db.models.expressions import Value
 from django.test import SimpleTestCase, TestCase
 from django.test.utils import CaptureQueriesContext, isolate_apps
 
-from django_mongodb_backend.fields import EmbeddedModelArrayField
+from django_mongodb_backend.fields import ArrayField, EmbeddedModelArrayField
 from django_mongodb_backend.models import EmbeddedModel
 
 from .models import Artifact, Audit, Exhibit, Movie, Restoration, Review, Section, Tour
@@ -147,9 +148,9 @@ def setUpTestData(cls):
         cls.egypt_tour = Tour.objects.create(guide="Amira", exhibit=cls.egypt)
         cls.wonders_tour = Tour.objects.create(guide="Carlos", exhibit=cls.wonders)
         cls.lost_tour = Tour.objects.create(guide="Yelena", exhibit=cls.lost_empires)
-        cls.audit_1 = Audit.objects.create(related_section_number=1, reviewed=True)
-        cls.audit_2 = Audit.objects.create(related_section_number=2, reviewed=True)
-        cls.audit_3 = Audit.objects.create(related_section_number=5, reviewed=False)
+        cls.audit_1 = Audit.objects.create(section_number=1, reviewed=True)
+        cls.audit_2 = Audit.objects.create(section_number=2, reviewed=True)
+        cls.audit_3 = Audit.objects.create(section_number=5, reviewed=False)
 
     def test_exact(self):
         self.assertCountEqual(
@@ -288,34 +289,60 @@ def test_foreign_field_with_slice(self):
         qs = Tour.objects.filter(exhibit__sections__0_2__section_number__in=[1, 2])
         self.assertCountEqual(qs, [self.wonders_tour, self.egypt_tour])
 
-    def test_subquery_section_number_lt(self):
+    def test_subquery_numeric_lookups(self):
         subq = Audit.objects.filter(
-            related_section_number__in=models.OuterRef("sections__section_number")
-        ).values("related_section_number")[:1]
-        self.assertCountEqual(
-            Exhibit.objects.filter(sections__section_number=subq),
-            [self.egypt, self.wonders, self.new_descoveries],
-        )
+            section_number__in=models.OuterRef("sections__section_number")
+        ).values("section_number")[:1]
+        lookups_expected_value = [
+            ("exact", [self.egypt, self.new_descoveries, self.wonders]),
+            ("lt", []),
+            ("lte", [self.egypt, self.new_descoveries, self.wonders]),
+            ("gt", [self.wonders]),
+            ("gte", [self.egypt, self.new_descoveries, self.wonders]),
+        ]
+        for lookup, expected_value in lookups_expected_value:
+            with self.subTest(key=lookup):
+                kwargs = {f"sections__section_number__{lookup}": subq}
+                self.assertCountEqual(Exhibit.objects.filter(**kwargs), expected_value)
 
-    def test_check_in_subquery(self):
-        subquery = Audit.objects.filter(reviewed=True).values_list(
-            "related_section_number", flat=True
-        )
+    def test_in_subquery(self):
+        subquery = Audit.objects.filter(reviewed=True).values_list("section_number", flat=True)
         result = Exhibit.objects.filter(sections__section_number__in=subquery)
-        self.assertCountEqual(result, [self.wonders, self.egypt, self.new_descoveries])
+        self.assertCountEqual(result, [self.wonders, self.new_descoveries, self.egypt])
 
     def test_array_as_rhs(self):
         result = Exhibit.objects.filter(
             main_section__section_number__in=models.F("sections__section_number")
         )
         self.assertCountEqual(result, [self.new_descoveries])
 
-    def test_array_annotation_as_rhs(self):
+    def test_array_annotation_lookup(self):
         result = Exhibit.objects.annotate(
             section_numbers=models.F("main_section__section_number")
         ).filter(section_numbers__in=models.F("sections__section_number"))
         self.assertCountEqual(result, [self.new_descoveries])
 
+    def test_arrayfield_annotation_lookups(self):
+        lookup_expected_value = [
+            ("exact", [self.wonders]),
+            ("lt", [self.new_descoveries]),
+            ("lte", [self.wonders, self.new_descoveries]),
+            ("gt", [self.egypt, self.lost_empires]),
+            ("gte", [self.egypt, self.wonders, self.lost_empires]),
+            ("overlap", [self.egypt, self.wonders, self.new_descoveries]),
+            ("contained_by", [self.wonders]),
+            ("contains", [self.egypt, self.wonders, self.new_descoveries, self.lost_empires]),
+        ]
+        for lookup, expected in lookup_expected_value:
+            with self.subTest(key=lookup):
+                kwargs = {f"section_numbers__{lookup}": models.F("sections__section_number")}
+                result = Exhibit.objects.annotate(
+                    section_numbers=Value(
+                        [1, 2], output_field=ArrayField(base_field=models.IntegerField())
+                    )
+                ).filter(**kwargs)
+                self.assertCountEqual(result, expected)
+
     def test_array_annotation_index(self):
         # This test would be useful to have, but it cannot be implemented
         # due to the current annotation handling.
@@ -327,9 +354,7 @@ def test_array_annotation_index(self):
         self.assertCountEqual(result, [self.new_descoveries, self.egypt])
 
     def test_array_annotation(self):
-        results = Exhibit.objects.annotate(
-            section_numbers=models.F("sections__section_number")
-        ).all()
+        results = Exhibit.objects.annotate(section_numbers=models.F("sections__section_number"))
         sections_numbers = [e.section_numbers for e in results]
         self.assertCountEqual(sections_numbers, [[1], [1, 2], [2], []])