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.http import QueryDict

from django.test import _doctest as doctest

from django.test.client import Client

from django.utils import simplejson

from django.utils.encoding import smart_str

normalize_long_ints = lambda s: re.sub(r'(?<![\w])(\d+)L(?![\w])', '\\1', s)

normalize_decimals = lambda s: re.sub(r"Decimal\('(\d+(\.\d*)?)'\)", lambda m: "Decimal(\"%s\")" % m.groups()[0], 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

real_commit = transaction.commit

real_rollback = transaction.rollback

real_enter_transaction_management = transaction.enter_transaction_management

real_leave_transaction_management = transaction.leave_transaction_management

real_savepoint_commit = transaction.savepoint_commit

real_savepoint_rollback = transaction.savepoint_rollback

real_managed = transaction.managed

def nop(*args, **kwargs):

    return

def disable_transaction_methods():

    transaction.commit = nop

    transaction.rollback = nop

    transaction.savepoint_commit = nop

    transaction.savepoint_rollback = nop

    transaction.enter_transaction_management = nop

    transaction.leave_transaction_management = nop

    transaction.managed = nop

def restore_transaction_methods():

    transaction.commit = real_commit

    transaction.rollback = real_rollback

    transaction.savepoint_commit = real_savepoint_commit

    transaction.savepoint_rollback = real_savepoint_rollback

    transaction.enter_transaction_management = real_enter_transaction_management

    transaction.leave_transaction_management = real_leave_transaction_management

    transaction.managed = real_managed

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_numeric,

                  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_numeric(self, want, got, optionflags):

        """Doctest does an exact string comparison of output, which means that

        some numerically equivalent values aren't equal. This check normalizes

         * long integers (22L) so that they equal normal integers. (22)

         * Decimals so that they are comparable, regardless of the change

           made to __repr__ in Python 2.6.

        """

        return doctest.OutputChecker.check_output(self,

            normalize_decimals(normalize_long_ints(want)),

            normalize_decimals(normalize_long_ints(got)),

            optionflags)

    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.

class TransactionTestCase(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.

        """

        self._fixture_setup()

        self._urlconf_setup()

        mail.outbox = []

    def _fixture_setup(self):

    def _urlconf_setup(self):

        if hasattr(self, 'urls'):

            self._old_root_urlconf = settings.ROOT_URLCONF

            settings.ROOT_URLCONF = self.urls

            clear_url_caches()

    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(TransactionTestCase, 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.

        """

        self._fixture_teardown()

        self._urlconf_teardown()

    def _fixture_teardown(self):

        pass

    def _urlconf_teardown(self):

        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,

        """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.

        """

        if hasattr(response, 'redirect_chain'):

            # The request was a followed redirect

            self.failUnless(len(response.redirect_chain) > 0,

            self.assertEqual(response.redirect_chain[0][1], status_code,

            url, status_code = response.redirect_chain[-1]

            self.assertEqual(response.status_code, target_status_code,

        else:

            # Not a followed redirect

            self.assertEqual(response.status_code, status_code,

            url = response['Location']

            scheme, netloc, path, query, fragment = urlsplit(url)

            redirect_response = response.client.get(path, QueryDict(query))

            # Get the redirection page, using the same client that was used

            # to obtain the original response.

            self.assertEqual(redirect_response.status_code, target_status_code,

        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,

        """

        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,

        text = smart_str(text, response._charset)

        real_count = response.content.count(text)

        if count is not None:

            self.assertEqual(real_count, count,

        else:

            self.failUnless(real_count != 0,

        """

        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,

        text = smart_str(text, response._charset)

        """

        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: