Fixed #27203 -- Replaced assertQuerysetEqual(..., lambda o: o) with assertSequenceEqual().

1 files changed, 38 insertions, 112 deletions

diff --git a/tests/custom_lookups/tests.py b/tests/custom_lookups/tests.py
index da9274904c..8ae94dda26 100644
--- a/tests/custom_lookups/tests.py
+++ b/tests/custom_lookups/tests.py
@@ -234,8 +234,8 @@ class LookupTests(TestCase):
             YearTransform.register_lookup(Exactly, custom_lookup_name)
             qs1 = Author.objects.filter(birthdate__testyear__exactly=1981)
             qs2 = Author.objects.filter(birthdate__justtheyear__isactually=1981)
-            self.assertQuerysetEqual(qs1, [a1], lambda x: x)
-            self.assertQuerysetEqual(qs2, [a1], lambda x: x)
+            self.assertSequenceEqual(qs1, [a1])
+            self.assertSequenceEqual(qs2, [a1])
         finally:
             YearTransform._unregister_lookup(Exactly)
             YearTransform._unregister_lookup(Exactly, custom_lookup_name)
@@ -248,22 +248,10 @@ class LookupTests(TestCase):
         a3 = Author.objects.create(name='a3', age=3)
         a4 = Author.objects.create(name='a4', age=4)
         with register_lookup(models.IntegerField, Div3Lookup):
-            self.assertQuerysetEqual(
-                Author.objects.filter(age__div3=0),
-                [a3], lambda x: x
-            )
-            self.assertQuerysetEqual(
-                Author.objects.filter(age__div3=1).order_by('age'),
-                [a1, a4], lambda x: x
-            )
-            self.assertQuerysetEqual(
-                Author.objects.filter(age__div3=2),
-                [a2], lambda x: x
-            )
-            self.assertQuerysetEqual(
-                Author.objects.filter(age__div3=3),
-                [], lambda x: x
-            )
+            self.assertSequenceEqual(Author.objects.filter(age__div3=0), [a3])
+            self.assertSequenceEqual(Author.objects.filter(age__div3=1).order_by('age'), [a1, a4])
+            self.assertSequenceEqual(Author.objects.filter(age__div3=2), [a2])
+            self.assertSequenceEqual(Author.objects.filter(age__div3=3), [])
 
     @unittest.skipUnless(connection.vendor == 'postgresql', "PostgreSQL specific SQL used")
     def test_birthdate_month(self):
@@ -272,26 +260,11 @@ class LookupTests(TestCase):
         a3 = Author.objects.create(name='a3', birthdate=date(2012, 1, 31))
         a4 = Author.objects.create(name='a4', birthdate=date(2012, 3, 1))
         with register_lookup(models.DateField, InMonth):
-            self.assertQuerysetEqual(
-                Author.objects.filter(birthdate__inmonth=date(2012, 1, 15)),
-                [a3], lambda x: x
-            )
-            self.assertQuerysetEqual(
-                Author.objects.filter(birthdate__inmonth=date(2012, 2, 1)),
-                [a2], lambda x: x
-            )
-            self.assertQuerysetEqual(
-                Author.objects.filter(birthdate__inmonth=date(1981, 2, 28)),
-                [a1], lambda x: x
-            )
-            self.assertQuerysetEqual(
-                Author.objects.filter(birthdate__inmonth=date(2012, 3, 12)),
-                [a4], lambda x: x
-            )
-            self.assertQuerysetEqual(
-                Author.objects.filter(birthdate__inmonth=date(2012, 4, 1)),
-                [], lambda x: x
-            )
+            self.assertSequenceEqual(Author.objects.filter(birthdate__inmonth=date(2012, 1, 15)), [a3])
+            self.assertSequenceEqual(Author.objects.filter(birthdate__inmonth=date(2012, 2, 1)), [a2])
+            self.assertSequenceEqual(Author.objects.filter(birthdate__inmonth=date(1981, 2, 28)), [a1])
+            self.assertSequenceEqual(Author.objects.filter(birthdate__inmonth=date(2012, 3, 12)), [a4])
+            self.assertSequenceEqual(Author.objects.filter(birthdate__inmonth=date(2012, 4, 1)), [])
 
     def test_div3_extract(self):
         with register_lookup(models.IntegerField, Div3Transform):
@@ -300,24 +273,12 @@ class LookupTests(TestCase):
             a3 = Author.objects.create(name='a3', age=3)
             a4 = Author.objects.create(name='a4', age=4)
             baseqs = Author.objects.order_by('name')
-            self.assertQuerysetEqual(
-                baseqs.filter(age__div3=2),
-                [a2], lambda x: x)
-            self.assertQuerysetEqual(
-                baseqs.filter(age__div3__lte=3),
-                [a1, a2, a3, a4], lambda x: x)
-            self.assertQuerysetEqual(
-                baseqs.filter(age__div3__in=[0, 2]),
-                [a2, a3], lambda x: x)
-            self.assertQuerysetEqual(
-                baseqs.filter(age__div3__in=[2, 4]),
-                [a2], lambda x: x)
-            self.assertQuerysetEqual(
-                baseqs.filter(age__div3__gte=3),
-                [], lambda x: x)
-            self.assertQuerysetEqual(
-                baseqs.filter(age__div3__range=(1, 2)),
-                [a1, a2, a4], lambda x: x)
+            self.assertSequenceEqual(baseqs.filter(age__div3=2), [a2])
+            self.assertSequenceEqual(baseqs.filter(age__div3__lte=3), [a1, a2, a3, a4])
+            self.assertSequenceEqual(baseqs.filter(age__div3__in=[0, 2]), [a2, a3])
+            self.assertSequenceEqual(baseqs.filter(age__div3__in=[2, 4]), [a2])
+            self.assertSequenceEqual(baseqs.filter(age__div3__gte=3), [])
+            self.assertSequenceEqual(baseqs.filter(age__div3__range=(1, 2)), [a1, a2, a4])
 
     def test_foreignobject_lookup_registration(self):
         field = Article._meta.get_field('author')
@@ -383,24 +344,12 @@ class BilateralTransformTests(TestCase):
             a3 = Author.objects.create(name='a3', age=3)
             a4 = Author.objects.create(name='a4', age=4)
             baseqs = Author.objects.order_by('name')
-            self.assertQuerysetEqual(
-                baseqs.filter(age__div3=2),
-                [a2], lambda x: x)
-            self.assertQuerysetEqual(
-                baseqs.filter(age__div3__lte=3),
-                [a3], lambda x: x)
-            self.assertQuerysetEqual(
-                baseqs.filter(age__div3__in=[0, 2]),
-                [a2, a3], lambda x: x)
-            self.assertQuerysetEqual(
-                baseqs.filter(age__div3__in=[2, 4]),
-                [a1, a2, a4], lambda x: x)
-            self.assertQuerysetEqual(
-                baseqs.filter(age__div3__gte=3),
-                [a1, a2, a3, a4], lambda x: x)
-            self.assertQuerysetEqual(
-                baseqs.filter(age__div3__range=(1, 2)),
-                [a1, a2, a4], lambda x: x)
+            self.assertSequenceEqual(baseqs.filter(age__div3=2), [a2])
+            self.assertSequenceEqual(baseqs.filter(age__div3__lte=3), [a3])
+            self.assertSequenceEqual(baseqs.filter(age__div3__in=[0, 2]), [a2, a3])
+            self.assertSequenceEqual(baseqs.filter(age__div3__in=[2, 4]), [a1, a2, a4])
+            self.assertSequenceEqual(baseqs.filter(age__div3__gte=3), [a1, a2, a3, a4])
+            self.assertSequenceEqual(baseqs.filter(age__div3__range=(1, 2)), [a1, a2, a4])
 
     def test_bilateral_order(self):
         with register_lookup(models.IntegerField, Mult3BilateralTransform, Div3BilateralTransform):
@@ -410,13 +359,9 @@ class BilateralTransformTests(TestCase):
             a4 = Author.objects.create(name='a4', age=4)
             baseqs = Author.objects.order_by('name')
 
-            self.assertQuerysetEqual(
-                baseqs.filter(age__mult3__div3=42),
-                # mult3__div3 always leads to 0
-                [a1, a2, a3, a4], lambda x: x)
-            self.assertQuerysetEqual(
-                baseqs.filter(age__div3__mult3=42),
-                [a3], lambda x: x)
+            # mult3__div3 always leads to 0
+            self.assertSequenceEqual(baseqs.filter(age__mult3__div3=42), [a1, a2, a3, a4])
+            self.assertSequenceEqual(baseqs.filter(age__div3__mult3=42), [a3])
 
     def test_bilateral_fexpr(self):
         with register_lookup(models.IntegerField, Mult3BilateralTransform):
@@ -425,13 +370,9 @@ class BilateralTransformTests(TestCase):
             a3 = Author.objects.create(name='a3', age=3, average_rating=1.5)
             a4 = Author.objects.create(name='a4', age=4)
             baseqs = Author.objects.order_by('name')
-            self.assertQuerysetEqual(
-                baseqs.filter(age__mult3=models.F('age')),
-                [a1, a2, a3, a4], lambda x: x)
-            self.assertQuerysetEqual(
-                # Same as age >= average_rating
-                baseqs.filter(age__mult3__gte=models.F('average_rating')),
-                [a2, a3], lambda x: x)
+            self.assertSequenceEqual(baseqs.filter(age__mult3=models.F('age')), [a1, a2, a3, a4])
+            # Same as age >= average_rating
+            self.assertSequenceEqual(baseqs.filter(age__mult3__gte=models.F('average_rating')), [a2, a3])
 
 
 @override_settings(USE_TZ=True)
@@ -441,9 +382,7 @@ class DateTimeLookupTests(TestCase):
         with register_lookup(models.PositiveIntegerField, DateTimeTransform):
             ut = MySQLUnixTimestamp.objects.create(timestamp=time.time())
             y2k = timezone.make_aware(datetime(2000, 1, 1))
-            self.assertQuerysetEqual(
-                MySQLUnixTimestamp.objects.filter(timestamp__as_datetime__gt=y2k),
-                [ut], lambda x: x)
+            self.assertSequenceEqual(MySQLUnixTimestamp.objects.filter(timestamp__as_datetime__gt=y2k), [ut])
 
 
 class YearLteTests(TestCase):
@@ -460,21 +399,13 @@ class YearLteTests(TestCase):
     @unittest.skipUnless(connection.vendor == 'postgresql', "PostgreSQL specific SQL used")
     def test_year_lte(self):
         baseqs = Author.objects.order_by('name')
-        self.assertQuerysetEqual(
-            baseqs.filter(birthdate__testyear__lte=2012),
-            [self.a1, self.a2, self.a3, self.a4], lambda x: x)
-        self.assertQuerysetEqual(
-            baseqs.filter(birthdate__testyear=2012),
-            [self.a2, self.a3, self.a4], lambda x: x)
+        self.assertSequenceEqual(baseqs.filter(birthdate__testyear__lte=2012), [self.a1, self.a2, self.a3, self.a4])
+        self.assertSequenceEqual(baseqs.filter(birthdate__testyear=2012), [self.a2, self.a3, self.a4])
 
         self.assertNotIn('BETWEEN', str(baseqs.filter(birthdate__testyear=2012).query))
-        self.assertQuerysetEqual(
-            baseqs.filter(birthdate__testyear__lte=2011),
-            [self.a1], lambda x: x)
+        self.assertSequenceEqual(baseqs.filter(birthdate__testyear__lte=2011), [self.a1])
         # The non-optimized version works, too.
-        self.assertQuerysetEqual(
-            baseqs.filter(birthdate__testyear__lt=2012),
-            [self.a1], lambda x: x)
+        self.assertSequenceEqual(baseqs.filter(birthdate__testyear__lt=2012), [self.a1])
 
     @unittest.skipUnless(connection.vendor == 'postgresql', "PostgreSQL specific SQL used")
     def test_year_lte_fexpr(self):
@@ -485,12 +416,8 @@ class YearLteTests(TestCase):
         self.a4.age = 2013
         self.a4.save()
         baseqs = Author.objects.order_by('name')
-        self.assertQuerysetEqual(
-            baseqs.filter(birthdate__testyear__lte=models.F('age')),
-            [self.a3, self.a4], lambda x: x)
-        self.assertQuerysetEqual(
-            baseqs.filter(birthdate__testyear__lt=models.F('age')),
-            [self.a4], lambda x: x)
+        self.assertSequenceEqual(baseqs.filter(birthdate__testyear__lte=models.F('age')), [self.a3, self.a4])
+        self.assertSequenceEqual(baseqs.filter(birthdate__testyear__lt=models.F('age')), [self.a4])
 
     def test_year_lte_sql(self):
         # This test will just check the generated SQL for __lte. This
@@ -624,6 +551,5 @@ class SubqueryTransformTests(TestCase):
             a2 = Author.objects.create(name='a2', age=2)
             Author.objects.create(name='a3', age=3)
             Author.objects.create(name='a4', age=4)
-            self.assertQuerysetEqual(
-                Author.objects.order_by('name').filter(id__in=Author.objects.filter(age__div3=2)),
-                [a2], lambda x: x)
+            qs = Author.objects.order_by('name').filter(id__in=Author.objects.filter(age__div3=2))
+            self.assertSequenceEqual(qs, [a2])