/tests/test_ext.py
Python | 640 lines | 592 code | 36 blank | 12 comment | 10 complexity | 14535fd8834ff326492c34f165509e47 MD5 | raw file
Possible License(s): BSD-3-Clause
- import re
- from io import BytesIO
- import pytest
- from jinja2 import contextfunction
- from jinja2 import DictLoader
- from jinja2 import Environment
- from jinja2 import nodes
- from jinja2.exceptions import TemplateAssertionError
- from jinja2.ext import Extension
- from jinja2.lexer import count_newlines
- from jinja2.lexer import Token
- importable_object = 23
- _gettext_re = re.compile(r"_\((.*?)\)", re.DOTALL)
- i18n_templates = {
- "master.html": '<title>{{ page_title|default(_("missing")) }}</title>'
- "{% block body %}{% endblock %}",
- "child.html": '{% extends "master.html" %}{% block body %}'
- "{% trans %}watch out{% endtrans %}{% endblock %}",
- "plural.html": "{% trans user_count %}One user online{% pluralize %}"
- "{{ user_count }} users online{% endtrans %}",
- "plural2.html": "{% trans user_count=get_user_count() %}{{ user_count }}s"
- "{% pluralize %}{{ user_count }}p{% endtrans %}",
- "stringformat.html": '{{ _("User: %(num)s")|format(num=user_count) }}',
- }
- newstyle_i18n_templates = {
- "master.html": '<title>{{ page_title|default(_("missing")) }}</title>'
- "{% block body %}{% endblock %}",
- "child.html": '{% extends "master.html" %}{% block body %}'
- "{% trans %}watch out{% endtrans %}{% endblock %}",
- "plural.html": "{% trans user_count %}One user online{% pluralize %}"
- "{{ user_count }} users online{% endtrans %}",
- "stringformat.html": '{{ _("User: %(num)s", num=user_count) }}',
- "ngettext.html": '{{ ngettext("%(num)s apple", "%(num)s apples", apples) }}',
- "ngettext_long.html": "{% trans num=apples %}{{ num }} apple{% pluralize %}"
- "{{ num }} apples{% endtrans %}",
- "transvars1.html": "{% trans %}User: {{ num }}{% endtrans %}",
- "transvars2.html": "{% trans num=count %}User: {{ num }}{% endtrans %}",
- "transvars3.html": "{% trans count=num %}User: {{ count }}{% endtrans %}",
- "novars.html": "{% trans %}%(hello)s{% endtrans %}",
- "vars.html": "{% trans %}{{ foo }}%(foo)s{% endtrans %}",
- "explicitvars.html": '{% trans foo="42" %}%(foo)s{% endtrans %}',
- }
- languages = {
- "de": {
- "missing": "fehlend",
- "watch out": "pass auf",
- "One user online": "Ein Benutzer online",
- "%(user_count)s users online": "%(user_count)s Benutzer online",
- "User: %(num)s": "Benutzer: %(num)s",
- "User: %(count)s": "Benutzer: %(count)s",
- "%(num)s apple": "%(num)s Apfel",
- "%(num)s apples": "%(num)s Äpfel",
- }
- }
- @contextfunction
- def gettext(context, string):
- language = context.get("LANGUAGE", "en")
- return languages.get(language, {}).get(string, string)
- @contextfunction
- def ngettext(context, s, p, n):
- language = context.get("LANGUAGE", "en")
- if n != 1:
- return languages.get(language, {}).get(p, p)
- return languages.get(language, {}).get(s, s)
- i18n_env = Environment(
- loader=DictLoader(i18n_templates), extensions=["jinja2.ext.i18n"]
- )
- i18n_env.globals.update({"_": gettext, "gettext": gettext, "ngettext": ngettext})
- i18n_env_trimmed = Environment(extensions=["jinja2.ext.i18n"])
- i18n_env_trimmed.policies["ext.i18n.trimmed"] = True
- i18n_env_trimmed.globals.update(
- {"_": gettext, "gettext": gettext, "ngettext": ngettext}
- )
- newstyle_i18n_env = Environment(
- loader=DictLoader(newstyle_i18n_templates), extensions=["jinja2.ext.i18n"]
- )
- newstyle_i18n_env.install_gettext_callables(gettext, ngettext, newstyle=True)
- class ExampleExtension(Extension):
- tags = {"test"}
- ext_attr = 42
- context_reference_node_cls = nodes.ContextReference
- def parse(self, parser):
- return nodes.Output(
- [
- self.call_method(
- "_dump",
- [
- nodes.EnvironmentAttribute("sandboxed"),
- self.attr("ext_attr"),
- nodes.ImportedName(__name__ + ".importable_object"),
- self.context_reference_node_cls(),
- ],
- )
- ]
- ).set_lineno(next(parser.stream).lineno)
- def _dump(self, sandboxed, ext_attr, imported_object, context):
- return (
- f"{sandboxed}|{ext_attr}|{imported_object}|{context.blocks}"
- f"|{context.get('test_var')}"
- )
- class DerivedExampleExtension(ExampleExtension):
- context_reference_node_cls = nodes.DerivedContextReference
- class PreprocessorExtension(Extension):
- def preprocess(self, source, name, filename=None):
- return source.replace("[[TEST]]", "({{ foo }})")
- class StreamFilterExtension(Extension):
- def filter_stream(self, stream):
- for token in stream:
- if token.type == "data":
- yield from self.interpolate(token)
- else:
- yield token
- def interpolate(self, token):
- pos = 0
- end = len(token.value)
- lineno = token.lineno
- while 1:
- match = _gettext_re.search(token.value, pos)
- if match is None:
- break
- value = token.value[pos : match.start()]
- if value:
- yield Token(lineno, "data", value)
- lineno += count_newlines(token.value)
- yield Token(lineno, "variable_begin", None)
- yield Token(lineno, "name", "gettext")
- yield Token(lineno, "lparen", None)
- yield Token(lineno, "string", match.group(1))
- yield Token(lineno, "rparen", None)
- yield Token(lineno, "variable_end", None)
- pos = match.end()
- if pos < end:
- yield Token(lineno, "data", token.value[pos:])
- class TestExtensions:
- def test_extend_late(self):
- env = Environment()
- env.add_extension("jinja2.ext.autoescape")
- t = env.from_string('{% autoescape true %}{{ "<test>" }}{% endautoescape %}')
- assert t.render() == "<test>"
- def test_loop_controls(self):
- env = Environment(extensions=["jinja2.ext.loopcontrols"])
- tmpl = env.from_string(
- """
- {%- for item in [1, 2, 3, 4] %}
- {%- if item % 2 == 0 %}{% continue %}{% endif -%}
- {{ item }}
- {%- endfor %}"""
- )
- assert tmpl.render() == "13"
- tmpl = env.from_string(
- """
- {%- for item in [1, 2, 3, 4] %}
- {%- if item > 2 %}{% break %}{% endif -%}
- {{ item }}
- {%- endfor %}"""
- )
- assert tmpl.render() == "12"
- def test_do(self):
- env = Environment(extensions=["jinja2.ext.do"])
- tmpl = env.from_string(
- """
- {%- set items = [] %}
- {%- for char in "foo" %}
- {%- do items.append(loop.index0 ~ char) %}
- {%- endfor %}{{ items|join(', ') }}"""
- )
- assert tmpl.render() == "0f, 1o, 2o"
- def test_extension_nodes(self):
- env = Environment(extensions=[ExampleExtension])
- tmpl = env.from_string("{% test %}")
- assert tmpl.render() == "False|42|23|{}|None"
- def test_contextreference_node_passes_context(self):
- env = Environment(extensions=[ExampleExtension])
- tmpl = env.from_string('{% set test_var="test_content" %}{% test %}')
- assert tmpl.render() == "False|42|23|{}|test_content"
- def test_contextreference_node_can_pass_locals(self):
- env = Environment(extensions=[DerivedExampleExtension])
- tmpl = env.from_string(
- '{% for test_var in ["test_content"] %}{% test %}{% endfor %}'
- )
- assert tmpl.render() == "False|42|23|{}|test_content"
- def test_identifier(self):
- assert ExampleExtension.identifier == __name__ + ".ExampleExtension"
- def test_rebinding(self):
- original = Environment(extensions=[ExampleExtension])
- overlay = original.overlay()
- for env in original, overlay:
- for ext in env.extensions.values():
- assert ext.environment is env
- def test_preprocessor_extension(self):
- env = Environment(extensions=[PreprocessorExtension])
- tmpl = env.from_string("{[[TEST]]}")
- assert tmpl.render(foo=42) == "{(42)}"
- def test_streamfilter_extension(self):
- env = Environment(extensions=[StreamFilterExtension])
- env.globals["gettext"] = lambda x: x.upper()
- tmpl = env.from_string("Foo _(bar) Baz")
- out = tmpl.render()
- assert out == "Foo BAR Baz"
- def test_extension_ordering(self):
- class T1(Extension):
- priority = 1
- class T2(Extension):
- priority = 2
- env = Environment(extensions=[T1, T2])
- ext = list(env.iter_extensions())
- assert ext[0].__class__ is T1
- assert ext[1].__class__ is T2
- def test_debug(self):
- env = Environment(extensions=["jinja2.ext.debug"])
- t = env.from_string("Hello\n{% debug %}\nGoodbye")
- out = t.render()
- for value in ("context", "cycler", "filters", "abs", "tests", "!="):
- assert f"'{value}'" in out
- class TestInternationalization:
- def test_trans(self):
- tmpl = i18n_env.get_template("child.html")
- assert tmpl.render(LANGUAGE="de") == "<title>fehlend</title>pass auf"
- def test_trans_plural(self):
- tmpl = i18n_env.get_template("plural.html")
- assert tmpl.render(LANGUAGE="de", user_count=1) == "Ein Benutzer online"
- assert tmpl.render(LANGUAGE="de", user_count=2) == "2 Benutzer online"
- def test_trans_plural_with_functions(self):
- tmpl = i18n_env.get_template("plural2.html")
- def get_user_count():
- get_user_count.called += 1
- return 1
- get_user_count.called = 0
- assert tmpl.render(LANGUAGE="de", get_user_count=get_user_count) == "1s"
- assert get_user_count.called == 1
- def test_complex_plural(self):
- tmpl = i18n_env.from_string(
- "{% trans foo=42, count=2 %}{{ count }} item{% "
- "pluralize count %}{{ count }} items{% endtrans %}"
- )
- assert tmpl.render() == "2 items"
- pytest.raises(
- TemplateAssertionError,
- i18n_env.from_string,
- "{% trans foo %}...{% pluralize bar %}...{% endtrans %}",
- )
- def test_trans_stringformatting(self):
- tmpl = i18n_env.get_template("stringformat.html")
- assert tmpl.render(LANGUAGE="de", user_count=5) == "Benutzer: 5"
- def test_trimmed(self):
- tmpl = i18n_env.from_string(
- "{%- trans trimmed %} hello\n world {% endtrans -%}"
- )
- assert tmpl.render() == "hello world"
- def test_trimmed_policy(self):
- s = "{%- trans %} hello\n world {% endtrans -%}"
- tmpl = i18n_env.from_string(s)
- trimmed_tmpl = i18n_env_trimmed.from_string(s)
- assert tmpl.render() == " hello\n world "
- assert trimmed_tmpl.render() == "hello world"
- def test_trimmed_policy_override(self):
- tmpl = i18n_env_trimmed.from_string(
- "{%- trans notrimmed %} hello\n world {% endtrans -%}"
- )
- assert tmpl.render() == " hello\n world "
- def test_trimmed_vars(self):
- tmpl = i18n_env.from_string(
- '{%- trans trimmed x="world" %} hello\n {{ x }} {% endtrans -%}'
- )
- assert tmpl.render() == "hello world"
- def test_trimmed_varname_trimmed(self):
- # unlikely variable name, but when used as a variable
- # it should not enable trimming
- tmpl = i18n_env.from_string(
- "{%- trans trimmed = 'world' %} hello\n {{ trimmed }} {% endtrans -%}"
- )
- assert tmpl.render() == " hello\n world "
- def test_extract(self):
- from jinja2.ext import babel_extract
- source = BytesIO(
- b"""
- {{ gettext('Hello World') }}
- {% trans %}Hello World{% endtrans %}
- {% trans %}{{ users }} user{% pluralize %}{{ users }} users{% endtrans %}
- """
- )
- assert list(babel_extract(source, ("gettext", "ngettext", "_"), [], {})) == [
- (2, "gettext", "Hello World", []),
- (3, "gettext", "Hello World", []),
- (4, "ngettext", ("%(users)s user", "%(users)s users", None), []),
- ]
- def test_extract_trimmed(self):
- from jinja2.ext import babel_extract
- source = BytesIO(
- b"""
- {{ gettext(' Hello \n World') }}
- {% trans trimmed %} Hello \n World{% endtrans %}
- {% trans trimmed %}{{ users }} \n user
- {%- pluralize %}{{ users }} \n users{% endtrans %}
- """
- )
- assert list(babel_extract(source, ("gettext", "ngettext", "_"), [], {})) == [
- (2, "gettext", " Hello \n World", []),
- (4, "gettext", "Hello World", []),
- (6, "ngettext", ("%(users)s user", "%(users)s users", None), []),
- ]
- def test_extract_trimmed_option(self):
- from jinja2.ext import babel_extract
- source = BytesIO(
- b"""
- {{ gettext(' Hello \n World') }}
- {% trans %} Hello \n World{% endtrans %}
- {% trans %}{{ users }} \n user
- {%- pluralize %}{{ users }} \n users{% endtrans %}
- """
- )
- opts = {"trimmed": "true"}
- assert list(babel_extract(source, ("gettext", "ngettext", "_"), [], opts)) == [
- (2, "gettext", " Hello \n World", []),
- (4, "gettext", "Hello World", []),
- (6, "ngettext", ("%(users)s user", "%(users)s users", None), []),
- ]
- def test_comment_extract(self):
- from jinja2.ext import babel_extract
- source = BytesIO(
- b"""
- {# trans first #}
- {{ gettext('Hello World') }}
- {% trans %}Hello World{% endtrans %}{# trans second #}
- {#: third #}
- {% trans %}{{ users }} user{% pluralize %}{{ users }} users{% endtrans %}
- """
- )
- assert list(
- babel_extract(source, ("gettext", "ngettext", "_"), ["trans", ":"], {})
- ) == [
- (3, "gettext", "Hello World", ["first"]),
- (4, "gettext", "Hello World", ["second"]),
- (6, "ngettext", ("%(users)s user", "%(users)s users", None), ["third"]),
- ]
- class TestScope:
- def test_basic_scope_behavior(self):
- # This is what the old with statement compiled down to
- class ScopeExt(Extension):
- tags = {"scope"}
- def parse(self, parser):
- node = nodes.Scope(lineno=next(parser.stream).lineno)
- assignments = []
- while parser.stream.current.type != "block_end":
- lineno = parser.stream.current.lineno
- if assignments:
- parser.stream.expect("comma")
- target = parser.parse_assign_target()
- parser.stream.expect("assign")
- expr = parser.parse_expression()
- assignments.append(nodes.Assign(target, expr, lineno=lineno))
- node.body = assignments + list(
- parser.parse_statements(("name:endscope",), drop_needle=True)
- )
- return node
- env = Environment(extensions=[ScopeExt])
- tmpl = env.from_string(
- """\
- {%- scope a=1, b=2, c=b, d=e, e=5 -%}
- {{ a }}|{{ b }}|{{ c }}|{{ d }}|{{ e }}
- {%- endscope -%}
- """
- )
- assert tmpl.render(b=3, e=4) == "1|2|2|4|5"
- class TestNewstyleInternationalization:
- def test_trans(self):
- tmpl = newstyle_i18n_env.get_template("child.html")
- assert tmpl.render(LANGUAGE="de") == "<title>fehlend</title>pass auf"
- def test_trans_plural(self):
- tmpl = newstyle_i18n_env.get_template("plural.html")
- assert tmpl.render(LANGUAGE="de", user_count=1) == "Ein Benutzer online"
- assert tmpl.render(LANGUAGE="de", user_count=2) == "2 Benutzer online"
- def test_complex_plural(self):
- tmpl = newstyle_i18n_env.from_string(
- "{% trans foo=42, count=2 %}{{ count }} item{% "
- "pluralize count %}{{ count }} items{% endtrans %}"
- )
- assert tmpl.render() == "2 items"
- pytest.raises(
- TemplateAssertionError,
- i18n_env.from_string,
- "{% trans foo %}...{% pluralize bar %}...{% endtrans %}",
- )
- def test_trans_stringformatting(self):
- tmpl = newstyle_i18n_env.get_template("stringformat.html")
- assert tmpl.render(LANGUAGE="de", user_count=5) == "Benutzer: 5"
- def test_newstyle_plural(self):
- tmpl = newstyle_i18n_env.get_template("ngettext.html")
- assert tmpl.render(LANGUAGE="de", apples=1) == "1 Apfel"
- assert tmpl.render(LANGUAGE="de", apples=5) == "5 Äpfel"
- def test_autoescape_support(self):
- env = Environment(extensions=["jinja2.ext.autoescape", "jinja2.ext.i18n"])
- env.install_gettext_callables(
- lambda x: "<strong>Wert: %(name)s</strong>",
- lambda s, p, n: s,
- newstyle=True,
- )
- t = env.from_string(
- '{% autoescape ae %}{{ gettext("foo", name='
- '"<test>") }}{% endautoescape %}'
- )
- assert t.render(ae=True) == "<strong>Wert: <test></strong>"
- assert t.render(ae=False) == "<strong>Wert: <test></strong>"
- def test_autoescape_macros(self):
- env = Environment(autoescape=False, extensions=["jinja2.ext.autoescape"])
- template = (
- "{% macro m() %}<html>{% endmacro %}"
- "{% autoescape true %}{{ m() }}{% endautoescape %}"
- )
- assert env.from_string(template).render() == "<html>"
- def test_num_used_twice(self):
- tmpl = newstyle_i18n_env.get_template("ngettext_long.html")
- assert tmpl.render(apples=5, LANGUAGE="de") == "5 Äpfel"
- def test_num_called_num(self):
- source = newstyle_i18n_env.compile(
- """
- {% trans num=3 %}{{ num }} apple{% pluralize
- %}{{ num }} apples{% endtrans %}
- """,
- raw=True,
- )
- # quite hacky, but the only way to properly test that. The idea is
- # that the generated code does not pass num twice (although that
- # would work) for better performance. This only works on the
- # newstyle gettext of course
- assert (
- re.search(r"u?'%\(num\)s apple', u?'%\(num\)s apples', 3", source)
- is not None
- )
- def test_trans_vars(self):
- t1 = newstyle_i18n_env.get_template("transvars1.html")
- t2 = newstyle_i18n_env.get_template("transvars2.html")
- t3 = newstyle_i18n_env.get_template("transvars3.html")
- assert t1.render(num=1, LANGUAGE="de") == "Benutzer: 1"
- assert t2.render(count=23, LANGUAGE="de") == "Benutzer: 23"
- assert t3.render(num=42, LANGUAGE="de") == "Benutzer: 42"
- def test_novars_vars_escaping(self):
- t = newstyle_i18n_env.get_template("novars.html")
- assert t.render() == "%(hello)s"
- t = newstyle_i18n_env.get_template("vars.html")
- assert t.render(foo="42") == "42%(foo)s"
- t = newstyle_i18n_env.get_template("explicitvars.html")
- assert t.render() == "%(foo)s"
- class TestAutoEscape:
- def test_scoped_setting(self):
- env = Environment(extensions=["jinja2.ext.autoescape"], autoescape=True)
- tmpl = env.from_string(
- """
- {{ "<HelloWorld>" }}
- {% autoescape false %}
- {{ "<HelloWorld>" }}
- {% endautoescape %}
- {{ "<HelloWorld>" }}
- """
- )
- assert tmpl.render().split() == [
- "<HelloWorld>",
- "<HelloWorld>",
- "<HelloWorld>",
- ]
- env = Environment(extensions=["jinja2.ext.autoescape"], autoescape=False)
- tmpl = env.from_string(
- """
- {{ "<HelloWorld>" }}
- {% autoescape true %}
- {{ "<HelloWorld>" }}
- {% endautoescape %}
- {{ "<HelloWorld>" }}
- """
- )
- assert tmpl.render().split() == [
- "<HelloWorld>",
- "<HelloWorld>",
- "<HelloWorld>",
- ]
- def test_nonvolatile(self):
- env = Environment(extensions=["jinja2.ext.autoescape"], autoescape=True)
- tmpl = env.from_string('{{ {"foo": "<test>"}|xmlattr|escape }}')
- assert tmpl.render() == ' foo="<test>"'
- tmpl = env.from_string(
- '{% autoescape false %}{{ {"foo": "<test>"}'
- "|xmlattr|escape }}{% endautoescape %}"
- )
- assert tmpl.render() == " foo="&lt;test&gt;""
- def test_volatile(self):
- env = Environment(extensions=["jinja2.ext.autoescape"], autoescape=True)
- tmpl = env.from_string(
- '{% autoescape foo %}{{ {"foo": "<test>"}'
- "|xmlattr|escape }}{% endautoescape %}"
- )
- assert tmpl.render(foo=False) == " foo="&lt;test&gt;""
- assert tmpl.render(foo=True) == ' foo="<test>"'
- def test_scoping(self):
- env = Environment(extensions=["jinja2.ext.autoescape"])
- tmpl = env.from_string(
- '{% autoescape true %}{% set x = "<x>" %}{{ x }}'
- '{% endautoescape %}{{ x }}{{ "<y>" }}'
- )
- assert tmpl.render(x=1) == "<x>1<y>"
- def test_volatile_scoping(self):
- env = Environment(extensions=["jinja2.ext.autoescape"])
- tmplsource = """
- {% autoescape val %}
- {% macro foo(x) %}
- [{{ x }}]
- {% endmacro %}
- {{ foo().__class__.__name__ }}
- {% endautoescape %}
- {{ '<testing>' }}
- """
- tmpl = env.from_string(tmplsource)
- assert tmpl.render(val=True).split()[0] == "Markup"
- assert tmpl.render(val=False).split()[0] == "str"
- # looking at the source we should see <testing> there in raw
- # (and then escaped as well)
- env = Environment(extensions=["jinja2.ext.autoescape"])
- pysource = env.compile(tmplsource, raw=True)
- assert "<testing>\\n" in pysource
- env = Environment(extensions=["jinja2.ext.autoescape"], autoescape=True)
- pysource = env.compile(tmplsource, raw=True)
- assert "<testing>\\n" in pysource
- def test_overlay_scopes(self):
- class MagicScopeExtension(Extension):
- tags = {"overlay"}
- def parse(self, parser):
- node = nodes.OverlayScope(lineno=next(parser.stream).lineno)
- node.body = list(
- parser.parse_statements(("name:endoverlay",), drop_needle=True)
- )
- node.context = self.call_method("get_scope")
- return node
- def get_scope(self):
- return {"x": [1, 2, 3]}
- env = Environment(extensions=[MagicScopeExtension])
- tmpl = env.from_string(
- """
- {{- x }}|{% set z = 99 %}
- {%- overlay %}
- {{- y }}|{{ z }}|{% for item in x %}[{{ item }}]{% endfor %}
- {%- endoverlay %}|
- {{- x -}}
- """
- )
- assert tmpl.render(x=42, y=23) == "42|23|99|[1][2][3]|42"