Debian Codegraph @

tests/many_to_one/tests.py

raw
1 import datetime
2 from copy import deepcopy
3
4 from django.core.exceptions import FieldError, MultipleObjectsReturned
5 from django.db import IntegrityError, models, transaction
6 from django.test import TestCase
7 from django.utils.deprecation import RemovedInDjango60Warning
8 from django.utils.translation import gettext_lazy
9
10 from .models import (
11 Article,
12 Category,
13 Child,
14 ChildNullableParent,
15 ChildStringPrimaryKeyParent,
16 City,
17 Country,
18 District,
19 First,
20 Parent,
21 ParentStringPrimaryKey,
22 Record,
23 Relation,
24 Reporter,
25 School,
26 Student,
27 Third,
28 ToFieldChild,
29 )
30
31
32 class ManyToOneTests(TestCase):
33 @classmethod
34 def setUpTestData(cls):
35 # Create a few Reporters.
36 cls.r = Reporter(first_name="John", last_name="Smith", email="[email protected]")
37 cls.r.save()
38 cls.r2 = Reporter(
39 first_name="Paul", last_name="Jones", email="[email protected]"
40 )
41 cls.r2.save()
42 # Create an Article.
43 cls.a = Article(
44 headline="This is a test",
45 pub_date=datetime.date(2005, 7, 27),
46 reporter=cls.r,
47 )
48 cls.a.save()
49
50 def test_get(self):
51 # Article objects have access to their related Reporter objects.
52 r = self.a.reporter
53 self.assertEqual(r.id, self.r.id)
54 self.assertEqual((r.first_name, self.r.last_name), ("John", "Smith"))
55
56 def test_create(self):
57 # You can also instantiate an Article by passing the Reporter's ID
58 # instead of a Reporter object.
59 a3 = Article(
60 headline="Third article",
61 pub_date=datetime.date(2005, 7, 27),
62 reporter_id=self.r.id,
63 )
64 a3.save()
65 self.assertEqual(a3.reporter.id, self.r.id)
66
67 # Similarly, the reporter ID can be a string.
68 a4 = Article(
69 headline="Fourth article",
70 pub_date=datetime.date(2005, 7, 27),
71 reporter_id=str(self.r.id),
72 )
73 a4.save()
74 self.assertEqual(repr(a4.reporter), "<Reporter: John Smith>")
75
76 def test_add(self):
77 # Create an Article via the Reporter object.
78 new_article = self.r.article_set.create(
79 headline="John's second story", pub_date=datetime.date(2005, 7, 29)
80 )
81 self.assertEqual(repr(new_article), "<Article: John's second story>")
82 self.assertEqual(new_article.reporter.id, self.r.id)
83
84 # Create a new article, and add it to the article set.
85 new_article2 = Article(
86 headline="Paul's story", pub_date=datetime.date(2006, 1, 17)
87 )
88 msg = (
89 "<Article: Paul's story> instance isn't saved. Use bulk=False or save the "
90 "object first."
91 )
92 with self.assertRaisesMessage(ValueError, msg):
93 self.r.article_set.add(new_article2)
94
95 self.r.article_set.add(new_article2, bulk=False)
96 self.assertEqual(new_article2.reporter.id, self.r.id)
97 self.assertSequenceEqual(
98 self.r.article_set.all(),
99 [new_article, new_article2, self.a],
100 )
101
102 # Add the same article to a different article set - check that it moves.
103 self.r2.article_set.add(new_article2)
104 self.assertEqual(new_article2.reporter.id, self.r2.id)
105 self.assertSequenceEqual(self.r2.article_set.all(), [new_article2])
106
107 # Adding an object of the wrong type raises TypeError.
108 with transaction.atomic():
109 with self.assertRaisesMessage(
110 TypeError, "'Article' instance expected, got <Reporter:"
111 ):
112 self.r.article_set.add(self.r2)
113 self.assertSequenceEqual(
114 self.r.article_set.all(),
115 [new_article, self.a],
116 )
117
118 def test_set(self):
119 new_article = self.r.article_set.create(
120 headline="John's second story", pub_date=datetime.date(2005, 7, 29)
121 )
122 new_article2 = self.r2.article_set.create(
123 headline="Paul's story", pub_date=datetime.date(2006, 1, 17)
124 )
125
126 # Assign the article to the reporter.
127 new_article2.reporter = self.r
128 new_article2.save()
129 self.assertEqual(repr(new_article2.reporter), "<Reporter: John Smith>")
130 self.assertEqual(new_article2.reporter.id, self.r.id)
131 self.assertSequenceEqual(
132 self.r.article_set.all(),
133 [new_article, new_article2, self.a],
134 )
135 self.assertSequenceEqual(self.r2.article_set.all(), [])
136
137 # Set the article back again.
138 self.r2.article_set.set([new_article, new_article2])
139 self.assertSequenceEqual(self.r.article_set.all(), [self.a])
140 self.assertSequenceEqual(
141 self.r2.article_set.all(),
142 [new_article, new_article2],
143 )
144
145 # Funny case - because the ForeignKey cannot be null,
146 # existing members of the set must remain.
147 self.r.article_set.set([new_article])
148 self.assertSequenceEqual(
149 self.r.article_set.all(),
150 [new_article, self.a],
151 )
152 self.assertSequenceEqual(self.r2.article_set.all(), [new_article2])
153
154 def test_reverse_assignment_deprecation(self):
155 msg = (
156 "Direct assignment to the reverse side of a related set is "
157 "prohibited. Use article_set.set() instead."
158 )
159 with self.assertRaisesMessage(TypeError, msg):
160 self.r2.article_set = []
161
162 def test_assign(self):
163 new_article = self.r.article_set.create(
164 headline="John's second story", pub_date=datetime.date(2005, 7, 29)
165 )
166 new_article2 = self.r2.article_set.create(
167 headline="Paul's story", pub_date=datetime.date(2006, 1, 17)
168 )
169
170 # Assign the article to the reporter directly using the descriptor.
171 new_article2.reporter = self.r
172 new_article2.save()
173 self.assertEqual(repr(new_article2.reporter), "<Reporter: John Smith>")
174 self.assertEqual(new_article2.reporter.id, self.r.id)
175 self.assertSequenceEqual(
176 self.r.article_set.all(),
177 [new_article, new_article2, self.a],
178 )
179 self.assertSequenceEqual(self.r2.article_set.all(), [])
180
181 # Set the article back again using set() method.
182 self.r2.article_set.set([new_article, new_article2])
183 self.assertSequenceEqual(self.r.article_set.all(), [self.a])
184 self.assertSequenceEqual(
185 self.r2.article_set.all(),
186 [new_article, new_article2],
187 )
188
189 # Because the ForeignKey cannot be null, existing members of the set
190 # must remain.
191 self.r.article_set.set([new_article])
192 self.assertSequenceEqual(
193 self.r.article_set.all(),
194 [new_article, self.a],
195 )
196 self.assertSequenceEqual(self.r2.article_set.all(), [new_article2])
197 # Reporter cannot be null - there should not be a clear or remove method
198 self.assertFalse(hasattr(self.r2.article_set, "remove"))
199 self.assertFalse(hasattr(self.r2.article_set, "clear"))
200
201 def test_assign_fk_id_value(self):
202 parent = Parent.objects.create(name="jeff")
203 child1 = Child.objects.create(name="frank", parent=parent)
204 child2 = Child.objects.create(name="randy", parent=parent)
205 parent.bestchild = child1
206 parent.save()
207 parent.bestchild_id = child2.pk
208 parent.save()
209 self.assertEqual(parent.bestchild_id, child2.pk)
210 self.assertFalse(Parent.bestchild.is_cached(parent))
211 self.assertEqual(parent.bestchild, child2)
212 self.assertTrue(Parent.bestchild.is_cached(parent))
213 # Reassigning the same value doesn't clear cached instance.
214 parent.bestchild_id = child2.pk
215 self.assertTrue(Parent.bestchild.is_cached(parent))
216
217 def test_assign_fk_id_none(self):
218 parent = Parent.objects.create(name="jeff")
219 child = Child.objects.create(name="frank", parent=parent)
220 parent.bestchild = child
221 parent.save()
222 parent.bestchild_id = None
223 parent.save()
224 self.assertIsNone(parent.bestchild_id)
225 self.assertFalse(Parent.bestchild.is_cached(parent))
226 self.assertIsNone(parent.bestchild)
227 self.assertTrue(Parent.bestchild.is_cached(parent))
228
229 def test_selects(self):
230 new_article1 = self.r.article_set.create(
231 headline="John's second story",
232 pub_date=datetime.date(2005, 7, 29),
233 )
234 new_article2 = self.r2.article_set.create(
235 headline="Paul's story",
236 pub_date=datetime.date(2006, 1, 17),
237 )
238 # Reporter objects have access to their related Article objects.
239 self.assertSequenceEqual(
240 self.r.article_set.all(),
241 [new_article1, self.a],
242 )
243 self.assertSequenceEqual(
244 self.r.article_set.filter(headline__startswith="This"), [self.a]
245 )
246 self.assertEqual(self.r.article_set.count(), 2)
247 self.assertEqual(self.r2.article_set.count(), 1)
248 # Get articles by id
249 self.assertSequenceEqual(Article.objects.filter(id__exact=self.a.id), [self.a])
250 self.assertSequenceEqual(Article.objects.filter(pk=self.a.id), [self.a])
251 # Query on an article property
252 self.assertSequenceEqual(
253 Article.objects.filter(headline__startswith="This"), [self.a]
254 )
255 # The API automatically follows relationships as far as you need.
256 # Use double underscores to separate relationships.
257 # This works as many levels deep as you want. There's no limit.
258 # Find all Articles for any Reporter whose first name is "John".
259 self.assertSequenceEqual(
260 Article.objects.filter(reporter__first_name__exact="John"),
261 [new_article1, self.a],
262 )
263 # Implied __exact also works
264 self.assertSequenceEqual(
265 Article.objects.filter(reporter__first_name="John"),
266 [new_article1, self.a],
267 )
268 # Query twice over the related field.
269 self.assertSequenceEqual(
270 Article.objects.filter(
271 reporter__first_name__exact="John", reporter__last_name__exact="Smith"
272 ),
273 [new_article1, self.a],
274 )
275 # The underlying query only makes one join when a related table is
276 # referenced twice.
277 queryset = Article.objects.filter(
278 reporter__first_name__exact="John", reporter__last_name__exact="Smith"
279 )
280 self.assertNumQueries(1, list, queryset)
281 self.assertEqual(
282 queryset.query.get_compiler(queryset.db).as_sql()[0].count("INNER JOIN"), 1
283 )
284
285 # The automatically joined table has a predictable name.
286 self.assertSequenceEqual(
287 Article.objects.filter(reporter__first_name__exact="John").extra(
288 where=["many_to_one_reporter.last_name='Smith'"]
289 ),
290 [new_article1, self.a],
291 )
292 # ... and should work fine with the string that comes out of
293 # forms.Form.cleaned_data.
294 self.assertQuerySetEqual(
295 (
296 Article.objects.filter(reporter__first_name__exact="John").extra(
297 where=["many_to_one_reporter.last_name='%s'" % "Smith"]
298 )
299 ),
300 [new_article1, self.a],
301 )
302 # Find all Articles for a Reporter.
303 # Use direct ID check, pk check, and object comparison
304 self.assertSequenceEqual(
305 Article.objects.filter(reporter__id__exact=self.r.id),
306 [new_article1, self.a],
307 )
308 self.assertSequenceEqual(
309 Article.objects.filter(reporter__pk=self.r.id),
310 [new_article1, self.a],
311 )
312 self.assertSequenceEqual(
313 Article.objects.filter(reporter=self.r.id),
314 [new_article1, self.a],
315 )
316 self.assertSequenceEqual(
317 Article.objects.filter(reporter=self.r),
318 [new_article1, self.a],
319 )
320 self.assertSequenceEqual(
321 Article.objects.filter(reporter__in=[self.r.id, self.r2.id]).distinct(),
322 [new_article1, new_article2, self.a],
323 )
324 self.assertSequenceEqual(
325 Article.objects.filter(reporter__in=[self.r, self.r2]).distinct(),
326 [new_article1, new_article2, self.a],
327 )
328 # You can also use a queryset instead of a literal list of instances.
329 # The queryset must be reduced to a list of values using values(),
330 # then converted into a query
331 self.assertSequenceEqual(
332 Article.objects.filter(
333 reporter__in=Reporter.objects.filter(first_name="John")
334 .values("pk")
335 .query
336 ).distinct(),
337 [new_article1, self.a],
338 )
339
340 def test_reverse_selects(self):
341 a3 = Article.objects.create(
342 headline="Third article",
343 pub_date=datetime.date(2005, 7, 27),
344 reporter_id=self.r.id,
345 )
346 Article.objects.create(
347 headline="Fourth article",
348 pub_date=datetime.date(2005, 7, 27),
349 reporter_id=self.r.id,
350 )
351 john_smith = [self.r]
352 # Reporters can be queried
353 self.assertSequenceEqual(
354 Reporter.objects.filter(id__exact=self.r.id), john_smith
355 )
356 self.assertSequenceEqual(Reporter.objects.filter(pk=self.r.id), john_smith)
357 self.assertSequenceEqual(
358 Reporter.objects.filter(first_name__startswith="John"), john_smith
359 )
360 # Reporters can query in opposite direction of ForeignKey definition
361 self.assertSequenceEqual(
362 Reporter.objects.filter(article__id__exact=self.a.id), john_smith
363 )
364 self.assertSequenceEqual(
365 Reporter.objects.filter(article__pk=self.a.id), john_smith
366 )
367 self.assertSequenceEqual(Reporter.objects.filter(article=self.a.id), john_smith)
368 self.assertSequenceEqual(Reporter.objects.filter(article=self.a), john_smith)
369 self.assertSequenceEqual(
370 Reporter.objects.filter(article__in=[self.a.id, a3.id]).distinct(),
371 john_smith,
372 )
373 self.assertSequenceEqual(
374 Reporter.objects.filter(article__in=[self.a.id, a3]).distinct(), john_smith
375 )
376 self.assertSequenceEqual(
377 Reporter.objects.filter(article__in=[self.a, a3]).distinct(), john_smith
378 )
379 self.assertCountEqual(
380 Reporter.objects.filter(article__headline__startswith="T"),
381 [self.r, self.r],
382 )
383 self.assertSequenceEqual(
384 Reporter.objects.filter(article__headline__startswith="T").distinct(),
385 john_smith,
386 )
387
388 # Counting in the opposite direction works in conjunction with distinct()
389 self.assertEqual(
390 Reporter.objects.filter(article__headline__startswith="T").count(), 2
391 )
392 self.assertEqual(
393 Reporter.objects.filter(article__headline__startswith="T")
394 .distinct()
395 .count(),
396 1,
397 )
398
399 # Queries can go round in circles.
400 self.assertCountEqual(
401 Reporter.objects.filter(article__reporter__first_name__startswith="John"),
402 [self.r, self.r, self.r],
403 )
404 self.assertSequenceEqual(
405 Reporter.objects.filter(
406 article__reporter__first_name__startswith="John"
407 ).distinct(),
408 john_smith,
409 )
410 self.assertSequenceEqual(
411 Reporter.objects.filter(article__reporter__exact=self.r).distinct(),
412 john_smith,
413 )
414
415 # Implied __exact also works.
416 self.assertSequenceEqual(
417 Reporter.objects.filter(article__reporter=self.r).distinct(), john_smith
418 )
419
420 # It's possible to use values() calls across many-to-one relations.
421 # (Note, too, that we clear the ordering here so as not to drag the
422 # 'headline' field into the columns being used to determine uniqueness)
423 d = {"reporter__first_name": "John", "reporter__last_name": "Smith"}
424 qs = (
425 Article.objects.filter(
426 reporter=self.r,
427 )
428 .distinct()
429 .order_by()
430 .values("reporter__first_name", "reporter__last_name")
431 )
432 self.assertEqual([d], list(qs))
433
434 def test_select_related(self):
435 # Article.objects.select_related().dates() works properly when there
436 # are multiple Articles with the same date but different foreign-key
437 # objects (Reporters).
438 r1 = Reporter.objects.create(
439 first_name="Mike", last_name="Royko", email="[email protected]"
440 )
441 r2 = Reporter.objects.create(
442 first_name="John", last_name="Kass", email="[email protected]"
443 )
444 Article.objects.create(
445 headline="First", pub_date=datetime.date(1980, 4, 23), reporter=r1
446 )
447 Article.objects.create(
448 headline="Second", pub_date=datetime.date(1980, 4, 23), reporter=r2
449 )
450 self.assertEqual(
451 list(Article.objects.select_related().dates("pub_date", "day")),
452 [datetime.date(1980, 4, 23), datetime.date(2005, 7, 27)],
453 )
454 self.assertEqual(
455 list(Article.objects.select_related().dates("pub_date", "month")),
456 [datetime.date(1980, 4, 1), datetime.date(2005, 7, 1)],
457 )
458 self.assertEqual(
459 list(Article.objects.select_related().dates("pub_date", "year")),
460 [datetime.date(1980, 1, 1), datetime.date(2005, 1, 1)],
461 )
462
463 def test_delete(self):
464 new_article1 = self.r.article_set.create(
465 headline="John's second story",
466 pub_date=datetime.date(2005, 7, 29),
467 )
468 new_article2 = self.r2.article_set.create(
469 headline="Paul's story",
470 pub_date=datetime.date(2006, 1, 17),
471 )
472 new_article3 = Article.objects.create(
473 headline="Third article",
474 pub_date=datetime.date(2005, 7, 27),
475 reporter_id=self.r.id,
476 )
477 new_article4 = Article.objects.create(
478 headline="Fourth article",
479 pub_date=datetime.date(2005, 7, 27),
480 reporter_id=str(self.r.id),
481 )
482 # If you delete a reporter, their articles will be deleted.
483 self.assertSequenceEqual(
484 Article.objects.all(),
485 [new_article4, new_article1, new_article2, new_article3, self.a],
486 )
487 self.assertSequenceEqual(
488 Reporter.objects.order_by("first_name"),
489 [self.r, self.r2],
490 )
491 self.r2.delete()
492 self.assertSequenceEqual(
493 Article.objects.all(),
494 [new_article4, new_article1, new_article3, self.a],
495 )
496 self.assertSequenceEqual(Reporter.objects.order_by("first_name"), [self.r])
497 # You can delete using a JOIN in the query.
498 Reporter.objects.filter(article__headline__startswith="This").delete()
499 self.assertSequenceEqual(Reporter.objects.all(), [])
500 self.assertSequenceEqual(Article.objects.all(), [])
501
502 def test_explicit_fk(self):
503 # Create a new Article with get_or_create using an explicit value
504 # for a ForeignKey.
505 a2, created = Article.objects.get_or_create(
506 headline="John's second test",
507 pub_date=datetime.date(2011, 5, 7),
508 reporter_id=self.r.id,
509 )
510 self.assertTrue(created)
511 self.assertEqual(a2.reporter.id, self.r.id)
512
513 # You can specify filters containing the explicit FK value.
514 self.assertSequenceEqual(
515 Article.objects.filter(reporter_id__exact=self.r.id),
516 [a2, self.a],
517 )
518
519 # Create an Article by Paul for the same date.
520 a3 = Article.objects.create(
521 headline="Paul's commentary",
522 pub_date=datetime.date(2011, 5, 7),
523 reporter_id=self.r2.id,
524 )
525 self.assertEqual(a3.reporter.id, self.r2.id)
526
527 # Get should respect explicit foreign keys as well.
528 msg = "get() returned more than one Article -- it returned 2!"
529 with self.assertRaisesMessage(MultipleObjectsReturned, msg):
530 Article.objects.get(reporter_id=self.r.id)
531 self.assertEqual(
532 repr(a3),
533 repr(
534 Article.objects.get(
535 reporter_id=self.r2.id, pub_date=datetime.date(2011, 5, 7)
536 )
537 ),
538 )
539
540 def test_deepcopy_and_circular_references(self):
541 # Regression for #12876 -- Model methods that include queries that
542 # recursive don't cause recursion depth problems under deepcopy.
543 self.r.cached_query = Article.objects.filter(reporter=self.r)
544 self.assertEqual(repr(deepcopy(self.r)), "<Reporter: John Smith>")
545
546 def test_manager_class_caching(self):
547 r1 = Reporter.objects.create(first_name="Mike")
548 r2 = Reporter.objects.create(first_name="John")
549
550 # Same twice
551 self.assertIs(r1.article_set.__class__, r1.article_set.__class__)
552
553 # Same as each other
554 self.assertIs(r1.article_set.__class__, r2.article_set.__class__)
555
556 def test_create_relation_with_gettext_lazy(self):
557 reporter = Reporter.objects.create(
558 first_name="John", last_name="Smith", email="[email protected]"
559 )
560 lazy = gettext_lazy("test")
561 reporter.article_set.create(headline=lazy, pub_date=datetime.date(2011, 6, 10))
562 notlazy = str(lazy)
563 article = reporter.article_set.get()
564 self.assertEqual(article.headline, notlazy)
565
566 def test_values_list_exception(self):
567 expected_message = (
568 "Cannot resolve keyword 'notafield' into field. Choices are: %s"
569 )
570 reporter_fields = ", ".join(sorted(f.name for f in Reporter._meta.get_fields()))
571 with self.assertRaisesMessage(FieldError, expected_message % reporter_fields):
572 Article.objects.values_list("reporter__notafield")
573 article_fields = ", ".join(
574 ["EXTRA"] + sorted(f.name for f in Article._meta.get_fields())
575 )
576 with self.assertRaisesMessage(FieldError, expected_message % article_fields):
577 Article.objects.extra(select={"EXTRA": "EXTRA_SELECT"}).values_list(
578 "notafield"
579 )
580
581 def test_fk_assignment_and_related_object_cache(self):
582 # Tests of ForeignKey assignment and the related-object cache (see #6886).
583
584 p = Parent.objects.create(name="Parent")
585 c = Child.objects.create(name="Child", parent=p)
586
587 # Look up the object again so that we get a "fresh" object.
588 c = Child.objects.get(name="Child")
589 p = c.parent
590
591 # Accessing the related object again returns the exactly same object.
592 self.assertIs(c.parent, p)
593
594 # But if we kill the cache, we get a new object.
595 del c._state.fields_cache["parent"]
596 self.assertIsNot(c.parent, p)
597
598 # Assigning a new object results in that object getting cached immediately.
599 p2 = Parent.objects.create(name="Parent 2")
600 c.parent = p2
601 self.assertIs(c.parent, p2)
602
603 # Assigning None succeeds if field is null=True.
604 p.bestchild = None
605 self.assertIsNone(p.bestchild)
606
607 # bestchild should still be None after saving.
608 p.save()
609 self.assertIsNone(p.bestchild)
610
611 # bestchild should still be None after fetching the object again.
612 p = Parent.objects.get(name="Parent")
613 self.assertIsNone(p.bestchild)
614
615 # Assigning None will not fail: Child.parent is null=False.
616 setattr(c, "parent", None)
617
618 # You also can't assign an object of the wrong type here
619 msg = (
620 'Cannot assign "<First: First object (1)>": "Child.parent" must '
621 'be a "Parent" instance.'
622 )
623 with self.assertRaisesMessage(ValueError, msg):
624 setattr(c, "parent", First(id=1, second=1))
625
626 # You can assign None to Child.parent during object creation.
627 Child(name="xyzzy", parent=None)
628
629 # But when trying to save a Child with parent=None, the database will
630 # raise IntegrityError.
631 with self.assertRaises(IntegrityError), transaction.atomic():
632 Child.objects.create(name="xyzzy", parent=None)
633
634 # Creation using keyword argument should cache the related object.
635 p = Parent.objects.get(name="Parent")
636 c = Child(parent=p)
637 self.assertIs(c.parent, p)
638
639 # Creation using keyword argument and unsaved related instance (#8070).
640 p = Parent()
641 msg = (
642 "save() prohibited to prevent data loss due to unsaved related object "
643 "'parent'."
644 )
645 with self.assertRaisesMessage(ValueError, msg):
646 Child.objects.create(parent=p)
647
648 with self.assertRaisesMessage(ValueError, msg):
649 ToFieldChild.objects.create(parent=p)
650
651 # Creation using attname keyword argument and an id will cause the
652 # related object to be fetched.
653 p = Parent.objects.get(name="Parent")
654 c = Child(parent_id=p.id)
655 self.assertIsNot(c.parent, p)
656 self.assertEqual(c.parent, p)
657
658 def test_save_parent_after_assign(self):
659 category = Category(name="cats")
660 record = Record(category=category)
661 category.save()
662 record.save()
663 category.name = "dogs"
664 with self.assertNumQueries(0):
665 self.assertEqual(category.id, record.category_id)
666 self.assertEqual(category.name, record.category.name)
667
668 def test_save_nullable_fk_after_parent(self):
669 parent = Parent()
670 child = ChildNullableParent(parent=parent)
671 parent.save()
672 child.save()
673 child.refresh_from_db()
674 self.assertEqual(child.parent, parent)
675
676 def test_save_nullable_fk_after_parent_with_to_field(self):
677 parent = Parent(name="jeff")
678 child = ToFieldChild(parent=parent)
679 parent.save()
680 child.save()
681 child.refresh_from_db()
682 self.assertEqual(child.parent, parent)
683 self.assertEqual(child.parent_id, parent.name)
684
685 def test_save_fk_after_parent_with_non_numeric_pk_set_on_child(self):
686 parent = ParentStringPrimaryKey()
687 child = ChildStringPrimaryKeyParent(parent=parent)
688 child.parent.name = "jeff"
689 parent.save()
690 child.save()
691 child.refresh_from_db()
692 self.assertEqual(child.parent, parent)
693 self.assertEqual(child.parent_id, parent.name)
694
695 def test_fk_to_bigautofield(self):
696 ch = City.objects.create(name="Chicago")
697 District.objects.create(city=ch, name="Far South")
698 District.objects.create(city=ch, name="North")
699
700 ny = City.objects.create(name="New York", id=2**33)
701 District.objects.create(city=ny, name="Brooklyn")
702 District.objects.create(city=ny, name="Manhattan")
703
704 def test_fk_to_smallautofield(self):
705 us = Country.objects.create(name="United States")
706 City.objects.create(country=us, name="Chicago")
707 City.objects.create(country=us, name="New York")
708
709 uk = Country.objects.create(name="United Kingdom", id=2**11)
710 City.objects.create(country=uk, name="London")
711 City.objects.create(country=uk, name="Edinburgh")
712
713 def test_multiple_foreignkeys(self):
714 # Test of multiple ForeignKeys to the same model (bug #7125).
715 c1 = Category.objects.create(name="First")
716 c2 = Category.objects.create(name="Second")
717 c3 = Category.objects.create(name="Third")
718 r1 = Record.objects.create(category=c1)
719 r2 = Record.objects.create(category=c1)
720 r3 = Record.objects.create(category=c2)
721 r4 = Record.objects.create(category=c2)
722 r5 = Record.objects.create(category=c3)
723 Relation.objects.create(left=r1, right=r2)
724 Relation.objects.create(left=r3, right=r4)
725 rel = Relation.objects.create(left=r1, right=r3)
726 Relation.objects.create(left=r5, right=r2)
727 Relation.objects.create(left=r3, right=r2)
728
729 q1 = Relation.objects.filter(
730 left__category__name__in=["First"], right__category__name__in=["Second"]
731 )
732 self.assertSequenceEqual(q1, [rel])
733
734 q2 = Category.objects.filter(
735 record__left_set__right__category__name="Second"
736 ).order_by("name")
737 self.assertSequenceEqual(q2, [c1, c2])
738
739 p = Parent.objects.create(name="Parent")
740 c = Child.objects.create(name="Child", parent=p)
741 msg = 'Cannot assign "%r": "Child.parent" must be a "Parent" instance.' % c
742 with self.assertRaisesMessage(ValueError, msg):
743 Child.objects.create(name="Grandchild", parent=c)
744
745 def test_fk_instantiation_outside_model(self):
746 # Regression for #12190 -- Should be able to instantiate a FK outside
747 # of a model, and interrogate its related field.
748 cat = models.ForeignKey(Category, models.CASCADE)
749 self.assertEqual("id", cat.remote_field.get_related_field().name)
750
751 def test_relation_unsaved(self):
752 Third.objects.create(name="Third 1")
753 Third.objects.create(name="Third 2")
754 th = Third(name="testing")
755 # The object isn't saved and the relation cannot be used.
756 msg = (
757 "'Third' instance needs to have a primary key value before this "
758 "relationship can be used."
759 )
760 with self.assertRaisesMessage(ValueError, msg):
761 th.child_set.count()
762 # The reverse foreign key manager can be created.
763 self.assertEqual(th.child_set.model, Third)
764
765 th.save()
766 # Now the model is saved, so we will need to execute a query.
767 with self.assertNumQueries(1):
768 self.assertEqual(th.child_set.count(), 0)
769
770 def test_related_object(self):
771 public_school = School.objects.create(is_public=True)
772 public_student = Student.objects.create(school=public_school)
773
774 private_school = School.objects.create(is_public=False)
775 private_student = Student.objects.create(school=private_school)
776
777 # Only one school is available via all() due to the custom default manager.
778 self.assertSequenceEqual(School.objects.all(), [public_school])
779
780 self.assertEqual(public_student.school, public_school)
781
782 # Make sure the base manager is used so that a student can still access
783 # its related school even if the default manager doesn't normally
784 # allow it.
785 self.assertEqual(private_student.school, private_school)
786
787 School._meta.base_manager_name = "objects"
788 School._meta._expire_cache()
789 try:
790 private_student = Student.objects.get(pk=private_student.pk)
791 with self.assertRaises(School.DoesNotExist):
792 private_student.school
793 finally:
794 School._meta.base_manager_name = None
795 School._meta._expire_cache()
796
797 def test_hasattr_related_object(self):
798 # The exception raised on attribute access when a related object
799 # doesn't exist should be an instance of a subclass of `AttributeError`
800 # refs #21563
801 self.assertFalse(hasattr(Article(), "reporter"))
802
803 def test_create_after_prefetch(self):
804 c = City.objects.create(name="Musical City")
805 d1 = District.objects.create(name="Ladida", city=c)
806 city = City.objects.prefetch_related("districts").get(id=c.id)
807 self.assertSequenceEqual(city.districts.all(), [d1])
808 d2 = city.districts.create(name="Goa")
809 self.assertSequenceEqual(city.districts.all(), [d1, d2])
810
811 def test_clear_after_prefetch(self):
812 c = City.objects.create(name="Musical City")
813 d = District.objects.create(name="Ladida", city=c)
814 city = City.objects.prefetch_related("districts").get(id=c.id)
815 self.assertSequenceEqual(city.districts.all(), [d])
816 city.districts.clear()
817 self.assertSequenceEqual(city.districts.all(), [])
818
819 def test_remove_after_prefetch(self):
820 c = City.objects.create(name="Musical City")
821 d = District.objects.create(name="Ladida", city=c)
822 city = City.objects.prefetch_related("districts").get(id=c.id)
823 self.assertSequenceEqual(city.districts.all(), [d])
824 city.districts.remove(d)
825 self.assertSequenceEqual(city.districts.all(), [])
826
827 def test_add_after_prefetch(self):
828 c = City.objects.create(name="Musical City")
829 District.objects.create(name="Ladida", city=c)
830 d2 = District.objects.create(name="Ladidu")
831 city = City.objects.prefetch_related("districts").get(id=c.id)
832 self.assertEqual(city.districts.count(), 1)
833 city.districts.add(d2)
834 self.assertEqual(city.districts.count(), 2)
835
836 def test_set_after_prefetch(self):
837 c = City.objects.create(name="Musical City")
838 District.objects.create(name="Ladida", city=c)
839 d2 = District.objects.create(name="Ladidu")
840 city = City.objects.prefetch_related("districts").get(id=c.id)
841 self.assertEqual(city.districts.count(), 1)
842 city.districts.set([d2])
843 self.assertSequenceEqual(city.districts.all(), [d2])
844
845 def test_add_then_remove_after_prefetch(self):
846 c = City.objects.create(name="Musical City")
847 District.objects.create(name="Ladida", city=c)
848 d2 = District.objects.create(name="Ladidu")
849 city = City.objects.prefetch_related("districts").get(id=c.id)
850 self.assertEqual(city.districts.count(), 1)
851 city.districts.add(d2)
852 self.assertEqual(city.districts.count(), 2)
853 city.districts.remove(d2)
854 self.assertEqual(city.districts.count(), 1)
855
856 def test_cached_relation_invalidated_on_save(self):
857 """
858 Model.save() invalidates stale ForeignKey relations after a primary key
859 assignment.
860 """
861 self.assertEqual(self.a.reporter, self.r) # caches a.reporter
862 self.a.reporter_id = self.r2.pk
863 self.a.save()
864 self.assertEqual(self.a.reporter, self.r2)
865
866 def test_cached_foreign_key_with_to_field_not_cleared_by_save(self):
867 parent = Parent.objects.create(name="a")
868 child = ToFieldChild.objects.create(parent=parent)
869 with self.assertNumQueries(0):
870 self.assertIs(child.parent, parent)
871
872 def test_reverse_foreign_key_instance_to_field_caching(self):
873 parent = Parent.objects.create(name="a")
874 ToFieldChild.objects.create(parent=parent)
875 child = parent.to_field_children.get()
876 with self.assertNumQueries(0):
877 self.assertIs(child.parent, parent)
878
879 def test_add_remove_set_by_pk_raises(self):
880 usa = Country.objects.create(name="United States")
881 chicago = City.objects.create(name="Chicago")
882 msg = "'City' instance expected, got %s" % chicago.pk
883 with self.assertRaisesMessage(TypeError, msg):
884 usa.cities.add(chicago.pk)
885 with self.assertRaisesMessage(TypeError, msg):
886 usa.cities.remove(chicago.pk)
887 with self.assertRaisesMessage(TypeError, msg):
888 usa.cities.set([chicago.pk])
889
890 def test_get_prefetch_queryset_warning(self):
891 City.objects.create(name="Chicago")
892 cities = City.objects.all()
893 msg = (
894 "get_prefetch_queryset() is deprecated. Use get_prefetch_querysets() "
895 "instead."
896 )
897 with self.assertWarnsMessage(RemovedInDjango60Warning, msg) as ctx:
898 City.country.get_prefetch_queryset(cities)
899 self.assertEqual(ctx.filename, __file__)
900
901 def test_get_prefetch_queryset_reverse_warning(self):
902 usa = Country.objects.create(name="United States")
903 City.objects.create(name="Chicago")
904 countries = Country.objects.all()
905 msg = (
906 "get_prefetch_queryset() is deprecated. Use get_prefetch_querysets() "
907 "instead."
908 )
909 with self.assertWarnsMessage(RemovedInDjango60Warning, msg) as ctx:
910 usa.cities.get_prefetch_queryset(countries)
911 self.assertEqual(ctx.filename, __file__)
912
913 def test_get_prefetch_querysets_invalid_querysets_length(self):
914 City.objects.create(name="Chicago")
915 cities = City.objects.all()
916 msg = (
917 "querysets argument of get_prefetch_querysets() should have a length of 1."
918 )
919 with self.assertRaisesMessage(ValueError, msg):
920 City.country.get_prefetch_querysets(
921 instances=cities,
922 querysets=[Country.objects.all(), Country.objects.all()],
923 )
924
925 def test_get_prefetch_querysets_reverse_invalid_querysets_length(self):
926 usa = Country.objects.create(name="United States")
927 City.objects.create(name="Chicago")
928 countries = Country.objects.all()
929 msg = (
930 "querysets argument of get_prefetch_querysets() should have a length of 1."
931 )
932 with self.assertRaisesMessage(ValueError, msg):
933 usa.cities.get_prefetch_querysets(
934 instances=countries,
935 querysets=[City.objects.all(), City.objects.all()],
936 )