From 1d50f6af99679c5665a4e9996febdf527b78c46f Mon Sep 17 00:00:00 2001 From: Russell Keith-Magee Date: Sun, 12 Sep 2010 20:03:12 +0000 Subject: [PATCH] Migrated custom_pk doctests. Thanks to Alex Gaynor. git-svn-id: http://code.djangoproject.com/svn/django/trunk@13776 bcc190cf-cafb-0310-a4f2-bffc1f526a37 --- tests/modeltests/custom_pk/fields.py | 1 + tests/modeltests/custom_pk/models.py | 135 -------------------- tests/modeltests/custom_pk/tests.py | 183 +++++++++++++++++++++++++++ 3 files changed, 184 insertions(+), 135 deletions(-) create mode 100644 tests/modeltests/custom_pk/tests.py diff --git a/tests/modeltests/custom_pk/fields.py b/tests/modeltests/custom_pk/fields.py index 319e42f974b..2eeb80e6ace 100644 --- a/tests/modeltests/custom_pk/fields.py +++ b/tests/modeltests/custom_pk/fields.py @@ -3,6 +3,7 @@ import string from django.db import models + class MyWrapper(object): def __init__(self, value): self.value = value diff --git a/tests/modeltests/custom_pk/models.py b/tests/modeltests/custom_pk/models.py index 84e6480af9d..ff2f2bac1ba 100644 --- a/tests/modeltests/custom_pk/models.py +++ b/tests/modeltests/custom_pk/models.py @@ -40,138 +40,3 @@ class Bar(models.Model): class Foo(models.Model): bar = models.ForeignKey(Bar) -__test__ = {'API_TESTS':""" ->>> dan = Employee(employee_code=123, first_name='Dan', last_name='Jones') ->>> dan.save() ->>> Employee.objects.all() -[] - ->>> fran = Employee(employee_code=456, first_name='Fran', last_name='Bones') ->>> fran.save() ->>> Employee.objects.all() -[, ] - ->>> Employee.objects.get(pk=123) - ->>> Employee.objects.get(pk=456) - ->>> Employee.objects.get(pk=42) -Traceback (most recent call last): - ... -DoesNotExist: Employee matching query does not exist. - -# Use the name of the primary key, rather than pk. ->>> Employee.objects.get(employee_code__exact=123) - - -# pk can be used as a substitute for the primary key. ->>> Employee.objects.filter(pk__in=[123, 456]) -[, ] - -# The primary key can be accessed via the pk property on the model. ->>> e = Employee.objects.get(pk=123) ->>> e.pk -123 - -# Or we can use the real attribute name for the primary key: ->>> e.employee_code -123 - -# Fran got married and changed her last name. ->>> fran = Employee.objects.get(pk=456) ->>> fran.last_name = 'Jones' ->>> fran.save() ->>> Employee.objects.filter(last_name__exact='Jones') -[, ] ->>> emps = Employee.objects.in_bulk([123, 456]) ->>> emps[123] - - ->>> b = Business(name='Sears') ->>> b.save() ->>> b.employees.add(dan, fran) ->>> b.employees.all() -[, ] ->>> fran.business_set.all() -[] ->>> Business.objects.in_bulk(['Sears']) -{u'Sears': } - ->>> Business.objects.filter(name__exact='Sears') -[] ->>> Business.objects.filter(pk='Sears') -[] - -# Queries across tables, involving primary key ->>> Employee.objects.filter(business__name__exact='Sears') -[, ] ->>> Employee.objects.filter(business__pk='Sears') -[, ] - ->>> Business.objects.filter(employees__employee_code__exact=123) -[] ->>> Business.objects.filter(employees__pk=123) -[] ->>> Business.objects.filter(employees__first_name__startswith='Fran') -[] - -# Primary key may be unicode string ->>> bus = Business(name=u'jaźń') ->>> bus.save() - -# The primary key must also obviously be unique, so trying to create a new -# object with the same primary key will fail. ->>> try: -... sid = transaction.savepoint() -... Employee.objects.create(employee_code=123, first_name='Fred', last_name='Jones') -... transaction.savepoint_commit(sid) -... except Exception, e: -... if isinstance(e, IntegrityError): -... transaction.savepoint_rollback(sid) -... print "Pass" -... else: -... print "Fail with %s" % type(e) -Pass - -# Regression for #10785 -- Custom fields can be used for primary keys. ->>> new_bar = Bar.objects.create() ->>> new_foo = Foo.objects.create(bar=new_bar) - -# FIXME: This still doesn't work, but will require some changes in -# get_db_prep_lookup to fix it. -# >>> f = Foo.objects.get(bar=new_bar.pk) -# >>> f == new_foo -# True -# >>> f.bar == new_bar -# True - ->>> f = Foo.objects.get(bar=new_bar) ->>> f == new_foo -True ->>> f.bar == new_bar -True - -"""} - -# SQLite lets objects be saved with an empty primary key, even though an -# integer is expected. So we can't check for an error being raised in that case -# for SQLite. Remove it from the suite for this next bit. -if settings.DATABASES[DEFAULT_DB_ALIAS]['ENGINE'] != 'django.db.backends.sqlite3': - __test__["API_TESTS"] += """ -# The primary key must be specified, so an error is raised if you try to create -# an object without it. ->>> try: -... sid = transaction.savepoint() -... Employee.objects.create(first_name='Tom', last_name='Smith') -... print 'hello' -... transaction.savepoint_commit(sid) -... print 'hello2' -... except Exception, e: -... if isinstance(e, IntegrityError): -... transaction.savepoint_rollback(sid) -... print "Pass" -... else: -... print "Fail with %s" % type(e) -Pass - -""" diff --git a/tests/modeltests/custom_pk/tests.py b/tests/modeltests/custom_pk/tests.py new file mode 100644 index 00000000000..6ef4bdd4331 --- /dev/null +++ b/tests/modeltests/custom_pk/tests.py @@ -0,0 +1,183 @@ +# -*- coding: utf-8 -*- +from django.conf import settings +from django.db import DEFAULT_DB_ALIAS, transaction, IntegrityError +from django.test import TestCase + +from models import Employee, Business, Bar, Foo + + +class CustomPKTests(TestCase): + def test_custom_pk(self): + dan = Employee.objects.create( + employee_code=123, first_name="Dan", last_name="Jones" + ) + self.assertQuerysetEqual( + Employee.objects.all(), [ + "Dan Jones", + ], + unicode + ) + + fran = Employee.objects.create( + employee_code=456, first_name="Fran", last_name="Bones" + ) + self.assertQuerysetEqual( + Employee.objects.all(), [ + "Fran Bones", + "Dan Jones", + ], + unicode + ) + + self.assertEqual(Employee.objects.get(pk=123), dan) + self.assertEqual(Employee.objects.get(pk=456), fran) + + self.assertRaises(Employee.DoesNotExist, + lambda: Employee.objects.get(pk=42) + ) + + # Use the name of the primary key, rather than pk. + self.assertEqual(Employee.objects.get(employee_code=123), dan) + # pk can be used as a substitute for the primary key. + self.assertQuerysetEqual( + Employee.objects.filter(pk__in=[123, 456]), [ + "Fran Bones", + "Dan Jones", + ], + unicode + ) + # The primary key can be accessed via the pk property on the model. + e = Employee.objects.get(pk=123) + self.assertEqual(e.pk, 123) + # Or we can use the real attribute name for the primary key: + self.assertEqual(e.employee_code, 123) + + # Fran got married and changed her last name. + fran = Employee.objects.get(pk=456) + fran.last_name = "Jones" + fran.save() + + self.assertQuerysetEqual( + Employee.objects.filter(last_name="Jones"), [ + "Dan Jones", + "Fran Jones", + ], + unicode + ) + + emps = Employee.objects.in_bulk([123, 456]) + self.assertEqual(emps[123], dan) + + b = Business.objects.create(name="Sears") + b.employees.add(dan, fran) + self.assertQuerysetEqual( + b.employees.all(), [ + "Dan Jones", + "Fran Jones", + ], + unicode + ) + self.assertQuerysetEqual( + fran.business_set.all(), [ + "Sears", + ], + lambda b: b.name + ) + + self.assertEqual(Business.objects.in_bulk(["Sears"]), { + "Sears": b, + }) + + self.assertQuerysetEqual( + Business.objects.filter(name="Sears"), [ + "Sears" + ], + lambda b: b.name + ) + self.assertQuerysetEqual( + Business.objects.filter(pk="Sears"), [ + "Sears", + ], + lambda b: b.name + ) + + # Queries across tables, involving primary key + self.assertQuerysetEqual( + Employee.objects.filter(business__name="Sears"), [ + "Dan Jones", + "Fran Jones", + ], + unicode, + ) + self.assertQuerysetEqual( + Employee.objects.filter(business__pk="Sears"), [ + "Dan Jones", + "Fran Jones", + ], + unicode, + ) + + self.assertQuerysetEqual( + Business.objects.filter(employees__employee_code=123), [ + "Sears", + ], + lambda b: b.name + ) + self.assertQuerysetEqual( + Business.objects.filter(employees__pk=123), [ + "Sears", + ], + lambda b: b.name, + ) + + self.assertQuerysetEqual( + Business.objects.filter(employees__first_name__startswith="Fran"), [ + "Sears", + ], + lambda b: b.name + ) + + def test_unicode_pk(self): + # Primary key may be unicode string + bus = Business.objects.create(name=u'jaźń') + + def test_unique_pk(self): + # The primary key must also obviously be unique, so trying to create a + # new object with the same primary key will fail. + e = Employee.objects.create( + employee_code=123, first_name="Frank", last_name="Jones" + ) + sid = transaction.savepoint() + self.assertRaises(IntegrityError, + Employee.objects.create, employee_code=123, first_name="Fred", last_name="Jones" + ) + transaction.savepoint_rollback(sid) + + def test_custom_field_pk(self): + # Regression for #10785 -- Custom fields can be used for primary keys. + new_bar = Bar.objects.create() + new_foo = Foo.objects.create(bar=new_bar) + + # FIXME: This still doesn't work, but will require some changes in + # get_db_prep_lookup to fix it. + # f = Foo.objects.get(bar=new_bar.pk) + # self.assertEqual(f, new_foo) + # self.assertEqual(f.bar, new_bar) + + f = Foo.objects.get(bar=new_bar) + self.assertEqual(f, new_foo), + self.assertEqual(f.bar, new_bar) + + + # SQLite lets objects be saved with an empty primary key, even though an + # integer is expected. So we can't check for an error being raised in that + # case for SQLite. Remove it from the suite for this next bit. + if settings.DATABASES[DEFAULT_DB_ALIAS]['ENGINE'] != 'django.db.backends.sqlite3': + def test_required_pk(self): + # The primary key must be specified, so an error is raised if you + # try to create an object without it. + sid = transaction.savepoint() + self.assertRaises(IntegrityError, + Employee.objects.create, first_name="Tom", last_name="Smith" + ) + transaction.savepoint_rollback(sid)