diff --git a/tests/regressiontests/one_to_one_regress/models.py b/tests/regressiontests/one_to_one_regress/models.py index 5c89c55f45..a7edbc098e 100644 --- a/tests/regressiontests/one_to_one_regress/models.py +++ b/tests/regressiontests/one_to_one_regress/models.py @@ -41,104 +41,3 @@ class Pointer(models.Model): class Pointer2(models.Model): other = models.OneToOneField(Target) - -__test__ = {'API_TESTS':""" -# Regression test for #1064 and #1506: Check that we create models via the m2m -# relation if the remote model has a OneToOneField. ->>> p1 = Place(name='Demon Dogs', address='944 W. Fullerton') ->>> p1.save() ->>> r = Restaurant(place=p1, serves_hot_dogs=True, serves_pizza=False) ->>> r.save() ->>> f = Favorites(name = 'Fred') ->>> f.save() ->>> f.restaurants = [r] ->>> f.restaurants.all() -[] - -# Regression test for #7173: Check that the name of the cache for the -# reverse object is correct. ->>> b = Bar(place=p1, serves_cocktails=False) ->>> b.save() ->>> p1.restaurant - ->>> p1.bar - - -# -# 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 ->>> p.restaurant is r -True - -# But if we kill the cache, we get a new object ->>> del p._restaurant_cache ->>> p.restaurant is r -False - -# 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 ->>> p.restaurant is r2 -True - -# Assigning None succeeds if field is null=True. ->>> ug_bar = UndergroundBar.objects.create(place=p, serves_cocktails=False) ->>> ug_bar.place = None ->>> ug_bar.place is None -True - -# Assigning None fails: Place.restaurant is null=False ->>> p.restaurant = None -Traceback (most recent call last): - ... -ValueError: Cannot assign None: "Place.restaurant" does not allow null values. - -# You also can't assign an object of the wrong type here ->>> p.restaurant = p -Traceback (most recent call last): - ... -ValueError: Cannot assign "": "Place.restaurant" must be a "Restaurant" instance. - -# Creation using keyword argument should cache the related object. ->>> p = Place.objects.get(name="Demon Dogs") ->>> r = Restaurant(place=p) ->>> r.place is p -True - -# Creation using keyword argument and unsaved related instance (#8070). ->>> p = Place() ->>> r = Restaurant(place=p) ->>> r.place is p -True - -# 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) ->>> r.place is p -False ->>> r.place == p -True - -# 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() ->>> Target.objects.filter(pointer=None) -[] ->>> Target.objects.exclude(pointer=None) -[] ->>> Target.objects.filter(pointer2=None) -[] ->>> Target.objects.exclude(pointer2=None) -[] - -"""} diff --git a/tests/regressiontests/one_to_one_regress/tests.py b/tests/regressiontests/one_to_one_regress/tests.py index a0a0c0584f..8787575a04 100644 --- a/tests/regressiontests/one_to_one_regress/tests.py +++ b/tests/regressiontests/one_to_one_regress/tests.py @@ -1,22 +1,130 @@ from django.test import TestCase -from regressiontests.one_to_one_regress.models import Place, UndergroundBar +from regressiontests.one_to_one_regress.models import * + +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() -class OneToOneDeletionTests(TestCase): def test_reverse_relationship_cache_cascade(self): """ Regression test for #9023: accessing the reverse relationship shouldn't result in a cascading delete(). """ - place = Place.objects.create(name="Dempsey's", address="623 Vermont St") - bar = UndergroundBar.objects.create(place=place, serves_cocktails=False) + 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. - place.undergroundbar + self.p1.undergroundbar bar.place.name='foo' bar.place = None bar.save() - place.delete() + 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.assertEquals(self.p1.restaurant, self.r1) + self.assertEquals(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 keyword argument and unsaved related instance (#8070). + p = Place() + 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. + """ + t = Target.objects.create() + + self.assertQuerysetEqual( + Target.objects.filter(pointer=None), + [''] + ) + self.assertQuerysetEqual( + Target.objects.exclude(pointer=None), + [] + ) + self.assertQuerysetEqual( + Target.objects.filter(pointer2=None), + [''] + ) + self.assertQuerysetEqual( + Target.objects.exclude(pointer2=None), + [] + )