mirror of
https://github.com/django/django.git
synced 2025-07-05 18:29:11 +00:00
Merged trunk changes r13307:13316 into test-refactor SoC branch.
git-svn-id: http://code.djangoproject.com/svn/django/branches/soc2010/test-refactor@13317 bcc190cf-cafb-0310-a4f2-bffc1f526a37
This commit is contained in:
Paul McMillan
parent
6c10480e99
commit
8bdf160e05
@ -218,13 +218,15 @@ class BaseCommand(object):
|
||||
output = self.handle(*args, **options)
|
||||
if output:
|
||||
if self.output_transaction:
|
||||
# This needs to be imported here, because it relies on settings.
|
||||
from django.db import connection
|
||||
# This needs to be imported here, because it relies on
|
||||
# settings.
|
||||
from django.db import connections, DEFAULT_DB_ALIAS
|
||||
connection = connections[options.get('database', DEFAULT_DB_ALIAS)]
|
||||
if connection.ops.start_transaction_sql():
|
||||
print self.style.SQL_KEYWORD(connection.ops.start_transaction_sql())
|
||||
print output
|
||||
if self.output_transaction:
|
||||
print self.style.SQL_KEYWORD("COMMIT;")
|
||||
print self.style.SQL_KEYWORD(connection.ops.end_transaction_sql())
|
||||
except CommandError, e:
|
||||
sys.stderr.write(smart_str(self.style.ERROR('Error: %s\n' % e)))
|
||||
sys.exit(1)
|
||||
|
||||
@ -353,6 +353,11 @@ class BaseDatabaseOperations(object):
|
||||
"""
|
||||
return "BEGIN;"
|
||||
|
||||
def end_transaction_sql(self, success=True):
|
||||
if not success:
|
||||
return "ROLLBACK;"
|
||||
return "COMMIT;"
|
||||
|
||||
def tablespace_sql(self, tablespace, inline=False):
|
||||
"""
|
||||
Returns the SQL that will be appended to tables or rows to define
|
||||
|
||||
@ -177,14 +177,14 @@ class QueryDict(MultiValueDict):
|
||||
super(QueryDict, self).__delitem__(key)
|
||||
|
||||
def __copy__(self):
|
||||
result = self.__class__('', mutable=True)
|
||||
result = self.__class__('', mutable=True, encoding=self.encoding)
|
||||
for key, value in dict.items(self):
|
||||
dict.__setitem__(result, key, value)
|
||||
return result
|
||||
|
||||
def __deepcopy__(self, memo):
|
||||
import django.utils.copycompat as copy
|
||||
result = self.__class__('', mutable=True)
|
||||
result = self.__class__('', mutable=True, encoding=self.encoding)
|
||||
memo[id(self)] = result
|
||||
for key, value in dict.items(self):
|
||||
dict.__setitem__(result, copy.deepcopy(key, memo), copy.deepcopy(value, memo))
|
||||
|
||||
@ -466,6 +466,9 @@ class TransactionTestCase(unittest.TestCase):
|
||||
msg_prefix + "Template '%s' was used unexpectedly in rendering"
|
||||
" the response" % template_name)
|
||||
|
||||
def assertQuerysetEqual(self, qs, values, transform=repr):
|
||||
return self.assertEqual(map(transform, qs), values)
|
||||
|
||||
def connections_support_transactions():
|
||||
"""
|
||||
Returns True if all connections support transactions. This is messy
|
||||
|
||||
@ -1,17 +1,17 @@
|
||||
"""
|
||||
The md5 and sha modules are deprecated since Python 2.5, replaced by the
|
||||
hashlib module containing both hash algorithms. Here, we provide a common
|
||||
interface to the md5 and sha constructors, preferring the hashlib module when
|
||||
available.
|
||||
interface to the md5 and sha constructors, depending on system version.
|
||||
"""
|
||||
|
||||
try:
|
||||
import sys
|
||||
if sys.version_info >= (2, 5):
|
||||
import hashlib
|
||||
md5_constructor = hashlib.md5
|
||||
md5_hmac = md5_constructor
|
||||
sha_constructor = hashlib.sha1
|
||||
sha_hmac = sha_constructor
|
||||
except ImportError:
|
||||
else:
|
||||
import md5
|
||||
md5_constructor = md5.new
|
||||
md5_hmac = md5
|
||||
|
||||
@ -12,7 +12,7 @@ from django.utils.importlib import import_module
|
||||
from django.utils.encoding import smart_unicode, smart_str
|
||||
|
||||
|
||||
HIDDEN_SETTINGS = re.compile('SECRET|PASSWORD|PROFANITIES_LIST')
|
||||
HIDDEN_SETTINGS = re.compile('SECRET|PASSWORD|PROFANITIES_LIST|SIGNATURE')
|
||||
|
||||
def linebreak_iter(template_source):
|
||||
yield 0
|
||||
|
||||
@ -1189,7 +1189,7 @@ your admin page for managing the relation.
|
||||
|
||||
In all other respects, the ``InlineModelAdmin`` is exactly the same as any
|
||||
other. You can customize the appearance using any of the normal
|
||||
``InlineModelAdmin`` properties.
|
||||
``ModelAdmin`` properties.
|
||||
|
||||
Working with Many-to-Many Intermediary Models
|
||||
----------------------------------------------
|
||||
|
||||
@ -494,8 +494,9 @@ A boolean that turns on/off debug mode.
|
||||
|
||||
If you define custom settings, `django/views/debug.py`_ has a ``HIDDEN_SETTINGS``
|
||||
regular expression which will hide from the DEBUG view anything that contains
|
||||
``'SECRET'``, ``'PASSWORD'``, or ``'PROFANITIES'``. This allows untrusted users to
|
||||
be able to give backtraces without seeing sensitive (or offensive) settings.
|
||||
``'SECRET'``, ``'PASSWORD'``, ``'PROFANITIES'``, or ``'SIGNATURE'``. This allows
|
||||
untrusted users to be able to give backtraces without seeing sensitive (or
|
||||
offensive) settings.
|
||||
|
||||
Still, note that there are always going to be sections of your debug output that
|
||||
are inappropriate for public consumption. File paths, configuration options, and
|
||||
@ -615,7 +616,7 @@ EMAIL_BACKEND
|
||||
|
||||
.. versionadded:: 1.2
|
||||
|
||||
Default: ``'django.core.mail.backends.smtp'``
|
||||
Default: ``'django.core.mail.backends.smtp.EmailBackend'``
|
||||
|
||||
The backend to use for sending emails. For the list of available backends see
|
||||
:ref:`topics-email`.
|
||||
|
||||
@ -1248,6 +1248,19 @@ cause of an failure in your test suite.
|
||||
``target_status_code`` will be the url and status code for the final
|
||||
point of the redirect chain.
|
||||
|
||||
.. method:: TestCase.assertQuerysetEqual(response, qs, values, transform=repr)
|
||||
|
||||
Asserts that a queryset ``qs`` returns a particular list of values ``values``.
|
||||
|
||||
The comparison of the contents of ``qs`` and ``values`` is performed using
|
||||
the function ``transform``; by default, this means that the ``repr()`` of
|
||||
each value is compared. Any other callable can be used if ``repr()`` doesn't
|
||||
provide a unique or helpful comparison.
|
||||
|
||||
The comparison is also ordering dependent. If ``qs`` doesn't provide an
|
||||
implicit ordering, you will need to apply a ``order_by()`` clause to your
|
||||
queryset to ensure that the test will pass reliably.
|
||||
|
||||
.. _topics-testing-email:
|
||||
|
||||
E-mail services
|
||||
|
||||
@ -1,6 +1,7 @@
|
||||
# coding: utf-8
|
||||
from django.db import models
|
||||
|
||||
|
||||
class Author(models.Model):
|
||||
name = models.CharField(max_length=100)
|
||||
age = models.IntegerField()
|
||||
@ -39,323 +40,3 @@ class Store(models.Model):
|
||||
def __unicode__(self):
|
||||
return self.name
|
||||
|
||||
# Tests on 'aggregate'
|
||||
# Different backends and numbers.
|
||||
__test__ = {'API_TESTS': """
|
||||
>>> from django.core import management
|
||||
>>> from decimal import Decimal
|
||||
>>> from datetime import date
|
||||
|
||||
# Reset the database representation of this app.
|
||||
# This will return the database to a clean initial state.
|
||||
>>> management.call_command('flush', verbosity=0, interactive=False)
|
||||
|
||||
# Empty Call - request nothing, get nothing.
|
||||
>>> Author.objects.all().aggregate()
|
||||
{}
|
||||
|
||||
>>> from django.db.models import Avg, Sum, Count, Max, Min
|
||||
|
||||
# Single model aggregation
|
||||
#
|
||||
|
||||
# Single aggregate
|
||||
# Average age of Authors
|
||||
>>> Author.objects.all().aggregate(Avg('age'))
|
||||
{'age__avg': 37.4...}
|
||||
|
||||
# Multiple aggregates
|
||||
# Average and Sum of Author ages
|
||||
>>> Author.objects.all().aggregate(Sum('age'), Avg('age'))
|
||||
{'age__sum': 337, 'age__avg': 37.4...}
|
||||
|
||||
# Aggreates interact with filters, and only
|
||||
# generate aggregate values for the filtered values
|
||||
# Sum of the age of those older than 29 years old
|
||||
>>> Author.objects.all().filter(age__gt=29).aggregate(Sum('age'))
|
||||
{'age__sum': 254}
|
||||
|
||||
# Depth-1 Joins
|
||||
#
|
||||
|
||||
# On Relationships with self
|
||||
# Average age of the friends of each author
|
||||
>>> Author.objects.all().aggregate(Avg('friends__age'))
|
||||
{'friends__age__avg': 34.07...}
|
||||
|
||||
# On ManyToMany Relationships
|
||||
#
|
||||
|
||||
# Forward
|
||||
# Average age of the Authors of Books with a rating of less than 4.5
|
||||
>>> Book.objects.all().filter(rating__lt=4.5).aggregate(Avg('authors__age'))
|
||||
{'authors__age__avg': 38.2...}
|
||||
|
||||
# Backward
|
||||
# Average rating of the Books whose Author's name contains the letter 'a'
|
||||
>>> Author.objects.all().filter(name__contains='a').aggregate(Avg('book__rating'))
|
||||
{'book__rating__avg': 4.0}
|
||||
|
||||
# On OneToMany Relationships
|
||||
#
|
||||
|
||||
# Forward
|
||||
# Sum of the number of awards of each Book's Publisher
|
||||
>>> Book.objects.all().aggregate(Sum('publisher__num_awards'))
|
||||
{'publisher__num_awards__sum': 30}
|
||||
|
||||
# Backward
|
||||
# Sum of the price of every Book that has a Publisher
|
||||
>>> Publisher.objects.all().aggregate(Sum('book__price'))
|
||||
{'book__price__sum': Decimal("270.27")}
|
||||
|
||||
# Multiple Joins
|
||||
#
|
||||
|
||||
# Forward
|
||||
>>> Store.objects.all().aggregate(Max('books__authors__age'))
|
||||
{'books__authors__age__max': 57}
|
||||
|
||||
# Backward
|
||||
# Note that the very long default alias may be truncated
|
||||
>>> Author.objects.all().aggregate(Min('book__publisher__num_awards'))
|
||||
{'book__publisher__num_award...': 1}
|
||||
|
||||
# Aggregate outputs can also be aliased.
|
||||
|
||||
# Average amazon.com Book rating
|
||||
>>> Store.objects.filter(name='Amazon.com').aggregate(amazon_mean=Avg('books__rating'))
|
||||
{'amazon_mean': 4.08...}
|
||||
|
||||
# Tests on annotate()
|
||||
|
||||
# An empty annotate call does nothing but return the same QuerySet
|
||||
>>> Book.objects.all().annotate().order_by('pk')
|
||||
[<Book: The Definitive Guide to Django: Web Development Done Right>, <Book: Sams Teach Yourself Django in 24 Hours>, <Book: Practical Django Projects>, <Book: Python Web Development with Django>, <Book: Artificial Intelligence: A Modern Approach>, <Book: Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp>]
|
||||
|
||||
# Annotate inserts the alias into the model object with the aggregated result
|
||||
>>> books = Book.objects.all().annotate(mean_age=Avg('authors__age'))
|
||||
>>> books.get(pk=1).name
|
||||
u'The Definitive Guide to Django: Web Development Done Right'
|
||||
|
||||
>>> books.get(pk=1).mean_age
|
||||
34.5
|
||||
|
||||
# On ManyToMany Relationships
|
||||
|
||||
# Forward
|
||||
# Average age of the Authors of each book with a rating less than 4.5
|
||||
>>> books = Book.objects.all().filter(rating__lt=4.5).annotate(Avg('authors__age'))
|
||||
>>> sorted([(b.name, b.authors__age__avg) for b in books])
|
||||
[(u'Artificial Intelligence: A Modern Approach', 51.5), (u'Practical Django Projects', 29.0), (u'Python Web Development with Django', 30.3...), (u'Sams Teach Yourself Django in 24 Hours', 45.0)]
|
||||
|
||||
# Count the number of authors of each book
|
||||
>>> books = Book.objects.annotate(num_authors=Count('authors'))
|
||||
>>> sorted([(b.name, b.num_authors) for b in books])
|
||||
[(u'Artificial Intelligence: A Modern Approach', 2), (u'Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp', 1), (u'Practical Django Projects', 1), (u'Python Web Development with Django', 3), (u'Sams Teach Yourself Django in 24 Hours', 1), (u'The Definitive Guide to Django: Web Development Done Right', 2)]
|
||||
|
||||
# Backward
|
||||
# Average rating of the Books whose Author's names contains the letter 'a'
|
||||
>>> authors = Author.objects.all().filter(name__contains='a').annotate(Avg('book__rating'))
|
||||
>>> sorted([(a.name, a.book__rating__avg) for a in authors])
|
||||
[(u'Adrian Holovaty', 4.5), (u'Brad Dayley', 3.0), (u'Jacob Kaplan-Moss', 4.5), (u'James Bennett', 4.0), (u'Paul Bissex', 4.0), (u'Stuart Russell', 4.0)]
|
||||
|
||||
# Count the number of books written by each author
|
||||
>>> authors = Author.objects.annotate(num_books=Count('book'))
|
||||
>>> sorted([(a.name, a.num_books) for a in authors])
|
||||
[(u'Adrian Holovaty', 1), (u'Brad Dayley', 1), (u'Jacob Kaplan-Moss', 1), (u'James Bennett', 1), (u'Jeffrey Forcier', 1), (u'Paul Bissex', 1), (u'Peter Norvig', 2), (u'Stuart Russell', 1), (u'Wesley J. Chun', 1)]
|
||||
|
||||
# On OneToMany Relationships
|
||||
|
||||
# Forward
|
||||
# Annotate each book with the number of awards of each Book's Publisher
|
||||
>>> books = Book.objects.all().annotate(Sum('publisher__num_awards'))
|
||||
>>> sorted([(b.name, b.publisher__num_awards__sum) for b in books])
|
||||
[(u'Artificial Intelligence: A Modern Approach', 7), (u'Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp', 9), (u'Practical Django Projects', 3), (u'Python Web Development with Django', 7), (u'Sams Teach Yourself Django in 24 Hours', 1), (u'The Definitive Guide to Django: Web Development Done Right', 3)]
|
||||
|
||||
# Backward
|
||||
# Annotate each publisher with the sum of the price of all books sold
|
||||
>>> publishers = Publisher.objects.all().annotate(Sum('book__price'))
|
||||
>>> sorted([(p.name, p.book__price__sum) for p in publishers])
|
||||
[(u'Apress', Decimal("59.69")), (u"Jonno's House of Books", None), (u'Morgan Kaufmann', Decimal("75.00")), (u'Prentice Hall', Decimal("112.49")), (u'Sams', Decimal("23.09"))]
|
||||
|
||||
# Calls to values() are not commutative over annotate().
|
||||
|
||||
# Calling values on a queryset that has annotations returns the output
|
||||
# as a dictionary
|
||||
>>> [sorted(o.iteritems()) for o in Book.objects.filter(pk=1).annotate(mean_age=Avg('authors__age')).values()]
|
||||
[[('contact_id', 1), ('id', 1), ('isbn', u'159059725'), ('mean_age', 34.5), ('name', u'The Definitive Guide to Django: Web Development Done Right'), ('pages', 447), ('price', Decimal("30...")), ('pubdate', datetime.date(2007, 12, 6)), ('publisher_id', 1), ('rating', 4.5)]]
|
||||
|
||||
>>> Book.objects.filter(pk=1).annotate(mean_age=Avg('authors__age')).values('pk', 'isbn', 'mean_age')
|
||||
[{'pk': 1, 'isbn': u'159059725', 'mean_age': 34.5}]
|
||||
|
||||
# Calling values() with parameters reduces the output
|
||||
>>> Book.objects.filter(pk=1).annotate(mean_age=Avg('authors__age')).values('name')
|
||||
[{'name': u'The Definitive Guide to Django: Web Development Done Right'}]
|
||||
|
||||
# An empty values() call before annotating has the same effect as an
|
||||
# empty values() call after annotating
|
||||
>>> [sorted(o.iteritems()) for o in Book.objects.filter(pk=1).values().annotate(mean_age=Avg('authors__age'))]
|
||||
[[('contact_id', 1), ('id', 1), ('isbn', u'159059725'), ('mean_age', 34.5), ('name', u'The Definitive Guide to Django: Web Development Done Right'), ('pages', 447), ('price', Decimal("30...")), ('pubdate', datetime.date(2007, 12, 6)), ('publisher_id', 1), ('rating', 4.5)]]
|
||||
|
||||
# Calling annotate() on a ValuesQuerySet annotates over the groups of
|
||||
# fields to be selected by the ValuesQuerySet.
|
||||
|
||||
# Note that an extra parameter is added to each dictionary. This
|
||||
# parameter is a queryset representing the objects that have been
|
||||
# grouped to generate the annotation
|
||||
|
||||
>>> Book.objects.all().values('rating').annotate(n_authors=Count('authors__id'), mean_age=Avg('authors__age')).order_by('rating')
|
||||
[{'rating': 3.0, 'n_authors': 1, 'mean_age': 45.0}, {'rating': 4.0, 'n_authors': 6, 'mean_age': 37.1...}, {'rating': 4.5, 'n_authors': 2, 'mean_age': 34.5}, {'rating': 5.0, 'n_authors': 1, 'mean_age': 57.0}]
|
||||
|
||||
# If a join doesn't match any objects, an aggregate returns None
|
||||
>>> authors = Author.objects.all().annotate(Avg('friends__age')).order_by('id')
|
||||
>>> len(authors)
|
||||
9
|
||||
>>> sorted([(a.name, a.friends__age__avg) for a in authors])
|
||||
[(u'Adrian Holovaty', 32.0), (u'Brad Dayley', None), (u'Jacob Kaplan-Moss', 29.5), (u'James Bennett', 34.0), (u'Jeffrey Forcier', 27.0), (u'Paul Bissex', 31.0), (u'Peter Norvig', 46.0), (u'Stuart Russell', 57.0), (u'Wesley J. Chun', 33.6...)]
|
||||
|
||||
|
||||
# The Count aggregation function allows an extra parameter: distinct.
|
||||
# This restricts the count results to unique items
|
||||
>>> Book.objects.all().aggregate(Count('rating'))
|
||||
{'rating__count': 6}
|
||||
|
||||
>>> Book.objects.all().aggregate(Count('rating', distinct=True))
|
||||
{'rating__count': 4}
|
||||
|
||||
# Retreiving the grouped objects
|
||||
|
||||
# When using Count you can also omit the primary key and refer only to
|
||||
# the related field name if you want to count all the related objects
|
||||
# and not a specific column
|
||||
>>> explicit = list(Author.objects.annotate(Count('book__id')))
|
||||
>>> implicit = list(Author.objects.annotate(Count('book')))
|
||||
>>> explicit == implicit
|
||||
True
|
||||
|
||||
# Ordering is allowed on aggregates
|
||||
>>> Book.objects.values('rating').annotate(oldest=Max('authors__age')).order_by('oldest', 'rating')
|
||||
[{'rating': 4.5, 'oldest': 35}, {'rating': 3.0, 'oldest': 45}, {'rating': 4.0, 'oldest': 57}, {'rating': 5.0, 'oldest': 57}]
|
||||
|
||||
>>> Book.objects.values('rating').annotate(oldest=Max('authors__age')).order_by('-oldest', '-rating')
|
||||
[{'rating': 5.0, 'oldest': 57}, {'rating': 4.0, 'oldest': 57}, {'rating': 3.0, 'oldest': 45}, {'rating': 4.5, 'oldest': 35}]
|
||||
|
||||
# It is possible to aggregate over anotated values
|
||||
>>> Book.objects.all().annotate(num_authors=Count('authors__id')).aggregate(Avg('num_authors'))
|
||||
{'num_authors__avg': 1.66...}
|
||||
|
||||
# You can filter the results based on the aggregation alias.
|
||||
|
||||
# Lets add a publisher to test the different possibilities for filtering
|
||||
>>> p = Publisher(name='Expensive Publisher', num_awards=0)
|
||||
>>> p.save()
|
||||
>>> Book(name='ExpensiveBook1', pages=1, isbn='111', rating=3.5, price=Decimal("1000"), publisher=p, contact_id=1, pubdate=date(2008,12,1)).save()
|
||||
>>> Book(name='ExpensiveBook2', pages=1, isbn='222', rating=4.0, price=Decimal("1000"), publisher=p, contact_id=1, pubdate=date(2008,12,2)).save()
|
||||
>>> Book(name='ExpensiveBook3', pages=1, isbn='333', rating=4.5, price=Decimal("35"), publisher=p, contact_id=1, pubdate=date(2008,12,3)).save()
|
||||
|
||||
# Publishers that have:
|
||||
|
||||
# (i) more than one book
|
||||
>>> Publisher.objects.annotate(num_books=Count('book__id')).filter(num_books__gt=1).order_by('pk')
|
||||
[<Publisher: Apress>, <Publisher: Prentice Hall>, <Publisher: Expensive Publisher>]
|
||||
|
||||
# (ii) a book that cost less than 40
|
||||
>>> Publisher.objects.filter(book__price__lt=Decimal("40.0")).order_by('pk')
|
||||
[<Publisher: Apress>, <Publisher: Apress>, <Publisher: Sams>, <Publisher: Prentice Hall>, <Publisher: Expensive Publisher>]
|
||||
|
||||
# (iii) more than one book and (at least) a book that cost less than 40
|
||||
>>> Publisher.objects.annotate(num_books=Count('book__id')).filter(num_books__gt=1, book__price__lt=Decimal("40.0")).order_by('pk')
|
||||
[<Publisher: Apress>, <Publisher: Prentice Hall>, <Publisher: Expensive Publisher>]
|
||||
|
||||
# (iv) more than one book that costs less than $40
|
||||
>>> Publisher.objects.filter(book__price__lt=Decimal("40.0")).annotate(num_books=Count('book__id')).filter(num_books__gt=1).order_by('pk')
|
||||
[<Publisher: Apress>]
|
||||
|
||||
# Now a bit of testing on the different lookup types
|
||||
#
|
||||
|
||||
>>> Publisher.objects.annotate(num_books=Count('book')).filter(num_books__range=[1, 3]).order_by('pk')
|
||||
[<Publisher: Apress>, <Publisher: Sams>, <Publisher: Prentice Hall>, <Publisher: Morgan Kaufmann>, <Publisher: Expensive Publisher>]
|
||||
|
||||
>>> Publisher.objects.annotate(num_books=Count('book')).filter(num_books__range=[1, 2]).order_by('pk')
|
||||
[<Publisher: Apress>, <Publisher: Sams>, <Publisher: Prentice Hall>, <Publisher: Morgan Kaufmann>]
|
||||
|
||||
>>> Publisher.objects.annotate(num_books=Count('book')).filter(num_books__in=[1, 3]).order_by('pk')
|
||||
[<Publisher: Sams>, <Publisher: Morgan Kaufmann>, <Publisher: Expensive Publisher>]
|
||||
|
||||
>>> Publisher.objects.annotate(num_books=Count('book')).filter(num_books__isnull=True)
|
||||
[]
|
||||
|
||||
>>> p.delete()
|
||||
|
||||
# Does Author X have any friends? (or better, how many friends does author X have)
|
||||
>> Author.objects.filter(pk=1).aggregate(Count('friends__id'))
|
||||
{'friends__id__count': 2.0}
|
||||
|
||||
# Give me a list of all Books with more than 1 authors
|
||||
>>> Book.objects.all().annotate(num_authors=Count('authors__name')).filter(num_authors__ge=2).order_by('pk')
|
||||
[<Book: The Definitive Guide to Django: Web Development Done Right>, <Book: Artificial Intelligence: A Modern Approach>]
|
||||
|
||||
# Give me a list of all Authors that have no friends
|
||||
>>> Author.objects.all().annotate(num_friends=Count('friends__id', distinct=True)).filter(num_friends=0).order_by('pk')
|
||||
[<Author: Brad Dayley>]
|
||||
|
||||
# Give me a list of all publishers that have published more than 1 books
|
||||
>>> Publisher.objects.all().annotate(num_books=Count('book__id')).filter(num_books__gt=1).order_by('pk')
|
||||
[<Publisher: Apress>, <Publisher: Prentice Hall>]
|
||||
|
||||
# Give me a list of all publishers that have published more than 1 books that cost less than 40
|
||||
>>> Publisher.objects.all().filter(book__price__lt=Decimal("40.0")).annotate(num_books=Count('book__id')).filter(num_books__gt=1)
|
||||
[<Publisher: Apress>]
|
||||
|
||||
# Give me a list of all Books that were written by X and one other author.
|
||||
>>> Book.objects.all().annotate(num_authors=Count('authors__id')).filter(authors__name__contains='Norvig', num_authors__gt=1)
|
||||
[<Book: Artificial Intelligence: A Modern Approach>]
|
||||
|
||||
# Give me the average rating of all Books that were written by X and one other author.
|
||||
#(Aggregate over objects discovered using membership of the m2m set)
|
||||
|
||||
# Adding an existing author to another book to test it the right way
|
||||
>>> a = Author.objects.get(name__contains='Norvig')
|
||||
>>> b = Book.objects.get(name__contains='Done Right')
|
||||
>>> b.authors.add(a)
|
||||
>>> b.save()
|
||||
|
||||
# This should do it
|
||||
>>> Book.objects.all().annotate(num_authors=Count('authors__id')).filter(authors__name__contains='Norvig', num_authors__gt=1).aggregate(Avg('rating'))
|
||||
{'rating__avg': 4.25}
|
||||
>>> b.authors.remove(a)
|
||||
|
||||
# Give me a list of all Authors that have published a book with at least one other person
|
||||
# (Filters over a count generated on a related object)
|
||||
#
|
||||
# Cheating: [a for a in Author.objects.all().annotate(num_coleagues=Count('book__authors__id'), num_books=Count('book__id', distinct=True)) if a.num_coleagues - a.num_books > 0]
|
||||
# F-Syntax is required. Will be fixed after F objects are available
|
||||
|
||||
# Aggregates also work on dates, times and datetimes
|
||||
>>> Publisher.objects.annotate(earliest_book=Min('book__pubdate')).exclude(earliest_book=None).order_by('earliest_book').values()
|
||||
[{'earliest_book': datetime.date(1991, 10, 15), 'num_awards': 9, 'id': 4, 'name': u'Morgan Kaufmann'}, {'earliest_book': datetime.date(1995, 1, 15), 'num_awards': 7, 'id': 3, 'name': u'Prentice Hall'}, {'earliest_book': datetime.date(2007, 12, 6), 'num_awards': 3, 'id': 1, 'name': u'Apress'}, {'earliest_book': datetime.date(2008, 3, 3), 'num_awards': 1, 'id': 2, 'name': u'Sams'}]
|
||||
|
||||
>>> Store.objects.aggregate(Max('friday_night_closing'), Min("original_opening"))
|
||||
{'friday_night_closing__max': datetime.time(23, 59, 59), 'original_opening__min': datetime.datetime(1945, 4, 25, 16, 24, 14)}
|
||||
|
||||
# values_list() can also be used
|
||||
|
||||
>>> Book.objects.filter(pk=1).annotate(mean_age=Avg('authors__age')).values_list('pk', 'isbn', 'mean_age')
|
||||
[(1, u'159059725', 34.5)]
|
||||
|
||||
>>> Book.objects.filter(pk=1).annotate(mean_age=Avg('authors__age')).values_list('isbn')
|
||||
[(u'159059725',)]
|
||||
|
||||
>>> Book.objects.filter(pk=1).annotate(mean_age=Avg('authors__age')).values_list('mean_age')
|
||||
[(34.5,)]
|
||||
|
||||
>>> Book.objects.filter(pk=1).annotate(mean_age=Avg('authors__age')).values_list('mean_age', flat=True)
|
||||
[34.5]
|
||||
|
||||
>>> qs = Book.objects.values_list('price').annotate(count=Count('price')).order_by('-count', 'price')
|
||||
>>> list(qs) == [(Decimal('29.69'), 2), (Decimal('23.09'), 1), (Decimal('30'), 1), (Decimal('75'), 1), (Decimal('82.8'), 1)]
|
||||
True
|
||||
|
||||
"""}
|
||||
|
||||
578
tests/modeltests/aggregation/tests.py
Normal file
578
tests/modeltests/aggregation/tests.py
Normal file
@ -0,0 +1,578 @@
|
||||
import datetime
|
||||
from decimal import Decimal
|
||||
|
||||
from django.db.models import Avg, Sum, Count, Max, Min
|
||||
from django.test import TestCase
|
||||
|
||||
from models import Author, Publisher, Book, Store
|
||||
|
||||
|
||||
class Approximate(object):
|
||||
def __init__(self, val, places=7):
|
||||
self.val = val
|
||||
self.places = places
|
||||
|
||||
def __repr__(self):
|
||||
return repr(self.val)
|
||||
|
||||
def __eq__(self, other):
|
||||
if self.val == other:
|
||||
return True
|
||||
return round(abs(self.val-other), self.places) == 0
|
||||
|
||||
class BaseAggregateTestCase(TestCase):
|
||||
fixtures = ["initial_data.json"]
|
||||
|
||||
def test_empty_aggregate(self):
|
||||
self.assertEqual(Author.objects.all().aggregate(), {})
|
||||
|
||||
def test_single_aggregate(self):
|
||||
vals = Author.objects.aggregate(Avg("age"))
|
||||
self.assertEqual(vals, {"age__avg": Approximate(37.4, places=1)})
|
||||
|
||||
def test_multiple_aggregates(self):
|
||||
vals = Author.objects.aggregate(Sum("age"), Avg("age"))
|
||||
self.assertEqual(vals, {"age__sum": 337, "age__avg": Approximate(37.4, places=1)})
|
||||
|
||||
def test_filter_aggregate(self):
|
||||
vals = Author.objects.filter(age__gt=29).aggregate(Sum("age"))
|
||||
self.assertEqual(len(vals), 1)
|
||||
self.assertEqual(vals["age__sum"], 254)
|
||||
|
||||
def test_related_aggregate(self):
|
||||
vals = Author.objects.aggregate(Avg("friends__age"))
|
||||
self.assertEqual(len(vals), 1)
|
||||
self.assertAlmostEqual(vals["friends__age__avg"], 34.07, places=2)
|
||||
|
||||
vals = Book.objects.filter(rating__lt=4.5).aggregate(Avg("authors__age"))
|
||||
self.assertEqual(len(vals), 1)
|
||||
self.assertAlmostEqual(vals["authors__age__avg"], 38.2857, places=2)
|
||||
|
||||
vals = Author.objects.all().filter(name__contains="a").aggregate(Avg("book__rating"))
|
||||
self.assertEqual(len(vals), 1)
|
||||
self.assertEqual(vals["book__rating__avg"], 4.0)
|
||||
|
||||
vals = Book.objects.aggregate(Sum("publisher__num_awards"))
|
||||
self.assertEqual(len(vals), 1)
|
||||
self.assertEquals(vals["publisher__num_awards__sum"], 30)
|
||||
|
||||
vals = Publisher.objects.aggregate(Sum("book__price"))
|
||||
self.assertEqual(len(vals), 1)
|
||||
self.assertEqual(vals["book__price__sum"], Decimal("270.27"))
|
||||
|
||||
def test_aggregate_multi_join(self):
|
||||
vals = Store.objects.aggregate(Max("books__authors__age"))
|
||||
self.assertEqual(len(vals), 1)
|
||||
self.assertEqual(vals["books__authors__age__max"], 57)
|
||||
|
||||
vals = Author.objects.aggregate(Min("book__publisher__num_awards"))
|
||||
self.assertEqual(len(vals), 1)
|
||||
self.assertEqual(vals["book__publisher__num_awards__min"], 1)
|
||||
|
||||
def test_aggregate_alias(self):
|
||||
vals = Store.objects.filter(name="Amazon.com").aggregate(amazon_mean=Avg("books__rating"))
|
||||
self.assertEqual(len(vals), 1)
|
||||
self.assertAlmostEqual(vals["amazon_mean"], 4.08, places=2)
|
||||
|
||||
def test_annotate_basic(self):
|
||||
self.assertQuerysetEqual(
|
||||
Book.objects.annotate().order_by('pk'), [
|
||||
"The Definitive Guide to Django: Web Development Done Right",
|
||||
"Sams Teach Yourself Django in 24 Hours",
|
||||
"Practical Django Projects",
|
||||
"Python Web Development with Django",
|
||||
"Artificial Intelligence: A Modern Approach",
|
||||
"Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp"
|
||||
],
|
||||
lambda b: b.name
|
||||
)
|
||||
|
||||
books = Book.objects.annotate(mean_age=Avg("authors__age"))
|
||||
b = books.get(pk=1)
|
||||
self.assertEqual(
|
||||
b.name,
|
||||
u'The Definitive Guide to Django: Web Development Done Right'
|
||||
)
|
||||
self.assertEqual(b.mean_age, 34.5)
|
||||
|
||||
def test_annotate_m2m(self):
|
||||
books = Book.objects.filter(rating__lt=4.5).annotate(Avg("authors__age")).order_by("name")
|
||||
self.assertQuerysetEqual(
|
||||
books, [
|
||||
(u'Artificial Intelligence: A Modern Approach', 51.5),
|
||||
(u'Practical Django Projects', 29.0),
|
||||
(u'Python Web Development with Django', Approximate(30.3, places=1)),
|
||||
(u'Sams Teach Yourself Django in 24 Hours', 45.0)
|
||||
],
|
||||
lambda b: (b.name, b.authors__age__avg),
|
||||
)
|
||||
|
||||
books = Book.objects.annotate(num_authors=Count("authors")).order_by("name")
|
||||
self.assertQuerysetEqual(
|
||||
books, [
|
||||
(u'Artificial Intelligence: A Modern Approach', 2),
|
||||
(u'Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp', 1),
|
||||
(u'Practical Django Projects', 1),
|
||||
(u'Python Web Development with Django', 3),
|
||||
(u'Sams Teach Yourself Django in 24 Hours', 1),
|
||||
(u'The Definitive Guide to Django: Web Development Done Right', 2)
|
||||
],
|
||||
lambda b: (b.name, b.num_authors)
|
||||
)
|
||||
|
||||
def test_backwards_m2m_annotate(self):
|
||||
authors = Author.objects.filter(name__contains="a").annotate(Avg("book__rating")).order_by("name")
|
||||
self.assertQuerysetEqual(
|
||||
authors, [
|
||||
(u'Adrian Holovaty', 4.5),
|
||||
(u'Brad Dayley', 3.0),
|
||||
(u'Jacob Kaplan-Moss', 4.5),
|
||||
(u'James Bennett', 4.0),
|
||||
(u'Paul Bissex', 4.0),
|
||||
(u'Stuart Russell', 4.0)
|
||||
],
|
||||
lambda a: (a.name, a.book__rating__avg)
|
||||
)
|
||||
|
||||
authors = Author.objects.annotate(num_books=Count("book")).order_by("name")
|
||||
self.assertQuerysetEqual(
|
||||
authors, [
|
||||
(u'Adrian Holovaty', 1),
|
||||
(u'Brad Dayley', 1),
|
||||
(u'Jacob Kaplan-Moss', 1),
|
||||
(u'James Bennett', 1),
|
||||
(u'Jeffrey Forcier', 1),
|
||||
(u'Paul Bissex', 1),
|
||||
(u'Peter Norvig', 2),
|
||||
(u'Stuart Russell', 1),
|
||||
(u'Wesley J. Chun', 1)
|
||||
],
|
||||
lambda a: (a.name, a.num_books)
|
||||
)
|
||||
|
||||
def test_reverse_fkey_annotate(self):
|
||||
books = Book.objects.annotate(Sum("publisher__num_awards")).order_by("name")
|
||||
self.assertQuerysetEqual(
|
||||
books, [
|
||||
(u'Artificial Intelligence: A Modern Approach', 7),
|
||||
(u'Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp', 9),
|
||||
(u'Practical Django Projects', 3),
|
||||
(u'Python Web Development with Django', 7),
|
||||
(u'Sams Teach Yourself Django in 24 Hours', 1),
|
||||
(u'The Definitive Guide to Django: Web Development Done Right', 3)
|
||||
],
|
||||
lambda b: (b.name, b.publisher__num_awards__sum)
|
||||
)
|
||||
|
||||
publishers = Publisher.objects.annotate(Sum("book__price")).order_by("name")
|
||||
self.assertQuerysetEqual(
|
||||
publishers, [
|
||||
(u'Apress', Decimal("59.69")),
|
||||
(u"Jonno's House of Books", None),
|
||||
(u'Morgan Kaufmann', Decimal("75.00")),
|
||||
(u'Prentice Hall', Decimal("112.49")),
|
||||
(u'Sams', Decimal("23.09"))
|
||||
],
|
||||
lambda p: (p.name, p.book__price__sum)
|
||||
)
|
||||
|
||||
def test_annotate_values(self):
|
||||
books = list(Book.objects.filter(pk=1).annotate(mean_age=Avg("authors__age")).values())
|
||||
self.assertEqual(
|
||||
books, [
|
||||
{
|
||||
"contact_id": 1,
|
||||
"id": 1,
|
||||
"isbn": "159059725",
|
||||
"mean_age": 34.5,
|
||||
"name": "The Definitive Guide to Django: Web Development Done Right",
|
||||
"pages": 447,
|
||||
"price": Approximate(Decimal("30")),
|
||||
"pubdate": datetime.date(2007, 12, 6),
|
||||
"publisher_id": 1,
|
||||
"rating": 4.5,
|
||||
}
|
||||
]
|
||||
)
|
||||
|
||||
books = Book.objects.filter(pk=1).annotate(mean_age=Avg('authors__age')).values('pk', 'isbn', 'mean_age')
|
||||
self.assertEqual(
|
||||
list(books), [
|
||||
{
|
||||
"pk": 1,
|
||||
"isbn": "159059725",
|
||||
"mean_age": 34.5,
|
||||
}
|
||||
]
|
||||
)
|
||||
|
||||
books = Book.objects.filter(pk=1).annotate(mean_age=Avg("authors__age")).values("name")
|
||||
self.assertEqual(
|
||||
list(books), [
|
||||
{
|
||||
"name": "The Definitive Guide to Django: Web Development Done Right"
|
||||
}
|
||||
]
|
||||
)
|
||||
|
||||
books = Book.objects.filter(pk=1).values().annotate(mean_age=Avg('authors__age'))
|
||||
self.assertEqual(
|
||||
list(books), [
|
||||
{
|
||||
"contact_id": 1,
|
||||
"id": 1,
|
||||
"isbn": "159059725",
|
||||
"mean_age": 34.5,
|
||||
"name": "The Definitive Guide to Django: Web Development Done Right",
|
||||
"pages": 447,
|
||||
"price": Approximate(Decimal("30")),
|
||||
"pubdate": datetime.date(2007, 12, 6),
|
||||
"publisher_id": 1,
|
||||
"rating": 4.5,
|
||||
}
|
||||
]
|
||||
)
|
||||
|
||||
books = Book.objects.values("rating").annotate(n_authors=Count("authors__id"), mean_age=Avg("authors__age")).order_by("rating")
|
||||
self.assertEqual(
|
||||
list(books), [
|
||||
{
|
||||
"rating": 3.0,
|
||||
"n_authors": 1,
|
||||
"mean_age": 45.0,
|
||||
},
|
||||
{
|
||||
"rating": 4.0,
|
||||
"n_authors": 6,
|
||||
"mean_age": Approximate(37.16, places=1)
|
||||
},
|
||||
{
|
||||
"rating": 4.5,
|
||||
"n_authors": 2,
|
||||
"mean_age": 34.5,
|
||||
},
|
||||
{
|
||||
"rating": 5.0,
|
||||
"n_authors": 1,
|
||||
"mean_age": 57.0,
|
||||
}
|
||||
]
|
||||
)
|
||||
|
||||
authors = Author.objects.annotate(Avg("friends__age")).order_by("name")
|
||||
self.assertEqual(len(authors), 9)
|
||||
self.assertQuerysetEqual(
|
||||
authors, [
|
||||
(u'Adrian Holovaty', 32.0),
|
||||
(u'Brad Dayley', None),
|
||||
(u'Jacob Kaplan-Moss', 29.5),
|
||||
(u'James Bennett', 34.0),
|
||||
(u'Jeffrey Forcier', 27.0),
|
||||
(u'Paul Bissex', 31.0),
|
||||
(u'Peter Norvig', 46.0),
|
||||
(u'Stuart Russell', 57.0),
|
||||
(u'Wesley J. Chun', Approximate(33.66, places=1))
|
||||
],
|
||||
lambda a: (a.name, a.friends__age__avg)
|
||||
)
|
||||
|
||||
def test_count(self):
|
||||
vals = Book.objects.aggregate(Count("rating"))
|
||||
self.assertEqual(vals, {"rating__count": 6})
|
||||
|
||||
vals = Book.objects.aggregate(Count("rating", distinct=True))
|
||||
self.assertEqual(vals, {"rating__count": 4})
|
||||
|
||||
def test_fkey_aggregate(self):
|
||||
explicit = list(Author.objects.annotate(Count('book__id')))
|
||||
implicit = list(Author.objects.annotate(Count('book')))
|
||||
self.assertEqual(explicit, implicit)
|
||||
|
||||
def test_annotate_ordering(self):
|
||||
books = Book.objects.values('rating').annotate(oldest=Max('authors__age')).order_by('oldest', 'rating')
|
||||
self.assertEqual(
|
||||
list(books), [
|
||||
{
|
||||
"rating": 4.5,
|
||||
"oldest": 35,
|
||||
},
|
||||
{
|
||||
"rating": 3.0,
|
||||
"oldest": 45
|
||||
},
|
||||
{
|
||||
"rating": 4.0,
|
||||
"oldest": 57,
|
||||
},
|
||||
{
|
||||
"rating": 5.0,
|
||||
"oldest": 57,
|
||||
}
|
||||
]
|
||||
)
|
||||
|
||||
books = Book.objects.values("rating").annotate(oldest=Max("authors__age")).order_by("-oldest", "-rating")
|
||||
self.assertEqual(
|
||||
list(books), [
|
||||
{
|
||||
"rating": 5.0,
|
||||
"oldest": 57,
|
||||
},
|
||||
{
|
||||
"rating": 4.0,
|
||||
"oldest": 57,
|
||||
},
|
||||
{
|
||||
"rating": 3.0,
|
||||
"oldest": 45,
|
||||
},
|
||||
{
|
||||
"rating": 4.5,
|
||||
"oldest": 35,
|
||||
}
|
||||
]
|
||||
)
|
||||
|
||||
def test_aggregate_annotation(self):
|
||||
vals = Book.objects.annotate(num_authors=Count("authors__id")).aggregate(Avg("num_authors"))
|
||||
self.assertEqual(vals, {"num_authors__avg": Approximate(1.66, places=1)})
|
||||
|
||||
def test_filtering(self):
|
||||
p = Publisher.objects.create(name='Expensive Publisher', num_awards=0)
|
||||
Book.objects.create(
|
||||
name='ExpensiveBook1',
|
||||
pages=1,
|
||||
isbn='111',
|
||||
rating=3.5,
|
||||
price=Decimal("1000"),
|
||||
publisher=p,
|
||||
contact_id=1,
|
||||
pubdate=datetime.date(2008,12,1)
|
||||
)
|
||||
Book.objects.create(
|
||||
name='ExpensiveBook2',
|
||||
pages=1,
|
||||
isbn='222',
|
||||
rating=4.0,
|
||||
price=Decimal("1000"),
|
||||
publisher=p,
|
||||
contact_id=1,
|
||||
pubdate=datetime.date(2008,12,2)
|
||||
)
|
||||
Book.objects.create(
|
||||
name='ExpensiveBook3',
|
||||
pages=1,
|
||||
isbn='333',
|
||||
rating=4.5,
|
||||
price=Decimal("35"),
|
||||
publisher=p,
|
||||
contact_id=1,
|
||||
pubdate=datetime.date(2008,12,3)
|
||||
)
|
||||
|
||||
publishers = Publisher.objects.annotate(num_books=Count("book__id")).filter(num_books__gt=1).order_by("pk")
|
||||
self.assertQuerysetEqual(
|
||||
publishers, [
|
||||
"Apress",
|
||||
"Prentice Hall",
|
||||
"Expensive Publisher",
|
||||
],
|
||||
lambda p: p.name,
|
||||
)
|
||||
|
||||
publishers = Publisher.objects.filter(book__price__lt=Decimal("40.0")).order_by("pk")
|
||||
self.assertQuerysetEqual(
|
||||
publishers, [
|
||||
"Apress",
|
||||
"Apress",
|
||||
"Sams",
|
||||
"Prentice Hall",
|
||||
"Expensive Publisher",
|
||||
],
|
||||
lambda p: p.name
|
||||
)
|
||||
|
||||
publishers = Publisher.objects.annotate(num_books=Count("book__id")).filter(num_books__gt=1, book__price__lt=Decimal("40.0")).order_by("pk")
|
||||
self.assertQuerysetEqual(
|
||||
publishers, [
|
||||
"Apress",
|
||||
"Prentice Hall",
|
||||
"Expensive Publisher",
|
||||
],
|
||||
lambda p: p.name,
|
||||
)
|
||||
|
||||
publishers = Publisher.objects.filter(book__price__lt=Decimal("40.0")).annotate(num_books=Count("book__id")).filter(num_books__gt=1).order_by("pk")
|
||||
self.assertQuerysetEqual(
|
||||
publishers, [
|
||||
"Apress",
|
||||
],
|
||||
lambda p: p.name
|
||||
)
|
||||
|
||||
publishers = Publisher.objects.annotate(num_books=Count("book")).filter(num_books__range=[1, 3]).order_by("pk")
|
||||
self.assertQuerysetEqual(
|
||||
publishers, [
|
||||
"Apress",
|
||||
"Sams",
|
||||
"Prentice Hall",
|
||||
"Morgan Kaufmann",
|
||||
"Expensive Publisher",
|
||||
],
|
||||
lambda p: p.name
|
||||
)
|
||||
|
||||
publishers = Publisher.objects.annotate(num_books=Count("book")).filter(num_books__range=[1, 2]).order_by("pk")
|
||||
self.assertQuerysetEqual(
|
||||
publishers, [
|
||||
"Apress",
|
||||
"Sams",
|
||||
"Prentice Hall",
|
||||
"Morgan Kaufmann",
|
||||
],
|
||||
lambda p: p.name
|
||||
)
|
||||
|
||||
publishers = Publisher.objects.annotate(num_books=Count("book")).filter(num_books__in=[1, 3]).order_by("pk")
|
||||
self.assertQuerysetEqual(
|
||||
publishers, [
|
||||
"Sams",
|
||||
"Morgan Kaufmann",
|
||||
"Expensive Publisher",
|
||||
],
|
||||
lambda p: p.name,
|
||||
)
|
||||
|
||||
publishers = Publisher.objects.annotate(num_books=Count("book")).filter(num_books__isnull=True)
|
||||
self.assertEqual(len(publishers), 0)
|
||||
|
||||
def test_annotation(self):
|
||||
vals = Author.objects.filter(pk=1).aggregate(Count("friends__id"))
|
||||
self.assertEqual(vals, {"friends__id__count": 2})
|
||||
|
||||
books = Book.objects.annotate(num_authors=Count("authors__name")).filter(num_authors__ge=2).order_by("pk")
|
||||
self.assertQuerysetEqual(
|
||||
books, [
|
||||
"The Definitive Guide to Django: Web Development Done Right",
|
||||
"Artificial Intelligence: A Modern Approach",
|
||||
],
|
||||
lambda b: b.name
|
||||
)
|
||||
|
||||
authors = Author.objects.annotate(num_friends=Count("friends__id", distinct=True)).filter(num_friends=0).order_by("pk")
|
||||
self.assertQuerysetEqual(
|
||||
authors, [
|
||||
"Brad Dayley",
|
||||
],
|
||||
lambda a: a.name
|
||||
)
|
||||
|
||||
publishers = Publisher.objects.annotate(num_books=Count("book__id")).filter(num_books__gt=1).order_by("pk")
|
||||
self.assertQuerysetEqual(
|
||||
publishers, [
|
||||
"Apress",
|
||||
"Prentice Hall",
|
||||
],
|
||||
lambda p: p.name
|
||||
)
|
||||
|
||||
publishers = Publisher.objects.filter(book__price__lt=Decimal("40.0")).annotate(num_books=Count("book__id")).filter(num_books__gt=1)
|
||||
self.assertQuerysetEqual(
|
||||
publishers, [
|
||||
"Apress",
|
||||
],
|
||||
lambda p: p.name
|
||||
)
|
||||
|
||||
books = Book.objects.annotate(num_authors=Count("authors__id")).filter(authors__name__contains="Norvig", num_authors__gt=1)
|
||||
self.assertQuerysetEqual(
|
||||
books, [
|
||||
"Artificial Intelligence: A Modern Approach",
|
||||
],
|
||||
lambda b: b.name
|
||||
)
|
||||
|
||||
def test_more_aggregation(self):
|
||||
a = Author.objects.get(name__contains='Norvig')
|
||||
b = Book.objects.get(name__contains='Done Right')
|
||||
b.authors.add(a)
|
||||
b.save()
|
||||
|
||||
vals = Book.objects.annotate(num_authors=Count("authors__id")).filter(authors__name__contains="Norvig", num_authors__gt=1).aggregate(Avg("rating"))
|
||||
self.assertEqual(vals, {"rating__avg": 4.25})
|
||||
|
||||
def test_even_more_aggregate(self):
|
||||
publishers = Publisher.objects.annotate(earliest_book=Min("book__pubdate")).exclude(earliest_book=None).order_by("earliest_book").values()
|
||||
self.assertEqual(
|
||||
list(publishers), [
|
||||
{
|
||||
'earliest_book': datetime.date(1991, 10, 15),
|
||||
'num_awards': 9,
|
||||
'id': 4,
|
||||
'name': u'Morgan Kaufmann'
|
||||
},
|
||||
{
|
||||
'earliest_book': datetime.date(1995, 1, 15),
|
||||
'num_awards': 7,
|
||||
'id': 3,
|
||||
'name': u'Prentice Hall'
|
||||
},
|
||||
{
|
||||
'earliest_book': datetime.date(2007, 12, 6),
|
||||
'num_awards': 3,
|
||||
'id': 1,
|
||||
'name': u'Apress'
|
||||
},
|
||||
{
|
||||
'earliest_book': datetime.date(2008, 3, 3),
|
||||
'num_awards': 1,
|
||||
'id': 2,
|
||||
'name': u'Sams'
|
||||
}
|
||||
]
|
||||
)
|
||||
|
||||
vals = Store.objects.aggregate(Max("friday_night_closing"), Min("original_opening"))
|
||||
self.assertEqual(
|
||||
vals,
|
||||
{
|
||||
"friday_night_closing__max": datetime.time(23, 59, 59),
|
||||
"original_opening__min": datetime.datetime(1945, 4, 25, 16, 24, 14),
|
||||
}
|
||||
)
|
||||
|
||||
def test_annotate_values_list(self):
|
||||
books = Book.objects.filter(pk=1).annotate(mean_age=Avg("authors__age")).values_list("pk", "isbn", "mean_age")
|
||||
self.assertEqual(
|
||||
list(books), [
|
||||
(1, "159059725", 34.5),
|
||||
]
|
||||
)
|
||||
|
||||
books = Book.objects.filter(pk=1).annotate(mean_age=Avg("authors__age")).values_list("isbn")
|
||||
self.assertEqual(
|
||||
list(books), [
|
||||
('159059725',)
|
||||
]
|
||||
)
|
||||
|
||||
books = Book.objects.filter(pk=1).annotate(mean_age=Avg("authors__age")).values_list("mean_age")
|
||||
self.assertEqual(
|
||||
list(books), [
|
||||
(34.5,)
|
||||
]
|
||||
)
|
||||
|
||||
books = Book.objects.filter(pk=1).annotate(mean_age=Avg("authors__age")).values_list("mean_age", flat=True)
|
||||
self.assertEqual(list(books), [34.5])
|
||||
|
||||
books = Book.objects.values_list("price").annotate(count=Count("price")).order_by("-count", "price")
|
||||
self.assertEqual(
|
||||
list(books), [
|
||||
(Decimal("29.69"), 2),
|
||||
(Decimal('23.09'), 1),
|
||||
(Decimal('30'), 1),
|
||||
(Decimal('75'), 1),
|
||||
(Decimal('82.8'), 1),
|
||||
]
|
||||
)
|
||||
@ -1,476 +1,228 @@
|
||||
"""
|
||||
###################
|
||||
# Empty QueryDict #
|
||||
###################
|
||||
|
||||
>>> q = QueryDict('')
|
||||
|
||||
>>> q['foo']
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
MultiValueDictKeyError: "Key 'foo' not found in <QueryDict: {}>"
|
||||
|
||||
>>> q['something'] = 'bar'
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
AttributeError: This QueryDict instance is immutable
|
||||
|
||||
>>> q.get('foo', 'default')
|
||||
'default'
|
||||
|
||||
>>> q.getlist('foo')
|
||||
[]
|
||||
|
||||
>>> q.setlist('foo', ['bar', 'baz'])
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
AttributeError: This QueryDict instance is immutable
|
||||
|
||||
>>> q.appendlist('foo', ['bar'])
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
AttributeError: This QueryDict instance is immutable
|
||||
|
||||
>>> q.has_key('foo')
|
||||
False
|
||||
|
||||
>>> 'foo' in q
|
||||
False
|
||||
|
||||
>>> q.items()
|
||||
[]
|
||||
|
||||
>>> q.lists()
|
||||
[]
|
||||
|
||||
>>> q.keys()
|
||||
[]
|
||||
|
||||
>>> q.values()
|
||||
[]
|
||||
|
||||
>>> len(q)
|
||||
0
|
||||
|
||||
>>> q.update({'foo': 'bar'})
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
AttributeError: This QueryDict instance is immutable
|
||||
|
||||
>>> q.pop('foo')
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
AttributeError: This QueryDict instance is immutable
|
||||
|
||||
>>> q.popitem()
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
AttributeError: This QueryDict instance is immutable
|
||||
|
||||
>>> q.clear()
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
AttributeError: This QueryDict instance is immutable
|
||||
|
||||
>>> q.setdefault('foo', 'bar')
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
AttributeError: This QueryDict instance is immutable
|
||||
|
||||
>>> q.urlencode()
|
||||
''
|
||||
|
||||
###################################
|
||||
# Mutable copy of empty QueryDict #
|
||||
###################################
|
||||
|
||||
>>> q = q.copy()
|
||||
|
||||
>>> q['foo']
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
MultiValueDictKeyError: "Key 'foo' not found in <QueryDict: {}>"
|
||||
|
||||
>>> q['name'] = 'john'
|
||||
|
||||
>>> q['name']
|
||||
u'john'
|
||||
|
||||
>>> del q['name']
|
||||
>>> 'name' in q
|
||||
False
|
||||
|
||||
>>> q['name'] = 'john'
|
||||
|
||||
>>> q.get('foo', 'default')
|
||||
'default'
|
||||
|
||||
>>> q.get('name', 'default')
|
||||
u'john'
|
||||
|
||||
>>> q.getlist('name')
|
||||
[u'john']
|
||||
|
||||
>>> q.getlist('foo')
|
||||
[]
|
||||
|
||||
>>> q.setlist('foo', ['bar', 'baz'])
|
||||
|
||||
>>> q.get('foo', 'default')
|
||||
u'baz'
|
||||
|
||||
>>> q.getlist('foo')
|
||||
[u'bar', u'baz']
|
||||
|
||||
>>> q.appendlist('foo', 'another')
|
||||
|
||||
>>> q.getlist('foo')
|
||||
[u'bar', u'baz', u'another']
|
||||
|
||||
>>> q['foo']
|
||||
u'another'
|
||||
|
||||
>>> q.has_key('foo')
|
||||
True
|
||||
|
||||
>>> 'foo' in q
|
||||
True
|
||||
|
||||
>>> q.items()
|
||||
[(u'foo', u'another'), (u'name', u'john')]
|
||||
|
||||
>>> q.lists()
|
||||
[(u'foo', [u'bar', u'baz', u'another']), (u'name', [u'john'])]
|
||||
|
||||
>>> q.keys()
|
||||
[u'foo', u'name']
|
||||
|
||||
>>> q.values()
|
||||
[u'another', u'john']
|
||||
|
||||
>>> len(q)
|
||||
2
|
||||
|
||||
>>> q.update({'foo': 'hello'})
|
||||
|
||||
# Displays last value
|
||||
>>> q['foo']
|
||||
u'hello'
|
||||
|
||||
>>> q.get('foo', 'not available')
|
||||
u'hello'
|
||||
|
||||
>>> q.getlist('foo')
|
||||
[u'bar', u'baz', u'another', u'hello']
|
||||
|
||||
>>> q.pop('foo')
|
||||
[u'bar', u'baz', u'another', u'hello']
|
||||
|
||||
>>> q.pop('foo', 'not there')
|
||||
'not there'
|
||||
|
||||
>>> q.get('foo', 'not there')
|
||||
'not there'
|
||||
|
||||
>>> q.setdefault('foo', 'bar')
|
||||
u'bar'
|
||||
|
||||
>>> q['foo']
|
||||
u'bar'
|
||||
|
||||
>>> q.getlist('foo')
|
||||
[u'bar']
|
||||
|
||||
>>> q.urlencode()
|
||||
'foo=bar&name=john'
|
||||
|
||||
>>> q.clear()
|
||||
|
||||
>>> len(q)
|
||||
0
|
||||
|
||||
#####################################
|
||||
# QueryDict with one key/value pair #
|
||||
#####################################
|
||||
|
||||
>>> q = QueryDict('foo=bar')
|
||||
|
||||
>>> q['foo']
|
||||
u'bar'
|
||||
|
||||
>>> q['bar']
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
MultiValueDictKeyError: "Key 'bar' not found in <QueryDict: {u'foo': [u'bar']}>"
|
||||
|
||||
>>> q['something'] = 'bar'
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
AttributeError: This QueryDict instance is immutable
|
||||
|
||||
>>> q.get('foo', 'default')
|
||||
u'bar'
|
||||
|
||||
>>> q.get('bar', 'default')
|
||||
'default'
|
||||
|
||||
>>> q.getlist('foo')
|
||||
[u'bar']
|
||||
|
||||
>>> q.getlist('bar')
|
||||
[]
|
||||
|
||||
>>> q.setlist('foo', ['bar', 'baz'])
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
AttributeError: This QueryDict instance is immutable
|
||||
|
||||
>>> q.appendlist('foo', ['bar'])
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
AttributeError: This QueryDict instance is immutable
|
||||
|
||||
>>> q.has_key('foo')
|
||||
True
|
||||
|
||||
>>> 'foo' in q
|
||||
True
|
||||
|
||||
>>> q.has_key('bar')
|
||||
False
|
||||
|
||||
>>> 'bar' in q
|
||||
False
|
||||
|
||||
>>> q.items()
|
||||
[(u'foo', u'bar')]
|
||||
|
||||
>>> q.lists()
|
||||
[(u'foo', [u'bar'])]
|
||||
|
||||
>>> q.keys()
|
||||
[u'foo']
|
||||
|
||||
>>> q.values()
|
||||
[u'bar']
|
||||
|
||||
>>> len(q)
|
||||
1
|
||||
|
||||
>>> q.update({'foo': 'bar'})
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
AttributeError: This QueryDict instance is immutable
|
||||
|
||||
>>> q.pop('foo')
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
AttributeError: This QueryDict instance is immutable
|
||||
|
||||
>>> q.popitem()
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
AttributeError: This QueryDict instance is immutable
|
||||
|
||||
>>> q.clear()
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
AttributeError: This QueryDict instance is immutable
|
||||
|
||||
>>> q.setdefault('foo', 'bar')
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
AttributeError: This QueryDict instance is immutable
|
||||
|
||||
>>> q.urlencode()
|
||||
'foo=bar'
|
||||
|
||||
#####################################################
|
||||
# QueryDict with two key/value pairs with same keys #
|
||||
#####################################################
|
||||
|
||||
>>> q = QueryDict('vote=yes&vote=no')
|
||||
|
||||
>>> q['vote']
|
||||
u'no'
|
||||
|
||||
>>> q['something'] = 'bar'
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
AttributeError: This QueryDict instance is immutable
|
||||
|
||||
>>> q.get('vote', 'default')
|
||||
u'no'
|
||||
|
||||
>>> q.get('foo', 'default')
|
||||
'default'
|
||||
|
||||
>>> q.getlist('vote')
|
||||
[u'yes', u'no']
|
||||
|
||||
>>> q.getlist('foo')
|
||||
[]
|
||||
|
||||
>>> q.setlist('foo', ['bar', 'baz'])
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
AttributeError: This QueryDict instance is immutable
|
||||
|
||||
>>> q.appendlist('foo', ['bar'])
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
AttributeError: This QueryDict instance is immutable
|
||||
|
||||
>>> q.has_key('vote')
|
||||
True
|
||||
|
||||
>>> 'vote' in q
|
||||
True
|
||||
|
||||
>>> q.has_key('foo')
|
||||
False
|
||||
|
||||
>>> 'foo' in q
|
||||
False
|
||||
|
||||
>>> q.items()
|
||||
[(u'vote', u'no')]
|
||||
|
||||
>>> q.lists()
|
||||
[(u'vote', [u'yes', u'no'])]
|
||||
|
||||
>>> q.keys()
|
||||
[u'vote']
|
||||
|
||||
>>> q.values()
|
||||
[u'no']
|
||||
|
||||
>>> len(q)
|
||||
1
|
||||
|
||||
>>> q.update({'foo': 'bar'})
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
AttributeError: This QueryDict instance is immutable
|
||||
|
||||
>>> q.pop('foo')
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
AttributeError: This QueryDict instance is immutable
|
||||
|
||||
>>> q.popitem()
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
AttributeError: This QueryDict instance is immutable
|
||||
|
||||
>>> q.clear()
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
AttributeError: This QueryDict instance is immutable
|
||||
|
||||
>>> q.setdefault('foo', 'bar')
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
AttributeError: This QueryDict instance is immutable
|
||||
|
||||
>>> q.urlencode()
|
||||
'vote=yes&vote=no'
|
||||
|
||||
>>> del q['vote']
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
AttributeError: This QueryDict instance is immutable
|
||||
|
||||
# QueryDicts must be able to handle invalid input encoding (in this case, bad
|
||||
# UTF-8 encoding).
|
||||
>>> q = QueryDict('foo=bar&foo=\xff')
|
||||
|
||||
>>> q['foo']
|
||||
u'\ufffd'
|
||||
|
||||
>>> q.getlist('foo')
|
||||
[u'bar', u'\ufffd']
|
||||
|
||||
|
||||
########################
|
||||
# Pickling a QueryDict #
|
||||
########################
|
||||
>>> import pickle
|
||||
>>> q = QueryDict('')
|
||||
>>> q1 = pickle.loads(pickle.dumps(q, 2))
|
||||
>>> q == q1
|
||||
True
|
||||
>>> q = QueryDict('a=b&c=d')
|
||||
>>> q1 = pickle.loads(pickle.dumps(q, 2))
|
||||
>>> q == q1
|
||||
True
|
||||
>>> q = QueryDict('a=b&c=d&a=1')
|
||||
>>> q1 = pickle.loads(pickle.dumps(q, 2))
|
||||
>>> q == q1
|
||||
True
|
||||
|
||||
######################################
|
||||
# HttpResponse with Unicode headers #
|
||||
######################################
|
||||
|
||||
>>> r = HttpResponse()
|
||||
|
||||
If we insert a unicode value it will be converted to an ascii
|
||||
string. This makes sure we comply with the HTTP specifications.
|
||||
|
||||
>>> r['value'] = u'test value'
|
||||
>>> isinstance(r['value'], str)
|
||||
True
|
||||
|
||||
An error is raised When a unicode object with non-ascii is assigned.
|
||||
|
||||
>>> r['value'] = u't\xebst value' # doctest:+ELLIPSIS
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
UnicodeEncodeError: ..., HTTP response headers must be in US-ASCII format
|
||||
|
||||
The response also converts unicode keys to strings.
|
||||
|
||||
>>> r[u'test'] = 'testing key'
|
||||
>>> l = list(r.items())
|
||||
>>> l.sort()
|
||||
>>> l[1]
|
||||
('test', 'testing key')
|
||||
|
||||
It will also raise errors for keys with non-ascii data.
|
||||
|
||||
>>> r[u't\xebst'] = 'testing key' # doctest:+ELLIPSIS
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
UnicodeEncodeError: ..., HTTP response headers must be in US-ASCII format
|
||||
|
||||
# Bug #10188: Do not allow newlines in headers (CR or LF)
|
||||
>>> r['test\\rstr'] = 'test'
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
BadHeaderError: Header values can't contain newlines (got 'test\\rstr')
|
||||
|
||||
>>> r['test\\nstr'] = 'test'
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
BadHeaderError: Header values can't contain newlines (got 'test\\nstr')
|
||||
|
||||
#
|
||||
# Regression test for #8278: QueryDict.update(QueryDict)
|
||||
#
|
||||
>>> x = QueryDict("a=1&a=2", mutable=True)
|
||||
>>> y = QueryDict("a=3&a=4")
|
||||
>>> x.update(y)
|
||||
>>> x.getlist('a')
|
||||
[u'1', u'2', u'3', u'4']
|
||||
"""
|
||||
|
||||
from django.http import QueryDict, HttpResponse, CompatCookie
|
||||
from django.test import TestCase
|
||||
|
||||
|
||||
class Cookies(TestCase):
|
||||
|
||||
import copy
|
||||
import pickle
|
||||
import unittest
|
||||
from django.http import QueryDict, HttpResponse, CompatCookie, BadHeaderError
|
||||
|
||||
class QueryDictTests(unittest.TestCase):
|
||||
def test_missing_key(self):
|
||||
q = QueryDict('')
|
||||
self.assertRaises(KeyError, q.__getitem__, 'foo')
|
||||
|
||||
def test_immutability(self):
|
||||
q = QueryDict('')
|
||||
self.assertRaises(AttributeError, q.__setitem__, 'something', 'bar')
|
||||
self.assertRaises(AttributeError, q.setlist, 'foo', ['bar'])
|
||||
self.assertRaises(AttributeError, q.appendlist, 'foo', ['bar'])
|
||||
self.assertRaises(AttributeError, q.update, {'foo': 'bar'})
|
||||
self.assertRaises(AttributeError, q.pop, 'foo')
|
||||
self.assertRaises(AttributeError, q.popitem)
|
||||
self.assertRaises(AttributeError, q.clear)
|
||||
|
||||
def test_immutable_get_with_default(self):
|
||||
q = QueryDict('')
|
||||
self.assertEqual(q.get('foo', 'default'), 'default')
|
||||
|
||||
def test_immutable_basic_operations(self):
|
||||
q = QueryDict('')
|
||||
self.assertEqual(q.getlist('foo'), [])
|
||||
self.assertEqual(q.has_key('foo'), False)
|
||||
self.assertEqual('foo' in q, False)
|
||||
self.assertEqual(q.items(), [])
|
||||
self.assertEqual(q.lists(), [])
|
||||
self.assertEqual(q.items(), [])
|
||||
self.assertEqual(q.keys(), [])
|
||||
self.assertEqual(q.values(), [])
|
||||
self.assertEqual(len(q), 0)
|
||||
self.assertEqual(q.urlencode(), '')
|
||||
|
||||
def test_single_key_value(self):
|
||||
"""Test QueryDict with one key/value pair"""
|
||||
|
||||
q = QueryDict('foo=bar')
|
||||
self.assertEqual(q['foo'], 'bar')
|
||||
self.assertRaises(KeyError, q.__getitem__, 'bar')
|
||||
self.assertRaises(AttributeError, q.__setitem__, 'something', 'bar')
|
||||
|
||||
self.assertEqual(q.get('foo', 'default'), 'bar')
|
||||
self.assertEqual(q.get('bar', 'default'), 'default')
|
||||
self.assertEqual(q.getlist('foo'), ['bar'])
|
||||
self.assertEqual(q.getlist('bar'), [])
|
||||
|
||||
self.assertRaises(AttributeError, q.setlist, 'foo', ['bar'])
|
||||
self.assertRaises(AttributeError, q.appendlist, 'foo', ['bar'])
|
||||
|
||||
self.failUnless(q.has_key('foo'))
|
||||
self.failUnless('foo' in q)
|
||||
self.failIf(q.has_key('bar'))
|
||||
self.failIf('bar' in q)
|
||||
|
||||
self.assertEqual(q.items(), [(u'foo', u'bar')])
|
||||
self.assertEqual(q.lists(), [(u'foo', [u'bar'])])
|
||||
self.assertEqual(q.keys(), ['foo'])
|
||||
self.assertEqual(q.values(), ['bar'])
|
||||
self.assertEqual(len(q), 1)
|
||||
|
||||
self.assertRaises(AttributeError, q.update, {'foo': 'bar'})
|
||||
self.assertRaises(AttributeError, q.pop, 'foo')
|
||||
self.assertRaises(AttributeError, q.popitem)
|
||||
self.assertRaises(AttributeError, q.clear)
|
||||
self.assertRaises(AttributeError, q.setdefault, 'foo', 'bar')
|
||||
|
||||
self.assertEqual(q.urlencode(), 'foo=bar')
|
||||
|
||||
def test_mutable_copy(self):
|
||||
"""A copy of a QueryDict is mutable."""
|
||||
q = QueryDict('').copy()
|
||||
self.assertRaises(KeyError, q.__getitem__, "foo")
|
||||
q['name'] = 'john'
|
||||
self.assertEqual(q['name'], 'john')
|
||||
|
||||
def test_mutable_delete(self):
|
||||
q = QueryDict('').copy()
|
||||
q['name'] = 'john'
|
||||
del q['name']
|
||||
self.failIf('name' in q)
|
||||
|
||||
def test_basic_mutable_operations(self):
|
||||
q = QueryDict('').copy()
|
||||
q['name'] = 'john'
|
||||
self.assertEqual(q.get('foo', 'default'), 'default')
|
||||
self.assertEqual(q.get('name', 'default'), 'john')
|
||||
self.assertEqual(q.getlist('name'), ['john'])
|
||||
self.assertEqual(q.getlist('foo'), [])
|
||||
|
||||
q.setlist('foo', ['bar', 'baz'])
|
||||
self.assertEqual(q.get('foo', 'default'), 'baz')
|
||||
self.assertEqual(q.getlist('foo'), ['bar', 'baz'])
|
||||
|
||||
q.appendlist('foo', 'another')
|
||||
self.assertEqual(q.getlist('foo'), ['bar', 'baz', 'another'])
|
||||
self.assertEqual(q['foo'], 'another')
|
||||
self.failUnless(q.has_key('foo'))
|
||||
self.failUnless('foo' in q)
|
||||
|
||||
self.assertEqual(q.items(), [(u'foo', u'another'), (u'name', u'john')])
|
||||
self.assertEqual(q.lists(), [(u'foo', [u'bar', u'baz', u'another']), (u'name', [u'john'])])
|
||||
self.assertEqual(q.keys(), [u'foo', u'name'])
|
||||
self.assertEqual(q.values(), [u'another', u'john'])
|
||||
self.assertEqual(len(q), 2)
|
||||
|
||||
q.update({'foo': 'hello'})
|
||||
self.assertEqual(q['foo'], 'hello')
|
||||
self.assertEqual(q.get('foo', 'not available'), 'hello')
|
||||
self.assertEqual(q.getlist('foo'), [u'bar', u'baz', u'another', u'hello'])
|
||||
self.assertEqual(q.pop('foo'), [u'bar', u'baz', u'another', u'hello'])
|
||||
self.assertEqual(q.pop('foo', 'not there'), 'not there')
|
||||
self.assertEqual(q.get('foo', 'not there'), 'not there')
|
||||
self.assertEqual(q.setdefault('foo', 'bar'), 'bar')
|
||||
self.assertEqual(q['foo'], 'bar')
|
||||
self.assertEqual(q.getlist('foo'), ['bar'])
|
||||
self.assertEqual(q.urlencode(), 'foo=bar&name=john')
|
||||
|
||||
q.clear()
|
||||
self.assertEqual(len(q), 0)
|
||||
|
||||
def test_multiple_keys(self):
|
||||
"""Test QueryDict with two key/value pairs with same keys."""
|
||||
|
||||
q = QueryDict('vote=yes&vote=no')
|
||||
|
||||
self.assertEqual(q['vote'], u'no')
|
||||
self.assertRaises(AttributeError, q.__setitem__, 'something', 'bar')
|
||||
|
||||
self.assertEqual(q.get('vote', 'default'), u'no')
|
||||
self.assertEqual(q.get('foo', 'default'), 'default')
|
||||
self.assertEqual(q.getlist('vote'), [u'yes', u'no'])
|
||||
self.assertEqual(q.getlist('foo'), [])
|
||||
|
||||
self.assertRaises(AttributeError, q.setlist, 'foo', ['bar', 'baz'])
|
||||
self.assertRaises(AttributeError, q.setlist, 'foo', ['bar', 'baz'])
|
||||
self.assertRaises(AttributeError, q.appendlist, 'foo', ['bar'])
|
||||
|
||||
self.assertEqual(q.has_key('vote'), True)
|
||||
self.assertEqual('vote' in q, True)
|
||||
self.assertEqual(q.has_key('foo'), False)
|
||||
self.assertEqual('foo' in q, False)
|
||||
self.assertEqual(q.items(), [(u'vote', u'no')])
|
||||
self.assertEqual(q.lists(), [(u'vote', [u'yes', u'no'])])
|
||||
self.assertEqual(q.keys(), [u'vote'])
|
||||
self.assertEqual(q.values(), [u'no'])
|
||||
self.assertEqual(len(q), 1)
|
||||
|
||||
self.assertRaises(AttributeError, q.update, {'foo': 'bar'})
|
||||
self.assertRaises(AttributeError, q.pop, 'foo')
|
||||
self.assertRaises(AttributeError, q.popitem)
|
||||
self.assertRaises(AttributeError, q.clear)
|
||||
self.assertRaises(AttributeError, q.setdefault, 'foo', 'bar')
|
||||
self.assertRaises(AttributeError, q.__delitem__, 'vote')
|
||||
|
||||
def test_invalid_input_encoding(self):
|
||||
"""
|
||||
QueryDicts must be able to handle invalid input encoding (in this
|
||||
case, bad UTF-8 encoding).
|
||||
"""
|
||||
q = QueryDict('foo=bar&foo=\xff')
|
||||
self.assertEqual(q['foo'], u'\ufffd')
|
||||
self.assertEqual(q.getlist('foo'), [u'bar', u'\ufffd'])
|
||||
|
||||
def test_pickle(self):
|
||||
q = QueryDict('')
|
||||
q1 = pickle.loads(pickle.dumps(q, 2))
|
||||
self.assertEqual(q == q1, True)
|
||||
q = QueryDict('a=b&c=d')
|
||||
q1 = pickle.loads(pickle.dumps(q, 2))
|
||||
self.assertEqual(q == q1, True)
|
||||
q = QueryDict('a=b&c=d&a=1')
|
||||
q1 = pickle.loads(pickle.dumps(q, 2))
|
||||
self.assertEqual(q == q1 , True)
|
||||
|
||||
def test_update_from_querydict(self):
|
||||
"""Regression test for #8278: QueryDict.update(QueryDict)"""
|
||||
x = QueryDict("a=1&a=2", mutable=True)
|
||||
y = QueryDict("a=3&a=4")
|
||||
x.update(y)
|
||||
self.assertEqual(x.getlist('a'), [u'1', u'2', u'3', u'4'])
|
||||
|
||||
def test_non_default_encoding(self):
|
||||
"""#13572 - QueryDict with a non-default encoding"""
|
||||
q = QueryDict('sbb=one', encoding='rot_13')
|
||||
self.assertEqual(q.encoding , 'rot_13' )
|
||||
self.assertEqual(q.items() , [(u'foo', u'bar')] )
|
||||
self.assertEqual(q.urlencode() , 'sbb=one' )
|
||||
q = q.copy()
|
||||
self.assertEqual(q.encoding , 'rot_13' )
|
||||
self.assertEqual(q.items() , [(u'foo', u'bar')] )
|
||||
self.assertEqual(q.urlencode() , 'sbb=one' )
|
||||
self.assertEqual(copy.copy(q).encoding , 'rot_13' )
|
||||
self.assertEqual(copy.deepcopy(q).encoding , 'rot_13')
|
||||
|
||||
class HttpResponseTests(unittest.TestCase):
|
||||
def test_unicode_headers(self):
|
||||
r = HttpResponse()
|
||||
|
||||
# If we insert a unicode value it will be converted to an ascii
|
||||
r['value'] = u'test value'
|
||||
self.failUnless(isinstance(r['value'], str))
|
||||
|
||||
# An error is raised When a unicode object with non-ascii is assigned.
|
||||
self.assertRaises(UnicodeEncodeError, r.__setitem__, 'value', u't\xebst value')
|
||||
|
||||
# The response also converts unicode keys to strings.)
|
||||
r[u'test'] = 'testing key'
|
||||
l = list(r.items())
|
||||
l.sort()
|
||||
self.assertEqual(l[1], ('test', 'testing key'))
|
||||
|
||||
# It will also raise errors for keys with non-ascii data.
|
||||
self.assertRaises(UnicodeEncodeError, r.__setitem__, u't\xebst key', 'value')
|
||||
|
||||
def test_newlines_in_headers(self):
|
||||
# Bug #10188: Do not allow newlines in headers (CR or LF)
|
||||
r = HttpResponse()
|
||||
self.assertRaises(BadHeaderError, r.__setitem__, 'test\rstr', 'test')
|
||||
self.assertRaises(BadHeaderError, r.__setitem__, 'test\nstr', 'test')
|
||||
|
||||
class CookieTests(unittest.TestCase):
|
||||
def test_encode(self):
|
||||
"""
|
||||
Test that we don't output tricky characters in encoded value
|
||||
@ -502,7 +254,3 @@ class Cookies(TestCase):
|
||||
c2 = CompatCookie()
|
||||
c2.load(c.output())
|
||||
self.assertEqual(c['test'].value, c2['test'].value)
|
||||
|
||||
if __name__ == "__main__":
|
||||
import doctest
|
||||
doctest.testmod()
|
||||
|
||||
@ -10,14 +10,16 @@ forward, backwards and self references.
|
||||
|
||||
import datetime
|
||||
import decimal
|
||||
import unittest
|
||||
from cStringIO import StringIO
|
||||
try:
|
||||
from cStringIO import StringIO
|
||||
except ImportError:
|
||||
from StringIO import StringIO
|
||||
|
||||
from django.utils.functional import curry
|
||||
from django.core import serializers
|
||||
from django.db import transaction, DEFAULT_DB_ALIAS
|
||||
from django.core import management
|
||||
from django.conf import settings
|
||||
from django.core import serializers, management
|
||||
from django.db import transaction, DEFAULT_DB_ALIAS
|
||||
from django.test import TestCase
|
||||
from django.utils.functional import curry
|
||||
|
||||
from models import *
|
||||
|
||||
@ -59,10 +61,10 @@ def im2m_create(pk, klass, data):
|
||||
|
||||
def im_create(pk, klass, data):
|
||||
instance = klass(id=pk)
|
||||
setattr(instance, 'right_id', data['right'])
|
||||
setattr(instance, 'left_id', data['left'])
|
||||
instance.right_id = data['right']
|
||||
instance.left_id = data['left']
|
||||
if 'extra' in data:
|
||||
setattr(instance, 'extra', data['extra'])
|
||||
instance.extra = data['extra']
|
||||
models.Model.save_base(instance, raw=True)
|
||||
return [instance]
|
||||
|
||||
@ -96,7 +98,9 @@ def inherited_create(pk, klass, data):
|
||||
def data_compare(testcase, pk, klass, data):
|
||||
instance = klass.objects.get(id=pk)
|
||||
testcase.assertEqual(data, instance.data,
|
||||
"Objects with PK=%d not equal; expected '%s' (%s), got '%s' (%s)" % (pk,data, type(data), instance.data, type(instance.data)))
|
||||
"Objects with PK=%d not equal; expected '%s' (%s), got '%s' (%s)" % (
|
||||
pk, data, type(data), instance.data, type(instance.data))
|
||||
)
|
||||
|
||||
def generic_compare(testcase, pk, klass, data):
|
||||
instance = klass.objects.get(id=pk)
|
||||
@ -348,28 +352,16 @@ if settings.DATABASES[DEFAULT_DB_ALIAS]['ENGINE'] != 'django.db.backends.mysql':
|
||||
|
||||
# Dynamically create serializer tests to ensure that all
|
||||
# registered serializers are automatically tested.
|
||||
class SerializerTests(unittest.TestCase):
|
||||
class SerializerTests(TestCase):
|
||||
pass
|
||||
|
||||
def serializerTest(format, self):
|
||||
# Clear the database first
|
||||
management.call_command('flush', verbosity=0, interactive=False)
|
||||
|
||||
# Create all the objects defined in the test data
|
||||
objects = []
|
||||
instance_count = {}
|
||||
transaction.enter_transaction_management()
|
||||
try:
|
||||
transaction.managed(True)
|
||||
for (func, pk, klass, datum) in test_data:
|
||||
objects.extend(func[0](pk, klass, datum))
|
||||
instance_count[klass] = 0
|
||||
transaction.commit()
|
||||
except:
|
||||
transaction.rollback()
|
||||
transaction.leave_transaction_management()
|
||||
raise
|
||||
transaction.leave_transaction_management()
|
||||
for (func, pk, klass, datum) in test_data:
|
||||
objects.extend(func[0](pk, klass, datum))
|
||||
|
||||
# Get a count of the number of objects created for each class
|
||||
for klass in instance_count:
|
||||
@ -381,19 +373,8 @@ def serializerTest(format, self):
|
||||
# Serialize the test database
|
||||
serialized_data = serializers.serialize(format, objects, indent=2)
|
||||
|
||||
# Flush the database and recreate from the serialized data
|
||||
management.call_command('flush', verbosity=0, interactive=False)
|
||||
transaction.enter_transaction_management()
|
||||
try:
|
||||
transaction.managed(True)
|
||||
for obj in serializers.deserialize(format, serialized_data):
|
||||
obj.save()
|
||||
transaction.commit()
|
||||
except:
|
||||
transaction.rollback()
|
||||
transaction.leave_transaction_management()
|
||||
raise
|
||||
transaction.leave_transaction_management()
|
||||
for obj in serializers.deserialize(format, serialized_data):
|
||||
obj.save()
|
||||
|
||||
# Assert that the deserialized data is the same
|
||||
# as the original source
|
||||
@ -406,10 +387,7 @@ def serializerTest(format, self):
|
||||
self.assertEquals(count, klass.objects.count())
|
||||
|
||||
def fieldsTest(format, self):
|
||||
# Clear the database first
|
||||
management.call_command('flush', verbosity=0, interactive=False)
|
||||
|
||||
obj = ComplexModel(field1='first',field2='second',field3='third')
|
||||
obj = ComplexModel(field1='first', field2='second', field3='third')
|
||||
obj.save_base(raw=True)
|
||||
|
||||
# Serialize then deserialize the test database
|
||||
@ -422,9 +400,6 @@ def fieldsTest(format, self):
|
||||
self.assertEqual(result.object.field3, 'third')
|
||||
|
||||
def streamTest(format, self):
|
||||
# Clear the database first
|
||||
management.call_command('flush', verbosity=0, interactive=False)
|
||||
|
||||
obj = ComplexModel(field1='first',field2='second',field3='third')
|
||||
obj.save_base(raw=True)
|
||||
|
||||
@ -440,7 +415,7 @@ def streamTest(format, self):
|
||||
stream.close()
|
||||
|
||||
for format in serializers.get_serializer_formats():
|
||||
setattr(SerializerTests, 'test_'+format+'_serializer', curry(serializerTest, format))
|
||||
setattr(SerializerTests, 'test_'+format+'_serializer_fields', curry(fieldsTest, format))
|
||||
setattr(SerializerTests, 'test_' + format + '_serializer', curry(serializerTest, format))
|
||||
setattr(SerializerTests, 'test_' + format + '_serializer_fields', curry(fieldsTest, format))
|
||||
if format != 'python':
|
||||
setattr(SerializerTests, 'test_'+format+'_serializer_stream', curry(streamTest, format))
|
||||
setattr(SerializerTests, 'test_' + format + '_serializer_stream', curry(streamTest, format))
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user