mirror of
https://github.com/django/django.git
synced 2024-11-18 07:26:04 +00:00
617 lines
28 KiB
Python
617 lines
28 KiB
Python
# -*- coding: utf-8 -*-
|
|
from __future__ import unicode_literals
|
|
|
|
import os
|
|
import sys
|
|
import traceback
|
|
import unittest
|
|
import warnings
|
|
|
|
from django import template
|
|
from django.contrib.auth.models import Group
|
|
from django.core import urlresolvers
|
|
from django.template import loader, Context, RequestContext, Template, TemplateSyntaxError
|
|
from django.template.engine import Engine
|
|
from django.template.loaders import app_directories, filesystem
|
|
from django.test import RequestFactory, SimpleTestCase
|
|
from django.test.utils import override_settings, extend_sys_path
|
|
from django.utils.deprecation import RemovedInDjango19Warning, RemovedInDjango20Warning
|
|
from django.utils._os import upath
|
|
from django.utils import six
|
|
from django.utils import translation
|
|
|
|
from . import filters
|
|
from .syntax_tests.utils import register_test_tags, ShouldNotExecuteException
|
|
|
|
|
|
class ContextStackException(Exception):
|
|
pass
|
|
|
|
|
|
class TemplateLoaderTests(SimpleTestCase):
|
|
|
|
def test_loaders_security(self):
|
|
ad_loader = app_directories.Loader(Engine.get_default())
|
|
fs_loader = filesystem.Loader(Engine.get_default())
|
|
|
|
def test_template_sources(path, template_dirs, expected_sources):
|
|
if isinstance(expected_sources, list):
|
|
# Fix expected sources so they are abspathed
|
|
expected_sources = [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(b'\xc3\x85ngstr\xc3\xb6m', template_dirs,
|
|
['/dir1/Ångström', '/dir2/Ångström'])
|
|
# Unicode strings are permitted.
|
|
test_template_sources('Ångström', template_dirs,
|
|
['/dir1/Ångström', '/dir2/Ångström'])
|
|
test_template_sources('Ångström', [b'/Stra\xc3\x9fe'], ['/Straße/Ångström'])
|
|
test_template_sources(b'\xc3\x85ngstr\xc3\xb6m', [b'/Stra\xc3\x9fe'],
|
|
['/Straße/Ångström'])
|
|
# Invalid UTF-8 encoding in bytestrings is not. Should raise a
|
|
# semi-useful error message.
|
|
test_template_sources(b'\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'])
|
|
|
|
@override_settings(TEMPLATE_LOADERS=['django.template.loaders.filesystem.Loader'])
|
|
# Turn TEMPLATE_DEBUG on, so that the origin file name will be kept with
|
|
# the compiled templates.
|
|
@override_settings(TEMPLATE_DEBUG=True)
|
|
def test_loader_debug_origin(self):
|
|
# We rely on the fact that runtests.py sets up TEMPLATE_DIRS to
|
|
# point to a directory containing a login.html file.
|
|
load_name = 'login.html'
|
|
|
|
# We also rely on the fact the file system and app directories loaders
|
|
# both inherit the load_template method from the base Loader class, so
|
|
# we only need to test one of them.
|
|
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)
|
|
|
|
@override_settings(TEMPLATE_LOADERS=[
|
|
('django.template.loaders.cached.Loader',
|
|
['django.template.loaders.filesystem.Loader']),
|
|
])
|
|
@override_settings(TEMPLATE_DEBUG=True)
|
|
def test_cached_loader_debug_origin(self):
|
|
# Same comment as in test_loader_debug_origin.
|
|
load_name = 'login.html'
|
|
|
|
# Test the cached loader separately since it overrides load_template.
|
|
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)
|
|
|
|
@override_settings(TEMPLATE_DEBUG=True)
|
|
def test_loader_origin(self):
|
|
template = loader.get_template('login.html')
|
|
self.assertEqual(template.origin.loadname, 'login.html')
|
|
|
|
@override_settings(TEMPLATE_DEBUG=True)
|
|
def test_string_origin(self):
|
|
template = Template('string template')
|
|
self.assertEqual(template.origin.source, 'string template')
|
|
|
|
def test_debug_false_origin(self):
|
|
template = loader.get_template('login.html')
|
|
self.assertEqual(template.origin, None)
|
|
|
|
# TEMPLATE_DEBUG must be true, otherwise the exception raised
|
|
# during {% include %} processing will be suppressed.
|
|
@override_settings(TEMPLATE_DEBUG=True)
|
|
# 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.
|
|
@override_settings(TEMPLATE_LOADERS=['django.template.loaders.app_directories.Loader'])
|
|
def test_include_missing_template(self):
|
|
"""
|
|
Tests that the correct template is identified as not existing
|
|
when {% include %} specifies a template that does not exist.
|
|
"""
|
|
load_name = 'test_include_error.html'
|
|
r = None
|
|
try:
|
|
tmpl = loader.select_template([load_name])
|
|
r = tmpl.render(template.Context({}))
|
|
except template.TemplateDoesNotExist as e:
|
|
self.assertEqual(e.args[0], 'missing.html')
|
|
self.assertEqual(r, None, 'Template rendering unexpectedly succeeded, produced: ->%r<-' % r)
|
|
|
|
# TEMPLATE_DEBUG must be true, otherwise the exception raised
|
|
# during {% include %} processing will be suppressed.
|
|
@override_settings(TEMPLATE_DEBUG=True)
|
|
# 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.
|
|
@override_settings(TEMPLATE_LOADERS=['django.template.loaders.app_directories.Loader'])
|
|
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.
|
|
"""
|
|
load_name = 'test_extends_error.html'
|
|
tmpl = loader.get_template(load_name)
|
|
r = None
|
|
try:
|
|
r = tmpl.render(template.Context({}))
|
|
except template.TemplateDoesNotExist as e:
|
|
self.assertEqual(e.args[0], 'missing.html')
|
|
self.assertEqual(r, None, 'Template rendering unexpectedly succeeded, produced: ->%r<-' % r)
|
|
|
|
@override_settings(TEMPLATE_DEBUG=True)
|
|
def test_extends_include_missing_cachedloader(self):
|
|
"""
|
|
Same as test_extends_include_missing_baseloader, only tests
|
|
behavior of the cached loader instead of base loader.
|
|
"""
|
|
with override_settings(TEMPLATE_LOADERS=[
|
|
('django.template.loaders.cached.Loader', [
|
|
'django.template.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.TemplateDoesNotExist as e:
|
|
self.assertEqual(e.args[0], '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.TemplateDoesNotExist as e:
|
|
self.assertEqual(e.args[0], 'missing.html')
|
|
self.assertEqual(r, None, 'Template rendering unexpectedly succeeded, produced: ->%r<-' % r)
|
|
|
|
def test_include_template_argument(self):
|
|
"""
|
|
Support any render() supporting object
|
|
"""
|
|
ctx = Context({
|
|
'tmpl': Template('This worked!'),
|
|
})
|
|
outer_tmpl = Template('{% include tmpl %}')
|
|
output = outer_tmpl.render(ctx)
|
|
self.assertEqual(output, 'This worked!')
|
|
|
|
@override_settings(TEMPLATE_DEBUG=True)
|
|
def test_include_immediate_missing(self):
|
|
"""
|
|
Regression test for #16417 -- {% include %} tag raises TemplateDoesNotExist at compile time if TEMPLATE_DEBUG is True
|
|
|
|
Test that an {% include %} tag with a literal string referencing a
|
|
template that does not exist does not raise an exception at parse
|
|
time.
|
|
"""
|
|
tmpl = Template('{% include "this_does_not_exist.html" %}')
|
|
self.assertIsInstance(tmpl, Template)
|
|
|
|
@override_settings(TEMPLATE_DEBUG=True)
|
|
def test_include_recursive(self):
|
|
comments = [
|
|
{
|
|
'comment': 'A1',
|
|
'children': [
|
|
{'comment': 'B1', 'children': []},
|
|
{'comment': 'B2', 'children': []},
|
|
{'comment': 'B3', 'children': [
|
|
{'comment': 'C1', 'children': []}
|
|
]},
|
|
]
|
|
}
|
|
]
|
|
|
|
t = loader.get_template('recursive_include.html')
|
|
self.assertEqual(
|
|
"Recursion! A1 Recursion! B1 B2 B3 Recursion! C1",
|
|
t.render(Context({'comments': comments})).replace(' ', '').replace('\n', ' ').strip(),
|
|
)
|
|
|
|
|
|
class TemplateRegressionTests(SimpleTestCase):
|
|
|
|
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")'])
|
|
|
|
@override_settings(SETTINGS_MODULE=None, TEMPLATE_DEBUG=True)
|
|
def test_url_reverse_no_settings_module(self):
|
|
# Regression test for #9005
|
|
t = Template('{% url will_not_match %}')
|
|
c = Context()
|
|
with self.assertRaises(urlresolvers.NoReverseMatch):
|
|
t.render(c)
|
|
|
|
@override_settings(TEMPLATE_STRING_IF_INVALID='%s is invalid', SETTINGS_MODULE='also_something')
|
|
def test_url_reverse_view_name(self):
|
|
# Regression test for #19827
|
|
t = Template('{% url will_not_match %}')
|
|
c = Context()
|
|
try:
|
|
t.render(c)
|
|
except urlresolvers.NoReverseMatch:
|
|
tb = sys.exc_info()[2]
|
|
depth = 0
|
|
while tb.tb_next is not None:
|
|
tb = tb.tb_next
|
|
depth += 1
|
|
self.assertGreater(depth, 5,
|
|
"The traceback context was lost when reraising the traceback. See #19827")
|
|
|
|
@override_settings(DEBUG=True, TEMPLATE_DEBUG=True)
|
|
def test_no_wrapped_exception(self):
|
|
"""
|
|
The template system doesn't wrap exceptions, but annotates them.
|
|
Refs #16770
|
|
"""
|
|
c = Context({"coconuts": lambda: 42 / 0})
|
|
t = Template("{{ coconuts }}")
|
|
with self.assertRaises(ZeroDivisionError) as cm:
|
|
t.render(c)
|
|
|
|
self.assertEqual(cm.exception.django_template_source[1], (0, 14))
|
|
|
|
def test_invalid_block_suggestion(self):
|
|
# See #7876
|
|
try:
|
|
Template("{% if 1 %}lala{% endblock %}{% endif %}")
|
|
except TemplateSyntaxError as e:
|
|
self.assertEqual(e.args[0], "Invalid block tag: 'endblock', expected 'elif', 'else' or 'endif'")
|
|
|
|
def test_ifchanged_concurrency(self):
|
|
# Tests for #15849
|
|
template = Template('[0{% for x in foo %},{% with var=get_value %}{% ifchanged %}{{ var }}{% endifchanged %}{% endwith %}{% endfor %}]')
|
|
|
|
# Using generator to mimic concurrency.
|
|
# The generator is not passed to the 'for' loop, because it does a list(values)
|
|
# instead, call gen.next() in the template to control the generator.
|
|
def gen():
|
|
yield 1
|
|
yield 2
|
|
# Simulate that another thread is now rendering.
|
|
# When the IfChangeNode stores state at 'self' it stays at '3' and skip the last yielded value below.
|
|
iter2 = iter([1, 2, 3])
|
|
output2 = template.render(Context({'foo': range(3), 'get_value': lambda: next(iter2)}))
|
|
self.assertEqual(output2, '[0,1,2,3]', 'Expected [0,1,2,3] in second parallel template, got {}'.format(output2))
|
|
yield 3
|
|
|
|
gen1 = gen()
|
|
output1 = template.render(Context({'foo': range(3), 'get_value': lambda: next(gen1)}))
|
|
self.assertEqual(output1, '[0,1,2,3]', 'Expected [0,1,2,3] in first template, got {}'.format(output1))
|
|
|
|
def test_cache_regression_20130(self):
|
|
t = Template('{% load cache %}{% cache 1 regression_20130 %}foo{% endcache %}')
|
|
cachenode = t.nodelist[1]
|
|
self.assertEqual(cachenode.fragment_name, 'regression_20130')
|
|
|
|
@override_settings(CACHES={
|
|
'default': {
|
|
'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
|
|
'LOCATION': 'default',
|
|
},
|
|
'template_fragments': {
|
|
'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
|
|
'LOCATION': 'fragments',
|
|
},
|
|
})
|
|
def test_cache_fragment_cache(self):
|
|
"""
|
|
When a cache called "template_fragments" is present, the cache tag
|
|
will use it in preference to 'default'
|
|
"""
|
|
t1 = Template('{% load cache %}{% cache 1 fragment %}foo{% endcache %}')
|
|
t2 = Template('{% load cache %}{% cache 1 fragment using="default" %}bar{% endcache %}')
|
|
|
|
ctx = Context()
|
|
o1 = t1.render(ctx)
|
|
o2 = t2.render(ctx)
|
|
|
|
self.assertEqual(o1, 'foo')
|
|
self.assertEqual(o2, 'bar')
|
|
|
|
def test_cache_missing_backend(self):
|
|
"""
|
|
When a cache that doesn't exist is specified, the cache tag will
|
|
raise a TemplateSyntaxError
|
|
'"""
|
|
t = Template('{% load cache %}{% cache 1 backend using="unknown" %}bar{% endcache %}')
|
|
|
|
ctx = Context()
|
|
with self.assertRaises(TemplateSyntaxError):
|
|
t.render(ctx)
|
|
|
|
def test_ifchanged_render_once(self):
|
|
""" Test for ticket #19890. The content of ifchanged template tag was
|
|
rendered twice."""
|
|
template = Template('{% ifchanged %}{% cycle "1st time" "2nd time" %}{% endifchanged %}')
|
|
output = template.render(Context({}))
|
|
self.assertEqual(output, '1st time')
|
|
|
|
def test_super_errors(self):
|
|
"""
|
|
Test behavior of the raise errors into included blocks.
|
|
See #18169
|
|
"""
|
|
t = loader.get_template('included_content.html')
|
|
with self.assertRaises(urlresolvers.NoReverseMatch):
|
|
t.render(Context({}))
|
|
|
|
def test_debug_tag_non_ascii(self):
|
|
"""
|
|
Test non-ASCII model representation in debug output (#23060).
|
|
"""
|
|
Group.objects.create(name="清風")
|
|
c1 = Context({"objs": Group.objects.all()})
|
|
t1 = Template('{% debug %}')
|
|
self.assertIn("清風", t1.render(c1))
|
|
|
|
|
|
# Set ALLOWED_INCLUDE_ROOTS so that ssi works.
|
|
@override_settings(TEMPLATE_DEBUG=False, ROOT_URLCONF='template_tests.urls')
|
|
class TemplateTests(SimpleTestCase):
|
|
|
|
@register_test_tags
|
|
def test_templates(self):
|
|
template_tests = filters.get_filter_tests()
|
|
|
|
templates = dict((name, t[0]) for name, t in six.iteritems(template_tests))
|
|
with override_settings(TEMPLATE_LOADERS=[
|
|
('django.template.loaders.cached.Loader', [
|
|
('django.template.loaders.locmem.Loader', templates),
|
|
]),
|
|
]):
|
|
failures = []
|
|
tests = sorted(template_tests.items())
|
|
|
|
# Warm the URL reversing cache. This ensures we don't pay the cost
|
|
# warming the cache during one of the tests.
|
|
urlresolvers.reverse('named.client', args=(0,))
|
|
|
|
for name, vals in tests:
|
|
|
|
# Set TEMPLATE_STRING_IF_INVALID to a known string.
|
|
expected_invalid_str = 'INVALID'
|
|
|
|
if isinstance(vals[2], tuple):
|
|
normal_string_result = vals[2][0]
|
|
invalid_string_result = vals[2][1]
|
|
|
|
if isinstance(invalid_string_result, tuple):
|
|
expected_invalid_str = 'INVALID %s'
|
|
invalid_string_result = invalid_string_result[0] % invalid_string_result[1]
|
|
|
|
try:
|
|
template_debug_result = vals[2][2]
|
|
except IndexError:
|
|
template_debug_result = normal_string_result
|
|
|
|
else:
|
|
normal_string_result = vals[2]
|
|
invalid_string_result = vals[2]
|
|
template_debug_result = vals[2]
|
|
|
|
with translation.override(vals[1].get('LANGUAGE_CODE', 'en-us')):
|
|
for invalid_str, template_debug, result in [
|
|
('', False, normal_string_result),
|
|
(expected_invalid_str, False, invalid_string_result),
|
|
('', True, template_debug_result)
|
|
]:
|
|
with override_settings(TEMPLATE_STRING_IF_INVALID=invalid_str,
|
|
TEMPLATE_DEBUG=template_debug):
|
|
for is_cached in (False, True):
|
|
try:
|
|
try:
|
|
with warnings.catch_warnings():
|
|
# Ignore pending deprecations of loading 'ssi' and 'url' tags from future.
|
|
warnings.filterwarnings("ignore", category=RemovedInDjango19Warning, module='django.templatetags.future')
|
|
# Ignore deprecations of loading 'cycle' and 'firstof' tags from future.
|
|
warnings.filterwarnings("ignore", category=RemovedInDjango20Warning, module="django.templatetags.future")
|
|
test_template = loader.get_template(name)
|
|
except ShouldNotExecuteException:
|
|
failures.append("Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s', TEMPLATE_DEBUG=%s): %s -- FAILED. Template loading invoked method that shouldn't have been invoked." % (is_cached, invalid_str, template_debug, name))
|
|
|
|
try:
|
|
with warnings.catch_warnings():
|
|
# Ignore deprecations of using the wrong number of variables with the 'for' tag.
|
|
# and warnings for {% url %} reversing by dotted path
|
|
warnings.filterwarnings("ignore", category=RemovedInDjango20Warning, module="django.template.defaulttags")
|
|
# Ignore deprecations of old style unordered_list
|
|
# and removetags.
|
|
warnings.filterwarnings("ignore", category=RemovedInDjango20Warning, module="django.template.defaultfilters")
|
|
# Ignore numpy deprecation warnings (#23890)
|
|
warnings.filterwarnings(
|
|
"ignore",
|
|
"Using a non-integer number instead of an "
|
|
"integer will result in an error in the future",
|
|
DeprecationWarning
|
|
)
|
|
output = self.render(test_template, vals)
|
|
except ShouldNotExecuteException:
|
|
failures.append("Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s', TEMPLATE_DEBUG=%s): %s -- FAILED. Template rendering invoked method that shouldn't have been invoked." % (is_cached, invalid_str, template_debug, name))
|
|
except ContextStackException:
|
|
failures.append("Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s', TEMPLATE_DEBUG=%s): %s -- FAILED. Context stack was left imbalanced" % (is_cached, invalid_str, template_debug, 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', TEMPLATE_DEBUG=%s): %s -- FAILED. Got %s, exception: %s\n%s" % (is_cached, invalid_str, template_debug, name, exc_type, exc_value, tb))
|
|
continue
|
|
if output != result:
|
|
failures.append("Template test (Cached='%s', TEMPLATE_STRING_IF_INVALID='%s', TEMPLATE_DEBUG=%s): %s -- FAILED. Expected %r, got %r" % (is_cached, invalid_str, template_debug, name, result, output))
|
|
|
|
Engine.get_default().template_loaders[0].reset()
|
|
|
|
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
|
|
|
|
|
|
class TemplateTagLoading(SimpleTestCase):
|
|
|
|
def setUp(self):
|
|
self.egg_dir = '%s/eggs' % os.path.dirname(upath(__file__))
|
|
|
|
def test_load_error(self):
|
|
ttext = "{% load broken_tag %}"
|
|
self.assertRaises(template.TemplateSyntaxError, template.Template, ttext)
|
|
try:
|
|
template.Template(ttext)
|
|
except template.TemplateSyntaxError as e:
|
|
self.assertIn('ImportError', e.args[0])
|
|
self.assertIn('Xtemplate', e.args[0])
|
|
|
|
def test_load_error_egg(self):
|
|
ttext = "{% load broken_egg %}"
|
|
egg_name = '%s/tagsegg.egg' % self.egg_dir
|
|
with extend_sys_path(egg_name):
|
|
with self.assertRaises(template.TemplateSyntaxError):
|
|
with self.settings(INSTALLED_APPS=['tagsegg']):
|
|
template.Template(ttext)
|
|
try:
|
|
with self.settings(INSTALLED_APPS=['tagsegg']):
|
|
template.Template(ttext)
|
|
except template.TemplateSyntaxError as e:
|
|
self.assertIn('ImportError', e.args[0])
|
|
self.assertIn('Xtemplate', e.args[0])
|
|
|
|
def test_load_working_egg(self):
|
|
ttext = "{% load working_egg %}"
|
|
egg_name = '%s/tagsegg.egg' % self.egg_dir
|
|
with extend_sys_path(egg_name):
|
|
with self.settings(INSTALLED_APPS=['tagsegg']):
|
|
template.Template(ttext)
|
|
|
|
|
|
class RequestContextTests(unittest.TestCase):
|
|
|
|
def setUp(self):
|
|
self.fake_request = RequestFactory().get('/')
|
|
|
|
@override_settings(TEMPLATE_LOADERS=[
|
|
('django.template.loaders.locmem.Loader', {
|
|
'child': '{{ var|default:"none" }}',
|
|
}),
|
|
])
|
|
def test_include_only(self):
|
|
"""
|
|
Regression test for #15721, ``{% include %}`` and ``RequestContext``
|
|
not playing together nicely.
|
|
"""
|
|
ctx = RequestContext(self.fake_request, {'var': 'parent'})
|
|
self.assertEqual(
|
|
template.Template('{% include "child" %}').render(ctx),
|
|
'parent'
|
|
)
|
|
self.assertEqual(
|
|
template.Template('{% include "child" only %}').render(ctx),
|
|
'none'
|
|
)
|
|
|
|
def test_stack_size(self):
|
|
"""
|
|
Regression test for #7116, Optimize RequetsContext construction
|
|
"""
|
|
ctx = RequestContext(self.fake_request, {})
|
|
# The stack should now contain 3 items:
|
|
# [builtins, supplied context, context processor]
|
|
self.assertEqual(len(ctx.dicts), 3)
|
|
|
|
@override_settings(TEMPLATE_CONTEXT_PROCESSORS=())
|
|
def test_context_comparable(self):
|
|
test_data = {'x': 'y', 'v': 'z', 'd': {'o': object, 'a': 'b'}}
|
|
|
|
# test comparing RequestContext to prevent problems if somebody
|
|
# adds __eq__ in the future
|
|
request = RequestFactory().get('/')
|
|
|
|
self.assertEqual(
|
|
RequestContext(request, dict_=test_data),
|
|
RequestContext(request, dict_=test_data)
|
|
)
|
|
|
|
|
|
class SSITests(SimpleTestCase):
|
|
def setUp(self):
|
|
self.this_dir = os.path.dirname(os.path.abspath(upath(__file__)))
|
|
self.ssi_dir = os.path.join(self.this_dir, "templates", "first")
|
|
|
|
def render_ssi(self, path):
|
|
# the path must exist for the test to be reliable
|
|
self.assertTrue(os.path.exists(path))
|
|
return template.Template('{%% ssi "%s" %%}' % path).render(Context())
|
|
|
|
def test_allowed_paths(self):
|
|
acceptable_path = os.path.join(self.ssi_dir, "..", "first", "test.html")
|
|
with override_settings(ALLOWED_INCLUDE_ROOTS=(self.ssi_dir,)):
|
|
self.assertEqual(self.render_ssi(acceptable_path), 'First template\n')
|
|
|
|
def test_relative_include_exploit(self):
|
|
"""
|
|
May not bypass ALLOWED_INCLUDE_ROOTS with relative paths
|
|
|
|
e.g. if ALLOWED_INCLUDE_ROOTS = ("/var/www",), it should not be
|
|
possible to do {% ssi "/var/www/../../etc/passwd" %}
|
|
"""
|
|
disallowed_paths = [
|
|
os.path.join(self.ssi_dir, "..", "ssi_include.html"),
|
|
os.path.join(self.ssi_dir, "..", "second", "test.html"),
|
|
]
|
|
with override_settings(ALLOWED_INCLUDE_ROOTS=(self.ssi_dir,)):
|
|
for path in disallowed_paths:
|
|
self.assertEqual(self.render_ssi(path), '')
|