| 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 |
) |