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

Update a bunch of failing tests 

Tests were failing because of:

* Models weren't being imported from their new location.
* PolymorphicManager doesn't work with non-polymorphic models, but
  migrations run models' manager, so having MROBase3 with
  PolymorphicManager failed.
* Some tests failed due to have assertions were being done (since they
  hardcoded expected instance ids). Update tests to use comparisons
  similar to #312
fix_request_path_info
Hugo Osvaldo Barrera 2017-09-06 19:47:50 -03:00
parent a507345c6d
commit e102a0502c
7 changed files with 195 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
polymorphic/tests/models.py
View File

@ -195,7 +195,7 @@ class MROBase2(MROBase1):
class MROBase3(models.Model):
base_3_id = models.AutoField(primary_key=True) # make sure 'id' field doesn't clash, detected by Django 1.11
objects = PolymorphicManager()
objects = models.Manager()
class MRODerived(MROBase2, MROBase3):

2
polymorphic/tests/test_admin.py
View File

@ -2,7 +2,7 @@ from django.contrib.admin import AdminSite
from django.test import TestCase
from polymorphic.admin import PolymorphicParentModelAdmin, PolymorphicChildModelAdmin, PolymorphicChildModelFilter
from polymorphic.tests import Model2A, Model2B, Model2C, Model2D
from polymorphic.tests.models import Model2A, Model2B, Model2C, Model2D
class MultipleDatabasesTests(TestCase):

5
polymorphic/tests/test_contrib.py
View File

@ -1,7 +1,10 @@
from unittest import TestCase
from polymorphic.contrib.guardian import get_polymorphic_base_content_type
from polymorphic.tests import * # all models
from polymorphic.tests.models import (
Model2D,
PlainC,
)
class ContribTests(TestCase):

70
polymorphic/tests/test_multidb.py
View File

@ -4,7 +4,19 @@ from django.contrib.contenttypes.models import ContentType
from django.db.models import Q
from django.test import TestCase
from polymorphic.tests import * # all models
from polymorphic.tests.models import (
Base,
BlogA,
BlogEntry,
Model2A,
Model2B,
Model2C,
Model2D,
ModelX,
ModelY,
One2OneRelatingModel,
RelatingModel,
)
class MultipleDatabasesTests(TestCase):
@ -16,15 +28,17 @@ class MultipleDatabasesTests(TestCase):
Model2B.objects.create(field1='B1', field2='B2')
Model2D(field1='D1', field2='D2', field3='D3', field4='D4').save()
default_objects = list(Model2A.objects.order_by('id'))
self.assertEqual(len(default_objects), 2)
self.assertEqual(repr(default_objects[0]), '<Model2B: id 1, field1 (CharField), field2 (CharField)>')
self.assertEqual(repr(default_objects[1]), '<Model2D: id 2, field1 (CharField), field2 (CharField), field3 (CharField), field4 (CharField)>')
self.assertQuerysetEqual(
Model2A.objects.order_by('id'),
[Model2B, Model2D],
transform=lambda o: o.__class__,
)
secondary_objects = list(Model2A.objects.db_manager('secondary').order_by('id'))
self.assertEqual(len(secondary_objects), 2)
self.assertEqual(repr(secondary_objects[0]), '<Model2A: id 1, field1 (CharField)>')
self.assertEqual(repr(secondary_objects[1]), '<Model2C: id 2, field1 (CharField), field2 (CharField), field3 (CharField)>')
self.assertQuerysetEqual(
Model2A.objects.db_manager('secondary').order_by('id'),
[Model2A, Model2C],
transform=lambda o: o.__class__,
)
def test_instance_of_filter_on_non_default_database(self):
Base.objects.db_manager('secondary').create(field_b='B1')
@ -32,23 +46,33 @@ class MultipleDatabasesTests(TestCase):
ModelY.objects.db_manager('secondary').create(field_b='Y', field_y='Y')
objects = Base.objects.db_manager('secondary').filter(instance_of=Base)
self.assertEqual(len(objects), 3)
self.assertEqual(repr(objects[0]), '<Base: id 1, field_b (CharField)>')
self.assertEqual(repr(objects[1]), '<ModelX: id 2, field_b (CharField), field_x (CharField)>')
self.assertEqual(repr(objects[2]), '<ModelY: id 3, field_b (CharField), field_y (CharField)>')
self.assertQuerysetEqual(
objects,
[Base, ModelX, ModelY],
transform=lambda o: o.__class__,
ordered=False,
)
objects = Base.objects.db_manager('secondary').filter(instance_of=ModelX)
self.assertEqual(len(objects), 1)
self.assertEqual(repr(objects[0]), '<ModelX: id 2, field_b (CharField), field_x (CharField)>')
self.assertQuerysetEqual(
Base.objects.db_manager('secondary').filter(instance_of=ModelX),
[ModelX],
transform=lambda o: o.__class__,
)
objects = Base.objects.db_manager('secondary').filter(instance_of=ModelY)
self.assertEqual(len(objects), 1)
self.assertEqual(repr(objects[0]), '<ModelY: id 3, field_b (CharField), field_y (CharField)>')
self.assertQuerysetEqual(
Base.objects.db_manager('secondary').filter(instance_of=ModelY),
[ModelY],
transform=lambda o: o.__class__,
)
objects = Base.objects.db_manager('secondary').filter(Q(instance_of=ModelX) | Q(instance_of=ModelY))
self.assertEqual(len(objects), 2)
self.assertEqual(repr(objects[0]), '<ModelX: id 2, field_b (CharField), field_x (CharField)>')
self.assertEqual(repr(objects[1]), '<ModelY: id 3, field_b (CharField), field_y (CharField)>')
self.assertQuerysetEqual(
Base.objects.db_manager('secondary').filter(
Q(instance_of=ModelX) | Q(instance_of=ModelY)
),
[ModelX, ModelY],
transform=lambda o: o.__class__,
ordered=False,
)
def test_forward_many_to_one_descriptor_on_non_default_database(self):
def func():

164
polymorphic/tests/test_orm.py
View File

@ -1,12 +1,82 @@
import re
import uuid
import django
from django.db import models
from django.db.models import Case, Count, Q, When
from django.test import TestCase, TransactionTestCase
from django.utils import six
from polymorphic.managers import PolymorphicManager
from polymorphic.models import PolymorphicTypeUndefined
from polymorphic.tests import * # all models
from polymorphic.tests.models import (
Base,
BlogA,
BlogB,
BlogBase,
BlogEntry,
BlogEntry_limit_choices_to,
ChildModelWithManager,
CustomPkBase,
CustomPkInherit,
Enhance_Base,
Enhance_Inherit,
InitTestModelSubclass,
MRODerived,
Model2A,
Model2B,
Model2C,
Model2D,
ModelExtraA,
ModelExtraB,
ModelExtraC,
ModelExtraExternal,
ModelFieldNameTest,
ModelShow1,
ModelShow1_plain,
ModelShow2,
ModelShow2_plain,
ModelShow3,
ModelUnderRelChild,
ModelUnderRelParent,
ModelWithMyManager,
ModelWithMyManager2,
ModelWithMyManagerDefault,
ModelWithMyManagerNoDefault,
ModelX,
ModelY,
MyManager,
MyManagerQuerySet,
NonProxyChild,
One2OneRelatingModel,
One2OneRelatingModelDerived,
ParentModelWithManager,
PlainA,
PlainB,
PlainC,
PlainChildModelWithManager,
PlainMyManager,
PlainMyManagerQuerySet,
PlainParentModelWithManager,
ProxiedBase,
ProxyBase,
ProxyChild,
ProxyModelA,
ProxyModelB,
ProxyModelBase,
QuerySet,
RelationA,
RelationB,
RelationBC,
RelationBase,
TestParentLinkAndRelatedName,
UUIDArtProject,
UUIDPlainA,
UUIDPlainB,
UUIDPlainC,
UUIDProject,
UUIDResearchProject,
)
class PolymorphicTests(TransactionTestCase):
@ -252,28 +322,52 @@ class PolymorphicTests(TransactionTestCase):
)
def test_base_manager(self):
def show_base_manager(model):
return "{0} {1}".format(
repr(type(model._base_manager)),
repr(model._base_manager.model)
def base_manager(model):
return (
type(model._base_manager),
model._base_manager.model
)
self.assertEqual(show_base_manager(PlainA), "<class 'django.db.models.manager.Manager'> <class 'polymorphic.tests.PlainA'>")
self.assertEqual(show_base_manager(PlainB), "<class 'django.db.models.manager.Manager'> <class 'polymorphic.tests.PlainB'>")
self.assertEqual(show_base_manager(PlainC), "<class 'django.db.models.manager.Manager'> <class 'polymorphic.tests.PlainC'>")
self.assertEqual(
base_manager(PlainA),
(models.Manager, PlainA),
)
self.assertEqual(
base_manager(PlainB),
(models.Manager, PlainB),
)
self.assertEqual(
base_manager(PlainC),
(models.Manager, PlainC),
)
self.assertEqual(show_base_manager(Model2A), "<class 'polymorphic.managers.PolymorphicManager'> <class 'polymorphic.tests.Model2A'>")
self.assertEqual(show_base_manager(Model2B), "<class 'polymorphic.managers.PolymorphicManager'> <class 'polymorphic.tests.Model2B'>")
self.assertEqual(show_base_manager(Model2C), "<class 'polymorphic.managers.PolymorphicManager'> <class 'polymorphic.tests.Model2C'>")
self.assertEqual(
base_manager(Model2A),
(PolymorphicManager, Model2A),
)
self.assertEqual(
base_manager(Model2B),
(PolymorphicManager, Model2B),
)
self.assertEqual(
base_manager(Model2C),
(PolymorphicManager, Model2C),
)
self.assertEqual(show_base_manager(One2OneRelatingModel), "<class 'polymorphic.managers.PolymorphicManager'> <class 'polymorphic.tests.One2OneRelatingModel'>")
self.assertEqual(show_base_manager(One2OneRelatingModelDerived), "<class 'polymorphic.managers.PolymorphicManager'> <class 'polymorphic.tests.One2OneRelatingModelDerived'>")
self.assertEqual(
base_manager(One2OneRelatingModel),
(PolymorphicManager, One2OneRelatingModel),
)
self.assertEqual(
base_manager(One2OneRelatingModelDerived),
(PolymorphicManager, One2OneRelatingModelDerived),
)
def test_instance_default_manager(self):
def show_default_manager(instance):
return "{0} {1}".format(
repr(type(instance.__class__._default_manager)),
repr(instance.__class__._default_manager.model)
def default_manager(instance):
return (
type(instance.__class__._default_manager),
instance.__class__._default_manager.model
)
plain_a = PlainA(field1='C1')
@ -284,13 +378,31 @@ class PolymorphicTests(TransactionTestCase):
model_2b = Model2B(field2='C1')
model_2c = Model2C(field3='C1')
self.assertEqual(show_default_manager(plain_a), "<class 'django.db.models.manager.Manager'> <class 'polymorphic.tests.PlainA'>")
self.assertEqual(show_default_manager(plain_b), "<class 'django.db.models.manager.Manager'> <class 'polymorphic.tests.PlainB'>")
self.assertEqual(show_default_manager(plain_c), "<class 'django.db.models.manager.Manager'> <class 'polymorphic.tests.PlainC'>")
self.assertEqual(
default_manager(plain_a),
(models.Manager, PlainA),
)
self.assertEqual(
default_manager(plain_b),
(models.Manager, PlainB),
)
self.assertEqual(
default_manager(plain_c),
(models.Manager, PlainC),
)
self.assertEqual(show_default_manager(model_2a), "<class 'polymorphic.managers.PolymorphicManager'> <class 'polymorphic.tests.Model2A'>")
self.assertEqual(show_default_manager(model_2b), "<class 'polymorphic.managers.PolymorphicManager'> <class 'polymorphic.tests.Model2B'>")
self.assertEqual(show_default_manager(model_2c), "<class 'polymorphic.managers.PolymorphicManager'> <class 'polymorphic.tests.Model2C'>")
self.assertEqual(
default_manager(model_2a),
(PolymorphicManager, Model2A),
)
self.assertEqual(
default_manager(model_2b),
(PolymorphicManager, Model2B),
)
self.assertEqual(
default_manager(model_2c),
(PolymorphicManager, Model2C),
)
def test_foreignkey_field(self):
self.create_model2abcd()
@ -376,7 +488,11 @@ class PolymorphicTests(TransactionTestCase):
ModelExtraExternal.objects.create(topic='extra1')
ModelExtraExternal.objects.create(topic='extra2')
ModelExtraExternal.objects.create(topic='extra3')
objects = ModelExtraA.objects.extra(tables=["polymorphic_modelextraexternal"], select={"topic": "polymorphic_modelextraexternal.topic"}, where=["polymorphic_modelextraa.id = polymorphic_modelextraexternal.id"])
objects = ModelExtraA.objects.extra(
tables=["tests_modelextraexternal"],
select={"topic": "tests_modelextraexternal.topic"},
where=["tests_modelextraa.id = tests_modelextraexternal.id"],
)
if six.PY3:
self.assertEqual(repr(objects[0]), '<ModelExtraA: id 1, field1 (CharField) "A1" - Extra: topic (str) "extra1">')
self.assertEqual(repr(objects[1]), '<ModelExtraB: id 2, field1 (CharField) "B1", field2 (CharField) "B2" - Extra: topic (str) "extra2">')

2
polymorphic/tests/test_regression.py
View File

@ -1,5 +1,5 @@
from django.test import TestCase
from . import Top, Middle, Bottom
from polymorphic.tests.models import Bottom, Middle, Top
class RegressionTests(TestCase):

2
polymorphic/tests/test_utils.py
View File

@ -1,7 +1,7 @@
from django.test import TransactionTestCase
from polymorphic.models import PolymorphicTypeUndefined
from polymorphic.tests import Model2A, Model2B, Model2C, Model2D
from polymorphic.tests.models import Model2A, Model2B, Model2C, Model2D
from polymorphic.utils import reset_polymorphic_ctype, sort_by_subclass