edits

Author: WaVEV

tests/model_fields_/test_embedded_model.py

@@ -23,6 +23,11 @@
 )
 
 
+def truncate_ms(value):
+    """Truncate microsends to millisecond precision as supported by MongoDB."""
+    return value.replace(microsecond=(value.microsecond // 1000) * 1000)
+
+
 class MethodTests(SimpleTestCase):
     def test_deconstruct(self):
         field = EmbeddedModelField("Data", null=True)
@@ -46,10 +51,6 @@ def test_validate(self):
 
 
 class ModelTests(TestCase):
-    def truncate_ms(self, value):
-        """Truncate microseconds to milliseconds as supported by MongoDB."""
-        return value.replace(microsecond=(value.microsecond // 1000) * 1000)
-
     def test_save_load(self):
         Holder.objects.create(data=Data(integer="5"))
         obj = Holder.objects.get()
@@ -72,12 +73,12 @@ def test_save_load_null(self):
     def test_pre_save(self):
         """Field.pre_save() is called on embedded model fields."""
         obj = Holder.objects.create(data=Data())
-        auto_now = self.truncate_ms(obj.data.auto_now)
-        auto_now_add = self.truncate_ms(obj.data.auto_now_add)
+        auto_now = truncate_ms(obj.data.auto_now)
+        auto_now_add = truncate_ms(obj.data.auto_now_add)
         self.assertEqual(auto_now, auto_now_add)
         # save() updates auto_now but not auto_now_add.
         obj.save()
-        self.assertEqual(self.truncate_ms(obj.data.auto_now_add), auto_now_add)
+        self.assertEqual(truncate_ms(obj.data.auto_now_add), auto_now_add)
         auto_now_two = obj.data.auto_now
         self.assertGreater(auto_now_two, obj.data.auto_now_add)
         # And again, save() updates auto_now but not auto_now_add.
@@ -107,52 +108,54 @@ def test_gt(self):
     def test_gte(self):
         self.assertCountEqual(Holder.objects.filter(data__integer__gte=3), self.objs[3:])
 
-    def test_nested(self):
-        obj = Book.objects.create(
-            author=Author(name="Shakespeare", age=55, address=Address(city="NYC", state="NY"))
-        )
-        self.assertCountEqual(Book.objects.filter(author__address__city="NYC"), [obj])
-
-    def truncate_ms(self, value):
-        """Truncate microsends to millisecond precision as supported by MongoDB."""
-        return value.replace(microsecond=(value.microsecond // 1000) * 1000)
-
     def test_ordering_by_embedded_field(self):
         query = Holder.objects.filter(data__integer__gt=3).order_by("-data__integer").values("pk")
         expected = [{"pk": e.pk} for e in list(reversed(self.objs[4:]))]
         self.assertSequenceEqual(query, expected)
 
     def test_ordering_grouping_by_embedded_field(self):
-        expected = sorted(
+        # Create and sort test data by `data__integer`
+        expected_obj = sorted(
             (Holder.objects.create(data=Data(integer=x)) for x in range(6)),
             key=lambda x: x.data.integer,
         )
-        query = (
+        # Group by `data__integer + 5` and get the latest `data__auto_now` timestamp
+        qs = (
             Holder.objects.annotate(
                 group=ExpressionWrapper(F("data__integer") + 5, output_field=IntegerField())
             )
             .values("group")
             .annotate(max_auto_now=Max("data__auto_now"))
             .order_by("data__integer")
         )
-        query_response = [{**e, "max_auto_now": self.truncate_ms(e["max_auto_now"])} for e in query]
+        response = [{**e, "max_auto_now": e["max_auto_now"]} for e in qs]
+        # Validate that each unique `data__integer` is correctly grouped and annotated
         self.assertSequenceEqual(
-            query_response,
+            response,
             [
-                {"group": e.data.integer + 5, "max_auto_now": self.truncate_ms(e.data.auto_now)}
-                for e in expected
+                {"group": e.data.integer + 5, "max_auto_now": truncate_ms(e.data.auto_now)}
+                for e in expected_obj
             ],
         )
 
     def test_ordering_grouping_by_sum(self):
+        # Create test data with repeated `data__integer` values
         [Holder.objects.create(data=Data(integer=x)) for x in range(6)]
+        # Group by `data__integer` and compute the sum of occurrences
         qs = (
             Holder.objects.values("data__integer")
             .annotate(sum=Sum("data__integer"))
             .order_by("sum")
         )
+        # The sum should be twice the integer values (since each appears twice)
         self.assertQuerySetEqual(qs, [0, 2, 4, 6, 8, 10], operator.itemgetter("sum"))
 
+    def test_nested(self):
+        obj = Book.objects.create(
+            author=Author(name="Shakespeare", age=55, address=Address(city="NYC", state="NY"))
+        )
+        self.assertCountEqual(Book.objects.filter(author__address__city="NYC"), [obj])
+
 
 @isolate_apps("model_fields_")
 class CheckTests(SimpleTestCase):