Debian Codegraph @

tests/one_to_one/tests.py

raw
1 from django.db import IntegrityError, connection, transaction
2 from django.test import TestCase
3 from django.utils.deprecation import RemovedInDjango60Warning
4
5 from .models import (
6 Bar,
7 Director,
8 Favorites,
9 HiddenPointer,
10 ManualPrimaryKey,
11 MultiModel,
12 Place,
13 Pointer,
14 RelatedModel,
15 Restaurant,
16 School,
17 Target,
18 ToFieldPointer,
19 UndergroundBar,
20 Waiter,
21 )
22
23
24 class OneToOneTests(TestCase):
25 @classmethod
26 def setUpTestData(cls):
27 cls.p1 = Place.objects.create(name="Demon Dogs", address="944 W. Fullerton")
28 cls.p2 = Place.objects.create(name="Ace Hardware", address="1013 N. Ashland")
29 cls.r1 = Restaurant.objects.create(
30 place=cls.p1, serves_hot_dogs=True, serves_pizza=False
31 )
32 cls.b1 = Bar.objects.create(place=cls.p1, serves_cocktails=False)
33
34 def test_getter(self):
35 # A Restaurant can access its place.
36 self.assertEqual(repr(self.r1.place), "<Place: Demon Dogs the place>")
37 # A Place can access its restaurant, if available.
38 self.assertEqual(
39 repr(self.p1.restaurant), "<Restaurant: Demon Dogs the restaurant>"
40 )
41 # p2 doesn't have an associated restaurant.
42 with self.assertRaisesMessage(
43 Restaurant.DoesNotExist, "Place has no restaurant"
44 ):
45 self.p2.restaurant
46 # The exception raised on attribute access when a related object
47 # doesn't exist should be an instance of a subclass of `AttributeError`
48 # refs #21563
49 self.assertFalse(hasattr(self.p2, "restaurant"))
50
51 def test_setter(self):
52 # Set the place using assignment notation. Because place is the primary
53 # key on Restaurant, the save will create a new restaurant
54 self.r1.place = self.p2
55 self.r1.save()
56 self.assertEqual(
57 repr(self.p2.restaurant), "<Restaurant: Ace Hardware the restaurant>"
58 )
59 self.assertEqual(repr(self.r1.place), "<Place: Ace Hardware the place>")
60 self.assertEqual(self.p2.pk, self.r1.pk)
61 # Set the place back again, using assignment in the reverse direction.
62 self.p1.restaurant = self.r1
63 self.assertEqual(
64 repr(self.p1.restaurant), "<Restaurant: Demon Dogs the restaurant>"
65 )
66 r = Restaurant.objects.get(pk=self.p1.id)
67 self.assertEqual(repr(r.place), "<Place: Demon Dogs the place>")
68
69 def test_manager_all(self):
70 # Restaurant.objects.all() just returns the Restaurants, not the Places.
71 self.assertSequenceEqual(Restaurant.objects.all(), [self.r1])
72 # Place.objects.all() returns all Places, regardless of whether they
73 # have Restaurants.
74 self.assertSequenceEqual(Place.objects.order_by("name"), [self.p2, self.p1])
75
76 def test_manager_get(self):
77 def assert_get_restaurant(**params):
78 self.assertEqual(
79 repr(Restaurant.objects.get(**params)),
80 "<Restaurant: Demon Dogs the restaurant>",
81 )
82
83 assert_get_restaurant(place__id__exact=self.p1.pk)
84 assert_get_restaurant(place__id=self.p1.pk)
85 assert_get_restaurant(place__exact=self.p1.pk)
86 assert_get_restaurant(place__exact=self.p1)
87 assert_get_restaurant(place=self.p1.pk)
88 assert_get_restaurant(place=self.p1)
89 assert_get_restaurant(pk=self.p1.pk)
90 assert_get_restaurant(place__pk__exact=self.p1.pk)
91 assert_get_restaurant(place__pk=self.p1.pk)
92 assert_get_restaurant(place__name__startswith="Demon")
93
94 def assert_get_place(**params):
95 self.assertEqual(
96 repr(Place.objects.get(**params)), "<Place: Demon Dogs the place>"
97 )
98
99 assert_get_place(restaurant__place__exact=self.p1.pk)
100 assert_get_place(restaurant__place__exact=self.p1)
101 assert_get_place(restaurant__place__pk=self.p1.pk)
102 assert_get_place(restaurant__exact=self.p1.pk)
103 assert_get_place(restaurant__exact=self.r1)
104 assert_get_place(restaurant__pk=self.p1.pk)
105 assert_get_place(restaurant=self.p1.pk)
106 assert_get_place(restaurant=self.r1)
107 assert_get_place(id__exact=self.p1.pk)
108 assert_get_place(pk=self.p1.pk)
109
110 def test_foreign_key(self):
111 # Add a Waiter to the Restaurant.
112 w = self.r1.waiter_set.create(name="Joe")
113 self.assertEqual(
114 repr(w), "<Waiter: Joe the waiter at Demon Dogs the restaurant>"
115 )
116
117 # Query the waiters
118 def assert_filter_waiters(**params):
119 self.assertSequenceEqual(Waiter.objects.filter(**params), [w])
120
121 assert_filter_waiters(restaurant__place__exact=self.p1.pk)
122 assert_filter_waiters(restaurant__place__exact=self.p1)
123 assert_filter_waiters(restaurant__place__pk=self.p1.pk)
124 assert_filter_waiters(restaurant__exact=self.r1.pk)
125 assert_filter_waiters(restaurant__exact=self.r1)
126 assert_filter_waiters(restaurant__pk=self.r1.pk)
127 assert_filter_waiters(restaurant=self.r1.pk)
128 assert_filter_waiters(restaurant=self.r1)
129 assert_filter_waiters(id__exact=w.pk)
130 assert_filter_waiters(pk=w.pk)
131 # Delete the restaurant; the waiter should also be removed
132 r = Restaurant.objects.get(pk=self.r1.pk)
133 r.delete()
134 self.assertEqual(Waiter.objects.count(), 0)
135
136 def test_multiple_o2o(self):
137 # One-to-one fields still work if you create your own primary key
138 o1 = ManualPrimaryKey(primary_key="abc123", name="primary")
139 o1.save()
140 o2 = RelatedModel(link=o1, name="secondary")
141 o2.save()
142
143 # You can have multiple one-to-one fields on a model, too.
144 x1 = MultiModel(link1=self.p1, link2=o1, name="x1")
145 x1.save()
146 self.assertEqual(repr(o1.multimodel), "<MultiModel: Multimodel x1>")
147 # This will fail because each one-to-one field must be unique (and
148 # link2=o1 was used for x1, above).
149 mm = MultiModel(link1=self.p2, link2=o1, name="x1")
150 with self.assertRaises(IntegrityError):
151 with transaction.atomic():
152 mm.save()
153
154 def test_unsaved_object(self):
155 """
156 #10811 -- Assigning an unsaved object to a OneToOneField
157 should raise an exception.
158 """
159 place = Place(name="User", address="London")
160 with self.assertRaises(Restaurant.DoesNotExist):
161 place.restaurant
162 msg = (
163 "save() prohibited to prevent data loss due to unsaved related object "
164 "'place'."
165 )
166 with self.assertRaisesMessage(ValueError, msg):
167 Restaurant.objects.create(
168 place=place, serves_hot_dogs=True, serves_pizza=False
169 )
170 # place should not cache restaurant
171 with self.assertRaises(Restaurant.DoesNotExist):
172 place.restaurant
173
174 def test_reverse_relationship_cache_cascade(self):
175 """
176 Regression test for #9023: accessing the reverse relationship shouldn't
177 result in a cascading delete().
178 """
179 bar = UndergroundBar.objects.create(place=self.p1, serves_cocktails=False)
180
181 # The bug in #9023: if you access the one-to-one relation *before*
182 # setting to None and deleting, the cascade happens anyway.
183 self.p1.undergroundbar
184 bar.place.name = "foo"
185 bar.place = None
186 bar.save()
187 self.p1.delete()
188
189 self.assertEqual(Place.objects.count(), 1)
190 self.assertEqual(UndergroundBar.objects.count(), 1)
191
192 def test_create_models_m2m(self):
193 """
194 Models are created via the m2m relation if the remote model has a
195 OneToOneField (#1064, #1506).
196 """
197 f = Favorites(name="Fred")
198 f.save()
199 f.restaurants.set([self.r1])
200 self.assertSequenceEqual(f.restaurants.all(), [self.r1])
201
202 def test_reverse_object_cache(self):
203 """
204 The name of the cache for the reverse object is correct (#7173).
205 """
206 self.assertEqual(self.p1.restaurant, self.r1)
207 self.assertEqual(self.p1.bar, self.b1)
208
209 def test_assign_none_reverse_relation(self):
210 p = Place.objects.get(name="Demon Dogs")
211 # Assigning None succeeds if field is null=True.
212 ug_bar = UndergroundBar.objects.create(place=p, serves_cocktails=False)
213 p.undergroundbar = None
214 self.assertIsNone(ug_bar.place)
215 ug_bar.save()
216 ug_bar.refresh_from_db()
217 self.assertIsNone(ug_bar.place)
218
219 def test_assign_none_null_reverse_relation(self):
220 p = Place.objects.get(name="Demon Dogs")
221 # Assigning None doesn't throw AttributeError if there isn't a related
222 # UndergroundBar.
223 p.undergroundbar = None
224
225 def test_assign_none_to_null_cached_reverse_relation(self):
226 p = Place.objects.get(name="Demon Dogs")
227 # Prime the relation's cache with a value of None.
228 with self.assertRaises(Place.undergroundbar.RelatedObjectDoesNotExist):
229 getattr(p, "undergroundbar")
230 # Assigning None works if there isn't a related UndergroundBar and the
231 # reverse cache has a value of None.
232 p.undergroundbar = None
233
234 def test_assign_o2o_id_value(self):
235 b = UndergroundBar.objects.create(place=self.p1)
236 b.place_id = self.p2.pk
237 b.save()
238 self.assertEqual(b.place_id, self.p2.pk)
239 self.assertFalse(UndergroundBar.place.is_cached(b))
240 self.assertEqual(b.place, self.p2)
241 self.assertTrue(UndergroundBar.place.is_cached(b))
242 # Reassigning the same value doesn't clear a cached instance.
243 b.place_id = self.p2.pk
244 self.assertTrue(UndergroundBar.place.is_cached(b))
245
246 def test_assign_o2o_id_none(self):
247 b = UndergroundBar.objects.create(place=self.p1)
248 b.place_id = None
249 b.save()
250 self.assertIsNone(b.place_id)
251 self.assertFalse(UndergroundBar.place.is_cached(b))
252 self.assertIsNone(b.place)
253 self.assertTrue(UndergroundBar.place.is_cached(b))
254
255 def test_related_object_cache(self):
256 """Regression test for #6886 (the related-object cache)"""
257
258 # Look up the objects again so that we get "fresh" objects
259 p = Place.objects.get(name="Demon Dogs")
260 r = p.restaurant
261
262 # Accessing the related object again returns the exactly same object
263 self.assertIs(p.restaurant, r)
264
265 # But if we kill the cache, we get a new object
266 del p._state.fields_cache["restaurant"]
267 self.assertIsNot(p.restaurant, r)
268
269 # Reassigning the Restaurant object results in an immediate cache update
270 # We can't use a new Restaurant because that'll violate one-to-one, but
271 # with a new *instance* the is test below will fail if #6886 regresses.
272 r2 = Restaurant.objects.get(pk=r.pk)
273 p.restaurant = r2
274 self.assertIs(p.restaurant, r2)
275
276 # Assigning None succeeds if field is null=True.
277 ug_bar = UndergroundBar.objects.create(place=p, serves_cocktails=False)
278 ug_bar.place = None
279 self.assertIsNone(ug_bar.place)
280
281 # Assigning None will not fail: Place.restaurant is null=False
282 setattr(p, "restaurant", None)
283
284 # You also can't assign an object of the wrong type here
285 msg = (
286 'Cannot assign "<Place: Demon Dogs the place>": '
287 '"Place.restaurant" must be a "Restaurant" instance.'
288 )
289 with self.assertRaisesMessage(ValueError, msg):
290 setattr(p, "restaurant", p)
291
292 # Creation using keyword argument should cache the related object.
293 p = Place.objects.get(name="Demon Dogs")
294 r = Restaurant(place=p)
295 self.assertIs(r.place, p)
296
297 # Creation using keyword argument and unsaved related instance (#8070).
298 p = Place()
299 r = Restaurant(place=p)
300 self.assertIs(r.place, p)
301
302 # Creation using attname keyword argument and an id will cause the related
303 # object to be fetched.
304 p = Place.objects.get(name="Demon Dogs")
305 r = Restaurant(place_id=p.id)
306 self.assertIsNot(r.place, p)
307 self.assertEqual(r.place, p)
308
309 def test_filter_one_to_one_relations(self):
310 """
311 Regression test for #9968
312
313 filtering reverse one-to-one relations with primary_key=True was
314 misbehaving. We test both (primary_key=True & False) cases here to
315 prevent any reappearance of the problem.
316 """
317 target = Target.objects.create()
318 self.assertSequenceEqual(Target.objects.filter(pointer=None), [target])
319 self.assertSequenceEqual(Target.objects.exclude(pointer=None), [])
320 self.assertSequenceEqual(Target.objects.filter(second_pointer=None), [target])
321 self.assertSequenceEqual(Target.objects.exclude(second_pointer=None), [])
322
323 def test_o2o_primary_key_delete(self):
324 t = Target.objects.create(name="name")
325 Pointer.objects.create(other=t)
326 num_deleted, objs = Pointer.objects.filter(other__name="name").delete()
327 self.assertEqual(num_deleted, 1)
328 self.assertEqual(objs, {"one_to_one.Pointer": 1})
329
330 def test_save_nullable_o2o_after_parent(self):
331 place = Place(name="Rose tattoo")
332 bar = UndergroundBar(place=place)
333 place.save()
334 bar.save()
335 bar.refresh_from_db()
336 self.assertEqual(bar.place, place)
337
338 def test_reverse_object_does_not_exist_cache(self):
339 """
340 Regression for #13839 and #17439.
341
342 DoesNotExist on a reverse one-to-one relation is cached.
343 """
344 p = Place(name="Zombie Cats", address="Not sure")
345 p.save()
346 with self.assertNumQueries(1):
347 with self.assertRaises(Restaurant.DoesNotExist):
348 p.restaurant
349 with self.assertNumQueries(0):
350 with self.assertRaises(Restaurant.DoesNotExist):
351 p.restaurant
352
353 def test_reverse_object_cached_when_related_is_accessed(self):
354 """
355 Regression for #13839 and #17439.
356
357 The target of a one-to-one relation is cached
358 when the origin is accessed through the reverse relation.
359 """
360 # Use a fresh object without caches
361 r = Restaurant.objects.get(pk=self.r1.pk)
362 p = r.place
363 with self.assertNumQueries(0):
364 self.assertEqual(p.restaurant, r)
365
366 def test_related_object_cached_when_reverse_is_accessed(self):
367 """
368 Regression for #13839 and #17439.
369
370 The origin of a one-to-one relation is cached
371 when the target is accessed through the reverse relation.
372 """
373 # Use a fresh object without caches
374 p = Place.objects.get(pk=self.p1.pk)
375 r = p.restaurant
376 with self.assertNumQueries(0):
377 self.assertEqual(r.place, p)
378
379 def test_reverse_object_cached_when_related_is_set(self):
380 """
381 Regression for #13839 and #17439.
382
383 The target of a one-to-one relation is always cached.
384 """
385 p = Place(name="Zombie Cats", address="Not sure")
386 p.save()
387 self.r1.place = p
388 self.r1.save()
389 with self.assertNumQueries(0):
390 self.assertEqual(p.restaurant, self.r1)
391
392 def test_reverse_object_cached_when_related_is_unset(self):
393 """
394 Regression for #13839 and #17439.
395
396 The target of a one-to-one relation is always cached.
397 """
398 b = UndergroundBar(place=self.p1, serves_cocktails=True)
399 b.save()
400 with self.assertNumQueries(0):
401 self.assertEqual(self.p1.undergroundbar, b)
402 b.place = None
403 b.save()
404 with self.assertNumQueries(0):
405 with self.assertRaises(UndergroundBar.DoesNotExist):
406 self.p1.undergroundbar
407
408 def test_get_reverse_on_unsaved_object(self):
409 """
410 Regression for #18153 and #19089.
411
412 Accessing the reverse relation on an unsaved object
413 always raises an exception.
414 """
415 p = Place()
416
417 # When there's no instance of the origin of the one-to-one
418 with self.assertNumQueries(0):
419 with self.assertRaises(UndergroundBar.DoesNotExist):
420 p.undergroundbar
421
422 UndergroundBar.objects.create()
423
424 # When there's one instance of the origin
425 # (p.undergroundbar used to return that instance)
426 with self.assertNumQueries(0):
427 with self.assertRaises(UndergroundBar.DoesNotExist):
428 p.undergroundbar
429
430 # Several instances of the origin are only possible if database allows
431 # inserting multiple NULL rows for a unique constraint
432 if connection.features.supports_nullable_unique_constraints:
433 UndergroundBar.objects.create()
434
435 # When there are several instances of the origin
436 with self.assertNumQueries(0):
437 with self.assertRaises(UndergroundBar.DoesNotExist):
438 p.undergroundbar
439
440 def test_set_reverse_on_unsaved_object(self):
441 """
442 Writing to the reverse relation on an unsaved object
443 is impossible too.
444 """
445 p = Place()
446 b = UndergroundBar.objects.create()
447
448 # Assigning a reverse relation on an unsaved object is allowed.
449 p.undergroundbar = b
450
451 # However saving the object is not allowed.
452 msg = (
453 "save() prohibited to prevent data loss due to unsaved related object "
454 "'place'."
455 )
456 with self.assertNumQueries(0):
457 with self.assertRaisesMessage(ValueError, msg):
458 b.save()
459
460 def test_nullable_o2o_delete(self):
461 u = UndergroundBar.objects.create(place=self.p1)
462 u.place_id = None
463 u.save()
464 self.p1.delete()
465 self.assertTrue(UndergroundBar.objects.filter(pk=u.pk).exists())
466 self.assertIsNone(UndergroundBar.objects.get(pk=u.pk).place)
467
468 def test_hidden_accessor(self):
469 """
470 When a '+' ending related name is specified no reverse accessor should
471 be added to the related model.
472 """
473 self.assertFalse(
474 hasattr(
475 Target,
476 HiddenPointer._meta.get_field("target").remote_field.accessor_name,
477 )
478 )
479
480 def test_related_object(self):
481 public_school = School.objects.create(is_public=True)
482 public_director = Director.objects.create(school=public_school, is_temp=False)
483
484 private_school = School.objects.create(is_public=False)
485 private_director = Director.objects.create(school=private_school, is_temp=True)
486
487 # Only one school is available via all() due to the custom default manager.
488 self.assertSequenceEqual(School.objects.all(), [public_school])
489
490 # Only one director is available via all() due to the custom default manager.
491 self.assertSequenceEqual(Director.objects.all(), [public_director])
492
493 self.assertEqual(public_director.school, public_school)
494 self.assertEqual(public_school.director, public_director)
495
496 # Make sure the base manager is used so that the related objects
497 # is still accessible even if the default manager doesn't normally
498 # allow it.
499 self.assertEqual(private_director.school, private_school)
500
501 # Make sure the base manager is used so that an student can still access
502 # its related school even if the default manager doesn't normally
503 # allow it.
504 self.assertEqual(private_school.director, private_director)
505
506 School._meta.base_manager_name = "objects"
507 School._meta._expire_cache()
508 try:
509 private_director = Director._base_manager.get(pk=private_director.pk)
510 with self.assertRaises(School.DoesNotExist):
511 private_director.school
512 finally:
513 School._meta.base_manager_name = None
514 School._meta._expire_cache()
515
516 Director._meta.base_manager_name = "objects"
517 Director._meta._expire_cache()
518 try:
519 private_school = School._base_manager.get(pk=private_school.pk)
520 with self.assertRaises(Director.DoesNotExist):
521 private_school.director
522 finally:
523 Director._meta.base_manager_name = None
524 Director._meta._expire_cache()
525
526 def test_create_reverse_o2o_error(self):
527 msg = "The following fields do not exist in this model: restaurant"
528 with self.assertRaisesMessage(ValueError, msg):
529 Place.objects.create(restaurant=self.r1)
530
531 def test_get_or_create_reverse_o2o_error(self):
532 msg = "The following fields do not exist in this model: restaurant"
533 r2 = Restaurant.objects.create(
534 place=self.p2, serves_hot_dogs=True, serves_pizza=False
535 )
536 with self.assertRaisesMessage(ValueError, msg):
537 Place.objects.get_or_create(name="nonexistent", defaults={"restaurant": r2})
538
539 def test_update_or_create_reverse_o2o_error(self):
540 msg = "The following fields do not exist in this model: restaurant"
541 r2 = Restaurant.objects.create(
542 place=self.p2, serves_hot_dogs=True, serves_pizza=False
543 )
544 with self.assertRaisesMessage(ValueError, msg):
545 Place.objects.update_or_create(
546 name="nonexistent", defaults={"restaurant": r2}
547 )
548
549 def test_hasattr_related_object(self):
550 # The exception raised on attribute access when a related object
551 # doesn't exist should be an instance of a subclass of `AttributeError`
552 # refs #21563
553 self.assertFalse(hasattr(Director(), "director"))
554 self.assertFalse(hasattr(School(), "school"))
555
556 def test_update_one_to_one_pk(self):
557 p1 = Place.objects.create()
558 p2 = Place.objects.create()
559 r1 = Restaurant.objects.create(place=p1)
560 r2 = Restaurant.objects.create(place=p2)
561 w = Waiter.objects.create(restaurant=r1)
562
563 Waiter.objects.update(restaurant=r2)
564 w.refresh_from_db()
565 self.assertEqual(w.restaurant, r2)
566
567 def test_rel_pk_subquery(self):
568 r = Restaurant.objects.first()
569 q1 = Restaurant.objects.filter(place_id=r.pk)
570 # Subquery using primary key and a query against the
571 # same model works correctly.
572 q2 = Restaurant.objects.filter(place_id__in=q1)
573 self.assertSequenceEqual(q2, [r])
574 # Subquery using 'pk__in' instead of 'place_id__in' work, too.
575 q2 = Restaurant.objects.filter(
576 pk__in=Restaurant.objects.filter(place__id=r.place.pk)
577 )
578 self.assertSequenceEqual(q2, [r])
579 q3 = Restaurant.objects.filter(place__in=Place.objects.all())
580 self.assertSequenceEqual(q3, [r])
581 q4 = Restaurant.objects.filter(place__in=Place.objects.filter(id=r.pk))
582 self.assertSequenceEqual(q4, [r])
583
584 def test_rel_pk_exact(self):
585 r = Restaurant.objects.first()
586 r2 = Restaurant.objects.filter(pk__exact=r).first()
587 self.assertEqual(r, r2)
588
589 def test_primary_key_to_field_filter(self):
590 target = Target.objects.create(name="foo")
591 pointer = ToFieldPointer.objects.create(target=target)
592 self.assertSequenceEqual(
593 ToFieldPointer.objects.filter(target=target), [pointer]
594 )
595 self.assertSequenceEqual(
596 ToFieldPointer.objects.filter(pk__exact=pointer), [pointer]
597 )
598
599 def test_cached_relation_invalidated_on_save(self):
600 """
601 Model.save() invalidates stale OneToOneField relations after a primary
602 key assignment.
603 """
604 self.assertEqual(self.b1.place, self.p1) # caches b1.place
605 self.b1.place_id = self.p2.pk
606 self.b1.save()
607 self.assertEqual(self.b1.place, self.p2)
608
609 def test_get_prefetch_queryset_warning(self):
610 places = Place.objects.all()
611 msg = (
612 "get_prefetch_queryset() is deprecated. Use get_prefetch_querysets() "
613 "instead."
614 )
615 with self.assertWarnsMessage(RemovedInDjango60Warning, msg) as ctx:
616 Place.bar.get_prefetch_queryset(places)
617 self.assertEqual(ctx.filename, __file__)
618
619 def test_get_prefetch_querysets_invalid_querysets_length(self):
620 places = Place.objects.all()
621 msg = (
622 "querysets argument of get_prefetch_querysets() should have a length of 1."
623 )
624 with self.assertRaisesMessage(ValueError, msg):
625 Place.bar.get_prefetch_querysets(
626 instances=places,
627 querysets=[Bar.objects.all(), Bar.objects.all()],
628 )