mirror of
https://github.com/django/django.git
synced 2025-11-20 03:30:00 +00:00
22506b2c16
Some checks are pending
Docs / docs (push) Waiting to run
Docs / blacken-docs (push) Waiting to run
Linters / flake8 (push) Waiting to run
Linters / isort (push) Waiting to run
Linters / black (push) Waiting to run
Tests / Windows, SQLite, Python 3.13 (push) Waiting to run
Tests / JavaScript tests (push) Waiting to run
Regression in 5183f7c287.
Thank you to Jon Banafato and Baptiste Mispelon for the report.
83 lines
2.8 KiB
Python
83 lines
2.8 KiB
Python
from django.template import Context, Template, Variable, VariableDoesNotExist
|
|
from django.template.base import DebugLexer, Lexer, TokenType
|
|
from django.test import SimpleTestCase
|
|
from django.utils.translation import gettext_lazy
|
|
|
|
|
|
class LexerTestMixin:
|
|
template_string = (
|
|
"text\n"
|
|
"{% if test %}{{ varvalue }}{% endif %}"
|
|
"{#comment {{not a var}} {%not a block%} #}"
|
|
"end text"
|
|
)
|
|
expected_token_tuples = [
|
|
# (token_type, contents, lineno, position)
|
|
(TokenType.TEXT, "text\n", 1, (0, 5)),
|
|
(TokenType.BLOCK, "if test", 2, (5, 18)),
|
|
(TokenType.VAR, "varvalue", 2, (18, 32)),
|
|
(TokenType.BLOCK, "endif", 2, (32, 43)),
|
|
(TokenType.COMMENT, "comment {{not a var}} {%not a block%}", 2, (43, 85)),
|
|
(TokenType.TEXT, "end text", 2, (85, 93)),
|
|
]
|
|
|
|
def test_tokenize(self):
|
|
tokens = self.lexer_class(self.template_string).tokenize()
|
|
token_tuples = [
|
|
(t.token_type, t.contents, t.lineno, t.position) for t in tokens
|
|
]
|
|
self.assertEqual(token_tuples, self.make_expected())
|
|
|
|
def make_expected(self):
|
|
raise NotImplementedError("This method must be implemented by a subclass.")
|
|
|
|
|
|
class LexerTests(LexerTestMixin, SimpleTestCase):
|
|
lexer_class = Lexer
|
|
|
|
def make_expected(self):
|
|
# The non-debug lexer does not record position.
|
|
return [t[:-1] + (None,) for t in self.expected_token_tuples]
|
|
|
|
|
|
class DebugLexerTests(LexerTestMixin, SimpleTestCase):
|
|
lexer_class = DebugLexer
|
|
|
|
def make_expected(self):
|
|
return self.expected_token_tuples
|
|
|
|
|
|
class TemplateTests(SimpleTestCase):
|
|
def test_lazy_template_string(self):
|
|
template_string = gettext_lazy("lazy string")
|
|
self.assertEqual(Template(template_string).render(Context()), template_string)
|
|
|
|
def test_repr(self):
|
|
template = Template(
|
|
"<html><body>\n"
|
|
"{% if test %}<h1>{{ varvalue }}</h1>{% endif %}"
|
|
"</body></html>"
|
|
)
|
|
self.assertEqual(
|
|
repr(template),
|
|
'<Template template_string="<html><body>{% if t...">',
|
|
)
|
|
|
|
|
|
class VariableDoesNotExistTests(SimpleTestCase):
|
|
def test_str(self):
|
|
exc = VariableDoesNotExist(msg="Failed lookup in %r", params=({"foo": "bar"},))
|
|
self.assertEqual(str(exc), "Failed lookup in {'foo': 'bar'}")
|
|
|
|
|
|
class VariableTests(SimpleTestCase):
|
|
def test_integer_literals(self):
|
|
self.assertEqual(
|
|
Variable("999999999999999999999999999").literal, 999999999999999999999999999
|
|
)
|
|
|
|
def test_nonliterals(self):
|
|
"""Variable names that aren't resolved as literals."""
|
|
for var in ["inf", "infinity", "iNFiniTy", "nan"]:
|
|
with self.subTest(var=var):
|
|
self.assertIsNone(Variable(var).literal)
|