Debian Codegraph @

tests/queryset_pickle/tests.py

raw
1 import datetime
2 import pickle
3
4 import django
5 from django.db import models
6 from django.test import TestCase
7
8 from .models import (
9 BinaryFieldModel,
10 Container,
11 Event,
12 Group,
13 Happening,
14 M2MModel,
15 MyEvent,
16 )
17
18
19 class PickleabilityTestCase(TestCase):
20 @classmethod
21 def setUpTestData(cls):
22 cls.happening = (
23 Happening.objects.create()
24 ) # make sure the defaults are working (#20158)
25
26 def assert_pickles(self, qs):
27 self.assertEqual(list(pickle.loads(pickle.dumps(qs))), list(qs))
28
29 def test_binaryfield(self):
30 BinaryFieldModel.objects.create(data=b"binary data")
31 self.assert_pickles(BinaryFieldModel.objects.all())
32
33 def test_related_field(self):
34 g = Group.objects.create(name="Ponies Who Own Maybachs")
35 self.assert_pickles(Event.objects.filter(group=g.id))
36
37 def test_datetime_callable_default_all(self):
38 self.assert_pickles(Happening.objects.all())
39
40 def test_datetime_callable_default_filter(self):
41 self.assert_pickles(Happening.objects.filter(when=datetime.datetime.now()))
42
43 def test_string_as_default(self):
44 self.assert_pickles(Happening.objects.filter(name="test"))
45
46 def test_standalone_method_as_default(self):
47 self.assert_pickles(Happening.objects.filter(number1=1))
48
49 def test_staticmethod_as_default(self):
50 self.assert_pickles(Happening.objects.filter(number2=1))
51
52 def test_filter_reverse_fk(self):
53 self.assert_pickles(Group.objects.filter(event=1))
54
55 def test_doesnotexist_exception(self):
56 # Ticket #17776
57 original = Event.DoesNotExist("Doesn't exist")
58 unpickled = pickle.loads(pickle.dumps(original))
59
60 # Exceptions are not equal to equivalent instances of themselves, so
61 # can't just use assertEqual(original, unpickled)
62 self.assertEqual(original.__class__, unpickled.__class__)
63 self.assertEqual(original.args, unpickled.args)
64
65 def test_doesnotexist_class(self):
66 klass = Event.DoesNotExist
67 self.assertIs(pickle.loads(pickle.dumps(klass)), klass)
68
69 def test_multipleobjectsreturned_class(self):
70 klass = Event.MultipleObjectsReturned
71 self.assertIs(pickle.loads(pickle.dumps(klass)), klass)
72
73 def test_forward_relatedobjectdoesnotexist_class(self):
74 # ForwardManyToOneDescriptor
75 klass = Event.group.RelatedObjectDoesNotExist
76 self.assertIs(pickle.loads(pickle.dumps(klass)), klass)
77 # ForwardOneToOneDescriptor
78 klass = Happening.event.RelatedObjectDoesNotExist
79 self.assertIs(pickle.loads(pickle.dumps(klass)), klass)
80
81 def test_reverse_one_to_one_relatedobjectdoesnotexist_class(self):
82 klass = Event.happening.RelatedObjectDoesNotExist
83 self.assertIs(pickle.loads(pickle.dumps(klass)), klass)
84
85 def test_manager_pickle(self):
86 pickle.loads(pickle.dumps(Happening.objects))
87
88 def test_model_pickle(self):
89 """
90 A model not defined on module level is picklable.
91 """
92 original = Container.SomeModel(pk=1)
93 dumped = pickle.dumps(original)
94 reloaded = pickle.loads(dumped)
95 self.assertEqual(original, reloaded)
96 # Also, deferred dynamic model works
97 Container.SomeModel.objects.create(somefield=1)
98 original = Container.SomeModel.objects.defer("somefield")[0]
99 dumped = pickle.dumps(original)
100 reloaded = pickle.loads(dumped)
101 self.assertEqual(original, reloaded)
102 self.assertEqual(original.somefield, reloaded.somefield)
103
104 def test_model_pickle_m2m(self):
105 """
106 Test intentionally the automatically created through model.
107 """
108 m1 = M2MModel.objects.create()
109 g1 = Group.objects.create(name="foof")
110 m1.groups.add(g1)
111 m2m_through = M2MModel._meta.get_field("groups").remote_field.through
112 original = m2m_through.objects.get()
113 dumped = pickle.dumps(original)
114 reloaded = pickle.loads(dumped)
115 self.assertEqual(original, reloaded)
116
117 def test_model_pickle_dynamic(self):
118 class Meta:
119 proxy = True
120
121 dynclass = type(
122 "DynamicEventSubclass",
123 (Event,),
124 {"Meta": Meta, "__module__": Event.__module__},
125 )
126 original = dynclass(pk=1)
127 dumped = pickle.dumps(original)
128 reloaded = pickle.loads(dumped)
129 self.assertEqual(original, reloaded)
130 self.assertIs(reloaded.__class__, dynclass)
131
132 def test_specialized_queryset(self):
133 self.assert_pickles(Happening.objects.values("name"))
134 self.assert_pickles(Happening.objects.values("name").dates("when", "year"))
135 # With related field (#14515)
136 self.assert_pickles(
137 Event.objects.select_related("group")
138 .order_by("title")
139 .values_list("title", "group__name")
140 )
141
142 def test_pickle_prefetch_related_idempotence(self):
143 g = Group.objects.create(name="foo")
144 groups = Group.objects.prefetch_related("event_set")
145
146 # First pickling
147 groups = pickle.loads(pickle.dumps(groups))
148 self.assertSequenceEqual(groups, [g])
149
150 # Second pickling
151 groups = pickle.loads(pickle.dumps(groups))
152 self.assertSequenceEqual(groups, [g])
153
154 def test_pickle_prefetch_queryset_usable_outside_of_prefetch(self):
155 # Prefetch shouldn't affect the fetch-on-pickle behavior of the
156 # queryset passed to it.
157 Group.objects.create(name="foo")
158 events = Event.objects.order_by("id")
159 Group.objects.prefetch_related(models.Prefetch("event_set", queryset=events))
160 with self.assertNumQueries(1):
161 events2 = pickle.loads(pickle.dumps(events))
162 with self.assertNumQueries(0):
163 list(events2)
164
165 def test_pickle_prefetch_queryset_still_usable(self):
166 g = Group.objects.create(name="foo")
167 groups = Group.objects.prefetch_related(
168 models.Prefetch("event_set", queryset=Event.objects.order_by("id"))
169 )
170 groups2 = pickle.loads(pickle.dumps(groups))
171 self.assertSequenceEqual(groups2.filter(id__gte=0), [g])
172
173 def test_pickle_prefetch_queryset_not_evaluated(self):
174 Group.objects.create(name="foo")
175 groups = Group.objects.prefetch_related(
176 models.Prefetch("event_set", queryset=Event.objects.order_by("id"))
177 )
178 list(groups) # evaluate QuerySet
179 with self.assertNumQueries(0):
180 pickle.loads(pickle.dumps(groups))
181
182 def test_pickle_prefetch_related_with_m2m_and_objects_deletion(self):
183 """
184 #24831 -- Cached properties on ManyToOneRel created in QuerySet.delete()
185 caused subsequent QuerySet pickling to fail.
186 """
187 g = Group.objects.create(name="foo")
188 m2m = M2MModel.objects.create()
189 m2m.groups.add(g)
190 Group.objects.all().delete()
191
192 m2ms = M2MModel.objects.prefetch_related("groups")
193 m2ms = pickle.loads(pickle.dumps(m2ms))
194 self.assertSequenceEqual(m2ms, [m2m])
195
196 def test_pickle_boolean_expression_in_Q__queryset(self):
197 group = Group.objects.create(name="group")
198 Event.objects.create(title="event", group=group)
199 groups = Group.objects.filter(
200 models.Q(
201 models.Exists(
202 Event.objects.filter(group_id=models.OuterRef("id")),
203 )
204 ),
205 )
206 groups2 = pickle.loads(pickle.dumps(groups))
207 self.assertSequenceEqual(groups2, [group])
208
209 def test_pickle_exists_queryset_still_usable(self):
210 group = Group.objects.create(name="group")
211 Event.objects.create(title="event", group=group)
212 groups = Group.objects.annotate(
213 has_event=models.Exists(
214 Event.objects.filter(group_id=models.OuterRef("id")),
215 ),
216 )
217 groups2 = pickle.loads(pickle.dumps(groups))
218 self.assertSequenceEqual(groups2.filter(has_event=True), [group])
219
220 def test_pickle_exists_queryset_not_evaluated(self):
221 group = Group.objects.create(name="group")
222 Event.objects.create(title="event", group=group)
223 groups = Group.objects.annotate(
224 has_event=models.Exists(
225 Event.objects.filter(group_id=models.OuterRef("id")),
226 ),
227 )
228 list(groups) # evaluate QuerySet.
229 with self.assertNumQueries(0):
230 self.assert_pickles(groups)
231
232 def test_pickle_exists_kwargs_queryset_not_evaluated(self):
233 group = Group.objects.create(name="group")
234 Event.objects.create(title="event", group=group)
235 groups = Group.objects.annotate(
236 has_event=models.Exists(
237 queryset=Event.objects.filter(group_id=models.OuterRef("id")),
238 ),
239 )
240 list(groups) # evaluate QuerySet.
241 with self.assertNumQueries(0):
242 self.assert_pickles(groups)
243
244 def test_pickle_subquery_queryset_not_evaluated(self):
245 group = Group.objects.create(name="group")
246 Event.objects.create(title="event", group=group)
247 groups = Group.objects.annotate(
248 event_title=models.Subquery(
249 Event.objects.filter(group_id=models.OuterRef("id")).values("title"),
250 ),
251 )
252 list(groups) # evaluate QuerySet.
253 with self.assertNumQueries(0):
254 self.assert_pickles(groups)
255
256 def test_pickle_filteredrelation(self):
257 group = Group.objects.create(name="group")
258 event_1 = Event.objects.create(title="Big event", group=group)
259 event_2 = Event.objects.create(title="Small event", group=group)
260 Happening.objects.bulk_create(
261 [
262 Happening(event=event_1, number1=5),
263 Happening(event=event_2, number1=3),
264 ]
265 )
266 groups = Group.objects.annotate(
267 big_events=models.FilteredRelation(
268 "event",
269 condition=models.Q(event__title__startswith="Big"),
270 ),
271 ).annotate(sum_number=models.Sum("big_events__happening__number1"))
272 groups_query = pickle.loads(pickle.dumps(groups.query))
273 groups = Group.objects.all()
274 groups.query = groups_query
275 self.assertEqual(groups.get().sum_number, 5)
276
277 def test_pickle_filteredrelation_m2m(self):
278 group = Group.objects.create(name="group")
279 m2mmodel = M2MModel.objects.create(added=datetime.date(2020, 1, 1))
280 m2mmodel.groups.add(group)
281 groups = Group.objects.annotate(
282 first_m2mmodels=models.FilteredRelation(
283 "m2mmodel",
284 condition=models.Q(m2mmodel__added__year=2020),
285 ),
286 ).annotate(count_groups=models.Count("first_m2mmodels__groups"))
287 groups_query = pickle.loads(pickle.dumps(groups.query))
288 groups = Group.objects.all()
289 groups.query = groups_query
290 self.assertEqual(groups.get().count_groups, 1)
291
292 def test_annotation_with_callable_default(self):
293 # Happening.when has a callable default of datetime.datetime.now.
294 qs = Happening.objects.annotate(latest_time=models.Max("when"))
295 self.assert_pickles(qs)
296
297 def test_annotation_values(self):
298 qs = Happening.objects.values("name").annotate(latest_time=models.Max("when"))
299 reloaded = Happening.objects.all()
300 reloaded.query = pickle.loads(pickle.dumps(qs.query))
301 self.assertEqual(
302 reloaded.get(),
303 {"name": "test", "latest_time": self.happening.when},
304 )
305
306 def test_annotation_values_list(self):
307 # values_list() is reloaded to values() when using a pickled query.
308 tests = [
309 Happening.objects.values_list("name"),
310 Happening.objects.values_list("name", flat=True),
311 Happening.objects.values_list("name", named=True),
312 ]
313 for qs in tests:
314 with self.subTest(qs._iterable_class.__name__):
315 reloaded = Happening.objects.all()
316 reloaded.query = pickle.loads(pickle.dumps(qs.query))
317 self.assertEqual(reloaded.get(), {"name": "test"})
318
319 def test_filter_deferred(self):
320 qs = Happening.objects.all()
321 qs._defer_next_filter = True
322 qs = qs.filter(id=0)
323 self.assert_pickles(qs)
324
325 def test_missing_django_version_unpickling(self):
326 """
327 #21430 -- Verifies a warning is raised for querysets that are
328 unpickled without a Django version
329 """
330 qs = Group.missing_django_version_objects.all()
331 msg = "Pickled queryset instance's Django version is not specified."
332 with self.assertRaisesMessage(RuntimeWarning, msg):
333 pickle.loads(pickle.dumps(qs))
334
335 def test_unsupported_unpickle(self):
336 """
337 #21430 -- Verifies a warning is raised for querysets that are
338 unpickled with a different Django version than the current
339 """
340 qs = Group.previous_django_version_objects.all()
341 msg = (
342 "Pickled queryset instance's Django version 1.0 does not match "
343 "the current version %s." % django.__version__
344 )
345 with self.assertRaisesMessage(RuntimeWarning, msg):
346 pickle.loads(pickle.dumps(qs))
347
348 def test_order_by_model_with_abstract_inheritance_and_meta_ordering(self):
349 group = Group.objects.create(name="test")
350 event = MyEvent.objects.create(title="test event", group=group)
351 event.edition_set.create()
352 self.assert_pickles(event.edition_set.order_by("event"))
353
354
355 class InLookupTests(TestCase):
356 @classmethod
357 def setUpTestData(cls):
358 for i in range(1, 3):
359 group = Group.objects.create(name="Group {}".format(i))
360 cls.e1 = Event.objects.create(title="Event 1", group=group)
361
362 def test_in_lookup_queryset_evaluation(self):
363 """
364 Neither pickling nor unpickling a QuerySet.query with an __in=inner_qs
365 lookup should evaluate inner_qs.
366 """
367 events = Event.objects.filter(group__in=Group.objects.all())
368
369 with self.assertNumQueries(0):
370 dumped = pickle.dumps(events.query)
371
372 with self.assertNumQueries(0):
373 reloaded = pickle.loads(dumped)
374 reloaded_events = Event.objects.none()
375 reloaded_events.query = reloaded
376
377 self.assertSequenceEqual(reloaded_events, [self.e1])
378
379 def test_in_lookup_query_evaluation(self):
380 events = Event.objects.filter(group__in=Group.objects.values("id").query)
381
382 with self.assertNumQueries(0):
383 dumped = pickle.dumps(events.query)
384
385 with self.assertNumQueries(0):
386 reloaded = pickle.loads(dumped)
387 reloaded_events = Event.objects.none()
388 reloaded_events.query = reloaded
389
390 self.assertSequenceEqual(reloaded_events, [self.e1])