From 8bdf160e05f666c0f1c9106719bad46b407f9992 Mon Sep 17 00:00:00 2001 From: Paul McMillan Date: Wed, 2 Jun 2010 23:49:27 +0000 Subject: [PATCH] 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 --- django/core/management/base.py | 8 +- django/db/backends/__init__.py | 5 + django/http/__init__.py | 4 +- django/test/testcases.py | 3 + django/utils/hashcompat.py | 8 +- django/views/debug.py | 2 +- docs/ref/contrib/admin/index.txt | 2 +- docs/ref/settings.txt | 7 +- docs/topics/testing.txt | 13 + tests/modeltests/aggregation/models.py | 321 +------- tests/modeltests/aggregation/tests.py | 578 ++++++++++++++ tests/regressiontests/httpwrappers/tests.py | 702 ++++++------------ .../serializers_regress/tests.py | 71 +- 13 files changed, 865 insertions(+), 859 deletions(-) create mode 100644 tests/modeltests/aggregation/tests.py diff --git a/django/core/management/base.py b/django/core/management/base.py index 4016faaa7a..a07fc7d56f 100644 --- a/django/core/management/base.py +++ b/django/core/management/base.py @@ -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) diff --git a/django/db/backends/__init__.py b/django/db/backends/__init__.py index 5918935899..fe2c7c451b 100644 --- a/django/db/backends/__init__.py +++ b/django/db/backends/__init__.py @@ -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 diff --git a/django/http/__init__.py b/django/http/__init__.py index 8756d046b5..c3917a16b2 100644 --- a/django/http/__init__.py +++ b/django/http/__init__.py @@ -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)) diff --git a/django/test/testcases.py b/django/test/testcases.py index 2f8acad68c..276d1f3c41 100644 --- a/django/test/testcases.py +++ b/django/test/testcases.py @@ -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 diff --git a/django/utils/hashcompat.py b/django/utils/hashcompat.py index b1e6021890..4d9b76f3a6 100644 --- a/django/utils/hashcompat.py +++ b/django/utils/hashcompat.py @@ -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 diff --git a/django/views/debug.py b/django/views/debug.py index 6604bd3dae..a396d36244 100644 --- a/django/views/debug.py +++ b/django/views/debug.py @@ -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 diff --git a/docs/ref/contrib/admin/index.txt b/docs/ref/contrib/admin/index.txt index 7fee903715..f7aefa457d 100644 --- a/docs/ref/contrib/admin/index.txt +++ b/docs/ref/contrib/admin/index.txt @@ -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 ---------------------------------------------- diff --git a/docs/ref/settings.txt b/docs/ref/settings.txt index 58f87b9cf4..958ac888e9 100644 --- a/docs/ref/settings.txt +++ b/docs/ref/settings.txt @@ -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`. diff --git a/docs/topics/testing.txt b/docs/topics/testing.txt index bd727ee136..9b23d546df 100644 --- a/docs/topics/testing.txt +++ b/docs/topics/testing.txt @@ -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 diff --git a/tests/modeltests/aggregation/models.py b/tests/modeltests/aggregation/models.py index f50abe651b..ccc12898b7 100644 --- a/tests/modeltests/aggregation/models.py +++ b/tests/modeltests/aggregation/models.py @@ -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') -[, , , , , ] - -# 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') -[, , ] - -# (ii) a book that cost less than 40 ->>> Publisher.objects.filter(book__price__lt=Decimal("40.0")).order_by('pk') -[, , , , ] - -# (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') -[, , ] - -# (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') -[] - -# 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.objects.annotate(num_books=Count('book')).filter(num_books__range=[1, 2]).order_by('pk') -[, , , ] - ->>> Publisher.objects.annotate(num_books=Count('book')).filter(num_books__in=[1, 3]).order_by('pk') -[, , ] - ->>> 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') -[, ] - -# 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') -[] - -# 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') -[, ] - -# 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) -[] - -# 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) -[] - -# 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 - -"""} diff --git a/tests/modeltests/aggregation/tests.py b/tests/modeltests/aggregation/tests.py new file mode 100644 index 0000000000..cb611439b9 --- /dev/null +++ b/tests/modeltests/aggregation/tests.py @@ -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), + ] + ) diff --git a/tests/regressiontests/httpwrappers/tests.py b/tests/regressiontests/httpwrappers/tests.py index 132472ca37..23aa526a37 100644 --- a/tests/regressiontests/httpwrappers/tests.py +++ b/tests/regressiontests/httpwrappers/tests.py @@ -1,476 +1,228 @@ -""" -################### -# Empty QueryDict # -################### - ->>> q = QueryDict('') - ->>> q['foo'] -Traceback (most recent call last): -... -MultiValueDictKeyError: "Key 'foo' not found in " - ->>> 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 " - ->>> 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 " - ->>> 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() diff --git a/tests/regressiontests/serializers_regress/tests.py b/tests/regressiontests/serializers_regress/tests.py index 84e90ff7e1..be920c6920 100644 --- a/tests/regressiontests/serializers_regress/tests.py +++ b/tests/regressiontests/serializers_regress/tests.py @@ -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))