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

polymorphic/tests/models.py

@@ -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):

polymorphic/tests/test_admin.py

@@ -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):

polymorphic/tests/test_contrib.py

@@ -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):

polymorphic/tests/test_multidb.py

@@ -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.assertQuerysetEqual(
-        self.assertEqual(len(default_objects), 2)
+            Model2A.objects.order_by('id'),
-        self.assertEqual(repr(default_objects[0]), '<Model2B: id 1, field1 (CharField), field2 (CharField)>')
+            [Model2B, Model2D],
-        self.assertEqual(repr(default_objects[1]), '<Model2D: id 2, field1 (CharField), field2 (CharField), field3 (CharField), field4 (CharField)>')
+            transform=lambda o: o.__class__,
+        )
 
-        secondary_objects = list(Model2A.objects.db_manager('secondary').order_by('id'))
+        self.assertQuerysetEqual(
-        self.assertEqual(len(secondary_objects), 2)
+            Model2A.objects.db_manager('secondary').order_by('id'),
-        self.assertEqual(repr(secondary_objects[0]), '<Model2A: id 1, field1 (CharField)>')
+            [Model2A, Model2C],
-        self.assertEqual(repr(secondary_objects[1]), '<Model2C: id 2, field1 (CharField), field2 (CharField), field3 (CharField)>')
+            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.assertQuerysetEqual(
-        self.assertEqual(repr(objects[0]), '<Base: id 1, field_b (CharField)>')
+            objects,
-        self.assertEqual(repr(objects[1]), '<ModelX: id 2, field_b (CharField), field_x (CharField)>')
+            [Base, ModelX, ModelY],
-        self.assertEqual(repr(objects[2]), '<ModelY: id 3, field_b (CharField), field_y (CharField)>')
+            transform=lambda o: o.__class__,
+            ordered=False,
+        )
 
-        objects = Base.objects.db_manager('secondary').filter(instance_of=ModelX)
+        self.assertQuerysetEqual(
-        self.assertEqual(len(objects), 1)
+            Base.objects.db_manager('secondary').filter(instance_of=ModelX),
-        self.assertEqual(repr(objects[0]), '<ModelX: id 2, field_b (CharField), field_x (CharField)>')
+            [ModelX],
+            transform=lambda o: o.__class__,
+        )
 
-        objects = Base.objects.db_manager('secondary').filter(instance_of=ModelY)
+        self.assertQuerysetEqual(
-        self.assertEqual(len(objects), 1)
+            Base.objects.db_manager('secondary').filter(instance_of=ModelY),
-        self.assertEqual(repr(objects[0]), '<ModelY: id 3, field_b (CharField), field_y (CharField)>')
+            [ModelY],
+            transform=lambda o: o.__class__,
+        )
 
-        objects = Base.objects.db_manager('secondary').filter(Q(instance_of=ModelX) | Q(instance_of=ModelY))
+        self.assertQuerysetEqual(
-        self.assertEqual(len(objects), 2)
+            Base.objects.db_manager('secondary').filter(
-        self.assertEqual(repr(objects[0]), '<ModelX: id 2, field_b (CharField), field_x (CharField)>')
+                Q(instance_of=ModelX) | Q(instance_of=ModelY)
-        self.assertEqual(repr(objects[1]), '<ModelY: id 3, field_b (CharField), field_y (CharField)>')
+            ),
+            [ModelX, ModelY],
+            transform=lambda o: o.__class__,
+            ordered=False,
+        )
 
     def test_forward_many_to_one_descriptor_on_non_default_database(self):
         def func():

polymorphic/tests/test_orm.py

@@ -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):
+        def base_manager(model):
-            return "{0} {1}".format(
+            return (
-                repr(type(model._base_manager)),
+                type(model._base_manager),
-                repr(model._base_manager.model)
+                model._base_manager.model
             )
 
-        self.assertEqual(show_base_manager(PlainA), "<class 'django.db.models.manager.Manager'> <class 'polymorphic.tests.PlainA'>")
+        self.assertEqual(
-        self.assertEqual(show_base_manager(PlainB), "<class 'django.db.models.manager.Manager'> <class 'polymorphic.tests.PlainB'>")
+            base_manager(PlainA),
-        self.assertEqual(show_base_manager(PlainC), "<class 'django.db.models.manager.Manager'> <class 'polymorphic.tests.PlainC'>")
+            (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(
-        self.assertEqual(show_base_manager(Model2B), "<class 'polymorphic.managers.PolymorphicManager'> <class 'polymorphic.tests.Model2B'>")
+            base_manager(Model2A),
-        self.assertEqual(show_base_manager(Model2C), "<class 'polymorphic.managers.PolymorphicManager'> <class 'polymorphic.tests.Model2C'>")
+            (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(
-        self.assertEqual(show_base_manager(One2OneRelatingModelDerived), "<class 'polymorphic.managers.PolymorphicManager'> <class 'polymorphic.tests.One2OneRelatingModelDerived'>")
+            base_manager(One2OneRelatingModel),
+            (PolymorphicManager, One2OneRelatingModel),
+        )
+        self.assertEqual(
+            base_manager(One2OneRelatingModelDerived),
+            (PolymorphicManager, One2OneRelatingModelDerived),
+        )
 
     def test_instance_default_manager(self):
-        def show_default_manager(instance):
+        def default_manager(instance):
-            return "{0} {1}".format(
+            return (
-                repr(type(instance.__class__._default_manager)),
+                type(instance.__class__._default_manager),
-                repr(instance.__class__._default_manager.model)
+                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(
-        self.assertEqual(show_default_manager(plain_b), "<class 'django.db.models.manager.Manager'> <class 'polymorphic.tests.PlainB'>")
+            default_manager(plain_a),
-        self.assertEqual(show_default_manager(plain_c), "<class 'django.db.models.manager.Manager'> <class 'polymorphic.tests.PlainC'>")
+            (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(
-        self.assertEqual(show_default_manager(model_2b), "<class 'polymorphic.managers.PolymorphicManager'> <class 'polymorphic.tests.Model2B'>")
+            default_manager(model_2a),
-        self.assertEqual(show_default_manager(model_2c), "<class 'polymorphic.managers.PolymorphicManager'> <class 'polymorphic.tests.Model2C'>")
+            (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">')

polymorphic/tests/test_regression.py

@@ -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):

polymorphic/tests/test_utils.py

@@ -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