| import re |
| import unittest |
| from urlparse import urlsplit, urlunsplit |
| from xml.dom.minidom import parseString, Node |
| |
| from django.conf import settings |
| from django.core import mail |
| from django.core.management import call_command |
| from django.core.urlresolvers import clear_url_caches |
| from django.db import transaction |
| from django.http import QueryDict |
| from django.test import _doctest as doctest |
| from django.test.client import Client |
| from django.utils import simplejson |
| |
| normalize_long_ints = lambda s: re.sub(r'(?<![\w])(\d+)L(?![\w])', '\\1', s) |
| |
| def to_list(value): |
| """ |
| Puts value into a list if it's not already one. |
| Returns an empty list if value is None. |
| """ |
| if value is None: |
| value = [] |
| elif not isinstance(value, list): |
| value = [value] |
| return value |
| |
| |
| class OutputChecker(doctest.OutputChecker): |
| def check_output(self, want, got, optionflags): |
| "The entry method for doctest output checking. Defers to a sequence of child checkers" |
| checks = (self.check_output_default, |
| self.check_output_long, |
| self.check_output_xml, |
| self.check_output_json) |
| for check in checks: |
| if check(want, got, optionflags): |
| return True |
| return False |
| |
| def check_output_default(self, want, got, optionflags): |
| "The default comparator provided by doctest - not perfect, but good for most purposes" |
| return doctest.OutputChecker.check_output(self, want, got, optionflags) |
| |
| def check_output_long(self, want, got, optionflags): |
| """Doctest does an exact string comparison of output, which means long |
| integers aren't equal to normal integers ("22L" vs. "22"). The |
| following code normalizes long integers so that they equal normal |
| integers. |
| """ |
| return normalize_long_ints(want) == normalize_long_ints(got) |
| |
| def check_output_xml(self, want, got, optionsflags): |
| """Tries to do a 'xml-comparision' of want and got. Plain string |
| comparision doesn't always work because, for example, attribute |
| ordering should not be important. |
| |
| Based on http://codespeak.net/svn/lxml/trunk/src/lxml/doctestcompare.py |
| """ |
| _norm_whitespace_re = re.compile(r'[ \t\n][ \t\n]+') |
| def norm_whitespace(v): |
| return _norm_whitespace_re.sub(' ', v) |
| |
| def child_text(element): |
| return ''.join([c.data for c in element.childNodes |
| if c.nodeType == Node.TEXT_NODE]) |
| |
| def children(element): |
| return [c for c in element.childNodes |
| if c.nodeType == Node.ELEMENT_NODE] |
| |
| def norm_child_text(element): |
| return norm_whitespace(child_text(element)) |
| |
| def attrs_dict(element): |
| return dict(element.attributes.items()) |
| |
| def check_element(want_element, got_element): |
| if want_element.tagName != got_element.tagName: |
| return False |
| if norm_child_text(want_element) != norm_child_text(got_element): |
| return False |
| if attrs_dict(want_element) != attrs_dict(got_element): |
| return False |
| want_children = children(want_element) |
| got_children = children(got_element) |
| if len(want_children) != len(got_children): |
| return False |
| for want, got in zip(want_children, got_children): |
| if not check_element(want, got): |
| return False |
| return True |
| |
| want, got = self._strip_quotes(want, got) |
| want = want.replace('\\n','\n') |
| got = got.replace('\\n','\n') |
| |
| # If the string is not a complete xml document, we may need to add a |
| # root element. This allow us to compare fragments, like "<foo/><bar/>" |
| if not want.startswith('<?xml'): |
| wrapper = '<root>%s</root>' |
| want = wrapper % want |
| got = wrapper % got |
| |
| # Parse the want and got strings, and compare the parsings. |
| try: |
| want_root = parseString(want).firstChild |
| got_root = parseString(got).firstChild |
| except: |
| return False |
| return check_element(want_root, got_root) |
| |
| def check_output_json(self, want, got, optionsflags): |
| "Tries to compare want and got as if they were JSON-encoded data" |
| want, got = self._strip_quotes(want, got) |
| try: |
| want_json = simplejson.loads(want) |
| got_json = simplejson.loads(got) |
| except: |
| return False |
| return want_json == got_json |
| |
| def _strip_quotes(self, want, got): |
| """ |
| Strip quotes of doctests output values: |
| |
| >>> o = OutputChecker() |
| >>> o._strip_quotes("'foo'") |
| "foo" |
| >>> o._strip_quotes('"foo"') |
| "foo" |
| >>> o._strip_quotes("u'foo'") |
| "foo" |
| >>> o._strip_quotes('u"foo"') |
| "foo" |
| """ |
| def is_quoted_string(s): |
| s = s.strip() |
| return (len(s) >= 2 |
| and s[0] == s[-1] |
| and s[0] in ('"', "'")) |
| |
| def is_quoted_unicode(s): |
| s = s.strip() |
| return (len(s) >= 3 |
| and s[0] == 'u' |
| and s[1] == s[-1] |
| and s[1] in ('"', "'")) |
| |
| if is_quoted_string(want) and is_quoted_string(got): |
| want = want.strip()[1:-1] |
| got = got.strip()[1:-1] |
| elif is_quoted_unicode(want) and is_quoted_unicode(got): |
| want = want.strip()[2:-1] |
| got = got.strip()[2:-1] |
| return want, got |
| |
| |
| class DocTestRunner(doctest.DocTestRunner): |
| def __init__(self, *args, **kwargs): |
| doctest.DocTestRunner.__init__(self, *args, **kwargs) |
| self.optionflags = doctest.ELLIPSIS |
| |
| def report_unexpected_exception(self, out, test, example, exc_info): |
| doctest.DocTestRunner.report_unexpected_exception(self, out, test, |
| example, exc_info) |
| # Rollback, in case of database errors. Otherwise they'd have |
| # side effects on other tests. |
| transaction.rollback_unless_managed() |
| |
| class TestCase(unittest.TestCase): |
| def _pre_setup(self): |
| """Performs any pre-test setup. This includes: |
| |
| * Flushing the database. |
| * If the Test Case class has a 'fixtures' member, installing the |
| named fixtures. |
| * If the Test Case class has a 'urls' member, replace the |
| ROOT_URLCONF with it. |
| * Clearing the mail test outbox. |
| """ |
| call_command('flush', verbosity=0, interactive=False) |
| if hasattr(self, 'fixtures'): |
| # We have to use this slightly awkward syntax due to the fact |
| # that we're using *args and **kwargs together. |
| call_command('loaddata', *self.fixtures, **{'verbosity': 0}) |
| if hasattr(self, 'urls'): |
| self._old_root_urlconf = settings.ROOT_URLCONF |
| settings.ROOT_URLCONF = self.urls |
| clear_url_caches() |
| mail.outbox = [] |
| |
| def __call__(self, result=None): |
| """ |
| Wrapper around default __call__ method to perform common Django test |
| set up. This means that user-defined Test Cases aren't required to |
| include a call to super().setUp(). |
| """ |
| self.client = Client() |
| try: |
| self._pre_setup() |
| except (KeyboardInterrupt, SystemExit): |
| raise |
| except Exception: |
| import sys |
| result.addError(self, sys.exc_info()) |
| return |
| super(TestCase, self).__call__(result) |
| try: |
| self._post_teardown() |
| except (KeyboardInterrupt, SystemExit): |
| raise |
| except Exception: |
| import sys |
| result.addError(self, sys.exc_info()) |
| return |
| |
| def _post_teardown(self): |
| """ Performs any post-test things. This includes: |
| |
| * Putting back the original ROOT_URLCONF if it was changed. |
| """ |
| if hasattr(self, '_old_root_urlconf'): |
| settings.ROOT_URLCONF = self._old_root_urlconf |
| clear_url_caches() |
| |
| def assertRedirects(self, response, expected_url, status_code=302, |
| target_status_code=200, host=None): |
| """Asserts that a response redirected to a specific URL, and that the |
| redirect URL can be loaded. |
| |
| Note that assertRedirects won't work for external links since it uses |
| TestClient to do a request. |
| """ |
| self.assertEqual(response.status_code, status_code, |
| ("Response didn't redirect as expected: Response code was %d" |
| " (expected %d)" % (response.status_code, status_code))) |
| url = response['Location'] |
| scheme, netloc, path, query, fragment = urlsplit(url) |
| e_scheme, e_netloc, e_path, e_query, e_fragment = urlsplit(expected_url) |
| if not (e_scheme or e_netloc): |
| expected_url = urlunsplit(('http', host or 'testserver', e_path, |
| e_query, e_fragment)) |
| self.assertEqual(url, expected_url, |
| "Response redirected to '%s', expected '%s'" % (url, expected_url)) |
| |
| # Get the redirection page, using the same client that was used |
| # to obtain the original response. |
| redirect_response = response.client.get(path, QueryDict(query)) |
| self.assertEqual(redirect_response.status_code, target_status_code, |
| ("Couldn't retrieve redirection page '%s': response code was %d" |
| " (expected %d)") % |
| (path, redirect_response.status_code, target_status_code)) |
| |
| def assertContains(self, response, text, count=None, status_code=200): |
| """ |
| Asserts that a response indicates that a page was retrieved |
| successfully, (i.e., the HTTP status code was as expected), and that |
| ``text`` occurs ``count`` times in the content of the response. |
| If ``count`` is None, the count doesn't matter - the assertion is true |
| if the text occurs at least once in the response. |
| """ |
| self.assertEqual(response.status_code, status_code, |
| "Couldn't retrieve page: Response code was %d (expected %d)'" % |
| (response.status_code, status_code)) |
| real_count = response.content.count(text) |
| if count is not None: |
| self.assertEqual(real_count, count, |
| "Found %d instances of '%s' in response (expected %d)" % |
| (real_count, text, count)) |
| else: |
| self.failUnless(real_count != 0, |
| "Couldn't find '%s' in response" % text) |
| |
| def assertNotContains(self, response, text, status_code=200): |
| """ |
| Asserts that a response indicates that a page was retrieved |
| successfully, (i.e., the HTTP status code was as expected), and that |
| ``text`` doesn't occurs in the content of the response. |
| """ |
| self.assertEqual(response.status_code, status_code, |
| "Couldn't retrieve page: Response code was %d (expected %d)'" % |
| (response.status_code, status_code)) |
| self.assertEqual(response.content.count(text), 0, |
| "Response should not contain '%s'" % text) |
| |
| def assertFormError(self, response, form, field, errors): |
| """ |
| Asserts that a form used to render the response has a specific field |
| error. |
| """ |
| # Put context(s) into a list to simplify processing. |
| contexts = to_list(response.context) |
| if not contexts: |
| self.fail('Response did not use any contexts to render the' |
| ' response') |
| |
| # Put error(s) into a list to simplify processing. |
| errors = to_list(errors) |
| |
| # Search all contexts for the error. |
| found_form = False |
| for i,context in enumerate(contexts): |
| if form not in context: |
| continue |
| found_form = True |
| for err in errors: |
| if field: |
| if field in context[form].errors: |
| field_errors = context[form].errors[field] |
| self.failUnless(err in field_errors, |
| "The field '%s' on form '%s' in" |
| " context %d does not contain the" |
| " error '%s' (actual errors: %s)" % |
| (field, form, i, err, |
| repr(field_errors))) |
| elif field in context[form].fields: |
| self.fail("The field '%s' on form '%s' in context %d" |
| " contains no errors" % (field, form, i)) |
| else: |
| self.fail("The form '%s' in context %d does not" |
| " contain the field '%s'" % |
| (form, i, field)) |
| else: |
| non_field_errors = context[form].non_field_errors() |
| self.failUnless(err in non_field_errors, |
| "The form '%s' in context %d does not contain the" |
| " non-field error '%s' (actual errors: %s)" % |
| (form, i, err, non_field_errors)) |
| if not found_form: |
| self.fail("The form '%s' was not used to render the response" % |
| form) |
| |
| def assertTemplateUsed(self, response, template_name): |
| """ |
| Asserts that the template with the provided name was used in rendering |
| the response. |
| """ |
| template_names = [t.name for t in to_list(response.template)] |
| if not template_names: |
| self.fail('No templates used to render the response') |
| self.failUnless(template_name in template_names, |
| (u"Template '%s' was not a template used to render the response." |
| u" Actual template(s) used: %s") % (template_name, |
| u', '.join(template_names))) |
| |
| def assertTemplateNotUsed(self, response, template_name): |
| """ |
| Asserts that the template with the provided name was NOT used in |
| rendering the response. |
| """ |
| template_names = [t.name for t in to_list(response.template)] |
| self.failIf(template_name in template_names, |
| (u"Template '%s' was used unexpectedly in rendering the" |
| u" response") % template_name) |
