1. from operator import attrgetter

  2. 

  3. from django.contrib.contenttypes.models import ContentType

  4. from django.contrib.sessions.backends.db import SessionStore

  5. from django.db import models

  6. from django.db.models import Count

  7. from django.test import TestCase, ignore_warnings, override_settings

  8. from django.utils.deprecation import RemovedInDjango50Warning

  9. 

  10. from .models import (

  11.     Base,

  12.     Child,

  13.     Derived,

  14.     Feature,

  15.     Item,

  16.     ItemAndSimpleItem,

  17.     Leaf,

  18.     Location,

  19.     OneToOneItem,

  20.     Proxy,

  21.     ProxyRelated,

  22.     RelatedItem,

  23.     Request,

  24.     ResolveThis,

  25.     SimpleItem,

  26.     SpecialFeature,

  27. )

  28. 

  29. 

  30. class DeferRegressionTest(TestCase):

  31.     def test_basic(self):

  32.         # Deferred fields should really be deferred and not accidentally use

  33.         # the field's default value just because they aren't passed to __init__

  34. 

  35.         Item.objects.create(name="first", value=42)

  36.         obj = Item.objects.only("name", "other_value").get(name="first")

  37.         # Accessing "name" doesn't trigger a new database query. Accessing

  38.         # "value" or "text" should.

  39.         with self.assertNumQueries(0):

  40.             self.assertEqual(obj.name, "first")

  41.             self.assertEqual(obj.other_value, 0)

  42. 

  43.         with self.assertNumQueries(1):

  44.             self.assertEqual(obj.value, 42)

  45. 

  46.         with self.assertNumQueries(1):

  47.             self.assertEqual(obj.text, "xyzzy")

  48. 

  49.         with self.assertNumQueries(0):

  50.             self.assertEqual(obj.text, "xyzzy")

  51. 

  52.         # Regression test for #10695. Make sure different instances don't

  53.         # inadvertently share data in the deferred descriptor objects.

  54.         i = Item.objects.create(name="no I'm first", value=37)

  55.         items = Item.objects.only("value").order_by("-value")

  56.         self.assertEqual(items[0].name, "first")

  57.         self.assertEqual(items[1].name, "no I'm first")

  58. 

  59.         RelatedItem.objects.create(item=i)

  60.         r = RelatedItem.objects.defer("item").get()

  61.         self.assertEqual(r.item_id, i.id)

  62.         self.assertEqual(r.item, i)

  63. 

  64.         # Some further checks for select_related() and inherited model

  65.         # behavior (regression for #10710).

  66.         c1 = Child.objects.create(name="c1", value=42)

  67.         c2 = Child.objects.create(name="c2", value=37)

  68.         Leaf.objects.create(name="l1", child=c1, second_child=c2)

  69. 

  70.         obj = Leaf.objects.only("name", "child").select_related()[0]

  71.         self.assertEqual(obj.child.name, "c1")

  72. 

  73.         self.assertQuerysetEqual(

  74.             Leaf.objects.select_related().only("child__name", "second_child__name"),

  75.             [

  76.                 "l1",

  77.             ],

  78.             attrgetter("name"),

  79.         )

  80. 

  81.         # Models instances with deferred fields should still return the same

  82.         # content types as their non-deferred versions (bug #10738).

  83.         ctype = ContentType.objects.get_for_model

  84.         c1 = ctype(Item.objects.all()[0])

  85.         c2 = ctype(Item.objects.defer("name")[0])

  86.         c3 = ctype(Item.objects.only("name")[0])

  87.         self.assertTrue(c1 is c2 is c3)

  88. 

  89.         # Regression for #10733 - only() can be used on a model with two

  90.         # foreign keys.

  91.         results = Leaf.objects.only("name", "child", "second_child").select_related()

  92.         self.assertEqual(results[0].child.name, "c1")

  93.         self.assertEqual(results[0].second_child.name, "c2")

  94. 

  95.         results = Leaf.objects.only(

  96.             "name", "child", "second_child", "child__name", "second_child__name"

  97.         ).select_related()

  98.         self.assertEqual(results[0].child.name, "c1")

  99.         self.assertEqual(results[0].second_child.name, "c2")

  100. 

  101.         # Regression for #16409 - make sure defer() and only() work with annotate()

  102.         self.assertIsInstance(

  103.             list(SimpleItem.objects.annotate(Count("feature")).defer("name")), list

  104.         )

  105.         self.assertIsInstance(

  106.             list(SimpleItem.objects.annotate(Count("feature")).only("name")), list

  107.         )

  108. 

  109.     @ignore_warnings(category=RemovedInDjango50Warning)

  110.     @override_settings(

  111.         SESSION_SERIALIZER="django.contrib.sessions.serializers.PickleSerializer"

  112.     )

  113.     def test_ticket_12163(self):

  114.         # Test for #12163 - Pickling error saving session with unsaved model

  115.         # instances.

  116.         SESSION_KEY = "2b1189a188b44ad18c35e1baac6ceead"

  117. 

  118.         item = Item()

  119.         item._deferred = False

  120.         s = SessionStore(SESSION_KEY)

  121.         s.clear()

  122.         s["item"] = item

  123.         s.save(must_create=True)

  124. 

  125.         s = SessionStore(SESSION_KEY)

  126.         s.modified = True

  127.         s.save()

  128. 

  129.         i2 = s["item"]

  130.         self.assertFalse(i2._deferred)

  131. 

  132.     def test_ticket_16409(self):

  133.         # Regression for #16409 - make sure defer() and only() work with annotate()

  134.         self.assertIsInstance(

  135.             list(SimpleItem.objects.annotate(Count("feature")).defer("name")), list

  136.         )

  137.         self.assertIsInstance(

  138.             list(SimpleItem.objects.annotate(Count("feature")).only("name")), list

  139.         )

  140. 

  141.     def test_ticket_23270(self):

  142.         d = Derived.objects.create(text="foo", other_text="bar")

  143.         with self.assertNumQueries(1):

  144.             obj = Base.objects.select_related("derived").defer("text")[0]

  145.             self.assertIsInstance(obj.derived, Derived)

  146.             self.assertEqual("bar", obj.derived.other_text)

  147.             self.assertNotIn("text", obj.__dict__)

  148.             self.assertEqual(d.pk, obj.derived.base_ptr_id)

  149. 

  150.     def test_only_and_defer_usage_on_proxy_models(self):

  151.         # Regression for #15790 - only() broken for proxy models

  152.         proxy = Proxy.objects.create(name="proxy", value=42)

  153. 

  154.         msg = "QuerySet.only() return bogus results with proxy models"

  155.         dp = Proxy.objects.only("other_value").get(pk=proxy.pk)

  156.         self.assertEqual(dp.name, proxy.name, msg=msg)

  157.         self.assertEqual(dp.value, proxy.value, msg=msg)

  158. 

  159.         # also test things with .defer()

  160.         msg = "QuerySet.defer() return bogus results with proxy models"

  161.         dp = Proxy.objects.defer("name", "text", "value").get(pk=proxy.pk)

  162.         self.assertEqual(dp.name, proxy.name, msg=msg)

  163.         self.assertEqual(dp.value, proxy.value, msg=msg)

  164. 

  165.     def test_resolve_columns(self):

  166.         ResolveThis.objects.create(num=5.0, name="Foobar")

  167.         qs = ResolveThis.objects.defer("num")

  168.         self.assertEqual(1, qs.count())

  169.         self.assertEqual("Foobar", qs[0].name)

  170. 

  171.     def test_reverse_one_to_one_relations(self):

  172.         # Refs #14694. Test reverse relations which are known unique (reverse

  173.         # side has o2ofield or unique FK) - the o2o case

  174.         item = Item.objects.create(name="first", value=42)

  175.         o2o = OneToOneItem.objects.create(item=item, name="second")

  176.         self.assertEqual(len(Item.objects.defer("one_to_one_item__name")), 1)

  177.         self.assertEqual(len(Item.objects.select_related("one_to_one_item")), 1)

  178.         self.assertEqual(

  179.             len(

  180.                 Item.objects.select_related("one_to_one_item").defer(

  181.                     "one_to_one_item__name"

  182.                 )

  183.             ),

  184.             1,

  185.         )

  186.         self.assertEqual(

  187.             len(Item.objects.select_related("one_to_one_item").defer("value")), 1

  188.         )

  189.         # Make sure that `only()` doesn't break when we pass in a unique relation,

  190.         # rather than a field on the relation.

  191.         self.assertEqual(len(Item.objects.only("one_to_one_item")), 1)

  192.         with self.assertNumQueries(1):

  193.             i = Item.objects.select_related("one_to_one_item")[0]

  194.             self.assertEqual(i.one_to_one_item.pk, o2o.pk)

  195.             self.assertEqual(i.one_to_one_item.name, "second")

  196.         with self.assertNumQueries(1):

  197.             i = Item.objects.select_related("one_to_one_item").defer(

  198.                 "value", "one_to_one_item__name"

  199.             )[0]

  200.             self.assertEqual(i.one_to_one_item.pk, o2o.pk)

  201.             self.assertEqual(i.name, "first")

  202.         with self.assertNumQueries(1):

  203.             self.assertEqual(i.one_to_one_item.name, "second")

  204.         with self.assertNumQueries(1):

  205.             self.assertEqual(i.value, 42)

  206. 

  207.     def test_defer_with_select_related(self):

  208.         item1 = Item.objects.create(name="first", value=47)

  209.         item2 = Item.objects.create(name="second", value=42)

  210.         simple = SimpleItem.objects.create(name="simple", value="23")

  211.         ItemAndSimpleItem.objects.create(item=item1, simple=simple)

  212. 

  213.         obj = ItemAndSimpleItem.objects.defer("item").select_related("simple").get()

  214.         self.assertEqual(obj.item, item1)

  215.         self.assertEqual(obj.item_id, item1.id)

  216. 

  217.         obj.item = item2

  218.         obj.save()

  219. 

  220.         obj = ItemAndSimpleItem.objects.defer("item").select_related("simple").get()

  221.         self.assertEqual(obj.item, item2)

  222.         self.assertEqual(obj.item_id, item2.id)

  223. 

  224.     def test_proxy_model_defer_with_select_related(self):

  225.         # Regression for #22050

  226.         item = Item.objects.create(name="first", value=47)

  227.         RelatedItem.objects.create(item=item)

  228.         # Defer fields with only()

  229.         obj = ProxyRelated.objects.select_related().only("item__name")[0]

  230.         with self.assertNumQueries(0):

  231.             self.assertEqual(obj.item.name, "first")

  232.         with self.assertNumQueries(1):

  233.             self.assertEqual(obj.item.value, 47)

  234. 

  235.     def test_only_with_select_related(self):

  236.         # Test for #17485.

  237.         item = SimpleItem.objects.create(name="first", value=47)

  238.         feature = Feature.objects.create(item=item)

  239.         SpecialFeature.objects.create(feature=feature)

  240. 

  241.         qs = Feature.objects.only("item__name").select_related("item")

  242.         self.assertEqual(len(qs), 1)

  243. 

  244.         qs = SpecialFeature.objects.only("feature__item__name").select_related(

  245.             "feature__item"

  246.         )

  247.         self.assertEqual(len(qs), 1)

  248. 

  249. 

  250. class DeferAnnotateSelectRelatedTest(TestCase):

  251.     def test_defer_annotate_select_related(self):

  252.         location = Location.objects.create()

  253.         Request.objects.create(location=location)

  254.         self.assertIsInstance(

  255.             list(

  256.                 Request.objects.annotate(Count("items"))

  257.                 .select_related("profile", "location")

  258.                 .only("profile", "location")

  259.             ),

  260.             list,

  261.         )

  262.         self.assertIsInstance(

  263.             list(

  264.                 Request.objects.annotate(Count("items"))

  265.                 .select_related("profile", "location")

  266.                 .only("profile__profile1", "location__location1")

  267.             ),

  268.             list,

  269.         )

  270.         self.assertIsInstance(

  271.             list(

  272.                 Request.objects.annotate(Count("items"))

  273.                 .select_related("profile", "location")

  274.                 .defer("request1", "request2", "request3", "request4")

  275.             ),

  276.             list,

  277.         )

  278. 

  279. 

  280. class DeferDeletionSignalsTests(TestCase):

  281.     senders = [Item, Proxy]

  282. 

  283.     @classmethod

  284.     def setUpTestData(cls):

  285.         cls.item_pk = Item.objects.create(value=1).pk

  286. 

  287.     def setUp(self):

  288.         self.pre_delete_senders = []

  289.         self.post_delete_senders = []

  290.         for sender in self.senders:

  291.             models.signals.pre_delete.connect(self.pre_delete_receiver, sender)

  292.             models.signals.post_delete.connect(self.post_delete_receiver, sender)

  293. 

  294.     def tearDown(self):

  295.         for sender in self.senders:

  296.             models.signals.pre_delete.disconnect(self.pre_delete_receiver, sender)

  297.             models.signals.post_delete.disconnect(self.post_delete_receiver, sender)

  298. 

  299.     def pre_delete_receiver(self, sender, **kwargs):

  300.         self.pre_delete_senders.append(sender)

  301. 

  302.     def post_delete_receiver(self, sender, **kwargs):

  303.         self.post_delete_senders.append(sender)

  304. 

  305.     def test_delete_defered_model(self):

  306.         Item.objects.only("value").get(pk=self.item_pk).delete()

  307.         self.assertEqual(self.pre_delete_senders, [Item])

  308.         self.assertEqual(self.post_delete_senders, [Item])

  309. 

  310.     def test_delete_defered_proxy_model(self):

  311.         Proxy.objects.only("value").get(pk=self.item_pk).delete()

  312.         self.assertEqual(self.pre_delete_senders, [Proxy])

  313.         self.assertEqual(self.post_delete_senders, [Proxy])
About Sign Up Leave Feedback Contact