mirror of
https://github.com/django/django.git
synced 2024-12-23 01:25:58 +00:00
847f46e9bf
Most QuerySet methods are mapped onto the Manager and, in general, it isn't necessary to call .all() on the manager.
586 lines
22 KiB
Python
586 lines
22 KiB
Python
from django.db import IntegrityError, connection, transaction
|
|
from django.test import TestCase
|
|
|
|
from .models import (
|
|
Bar,
|
|
Director,
|
|
Favorites,
|
|
HiddenPointer,
|
|
ManualPrimaryKey,
|
|
MultiModel,
|
|
Place,
|
|
Pointer,
|
|
RelatedModel,
|
|
Restaurant,
|
|
School,
|
|
Target,
|
|
ToFieldPointer,
|
|
UndergroundBar,
|
|
Waiter,
|
|
)
|
|
|
|
|
|
class OneToOneTests(TestCase):
|
|
@classmethod
|
|
def setUpTestData(cls):
|
|
cls.p1 = Place.objects.create(name="Demon Dogs", address="944 W. Fullerton")
|
|
cls.p2 = Place.objects.create(name="Ace Hardware", address="1013 N. Ashland")
|
|
cls.r1 = Restaurant.objects.create(
|
|
place=cls.p1, serves_hot_dogs=True, serves_pizza=False
|
|
)
|
|
cls.b1 = Bar.objects.create(place=cls.p1, serves_cocktails=False)
|
|
|
|
def test_getter(self):
|
|
# A Restaurant can access its place.
|
|
self.assertEqual(repr(self.r1.place), "<Place: Demon Dogs the place>")
|
|
# A Place can access its restaurant, if available.
|
|
self.assertEqual(
|
|
repr(self.p1.restaurant), "<Restaurant: Demon Dogs the restaurant>"
|
|
)
|
|
# p2 doesn't have an associated restaurant.
|
|
with self.assertRaisesMessage(
|
|
Restaurant.DoesNotExist, "Place has no restaurant"
|
|
):
|
|
self.p2.restaurant
|
|
# The exception raised on attribute access when a related object
|
|
# doesn't exist should be an instance of a subclass of `AttributeError`
|
|
# refs #21563
|
|
self.assertFalse(hasattr(self.p2, "restaurant"))
|
|
|
|
def test_setter(self):
|
|
# Set the place using assignment notation. Because place is the primary
|
|
# key on Restaurant, the save will create a new restaurant
|
|
self.r1.place = self.p2
|
|
self.r1.save()
|
|
self.assertEqual(
|
|
repr(self.p2.restaurant), "<Restaurant: Ace Hardware the restaurant>"
|
|
)
|
|
self.assertEqual(repr(self.r1.place), "<Place: Ace Hardware the place>")
|
|
self.assertEqual(self.p2.pk, self.r1.pk)
|
|
# Set the place back again, using assignment in the reverse direction.
|
|
self.p1.restaurant = self.r1
|
|
self.assertEqual(
|
|
repr(self.p1.restaurant), "<Restaurant: Demon Dogs the restaurant>"
|
|
)
|
|
r = Restaurant.objects.get(pk=self.p1.id)
|
|
self.assertEqual(repr(r.place), "<Place: Demon Dogs the place>")
|
|
|
|
def test_manager_all(self):
|
|
# Restaurant.objects.all() just returns the Restaurants, not the Places.
|
|
self.assertSequenceEqual(Restaurant.objects.all(), [self.r1])
|
|
# Place.objects.all() returns all Places, regardless of whether they
|
|
# have Restaurants.
|
|
self.assertSequenceEqual(Place.objects.order_by("name"), [self.p2, self.p1])
|
|
|
|
def test_manager_get(self):
|
|
def assert_get_restaurant(**params):
|
|
self.assertEqual(
|
|
repr(Restaurant.objects.get(**params)),
|
|
"<Restaurant: Demon Dogs the restaurant>",
|
|
)
|
|
|
|
assert_get_restaurant(place__id__exact=self.p1.pk)
|
|
assert_get_restaurant(place__id=self.p1.pk)
|
|
assert_get_restaurant(place__exact=self.p1.pk)
|
|
assert_get_restaurant(place__exact=self.p1)
|
|
assert_get_restaurant(place=self.p1.pk)
|
|
assert_get_restaurant(place=self.p1)
|
|
assert_get_restaurant(pk=self.p1.pk)
|
|
assert_get_restaurant(place__pk__exact=self.p1.pk)
|
|
assert_get_restaurant(place__pk=self.p1.pk)
|
|
assert_get_restaurant(place__name__startswith="Demon")
|
|
|
|
def assert_get_place(**params):
|
|
self.assertEqual(
|
|
repr(Place.objects.get(**params)), "<Place: Demon Dogs the place>"
|
|
)
|
|
|
|
assert_get_place(restaurant__place__exact=self.p1.pk)
|
|
assert_get_place(restaurant__place__exact=self.p1)
|
|
assert_get_place(restaurant__place__pk=self.p1.pk)
|
|
assert_get_place(restaurant__exact=self.p1.pk)
|
|
assert_get_place(restaurant__exact=self.r1)
|
|
assert_get_place(restaurant__pk=self.p1.pk)
|
|
assert_get_place(restaurant=self.p1.pk)
|
|
assert_get_place(restaurant=self.r1)
|
|
assert_get_place(id__exact=self.p1.pk)
|
|
assert_get_place(pk=self.p1.pk)
|
|
|
|
def test_foreign_key(self):
|
|
# Add a Waiter to the Restaurant.
|
|
w = self.r1.waiter_set.create(name="Joe")
|
|
self.assertEqual(
|
|
repr(w), "<Waiter: Joe the waiter at Demon Dogs the restaurant>"
|
|
)
|
|
|
|
# Query the waiters
|
|
def assert_filter_waiters(**params):
|
|
self.assertSequenceEqual(Waiter.objects.filter(**params), [w])
|
|
|
|
assert_filter_waiters(restaurant__place__exact=self.p1.pk)
|
|
assert_filter_waiters(restaurant__place__exact=self.p1)
|
|
assert_filter_waiters(restaurant__place__pk=self.p1.pk)
|
|
assert_filter_waiters(restaurant__exact=self.r1.pk)
|
|
assert_filter_waiters(restaurant__exact=self.r1)
|
|
assert_filter_waiters(restaurant__pk=self.r1.pk)
|
|
assert_filter_waiters(restaurant=self.r1.pk)
|
|
assert_filter_waiters(restaurant=self.r1)
|
|
assert_filter_waiters(id__exact=w.pk)
|
|
assert_filter_waiters(pk=w.pk)
|
|
# Delete the restaurant; the waiter should also be removed
|
|
r = Restaurant.objects.get(pk=self.r1.pk)
|
|
r.delete()
|
|
self.assertEqual(Waiter.objects.count(), 0)
|
|
|
|
def test_multiple_o2o(self):
|
|
# One-to-one fields still work if you create your own primary key
|
|
o1 = ManualPrimaryKey(primary_key="abc123", name="primary")
|
|
o1.save()
|
|
o2 = RelatedModel(link=o1, name="secondary")
|
|
o2.save()
|
|
|
|
# You can have multiple one-to-one fields on a model, too.
|
|
x1 = MultiModel(link1=self.p1, link2=o1, name="x1")
|
|
x1.save()
|
|
self.assertEqual(repr(o1.multimodel), "<MultiModel: Multimodel x1>")
|
|
# This will fail because each one-to-one field must be unique (and
|
|
# link2=o1 was used for x1, above).
|
|
mm = MultiModel(link1=self.p2, link2=o1, name="x1")
|
|
with self.assertRaises(IntegrityError):
|
|
with transaction.atomic():
|
|
mm.save()
|
|
|
|
def test_unsaved_object(self):
|
|
"""
|
|
#10811 -- Assigning an unsaved object to a OneToOneField
|
|
should raise an exception.
|
|
"""
|
|
place = Place(name="User", address="London")
|
|
with self.assertRaises(Restaurant.DoesNotExist):
|
|
place.restaurant
|
|
msg = (
|
|
"save() prohibited to prevent data loss due to unsaved related object "
|
|
"'place'."
|
|
)
|
|
with self.assertRaisesMessage(ValueError, msg):
|
|
Restaurant.objects.create(
|
|
place=place, serves_hot_dogs=True, serves_pizza=False
|
|
)
|
|
# place should not cache restaurant
|
|
with self.assertRaises(Restaurant.DoesNotExist):
|
|
place.restaurant
|
|
|
|
def test_reverse_relationship_cache_cascade(self):
|
|
"""
|
|
Regression test for #9023: accessing the reverse relationship shouldn't
|
|
result in a cascading delete().
|
|
"""
|
|
bar = UndergroundBar.objects.create(place=self.p1, serves_cocktails=False)
|
|
|
|
# The bug in #9023: if you access the one-to-one relation *before*
|
|
# setting to None and deleting, the cascade happens anyway.
|
|
self.p1.undergroundbar
|
|
bar.place.name = "foo"
|
|
bar.place = None
|
|
bar.save()
|
|
self.p1.delete()
|
|
|
|
self.assertEqual(Place.objects.count(), 1)
|
|
self.assertEqual(UndergroundBar.objects.count(), 1)
|
|
|
|
def test_create_models_m2m(self):
|
|
"""
|
|
Models are created via the m2m relation if the remote model has a
|
|
OneToOneField (#1064, #1506).
|
|
"""
|
|
f = Favorites(name="Fred")
|
|
f.save()
|
|
f.restaurants.set([self.r1])
|
|
self.assertSequenceEqual(f.restaurants.all(), [self.r1])
|
|
|
|
def test_reverse_object_cache(self):
|
|
"""
|
|
The name of the cache for the reverse object is correct (#7173).
|
|
"""
|
|
self.assertEqual(self.p1.restaurant, self.r1)
|
|
self.assertEqual(self.p1.bar, self.b1)
|
|
|
|
def test_assign_none_reverse_relation(self):
|
|
p = Place.objects.get(name="Demon Dogs")
|
|
# Assigning None succeeds if field is null=True.
|
|
ug_bar = UndergroundBar.objects.create(place=p, serves_cocktails=False)
|
|
p.undergroundbar = None
|
|
self.assertIsNone(ug_bar.place)
|
|
ug_bar.save()
|
|
ug_bar.refresh_from_db()
|
|
self.assertIsNone(ug_bar.place)
|
|
|
|
def test_assign_none_null_reverse_relation(self):
|
|
p = Place.objects.get(name="Demon Dogs")
|
|
# Assigning None doesn't throw AttributeError if there isn't a related
|
|
# UndergroundBar.
|
|
p.undergroundbar = None
|
|
|
|
def test_assign_none_to_null_cached_reverse_relation(self):
|
|
p = Place.objects.get(name="Demon Dogs")
|
|
# Prime the relation's cache with a value of None.
|
|
with self.assertRaises(Place.undergroundbar.RelatedObjectDoesNotExist):
|
|
getattr(p, "undergroundbar")
|
|
# Assigning None works if there isn't a related UndergroundBar and the
|
|
# reverse cache has a value of None.
|
|
p.undergroundbar = None
|
|
|
|
def test_assign_o2o_id_value(self):
|
|
b = UndergroundBar.objects.create(place=self.p1)
|
|
b.place_id = self.p2.pk
|
|
b.save()
|
|
self.assertEqual(b.place_id, self.p2.pk)
|
|
self.assertFalse(UndergroundBar.place.is_cached(b))
|
|
self.assertEqual(b.place, self.p2)
|
|
self.assertTrue(UndergroundBar.place.is_cached(b))
|
|
# Reassigning the same value doesn't clear a cached instance.
|
|
b.place_id = self.p2.pk
|
|
self.assertTrue(UndergroundBar.place.is_cached(b))
|
|
|
|
def test_assign_o2o_id_none(self):
|
|
b = UndergroundBar.objects.create(place=self.p1)
|
|
b.place_id = None
|
|
b.save()
|
|
self.assertIsNone(b.place_id)
|
|
self.assertFalse(UndergroundBar.place.is_cached(b))
|
|
self.assertIsNone(b.place)
|
|
self.assertTrue(UndergroundBar.place.is_cached(b))
|
|
|
|
def test_related_object_cache(self):
|
|
"""Regression test for #6886 (the related-object cache)"""
|
|
|
|
# Look up the objects again so that we get "fresh" objects
|
|
p = Place.objects.get(name="Demon Dogs")
|
|
r = p.restaurant
|
|
|
|
# Accessing the related object again returns the exactly same object
|
|
self.assertIs(p.restaurant, r)
|
|
|
|
# But if we kill the cache, we get a new object
|
|
del p._state.fields_cache["restaurant"]
|
|
self.assertIsNot(p.restaurant, r)
|
|
|
|
# Reassigning the Restaurant object results in an immediate cache update
|
|
# We can't use a new Restaurant because that'll violate one-to-one, but
|
|
# with a new *instance* the is test below will fail if #6886 regresses.
|
|
r2 = Restaurant.objects.get(pk=r.pk)
|
|
p.restaurant = r2
|
|
self.assertIs(p.restaurant, r2)
|
|
|
|
# Assigning None succeeds if field is null=True.
|
|
ug_bar = UndergroundBar.objects.create(place=p, serves_cocktails=False)
|
|
ug_bar.place = None
|
|
self.assertIsNone(ug_bar.place)
|
|
|
|
# Assigning None will not fail: Place.restaurant is null=False
|
|
setattr(p, "restaurant", None)
|
|
|
|
# You also can't assign an object of the wrong type here
|
|
msg = (
|
|
'Cannot assign "<Place: Demon Dogs the place>": '
|
|
'"Place.restaurant" must be a "Restaurant" instance.'
|
|
)
|
|
with self.assertRaisesMessage(ValueError, msg):
|
|
setattr(p, "restaurant", p)
|
|
|
|
# Creation using keyword argument should cache the related object.
|
|
p = Place.objects.get(name="Demon Dogs")
|
|
r = Restaurant(place=p)
|
|
self.assertIs(r.place, p)
|
|
|
|
# Creation using keyword argument and unsaved related instance (#8070).
|
|
p = Place()
|
|
r = Restaurant(place=p)
|
|
self.assertIs(r.place, p)
|
|
|
|
# Creation using attname keyword argument and an id will cause the related
|
|
# object to be fetched.
|
|
p = Place.objects.get(name="Demon Dogs")
|
|
r = Restaurant(place_id=p.id)
|
|
self.assertIsNot(r.place, p)
|
|
self.assertEqual(r.place, p)
|
|
|
|
def test_filter_one_to_one_relations(self):
|
|
"""
|
|
Regression test for #9968
|
|
|
|
filtering reverse one-to-one relations with primary_key=True was
|
|
misbehaving. We test both (primary_key=True & False) cases here to
|
|
prevent any reappearance of the problem.
|
|
"""
|
|
target = Target.objects.create()
|
|
self.assertSequenceEqual(Target.objects.filter(pointer=None), [target])
|
|
self.assertSequenceEqual(Target.objects.exclude(pointer=None), [])
|
|
self.assertSequenceEqual(Target.objects.filter(second_pointer=None), [target])
|
|
self.assertSequenceEqual(Target.objects.exclude(second_pointer=None), [])
|
|
|
|
def test_o2o_primary_key_delete(self):
|
|
t = Target.objects.create(name="name")
|
|
Pointer.objects.create(other=t)
|
|
num_deleted, objs = Pointer.objects.filter(other__name="name").delete()
|
|
self.assertEqual(num_deleted, 1)
|
|
self.assertEqual(objs, {"one_to_one.Pointer": 1})
|
|
|
|
def test_save_nullable_o2o_after_parent(self):
|
|
place = Place(name="Rose tattoo")
|
|
bar = UndergroundBar(place=place)
|
|
place.save()
|
|
bar.save()
|
|
bar.refresh_from_db()
|
|
self.assertEqual(bar.place, place)
|
|
|
|
def test_reverse_object_does_not_exist_cache(self):
|
|
"""
|
|
Regression for #13839 and #17439.
|
|
|
|
DoesNotExist on a reverse one-to-one relation is cached.
|
|
"""
|
|
p = Place(name="Zombie Cats", address="Not sure")
|
|
p.save()
|
|
with self.assertNumQueries(1):
|
|
with self.assertRaises(Restaurant.DoesNotExist):
|
|
p.restaurant
|
|
with self.assertNumQueries(0):
|
|
with self.assertRaises(Restaurant.DoesNotExist):
|
|
p.restaurant
|
|
|
|
def test_reverse_object_cached_when_related_is_accessed(self):
|
|
"""
|
|
Regression for #13839 and #17439.
|
|
|
|
The target of a one-to-one relation is cached
|
|
when the origin is accessed through the reverse relation.
|
|
"""
|
|
# Use a fresh object without caches
|
|
r = Restaurant.objects.get(pk=self.r1.pk)
|
|
p = r.place
|
|
with self.assertNumQueries(0):
|
|
self.assertEqual(p.restaurant, r)
|
|
|
|
def test_related_object_cached_when_reverse_is_accessed(self):
|
|
"""
|
|
Regression for #13839 and #17439.
|
|
|
|
The origin of a one-to-one relation is cached
|
|
when the target is accessed through the reverse relation.
|
|
"""
|
|
# Use a fresh object without caches
|
|
p = Place.objects.get(pk=self.p1.pk)
|
|
r = p.restaurant
|
|
with self.assertNumQueries(0):
|
|
self.assertEqual(r.place, p)
|
|
|
|
def test_reverse_object_cached_when_related_is_set(self):
|
|
"""
|
|
Regression for #13839 and #17439.
|
|
|
|
The target of a one-to-one relation is always cached.
|
|
"""
|
|
p = Place(name="Zombie Cats", address="Not sure")
|
|
p.save()
|
|
self.r1.place = p
|
|
self.r1.save()
|
|
with self.assertNumQueries(0):
|
|
self.assertEqual(p.restaurant, self.r1)
|
|
|
|
def test_reverse_object_cached_when_related_is_unset(self):
|
|
"""
|
|
Regression for #13839 and #17439.
|
|
|
|
The target of a one-to-one relation is always cached.
|
|
"""
|
|
b = UndergroundBar(place=self.p1, serves_cocktails=True)
|
|
b.save()
|
|
with self.assertNumQueries(0):
|
|
self.assertEqual(self.p1.undergroundbar, b)
|
|
b.place = None
|
|
b.save()
|
|
with self.assertNumQueries(0):
|
|
with self.assertRaises(UndergroundBar.DoesNotExist):
|
|
self.p1.undergroundbar
|
|
|
|
def test_get_reverse_on_unsaved_object(self):
|
|
"""
|
|
Regression for #18153 and #19089.
|
|
|
|
Accessing the reverse relation on an unsaved object
|
|
always raises an exception.
|
|
"""
|
|
p = Place()
|
|
|
|
# When there's no instance of the origin of the one-to-one
|
|
with self.assertNumQueries(0):
|
|
with self.assertRaises(UndergroundBar.DoesNotExist):
|
|
p.undergroundbar
|
|
|
|
UndergroundBar.objects.create()
|
|
|
|
# When there's one instance of the origin
|
|
# (p.undergroundbar used to return that instance)
|
|
with self.assertNumQueries(0):
|
|
with self.assertRaises(UndergroundBar.DoesNotExist):
|
|
p.undergroundbar
|
|
|
|
# Several instances of the origin are only possible if database allows
|
|
# inserting multiple NULL rows for a unique constraint
|
|
if connection.features.supports_nullable_unique_constraints:
|
|
UndergroundBar.objects.create()
|
|
|
|
# When there are several instances of the origin
|
|
with self.assertNumQueries(0):
|
|
with self.assertRaises(UndergroundBar.DoesNotExist):
|
|
p.undergroundbar
|
|
|
|
def test_set_reverse_on_unsaved_object(self):
|
|
"""
|
|
Writing to the reverse relation on an unsaved object
|
|
is impossible too.
|
|
"""
|
|
p = Place()
|
|
b = UndergroundBar.objects.create()
|
|
|
|
# Assigning a reverse relation on an unsaved object is allowed.
|
|
p.undergroundbar = b
|
|
|
|
# However saving the object is not allowed.
|
|
msg = (
|
|
"save() prohibited to prevent data loss due to unsaved related object "
|
|
"'place'."
|
|
)
|
|
with self.assertNumQueries(0):
|
|
with self.assertRaisesMessage(ValueError, msg):
|
|
b.save()
|
|
|
|
def test_nullable_o2o_delete(self):
|
|
u = UndergroundBar.objects.create(place=self.p1)
|
|
u.place_id = None
|
|
u.save()
|
|
self.p1.delete()
|
|
self.assertTrue(UndergroundBar.objects.filter(pk=u.pk).exists())
|
|
self.assertIsNone(UndergroundBar.objects.get(pk=u.pk).place)
|
|
|
|
def test_hidden_accessor(self):
|
|
"""
|
|
When a '+' ending related name is specified no reverse accessor should
|
|
be added to the related model.
|
|
"""
|
|
self.assertFalse(
|
|
hasattr(
|
|
Target,
|
|
HiddenPointer._meta.get_field(
|
|
"target"
|
|
).remote_field.get_accessor_name(),
|
|
)
|
|
)
|
|
|
|
def test_related_object(self):
|
|
public_school = School.objects.create(is_public=True)
|
|
public_director = Director.objects.create(school=public_school, is_temp=False)
|
|
|
|
private_school = School.objects.create(is_public=False)
|
|
private_director = Director.objects.create(school=private_school, is_temp=True)
|
|
|
|
# Only one school is available via all() due to the custom default manager.
|
|
self.assertSequenceEqual(School.objects.all(), [public_school])
|
|
|
|
# Only one director is available via all() due to the custom default manager.
|
|
self.assertSequenceEqual(Director.objects.all(), [public_director])
|
|
|
|
self.assertEqual(public_director.school, public_school)
|
|
self.assertEqual(public_school.director, public_director)
|
|
|
|
# Make sure the base manager is used so that the related objects
|
|
# is still accessible even if the default manager doesn't normally
|
|
# allow it.
|
|
self.assertEqual(private_director.school, private_school)
|
|
|
|
# Make sure the base manager is used so that an student can still access
|
|
# its related school even if the default manager doesn't normally
|
|
# allow it.
|
|
self.assertEqual(private_school.director, private_director)
|
|
|
|
School._meta.base_manager_name = "objects"
|
|
School._meta._expire_cache()
|
|
try:
|
|
private_director = Director._base_manager.get(pk=private_director.pk)
|
|
with self.assertRaises(School.DoesNotExist):
|
|
private_director.school
|
|
finally:
|
|
School._meta.base_manager_name = None
|
|
School._meta._expire_cache()
|
|
|
|
Director._meta.base_manager_name = "objects"
|
|
Director._meta._expire_cache()
|
|
try:
|
|
private_school = School._base_manager.get(pk=private_school.pk)
|
|
with self.assertRaises(Director.DoesNotExist):
|
|
private_school.director
|
|
finally:
|
|
Director._meta.base_manager_name = None
|
|
Director._meta._expire_cache()
|
|
|
|
def test_hasattr_related_object(self):
|
|
# The exception raised on attribute access when a related object
|
|
# doesn't exist should be an instance of a subclass of `AttributeError`
|
|
# refs #21563
|
|
self.assertFalse(hasattr(Director(), "director"))
|
|
self.assertFalse(hasattr(School(), "school"))
|
|
|
|
def test_update_one_to_one_pk(self):
|
|
p1 = Place.objects.create()
|
|
p2 = Place.objects.create()
|
|
r1 = Restaurant.objects.create(place=p1)
|
|
r2 = Restaurant.objects.create(place=p2)
|
|
w = Waiter.objects.create(restaurant=r1)
|
|
|
|
Waiter.objects.update(restaurant=r2)
|
|
w.refresh_from_db()
|
|
self.assertEqual(w.restaurant, r2)
|
|
|
|
def test_rel_pk_subquery(self):
|
|
r = Restaurant.objects.first()
|
|
q1 = Restaurant.objects.filter(place_id=r.pk)
|
|
# Subquery using primary key and a query against the
|
|
# same model works correctly.
|
|
q2 = Restaurant.objects.filter(place_id__in=q1)
|
|
self.assertSequenceEqual(q2, [r])
|
|
# Subquery using 'pk__in' instead of 'place_id__in' work, too.
|
|
q2 = Restaurant.objects.filter(
|
|
pk__in=Restaurant.objects.filter(place__id=r.place.pk)
|
|
)
|
|
self.assertSequenceEqual(q2, [r])
|
|
q3 = Restaurant.objects.filter(place__in=Place.objects.all())
|
|
self.assertSequenceEqual(q3, [r])
|
|
q4 = Restaurant.objects.filter(place__in=Place.objects.filter(id=r.pk))
|
|
self.assertSequenceEqual(q4, [r])
|
|
|
|
def test_rel_pk_exact(self):
|
|
r = Restaurant.objects.first()
|
|
r2 = Restaurant.objects.filter(pk__exact=r).first()
|
|
self.assertEqual(r, r2)
|
|
|
|
def test_primary_key_to_field_filter(self):
|
|
target = Target.objects.create(name="foo")
|
|
pointer = ToFieldPointer.objects.create(target=target)
|
|
self.assertSequenceEqual(
|
|
ToFieldPointer.objects.filter(target=target), [pointer]
|
|
)
|
|
self.assertSequenceEqual(
|
|
ToFieldPointer.objects.filter(pk__exact=pointer), [pointer]
|
|
)
|
|
|
|
def test_cached_relation_invalidated_on_save(self):
|
|
"""
|
|
Model.save() invalidates stale OneToOneField relations after a primary
|
|
key assignment.
|
|
"""
|
|
self.assertEqual(self.b1.place, self.p1) # caches b1.place
|
|
self.b1.place_id = self.p2.pk
|
|
self.b1.save()
|
|
self.assertEqual(self.b1.place, self.p2)
|