haven't committed in a while oops. A fuck-ton of HTML stuff

venv/lib/python3.8/site-packages/polymorphic/tests/test_admin.py

@@ -0,0 +1,141 @@
+from django.contrib import admin
+from django.contrib.contenttypes.models import ContentType
+from django.utils.html import escape
+
+from polymorphic.admin import (
+    PolymorphicChildModelAdmin,
+    PolymorphicChildModelFilter,
+    PolymorphicInlineSupportMixin,
+    PolymorphicParentModelAdmin,
+    StackedPolymorphicInline,
+)
+from polymorphic.tests.admintestcase import AdminTestCase
+from polymorphic.tests.models import (
+    InlineModelA,
+    InlineModelB,
+    InlineParent,
+    Model2A,
+    Model2B,
+    Model2C,
+    Model2D,
+)
+
+
+class PolymorphicAdminTests(AdminTestCase):
+    def test_admin_registration(self):
+        """
+        Test how the registration works
+        """
+
+        @self.register(Model2A)
+        class Model2Admin(PolymorphicParentModelAdmin):
+            base_model = Model2A
+            list_filter = (PolymorphicChildModelFilter,)
+            child_models = (Model2B, Model2C, Model2D)
+
+        @self.register(Model2B)
+        @self.register(Model2C)
+        @self.register(Model2D)
+        class Model2ChildAdmin(PolymorphicChildModelAdmin):
+            base_model = Model2A
+            base_fieldsets = (("Base fields", {"fields": ("field1",)}),)
+
+        # -- add page
+        ct_id = ContentType.objects.get_for_model(Model2D).pk
+        self.admin_get_add(Model2A)  # shows type page
+        self.admin_get_add(Model2A, qs="?ct_id={}".format(ct_id))  # shows type page
+
+        self.admin_get_add(Model2A)  # shows type page
+        self.admin_post_add(
+            Model2A,
+            {"field1": "A", "field2": "B", "field3": "C", "field4": "D"},
+            qs="?ct_id={}".format(ct_id),
+        )
+
+        d_obj = Model2A.objects.all()[0]
+        self.assertEqual(d_obj.__class__, Model2D)
+        self.assertEqual(d_obj.field1, "A")
+        self.assertEqual(d_obj.field2, "B")
+
+        # -- list page
+        self.admin_get_changelist(Model2A)  # asserts 200
+
+        # -- edit
+        response = self.admin_get_change(Model2A, d_obj.pk)
+        self.assertContains(response, "field4")
+        self.admin_post_change(
+            Model2A,
+            d_obj.pk,
+            {"field1": "A2", "field2": "B2", "field3": "C2", "field4": "D2"},
+        )
+
+        d_obj.refresh_from_db()
+        self.assertEqual(d_obj.field1, "A2")
+        self.assertEqual(d_obj.field2, "B2")
+        self.assertEqual(d_obj.field3, "C2")
+        self.assertEqual(d_obj.field4, "D2")
+
+        # -- history
+        self.admin_get_history(Model2A, d_obj.pk)
+
+        # -- delete
+        self.admin_get_delete(Model2A, d_obj.pk)
+        self.admin_post_delete(Model2A, d_obj.pk)
+        self.assertRaises(Model2A.DoesNotExist, lambda: d_obj.refresh_from_db())
+
+    def test_admin_inlines(self):
+        """
+        Test the registration of inline models.
+        """
+
+        class InlineModelAChild(StackedPolymorphicInline.Child):
+            model = InlineModelA
+
+        class InlineModelBChild(StackedPolymorphicInline.Child):
+            model = InlineModelB
+
+        class Inline(StackedPolymorphicInline):
+            model = InlineModelA
+            child_inlines = (InlineModelAChild, InlineModelBChild)
+
+        @self.register(InlineParent)
+        class InlineParentAdmin(PolymorphicInlineSupportMixin, admin.ModelAdmin):
+            inlines = (Inline,)
+
+        parent = InlineParent.objects.create(title="FOO")
+        self.assertEqual(parent.inline_children.count(), 0)
+
+        # -- get edit page
+        response = self.admin_get_change(InlineParent, parent.pk)
+
+        # Make sure the fieldset has the right data exposed in data-inline-formset
+        self.assertContains(response, "childTypes")
+        self.assertContains(response, escape('"type": "inlinemodela"'))
+        self.assertContains(response, escape('"type": "inlinemodelb"'))
+
+        # -- post edit page
+        self.admin_post_change(
+            InlineParent,
+            parent.pk,
+            {
+                "title": "FOO2",
+                "inline_children-INITIAL_FORMS": 0,
+                "inline_children-TOTAL_FORMS": 1,
+                "inline_children-MIN_NUM_FORMS": 0,
+                "inline_children-MAX_NUM_FORMS": 1000,
+                "inline_children-0-parent": parent.pk,
+                "inline_children-0-polymorphic_ctype": ContentType.objects.get_for_model(
+                    InlineModelB
+                ).pk,
+                "inline_children-0-field1": "A2",
+                "inline_children-0-field2": "B2",
+            },
+        )
+
+        parent.refresh_from_db()
+        self.assertEqual(parent.title, "FOO2")
+        self.assertEqual(parent.inline_children.count(), 1)
+        child = parent.inline_children.all()[0]
+        self.assertEqual(child.__class__, InlineModelB)
+        self.assertEqual(child.field1, "A2")
+        self.assertEqual(child.field2, "B2")

venv/lib/python3.8/site-packages/polymorphic/tests/test_multidb.py

@@ -0,0 +1,130 @@
+from __future__ import print_function
+
+from django.contrib.contenttypes.models import ContentType
+from django.db.models import Q
+from django.test import TestCase
+
+from polymorphic.tests.models import (
+    Base,
+    BlogA,
+    BlogEntry,
+    Model2A,
+    Model2B,
+    Model2C,
+    Model2D,
+    ModelX,
+    ModelY,
+    One2OneRelatingModel,
+    RelatingModel,
+)
+
+
+class MultipleDatabasesTests(TestCase):
+    multi_db = True
+
+    def test_save_to_non_default_database(self):
+        Model2A.objects.db_manager("secondary").create(field1="A1")
+        Model2C(field1="C1", field2="C2", field3="C3").save(using="secondary")
+        Model2B.objects.create(field1="B1", field2="B2")
+        Model2D(field1="D1", field2="D2", field3="D3", field4="D4").save()
+
+        self.assertQuerysetEqual(
+            Model2A.objects.order_by("id"),
+            [Model2B, Model2D],
+            transform=lambda o: o.__class__,
+        )
+
+        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")
+        ModelX.objects.db_manager("secondary").create(field_b="B", field_x="X")
+        ModelY.objects.db_manager("secondary").create(field_b="Y", field_y="Y")
+
+        objects = Base.objects.db_manager("secondary").filter(instance_of=Base)
+        self.assertQuerysetEqual(
+            objects,
+            [Base, ModelX, ModelY],
+            transform=lambda o: o.__class__,
+            ordered=False,
+        )
+
+        self.assertQuerysetEqual(
+            Base.objects.db_manager("secondary").filter(instance_of=ModelX),
+            [ModelX],
+            transform=lambda o: o.__class__,
+        )
+
+        self.assertQuerysetEqual(
+            Base.objects.db_manager("secondary").filter(instance_of=ModelY),
+            [ModelY],
+            transform=lambda o: o.__class__,
+        )
+
+        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():
+            blog = BlogA.objects.db_manager("secondary").create(
+                name="Blog", info="Info"
+            )
+            entry = BlogEntry.objects.db_manager("secondary").create(
+                blog=blog, text="Text"
+            )
+            ContentType.objects.clear_cache()
+            entry = BlogEntry.objects.db_manager("secondary").get(pk=entry.id)
+            self.assertEqual(blog, entry.blog)
+
+        # Ensure no queries are made using the default database.
+        self.assertNumQueries(0, func)
+
+    def test_reverse_many_to_one_descriptor_on_non_default_database(self):
+        def func():
+            blog = BlogA.objects.db_manager("secondary").create(
+                name="Blog", info="Info"
+            )
+            entry = BlogEntry.objects.db_manager("secondary").create(
+                blog=blog, text="Text"
+            )
+            ContentType.objects.clear_cache()
+            blog = BlogA.objects.db_manager("secondary").get(pk=blog.id)
+            self.assertEqual(entry, blog.blogentry_set.using("secondary").get())
+
+        # Ensure no queries are made using the default database.
+        self.assertNumQueries(0, func)
+
+    def test_reverse_one_to_one_descriptor_on_non_default_database(self):
+        def func():
+            m2a = Model2A.objects.db_manager("secondary").create(field1="A1")
+            one2one = One2OneRelatingModel.objects.db_manager("secondary").create(
+                one2one=m2a, field1="121"
+            )
+            ContentType.objects.clear_cache()
+            m2a = Model2A.objects.db_manager("secondary").get(pk=m2a.id)
+            self.assertEqual(one2one, m2a.one2onerelatingmodel)
+
+        # Ensure no queries are made using the default database.
+        self.assertNumQueries(0, func)
+
+    def test_many_to_many_descriptor_on_non_default_database(self):
+        def func():
+            m2a = Model2A.objects.db_manager("secondary").create(field1="A1")
+            rm = RelatingModel.objects.db_manager("secondary").create()
+            rm.many2many.add(m2a)
+            ContentType.objects.clear_cache()
+            m2a = Model2A.objects.db_manager("secondary").get(pk=m2a.id)
+            self.assertEqual(rm, m2a.relatingmodel_set.using("secondary").get())
+
+        # Ensure no queries are made using the default database.
+        self.assertNumQueries(0, func)

venv/lib/python3.8/site-packages/polymorphic/tests/test_regression.py

@@ -0,0 +1,30 @@
+from django.test import TestCase
+
+from polymorphic.tests.models import Bottom, Middle, Top
+
+
+class RegressionTests(TestCase):
+    def test_for_query_result_incomplete_with_inheritance(self):
+        """ https://github.com/bconstantin/django_polymorphic/issues/15 """
+
+        top = Top()
+        top.save()
+        middle = Middle()
+        middle.save()
+        bottom = Bottom()
+        bottom.save()
+
+        expected_queryset = [top, middle, bottom]
+        self.assertQuerysetEqual(
+            Top.objects.order_by("pk"), [repr(r) for r in expected_queryset]
+        )
+
+        expected_queryset = [middle, bottom]
+        self.assertQuerysetEqual(
+            Middle.objects.order_by("pk"), [repr(r) for r in expected_queryset]
+        )
+
+        expected_queryset = [bottom]
+        self.assertQuerysetEqual(
+            Bottom.objects.order_by("pk"), [repr(r) for r in expected_queryset]
+        )

venv/lib/python3.8/site-packages/polymorphic/tests/test_utils.py

@@ -0,0 +1,82 @@
+from django.test import TransactionTestCase
+
+from polymorphic.models import PolymorphicModel, PolymorphicTypeUndefined
+from polymorphic.tests.models import (
+    Enhance_Base,
+    Enhance_Inherit,
+    Model2A,
+    Model2B,
+    Model2C,
+    Model2D,
+)
+from polymorphic.utils import (
+    get_base_polymorphic_model,
+    reset_polymorphic_ctype,
+    sort_by_subclass,
+)
+
+
+class UtilsTests(TransactionTestCase):
+    def test_sort_by_subclass(self):
+        self.assertEqual(
+            sort_by_subclass(Model2D, Model2B, Model2D, Model2A, Model2C),
+            [Model2A, Model2B, Model2C, Model2D, Model2D],
+        )
+
+    def test_reset_polymorphic_ctype(self):
+        """
+        Test the the polymorphic_ctype_id can be restored.
+        """
+        Model2A.objects.create(field1="A1")
+        Model2D.objects.create(field1="A1", field2="B2", field3="C3", field4="D4")
+        Model2B.objects.create(field1="A1", field2="B2")
+        Model2B.objects.create(field1="A1", field2="B2")
+        Model2A.objects.all().update(polymorphic_ctype_id=None)
+
+        with self.assertRaises(PolymorphicTypeUndefined):
+            list(Model2A.objects.all())
+
+        reset_polymorphic_ctype(Model2D, Model2B, Model2D, Model2A, Model2C)
+
+        self.assertQuerysetEqual(
+            Model2A.objects.order_by("pk"),
+            [Model2A, Model2D, Model2B, Model2B],
+            transform=lambda o: o.__class__,
+        )
+
+    def test_get_base_polymorphic_model(self):
+        """
+        Test that finding the base polymorphic model works.
+        """
+        # Finds the base from every level (including lowest)
+        self.assertIs(get_base_polymorphic_model(Model2D), Model2A)
+        self.assertIs(get_base_polymorphic_model(Model2C), Model2A)
+        self.assertIs(get_base_polymorphic_model(Model2B), Model2A)
+        self.assertIs(get_base_polymorphic_model(Model2A), Model2A)
+
+        # Properly handles multiple inheritance
+        self.assertIs(get_base_polymorphic_model(Enhance_Inherit), Enhance_Base)
+
+        # Ignores PolymorphicModel itself.
+        self.assertIs(get_base_polymorphic_model(PolymorphicModel), None)
+
+    def test_get_base_polymorphic_model_skip_abstract(self):
+        """
+        Skipping abstract models that can't be used for querying.
+        """
+
+        class A(PolymorphicModel):
+            class Meta:
+                abstract = True
+
+        class B(A):
+            pass
+
+        class C(B):
+            pass
+
+        self.assertIs(get_base_polymorphic_model(A), None)
+        self.assertIs(get_base_polymorphic_model(B), B)
+        self.assertIs(get_base_polymorphic_model(C), B)
+
+        self.assertIs(get_base_polymorphic_model(C, allow_abstract=True), A)