Briq
/
django-polymorphic
6
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

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.
fix_request_path_info
Hugo Osvaldo Barrera 2017-09-06 12:11:17 -03:00 committed by Jerome Leclanche
parent 3af5db0ceb
commit 80b4f2bb41
2 changed files with 152 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

227
polymorphic/tests/test_orm.py
View File

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

26
polymorphic/tests/test_utils.py
View File

@ -1,12 +1,11 @@
from unittest import TestCase from django.test import TransactionTestCase
from polymorphic.models import PolymorphicTypeUndefined from polymorphic.models import PolymorphicTypeUndefined
from polymorphic.tests import Model2A, Model2B, Model2C, Model2D from polymorphic.tests import Model2A, Model2B, Model2C, Model2D
from polymorphic.tests.test_orm import qrepr from polymorphic.utils import reset_polymorphic_ctype, sort_by_subclass
from polymorphic.utils import sort_by_subclass, reset_polymorphic_ctype
class UtilsTests(TestCase): class UtilsTests(TransactionTestCase):
def test_sort_by_subclass(self): def test_sort_by_subclass(self):
self.assertEqual( self.assertEqual(
@ -29,12 +28,13 @@ class UtilsTests(TestCase):
reset_polymorphic_ctype(Model2D, Model2B, Model2D, Model2A, Model2C) reset_polymorphic_ctype(Model2D, Model2B, Model2D, Model2A, Model2C)
field_reprs = [ self.assertQuerysetEqual(
"<Model2A: id 1, field1 (CharField)>", Model2A.objects.order_by("pk"),
"<Model2D: id 2, field1 (CharField), field2 (CharField), field3 (CharField), field4 (CharField)>", [
"<Model2B: id 3, field1 (CharField), field2 (CharField)>", Model2A,
"<Model2B: id 4, field1 (CharField), field2 (CharField)>", Model2D,
] Model2B,
Model2B,
for f, f_repr in zip(Model2A.objects.order_by("pk"), field_reprs): ],
self.assertEqual(qrepr(f), f_repr) transform=lambda o: o.__class__,
)