Fix failing tests with django/master

Several tests were failing with django master. This is because,
apparently, IDs don't match those expected in tests, and other
test-related details.

Replace all test comparisons with assertQuerysetEqual, which is safer
and cleaner for the sort of comparison we're doing.

Author: Hugo Osvaldo Barrera

polymorphic/tests/test_orm.py

@@ -2,14 +2,14 @@
 
 import django
 from django.db.models import Case, Count, Q, When
-from django.test import TestCase
+from django.test import TestCase, TransactionTestCase
 from django.utils import six
 
 from polymorphic.models import PolymorphicTypeUndefined
 from polymorphic.tests import *  # all models
 
 
-class PolymorphicTests(TestCase):
+class PolymorphicTests(TransactionTestCase):
     """
     The test suite
     """
@@ -129,19 +129,23 @@ def create_model2abcd(self):
         Create the chain of objects of Model2,
         this is reused in various tests.
         """
-        Model2A.objects.create(field1='A1')
-        Model2B.objects.create(field1='B1', field2='B2')
-        Model2C.objects.create(field1='C1', field2='C2', field3='C3')
-        Model2D.objects.create(field1='D1', field2='D2', field3='D3', field4='D4')
+        a = Model2A.objects.create(field1='A1')
+        b = Model2B.objects.create(field1='B1', field2='B2')
+        c = Model2C.objects.create(field1='C1', field2='C2', field3='C3')
+        d = Model2D.objects.create(field1='D1', field2='D2', field3='D3', field4='D4')
+
+        return a, b, c, d
 
     def test_simple_inheritance(self):
         self.create_model2abcd()
 
-        objects = list(Model2A.objects.all())
-        self.assertEqual(repr(objects[0]), '<Model2A: id 1, field1 (CharField)>')
-        self.assertEqual(repr(objects[1]), '<Model2B: id 2, field1 (CharField), field2 (CharField)>')
-        self.assertEqual(repr(objects[2]), '<Model2C: id 3, field1 (CharField), field2 (CharField), field3 (CharField)>')
-        self.assertEqual(repr(objects[3]), '<Model2D: id 4, field1 (CharField), field2 (CharField), field3 (CharField), field4 (CharField)>')
+        objects = Model2A.objects.all()
+        self.assertQuerysetEqual(
+            objects,
+            [Model2A, Model2B, Model2C, Model2D],
+            transform=lambda o: o.__class__,
+            ordered=False,
+        )
 
     def test_defer_fields(self):
         self.create_model2abcd()
@@ -184,69 +188,68 @@ def test_defer_related_fields(self):
         objects_deferred_field4 = Model2A.objects.defer('Model2D___field4')
         self.assertNotIn('field4', objects_deferred_field4[3].__dict__,
                          'field4 was not deferred (using defer(), traversing inheritance)')
-        self.assertEqual(repr(objects_deferred_field4[0]),
-                         '<Model2A: id 1, field1 (CharField)>')
-        self.assertEqual(repr(objects_deferred_field4[1]),
-                         '<Model2B: id 2, field1 (CharField), field2 (CharField)>')
-        self.assertEqual(repr(objects_deferred_field4[2]),
-                         '<Model2C: id 3, field1 (CharField), field2 (CharField), field3 (CharField)>')
-        self.assertEqual(repr(objects_deferred_field4[3]),
-                         '<Model2D: id 4, field1 (CharField), field2 (CharField), field3 (CharField), field4 (CharField), deferred[field4]>')
+        self.assertEqual(objects_deferred_field4[0].__class__, Model2A)
+        self.assertEqual(objects_deferred_field4[1].__class__, Model2B)
+        self.assertEqual(objects_deferred_field4[2].__class__, Model2C)
+        self.assertEqual(objects_deferred_field4[3].__class__, Model2D)
 
         objects_only_field4 = Model2A.objects.only(
             'polymorphic_ctype', 'field1',
             'Model2B___id', 'Model2B___field2', 'Model2B___model2a_ptr',
             'Model2C___id', 'Model2C___field3', 'Model2C___model2b_ptr',
             'Model2D___id', 'Model2D___model2c_ptr')
-        self.assertEqual(repr(objects_only_field4[0]),
-                         '<Model2A: id 1, field1 (CharField)>')
-        self.assertEqual(repr(objects_only_field4[1]),
-                         '<Model2B: id 2, field1 (CharField), field2 (CharField)>')
-        self.assertEqual(repr(objects_only_field4[2]),
-                         '<Model2C: id 3, field1 (CharField), field2 (CharField), field3 (CharField)>')
-        self.assertEqual(repr(objects_only_field4[3]),
-                         '<Model2D: id 4, field1 (CharField), field2 (CharField), field3 (CharField), field4 (CharField), deferred[field4]>')
+        self.assertEqual(objects_only_field4[0].__class__, Model2A)
+        self.assertEqual(objects_only_field4[1].__class__, Model2B)
+        self.assertEqual(objects_only_field4[2].__class__, Model2C)
+        self.assertEqual(objects_only_field4[3].__class__, Model2D)
 
     def test_manual_get_real_instance(self):
         self.create_model2abcd()
 
         o = Model2A.objects.non_polymorphic().get(field1='C1')
-        self.assertEqual(repr(o.get_real_instance()), '<Model2C: id 3, field1 (CharField), field2 (CharField), field3 (CharField)>')
+        self.assertEqual(o.get_real_instance().__class__, Model2C)
 
     def test_non_polymorphic(self):
         self.create_model2abcd()
 
         objects = list(Model2A.objects.all().non_polymorphic())
-        self.assertEqual(repr(objects[0]), '<Model2A: id 1, field1 (CharField)>')
-        self.assertEqual(repr(objects[1]), '<Model2A: id 2, field1 (CharField)>')
-        self.assertEqual(repr(objects[2]), '<Model2A: id 3, field1 (CharField)>')
-        self.assertEqual(repr(objects[3]), '<Model2A: id 4, field1 (CharField)>')
+        self.assertQuerysetEqual(
+            objects,
+            [Model2A, Model2A, Model2A, Model2A],
+            transform=lambda o: o.__class__,
+        )
 
     def test_get_real_instances(self):
         self.create_model2abcd()
         qs = Model2A.objects.all().non_polymorphic()
 
         # from queryset
         objects = qs.get_real_instances()
-        self.assertEqual(repr(objects[0]), '<Model2A: id 1, field1 (CharField)>')
-        self.assertEqual(repr(objects[1]), '<Model2B: id 2, field1 (CharField), field2 (CharField)>')
-        self.assertEqual(repr(objects[2]), '<Model2C: id 3, field1 (CharField), field2 (CharField), field3 (CharField)>')
-        self.assertEqual(repr(objects[3]), '<Model2D: id 4, field1 (CharField), field2 (CharField), field3 (CharField), field4 (CharField)>')
+        self.assertQuerysetEqual(
+            objects,
+            [Model2A, Model2B, Model2C, Model2D],
+            transform=lambda o: o.__class__,
+        )
 
         # from a manual list
         objects = Model2A.objects.get_real_instances(list(qs))
-        self.assertEqual(repr(objects[0]), '<Model2A: id 1, field1 (CharField)>')
-        self.assertEqual(repr(objects[1]), '<Model2B: id 2, field1 (CharField), field2 (CharField)>')
-        self.assertEqual(repr(objects[2]), '<Model2C: id 3, field1 (CharField), field2 (CharField), field3 (CharField)>')
-        self.assertEqual(repr(objects[3]), '<Model2D: id 4, field1 (CharField), field2 (CharField), field3 (CharField), field4 (CharField)>')
+        self.assertQuerysetEqual(
+            objects,
+            [Model2A, Model2B, Model2C, Model2D],
+            transform=lambda o: o.__class__,
+        )
 
     def test_translate_polymorphic_q_object(self):
         self.create_model2abcd()
 
         q = Model2A.translate_polymorphic_Q_object(Q(instance_of=Model2C))
         objects = Model2A.objects.filter(q)
-        self.assertEqual(repr(objects[0]), '<Model2C: id 3, field1 (CharField), field2 (CharField), field3 (CharField)>')
-        self.assertEqual(repr(objects[1]), '<Model2D: id 4, field1 (CharField), field2 (CharField), field3 (CharField), field4 (CharField)>')
+        self.assertQuerysetEqual(
+            objects,
+            [Model2C, Model2D],
+            transform=lambda o: o.__class__,
+            ordered=False,
+        )
 
     def test_base_manager(self):
         def show_base_manager(model):
@@ -293,10 +296,10 @@ def test_foreignkey_field(self):
         self.create_model2abcd()
 
         object2a = Model2A.base_objects.get(field1='C1')
-        self.assertEqual(repr(object2a.model2b), '<Model2B: id 3, field1 (CharField), field2 (CharField)>')
+        self.assertEqual(object2a.model2b.__class__, Model2B)
 
         object2b = Model2B.base_objects.get(field1='C1')
-        self.assertEqual(repr(object2b.model2c), '<Model2C: id 3, field1 (CharField), field2 (CharField), field3 (CharField)>')
+        self.assertEqual(object2b.model2c.__class__, Model2C)
 
     def test_onetoone_field(self):
         self.create_model2abcd()
@@ -305,11 +308,15 @@ def test_onetoone_field(self):
         b = One2OneRelatingModelDerived.objects.create(one2one=a, field1='f1', field2='f2')
 
         # this result is basically wrong, probably due to Django cacheing (we used base_objects), but should not be a problem
-        self.assertEqual(repr(b.one2one), '<Model2A: id 3, field1 (CharField)>')
+        self.assertEqual(b.one2one.__class__, Model2A)
+        self.assertEqual(b.one2one_id, b.one2one.id)
 
         c = One2OneRelatingModelDerived.objects.get(field1='f1')
-        self.assertEqual(repr(c.one2one), '<Model2C: id 3, field1 (CharField), field2 (CharField), field3 (CharField)>')
-        self.assertEqual(repr(a.one2onerelatingmodel), '<One2OneRelatingModelDerived: One2OneRelatingModelDerived object>')
+        self.assertEqual(c.one2one.__class__, Model2C)
+        self.assertEqual(
+            a.one2onerelatingmodel.__class__,
+            One2OneRelatingModelDerived,
+        )
 
     def test_manytomany_field(self):
         # Model 1
@@ -336,19 +343,32 @@ def test_manytomany_field(self):
         # no pretty printing
         ModelShow1_plain.objects.create(field1='abc')
         ModelShow2_plain.objects.create(field1='abc', field2='def')
-        self.assertEqual(qrepr(ModelShow1_plain.objects.all()), '<PolymorphicQuerySet [<ModelShow1_plain: ModelShow1_plain object>, <ModelShow2_plain: ModelShow2_plain object>]>')
+        self.assertQuerysetEqual(
+            ModelShow1_plain.objects.all(),
+            [ModelShow1_plain, ModelShow2_plain],
+            transform=lambda o: o.__class__,
+            ordered=False,
+        )
 
     def test_extra_method(self):
-        self.create_model2abcd()
+        a, b, c, d = self.create_model2abcd()
 
-        objects = list(Model2A.objects.extra(where=['id IN (2, 3)']))
-        self.assertEqual(repr(objects[0]), '<Model2B: id 2, field1 (CharField), field2 (CharField)>')
-        self.assertEqual(repr(objects[1]), '<Model2C: id 3, field1 (CharField), field2 (CharField), field3 (CharField)>')
+        objects = Model2A.objects.extra(
+            where=['id IN ({}, {})'.format(b.id, c.id)]
+        )
+        self.assertQuerysetEqual(
+            objects,
+            [Model2B, Model2C],
+            transform=lambda o: o.__class__,
+            ordered=False,
+        )
 
         objects = Model2A.objects.extra(select={"select_test": "field1 = 'A1'"}, where=["field1 = 'A1' OR field1 = 'B1'"], order_by=['-id'])
-        self.assertEqual(repr(objects[0]), '<Model2B: id 2, field1 (CharField), field2 (CharField) - Extra: select_test (int)>')
-        self.assertEqual(repr(objects[1]), '<Model2A: id 1, field1 (CharField) - Extra: select_test (int)>')
-        self.assertEqual(len(objects), 2)   # Placed after the other tests, only verifying whether there are no more additional objects.
+        self.assertQuerysetEqual(
+            objects,
+            [Model2B, Model2A],
+            transform=lambda o: o.__class__,
+        )
 
         ModelExtraA.objects.create(field1='A1')
         ModelExtraB.objects.create(field1='B1', field2='B2')
@@ -371,34 +391,47 @@ def test_instance_of_filter(self):
         self.create_model2abcd()
 
         objects = Model2A.objects.instance_of(Model2B)
-        self.assertEqual(repr(objects[0]), '<Model2B: id 2, field1 (CharField), field2 (CharField)>')
-        self.assertEqual(repr(objects[1]), '<Model2C: id 3, field1 (CharField), field2 (CharField), field3 (CharField)>')
-        self.assertEqual(repr(objects[2]), '<Model2D: id 4, field1 (CharField), field2 (CharField), field3 (CharField), field4 (CharField)>')
-        self.assertEqual(len(objects), 3)
+        self.assertQuerysetEqual(
+            objects,
+            [Model2B, Model2C, Model2D],
+            transform=lambda o: o.__class__,
+            ordered=False,
+        )
 
         objects = Model2A.objects.filter(instance_of=Model2B)
-        self.assertEqual(repr(objects[0]), '<Model2B: id 2, field1 (CharField), field2 (CharField)>')
-        self.assertEqual(repr(objects[1]), '<Model2C: id 3, field1 (CharField), field2 (CharField), field3 (CharField)>')
-        self.assertEqual(repr(objects[2]), '<Model2D: id 4, field1 (CharField), field2 (CharField), field3 (CharField), field4 (CharField)>')
-        self.assertEqual(len(objects), 3)
+        self.assertQuerysetEqual(
+            objects,
+            [Model2B, Model2C, Model2D],
+            transform=lambda o: o.__class__,
+            ordered=False,
+        )
 
         objects = Model2A.objects.filter(Q(instance_of=Model2B))
-        self.assertEqual(repr(objects[0]), '<Model2B: id 2, field1 (CharField), field2 (CharField)>')
-        self.assertEqual(repr(objects[1]), '<Model2C: id 3, field1 (CharField), field2 (CharField), field3 (CharField)>')
-        self.assertEqual(repr(objects[2]), '<Model2D: id 4, field1 (CharField), field2 (CharField), field3 (CharField), field4 (CharField)>')
-        self.assertEqual(len(objects), 3)
+        self.assertQuerysetEqual(
+            objects,
+            [Model2B, Model2C, Model2D],
+            transform=lambda o: o.__class__,
+            ordered=False,
+        )
 
         objects = Model2A.objects.not_instance_of(Model2B)
-        self.assertEqual(repr(objects[0]), '<Model2A: id 1, field1 (CharField)>')
-        self.assertEqual(len(objects), 1)
+        self.assertQuerysetEqual(
+            objects,
+            [Model2A],
+            transform=lambda o: o.__class__,
+            ordered=False,
+        )
 
     def test_polymorphic___filter(self):
         self.create_model2abcd()
 
         objects = Model2A.objects.filter(Q(Model2B___field2='B2') | Q(Model2C___field3='C3'))
-        self.assertEqual(len(objects), 2)
-        self.assertEqual(repr(objects[0]), '<Model2B: id 2, field1 (CharField), field2 (CharField)>')
-        self.assertEqual(repr(objects[1]), '<Model2C: id 3, field1 (CharField), field2 (CharField), field3 (CharField)>')
+        self.assertQuerysetEqual(
+            objects,
+            [Model2B, Model2C],
+            transform=lambda o: o.__class__,
+            ordered=False,
+        )
 
     def test_query_filter_exclude_is_immutable(self):
         # given
@@ -434,18 +467,20 @@ def test_polymorphic___filter_reverse_field(self):
         self.assertEqual(len(objects), 1)
 
     def test_delete(self):
-        self.create_model2abcd()
+        a, b, c, d = self.create_model2abcd()
 
-        oa = Model2A.objects.get(id=2)
-        self.assertEqual(repr(oa), '<Model2B: id 2, field1 (CharField), field2 (CharField)>')
+        oa = Model2A.objects.get(id=b.id)
+        self.assertEqual(oa.__class__, Model2B)
         self.assertEqual(Model2A.objects.count(), 4)
 
         oa.delete()
         objects = Model2A.objects.all()
-        self.assertEqual(repr(objects[0]), '<Model2A: id 1, field1 (CharField)>')
-        self.assertEqual(repr(objects[1]), '<Model2C: id 3, field1 (CharField), field2 (CharField), field3 (CharField)>')
-        self.assertEqual(repr(objects[2]), '<Model2D: id 4, field1 (CharField), field2 (CharField), field3 (CharField), field4 (CharField)>')
-        self.assertEqual(len(objects), 3)
+        self.assertQuerysetEqual(
+            objects,
+            [Model2A, Model2C, Model2D],
+            transform=lambda o: o.__class__,
+            ordered=False,
+        )
 
     def test_combine_querysets(self):
         ModelX.objects.create(field_x='x')
@@ -506,9 +541,14 @@ def test_user_defined_manager(self):
         ModelWithMyManager.objects.create(field1='D1b', field4='D4b')
 
         objects = ModelWithMyManager.objects.all()   # MyManager should reverse the sorting of field1
-        self.assertEqual(repr(objects[0]), '<ModelWithMyManager: id 6, field1 (CharField) "D1b", field4 (CharField) "D4b">')
-        self.assertEqual(repr(objects[1]), '<ModelWithMyManager: id 5, field1 (CharField) "D1a", field4 (CharField) "D4a">')
-        self.assertEqual(len(objects), 2)
+        self.assertQuerysetEqual(
+            objects,
+            [
+                (ModelWithMyManager, 'D1b', 'D4b'),
+                (ModelWithMyManager, 'D1a', 'D4a'),
+            ],
+            transform=lambda o: (o.__class__, o.field1, o.field4),
+        )
 
         self.assertIs(type(ModelWithMyManager.objects), MyManager)
         self.assertIs(type(ModelWithMyManager._default_manager), MyManager)
@@ -520,9 +560,14 @@ def test_user_defined_manager_as_secondary(self):
         ModelWithMyManagerNoDefault.objects.create(field1='D1b', field4='D4b')
 
         objects = ModelWithMyManagerNoDefault.my_objects.all()   # MyManager should reverse the sorting of field1
-        self.assertEqual(repr(objects[0]), '<ModelWithMyManagerNoDefault: id 6, field1 (CharField) "D1b", field4 (CharField) "D4b">')
-        self.assertEqual(repr(objects[1]), '<ModelWithMyManagerNoDefault: id 5, field1 (CharField) "D1a", field4 (CharField) "D4a">')
-        self.assertEqual(len(objects), 2)
+        self.assertQuerysetEqual(
+            objects,
+            [
+                (ModelWithMyManagerNoDefault, 'D1b', 'D4b'),
+                (ModelWithMyManagerNoDefault, 'D1a', 'D4a'),
+            ],
+            transform=lambda o: (o.__class__, o.field1, o.field4),
+        )
 
         self.assertIs(type(ModelWithMyManagerNoDefault.my_objects), MyManager)
         self.assertIs(type(ModelWithMyManagerNoDefault.objects), PolymorphicManager)
@@ -545,9 +590,15 @@ def test_user_defined_queryset_as_manager(self):
         ModelWithMyManager2.objects.create(field1='D1b', field4='D4b')
 
         objects = ModelWithMyManager2.objects.all()
-        self.assertEqual(repr(objects[0]), '<ModelWithMyManager2: id 5, field1 (CharField) "D1a", field4 (CharField) "D4a">')
-        self.assertEqual(repr(objects[1]), '<ModelWithMyManager2: id 6, field1 (CharField) "D1b", field4 (CharField) "D4b">')
-        self.assertEqual(len(objects), 2)
+        self.assertQuerysetEqual(
+            objects,
+            [
+                (ModelWithMyManager2, 'D1a', 'D4a'),
+                (ModelWithMyManager2, 'D1b', 'D4b'),
+            ],
+            transform=lambda o: (o.__class__, o.field1, o.field4),
+            ordered=False,
+        )
 
         self.assertEqual(type(ModelWithMyManager2.objects).__name__, 'PolymorphicManagerFromMyManagerQuerySet')
         self.assertEqual(type(ModelWithMyManager2._default_manager).__name__, 'PolymorphicManagerFromMyManagerQuerySet')