1
0
mirror of https://github.com/django/django.git synced 2024-12-23 01:25:58 +00:00

Revert "Began implementing a shared set of test models to speed up tests."

This reverts commit 22b7870e40.
This commit is contained in:
Florian Apolloner 2013-06-10 12:22:40 +02:00
parent dfcce4288a
commit f5d4849cbe
5 changed files with 215 additions and 206 deletions

View File

@ -5,7 +5,6 @@ from operator import attrgetter
from django.core.exceptions import FieldError
from django.test import TestCase, skipUnlessDBFeature
from django.utils import six
from shared_models.models import Author, Book
@ -21,19 +20,19 @@ class LookupTests(TestCase):
self.au2 = Author(name='Author 2')
self.au2.save()
# Create a couple of Books.
self.b1 = Book(title='Book 1', pubdate=datetime(2005, 7, 26), author=self.au1)
self.b1 = Book(name='Book 1', pubdate=datetime(2005, 7, 26), author=self.au1)
self.b1.save()
self.b2 = Book(title='Book 2', pubdate=datetime(2005, 7, 27), author=self.au1)
self.b2 = Book(name='Book 2', pubdate=datetime(2005, 7, 27), author=self.au1)
self.b2.save()
self.b3 = Book(title='Book 3', pubdate=datetime(2005, 7, 27), author=self.au1)
self.b3 = Book(name='Book 3', pubdate=datetime(2005, 7, 27), author=self.au1)
self.b3.save()
self.b4 = Book(title='Book 4', pubdate=datetime(2005, 7, 28), author=self.au1)
self.b4 = Book(name='Book 4', pubdate=datetime(2005, 7, 28), author=self.au1)
self.b4.save()
self.b5 = Book(title='Book 5', pubdate=datetime(2005, 8, 1, 9, 0), author=self.au2)
self.b5 = Book(name='Book 5', pubdate=datetime(2005, 8, 1, 9, 0), author=self.au2)
self.b5.save()
self.b6 = Book(title='Book 6', pubdate=datetime(2005, 8, 1, 8, 0), author=self.au2)
self.b6 = Book(name='Book 6', pubdate=datetime(2005, 8, 1, 8, 0), author=self.au2)
self.b6.save()
self.b7 = Book(title='Book 7', pubdate=datetime(2005, 7, 27), author=self.au2)
self.b7 = Book(name='Book 7', pubdate=datetime(2005, 7, 27), author=self.au2)
self.b7.save()
# Create a few Tags.
self.t1 = Tag(name='Tag 1')
@ -86,18 +85,18 @@ class LookupTests(TestCase):
'Book 7',
'Book 1',
],
transform=attrgetter('title'))
transform=attrgetter('name'))
# iterator() can be used on any QuerySet.
self.assertQuerysetEqual(
Book.objects.filter(title__endswith='4').iterator(),
Book.objects.filter(name__endswith='4').iterator(),
['Book 4'],
transform=attrgetter('title'))
transform=attrgetter('name'))
def test_count(self):
# count() returns the number of objects matching search criteria.
self.assertEqual(Book.objects.count(), 7)
self.assertEqual(Book.objects.filter(pubdate__exact=datetime(2005, 7, 27)).count(), 3)
self.assertEqual(Book.objects.filter(title__startswith='Blah blah').count(), 0)
self.assertEqual(Book.objects.filter(name__startswith='Blah blah').count(), 0)
# count() should respect sliced query sets.
articles = Book.objects.all()
@ -129,43 +128,43 @@ class LookupTests(TestCase):
# values() returns a list of dictionaries instead of object instances --
# and you can specify which fields you want to retrieve.
identity = lambda x:x
self.assertQuerysetEqual(Book.objects.values('title'),
self.assertQuerysetEqual(Book.objects.values('name'),
[
{'title': 'Book 5'},
{'title': 'Book 6'},
{'title': 'Book 4'},
{'title': 'Book 2'},
{'title': 'Book 3'},
{'title': 'Book 7'},
{'title': 'Book 1'},
{'name': 'Book 5'},
{'name': 'Book 6'},
{'name': 'Book 4'},
{'name': 'Book 2'},
{'name': 'Book 3'},
{'name': 'Book 7'},
{'name': 'Book 1'},
],
transform=identity)
self.assertQuerysetEqual(
Book.objects.filter(pubdate__exact=datetime(2005, 7, 27)).values('id'),
[{'id': self.b2.id}, {'id': self.b3.id}, {'id': self.b7.id}],
transform=identity)
self.assertQuerysetEqual(Book.objects.values('id', 'title'),
self.assertQuerysetEqual(Book.objects.values('id', 'name'),
[
{'id': self.b5.id, 'title': 'Book 5'},
{'id': self.b6.id, 'title': 'Book 6'},
{'id': self.b4.id, 'title': 'Book 4'},
{'id': self.b2.id, 'title': 'Book 2'},
{'id': self.b3.id, 'title': 'Book 3'},
{'id': self.b7.id, 'title': 'Book 7'},
{'id': self.b1.id, 'title': 'Book 1'},
{'id': self.b5.id, 'name': 'Book 5'},
{'id': self.b6.id, 'name': 'Book 6'},
{'id': self.b4.id, 'name': 'Book 4'},
{'id': self.b2.id, 'name': 'Book 2'},
{'id': self.b3.id, 'name': 'Book 3'},
{'id': self.b7.id, 'name': 'Book 7'},
{'id': self.b1.id, 'name': 'Book 1'},
],
transform=identity)
# You can use values() with iterator() for memory savings,
# because iterator() uses database-level iteration.
self.assertQuerysetEqual(Book.objects.values('id', 'title').iterator(),
self.assertQuerysetEqual(Book.objects.values('id', 'name').iterator(),
[
{'title': 'Book 5', 'id': self.b5.id},
{'title': 'Book 6', 'id': self.b6.id},
{'title': 'Book 4', 'id': self.b4.id},
{'title': 'Book 2', 'id': self.b2.id},
{'title': 'Book 3', 'id': self.b3.id},
{'title': 'Book 7', 'id': self.b7.id},
{'title': 'Book 1', 'id': self.b1.id},
{'name': 'Book 5', 'id': self.b5.id},
{'name': 'Book 6', 'id': self.b6.id},
{'name': 'Book 4', 'id': self.b4.id},
{'name': 'Book 2', 'id': self.b2.id},
{'name': 'Book 3', 'id': self.b3.id},
{'name': 'Book 7', 'id': self.b7.id},
{'name': 'Book 1', 'id': self.b1.id},
],
transform=identity)
# The values() method works with "extra" fields specified in extra(select).
@ -205,39 +204,39 @@ class LookupTests(TestCase):
}], transform=identity)
# You can specify fields from forward and reverse relations, just like filter().
self.assertQuerysetEqual(
Book.objects.values('title', 'author__name'),
Book.objects.values('name', 'author__name'),
[
{'title': self.b5.title, 'author__name': self.au2.name},
{'title': self.b6.title, 'author__name': self.au2.name},
{'title': self.b4.title, 'author__name': self.au1.name},
{'title': self.b2.title, 'author__name': self.au1.name},
{'title': self.b3.title, 'author__name': self.au1.name},
{'title': self.b7.title, 'author__name': self.au2.name},
{'title': self.b1.title, 'author__name': self.au1.name},
{'name': self.b5.name, 'author__name': self.au2.name},
{'name': self.b6.name, 'author__name': self.au2.name},
{'name': self.b4.name, 'author__name': self.au1.name},
{'name': self.b2.name, 'author__name': self.au1.name},
{'name': self.b3.name, 'author__name': self.au1.name},
{'name': self.b7.name, 'author__name': self.au2.name},
{'name': self.b1.name, 'author__name': self.au1.name},
], transform=identity)
self.assertQuerysetEqual(
Author.objects.values('name', 'book__title').order_by('name', 'book__title'),
Author.objects.values('name', 'book__name').order_by('name', 'book__name'),
[
{'name': self.au1.name, 'book__title': self.b1.title},
{'name': self.au1.name, 'book__title': self.b2.title},
{'name': self.au1.name, 'book__title': self.b3.title},
{'name': self.au1.name, 'book__title': self.b4.title},
{'name': self.au2.name, 'book__title': self.b5.title},
{'name': self.au2.name, 'book__title': self.b6.title},
{'name': self.au2.name, 'book__title': self.b7.title},
{'name': self.au1.name, 'book__name': self.b1.name},
{'name': self.au1.name, 'book__name': self.b2.name},
{'name': self.au1.name, 'book__name': self.b3.name},
{'name': self.au1.name, 'book__name': self.b4.name},
{'name': self.au2.name, 'book__name': self.b5.name},
{'name': self.au2.name, 'book__name': self.b6.name},
{'name': self.au2.name, 'book__name': self.b7.name},
], transform=identity)
self.assertQuerysetEqual(
Author.objects.values('name', 'book__title', 'book__tag__name').order_by('name', 'book__title', 'book__tag__name'),
Author.objects.values('name', 'book__name', 'book__tag__name').order_by('name', 'book__name', 'book__tag__name'),
[
{'name': self.au1.name, 'book__title': self.b1.title, 'book__tag__name': self.t1.name},
{'name': self.au1.name, 'book__title': self.b2.title, 'book__tag__name': self.t1.name},
{'name': self.au1.name, 'book__title': self.b3.title, 'book__tag__name': self.t1.name},
{'name': self.au1.name, 'book__title': self.b3.title, 'book__tag__name': self.t2.name},
{'name': self.au1.name, 'book__title': self.b4.title, 'book__tag__name': self.t2.name},
{'name': self.au2.name, 'book__title': self.b5.title, 'book__tag__name': self.t2.name},
{'name': self.au2.name, 'book__title': self.b5.title, 'book__tag__name': self.t3.name},
{'name': self.au2.name, 'book__title': self.b6.title, 'book__tag__name': self.t3.name},
{'name': self.au2.name, 'book__title': self.b7.title, 'book__tag__name': self.t3.name},
{'name': self.au1.name, 'book__name': self.b1.name, 'book__tag__name': self.t1.name},
{'name': self.au1.name, 'book__name': self.b2.name, 'book__tag__name': self.t1.name},
{'name': self.au1.name, 'book__name': self.b3.name, 'book__tag__name': self.t1.name},
{'name': self.au1.name, 'book__name': self.b3.name, 'book__tag__name': self.t2.name},
{'name': self.au1.name, 'book__name': self.b4.name, 'book__tag__name': self.t2.name},
{'name': self.au2.name, 'book__name': self.b5.name, 'book__tag__name': self.t2.name},
{'name': self.au2.name, 'book__name': self.b5.name, 'book__tag__name': self.t3.name},
{'name': self.au2.name, 'book__name': self.b6.name, 'book__tag__name': self.t3.name},
{'name': self.au2.name, 'book__name': self.b7.name, 'book__tag__name': self.t3.name},
], transform=identity)
# However, an exception FieldDoesNotExist will be thrown if you specify
# a non-existent field name in values() (a field that is neither in the
@ -250,7 +249,7 @@ class LookupTests(TestCase):
[{
'id': self.b5.id,
'author_id': self.au2.id,
'title': 'Book 5',
'name': 'Book 5',
'pages': 0,
'pubdate': datetime(2005, 8, 1, 9, 0)
}], transform=identity)
@ -261,7 +260,7 @@ class LookupTests(TestCase):
# Within each tuple, the order of the elements is the same as the order
# of fields in the values_list() call.
identity = lambda x:x
self.assertQuerysetEqual(Book.objects.values_list('title'),
self.assertQuerysetEqual(Book.objects.values_list('name'),
[
('Book 5',),
('Book 6',),
@ -310,19 +309,19 @@ class LookupTests(TestCase):
],
transform=identity)
self.assertQuerysetEqual(
Author.objects.values_list('name', 'book__title', 'book__tag__name').order_by('name', 'book__title', 'book__tag__name'),
Author.objects.values_list('name', 'book__name', 'book__tag__name').order_by('name', 'book__name', 'book__tag__name'),
[
(self.au1.name, self.b1.title, self.t1.name),
(self.au1.name, self.b2.title, self.t1.name),
(self.au1.name, self.b3.title, self.t1.name),
(self.au1.name, self.b3.title, self.t2.name),
(self.au1.name, self.b4.title, self.t2.name),
(self.au2.name, self.b5.title, self.t2.name),
(self.au2.name, self.b5.title, self.t3.name),
(self.au2.name, self.b6.title, self.t3.name),
(self.au2.name, self.b7.title, self.t3.name),
(self.au1.name, self.b1.name, self.t1.name),
(self.au1.name, self.b2.name, self.t1.name),
(self.au1.name, self.b3.name, self.t1.name),
(self.au1.name, self.b3.name, self.t2.name),
(self.au1.name, self.b4.name, self.t2.name),
(self.au2.name, self.b5.name, self.t2.name),
(self.au2.name, self.b5.name, self.t3.name),
(self.au2.name, self.b6.name, self.t3.name),
(self.au2.name, self.b7.name, self.t3.name),
], transform=identity)
self.assertRaises(TypeError, Book.objects.values_list, 'id', 'title', flat=True)
self.assertRaises(TypeError, Book.objects.values_list, 'id', 'name', flat=True)
def test_get_next_previous_by(self):
# Every DateField and DateTimeField creates get_next_by_FOO() and
@ -333,7 +332,7 @@ class LookupTests(TestCase):
'<Book: Book 2>')
self.assertEqual(repr(self.b2.get_next_by_pubdate()),
'<Book: Book 3>')
self.assertEqual(repr(self.b2.get_next_by_pubdate(title__endswith='6')),
self.assertEqual(repr(self.b2.get_next_by_pubdate(name__endswith='6')),
'<Book: Book 6>')
self.assertEqual(repr(self.b3.get_next_by_pubdate()),
'<Book: Book 7>')
@ -361,9 +360,9 @@ class LookupTests(TestCase):
def test_escaping(self):
# Underscores, percent signs and backslashes have special meaning in the
# underlying SQL code, but Django handles the quoting of them automatically.
b8 = Book(title='Book_ with underscore', pubdate=datetime(2005, 11, 20))
b8 = Book(name='Book_ with underscore', pubdate=datetime(2005, 11, 20))
b8.save()
self.assertQuerysetEqual(Book.objects.filter(title__startswith='Book'),
self.assertQuerysetEqual(Book.objects.filter(name__startswith='Book'),
[
'<Book: Book_ with underscore>',
'<Book: Book 5>',
@ -374,11 +373,11 @@ class LookupTests(TestCase):
'<Book: Book 7>',
'<Book: Book 1>',
])
self.assertQuerysetEqual(Book.objects.filter(title__startswith='Book_'),
self.assertQuerysetEqual(Book.objects.filter(name__startswith='Book_'),
['<Book: Book_ with underscore>'])
b9 = Book(title='Book% with percent sign', pubdate=datetime(2005, 11, 21))
b9 = Book(name='Book% with percent sign', pubdate=datetime(2005, 11, 21))
b9.save()
self.assertQuerysetEqual(Book.objects.filter(title__startswith='Book'),
self.assertQuerysetEqual(Book.objects.filter(name__startswith='Book'),
[
'<Book: Book% with percent sign>',
'<Book: Book_ with underscore>',
@ -390,21 +389,21 @@ class LookupTests(TestCase):
'<Book: Book 7>',
'<Book: Book 1>',
])
self.assertQuerysetEqual(Book.objects.filter(title__startswith='Book%'),
self.assertQuerysetEqual(Book.objects.filter(name__startswith='Book%'),
['<Book: Book% with percent sign>'])
b10 = Book(title='Book with \\ backslash', pubdate=datetime(2005, 11, 22))
b10 = Book(name='Book with \\ backslash', pubdate=datetime(2005, 11, 22))
b10.save()
self.assertQuerysetEqual(Book.objects.filter(title__contains='\\'),
self.assertQuerysetEqual(Book.objects.filter(name__contains='\\'),
['<Book: Book with \ backslash>'])
def test_exclude(self):
b8 = Book.objects.create(title='Book_ with underscore', pubdate=datetime(2005, 11, 20))
b9 = Book.objects.create(title='Book% with percent sign', pubdate=datetime(2005, 11, 21))
b10 = Book.objects.create(title='Book with \\ backslash', pubdate=datetime(2005, 11, 22))
b8 = Book.objects.create(name='Book_ with underscore', pubdate=datetime(2005, 11, 20))
b9 = Book.objects.create(name='Book% with percent sign', pubdate=datetime(2005, 11, 21))
b10 = Book.objects.create(name='Book with \\ backslash', pubdate=datetime(2005, 11, 22))
# exclude() is the opposite of filter() when doing lookups:
self.assertQuerysetEqual(
Book.objects.filter(title__contains='Book').exclude(title__contains='with'),
Book.objects.filter(name__contains='Book').exclude(name__contains='with'),
[
'<Book: Book 5>',
'<Book: Book 6>',
@ -414,7 +413,7 @@ class LookupTests(TestCase):
'<Book: Book 7>',
'<Book: Book 1>',
])
self.assertQuerysetEqual(Book.objects.exclude(title__startswith="Book_"),
self.assertQuerysetEqual(Book.objects.exclude(name__startswith="Book_"),
[
'<Book: Book with \\ backslash>',
'<Book: Book% with percent sign>',
@ -426,7 +425,7 @@ class LookupTests(TestCase):
'<Book: Book 7>',
'<Book: Book 1>',
])
self.assertQuerysetEqual(Book.objects.exclude(title="Book 7"),
self.assertQuerysetEqual(Book.objects.exclude(name="Book 7"),
[
'<Book: Book with \\ backslash>',
'<Book: Book% with percent sign>',
@ -443,12 +442,12 @@ class LookupTests(TestCase):
# none() returns a QuerySet that behaves like any other QuerySet object
self.assertQuerysetEqual(Book.objects.none(), [])
self.assertQuerysetEqual(
Book.objects.none().filter(title__startswith='Book'), [])
Book.objects.none().filter(name__startswith='Book'), [])
self.assertQuerysetEqual(
Book.objects.filter(title__startswith='Book').none(), [])
Book.objects.filter(name__startswith='Book').none(), [])
self.assertEqual(Book.objects.none().count(), 0)
self.assertEqual(
Book.objects.none().update(title="This should not take effect"), 0)
Book.objects.none().update(name="This should not take effect"), 0)
self.assertQuerysetEqual(
[article for article in Book.objects.none().iterator()],
[])
@ -469,41 +468,46 @@ class LookupTests(TestCase):
def test_error_messages(self):
# Programming errors are pointed out with nice error messages
with six.assertRaisesRegex(self, FieldError, "Cannot resolve keyword 'pubdate_year' "
"into field. Choices are: .+"):
try:
Book.objects.filter(pubdate_year='2005').count()
with self.assertRaises(FieldError, msg="Join on field 'title' not permitted. "
"Did you misspell 'starts' for the lookup type?"):
Book.objects.filter(title__starts='Book')
self.fail('FieldError not raised')
except FieldError as ex:
self.assertEqual(str(ex), "Cannot resolve keyword 'pubdate_year' "
"into field. Choices are: author, id, name, pages, pubdate, tag, tags")
try:
Book.objects.filter(name__starts='Book')
self.fail('FieldError not raised')
except FieldError as ex:
self.assertEqual(str(ex), "Join on field 'name' not permitted. "
"Did you misspell 'starts' for the lookup type?")
def test_regex(self):
# Create some articles with a bit more interesting names for testing field lookups:
for a in Book.objects.all():
a.delete()
now = datetime.now()
b1 = Book(pubdate=now, title='f')
b1 = Book(pubdate=now, name='f')
b1.save()
b2 = Book(pubdate=now, title='fo')
b2 = Book(pubdate=now, name='fo')
b2.save()
b3 = Book(pubdate=now, title='foo')
b3 = Book(pubdate=now, name='foo')
b3.save()
b4 = Book(pubdate=now, title='fooo')
b4 = Book(pubdate=now, name='fooo')
b4.save()
b5 = Book(pubdate=now, title='hey-Foo')
b5 = Book(pubdate=now, name='hey-Foo')
b5.save()
b6 = Book(pubdate=now, title='bar')
b6 = Book(pubdate=now, name='bar')
b6.save()
b7 = Book(pubdate=now, title='AbBa')
b7 = Book(pubdate=now, name='AbBa')
b7.save()
b8 = Book(pubdate=now, title='baz')
b8 = Book(pubdate=now, name='baz')
b8.save()
b9 = Book(pubdate=now, title='baxZ')
b9 = Book(pubdate=now, name='baxZ')
b9.save()
# zero-or-more
self.assertQuerysetEqual(Book.objects.filter(title__regex=r'fo*'),
self.assertQuerysetEqual(Book.objects.filter(name__regex=r'fo*'),
['<Book: f>', '<Book: fo>', '<Book: foo>', '<Book: fooo>'])
self.assertQuerysetEqual(Book.objects.filter(title__iregex=r'fo*'),
self.assertQuerysetEqual(Book.objects.filter(name__iregex=r'fo*'),
[
'<Book: f>',
'<Book: fo>',
@ -512,54 +516,54 @@ class LookupTests(TestCase):
'<Book: hey-Foo>',
])
# one-or-more
self.assertQuerysetEqual(Book.objects.filter(title__regex=r'fo+'),
self.assertQuerysetEqual(Book.objects.filter(name__regex=r'fo+'),
['<Book: fo>', '<Book: foo>', '<Book: fooo>'])
# wildcard
self.assertQuerysetEqual(Book.objects.filter(title__regex=r'fooo?'),
self.assertQuerysetEqual(Book.objects.filter(name__regex=r'fooo?'),
['<Book: foo>', '<Book: fooo>'])
# leading anchor
self.assertQuerysetEqual(Book.objects.filter(title__regex=r'^b'),
self.assertQuerysetEqual(Book.objects.filter(name__regex=r'^b'),
['<Book: bar>', '<Book: baxZ>', '<Book: baz>'])
self.assertQuerysetEqual(Book.objects.filter(title__iregex=r'^a'),
self.assertQuerysetEqual(Book.objects.filter(name__iregex=r'^a'),
['<Book: AbBa>'])
# trailing anchor
self.assertQuerysetEqual(Book.objects.filter(title__regex=r'z$'),
self.assertQuerysetEqual(Book.objects.filter(name__regex=r'z$'),
['<Book: baz>'])
self.assertQuerysetEqual(Book.objects.filter(title__iregex=r'z$'),
self.assertQuerysetEqual(Book.objects.filter(name__iregex=r'z$'),
['<Book: baxZ>', '<Book: baz>'])
# character sets
self.assertQuerysetEqual(Book.objects.filter(title__regex=r'ba[rz]'),
self.assertQuerysetEqual(Book.objects.filter(name__regex=r'ba[rz]'),
['<Book: bar>', '<Book: baz>'])
self.assertQuerysetEqual(Book.objects.filter(title__regex=r'ba.[RxZ]'),
self.assertQuerysetEqual(Book.objects.filter(name__regex=r'ba.[RxZ]'),
['<Book: baxZ>'])
self.assertQuerysetEqual(Book.objects.filter(title__iregex=r'ba[RxZ]'),
self.assertQuerysetEqual(Book.objects.filter(name__iregex=r'ba[RxZ]'),
['<Book: bar>', '<Book: baxZ>', '<Book: baz>'])
# and more articles:
b10 = Book(pubdate=now, title='foobar')
b10 = Book(pubdate=now, name='foobar')
b10.save()
b11 = Book(pubdate=now, title='foobaz')
b11 = Book(pubdate=now, name='foobaz')
b11.save()
b12 = Book(pubdate=now, title='ooF')
b12 = Book(pubdate=now, name='ooF')
b12.save()
b13 = Book(pubdate=now, title='foobarbaz')
b13 = Book(pubdate=now, name='foobarbaz')
b13.save()
b14 = Book(pubdate=now, title='zoocarfaz')
b14 = Book(pubdate=now, name='zoocarfaz')
b14.save()
b15 = Book(pubdate=now, title='barfoobaz')
b15 = Book(pubdate=now, name='barfoobaz')
b15.save()
b16 = Book(pubdate=now, title='bazbaRFOO')
b16 = Book(pubdate=now, name='bazbaRFOO')
b16.save()
# alternation
self.assertQuerysetEqual(Book.objects.filter(title__regex=r'oo(f|b)'),
self.assertQuerysetEqual(Book.objects.filter(name__regex=r'oo(f|b)'),
[
'<Book: barfoobaz>',
'<Book: foobar>',
'<Book: foobarbaz>',
'<Book: foobaz>',
])
self.assertQuerysetEqual(Book.objects.filter(title__iregex=r'oo(f|b)'),
self.assertQuerysetEqual(Book.objects.filter(name__iregex=r'oo(f|b)'),
[
'<Book: barfoobaz>',
'<Book: foobar>',
@ -567,11 +571,11 @@ class LookupTests(TestCase):
'<Book: foobaz>',
'<Book: ooF>',
])
self.assertQuerysetEqual(Book.objects.filter(title__regex=r'^foo(f|b)'),
self.assertQuerysetEqual(Book.objects.filter(name__regex=r'^foo(f|b)'),
['<Book: foobar>', '<Book: foobarbaz>', '<Book: foobaz>'])
# greedy matching
self.assertQuerysetEqual(Book.objects.filter(title__regex=r'b.*az'),
self.assertQuerysetEqual(Book.objects.filter(name__regex=r'b.*az'),
[
'<Book: barfoobaz>',
'<Book: baz>',
@ -579,7 +583,7 @@ class LookupTests(TestCase):
'<Book: foobarbaz>',
'<Book: foobaz>',
])
self.assertQuerysetEqual(Book.objects.filter(title__iregex=r'b.*ar'),
self.assertQuerysetEqual(Book.objects.filter(name__iregex=r'b.*ar'),
[
'<Book: bar>',
'<Book: barfoobaz>',
@ -592,21 +596,21 @@ class LookupTests(TestCase):
def test_regex_backreferencing(self):
# grouping and backreferences
now = datetime.now()
b10 = Book(pubdate=now, title='foobar')
b10 = Book(pubdate=now, name='foobar')
b10.save()
b11 = Book(pubdate=now, title='foobaz')
b11 = Book(pubdate=now, name='foobaz')
b11.save()
b12 = Book(pubdate=now, title='ooF')
b12 = Book(pubdate=now, name='ooF')
b12.save()
b13 = Book(pubdate=now, title='foobarbaz')
b13 = Book(pubdate=now, name='foobarbaz')
b13.save()
b14 = Book(pubdate=now, title='zoocarfaz')
b14 = Book(pubdate=now, name='zoocarfaz')
b14.save()
b15 = Book(pubdate=now, title='barfoobaz')
b15 = Book(pubdate=now, name='barfoobaz')
b15.save()
b16 = Book(pubdate=now, title='bazbaRFOO')
b16 = Book(pubdate=now, name='bazbaRFOO')
b16.save()
self.assertQuerysetEqual(Book.objects.filter(title__regex=r'b(.).*b\1'),
self.assertQuerysetEqual(Book.objects.filter(name__regex=r'b(.).*b\1'),
['<Book: barfoobaz>', '<Book: bazbaRFOO>', '<Book: foobarbaz>'])
def test_nonfield_lookups(self):

View File

@ -17,7 +17,6 @@ from django.db import models
from django.utils import six
from django.utils.encoding import python_2_unicode_compatible
from shared_models.models import Author, Book
temp_storage_dir = tempfile.mkdtemp(dir=os.environ['DJANGO_TEST_TEMP_DIR'])
temp_storage = FileSystemStorage(temp_storage_dir)
@ -46,13 +45,23 @@ class Category(models.Model):
def __repr__(self):
return self.__str__()
@python_2_unicode_compatible
class Writer(models.Model):
name = models.CharField(max_length=50, help_text='Use both first and last names.')
class Meta:
ordering = ('name',)
def __str__(self):
return self.name
@python_2_unicode_compatible
class Article(models.Model):
headline = models.CharField(max_length=50)
slug = models.SlugField()
pub_date = models.DateField()
created = models.DateField(editable=False)
writer = models.ForeignKey(Author)
writer = models.ForeignKey(Writer)
article = models.TextField()
categories = models.ManyToManyField(Category, blank=True)
status = models.PositiveIntegerField(choices=ARTICLE_STATUS, blank=True, null=True)
@ -72,12 +81,12 @@ class ImprovedArticle(models.Model):
class ImprovedArticleWithParentLink(models.Model):
article = models.OneToOneField(Article, parent_link=True)
class BetterAuthor(Author):
class BetterWriter(Writer):
score = models.IntegerField()
@python_2_unicode_compatible
class AuthorProfile(models.Model):
writer = models.OneToOneField(Author, primary_key=True)
class WriterProfile(models.Model):
writer = models.OneToOneField(Writer, primary_key=True)
age = models.PositiveIntegerField()
def __str__(self):
@ -177,6 +186,14 @@ class Inventory(models.Model):
def __repr__(self):
return self.__str__()
class Book(models.Model):
title = models.CharField(max_length=40)
author = models.ForeignKey(Writer, blank=True, null=True)
special_id = models.IntegerField(blank=True, null=True, unique=True)
class Meta:
unique_together = ('title', 'author')
class BookXtra(models.Model):
isbn = models.CharField(max_length=16, unique=True)
suffix1 = models.IntegerField(blank=True, default=0)

View File

@ -17,13 +17,11 @@ from django.utils.unittest import skipUnless
from django.test import TestCase
from django.utils import six
from shared_models.models import Author, Book
from .models import (Article, ArticleStatus, BetterAuthor, BigInt,
from .models import (Article, ArticleStatus, BetterWriter, BigInt, Book,
Category, CommaSeparatedInteger, CustomFieldForExclusionModel, DerivedBook,
DerivedPost, ExplicitPK, FlexibleDatePost, ImprovedArticle,
ImprovedArticleWithParentLink, Inventory, Post, Price,
Product, TextFile, AuthorProfile, Colour, ColourfulItem,
Product, TextFile, Writer, WriterProfile, Colour, ColourfulItem,
ArticleStatusNote, DateTimePost, test_images)
if test_images:
@ -54,13 +52,11 @@ class PriceForm(forms.ModelForm):
class BookForm(forms.ModelForm):
class Meta:
fields = ['title', 'author', 'pubdate']
model = Book
class DerivedBookForm(forms.ModelForm):
class Meta:
fields = ['title', 'author', 'isbn', 'suffix1', 'suffix2']
model = DerivedBook
@ -88,11 +84,11 @@ class DerivedPostForm(forms.ModelForm):
fields = '__all__'
class CustomAuthorForm(forms.ModelForm):
class CustomWriterForm(forms.ModelForm):
name = forms.CharField(required=False)
class Meta:
model = Author
model = Writer
fields = '__all__'
@ -128,7 +124,7 @@ class PartialArticleForm(forms.ModelForm):
class RoykoForm(forms.ModelForm):
class Meta:
model = Author
model = Writer
fields = '__all__'
@ -188,15 +184,14 @@ class ImprovedArticleWithParentLinkForm(forms.ModelForm):
fields = '__all__'
class BetterAuthorForm(forms.ModelForm):
class BetterWriterForm(forms.ModelForm):
class Meta:
model = BetterAuthor
model = BetterWriter
fields = '__all__'
class AuthorProfileForm(forms.ModelForm):
class WriterProfileForm(forms.ModelForm):
class Meta:
model = AuthorProfile
model = WriterProfile
fields = '__all__'
@ -324,14 +319,14 @@ class ModelFormBaseTest(TestCase):
forms.fields.BooleanField)
def test_override_field(self):
class AuthorForm(forms.ModelForm):
class WriterForm(forms.ModelForm):
book = forms.CharField(required=False)
class Meta:
model = Author
model = Writer
fields = '__all__'
wf = AuthorForm({'name': 'Richard Lockridge'})
wf = WriterForm({'name': 'Richard Lockridge'})
self.assertTrue(wf.is_valid())
def test_limit_nonexistent_field(self):
@ -556,7 +551,7 @@ class ValidationTest(TestCase):
assert form.is_valid()
def test_notrequired_overrides_notblank(self):
form = CustomAuthorForm({})
form = CustomWriterForm({})
assert form.is_valid()
@ -565,7 +560,7 @@ class ValidationTest(TestCase):
# unique/unique_together validation
class UniqueTest(TestCase):
def setUp(self):
self.author = Author.objects.create(name='Mike Royko')
self.writer = Writer.objects.create(name='Mike Royko')
def test_simple_unique(self):
form = ProductForm({'slug': 'teddy-bear-blue'})
@ -589,31 +584,33 @@ class UniqueTest(TestCase):
def test_unique_null(self):
title = 'I May Be Wrong But I Doubt It'
form = BookForm({'title': title, 'author': self.author.pk, 'pubdate': '2012-12-12 00:00:00'})
form = BookForm({'title': title, 'author': self.writer.pk})
self.assertTrue(form.is_valid())
form.save()
form = BookForm({'title': title, 'author': self.author.pk, 'pubdate': '2012-12-12 00:00:00'})
form = BookForm({'title': title, 'author': self.writer.pk})
self.assertFalse(form.is_valid())
self.assertEqual(len(form.errors), 1)
self.assertEqual(form.errors['__all__'], ['Book with this Title and Author already exists.'])
form = BookForm({'title': title, 'pubdate': '2012-12-12 00:00:00'})
form = BookForm({'title': title})
self.assertTrue(form.is_valid())
form.save()
form = BookForm({'title': title, 'pubdate': '2012-12-12 00:00:00'})
form = BookForm({'title': title})
self.assertTrue(form.is_valid())
def test_inherited_unique(self):
form = BetterAuthorForm({'name': 'Mike Royko', 'score': 3})
title = 'Boss'
Book.objects.create(title=title, author=self.writer, special_id=1)
form = DerivedBookForm({'title': 'Other', 'author': self.writer.pk, 'special_id': '1', 'isbn': '12345'})
self.assertFalse(form.is_valid())
self.assertEqual(len(form.errors), 1)
self.assertEqual(form.errors['name'], ['Author with this Name already exists.'])
self.assertEqual(form.errors['special_id'], ['Book with this Special id already exists.'])
def test_inherited_unique_together(self):
title = 'Boss'
form = BookForm({'title': title, 'author': self.author.pk, 'pubdate': '2012-12-12 00:00:00'})
form = BookForm({'title': title, 'author': self.writer.pk})
self.assertTrue(form.is_valid())
form.save()
form = DerivedBookForm({'title': title, 'author': self.author.pk, 'isbn': '12345'})
form = DerivedBookForm({'title': title, 'author': self.writer.pk, 'isbn': '12345'})
self.assertFalse(form.is_valid())
self.assertEqual(len(form.errors), 1)
self.assertEqual(form.errors['__all__'], ['Book with this Title and Author already exists.'])
@ -621,9 +618,8 @@ class UniqueTest(TestCase):
def test_abstract_inherited_unique(self):
title = 'Boss'
isbn = '12345'
dbook = DerivedBook.objects.create(title=title, author=self.author, isbn=isbn,
pubdate='2012-12-12 00:00')
form = DerivedBookForm({'title': 'Other', 'author': self.author.pk, 'isbn': isbn})
dbook = DerivedBook.objects.create(title=title, author=self.writer, isbn=isbn)
form = DerivedBookForm({'title': 'Other', 'author': self.writer.pk, 'isbn': isbn})
self.assertFalse(form.is_valid())
self.assertEqual(len(form.errors), 1)
self.assertEqual(form.errors['isbn'], ['Derived book with this Isbn already exists.'])
@ -631,11 +627,10 @@ class UniqueTest(TestCase):
def test_abstract_inherited_unique_together(self):
title = 'Boss'
isbn = '12345'
dbook = DerivedBook.objects.create(title=title, author=self.author, isbn=isbn,
pubdate='2012-12-12 00:00')
dbook = DerivedBook.objects.create(title=title, author=self.writer, isbn=isbn)
form = DerivedBookForm({
'title': 'Other',
'author': self.author.pk,
'author': self.writer.pk,
'isbn': '9876',
'suffix1': '0',
'suffix2': '0'
@ -753,7 +748,7 @@ class ModelToDictTests(TestCase):
]
for c in categories:
c.save()
writer = Author(name='Test writer')
writer = Writer(name='Test writer')
writer.save()
art = Article(
@ -862,10 +857,10 @@ class OldFormForXTests(TestCase):
with self.assertRaises(ValueError):
f.save()
# Create a couple of Authors.
w_royko = Author(name='Mike Royko')
# Create a couple of Writers.
w_royko = Writer(name='Mike Royko')
w_royko.save()
w_woodward = Author(name='Bob Woodward')
w_woodward = Writer(name='Bob Woodward')
w_woodward.save()
# ManyToManyFields are represented by a MultipleChoiceField, ForeignKeys and any
# fields with the 'choices' attribute are represented by a ChoiceField.
@ -903,9 +898,9 @@ class OldFormForXTests(TestCase):
# When the ModelForm is passed an instance, that instance's current values are
# inserted as 'initial' data in each Field.
w = Author.objects.get(name='Mike Royko')
w = Writer.objects.get(name='Mike Royko')
f = RoykoForm(auto_id=False, instance=w)
self.assertHTMLEqual(six.text_type(f), '''<tr><th>Name:</th><td><input type="text" name="name" value="Mike Royko" maxlength="100" /><br /><span class="helptext">Use both first and last names.</span></td></tr>''')
self.assertHTMLEqual(six.text_type(f), '''<tr><th>Name:</th><td><input type="text" name="name" value="Mike Royko" maxlength="50" /><br /><span class="helptext">Use both first and last names.</span></td></tr>''')
art = Article(
headline='Test article',
@ -1117,7 +1112,7 @@ class OldFormForXTests(TestCase):
c4 = Category.objects.create(name='Fourth', url='4th')
self.assertEqual(c4.name, 'Fourth')
w_bernstein = Author.objects.create(name='Carl Bernstein')
w_bernstein = Writer.objects.create(name='Carl Bernstein')
self.assertEqual(w_bernstein.name, 'Carl Bernstein')
self.assertHTMLEqual(f.as_ul(), '''<li>Headline: <input type="text" name="headline" maxlength="50" /></li>
<li>Slug: <input type="text" name="slug" maxlength="50" /></li>
@ -1294,17 +1289,17 @@ class OldFormForXTests(TestCase):
self.assertEqual(list(ImprovedArticleWithParentLinkForm.base_fields), [])
bw = BetterAuthor(name='Joe Better', score=10)
bw = BetterWriter(name='Joe Better', score=10)
bw.save()
self.assertEqual(sorted(model_to_dict(bw)),
['author_ptr', 'id', 'name', 'score'])
['id', 'name', 'score', 'writer_ptr'])
form = BetterAuthorForm({'name': 'Some Name', 'score': 12})
form = BetterWriterForm({'name': 'Some Name', 'score': 12})
self.assertEqual(form.is_valid(), True)
bw2 = form.save()
bw2.delete()
form = AuthorProfileForm()
form = WriterProfileForm()
self.assertHTMLEqual(form.as_p(), '''<p><label for="id_writer">Writer:</label> <select name="writer" id="id_writer">
<option value="" selected="selected">---------</option>
<option value="%s">Bob Woodward</option>
@ -1318,11 +1313,11 @@ class OldFormForXTests(TestCase):
'writer': six.text_type(w_woodward.pk),
'age': '65',
}
form = AuthorProfileForm(data)
form = WriterProfileForm(data)
instance = form.save()
self.assertEqual(six.text_type(instance), 'Bob Woodward is 65')
form = AuthorProfileForm(instance=instance)
form = WriterProfileForm(instance=instance)
self.assertHTMLEqual(form.as_p(), '''<p><label for="id_writer">Writer:</label> <select name="writer" id="id_writer">
<option value="">---------</option>
<option value="%s" selected="selected">Bob Woodward</option>

View File

@ -1,5 +1,3 @@
from __future__ import unicode_literals
from django.db import models
from django.utils import timezone
from django.utils.encoding import python_2_unicode_compatible
@ -11,11 +9,7 @@ class Tag(models.Model):
@python_2_unicode_compatible
class Author(models.Model):
name = models.CharField(max_length=100, help_text='Use both first and last names.',
unique=True)
class Meta:
ordering = ['name']
name = models.CharField(max_length=100)
def __str__(self):
return self.name
@ -23,15 +17,14 @@ class Author(models.Model):
@python_2_unicode_compatible
class Book(models.Model):
title = models.CharField(max_length=200)
name = models.CharField(max_length=200)
pages = models.IntegerField(default=0)
author = models.ForeignKey(Author, null=True, blank=True)
author = models.ForeignKey(Author, null=True)
pubdate = models.DateTimeField()
tags = models.ManyToManyField(Tag)
class Meta:
ordering = ['-pubdate', 'title']
unique_together = ['title', 'author']
ordering = ['-pubdate', 'name']
def __str__(self):
return self.title
return self.name

View File

@ -77,7 +77,7 @@ class SignalsRegressTests(TestCase):
"Is created"
])
b1 = Book(title='Snow Crash', pubdate='2012-02-02 12:00')
b1 = Book(name='Snow Crash', pubdate='2012-02-02 12:00')
self.assertEqual(self.get_signal_output(b1.save), [
"pre_save signal, Snow Crash",
"post_save signal, Snow Crash",
@ -87,7 +87,7 @@ class SignalsRegressTests(TestCase):
def test_m2m_signals(self):
""" Assigning and removing to/from m2m shouldn't generate an m2m signal """
b1 = Book(title='Snow Crash', pubdate='2012-02-02 12:00')
b1 = Book(name='Snow Crash', pubdate='2012-02-02 12:00')
self.get_signal_output(b1.save)
a1 = Author(name='Neal Stephenson')
self.get_signal_output(a1.save)