Merged one_to_one_regress into the one_to_one test package.

2 files changed, 297 insertions, 24 deletions

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), '<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())
+        )