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

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)
-[]
-
-"""}

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=self.p1, serves_cocktails=False)
-        bar = UndergroundBar.objects.create(place=place, 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),
+                []
+        )