Debian Codegraph @

tests/defer/tests.py

raw
1 from django.core.exceptions import FieldDoesNotExist, FieldError
2 from django.test import SimpleTestCase, TestCase
3
4 from .models import (
5 BigChild,
6 Child,
7 ChildProxy,
8 Primary,
9 PrimaryOneToOne,
10 RefreshPrimaryProxy,
11 Secondary,
12 ShadowChild,
13 )
14
15
16 class AssertionMixin:
17 def assert_delayed(self, obj, num):
18 """
19 Instances with deferred fields look the same as normal instances when
20 we examine attribute values. Therefore, this method returns the number
21 of deferred fields on returned instances.
22 """
23 count = len(obj.get_deferred_fields())
24 self.assertEqual(count, num)
25
26
27 class DeferTests(AssertionMixin, TestCase):
28 @classmethod
29 def setUpTestData(cls):
30 cls.s1 = Secondary.objects.create(first="x1", second="y1")
31 cls.p1 = Primary.objects.create(name="p1", value="xx", related=cls.s1)
32
33 def test_defer(self):
34 qs = Primary.objects.all()
35 self.assert_delayed(qs.defer("name")[0], 1)
36 self.assert_delayed(qs.defer("name").get(pk=self.p1.pk), 1)
37 self.assert_delayed(qs.defer("related__first")[0], 0)
38 self.assert_delayed(qs.defer("name").defer("value")[0], 2)
39
40 def test_only(self):
41 qs = Primary.objects.all()
42 self.assert_delayed(qs.only("name")[0], 2)
43 self.assert_delayed(qs.only("name").get(pk=self.p1.pk), 2)
44 self.assert_delayed(qs.only("name").only("value")[0], 2)
45 self.assert_delayed(qs.only("related__first")[0], 2)
46 # Using 'pk' with only() should result in 3 deferred fields, namely all
47 # of them except the model's primary key see #15494
48 self.assert_delayed(qs.only("pk")[0], 3)
49 # You can use 'pk' with reverse foreign key lookups.
50 # The related_id is always set even if it's not fetched from the DB,
51 # so pk and related_id are not deferred.
52 self.assert_delayed(self.s1.primary_set.only("pk")[0], 2)
53
54 def test_defer_only_chaining(self):
55 qs = Primary.objects.all()
56 self.assert_delayed(qs.only("name", "value").defer("name")[0], 2)
57 self.assert_delayed(qs.defer("name").only("value", "name")[0], 2)
58 self.assert_delayed(qs.defer("name").only("name").only("value")[0], 2)
59 self.assert_delayed(qs.defer("name").only("value")[0], 2)
60 self.assert_delayed(qs.only("name").defer("value")[0], 2)
61 self.assert_delayed(qs.only("name").defer("name").defer("value")[0], 1)
62 self.assert_delayed(qs.only("name").defer("name", "value")[0], 1)
63
64 def test_defer_only_clear(self):
65 qs = Primary.objects.all()
66 self.assert_delayed(qs.only("name").defer("name")[0], 0)
67 self.assert_delayed(qs.defer("name").only("name")[0], 0)
68
69 def test_defer_on_an_already_deferred_field(self):
70 qs = Primary.objects.all()
71 self.assert_delayed(qs.defer("name")[0], 1)
72 self.assert_delayed(qs.defer("name").defer("name")[0], 1)
73
74 def test_defer_none_to_clear_deferred_set(self):
75 qs = Primary.objects.all()
76 self.assert_delayed(qs.defer("name", "value")[0], 2)
77 self.assert_delayed(qs.defer(None)[0], 0)
78 self.assert_delayed(qs.only("name").defer(None)[0], 0)
79
80 def test_only_none_raises_error(self):
81 msg = "Cannot pass None as an argument to only()."
82 with self.assertRaisesMessage(TypeError, msg):
83 Primary.objects.only(None)
84
85 def test_defer_extra(self):
86 qs = Primary.objects.all()
87 self.assert_delayed(qs.defer("name").extra(select={"a": 1})[0], 1)
88 self.assert_delayed(qs.extra(select={"a": 1}).defer("name")[0], 1)
89
90 def test_defer_values_does_not_defer(self):
91 # User values() won't defer anything (you get the full list of
92 # dictionaries back), but it still works.
93 self.assertEqual(
94 Primary.objects.defer("name").values()[0],
95 {
96 "id": self.p1.id,
97 "name": "p1",
98 "value": "xx",
99 "related_id": self.s1.id,
100 },
101 )
102
103 def test_only_values_does_not_defer(self):
104 self.assertEqual(
105 Primary.objects.only("name").values()[0],
106 {
107 "id": self.p1.id,
108 "name": "p1",
109 "value": "xx",
110 "related_id": self.s1.id,
111 },
112 )
113
114 def test_get(self):
115 # Using defer() and only() with get() is also valid.
116 qs = Primary.objects.all()
117 self.assert_delayed(qs.defer("name").get(pk=self.p1.pk), 1)
118 self.assert_delayed(qs.only("name").get(pk=self.p1.pk), 2)
119
120 def test_defer_with_select_related(self):
121 obj = Primary.objects.select_related().defer(
122 "related__first", "related__second"
123 )[0]
124 self.assert_delayed(obj.related, 2)
125 self.assert_delayed(obj, 0)
126
127 def test_only_with_select_related(self):
128 obj = Primary.objects.select_related().only("related__first")[0]
129 self.assert_delayed(obj, 2)
130 self.assert_delayed(obj.related, 1)
131 self.assertEqual(obj.related_id, self.s1.pk)
132 self.assertEqual(obj.name, "p1")
133
134 def test_defer_foreign_keys_are_deferred_and_not_traversed(self):
135 # select_related() overrides defer().
136 with self.assertNumQueries(1):
137 obj = Primary.objects.defer("related").select_related()[0]
138 self.assert_delayed(obj, 1)
139 self.assertEqual(obj.related.id, self.s1.pk)
140
141 def test_saving_object_with_deferred_field(self):
142 # Saving models with deferred fields is possible (but inefficient,
143 # since every field has to be retrieved first).
144 Primary.objects.create(name="p2", value="xy", related=self.s1)
145 obj = Primary.objects.defer("value").get(name="p2")
146 obj.name = "a new name"
147 obj.save()
148 self.assertQuerySetEqual(
149 Primary.objects.all(),
150 [
151 "p1",
152 "a new name",
153 ],
154 lambda p: p.name,
155 ordered=False,
156 )
157
158 def test_defer_baseclass_when_subclass_has_no_added_fields(self):
159 # Regression for #10572 - A subclass with no extra fields can defer
160 # fields from the base class
161 Child.objects.create(name="c1", value="foo", related=self.s1)
162 # You can defer a field on a baseclass when the subclass has no fields
163 obj = Child.objects.defer("value").get(name="c1")
164 self.assert_delayed(obj, 1)
165 self.assertEqual(obj.name, "c1")
166 self.assertEqual(obj.value, "foo")
167
168 def test_only_baseclass_when_subclass_has_no_added_fields(self):
169 # You can retrieve a single column on a base class with no fields
170 Child.objects.create(name="c1", value="foo", related=self.s1)
171 obj = Child.objects.only("name").get(name="c1")
172 # on an inherited model, its PK is also fetched, hence '3' deferred fields.
173 self.assert_delayed(obj, 3)
174 self.assertEqual(obj.name, "c1")
175 self.assertEqual(obj.value, "foo")
176
177 def test_defer_of_overridden_scalar(self):
178 ShadowChild.objects.create()
179 obj = ShadowChild.objects.defer("name").get()
180 self.assertEqual(obj.name, "adonis")
181
182 def test_defer_fk_attname(self):
183 primary = Primary.objects.defer("related_id").get()
184 with self.assertNumQueries(1):
185 self.assertEqual(primary.related_id, self.p1.related_id)
186
187
188 class BigChildDeferTests(AssertionMixin, TestCase):
189 @classmethod
190 def setUpTestData(cls):
191 cls.s1 = Secondary.objects.create(first="x1", second="y1")
192 BigChild.objects.create(name="b1", value="foo", related=cls.s1, other="bar")
193
194 def test_defer_baseclass_when_subclass_has_added_field(self):
195 # You can defer a field on a baseclass
196 obj = BigChild.objects.defer("value").get(name="b1")
197 self.assert_delayed(obj, 1)
198 self.assertEqual(obj.name, "b1")
199 self.assertEqual(obj.value, "foo")
200 self.assertEqual(obj.other, "bar")
201
202 def test_defer_subclass(self):
203 # You can defer a field on a subclass
204 obj = BigChild.objects.defer("other").get(name="b1")
205 self.assert_delayed(obj, 1)
206 self.assertEqual(obj.name, "b1")
207 self.assertEqual(obj.value, "foo")
208 self.assertEqual(obj.other, "bar")
209
210 def test_defer_subclass_both(self):
211 # Deferring fields from both superclass and subclass works.
212 obj = BigChild.objects.defer("other", "value").get(name="b1")
213 self.assert_delayed(obj, 2)
214
215 def test_only_baseclass_when_subclass_has_added_field(self):
216 # You can retrieve a single field on a baseclass
217 obj = BigChild.objects.only("name").get(name="b1")
218 # when inherited model, its PK is also fetched, hence '4' deferred fields.
219 self.assert_delayed(obj, 4)
220 self.assertEqual(obj.name, "b1")
221 self.assertEqual(obj.value, "foo")
222 self.assertEqual(obj.other, "bar")
223
224 def test_only_subclass(self):
225 # You can retrieve a single field on a subclass
226 obj = BigChild.objects.only("other").get(name="b1")
227 self.assert_delayed(obj, 4)
228 self.assertEqual(obj.name, "b1")
229 self.assertEqual(obj.value, "foo")
230 self.assertEqual(obj.other, "bar")
231
232
233 class TestDefer2(AssertionMixin, TestCase):
234 def test_defer_proxy(self):
235 """
236 Ensure select_related together with only on a proxy model behaves
237 as expected. See #17876.
238 """
239 related = Secondary.objects.create(first="x1", second="x2")
240 ChildProxy.objects.create(name="p1", value="xx", related=related)
241 children = ChildProxy.objects.select_related().only("id", "name")
242 self.assertEqual(len(children), 1)
243 child = children[0]
244 self.assert_delayed(child, 2)
245 self.assertEqual(child.name, "p1")
246 self.assertEqual(child.value, "xx")
247
248 def test_defer_inheritance_pk_chaining(self):
249 """
250 When an inherited model is fetched from the DB, its PK is also fetched.
251 When getting the PK of the parent model it is useful to use the already
252 fetched parent model PK if it happens to be available.
253 """
254 s1 = Secondary.objects.create(first="x1", second="y1")
255 bc = BigChild.objects.create(name="b1", value="foo", related=s1, other="bar")
256 bc_deferred = BigChild.objects.only("name").get(pk=bc.pk)
257 with self.assertNumQueries(0):
258 bc_deferred.id
259 self.assertEqual(bc_deferred.pk, bc_deferred.id)
260
261 def test_eq(self):
262 s1 = Secondary.objects.create(first="x1", second="y1")
263 s1_defer = Secondary.objects.only("pk").get(pk=s1.pk)
264 self.assertEqual(s1, s1_defer)
265 self.assertEqual(s1_defer, s1)
266
267 def test_refresh_not_loading_deferred_fields(self):
268 s = Secondary.objects.create()
269 rf = Primary.objects.create(name="foo", value="bar", related=s)
270 rf2 = Primary.objects.only("related", "value").get()
271 rf.name = "new foo"
272 rf.value = "new bar"
273 rf.save()
274 with self.assertNumQueries(1):
275 rf2.refresh_from_db()
276 self.assertEqual(rf2.value, "new bar")
277 with self.assertNumQueries(1):
278 self.assertEqual(rf2.name, "new foo")
279
280 def test_custom_refresh_on_deferred_loading(self):
281 s = Secondary.objects.create()
282 rf = RefreshPrimaryProxy.objects.create(name="foo", value="bar", related=s)
283 rf2 = RefreshPrimaryProxy.objects.only("related").get()
284 rf.name = "new foo"
285 rf.value = "new bar"
286 rf.save()
287 with self.assertNumQueries(1):
288 # Customized refresh_from_db() reloads all deferred fields on
289 # access of any of them.
290 self.assertEqual(rf2.name, "new foo")
291 self.assertEqual(rf2.value, "new bar")
292
293 def test_refresh_when_one_field_deferred(self):
294 s = Secondary.objects.create()
295 PrimaryOneToOne.objects.create(name="foo", value="bar", related=s)
296 s = Secondary.objects.defer("first").get()
297 p_before = s.primary_o2o
298 s.refresh_from_db()
299 self.assertIsNot(s.primary_o2o, p_before)
300
301
302 class InvalidDeferTests(SimpleTestCase):
303 def test_invalid_defer(self):
304 msg = "Primary has no field named 'missing'"
305 with self.assertRaisesMessage(FieldDoesNotExist, msg):
306 list(Primary.objects.defer("missing"))
307 with self.assertRaisesMessage(FieldError, "missing"):
308 list(Primary.objects.defer("value__missing"))
309 msg = "Secondary has no field named 'missing'"
310 with self.assertRaisesMessage(FieldDoesNotExist, msg):
311 list(Primary.objects.defer("related__missing"))
312
313 def test_invalid_only(self):
314 msg = "Primary has no field named 'missing'"
315 with self.assertRaisesMessage(FieldDoesNotExist, msg):
316 list(Primary.objects.only("missing"))
317 with self.assertRaisesMessage(FieldError, "missing"):
318 list(Primary.objects.only("value__missing"))
319 msg = "Secondary has no field named 'missing'"
320 with self.assertRaisesMessage(FieldDoesNotExist, msg):
321 list(Primary.objects.only("related__missing"))
322
323 def test_defer_select_related_raises_invalid_query(self):
324 msg = (
325 "Field Primary.related cannot be both deferred and traversed using "
326 "select_related at the same time."
327 )
328 with self.assertRaisesMessage(FieldError, msg):
329 Primary.objects.defer("related").select_related("related")[0]
330
331 def test_only_select_related_raises_invalid_query(self):
332 msg = (
333 "Field Primary.related cannot be both deferred and traversed using "
334 "select_related at the same time."
335 )
336 with self.assertRaisesMessage(FieldError, msg):
337 Primary.objects.only("name").select_related("related")[0]
338
339
340 class DeferredRelationTests(TestCase):
341 @classmethod
342 def setUpTestData(cls):
343 cls.secondary = Secondary.objects.create(first="a", second="b")
344 cls.primary = PrimaryOneToOne.objects.create(
345 name="Bella", value="Baxter", related=cls.secondary
346 )
347
348 def test_defer_not_clear_cached_relations(self):
349 obj = Secondary.objects.defer("first").get(pk=self.secondary.pk)
350 with self.assertNumQueries(1):
351 obj.primary_o2o
352 obj.first # Accessing a deferred field.
353 with self.assertNumQueries(0):
354 obj.primary_o2o
355
356 def test_only_not_clear_cached_relations(self):
357 obj = Secondary.objects.only("first").get(pk=self.secondary.pk)
358 with self.assertNumQueries(1):
359 obj.primary_o2o
360 obj.second # Accessing a deferred field.
361 with self.assertNumQueries(0):
362 obj.primary_o2o