Debian Codegraph @

tests/defer_regress/tests.py

raw
1 from operator import attrgetter
2
3 from django.contrib.contenttypes.models import ContentType
4 from django.db import models
5 from django.db.models import Count
6 from django.test import TestCase
7
8 from .models import (
9 Base,
10 Child,
11 Derived,
12 Feature,
13 Item,
14 ItemAndSimpleItem,
15 Leaf,
16 Location,
17 OneToOneItem,
18 Proxy,
19 ProxyRelated,
20 RelatedItem,
21 Request,
22 ResolveThis,
23 SimpleItem,
24 SpecialFeature,
25 )
26
27
28 class DeferRegressionTest(TestCase):
29 def test_basic(self):
30 # Deferred fields should really be deferred and not accidentally use
31 # the field's default value just because they aren't passed to __init__
32
33 Item.objects.create(name="first", value=42)
34 obj = Item.objects.only("name", "other_value").get(name="first")
35 # Accessing "name" doesn't trigger a new database query. Accessing
36 # "value" or "text" should.
37 with self.assertNumQueries(0):
38 self.assertEqual(obj.name, "first")
39 self.assertEqual(obj.other_value, 0)
40
41 with self.assertNumQueries(1):
42 self.assertEqual(obj.value, 42)
43
44 with self.assertNumQueries(1):
45 self.assertEqual(obj.text, "xyzzy")
46
47 with self.assertNumQueries(0):
48 self.assertEqual(obj.text, "xyzzy")
49
50 # Regression test for #10695. Make sure different instances don't
51 # inadvertently share data in the deferred descriptor objects.
52 i = Item.objects.create(name="no I'm first", value=37)
53 items = Item.objects.only("value").order_by("-value")
54 self.assertEqual(items[0].name, "first")
55 self.assertEqual(items[1].name, "no I'm first")
56
57 RelatedItem.objects.create(item=i)
58 r = RelatedItem.objects.defer("item").get()
59 self.assertEqual(r.item_id, i.id)
60 self.assertEqual(r.item, i)
61
62 # Some further checks for select_related() and inherited model
63 # behavior (regression for #10710).
64 c1 = Child.objects.create(name="c1", value=42)
65 c2 = Child.objects.create(name="c2", value=37)
66 Leaf.objects.create(name="l1", child=c1, second_child=c2)
67
68 obj = Leaf.objects.only("name", "child").select_related()[0]
69 self.assertEqual(obj.child.name, "c1")
70
71 self.assertQuerySetEqual(
72 Leaf.objects.select_related().only("child__name", "second_child__name"),
73 [
74 "l1",
75 ],
76 attrgetter("name"),
77 )
78
79 # Models instances with deferred fields should still return the same
80 # content types as their non-deferred versions (bug #10738).
81 ctype = ContentType.objects.get_for_model
82 c1 = ctype(Item.objects.all()[0])
83 c2 = ctype(Item.objects.defer("name")[0])
84 c3 = ctype(Item.objects.only("name")[0])
85 self.assertTrue(c1 is c2 is c3)
86
87 # Regression for #10733 - only() can be used on a model with two
88 # foreign keys.
89 results = Leaf.objects.only("name", "child", "second_child").select_related()
90 self.assertEqual(results[0].child.name, "c1")
91 self.assertEqual(results[0].second_child.name, "c2")
92
93 results = Leaf.objects.only(
94 "name", "child", "second_child", "child__name", "second_child__name"
95 ).select_related()
96 self.assertEqual(results[0].child.name, "c1")
97 self.assertEqual(results[0].second_child.name, "c2")
98
99 # Regression for #16409 - make sure defer() and only() work with annotate()
100 self.assertIsInstance(
101 list(SimpleItem.objects.annotate(Count("feature")).defer("name")), list
102 )
103 self.assertIsInstance(
104 list(SimpleItem.objects.annotate(Count("feature")).only("name")), list
105 )
106
107 def test_ticket_16409(self):
108 # Regression for #16409 - make sure defer() and only() work with annotate()
109 self.assertIsInstance(
110 list(SimpleItem.objects.annotate(Count("feature")).defer("name")), list
111 )
112 self.assertIsInstance(
113 list(SimpleItem.objects.annotate(Count("feature")).only("name")), list
114 )
115
116 def test_ticket_23270(self):
117 d = Derived.objects.create(text="foo", other_text="bar")
118 with self.assertNumQueries(1):
119 obj = Base.objects.select_related("derived").defer("text")[0]
120 self.assertIsInstance(obj.derived, Derived)
121 self.assertEqual("bar", obj.derived.other_text)
122 self.assertNotIn("text", obj.__dict__)
123 self.assertEqual(d.pk, obj.derived.base_ptr_id)
124
125 def test_only_and_defer_usage_on_proxy_models(self):
126 # Regression for #15790 - only() broken for proxy models
127 proxy = Proxy.objects.create(name="proxy", value=42)
128
129 msg = "QuerySet.only() return bogus results with proxy models"
130 dp = Proxy.objects.only("other_value").get(pk=proxy.pk)
131 self.assertEqual(dp.name, proxy.name, msg=msg)
132 self.assertEqual(dp.value, proxy.value, msg=msg)
133
134 # also test things with .defer()
135 msg = "QuerySet.defer() return bogus results with proxy models"
136 dp = Proxy.objects.defer("name", "text", "value").get(pk=proxy.pk)
137 self.assertEqual(dp.name, proxy.name, msg=msg)
138 self.assertEqual(dp.value, proxy.value, msg=msg)
139
140 def test_resolve_columns(self):
141 ResolveThis.objects.create(num=5.0, name="Foobar")
142 qs = ResolveThis.objects.defer("num")
143 self.assertEqual(1, qs.count())
144 self.assertEqual("Foobar", qs[0].name)
145
146 def test_reverse_one_to_one_relations(self):
147 # Refs #14694. Test reverse relations which are known unique (reverse
148 # side has o2ofield or unique FK) - the o2o case
149 item = Item.objects.create(name="first", value=42)
150 o2o = OneToOneItem.objects.create(item=item, name="second")
151 self.assertEqual(len(Item.objects.defer("one_to_one_item__name")), 1)
152 self.assertEqual(len(Item.objects.select_related("one_to_one_item")), 1)
153 self.assertEqual(
154 len(
155 Item.objects.select_related("one_to_one_item").defer(
156 "one_to_one_item__name"
157 )
158 ),
159 1,
160 )
161 self.assertEqual(
162 len(Item.objects.select_related("one_to_one_item").defer("value")), 1
163 )
164 # Make sure that `only()` doesn't break when we pass in a unique relation,
165 # rather than a field on the relation.
166 self.assertEqual(len(Item.objects.only("one_to_one_item")), 1)
167 with self.assertNumQueries(1):
168 i = Item.objects.select_related("one_to_one_item")[0]
169 self.assertEqual(i.one_to_one_item.pk, o2o.pk)
170 self.assertEqual(i.one_to_one_item.name, "second")
171 with self.assertNumQueries(1):
172 i = Item.objects.select_related("one_to_one_item").defer(
173 "value", "one_to_one_item__name"
174 )[0]
175 self.assertEqual(i.one_to_one_item.pk, o2o.pk)
176 self.assertEqual(i.name, "first")
177 with self.assertNumQueries(1):
178 self.assertEqual(i.one_to_one_item.name, "second")
179 with self.assertNumQueries(1):
180 self.assertEqual(i.value, 42)
181 with self.assertNumQueries(1):
182 i = Item.objects.select_related("one_to_one_item").only(
183 "name", "one_to_one_item__item"
184 )[0]
185 self.assertEqual(i.one_to_one_item.pk, o2o.pk)
186 self.assertEqual(i.name, "first")
187 with self.assertNumQueries(1):
188 self.assertEqual(i.one_to_one_item.name, "second")
189 with self.assertNumQueries(1):
190 self.assertEqual(i.value, 42)
191
192 def test_defer_with_select_related(self):
193 item1 = Item.objects.create(name="first", value=47)
194 item2 = Item.objects.create(name="second", value=42)
195 simple = SimpleItem.objects.create(name="simple", value="23")
196 ItemAndSimpleItem.objects.create(item=item1, simple=simple)
197
198 obj = ItemAndSimpleItem.objects.defer("item").select_related("simple").get()
199 self.assertEqual(obj.item, item1)
200 self.assertEqual(obj.item_id, item1.id)
201
202 obj.item = item2
203 obj.save()
204
205 obj = ItemAndSimpleItem.objects.defer("item").select_related("simple").get()
206 self.assertEqual(obj.item, item2)
207 self.assertEqual(obj.item_id, item2.id)
208
209 def test_proxy_model_defer_with_select_related(self):
210 # Regression for #22050
211 item = Item.objects.create(name="first", value=47)
212 RelatedItem.objects.create(item=item)
213 # Defer fields with only()
214 obj = ProxyRelated.objects.select_related().only("item__name")[0]
215 with self.assertNumQueries(0):
216 self.assertEqual(obj.item.name, "first")
217 with self.assertNumQueries(1):
218 self.assertEqual(obj.item.value, 47)
219
220 def test_only_with_select_related(self):
221 # Test for #17485.
222 item = SimpleItem.objects.create(name="first", value=47)
223 feature = Feature.objects.create(item=item)
224 SpecialFeature.objects.create(feature=feature)
225
226 qs = Feature.objects.only("item__name").select_related("item")
227 self.assertEqual(len(qs), 1)
228
229 qs = SpecialFeature.objects.only("feature__item__name").select_related(
230 "feature__item"
231 )
232 self.assertEqual(len(qs), 1)
233
234 def test_defer_annotate_select_related(self):
235 location = Location.objects.create()
236 Request.objects.create(location=location)
237 self.assertIsInstance(
238 list(
239 Request.objects.annotate(Count("items"))
240 .select_related("profile", "location")
241 .only("profile", "location")
242 ),
243 list,
244 )
245 self.assertIsInstance(
246 list(
247 Request.objects.annotate(Count("items"))
248 .select_related("profile", "location")
249 .only("profile__profile1", "location__location1")
250 ),
251 list,
252 )
253 self.assertIsInstance(
254 list(
255 Request.objects.annotate(Count("items"))
256 .select_related("profile", "location")
257 .defer("request1", "request2", "request3", "request4")
258 ),
259 list,
260 )
261
262 def test_common_model_different_mask(self):
263 child = Child.objects.create(name="Child", value=42)
264 second_child = Child.objects.create(name="Second", value=64)
265 Leaf.objects.create(child=child, second_child=second_child)
266 with self.assertNumQueries(1):
267 leaf = (
268 Leaf.objects.select_related("child", "second_child")
269 .defer("child__name", "second_child__value")
270 .get()
271 )
272 self.assertEqual(leaf.child, child)
273 self.assertEqual(leaf.second_child, second_child)
274 self.assertEqual(leaf.child.get_deferred_fields(), {"name"})
275 self.assertEqual(leaf.second_child.get_deferred_fields(), {"value"})
276 with self.assertNumQueries(0):
277 self.assertEqual(leaf.child.value, 42)
278 self.assertEqual(leaf.second_child.name, "Second")
279 with self.assertNumQueries(1):
280 self.assertEqual(leaf.child.name, "Child")
281 with self.assertNumQueries(1):
282 self.assertEqual(leaf.second_child.value, 64)
283
284 def test_defer_many_to_many_ignored(self):
285 location = Location.objects.create()
286 request = Request.objects.create(location=location)
287 with self.assertNumQueries(1):
288 self.assertEqual(Request.objects.defer("items").get(), request)
289
290 def test_only_many_to_many_ignored(self):
291 location = Location.objects.create()
292 request = Request.objects.create(location=location)
293 with self.assertNumQueries(1):
294 self.assertEqual(Request.objects.only("items").get(), request)
295
296 def test_defer_reverse_many_to_many_ignored(self):
297 location = Location.objects.create()
298 request = Request.objects.create(location=location)
299 item = Item.objects.create(value=1)
300 request.items.add(item)
301 with self.assertNumQueries(1):
302 self.assertEqual(Item.objects.defer("request").get(), item)
303
304 def test_only_reverse_many_to_many_ignored(self):
305 location = Location.objects.create()
306 request = Request.objects.create(location=location)
307 item = Item.objects.create(value=1)
308 request.items.add(item)
309 with self.assertNumQueries(1):
310 self.assertEqual(Item.objects.only("request").get(), item)
311
312 def test_self_referential_one_to_one(self):
313 first = Item.objects.create(name="first", value=1)
314 second = Item.objects.create(name="second", value=2, source=first)
315 with self.assertNumQueries(1):
316 deferred_first, deferred_second = (
317 Item.objects.select_related("source", "destination")
318 .only("name", "source__name", "destination__value")
319 .order_by("pk")
320 )
321 with self.assertNumQueries(0):
322 self.assertEqual(deferred_first.name, first.name)
323 self.assertEqual(deferred_second.name, second.name)
324 self.assertEqual(deferred_second.source.name, first.name)
325 self.assertEqual(deferred_first.destination.value, second.value)
326 with self.assertNumQueries(1):
327 self.assertEqual(deferred_first.value, first.value)
328 with self.assertNumQueries(1):
329 self.assertEqual(deferred_second.source.value, first.value)
330 with self.assertNumQueries(1):
331 self.assertEqual(deferred_first.destination.name, second.name)
332
333
334 class DeferDeletionSignalsTests(TestCase):
335 senders = [Item, Proxy]
336
337 @classmethod
338 def setUpTestData(cls):
339 cls.item_pk = Item.objects.create(value=1).pk
340
341 def setUp(self):
342 self.pre_delete_senders = []
343 self.post_delete_senders = []
344 for sender in self.senders:
345 models.signals.pre_delete.connect(self.pre_delete_receiver, sender)
346 self.addCleanup(
347 models.signals.pre_delete.disconnect, self.pre_delete_receiver, sender
348 )
349 models.signals.post_delete.connect(self.post_delete_receiver, sender)
350 self.addCleanup(
351 models.signals.post_delete.disconnect, self.post_delete_receiver, sender
352 )
353
354 def pre_delete_receiver(self, sender, **kwargs):
355 self.pre_delete_senders.append(sender)
356
357 def post_delete_receiver(self, sender, **kwargs):
358 self.post_delete_senders.append(sender)
359
360 def test_delete_defered_model(self):
361 Item.objects.only("value").get(pk=self.item_pk).delete()
362 self.assertEqual(self.pre_delete_senders, [Item])
363 self.assertEqual(self.post_delete_senders, [Item])
364
365 def test_delete_defered_proxy_model(self):
366 Proxy.objects.only("value").get(pk=self.item_pk).delete()
367 self.assertEqual(self.pre_delete_senders, [Proxy])
368 self.assertEqual(self.post_delete_senders, [Proxy])