From 1c09aca6670321b097e1a7b83dc597f7fe4a6933 Mon Sep 17 00:00:00 2001
From: Russell Keith-Magee <russell@keith-magee.com>
Date: Tue, 28 Sep 2010 08:16:23 +0000
Subject: [PATCH] Migrated one_to_one_regress doctests. Thanks to Stephan
Jaekel.
git-svn-id: http://code.djangoproject.com/svn/django/trunk@13931 bcc190cf-cafb-0310-a4f2-bffc1f526a37
---
.../one_to_one_regress/models.py | 101 ---------------
.../one_to_one_regress/tests.py | 120 +++++++++++++++++-
2 files changed, 114 insertions(+), 107 deletions(-)
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()
-[<Restaurant: Demon Dogs the restaurant>]
-
-# 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
-<Restaurant: Demon Dogs the restaurant>
->>> p1.bar
-<Bar: Demon Dogs the 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: Demon Dogs the place>": "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: Target object>]
->>> Target.objects.exclude(pointer=None)
-[]
->>> Target.objects.filter(pointer2=None)
-[<Target: Target object>]
->>> 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(),
+ ['<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.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),
+ ['<Target: Target object>']
+ )
+ self.assertQuerysetEqual(
+ Target.objects.exclude(pointer=None),
+ []
+ )
+ self.assertQuerysetEqual(
+ Target.objects.filter(pointer2=None),
+ ['<Target: Target object>']
+ )
+ self.assertQuerysetEqual(
+ Target.objects.exclude(pointer2=None),
+ []
+ )