Debian Codegraph @

tests/foreign_object/tests.py

raw
1 import copy
2 import datetime
3 import pickle
4 from operator import attrgetter
5
6 from django.core.exceptions import FieldError
7 from django.db import connection, models
8 from django.test import SimpleTestCase, TestCase, skipUnlessDBFeature
9 from django.test.utils import isolate_apps
10 from django.utils import translation
11 from django.utils.deprecation import RemovedInDjango60Warning
12
13 from .models import (
14 Article,
15 ArticleIdea,
16 ArticleTag,
17 ArticleTranslation,
18 Country,
19 Friendship,
20 Group,
21 Membership,
22 NewsArticle,
23 Person,
24 )
25
26 # Note that these tests are testing internal implementation details.
27 # ForeignObject is not part of public API.
28
29
30 class MultiColumnFKTests(TestCase):
31 @classmethod
32 def setUpTestData(cls):
33 # Creating countries
34 cls.usa = Country.objects.create(name="United States of America")
35 cls.soviet_union = Country.objects.create(name="Soviet Union")
36 # Creating People
37 cls.bob = Person.objects.create(name="Bob", person_country=cls.usa)
38 cls.jim = Person.objects.create(name="Jim", person_country=cls.usa)
39 cls.george = Person.objects.create(name="George", person_country=cls.usa)
40
41 cls.jane = Person.objects.create(name="Jane", person_country=cls.soviet_union)
42 cls.mark = Person.objects.create(name="Mark", person_country=cls.soviet_union)
43 cls.sam = Person.objects.create(name="Sam", person_country=cls.soviet_union)
44
45 # Creating Groups
46 cls.kgb = Group.objects.create(name="KGB", group_country=cls.soviet_union)
47 cls.cia = Group.objects.create(name="CIA", group_country=cls.usa)
48 cls.republican = Group.objects.create(name="Republican", group_country=cls.usa)
49 cls.democrat = Group.objects.create(name="Democrat", group_country=cls.usa)
50
51 def test_get_succeeds_on_multicolumn_match(self):
52 # Membership objects have access to their related Person if both
53 # country_ids match between them
54 membership = Membership.objects.create(
55 membership_country_id=self.usa.id,
56 person_id=self.bob.id,
57 group_id=self.cia.id,
58 )
59
60 person = membership.person
61 self.assertEqual((person.id, person.name), (self.bob.id, "Bob"))
62
63 def test_get_fails_on_multicolumn_mismatch(self):
64 # Membership objects returns DoesNotExist error when there is no
65 # Person with the same id and country_id
66 membership = Membership.objects.create(
67 membership_country_id=self.usa.id,
68 person_id=self.jane.id,
69 group_id=self.cia.id,
70 )
71
72 with self.assertRaises(Person.DoesNotExist):
73 getattr(membership, "person")
74
75 def test_reverse_query_returns_correct_result(self):
76 # Creating a valid membership because it has the same country has the person
77 Membership.objects.create(
78 membership_country_id=self.usa.id,
79 person_id=self.bob.id,
80 group_id=self.cia.id,
81 )
82
83 # Creating an invalid membership because it has a different country has
84 # the person.
85 Membership.objects.create(
86 membership_country_id=self.soviet_union.id,
87 person_id=self.bob.id,
88 group_id=self.republican.id,
89 )
90
91 with self.assertNumQueries(1):
92 membership = self.bob.membership_set.get()
93 self.assertEqual(membership.group_id, self.cia.id)
94 self.assertIs(membership.person, self.bob)
95
96 def test_query_filters_correctly(self):
97 # Creating a to valid memberships
98 Membership.objects.create(
99 membership_country_id=self.usa.id,
100 person_id=self.bob.id,
101 group_id=self.cia.id,
102 )
103 Membership.objects.create(
104 membership_country_id=self.usa.id,
105 person_id=self.jim.id,
106 group_id=self.cia.id,
107 )
108
109 # Creating an invalid membership
110 Membership.objects.create(
111 membership_country_id=self.soviet_union.id,
112 person_id=self.george.id,
113 group_id=self.cia.id,
114 )
115
116 self.assertQuerySetEqual(
117 Membership.objects.filter(person__name__contains="o"),
118 [self.bob.id],
119 attrgetter("person_id"),
120 )
121
122 def test_reverse_query_filters_correctly(self):
123 timemark = datetime.datetime.now(tz=datetime.timezone.utc).replace(tzinfo=None)
124 timedelta = datetime.timedelta(days=1)
125
126 # Creating a to valid memberships
127 Membership.objects.create(
128 membership_country_id=self.usa.id,
129 person_id=self.bob.id,
130 group_id=self.cia.id,
131 date_joined=timemark - timedelta,
132 )
133 Membership.objects.create(
134 membership_country_id=self.usa.id,
135 person_id=self.jim.id,
136 group_id=self.cia.id,
137 date_joined=timemark + timedelta,
138 )
139
140 # Creating an invalid membership
141 Membership.objects.create(
142 membership_country_id=self.soviet_union.id,
143 person_id=self.george.id,
144 group_id=self.cia.id,
145 date_joined=timemark + timedelta,
146 )
147
148 self.assertQuerySetEqual(
149 Person.objects.filter(membership__date_joined__gte=timemark),
150 ["Jim"],
151 attrgetter("name"),
152 )
153
154 def test_forward_in_lookup_filters_correctly(self):
155 Membership.objects.create(
156 membership_country_id=self.usa.id,
157 person_id=self.bob.id,
158 group_id=self.cia.id,
159 )
160 Membership.objects.create(
161 membership_country_id=self.usa.id,
162 person_id=self.jim.id,
163 group_id=self.cia.id,
164 )
165
166 # Creating an invalid membership
167 Membership.objects.create(
168 membership_country_id=self.soviet_union.id,
169 person_id=self.george.id,
170 group_id=self.cia.id,
171 )
172
173 self.assertQuerySetEqual(
174 Membership.objects.filter(person__in=[self.george, self.jim]),
175 [
176 self.jim.id,
177 ],
178 attrgetter("person_id"),
179 )
180 self.assertQuerySetEqual(
181 Membership.objects.filter(person__in=Person.objects.filter(name="Jim")),
182 [
183 self.jim.id,
184 ],
185 attrgetter("person_id"),
186 )
187
188 def test_double_nested_query(self):
189 m1 = Membership.objects.create(
190 membership_country_id=self.usa.id,
191 person_id=self.bob.id,
192 group_id=self.cia.id,
193 )
194 m2 = Membership.objects.create(
195 membership_country_id=self.usa.id,
196 person_id=self.jim.id,
197 group_id=self.cia.id,
198 )
199 Friendship.objects.create(
200 from_friend_country_id=self.usa.id,
201 from_friend_id=self.bob.id,
202 to_friend_country_id=self.usa.id,
203 to_friend_id=self.jim.id,
204 )
205 self.assertSequenceEqual(
206 Membership.objects.filter(
207 person__in=Person.objects.filter(
208 from_friend__in=Friendship.objects.filter(
209 to_friend__in=Person.objects.all()
210 )
211 )
212 ),
213 [m1],
214 )
215 self.assertSequenceEqual(
216 Membership.objects.exclude(
217 person__in=Person.objects.filter(
218 from_friend__in=Friendship.objects.filter(
219 to_friend__in=Person.objects.all()
220 )
221 )
222 ),
223 [m2],
224 )
225
226 def test_query_does_not_mutate(self):
227 """
228 Recompiling the same subquery doesn't mutate it.
229 """
230 queryset = Friendship.objects.filter(to_friend__in=Person.objects.all())
231 self.assertEqual(str(queryset.query), str(queryset.query))
232
233 def test_select_related_foreignkey_forward_works(self):
234 Membership.objects.create(
235 membership_country=self.usa, person=self.bob, group=self.cia
236 )
237 Membership.objects.create(
238 membership_country=self.usa, person=self.jim, group=self.democrat
239 )
240
241 with self.assertNumQueries(1):
242 people = [
243 m.person
244 for m in Membership.objects.select_related("person").order_by("pk")
245 ]
246
247 normal_people = [m.person for m in Membership.objects.order_by("pk")]
248 self.assertEqual(people, normal_people)
249
250 def test_prefetch_foreignobject_forward(self):
251 Membership.objects.create(
252 membership_country=self.usa, person=self.bob, group=self.cia
253 )
254 Membership.objects.create(
255 membership_country=self.usa, person=self.jim, group=self.democrat
256 )
257
258 with self.assertNumQueries(2):
259 people = [
260 m.person
261 for m in Membership.objects.prefetch_related("person").order_by("pk")
262 ]
263
264 normal_people = [m.person for m in Membership.objects.order_by("pk")]
265 self.assertEqual(people, normal_people)
266
267 def test_prefetch_foreignobject_hidden_forward(self):
268 Friendship.objects.create(
269 from_friend_country=self.usa,
270 from_friend_id=self.bob.id,
271 to_friend_country_id=self.usa.id,
272 to_friend_id=self.george.id,
273 )
274 Friendship.objects.create(
275 from_friend_country=self.usa,
276 from_friend_id=self.bob.id,
277 to_friend_country_id=self.soviet_union.id,
278 to_friend_id=self.sam.id,
279 )
280 with self.assertNumQueries(2) as ctx:
281 friendships = list(
282 Friendship.objects.prefetch_related("to_friend").order_by("pk")
283 )
284 prefetch_sql = ctx[-1]["sql"]
285 # Prefetch queryset should be filtered by all foreign related fields
286 # to prevent extra rows from being eagerly fetched.
287 prefetch_where_sql = prefetch_sql.split("WHERE")[-1]
288 for to_field_name in Friendship.to_friend.field.to_fields:
289 to_field = Person._meta.get_field(to_field_name)
290 with self.subTest(to_field=to_field):
291 self.assertIn(
292 connection.ops.quote_name(to_field.column),
293 prefetch_where_sql,
294 )
295 self.assertNotIn(" JOIN ", prefetch_sql)
296 with self.assertNumQueries(0):
297 self.assertEqual(friendships[0].to_friend, self.george)
298 self.assertEqual(friendships[1].to_friend, self.sam)
299
300 def test_prefetch_foreignobject_null_hidden_forward_skipped(self):
301 fiendship = Friendship.objects.create(
302 from_friend_country=self.usa,
303 from_friend_id=self.bob.id,
304 to_friend_country_id=self.usa.id,
305 to_friend_id=None,
306 )
307 with self.assertNumQueries(1):
308 self.assertEqual(
309 Friendship.objects.prefetch_related("to_friend").get(),
310 fiendship,
311 )
312
313 def test_prefetch_foreignobject_reverse(self):
314 Membership.objects.create(
315 membership_country=self.usa, person=self.bob, group=self.cia
316 )
317 Membership.objects.create(
318 membership_country=self.usa, person=self.jim, group=self.democrat
319 )
320 with self.assertNumQueries(2):
321 membership_sets = [
322 list(p.membership_set.all())
323 for p in Person.objects.prefetch_related("membership_set").order_by(
324 "pk"
325 )
326 ]
327
328 with self.assertNumQueries(7):
329 normal_membership_sets = [
330 list(p.membership_set.all()) for p in Person.objects.order_by("pk")
331 ]
332 self.assertEqual(membership_sets, normal_membership_sets)
333
334 def test_m2m_through_forward_returns_valid_members(self):
335 # We start out by making sure that the Group 'CIA' has no members.
336 self.assertQuerySetEqual(self.cia.members.all(), [])
337
338 Membership.objects.create(
339 membership_country=self.usa, person=self.bob, group=self.cia
340 )
341 Membership.objects.create(
342 membership_country=self.usa, person=self.jim, group=self.cia
343 )
344
345 # Bob and Jim should be members of the CIA.
346
347 self.assertQuerySetEqual(
348 self.cia.members.all(), ["Bob", "Jim"], attrgetter("name")
349 )
350
351 def test_m2m_through_reverse_returns_valid_members(self):
352 # We start out by making sure that Bob is in no groups.
353 self.assertQuerySetEqual(self.bob.groups.all(), [])
354
355 Membership.objects.create(
356 membership_country=self.usa, person=self.bob, group=self.cia
357 )
358 Membership.objects.create(
359 membership_country=self.usa, person=self.bob, group=self.republican
360 )
361
362 # Bob should be in the CIA and a Republican
363 self.assertQuerySetEqual(
364 self.bob.groups.all(), ["CIA", "Republican"], attrgetter("name")
365 )
366
367 def test_m2m_through_forward_ignores_invalid_members(self):
368 # We start out by making sure that the Group 'CIA' has no members.
369 self.assertQuerySetEqual(self.cia.members.all(), [])
370
371 # Something adds jane to group CIA but Jane is in Soviet Union which
372 # isn't CIA's country.
373 Membership.objects.create(
374 membership_country=self.usa, person=self.jane, group=self.cia
375 )
376
377 # There should still be no members in CIA
378 self.assertQuerySetEqual(self.cia.members.all(), [])
379
380 def test_m2m_through_reverse_ignores_invalid_members(self):
381 # We start out by making sure that Jane has no groups.
382 self.assertQuerySetEqual(self.jane.groups.all(), [])
383
384 # Something adds jane to group CIA but Jane is in Soviet Union which
385 # isn't CIA's country.
386 Membership.objects.create(
387 membership_country=self.usa, person=self.jane, group=self.cia
388 )
389
390 # Jane should still not be in any groups
391 self.assertQuerySetEqual(self.jane.groups.all(), [])
392
393 def test_m2m_through_on_self_works(self):
394 self.assertQuerySetEqual(self.jane.friends.all(), [])
395
396 Friendship.objects.create(
397 from_friend_country=self.jane.person_country,
398 from_friend=self.jane,
399 to_friend_country=self.george.person_country,
400 to_friend=self.george,
401 )
402
403 self.assertQuerySetEqual(
404 self.jane.friends.all(), ["George"], attrgetter("name")
405 )
406
407 def test_m2m_through_on_self_ignores_mismatch_columns(self):
408 self.assertQuerySetEqual(self.jane.friends.all(), [])
409
410 # Note that we use ids instead of instances. This is because instances
411 # on ForeignObject properties will set all related field off of the
412 # given instance.
413 Friendship.objects.create(
414 from_friend_id=self.jane.id,
415 to_friend_id=self.george.id,
416 to_friend_country_id=self.jane.person_country_id,
417 from_friend_country_id=self.george.person_country_id,
418 )
419
420 self.assertQuerySetEqual(self.jane.friends.all(), [])
421
422 def test_prefetch_related_m2m_forward_works(self):
423 Membership.objects.create(
424 membership_country=self.usa, person=self.bob, group=self.cia
425 )
426 Membership.objects.create(
427 membership_country=self.usa, person=self.jim, group=self.democrat
428 )
429
430 with self.assertNumQueries(2):
431 members_lists = [
432 list(g.members.all()) for g in Group.objects.prefetch_related("members")
433 ]
434
435 normal_members_lists = [list(g.members.all()) for g in Group.objects.all()]
436 self.assertEqual(members_lists, normal_members_lists)
437
438 def test_prefetch_related_m2m_reverse_works(self):
439 Membership.objects.create(
440 membership_country=self.usa, person=self.bob, group=self.cia
441 )
442 Membership.objects.create(
443 membership_country=self.usa, person=self.jim, group=self.democrat
444 )
445
446 with self.assertNumQueries(2):
447 groups_lists = [
448 list(p.groups.all()) for p in Person.objects.prefetch_related("groups")
449 ]
450
451 normal_groups_lists = [list(p.groups.all()) for p in Person.objects.all()]
452 self.assertEqual(groups_lists, normal_groups_lists)
453
454 @translation.override("fi")
455 def test_translations(self):
456 a1 = Article.objects.create(pub_date=datetime.date.today())
457 at1_fi = ArticleTranslation(
458 article=a1, lang="fi", title="Otsikko", body="Diipadaapa"
459 )
460 at1_fi.save()
461 at2_en = ArticleTranslation(
462 article=a1, lang="en", title="Title", body="Lalalalala"
463 )
464 at2_en.save()
465
466 self.assertEqual(Article.objects.get(pk=a1.pk).active_translation, at1_fi)
467
468 with self.assertNumQueries(1):
469 fetched = Article.objects.select_related("active_translation").get(
470 active_translation__title="Otsikko"
471 )
472 self.assertEqual(fetched.active_translation.title, "Otsikko")
473 a2 = Article.objects.create(pub_date=datetime.date.today())
474 at2_fi = ArticleTranslation(
475 article=a2, lang="fi", title="Atsikko", body="Diipadaapa", abstract="dipad"
476 )
477 at2_fi.save()
478 a3 = Article.objects.create(pub_date=datetime.date.today())
479 at3_en = ArticleTranslation(
480 article=a3, lang="en", title="A title", body="lalalalala", abstract="lala"
481 )
482 at3_en.save()
483 # Test model initialization with active_translation field.
484 a3 = Article(id=a3.id, pub_date=a3.pub_date, active_translation=at3_en)
485 a3.save()
486 self.assertEqual(
487 list(Article.objects.filter(active_translation__abstract=None)), [a1, a3]
488 )
489 self.assertEqual(
490 list(
491 Article.objects.filter(
492 active_translation__abstract=None,
493 active_translation__pk__isnull=False,
494 )
495 ),
496 [a1],
497 )
498
499 with translation.override("en"):
500 self.assertEqual(
501 list(Article.objects.filter(active_translation__abstract=None)),
502 [a1, a2],
503 )
504
505 def test_foreign_key_raises_informative_does_not_exist(self):
506 referrer = ArticleTranslation()
507 with self.assertRaisesMessage(
508 Article.DoesNotExist, "ArticleTranslation has no article"
509 ):
510 referrer.article
511
512 def test_foreign_key_related_query_name(self):
513 a1 = Article.objects.create(pub_date=datetime.date.today())
514 ArticleTag.objects.create(article=a1, name="foo")
515 self.assertEqual(Article.objects.filter(tag__name="foo").count(), 1)
516 self.assertEqual(Article.objects.filter(tag__name="bar").count(), 0)
517 msg = (
518 "Cannot resolve keyword 'tags' into field. Choices are: "
519 "active_translation, active_translation_q, articletranslation, "
520 "id, idea_things, newsarticle, pub_date, tag"
521 )
522 with self.assertRaisesMessage(FieldError, msg):
523 Article.objects.filter(tags__name="foo")
524
525 def test_many_to_many_related_query_name(self):
526 a1 = Article.objects.create(pub_date=datetime.date.today())
527 i1 = ArticleIdea.objects.create(name="idea1")
528 a1.ideas.add(i1)
529 self.assertEqual(Article.objects.filter(idea_things__name="idea1").count(), 1)
530 self.assertEqual(Article.objects.filter(idea_things__name="idea2").count(), 0)
531 msg = (
532 "Cannot resolve keyword 'ideas' into field. Choices are: "
533 "active_translation, active_translation_q, articletranslation, "
534 "id, idea_things, newsarticle, pub_date, tag"
535 )
536 with self.assertRaisesMessage(FieldError, msg):
537 Article.objects.filter(ideas__name="idea1")
538
539 @translation.override("fi")
540 def test_inheritance(self):
541 na = NewsArticle.objects.create(pub_date=datetime.date.today())
542 ArticleTranslation.objects.create(
543 article=na, lang="fi", title="foo", body="bar"
544 )
545 self.assertSequenceEqual(
546 NewsArticle.objects.select_related("active_translation"), [na]
547 )
548 with self.assertNumQueries(1):
549 self.assertEqual(
550 NewsArticle.objects.select_related("active_translation")[
551 0
552 ].active_translation.title,
553 "foo",
554 )
555
556 @skipUnlessDBFeature("has_bulk_insert")
557 def test_batch_create_foreign_object(self):
558 objs = [
559 Person(name="abcd_%s" % i, person_country=self.usa) for i in range(0, 5)
560 ]
561 Person.objects.bulk_create(objs, 10)
562
563 def test_isnull_lookup(self):
564 m1 = Membership.objects.create(
565 person_id=self.bob.id,
566 membership_country_id=self.usa.id,
567 group_id=None,
568 )
569 m2 = Membership.objects.create(
570 person_id=self.jim.id,
571 membership_country_id=None,
572 group_id=self.cia.id,
573 )
574 m3 = Membership.objects.create(
575 person_id=self.jane.id,
576 membership_country_id=None,
577 group_id=None,
578 )
579 m4 = Membership.objects.create(
580 person_id=self.george.id,
581 membership_country_id=self.soviet_union.id,
582 group_id=self.kgb.id,
583 )
584 for member in [m1, m2, m3]:
585 with self.assertRaises(Membership.group.RelatedObjectDoesNotExist):
586 getattr(member, "group")
587 self.assertSequenceEqual(
588 Membership.objects.filter(group__isnull=True),
589 [m1, m2, m3],
590 )
591 self.assertSequenceEqual(
592 Membership.objects.filter(group__isnull=False),
593 [m4],
594 )
595
596
597 class TestModelCheckTests(SimpleTestCase):
598 @isolate_apps("foreign_object")
599 def test_check_composite_foreign_object(self):
600 class Parent(models.Model):
601 a = models.PositiveIntegerField()
602 b = models.PositiveIntegerField()
603
604 class Meta:
605 unique_together = (("a", "b"),)
606
607 class Child(models.Model):
608 a = models.PositiveIntegerField()
609 b = models.PositiveIntegerField()
610 value = models.CharField(max_length=255)
611 parent = models.ForeignObject(
612 Parent,
613 on_delete=models.SET_NULL,
614 from_fields=("a", "b"),
615 to_fields=("a", "b"),
616 related_name="children",
617 )
618
619 self.assertEqual(Child._meta.get_field("parent").check(from_model=Child), [])
620
621 @isolate_apps("foreign_object")
622 def test_check_subset_composite_foreign_object(self):
623 class Parent(models.Model):
624 a = models.PositiveIntegerField()
625 b = models.PositiveIntegerField()
626 c = models.PositiveIntegerField()
627
628 class Meta:
629 unique_together = (("a", "b"),)
630
631 class Child(models.Model):
632 a = models.PositiveIntegerField()
633 b = models.PositiveIntegerField()
634 c = models.PositiveIntegerField()
635 d = models.CharField(max_length=255)
636 parent = models.ForeignObject(
637 Parent,
638 on_delete=models.SET_NULL,
639 from_fields=("a", "b", "c"),
640 to_fields=("a", "b", "c"),
641 related_name="children",
642 )
643
644 self.assertEqual(Child._meta.get_field("parent").check(from_model=Child), [])
645
646
647 class TestExtraJoinFilterQ(TestCase):
648 @translation.override("fi")
649 def test_extra_join_filter_q(self):
650 a = Article.objects.create(pub_date=datetime.datetime.today())
651 ArticleTranslation.objects.create(
652 article=a, lang="fi", title="title", body="body"
653 )
654 qs = Article.objects.all()
655 with self.assertNumQueries(2):
656 self.assertEqual(qs[0].active_translation_q.title, "title")
657 qs = qs.select_related("active_translation_q")
658 with self.assertNumQueries(1):
659 self.assertEqual(qs[0].active_translation_q.title, "title")
660
661
662 class TestCachedPathInfo(TestCase):
663 def test_equality(self):
664 """
665 The path_infos and reverse_path_infos attributes are equivalent to
666 calling the get_<method>() with no arguments.
667 """
668 foreign_object = Membership._meta.get_field("person")
669 self.assertEqual(
670 foreign_object.path_infos,
671 foreign_object.get_path_info(),
672 )
673 self.assertEqual(
674 foreign_object.reverse_path_infos,
675 foreign_object.get_reverse_path_info(),
676 )
677
678 def test_copy_removes_direct_cached_values(self):
679 """
680 Shallow copying a ForeignObject (or a ForeignObjectRel) removes the
681 object's direct cached PathInfo values.
682 """
683 foreign_object = Membership._meta.get_field("person")
684 # Trigger storage of cached_property into ForeignObject's __dict__.
685 foreign_object.path_infos
686 foreign_object.reverse_path_infos
687 # The ForeignObjectRel doesn't have reverse_path_infos.
688 foreign_object.remote_field.path_infos
689 self.assertIn("path_infos", foreign_object.__dict__)
690 self.assertIn("reverse_path_infos", foreign_object.__dict__)
691 self.assertIn("path_infos", foreign_object.remote_field.__dict__)
692 # Cached value is removed via __getstate__() on ForeignObjectRel
693 # because no __copy__() method exists, so __reduce_ex__() is used.
694 remote_field_copy = copy.copy(foreign_object.remote_field)
695 self.assertNotIn("path_infos", remote_field_copy.__dict__)
696 # Cached values are removed via __copy__() on ForeignObject for
697 # consistency of behavior.
698 foreign_object_copy = copy.copy(foreign_object)
699 self.assertNotIn("path_infos", foreign_object_copy.__dict__)
700 self.assertNotIn("reverse_path_infos", foreign_object_copy.__dict__)
701 # ForeignObjectRel's remains because it's part of a shallow copy.
702 self.assertIn("path_infos", foreign_object_copy.remote_field.__dict__)
703
704 def test_deepcopy_removes_cached_values(self):
705 """
706 Deep copying a ForeignObject removes the object's cached PathInfo
707 values, including those of the related ForeignObjectRel.
708 """
709 foreign_object = Membership._meta.get_field("person")
710 # Trigger storage of cached_property into ForeignObject's __dict__.
711 foreign_object.path_infos
712 foreign_object.reverse_path_infos
713 # The ForeignObjectRel doesn't have reverse_path_infos.
714 foreign_object.remote_field.path_infos
715 self.assertIn("path_infos", foreign_object.__dict__)
716 self.assertIn("reverse_path_infos", foreign_object.__dict__)
717 self.assertIn("path_infos", foreign_object.remote_field.__dict__)
718 # Cached value is removed via __getstate__() on ForeignObjectRel
719 # because no __deepcopy__() method exists, so __reduce_ex__() is used.
720 remote_field_copy = copy.deepcopy(foreign_object.remote_field)
721 self.assertNotIn("path_infos", remote_field_copy.__dict__)
722 # Field.__deepcopy__() internally uses __copy__() on both the
723 # ForeignObject and ForeignObjectRel, so all cached values are removed.
724 foreign_object_copy = copy.deepcopy(foreign_object)
725 self.assertNotIn("path_infos", foreign_object_copy.__dict__)
726 self.assertNotIn("reverse_path_infos", foreign_object_copy.__dict__)
727 self.assertNotIn("path_infos", foreign_object_copy.remote_field.__dict__)
728
729 def test_pickling_foreignobjectrel(self):
730 """
731 Pickling a ForeignObjectRel removes the path_infos attribute.
732
733 ForeignObjectRel implements __getstate__(), so copy and pickle modules
734 both use that, but ForeignObject implements __reduce__() and __copy__()
735 separately, so doesn't share the same behaviour.
736 """
737 foreign_object_rel = Membership._meta.get_field("person").remote_field
738 # Trigger storage of cached_property into ForeignObjectRel's __dict__.
739 foreign_object_rel.path_infos
740 self.assertIn("path_infos", foreign_object_rel.__dict__)
741 foreign_object_rel_restored = pickle.loads(pickle.dumps(foreign_object_rel))
742 self.assertNotIn("path_infos", foreign_object_rel_restored.__dict__)
743
744 def test_pickling_foreignobject(self):
745 """
746 Pickling a ForeignObject does not remove the cached PathInfo values.
747
748 ForeignObject will always keep the path_infos and reverse_path_infos
749 attributes within the same process, because of the way
750 Field.__reduce__() is used for restoring values.
751 """
752 foreign_object = Membership._meta.get_field("person")
753 # Trigger storage of cached_property into ForeignObjectRel's __dict__
754 foreign_object.path_infos
755 foreign_object.reverse_path_infos
756 self.assertIn("path_infos", foreign_object.__dict__)
757 self.assertIn("reverse_path_infos", foreign_object.__dict__)
758 foreign_object_restored = pickle.loads(pickle.dumps(foreign_object))
759 self.assertIn("path_infos", foreign_object_restored.__dict__)
760 self.assertIn("reverse_path_infos", foreign_object_restored.__dict__)
761
762
763 class GetJoiningDeprecationTests(TestCase):
764 def test_foreign_object_get_joining_columns_warning(self):
765 msg = (
766 "ForeignObject.get_joining_columns() is deprecated. Use "
767 "get_joining_fields() instead."
768 )
769 with self.assertWarnsMessage(RemovedInDjango60Warning, msg) as ctx:
770 Membership.person.field.get_joining_columns()
771 self.assertEqual(ctx.filename, __file__)
772
773 def test_foreign_object_get_reverse_joining_columns_warning(self):
774 msg = (
775 "ForeignObject.get_reverse_joining_columns() is deprecated. Use "
776 "get_reverse_joining_fields() instead."
777 )
778 with self.assertWarnsMessage(RemovedInDjango60Warning, msg) as ctx:
779 Membership.person.field.get_reverse_joining_columns()
780 self.assertEqual(ctx.filename, __file__)
781
782 def test_foreign_object_rel_get_joining_columns_warning(self):
783 msg = (
784 "ForeignObjectRel.get_joining_columns() is deprecated. Use "
785 "get_joining_fields() instead."
786 )
787 with self.assertWarnsMessage(RemovedInDjango60Warning, msg) as ctx:
788 Membership.person.field.remote_field.get_joining_columns()
789 self.assertEqual(ctx.filename, __file__)
790
791 def test_join_get_joining_columns_warning(self):
792 class CustomForeignKey(models.ForeignKey):
793 def __getattribute__(self, attr):
794 if attr == "get_joining_fields":
795 raise AttributeError
796 return super().__getattribute__(attr)
797
798 class CustomParent(models.Model):
799 value = models.CharField(max_length=255)
800
801 class CustomChild(models.Model):
802 links = CustomForeignKey(CustomParent, models.CASCADE)
803
804 msg = (
805 "The usage of get_joining_columns() in Join is deprecated. Implement "
806 "get_joining_fields() instead."
807 )
808 with self.assertWarnsMessage(RemovedInDjango60Warning, msg):
809 CustomChild.objects.filter(links__value="value")