diff --git a/tests/one_to_one/models.py b/tests/one_to_one/models.py index f9c0a40ee0..ccb6851bc3 100644 --- a/tests/one_to_one/models.py +++ b/tests/one_to_one/models.py @@ -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+') diff --git a/tests/one_to_one/tests.py b/tests/one_to_one/tests.py index af983fed74..da0fb5259f 100644 --- a/tests/one_to_one/tests.py +++ b/tests/one_to_one/tests.py @@ -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), '') + self.assertEqual(repr(self.r1.place), '') # A Place can access its restaurant, if available. self.assertEqual(repr(self.p1.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), '') - self.assertEqual(repr(self.r.place), '') - self.assertEqual(self.p2.pk, self.r.pk) + self.assertEqual(repr(self.r1.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), '') r = Restaurant.objects.get(pk=self.p1.id) self.assertEqual(repr(r.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), '') # 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(), + [''] + ) + + 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), + [''] + ) + self.assertQuerysetEqual( + Target.objects.exclude(pointer=None), + [] + ) + self.assertQuerysetEqual( + Target.objects.filter(second_pointer=None), + [''] + ) + 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()) + ) diff --git a/tests/one_to_one_regress/__init__.py b/tests/one_to_one_regress/__init__.py deleted file mode 100644 index e69de29bb2..0000000000 diff --git a/tests/one_to_one_regress/models.py b/tests/one_to_one_regress/models.py deleted file mode 100644 index 3cd4e17604..0000000000 --- a/tests/one_to_one_regress/models.py +++ /dev/null @@ -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+') diff --git a/tests/one_to_one_regress/tests.py b/tests/one_to_one_regress/tests.py deleted file mode 100644 index 2f4c5fe6bf..0000000000 --- a/tests/one_to_one_regress/tests.py +++ /dev/null @@ -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(), - [''] - ) - - 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), - [''] - ) - self.assertQuerysetEqual( - Target.objects.exclude(pointer=None), - [] - ) - self.assertQuerysetEqual( - Target.objects.filter(second_pointer=None), - [''] - ) - 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()) - )