# -*- coding: utf-8 -*-

from django.conf import settings

if __name__ == '__main__':

    # When running this file in isolation, we need to set up the configuration

    # before importing 'template'.

    settings.configure()

from datetime import datetime, timedelta

import time

import os

import sys

import traceback

import unittest

from django import template

from django.core import urlresolvers

from django.template import loader

from django.template.loaders import app_directories, filesystem, cached

from django.utils.translation import activate, deactivate, ugettext as _

from django.utils.safestring import mark_safe

from django.utils.tzinfo import LocalTimezone

from context import ContextTests

from custom import CustomTests

from parser import ParserTests

from unicode import UnicodeTests

from nodelist import NodelistTest

from smartif import *

try:

    from loaders import *

except ImportError:

    pass # If setuptools isn't installed, that's fine. Just move on.

import filters

#################################

# Custom template tag for tests #

#################################

register = template.Library()

class EchoNode(template.Node):

    def __init__(self, contents):

        self.contents = contents

    def render(self, context):

        return " ".join(self.contents)

def do_echo(parser, token):

    return EchoNode(token.contents.split()[1:])

register.tag("echo", do_echo)

template.libraries['testtags'] = register

#####################################

# Helper objects for template tests #

#####################################

class SomeException(Exception):

    silent_variable_failure = True

class SomeOtherException(Exception):

    pass

class ContextStackException(Exception):

    pass

class SomeClass:

    def __init__(self):

        self.otherclass = OtherClass()

    def method(self):

        return "SomeClass.method"

    def method2(self, o):

        return o

    def method3(self):

        raise SomeException

    def method4(self):

        raise SomeOtherException

class OtherClass:

    def method(self):

        return "OtherClass.method"

class TestObj(object):

    def is_true(self):

        return True

    def is_false(self):

        return False

    def is_bad(self):

        time.sleep(0.3)

        return True

class SilentGetItemClass(object):

    def __getitem__(self, key):

        raise SomeException

class SilentAttrClass(object):

    def b(self):

        raise SomeException

    b = property(b)

class UTF8Class:

    "Class whose __str__ returns non-ASCII data"

    def __str__(self):

        return u'ŠĐĆŽćžšđ'.encode('utf-8')

class Templates(unittest.TestCase):

    def test_loaders_security(self):

        ad_loader = app_directories.Loader()

        fs_loader = filesystem.Loader()

        def test_template_sources(path, template_dirs, expected_sources):

            if isinstance(expected_sources, list):

                # Fix expected sources so they are normcased and abspathed

                expected_sources = [os.path.normcase(os.path.abspath(s)) for s in expected_sources]

            # Test the two loaders (app_directores and filesystem).

            func1 = lambda p, t: list(ad_loader.get_template_sources(p, t))

            func2 = lambda p, t: list(fs_loader.get_template_sources(p, t))

            for func in (func1, func2):

                if isinstance(expected_sources, list):

                    self.assertEqual(func(path, template_dirs), expected_sources)

                else:

                    self.assertRaises(expected_sources, func, path, template_dirs)

        template_dirs = ['/dir1', '/dir2']

        test_template_sources('index.html', template_dirs,

                              ['/dir1/index.html', '/dir2/index.html'])

        test_template_sources('/etc/passwd', template_dirs, [])

        test_template_sources('etc/passwd', template_dirs,

                              ['/dir1/etc/passwd', '/dir2/etc/passwd'])

        test_template_sources('../etc/passwd', template_dirs, [])

        test_template_sources('../../../etc/passwd', template_dirs, [])

        test_template_sources('/dir1/index.html', template_dirs,

                              ['/dir1/index.html'])

        test_template_sources('../dir2/index.html', template_dirs,

                              ['/dir2/index.html'])

        test_template_sources('/dir1blah', template_dirs, [])

        test_template_sources('../dir1blah', template_dirs, [])

        # UTF-8 bytestrings are permitted.

        test_template_sources('\xc3\x85ngstr\xc3\xb6m', template_dirs,

                              [u'/dir1/Ångström', u'/dir2/Ångström'])

        # Unicode strings are permitted.

        test_template_sources(u'Ångström', template_dirs,

                              [u'/dir1/Ångström', u'/dir2/Ångström'])

        test_template_sources(u'Ångström', ['/Straße'], [u'/Straße/Ångström'])

        test_template_sources('\xc3\x85ngstr\xc3\xb6m', ['/Straße'],

                              [u'/Straße/Ångström'])

        # Invalid UTF-8 encoding in bytestrings is not. Should raise a

        # semi-useful error message.

        test_template_sources('\xc3\xc3', template_dirs, UnicodeDecodeError)

        # Case insensitive tests (for win32). Not run unless we're on

        # a case insensitive operating system.

        if os.path.normcase('/TEST') == os.path.normpath('/test'):

            template_dirs = ['/dir1', '/DIR2']

            test_template_sources('index.html', template_dirs,

                                  ['/dir1/index.html', '/dir2/index.html'])

            test_template_sources('/DIR1/index.HTML', template_dirs,

                                  ['/dir1/index.html'])

    def test_loader_debug_origin(self):

        # Turn TEMPLATE_DEBUG on, so that the origin file name will be kept with

        # the compiled templates.

        old_td, settings.TEMPLATE_DEBUG = settings.TEMPLATE_DEBUG, True

        old_loaders = loader.template_source_loaders

        try:

            loader.template_source_loaders = (filesystem.Loader(),)

            # We rely on the fact that runtests.py sets up TEMPLATE_DIRS to

            # point to a directory containing a 404.html file. Also that

            # the file system and app directories loaders both inherit the

            # load_template method from the BaseLoader class, so we only need

            # to test one of them.

            load_name = '404.html'

            template = loader.get_template(load_name)

            template_name = template.nodelist[0].source[0].name

            self.assertTrue(template_name.endswith(load_name),

                'Template loaded by filesystem loader has incorrect name for debug page: %s' % template_name)

            # Aso test the cached loader, since it overrides load_template

            cache_loader = cached.Loader(('',))

            cache_loader._cached_loaders = loader.template_source_loaders

            loader.template_source_loaders = (cache_loader,)

            template = loader.get_template(load_name)

            template_name = template.nodelist[0].source[0].name

            self.assertTrue(template_name.endswith(load_name),

                'Template loaded through cached loader has incorrect name for debug page: %s' % template_name)

            template = loader.get_template(load_name)

            template_name = template.nodelist[0].source[0].name

            self.assertTrue(template_name.endswith(load_name),

                'Cached template loaded through cached loader has incorrect name for debug page: %s' % template_name)

        finally:

            loader.template_source_loaders = old_loaders

            settings.TEMPLATE_DEBUG = old_td

    def test_extends_include_missing_baseloader(self):

        """

        Tests that the correct template is identified as not existing

        when {% extends %} specifies a template that does exist, but

        that template has an {% include %} of something that does not

        exist. See #12787.

        """

        # TEMPLATE_DEBUG must be true, otherwise the exception raised

        # during {% include %} processing will be suppressed.

        old_td, settings.TEMPLATE_DEBUG = settings.TEMPLATE_DEBUG, True

        old_loaders = loader.template_source_loaders

        try:

            # Test the base loader class via the app loader. load_template

            # from base is used by all shipped loaders excepting cached,

            # which has its own test.

            loader.template_source_loaders = (app_directories.Loader(),)

            load_name = 'test_extends_error.html'

            tmpl = loader.get_template(load_name)

            r = None

            try:

                r = tmpl.render(template.Context({}))

            except template.TemplateSyntaxError, e:

                settings.TEMPLATE_DEBUG = old_td

                self.assertEqual(e.args[0], 'Caught TemplateDoesNotExist while rendering: missing.html')

            self.assertEqual(r, None, 'Template rendering unexpectedly succeeded, produced: ->%r<-' % r)

        finally:

            loader.template_source_loaders = old_loaders

            settings.TEMPLATE_DEBUG = old_td

    def test_extends_include_missing_cachedloader(self):

        """

        Same as test_extends_include_missing_baseloader, only tests

        behavior of the cached loader instead of BaseLoader.

        """

        old_td, settings.TEMPLATE_DEBUG = settings.TEMPLATE_DEBUG, True

        old_loaders = loader.template_source_loaders

        try:

            cache_loader = cached.Loader(('',))

            cache_loader._cached_loaders = (app_directories.Loader(),)

            loader.template_source_loaders = (cache_loader,)

            load_name = 'test_extends_error.html'

            tmpl = loader.get_template(load_name)

            r = None

            try:

                r = tmpl.render(template.Context({}))

            except template.TemplateSyntaxError, e:

                self.assertEqual(e.args[0], 'Caught TemplateDoesNotExist while rendering: missing.html')

            self.assertEqual(r, None, 'Template rendering unexpectedly succeeded, produced: ->%r<-' % r)

            # For the cached loader, repeat the test, to ensure the first attempt did not cache a

            # result that behaves incorrectly on subsequent attempts.

            tmpl = loader.get_template(load_name)

            try:

                tmpl.render(template.Context({}))

            except template.TemplateSyntaxError, e:

                self.assertEqual(e.args[0], 'Caught TemplateDoesNotExist while rendering: missing.html')

            self.assertEqual(r, None, 'Template rendering unexpectedly succeeded, produced: ->%r<-' % r)

        finally:

            loader.template_source_loaders = old_loaders

            settings.TEMPLATE_DEBUG = old_td

    def test_token_smart_split(self):

        # Regression test for #7027

        token = template.Token(template.TOKEN_BLOCK, 'sometag _("Page not found") value|yesno:_("yes,no")')

        split = token.split_contents()

        self.assertEqual(split, ["sometag", '_("Page not found")', 'value|yesno:_("yes,no")'])

    def test_url_reverse_no_settings_module(self):

        # Regression test for #9005

        from django.template import Template, Context, TemplateSyntaxError

        old_settings_module = settings.SETTINGS_MODULE

        old_template_debug = settings.TEMPLATE_DEBUG

        settings.SETTINGS_MODULE = None

        settings.TEMPLATE_DEBUG = True

        t = Template('{% url will_not_match %}')

        c = Context()

        try:

            rendered = t.render(c)

        except TemplateSyntaxError, e:

            # Assert that we are getting the template syntax error and not the

            # string encoding error.

            self.assertEquals(e.args[0], "Caught NoReverseMatch while rendering: Reverse for 'will_not_match' with arguments '()' and keyword arguments '{}' not found.")

        settings.SETTINGS_MODULE = old_settings_module

        settings.TEMPLATE_DEBUG = old_template_debug

    def test_invalid_block_suggestion(self):

        # See #7876

        from django.template import Template, TemplateSyntaxError

        try:

            t = Template("{% if 1 %}lala{% endblock %}{% endif %}")

        except TemplateSyntaxError, e:

            self.assertEquals(e.args[0], "Invalid block tag: 'endblock', expected 'else' or 'endif'")

    def test_templates(self):

        template_tests = self.get_template_tests()

        filter_tests = filters.get_filter_tests()

        # Quickly check that we aren't accidentally using a name in both

        # template and filter tests.

        overlapping_names = [name for name in filter_tests if name in template_tests]

        assert not overlapping_names, 'Duplicate test name(s): %s' % ', '.join(overlapping_names)

        template_tests.update(filter_tests)

        # Register our custom template loader.

        def test_template_loader(template_name, template_dirs=None):

            "A custom template loader that loads the unit-test templates."

            try:

                return (template_tests[template_name][0] , "test:%s" % template_name)

            except KeyError:

                raise template.TemplateDoesNotExist, template_name

        cache_loader = cached.Loader(('test_template_loader',))

        cache_loader._cached_loaders = (test_template_loader,)

        old_template_loaders = loader.template_source_loaders

        loader.template_source_loaders = [cache_loader]

        failures = []

        tests = template_tests.items()

        tests.sort()

        # Turn TEMPLATE_DEBUG off, because tests assume that.

        old_td, settings.TEMPLATE_DEBUG = settings.TEMPLATE_DEBUG, False

        # Set TEMPLATE_STRING_IF_INVALID to a known string.

        old_invalid = settings.TEMPLATE_STRING_IF_INVALID

        expected_invalid_str = 'INVALID'

        # Warm the URL reversing cache. This ensures we don't pay the cost

        # warming the cache during one of the tests.

        urlresolvers.reverse('regressiontests.templates.views.client_action',

                             kwargs={'id':0,'action':"update"})

        for name, vals in tests:

            if isinstance(vals[2], tuple):

                normal_string_result = vals[2][0]

                invalid_string_result = vals[2][1]

                if isinstance(invalid_string_result, basestring) and '%s' in invalid_string_result:

                    expected_invalid_str = 'INVALID %s'

                    invalid_string_result = invalid_string_result % vals[2][2]

                    template.invalid_var_format_string = True

            else:

                normal_string_result = vals[2]

                invalid_string_result = vals[2]

            if 'LANGUAGE_CODE' in vals[1]:

                activate(vals[1]['LANGUAGE_CODE'])

            else:

                activate('en-us')

            for invalid_str, result in [('', normal_string_result),

                                        (expected_invalid_str, invalid_string_result)]:

                settings.TEMPLATE_STRING_IF_INVALID = invalid_str

                for is_cached in (False, True):

                    try:

                        start = datetime.now()

                        test_template = loader.get_template(name)

                        end = datetime.now()

                        if end-start > timedelta(seconds=0.2):

                            failures.append("Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s'): %s -- FAILED. Took too long to parse test" % (is_cached, invalid_str, name))

                        start = datetime.now()

                        output = self.render(test_template, vals)

                        end = datetime.now()

                        if end-start > timedelta(seconds=0.2):

                            failures.append("Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s'): %s -- FAILED. Took too long to render test" % (is_cached, invalid_str, name))

                    except ContextStackException:

                        failures.append("Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s'): %s -- FAILED. Context stack was left imbalanced" % (is_cached, invalid_str, name))

                        continue

                    except Exception:

                        exc_type, exc_value, exc_tb = sys.exc_info()

                        if exc_type != result:

                            tb = '\n'.join(traceback.format_exception(exc_type, exc_value, exc_tb))

                            failures.append("Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s'): %s -- FAILED. Got %s, exception: %s\n%s" % (is_cached, invalid_str, name, exc_type, exc_value, tb))

                        continue

                    if output != result:

                        failures.append("Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s'): %s -- FAILED. Expected %r, got %r" % (is_cached, invalid_str, name, result, output))

                cache_loader.reset()

            if 'LANGUAGE_CODE' in vals[1]:

                deactivate()

            if template.invalid_var_format_string:

                expected_invalid_str = 'INVALID'

                template.invalid_var_format_string = False

        loader.template_source_loaders = old_template_loaders

        deactivate()

        settings.TEMPLATE_DEBUG = old_td

        settings.TEMPLATE_STRING_IF_INVALID = old_invalid

        self.assertEqual(failures, [], "Tests failed:\n%s\n%s" %

            ('-'*70, ("\n%s\n" % ('-'*70)).join(failures)))

    def render(self, test_template, vals):

        context = template.Context(vals[1])

        before_stack_size = len(context.dicts)

        output = test_template.render(context)

        if len(context.dicts) != before_stack_size:

            raise ContextStackException

        return output

    def get_template_tests(self):

        # SYNTAX --

        # 'template_name': ('template contents', 'context dict', 'expected string output' or Exception class)

        return {

            ### BASIC SYNTAX ################################################

            # Plain text should go through the template parser untouched

            'basic-syntax01': ("something cool", {}, "something cool"),

            # Variables should be replaced with their value in the current

            # context

            'basic-syntax02': ("{{ headline }}", {'headline':'Success'}, "Success"),

            # More than one replacement variable is allowed in a template

            'basic-syntax03': ("{{ first }} --- {{ second }}", {"first" : 1, "second" : 2}, "1 --- 2"),

            # Fail silently when a variable is not found in the current context

            'basic-syntax04': ("as{{ missing }}df", {}, ("asdf","asINVALIDdf")),

            # A variable may not contain more than one word

            'basic-syntax06': ("{{ multi word variable }}", {}, template.TemplateSyntaxError),

            # Raise TemplateSyntaxError for empty variable tags

            'basic-syntax07': ("{{ }}",        {}, template.TemplateSyntaxError),

            'basic-syntax08': ("{{        }}", {}, template.TemplateSyntaxError),

            # Attribute syntax allows a template to call an object's attribute

            'basic-syntax09': ("{{ var.method }}", {"var": SomeClass()}, "SomeClass.method"),

            # Multiple levels of attribute access are allowed

            'basic-syntax10': ("{{ var.otherclass.method }}", {"var": SomeClass()}, "OtherClass.method"),

            # Fail silently when a variable's attribute isn't found

            'basic-syntax11': ("{{ var.blech }}", {"var": SomeClass()}, ("","INVALID")),

            # Raise TemplateSyntaxError when trying to access a variable beginning with an underscore

            'basic-syntax12': ("{{ var.__dict__ }}", {"var": SomeClass()}, template.TemplateSyntaxError),

            # Raise TemplateSyntaxError when trying to access a variable containing an illegal character

            'basic-syntax13': ("{{ va>r }}", {}, template.TemplateSyntaxError),

            'basic-syntax14': ("{{ (var.r) }}", {}, template.TemplateSyntaxError),

            'basic-syntax15': ("{{ sp%am }}", {}, template.TemplateSyntaxError),

            'basic-syntax16': ("{{ eggs! }}", {}, template.TemplateSyntaxError),

            'basic-syntax17': ("{{ moo? }}", {}, template.TemplateSyntaxError),

            # Attribute syntax allows a template to call a dictionary key's value

            'basic-syntax18': ("{{ foo.bar }}", {"foo" : {"bar" : "baz"}}, "baz"),

            # Fail silently when a variable's dictionary key isn't found

            'basic-syntax19': ("{{ foo.spam }}", {"foo" : {"bar" : "baz"}}, ("","INVALID")),

            # Fail silently when accessing a non-simple method

            'basic-syntax20': ("{{ var.method2 }}", {"var": SomeClass()}, ("","INVALID")),

            # Don't get confused when parsing something that is almost, but not

            # quite, a template tag.

            'basic-syntax21': ("a {{ moo %} b", {}, "a {{ moo %} b"),

            'basic-syntax22': ("{{ moo #}", {}, "{{ moo #}"),

            # Will try to treat "moo #} {{ cow" as the variable. Not ideal, but

            # costly to work around, so this triggers an error.

            'basic-syntax23': ("{{ moo #} {{ cow }}", {"cow": "cow"}, template.TemplateSyntaxError),

            # Embedded newlines make it not-a-tag.

            'basic-syntax24': ("{{ moo\n }}", {}, "{{ moo\n }}"),

            # Literal strings are permitted inside variables, mostly for i18n

            # purposes.

            'basic-syntax25': ('{{ "fred" }}', {}, "fred"),

            'basic-syntax26': (r'{{ "\"fred\"" }}', {}, "\"fred\""),

            'basic-syntax27': (r'{{ _("\"fred\"") }}', {}, "\"fred\""),

            # regression test for ticket #12554

            # make sure a silent_variable_failure Exception is supressed

            # on dictionary and attribute lookup

            'basic-syntax28': ("{{ a.b }}", {'a': SilentGetItemClass()}, ('', 'INVALID')),

            'basic-syntax29': ("{{ a.b }}", {'a': SilentAttrClass()}, ('', 'INVALID')),

            # Something that starts like a number but has an extra lookup works as a lookup. 

            'basic-syntax30': ("{{ 1.2.3 }}", {"1": {"2": {"3": "d"}}}, "d"), 

            'basic-syntax31': ("{{ 1.2.3 }}", {"1": {"2": ("a", "b", "c", "d")}}, "d"), 

            'basic-syntax32': ("{{ 1.2.3 }}", {"1": (("x", "x", "x", "x"), ("y", "y", "y", "y"), ("a", "b", "c", "d"))}, "d"), 

            'basic-syntax33': ("{{ 1.2.3 }}", {"1": ("xxxx", "yyyy", "abcd")}, "d"), 

            'basic-syntax34': ("{{ 1.2.3 }}", {"1": ({"x": "x"}, {"y": "y"}, {"z": "z", "3": "d"})}, "d"), 

            # Numbers are numbers even if their digits are in the context. 

            'basic-syntax35': ("{{ 1 }}", {"1": "abc"}, "1"), 

            'basic-syntax36': ("{{ 1.2 }}", {"1": "abc"}, "1.2"), 

            # List-index syntax allows a template to access a certain item of a subscriptable object.

            'list-index01': ("{{ var.1 }}", {"var": ["first item", "second item"]}, "second item"),

            # Fail silently when the list index is out of range.

            'list-index02': ("{{ var.5 }}", {"var": ["first item", "second item"]}, ("", "INVALID")),

            # Fail silently when the variable is not a subscriptable object.

            'list-index03': ("{{ var.1 }}", {"var": None}, ("", "INVALID")),

            # Fail silently when variable is a dict without the specified key.

            'list-index04': ("{{ var.1 }}", {"var": {}}, ("", "INVALID")),

            # Dictionary lookup wins out when dict's key is a string.

            'list-index05': ("{{ var.1 }}", {"var": {'1': "hello"}}, "hello"),

            # But list-index lookup wins out when dict's key is an int, which

            # behind the scenes is really a dictionary lookup (for a dict)

            # after converting the key to an int.

            'list-index06': ("{{ var.1 }}", {"var": {1: "hello"}}, "hello"),