Merged one_to_one_regress into the one_to_one test package. (7fe554b2) · Commits · Dom Sekotill / django

tests/one_to_one/models.py

+35 −0

Original line number	Diff line number	Diff line
		@@ -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+')

tests/one_to_one/tests.py

+262 −24

Original line number	Diff line number	Diff line
		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())
		)

tests/one_to_one_regress/init.py

deleted100644 → 0

+0 −0

Empty file deleted.

tests/one_to_one_regress/models.py

deleted100644 → 0

+0 −62

Original line number	Diff line number	Diff line
		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+')

tests/one_to_one_regress/tests.py

deleted100644 → 0

+0 −261

File deleted.

Preview size limit exceeded, changes collapsed.