From 80b4f2bb41423d6131e2e39ef5c6b212ce5a7b56 Mon Sep 17 00:00:00 2001 From: Hugo Osvaldo Barrera Date: Wed, 6 Sep 2017 12:11:17 -0300 Subject: [PATCH] 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. --- polymorphic/tests/test_orm.py | 227 +++++++++++++++++++------------- polymorphic/tests/test_utils.py | 26 ++-- 2 files changed, 152 insertions(+), 101 deletions(-) diff --git a/polymorphic/tests/test_orm.py b/polymorphic/tests/test_orm.py index 5f6186f..41d6c12 100644 --- a/polymorphic/tests/test_orm.py +++ b/polymorphic/tests/test_orm.py @@ -2,14 +2,14 @@ import re 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 @@ class PolymorphicTests(TestCase): 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]), '') - self.assertEqual(repr(objects[1]), '') - self.assertEqual(repr(objects[2]), '') - self.assertEqual(repr(objects[3]), '') + 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,43 +188,36 @@ class PolymorphicTests(TestCase): 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]), - '') - self.assertEqual(repr(objects_deferred_field4[1]), - '') - self.assertEqual(repr(objects_deferred_field4[2]), - '') - self.assertEqual(repr(objects_deferred_field4[3]), - '') + 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]), - '') - self.assertEqual(repr(objects_only_field4[1]), - '') - self.assertEqual(repr(objects_only_field4[2]), - '') - self.assertEqual(repr(objects_only_field4[3]), - '') + 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()), '') + 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]), '') - self.assertEqual(repr(objects[1]), '') - self.assertEqual(repr(objects[2]), '') - self.assertEqual(repr(objects[3]), '') + self.assertQuerysetEqual( + objects, + [Model2A, Model2A, Model2A, Model2A], + transform=lambda o: o.__class__, + ) def test_get_real_instances(self): self.create_model2abcd() @@ -228,25 +225,31 @@ class PolymorphicTests(TestCase): # from queryset objects = qs.get_real_instances() - self.assertEqual(repr(objects[0]), '') - self.assertEqual(repr(objects[1]), '') - self.assertEqual(repr(objects[2]), '') - self.assertEqual(repr(objects[3]), '') + 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]), '') - self.assertEqual(repr(objects[1]), '') - self.assertEqual(repr(objects[2]), '') - self.assertEqual(repr(objects[3]), '') + 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]), '') - self.assertEqual(repr(objects[1]), '') + 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 @@ class PolymorphicTests(TestCase): self.create_model2abcd() object2a = Model2A.base_objects.get(field1='C1') - self.assertEqual(repr(object2a.model2b), '') + self.assertEqual(object2a.model2b.__class__, Model2B) object2b = Model2B.base_objects.get(field1='C1') - self.assertEqual(repr(object2b.model2c), '') + self.assertEqual(object2b.model2c.__class__, Model2C) def test_onetoone_field(self): self.create_model2abcd() @@ -305,11 +308,15 @@ class PolymorphicTests(TestCase): 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), '') + 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), '') - self.assertEqual(repr(a.one2onerelatingmodel), '') + self.assertEqual(c.one2one.__class__, Model2C) + self.assertEqual( + a.one2onerelatingmodel.__class__, + One2OneRelatingModelDerived, + ) def test_manytomany_field(self): # Model 1 @@ -336,19 +343,32 @@ class PolymorphicTests(TestCase): # no pretty printing ModelShow1_plain.objects.create(field1='abc') ModelShow2_plain.objects.create(field1='abc', field2='def') - self.assertEqual(qrepr(ModelShow1_plain.objects.all()), ', ]>') + 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]), '') - self.assertEqual(repr(objects[1]), '') + 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]), '') - self.assertEqual(repr(objects[1]), '') - 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 @@ class PolymorphicTests(TestCase): self.create_model2abcd() objects = Model2A.objects.instance_of(Model2B) - self.assertEqual(repr(objects[0]), '') - self.assertEqual(repr(objects[1]), '') - self.assertEqual(repr(objects[2]), '') - 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]), '') - self.assertEqual(repr(objects[1]), '') - self.assertEqual(repr(objects[2]), '') - 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]), '') - self.assertEqual(repr(objects[1]), '') - self.assertEqual(repr(objects[2]), '') - 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]), '') - 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]), '') - self.assertEqual(repr(objects[1]), '') + 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 @@ class PolymorphicTests(TestCase): 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), '') + 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]), '') - self.assertEqual(repr(objects[1]), '') - self.assertEqual(repr(objects[2]), '') - 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 @@ class PolymorphicTests(TestCase): ModelWithMyManager.objects.create(field1='D1b', field4='D4b') objects = ModelWithMyManager.objects.all() # MyManager should reverse the sorting of field1 - self.assertEqual(repr(objects[0]), '') - self.assertEqual(repr(objects[1]), '') - 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 @@ class PolymorphicTests(TestCase): ModelWithMyManagerNoDefault.objects.create(field1='D1b', field4='D4b') objects = ModelWithMyManagerNoDefault.my_objects.all() # MyManager should reverse the sorting of field1 - self.assertEqual(repr(objects[0]), '') - self.assertEqual(repr(objects[1]), '') - 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 @@ class PolymorphicTests(TestCase): ModelWithMyManager2.objects.create(field1='D1b', field4='D4b') objects = ModelWithMyManager2.objects.all() - self.assertEqual(repr(objects[0]), '') - self.assertEqual(repr(objects[1]), '') - 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') diff --git a/polymorphic/tests/test_utils.py b/polymorphic/tests/test_utils.py index 5a3d9b4..e857f64 100644 --- a/polymorphic/tests/test_utils.py +++ b/polymorphic/tests/test_utils.py @@ -1,12 +1,11 @@ -from unittest import TestCase +from django.test import TransactionTestCase from polymorphic.models import PolymorphicTypeUndefined from polymorphic.tests import Model2A, Model2B, Model2C, Model2D -from polymorphic.tests.test_orm import qrepr -from polymorphic.utils import sort_by_subclass, reset_polymorphic_ctype +from polymorphic.utils import reset_polymorphic_ctype, sort_by_subclass -class UtilsTests(TestCase): +class UtilsTests(TransactionTestCase): def test_sort_by_subclass(self): self.assertEqual( @@ -29,12 +28,13 @@ class UtilsTests(TestCase): reset_polymorphic_ctype(Model2D, Model2B, Model2D, Model2A, Model2C) - field_reprs = [ - "", - "", - "", - "", - ] - - for f, f_repr in zip(Model2A.objects.order_by("pk"), field_reprs): - self.assertEqual(qrepr(f), f_repr) + self.assertQuerysetEqual( + Model2A.objects.order_by("pk"), + [ + Model2A, + Model2D, + Model2B, + Model2B, + ], + transform=lambda o: o.__class__, + )