diff --git a/tests/modeltests/one_to_one/models.py b/tests/modeltests/one_to_one/models.py index e25e33bcc0a..f2637350cad 100644 --- a/tests/modeltests/one_to_one/models.py +++ b/tests/modeltests/one_to_one/models.py @@ -45,150 +45,3 @@ class MultiModel(models.Model): def __unicode__(self): return u"Multimodel %s" % self.name - -__test__ = {'API_TESTS':""" -# Create a couple of Places. ->>> p1 = Place(name='Demon Dogs', address='944 W. Fullerton') ->>> p1.save() ->>> p2 = Place(name='Ace Hardware', address='1013 N. Ashland') ->>> p2.save() - -# Create a Restaurant. Pass the ID of the "parent" object as this object's ID. ->>> r = Restaurant(place=p1, serves_hot_dogs=True, serves_pizza=False) ->>> r.save() - -# A Restaurant can access its place. ->>> r.place - - -# A Place can access its restaurant, if available. ->>> p1.restaurant - - -# p2 doesn't have an associated restaurant. ->>> p2.restaurant -Traceback (most recent call last): - ... -DoesNotExist: Restaurant matching query does not exist. - -# Set the place using assignment notation. Because place is the primary key on -# Restaurant, the save will create a new restaurant ->>> r.place = p2 ->>> r.save() ->>> p2.restaurant - ->>> r.place - ->>> p2.id -2 - -# Set the place back again, using assignment in the reverse direction. ->>> p1.restaurant = r ->>> p1.restaurant - - ->>> r = Restaurant.objects.get(pk=1) ->>> r.place - - -# Restaurant.objects.all() just returns the Restaurants, not the Places. -# Note that there are two restaurants - Ace Hardware the Restaurant was created -# in the call to r.place = p2. ->>> Restaurant.objects.all() -[, ] - -# Place.objects.all() returns all Places, regardless of whether they have -# Restaurants. ->>> Place.objects.order_by('name') -[, ] - ->>> Restaurant.objects.get(place__id__exact=1) - ->>> Restaurant.objects.get(pk=1) - ->>> Restaurant.objects.get(place__exact=1) - ->>> Restaurant.objects.get(place__exact=p1) - ->>> Restaurant.objects.get(place=1) - ->>> Restaurant.objects.get(place=p1) - ->>> Restaurant.objects.get(place__pk=1) - ->>> Restaurant.objects.get(place__name__startswith="Demon") - - ->>> Place.objects.get(id__exact=1) - ->>> Place.objects.get(pk=1) - ->>> Place.objects.get(restaurant__place__exact=1) - ->>> Place.objects.get(restaurant__place__exact=p1) - ->>> Place.objects.get(restaurant__pk=1) - ->>> Place.objects.get(restaurant=1) - ->>> Place.objects.get(restaurant=r) - ->>> Place.objects.get(restaurant__exact=1) - ->>> Place.objects.get(restaurant__exact=r) - - -# Add a Waiter to the Restaurant. ->>> w = r.waiter_set.create(name='Joe') ->>> w.save() ->>> w - - -# Query the waiters ->>> Waiter.objects.filter(restaurant__place__pk=1) -[] ->>> Waiter.objects.filter(restaurant__place__exact=1) -[] ->>> Waiter.objects.filter(restaurant__place__exact=p1) -[] ->>> Waiter.objects.filter(restaurant__pk=1) -[] ->>> Waiter.objects.filter(id__exact=1) -[] ->>> Waiter.objects.filter(pk=1) -[] ->>> Waiter.objects.filter(restaurant=1) -[] ->>> Waiter.objects.filter(restaurant=r) -[] - -# Delete the restaurant; the waiter should also be removed ->>> r = Restaurant.objects.get(pk=1) ->>> r.delete() - -# One-to-one fields still work if you create your own primary key ->>> o1 = ManualPrimaryKey(primary_key="abc123", name="primary") ->>> o1.save() ->>> o2 = RelatedModel(link=o1, name="secondary") ->>> o2.save() - -# You can have multiple one-to-one fields on a model, too. ->>> x1 = MultiModel(link1=p1, link2=o1, name="x1") ->>> x1.save() ->>> o1.multimodel - - -# This will fail because each one-to-one field must be unique (and link2=o1 was -# used for x1, above). ->>> sid = transaction.savepoint() ->>> try: -... MultiModel(link1=p2, link2=o1, name="x1").save() -... except Exception, e: -... if isinstance(e, IntegrityError): -... print "Pass" -... else: -... print "Fail with %s" % type(e) -Pass ->>> transaction.savepoint_rollback(sid) - -"""} diff --git a/tests/modeltests/one_to_one/tests.py b/tests/modeltests/one_to_one/tests.py new file mode 100644 index 00000000000..c3e17044521 --- /dev/null +++ b/tests/modeltests/one_to_one/tests.py @@ -0,0 +1,119 @@ +from django.test import TestCase +from django.db import transaction, IntegrityError +from models import Place, Restaurant, Waiter, ManualPrimaryKey, RelatedModel, MultiModel + +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() + + def test_getter(self): + # A Restaurant can access its place. + self.assertEqual(repr(self.r.place), '') + # A Place can access its restaurant, if available. + self.assertEqual(repr(self.p1.restaurant), '') + # p2 doesn't have an associated restaurant. + self.assertRaises(Restaurant.DoesNotExist, getattr, self.p2, 'restaurant') + + 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.assertEqual(repr(self.p2.restaurant), '') + self.assertEqual(repr(self.r.place), '') + self.assertEqual(self.p2.pk, self.r.pk) + # Set the place back again, using assignment in the reverse direction. + self.p1.restaurant = self.r + self.assertEqual(repr(self.p1.restaurant), '') + r = Restaurant.objects.get(pk=self.p1.id) + self.assertEqual(repr(r.place), '') + + def test_manager_all(self): + # Restaurant.objects.all() just returns the Restaurants, not the Places. + self.assertQuerysetEqual(Restaurant.objects.all(), [ + '', + ]) + # Place.objects.all() returns all Places, regardless of whether they + # have Restaurants. + self.assertQuerysetEqual(Place.objects.order_by('name'), [ + '', + '', + ]) + + def test_manager_get(self): + def assert_get_restaurant(**params): + self.assertEqual(repr(Restaurant.objects.get(**params)), + '') + assert_get_restaurant(place__id__exact=self.p1.pk) + assert_get_restaurant(place__id=self.p1.pk) + assert_get_restaurant(place__exact=self.p1.pk) + assert_get_restaurant(place__exact=self.p1) + assert_get_restaurant(place=self.p1.pk) + assert_get_restaurant(place=self.p1) + assert_get_restaurant(pk=self.p1.pk) + assert_get_restaurant(place__pk__exact=self.p1.pk) + assert_get_restaurant(place__pk=self.p1.pk) + assert_get_restaurant(place__name__startswith="Demon") + + def assert_get_place(**params): + self.assertEqual(repr(Place.objects.get(**params)), + '') + assert_get_place(restaurant__place__exact=self.p1.pk) + 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__pk=self.p1.pk) + assert_get_place(restaurant=self.p1.pk) + assert_get_place(restaurant=self.r) + 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() + self.assertEqual(repr(w), '') + # Query the waiters + def assert_filter_waiters(**params): + self.assertQuerysetEqual(Waiter.objects.filter(**params), [ + '' + ]) + assert_filter_waiters(restaurant__place__exact=self.p1.pk) + assert_filter_waiters(restaurant__place__exact=self.p1) + assert_filter_waiters(restaurant__place__pk=self.p1.pk) + assert_filter_waiters(restaurant__exact=self.p1.pk) + assert_filter_waiters(restaurant__exact=self.p1) + 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) + # Delete the restaurant; the waiter should also be removed + r = Restaurant.objects.get(pk=self.p1.pk) + r.delete() + self.assertEqual(Waiter.objects.count(), 0) + + def test_multiple_o2o(self): + # One-to-one fields still work if you create your own primary key + o1 = ManualPrimaryKey(primary_key="abc123", name="primary") + o1.save() + o2 = RelatedModel(link=o1, name="secondary") + o2.save() + + # You can have multiple one-to-one fields on a model, too. + x1 = MultiModel(link1=self.p1, link2=o1, name="x1") + x1.save() + self.assertEqual(repr(o1.multimodel), '') + # This will fail because each one-to-one field must be unique (and + # link2=o1 was used for x1, above). + sid = transaction.savepoint() + mm = MultiModel(link1=self.p2, link2=o1, name="x1") + self.assertRaises(IntegrityError, mm.save) + transaction.savepoint_rollback(sid)