Fixed #32980 -- Made models cache related managers.

6 files changed, 114 insertions, 6 deletions

diff --git a/tests/custom_managers/models.py b/tests/custom_managers/models.py
index 14222bfaf3..50d4bfb446 100644
--- a/tests/custom_managers/models.py
+++ b/tests/custom_managers/models.py
@@ -155,6 +155,22 @@ class Book(models.Model):
         base_manager_name = 'annotated_objects'
 
 
+class ConfusedBook(models.Model):
+    title = models.CharField(max_length=50)
+    author = models.CharField(max_length=30)
+    favorite_things = GenericRelation(
+        Person,
+        content_type_field='favorite_thing_type',
+        object_id_field='favorite_thing_id',
+    )
+    less_favorite_things = GenericRelation(
+        FunPerson,
+        content_type_field='favorite_thing_type',
+        object_id_field='favorite_thing_id',
+        related_query_name='favorite_things',
+    )
+
+
 class FastCarManager(models.Manager):
     def get_queryset(self):
         return super().get_queryset().filter(top_speed__gt=150)
diff --git a/tests/custom_managers/tests.py b/tests/custom_managers/tests.py
index 8e5ab1418f..b397816668 100644
--- a/tests/custom_managers/tests.py
+++ b/tests/custom_managers/tests.py
@@ -2,10 +2,10 @@ from django.db import models
 from django.test import TestCase
 
 from .models import (
-    Book, Car, CustomManager, CustomQuerySet, DeconstructibleCustomManager,
-    FastCarAsBase, FastCarAsDefault, FunPerson, OneToOneRestrictedModel,
-    Person, PersonFromAbstract, PersonManager, PublishedBookManager,
-    RelatedModel, RestrictedModel,
+    Book, Car, ConfusedBook, CustomManager, CustomQuerySet,
+    DeconstructibleCustomManager, FastCarAsBase, FastCarAsDefault, FunPerson,
+    OneToOneRestrictedModel, Person, PersonFromAbstract, PersonManager,
+    PublishedBookManager, RelatedModel, RestrictedModel,
 )
 
 
@@ -169,6 +169,10 @@ class CustomManagerTests(TestCase):
             ordered=False,
         )
 
+    def test_fk_related_manager_reused(self):
+        self.assertIs(self.b1.favorite_books, self.b1.favorite_books)
+        self.assertIn('favorite_books', self.b1._state.related_managers_cache)
+
     def test_gfk_related_manager(self):
         Person.objects.create(first_name="Bugs", last_name="Bunny", fun=True, favorite_thing=self.b1)
         Person.objects.create(first_name="Droopy", last_name="Dog", fun=False, favorite_thing=self.b1)
@@ -205,6 +209,60 @@ class CustomManagerTests(TestCase):
             ordered=False,
         )
 
+    def test_gfk_related_manager_reused(self):
+        self.assertIs(
+            self.b1.fun_people_favorite_things,
+            self.b1.fun_people_favorite_things,
+        )
+        self.assertIn(
+            'fun_people_favorite_things',
+            self.b1._state.related_managers_cache,
+        )
+
+    def test_gfk_related_manager_not_reused_when_alternate(self):
+        self.assertIsNot(
+            self.b1.favorite_things(manager='fun_people'),
+            self.b1.favorite_things(manager='fun_people'),
+        )
+
+    def test_gfk_related_manager_no_overlap_when_not_hidden(self):
+        """
+        If a GenericRelation defines a related_query_name (and thus the
+        related_name) which shadows another GenericRelation, it should not
+        cause those separate managers to clash.
+        """
+        book = ConfusedBook.objects.create(
+            title='How to program', author='Rodney Dangerfield',
+        )
+        person = Person.objects.create(
+            first_name='Bugs', last_name='Bunny', fun=True, favorite_thing=book,
+        )
+        fun_person = FunPerson.objects.create(
+            first_name='Droopy', last_name='Dog', fun=False, favorite_thing=book,
+        )
+        # The managers don't collide in the internal cache.
+        self.assertIsNot(book.favorite_things, book.less_favorite_things)
+        self.assertIs(book.favorite_things, book.favorite_things)
+        self.assertIs(book.less_favorite_things, book.less_favorite_things)
+        # Both managers are cached separately despite the collision in names.
+        self.assertIn('favorite_things', book._state.related_managers_cache)
+        self.assertIn('less_favorite_things', book._state.related_managers_cache)
+        # "less_favorite_things" isn't available as a reverse related manager,
+        # so never ends up in the cache.
+        self.assertQuerysetEqual(fun_person.favorite_things.all(), [book])
+        with self.assertRaises(AttributeError):
+            fun_person.less_favorite_things
+        self.assertIn('favorite_things', fun_person._state.related_managers_cache)
+        self.assertNotIn(
+            'less_favorite_things',
+            fun_person._state.related_managers_cache,
+        )
+        # The GenericRelation doesn't exist for Person, only FunPerson, so the
+        # exception prevents the cache from being polluted.
+        with self.assertRaises(AttributeError):
+            person.favorite_things
+        self.assertNotIn('favorite_things', person._state.related_managers_cache)
+
     def test_m2m_related_manager(self):
         bugs = Person.objects.create(first_name="Bugs", last_name="Bunny", fun=True)
         self.b1.authors.add(bugs)
@@ -245,6 +303,16 @@ class CustomManagerTests(TestCase):
             ordered=False,
         )
 
+    def test_m2m_related_forward_manager_reused(self):
+        self.assertIs(self.b1.authors, self.b1.authors)
+        self.assertIn('authors', self.b1._state.related_managers_cache)
+
+    def test_m2m_related_revers_manager_reused(self):
+        bugs = Person.objects.create(first_name='Bugs', last_name='Bunny')
+        self.b1.authors.add(bugs)
+        self.assertIs(bugs.books, bugs.books)
+        self.assertIn('books', bugs._state.related_managers_cache)
+
     def test_removal_through_default_fk_related_manager(self, bulk=True):
         bugs = FunPerson.objects.create(first_name="Bugs", last_name="Bunny", fun=True, favorite_book=self.b1)
         droopy = FunPerson.objects.create(first_name="Droopy", last_name="Dog", fun=False, favorite_book=self.b1)
diff --git a/tests/m2m_regress/tests.py b/tests/m2m_regress/tests.py
index a2c7fc99cc..0240893fdd 100644
--- a/tests/m2m_regress/tests.py
+++ b/tests/m2m_regress/tests.py
@@ -31,6 +31,14 @@ class M2MRegressionTests(TestCase):
         self.assertSequenceEqual(e1.topics.all(), [t1])
         self.assertSequenceEqual(e1.related.all(), [t2])
 
+    def test_m2m_managers_reused(self):
+        s1 = SelfRefer.objects.create(name='s1')
+        e1 = Entry.objects.create(name='e1')
+        self.assertIs(s1.references, s1.references)
+        self.assertIs(s1.related, s1.related)
+        self.assertIs(e1.topics, e1.topics)
+        self.assertIs(e1.related, e1.related)
+
     def test_internal_related_name_not_in_error_msg(self):
         # The secret internal related names for self-referential many-to-many
         # fields shouldn't appear in the list when an error is made.
diff --git a/tests/model_inheritance_regress/tests.py b/tests/model_inheritance_regress/tests.py
index 2c15925da5..ff1531b3f0 100644
--- a/tests/model_inheritance_regress/tests.py
+++ b/tests/model_inheritance_regress/tests.py
@@ -354,6 +354,11 @@ class ModelInheritanceTest(TestCase):
         parties = list(p4.bachelorparty_set.all())
         self.assertEqual(parties, [bachelor, messy_parent])
 
+    def test_abstract_base_class_m2m_relation_inheritance_manager_reused(self):
+        p1 = Person.objects.create(name='Alice')
+        self.assertIs(p1.birthdayparty_set, p1.birthdayparty_set)
+        self.assertIs(p1.bachelorparty_set, p1.bachelorparty_set)
+
     def test_abstract_verbose_name_plural_inheritance(self):
         """
         verbose_name_plural correctly inherited from ABC if inheritance chain
diff --git a/tests/model_regress/test_state.py b/tests/model_regress/test_state.py
index f41e4e52f4..66e519702a 100644
--- a/tests/model_regress/test_state.py
+++ b/tests/model_regress/test_state.py
@@ -1,8 +1,11 @@
-from django.db.models.base import ModelState, ModelStateFieldsCacheDescriptor
+from django.db.models.base import ModelState, ModelStateCacheDescriptor
 from django.test import SimpleTestCase
 
 
 class ModelStateTests(SimpleTestCase):
 
     def test_fields_cache_descriptor(self):
-        self.assertIsInstance(ModelState.fields_cache, ModelStateFieldsCacheDescriptor)
+        self.assertIsInstance(ModelState.fields_cache, ModelStateCacheDescriptor)
+
+    def test_related_managers_descriptor(self):
+        self.assertIsInstance(ModelState.related_managers_cache, ModelStateCacheDescriptor)
diff --git a/tests/prefetch_related/tests.py b/tests/prefetch_related/tests.py
index 242ff6c366..4ea7fccd5e 100644
--- a/tests/prefetch_related/tests.py
+++ b/tests/prefetch_related/tests.py
@@ -1147,6 +1147,14 @@ class ForeignKeyToFieldTest(TestCase):
                 ]
             )
 
+    def test_m2m_manager_reused(self):
+        author = Author.objects.prefetch_related(
+            'favorite_authors',
+            'favors_me',
+        ).first()
+        self.assertIs(author.favorite_authors, author.favorite_authors)
+        self.assertIs(author.favors_me, author.favors_me)
+
 
 class LookupOrderingTest(TestCase):
     """