Merged one_to_one_regress into the one_to_one test package.
This commit is contained in:
Loic Bistuer
parent
37b13033c6
commit
7fe554b2a3
|
|
@ -30,8 +30,18 @@ class Restaurant(models.Model):
|
|||
return "%s the restaurant" % self.place.name
|
||||
|
||||
|
||||
@python_2_unicode_compatible
|
||||
class Bar(models.Model):
|
||||
place = models.OneToOneField(Place)
|
||||
serves_cocktails = models.BooleanField(default=True)
|
||||
|
||||
def __str__(self):
|
||||
return "%s the bar" % self.place.name
|
||||
|
||||
|
||||
class UndergroundBar(models.Model):
|
||||
place = models.OneToOneField(Place, null=True)
|
||||
serves_cocktails = models.BooleanField(default=True)
|
||||
|
||||
|
||||
@python_2_unicode_compatible
|
||||
|
|
@ -43,6 +53,15 @@ class Waiter(models.Model):
|
|||
return "%s the waiter at %s" % (self.name, self.restaurant)
|
||||
|
||||
|
||||
@python_2_unicode_compatible
|
||||
class Favorites(models.Model):
|
||||
name = models.CharField(max_length=50)
|
||||
restaurants = models.ManyToManyField(Restaurant)
|
||||
|
||||
def __str__(self):
|
||||
return "Favorites for %s" % self.name
|
||||
|
||||
|
||||
class ManualPrimaryKey(models.Model):
|
||||
primary_key = models.CharField(max_length=10, primary_key=True)
|
||||
name = models.CharField(max_length=50)
|
||||
|
|
@ -61,3 +80,19 @@ class MultiModel(models.Model):
|
|||
|
||||
def __str__(self):
|
||||
return "Multimodel %s" % self.name
|
||||
|
||||
|
||||
class Target(models.Model):
|
||||
pass
|
||||
|
||||
|
||||
class Pointer(models.Model):
|
||||
other = models.OneToOneField(Target, primary_key=True)
|
||||
|
||||
|
||||
class Pointer2(models.Model):
|
||||
other = models.OneToOneField(Target, related_name='second_pointer')
|
||||
|
||||
|
||||
class HiddenPointer(models.Model):
|
||||
target = models.OneToOneField(Target, related_name='hidden+')
|
||||
|
|
|
|||
|
|
@ -1,25 +1,23 @@
|
|||
from __future__ import unicode_literals
|
||||
|
||||
from django.db import transaction, IntegrityError
|
||||
from django.db import transaction, IntegrityError, connection
|
||||
from django.test import TestCase
|
||||
|
||||
from .models import (Place, Restaurant, Bar, Waiter, ManualPrimaryKey, RelatedModel,
|
||||
MultiModel)
|
||||
from .models import (Bar, Favorites, HiddenPointer, ManualPrimaryKey, MultiModel,
|
||||
Place, RelatedModel, Restaurant, Target, UndergroundBar, Waiter)
|
||||
|
||||
|
||||
class OneToOneTests(TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.p1 = Place(name='Demon Dogs', address='944 W. Fullerton')
|
||||
self.p1.save()
|
||||
self.p2 = Place(name='Ace Hardware', address='1013 N. Ashland')
|
||||
self.p2.save()
|
||||
self.r = Restaurant(place=self.p1, serves_hot_dogs=True, serves_pizza=False)
|
||||
self.r.save()
|
||||
self.p1 = Place.objects.create(name='Demon Dogs', address='944 W. Fullerton')
|
||||
self.p2 = Place.objects.create(name='Ace Hardware', address='1013 N. Ashland')
|
||||
self.r1 = Restaurant.objects.create(place=self.p1, serves_hot_dogs=True, serves_pizza=False)
|
||||
self.b1 = Bar.objects.create(place=self.p1, serves_cocktails=False)
|
||||
|
||||
def test_getter(self):
|
||||
# A Restaurant can access its place.
|
||||
self.assertEqual(repr(self.r.place), '<Place: Demon Dogs the 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.
|
||||
|
|
@ -33,13 +31,13 @@ class OneToOneTests(TestCase):
|
|||
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.r.place = self.p2
|
||||
self.r.save()
|
||||
self.r1.place = self.p2
|
||||
self.r1.save()
|
||||
self.assertEqual(repr(self.p2.restaurant), '<Restaurant: Ace Hardware the restaurant>')
|
||||
self.assertEqual(repr(self.r.place), '<Place: Ace Hardware the place>')
|
||||
self.assertEqual(self.p2.pk, self.r.pk)
|
||||
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.r
|
||||
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>')
|
||||
|
|
@ -78,17 +76,16 @@ class OneToOneTests(TestCase):
|
|||
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.r)
|
||||
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.r)
|
||||
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.r.waiter_set.create(name='Joe')
|
||||
w.save()
|
||||
w = self.r1.waiter_set.create(name='Joe')
|
||||
self.assertEqual(repr(w), '<Waiter: Joe the waiter at Demon Dogs the restaurant>')
|
||||
|
||||
# Query the waiters
|
||||
|
|
@ -102,9 +99,7 @@ class OneToOneTests(TestCase):
|
|||
assert_filter_waiters(restaurant__exact=self.p1.pk)
|
||||
assert_filter_waiters(restaurant__pk=self.p1.pk)
|
||||
assert_filter_waiters(restaurant=self.p1.pk)
|
||||
assert_filter_waiters(restaurant=self.r)
|
||||
assert_filter_waiters(id__exact=self.p1.pk)
|
||||
assert_filter_waiters(pk=self.p1.pk)
|
||||
assert_filter_waiters(restaurant=self.r1)
|
||||
# Delete the restaurant; the waiter should also be removed
|
||||
r = Restaurant.objects.get(pk=self.p1.pk)
|
||||
r.delete()
|
||||
|
|
@ -138,9 +133,252 @@ class OneToOneTests(TestCase):
|
|||
'Cannot assign "%r": "%s" instance isn\'t saved in the database.'
|
||||
% (place, Restaurant.place.field.rel.to._meta.object_name)):
|
||||
Restaurant.objects.create(place=place, serves_hot_dogs=True, serves_pizza=False)
|
||||
bar = Bar()
|
||||
bar = UndergroundBar()
|
||||
p = Place(name='User', address='London')
|
||||
with self.assertRaisesMessage(ValueError,
|
||||
'Cannot assign "%r": "%s" instance isn\'t saved in the database.'
|
||||
% (bar, p._meta.object_name)):
|
||||
p.bar = bar
|
||||
p.undergroundbar = bar
|
||||
|
||||
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.all().count(), 1)
|
||||
self.assertEqual(UndergroundBar.objects.all().count(), 1)
|
||||
|
||||
def test_create_models_m2m(self):
|
||||
"""
|
||||
Regression test for #1064 and #1506
|
||||
|
||||
Check that we create models via the m2m relation if the remote model
|
||||
has a OneToOneField.
|
||||
"""
|
||||
f = Favorites(name='Fred')
|
||||
f.save()
|
||||
f.restaurants = [self.r1]
|
||||
self.assertQuerysetEqual(
|
||||
f.restaurants.all(),
|
||||
['<Restaurant: Demon Dogs the restaurant>']
|
||||
)
|
||||
|
||||
def test_reverse_object_cache(self):
|
||||
"""
|
||||
Regression test for #7173
|
||||
|
||||
Check that the name of the cache for the reverse object is correct.
|
||||
"""
|
||||
self.assertEqual(self.p1.restaurant, self.r1)
|
||||
self.assertEqual(self.p1.bar, self.b1)
|
||||
|
||||
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.assertTrue(p.restaurant is r)
|
||||
|
||||
# But if we kill the cache, we get a new object
|
||||
del p._restaurant_cache
|
||||
self.assertFalse(p.restaurant is 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.assertTrue(p.restaurant is r2)
|
||||
|
||||
# Assigning None succeeds if field is null=True.
|
||||
ug_bar = UndergroundBar.objects.create(place=p, serves_cocktails=False)
|
||||
ug_bar.place = None
|
||||
self.assertTrue(ug_bar.place is None)
|
||||
|
||||
# Assigning None fails: Place.restaurant is null=False
|
||||
self.assertRaises(ValueError, setattr, p, 'restaurant', None)
|
||||
|
||||
# You also can't assign an object of the wrong type here
|
||||
self.assertRaises(ValueError, 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.assertTrue(r.place is 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.assertFalse(r.place is 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.objects.create()
|
||||
|
||||
self.assertQuerysetEqual(
|
||||
Target.objects.filter(pointer=None),
|
||||
['<Target: Target object>']
|
||||
)
|
||||
self.assertQuerysetEqual(
|
||||
Target.objects.exclude(pointer=None),
|
||||
[]
|
||||
)
|
||||
self.assertQuerysetEqual(
|
||||
Target.objects.filter(second_pointer=None),
|
||||
['<Target: Target object>']
|
||||
)
|
||||
self.assertQuerysetEqual(
|
||||
Target.objects.exclude(second_pointer=None),
|
||||
[]
|
||||
)
|
||||
|
||||
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()
|
||||
with self.assertNumQueries(0):
|
||||
with self.assertRaises(ValueError):
|
||||
p.undergroundbar = b
|
||||
|
||||
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').related.get_accessor_name())
|
||||
)
|
||||
|
|
|
|||
|
|
@ -1,62 +0,0 @@
|
|||
from __future__ import unicode_literals
|
||||
|
||||
from django.db import models
|
||||
from django.utils.encoding import python_2_unicode_compatible
|
||||
|
||||
|
||||
@python_2_unicode_compatible
|
||||
class Place(models.Model):
|
||||
name = models.CharField(max_length=50)
|
||||
address = models.CharField(max_length=80)
|
||||
|
||||
def __str__(self):
|
||||
return "%s the place" % self.name
|
||||
|
||||
|
||||
@python_2_unicode_compatible
|
||||
class Restaurant(models.Model):
|
||||
place = models.OneToOneField(Place)
|
||||
serves_hot_dogs = models.BooleanField(default=False)
|
||||
serves_pizza = models.BooleanField(default=False)
|
||||
|
||||
def __str__(self):
|
||||
return "%s the restaurant" % self.place.name
|
||||
|
||||
|
||||
@python_2_unicode_compatible
|
||||
class Bar(models.Model):
|
||||
place = models.OneToOneField(Place)
|
||||
serves_cocktails = models.BooleanField(default=True)
|
||||
|
||||
def __str__(self):
|
||||
return "%s the bar" % self.place.name
|
||||
|
||||
|
||||
class UndergroundBar(models.Model):
|
||||
place = models.OneToOneField(Place, null=True)
|
||||
serves_cocktails = models.BooleanField(default=True)
|
||||
|
||||
|
||||
@python_2_unicode_compatible
|
||||
class Favorites(models.Model):
|
||||
name = models.CharField(max_length=50)
|
||||
restaurants = models.ManyToManyField(Restaurant)
|
||||
|
||||
def __str__(self):
|
||||
return "Favorites for %s" % self.name
|
||||
|
||||
|
||||
class Target(models.Model):
|
||||
pass
|
||||
|
||||
|
||||
class Pointer(models.Model):
|
||||
other = models.OneToOneField(Target, primary_key=True)
|
||||
|
||||
|
||||
class Pointer2(models.Model):
|
||||
other = models.OneToOneField(Target, related_name='second_pointer')
|
||||
|
||||
|
||||
class HiddenPointer(models.Model):
|
||||
target = models.OneToOneField(Target, related_name='hidden+')
|
||||
|
|
@ -1,261 +0,0 @@
|
|||
from __future__ import unicode_literals
|
||||
|
||||
from django.db import connection
|
||||
from django.test import TestCase
|
||||
|
||||
from .models import (Bar, Favorites, HiddenPointer, Place, Restaurant, Target,
|
||||
UndergroundBar)
|
||||
|
||||
|
||||
class OneToOneRegressionTests(TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.p1 = Place(name='Demon Dogs', address='944 W. Fullerton')
|
||||
self.p1.save()
|
||||
self.r1 = Restaurant(place=self.p1, serves_hot_dogs=True, serves_pizza=False)
|
||||
self.r1.save()
|
||||
self.b1 = Bar(place=self.p1, serves_cocktails=False)
|
||||
self.b1.save()
|
||||
|
||||
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.all().count(), 0)
|
||||
self.assertEqual(UndergroundBar.objects.all().count(), 1)
|
||||
|
||||
def test_create_models_m2m(self):
|
||||
"""
|
||||
Regression test for #1064 and #1506
|
||||
|
||||
Check that we create models via the m2m relation if the remote model
|
||||
has a OneToOneField.
|
||||
"""
|
||||
f = Favorites(name='Fred')
|
||||
f.save()
|
||||
f.restaurants = [self.r1]
|
||||
self.assertQuerysetEqual(
|
||||
f.restaurants.all(),
|
||||
['<Restaurant: Demon Dogs the restaurant>']
|
||||
)
|
||||
|
||||
def test_reverse_object_cache(self):
|
||||
"""
|
||||
Regression test for #7173
|
||||
|
||||
Check that the name of the cache for the reverse object is correct.
|
||||
"""
|
||||
self.assertEqual(self.p1.restaurant, self.r1)
|
||||
self.assertEqual(self.p1.bar, self.b1)
|
||||
|
||||
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.assertTrue(p.restaurant is r)
|
||||
|
||||
# But if we kill the cache, we get a new object
|
||||
del p._restaurant_cache
|
||||
self.assertFalse(p.restaurant is 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.assertTrue(p.restaurant is r2)
|
||||
|
||||
# Assigning None succeeds if field is null=True.
|
||||
ug_bar = UndergroundBar.objects.create(place=p, serves_cocktails=False)
|
||||
ug_bar.place = None
|
||||
self.assertTrue(ug_bar.place is None)
|
||||
|
||||
# Assigning None fails: Place.restaurant is null=False
|
||||
self.assertRaises(ValueError, setattr, p, 'restaurant', None)
|
||||
|
||||
# You also can't assign an object of the wrong type here
|
||||
self.assertRaises(ValueError, 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.assertTrue(r.place is 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.assertFalse(r.place is 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.objects.create()
|
||||
|
||||
self.assertQuerysetEqual(
|
||||
Target.objects.filter(pointer=None),
|
||||
['<Target: Target object>']
|
||||
)
|
||||
self.assertQuerysetEqual(
|
||||
Target.objects.exclude(pointer=None),
|
||||
[]
|
||||
)
|
||||
self.assertQuerysetEqual(
|
||||
Target.objects.filter(second_pointer=None),
|
||||
['<Target: Target object>']
|
||||
)
|
||||
self.assertQuerysetEqual(
|
||||
Target.objects.exclude(second_pointer=None),
|
||||
[]
|
||||
)
|
||||
|
||||
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()
|
||||
with self.assertNumQueries(0):
|
||||
with self.assertRaises(ValueError):
|
||||
p.undergroundbar = b
|
||||
|
||||
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').related.get_accessor_name())
|
||||
)
|
||||
Loading…
Reference in New Issue