| 1 |
from pathlib import Path |
| 2 |
from unittest import mock, skipIf |
| 3 |
|
| 4 |
from django.contrib.auth.models import User |
| 5 |
from django.template import TemplateSyntaxError |
| 6 |
from django.test import RequestFactory, TestCase |
| 7 |
|
| 8 |
from .test_dummy import TemplateStringsTests |
| 9 |
|
| 10 |
try: |
| 11 |
import jinja2 |
| 12 |
except ImportError: |
| 13 |
jinja2 = None |
| 14 |
Jinja2 = None |
| 15 |
else: |
| 16 |
from django.template.backends.jinja2 import Jinja2 |
| 17 |
|
| 18 |
|
| 19 |
@skipIf(jinja2 is None, "this test requires jinja2") |
| 20 |
class Jinja2Tests(TemplateStringsTests): |
| 21 |
engine_class = Jinja2 |
| 22 |
backend_name = "jinja2" |
| 23 |
options = { |
| 24 |
"keep_trailing_newline": True, |
| 25 |
"context_processors": [ |
| 26 |
"django.template.context_processors.static", |
| 27 |
], |
| 28 |
} |
| 29 |
|
| 30 |
def test_origin(self): |
| 31 |
template = self.engine.get_template("template_backends/hello.html") |
| 32 |
self.assertTrue(template.origin.name.endswith("hello.html")) |
| 33 |
self.assertEqual(template.origin.template_name, "template_backends/hello.html") |
| 34 |
|
| 35 |
def test_origin_from_string(self): |
| 36 |
template = self.engine.from_string("Hello!\n") |
| 37 |
self.assertEqual(template.origin.name, "<template>") |
| 38 |
self.assertIsNone(template.origin.template_name) |
| 39 |
|
| 40 |
def test_self_context(self): |
| 41 |
""" |
| 42 |
Using 'self' in the context should not throw errors (#24538). |
| 43 |
""" |
| 44 |
# self will be overridden to be a TemplateReference, so the self |
| 45 |
# variable will not come through. Attempting to use one though should |
| 46 |
# not throw an error. |
| 47 |
template = self.engine.from_string("hello {{ foo }}!") |
| 48 |
content = template.render(context={"self": "self", "foo": "world"}) |
| 49 |
self.assertEqual(content, "hello world!") |
| 50 |
|
| 51 |
def test_exception_debug_info_min_context(self): |
| 52 |
with self.assertRaises(TemplateSyntaxError) as e: |
| 53 |
self.engine.get_template("template_backends/syntax_error.html") |
| 54 |
debug = e.exception.template_debug |
| 55 |
self.assertEqual(debug["after"], "") |
| 56 |
self.assertEqual(debug["before"], "") |
| 57 |
self.assertEqual(debug["during"], "{% block %}") |
| 58 |
self.assertEqual(debug["bottom"], 1) |
| 59 |
self.assertEqual(debug["top"], 0) |
| 60 |
self.assertEqual(debug["line"], 1) |
| 61 |
self.assertEqual(debug["total"], 1) |
| 62 |
self.assertEqual(len(debug["source_lines"]), 1) |
| 63 |
self.assertTrue(debug["name"].endswith("syntax_error.html")) |
| 64 |
self.assertIn("message", debug) |
| 65 |
|
| 66 |
def test_exception_debug_info_max_context(self): |
| 67 |
with self.assertRaises(TemplateSyntaxError) as e: |
| 68 |
self.engine.get_template("template_backends/syntax_error2.html") |
| 69 |
debug = e.exception.template_debug |
| 70 |
self.assertEqual(debug["after"], "") |
| 71 |
self.assertEqual(debug["before"], "") |
| 72 |
self.assertEqual(debug["during"], "{% block %}") |
| 73 |
self.assertEqual(debug["bottom"], 26) |
| 74 |
self.assertEqual(debug["top"], 5) |
| 75 |
self.assertEqual(debug["line"], 16) |
| 76 |
self.assertEqual(debug["total"], 31) |
| 77 |
self.assertEqual(len(debug["source_lines"]), 21) |
| 78 |
self.assertTrue(debug["name"].endswith("syntax_error2.html")) |
| 79 |
self.assertIn("message", debug) |
| 80 |
|
| 81 |
def test_context_processors(self): |
| 82 |
request = RequestFactory().get("/") |
| 83 |
template = self.engine.from_string("Static URL: {{ STATIC_URL }}") |
| 84 |
content = template.render(request=request) |
| 85 |
self.assertEqual(content, "Static URL: /static/") |
| 86 |
with self.settings(STATIC_URL="/s/"): |
| 87 |
content = template.render(request=request) |
| 88 |
self.assertEqual(content, "Static URL: /s/") |
| 89 |
|
| 90 |
def test_dirs_pathlib(self): |
| 91 |
engine = Jinja2( |
| 92 |
{ |
| 93 |
"DIRS": [Path(__file__).parent / "templates" / "template_backends"], |
| 94 |
"APP_DIRS": False, |
| 95 |
"NAME": "jinja2", |
| 96 |
"OPTIONS": {}, |
| 97 |
} |
| 98 |
) |
| 99 |
template = engine.get_template("hello.html") |
| 100 |
self.assertEqual(template.render({"name": "Joe"}), "Hello Joe!") |
| 101 |
|
| 102 |
def test_template_render_nested_error(self): |
| 103 |
template = self.engine.get_template( |
| 104 |
"template_backends/syntax_error_include.html" |
| 105 |
) |
| 106 |
with self.assertRaises(TemplateSyntaxError) as e: |
| 107 |
template.render(context={}) |
| 108 |
debug = e.exception.template_debug |
| 109 |
self.assertEqual(debug["after"], "") |
| 110 |
self.assertEqual(debug["before"], "") |
| 111 |
self.assertEqual(debug["during"], "{% block %}") |
| 112 |
self.assertEqual(debug["bottom"], 1) |
| 113 |
self.assertEqual(debug["top"], 0) |
| 114 |
self.assertEqual(debug["line"], 1) |
| 115 |
self.assertEqual(debug["total"], 1) |
| 116 |
self.assertEqual(len(debug["source_lines"]), 1) |
| 117 |
self.assertTrue(debug["name"].endswith("syntax_error.html")) |
| 118 |
self.assertIn("message", debug) |
| 119 |
|
| 120 |
def test_template_render_error_nonexistent_source(self): |
| 121 |
template = self.engine.get_template("template_backends/hello.html") |
| 122 |
with mock.patch( |
| 123 |
"jinja2.environment.Template.render", |
| 124 |
side_effect=jinja2.TemplateSyntaxError("", 1, filename="nonexistent.html"), |
| 125 |
): |
| 126 |
with self.assertRaises(TemplateSyntaxError) as e: |
| 127 |
template.render(context={}) |
| 128 |
debug = e.exception.template_debug |
| 129 |
self.assertEqual(debug["after"], "") |
| 130 |
self.assertEqual(debug["before"], "") |
| 131 |
self.assertEqual(debug["during"], "") |
| 132 |
self.assertEqual(debug["bottom"], 0) |
| 133 |
self.assertEqual(debug["top"], 0) |
| 134 |
self.assertEqual(debug["line"], 1) |
| 135 |
self.assertEqual(debug["total"], 0) |
| 136 |
self.assertEqual(len(debug["source_lines"]), 0) |
| 137 |
self.assertTrue(debug["name"].endswith("nonexistent.html")) |
| 138 |
self.assertIn("message", debug) |
| 139 |
|
| 140 |
|
| 141 |
@skipIf(jinja2 is None, "this test requires jinja2") |
| 142 |
class Jinja2SandboxTests(TestCase): |
| 143 |
engine_class = Jinja2 |
| 144 |
backend_name = "jinja2" |
| 145 |
options = {"environment": "jinja2.sandbox.SandboxedEnvironment"} |
| 146 |
|
| 147 |
@classmethod |
| 148 |
def setUpClass(cls): |
| 149 |
super().setUpClass() |
| 150 |
params = { |
| 151 |
"DIRS": [], |
| 152 |
"APP_DIRS": True, |
| 153 |
"NAME": cls.backend_name, |
| 154 |
"OPTIONS": cls.options, |
| 155 |
} |
| 156 |
cls.engine = cls.engine_class(params) |
| 157 |
|
| 158 |
def test_set_alters_data(self): |
| 159 |
template = self.engine.from_string( |
| 160 |
"{% set test = User.objects.create_superuser(" |
| 161 |
"username='evil', email='[email protected]', password='xxx') %}" |
| 162 |
"{{ test }}" |
| 163 |
) |
| 164 |
with self.assertRaises(jinja2.exceptions.SecurityError): |
| 165 |
template.render(context={"User": User}) |
| 166 |
self.assertEqual(User.objects.count(), 0) |