def test_scoped_setting(self):
env = Environment(extensions=["jinja.ext.autoescape"], autoescape=True)
tmpl = env.from_string("""
{{ "<HelloWorld>" }}
{% autoescape false %}
{{ "<HelloWorld>" }}
{% endautoescape %}
{{ "<HelloWorld>" }}
""")
assert tmpl.render().split() == [
u"<HelloWorld>",
u"<HelloWorld>",
u"<HelloWorld>",
]
env = Environment(extensions=["jinja.ext.autoescape"],
autoescape=False)
tmpl = env.from_string("""
{{ "<HelloWorld>" }}
{% autoescape true %}
{{ "<HelloWorld>" }}
{% endautoescape %}
{{ "<HelloWorld>" }}
""")
assert tmpl.render().split() == [
u"<HelloWorld>",
u"<HelloWorld>",
u"<HelloWorld>",
]
def test_replace(self, env):
env = Environment()
tmpl = env.from_string('{{ string|replace("o", 42) }}')
assert tmpl.render(string="<foo>") == "<f4242>"
env = Environment(autoescape=True)
tmpl = env.from_string('{{ string|replace("o", 42) }}')
assert tmpl.render(string="<foo>") == "<f4242>"
tmpl = env.from_string('{{ string|replace("<", 42) }}')
assert tmpl.render(string="<foo>") == "42foo>"
tmpl = env.from_string('{{ string|replace("o", ">x<") }}')
assert tmpl.render(string=Markup("foo")) == "f>x<>x<"
def compile_down(self, prefix_loader, zip="deflated", py_compile=False):
log = []
self.reg_env = Environment(loader=prefix_loader)
if zip is not None:
fd, self.archive = tempfile.mkstemp(suffix=".zip")
os.close(fd)
else:
self.archive = tempfile.mkdtemp()
self.reg_env.compile_templates(
self.archive, zip=zip, log_function=log.append, py_compile=py_compile
)
self.mod_env = Environment(loader=loaders.ModuleLoader(self.archive))
return "".join(log)
def model_run(self, model_context):
context = self._build_context(model_context)
# mostrar el reporte
fileloader = PackageLoader('m2000', 'templates')
env = Environment(loader=fileloader)
t = env.get_template('cartera_perdida_x_incobrable.html')
yield PrintHtml(t.render(context))
def model_run(self, model_context):
context = self._build_context(model_context)
# mostrar el reporte
fileloader = PackageLoader('m2000', 'templates')
env = Environment(loader=fileloader)
t = env.get_template('recaudacion_potencial_total_x_barrio.html')
yield PrintHtml(t.render(context))
def model_run(self, model_context):
context = self._build_context(model_context)
# mostrar el reporte
fileloader = PackageLoader('m2000', 'templates')
env = Environment(loader=fileloader)
t = env.get_template('indicadores.html')
yield PrintHtmlLandscape(t.render(context))
def test_import_from_with_context(self):
env = Environment(loader=DictLoader(
{"a": "{% macro x() %}{{ foobar }}{% endmacro %}"}))
t = env.from_string(
"{% set foobar = 42 %}{% from 'a' import x with context %}{{ x() }}"
)
assert t.render() == "42"
def test_cache_loader_change(self):
loader1 = loaders.DictLoader({"foo": "one"})
loader2 = loaders.DictLoader({"foo": "two"})
env = Environment(loader=loader1, cache_size=2)
assert env.get_template("foo").render() == "one"
env.loader = loader2
assert env.get_template("foo").render() == "two"
def test_prefix_loader(self, prefix_loader):
env = Environment(loader=prefix_loader)
tmpl = env.get_template("a/test.html")
assert tmpl.render().strip() == "BAR"
tmpl = env.get_template("b/justdict.html")
assert tmpl.render().strip() == "FOO"
pytest.raises(TemplateNotFound, env.get_template, "missing")
def model_run(self, model_context):
context = self._build_context(model_context)
# mostrar el reporte
fileloader = PackageLoader('m2000', 'templates')
env = Environment(loader=fileloader)
t = env.get_template('cartera_finalizados_sin_saldar.html')
yield PrintHtml(t.render(context))
def test_raw3(self, env):
# The second newline after baz exists because it is AFTER the
# {% raw %} and is ignored.
env = Environment(lstrip_blocks=True, trim_blocks=True)
tmpl = env.from_string(
"bar\n{% raw %}\n {{baz}}2 spaces\n{% endraw %}\nfoo")
assert tmpl.render(baz="test") == "bar\n\n {{baz}}2 spaces\nfoo"
def test_weird_inline_comment(self, env):
env = Environment(line_statement_prefix="%")
pytest.raises(
TemplateSyntaxError,
env.from_string,
"% for item in seq {# missing #}\n...% endfor",
)
def test_scopes_and_blocks(self):
env = Environment(
loader=DictLoader({
"a.html": """
{%- set foo = 'bar' -%}
{% include 'x.html' -%}
""",
"b.html": """
{%- set foo = 'bar' -%}
{% block test %}{% include 'x.html' %}{% endblock -%}
""",
"c.html": """
{%- set foo = 'bar' -%}
{% block test %}{% set foo = foo
%}{% include 'x.html' %}{% endblock -%}
""",
"x.html": """{{ foo }}|{{ test }}""",
}))
a = env.get_template("a.html")
b = env.get_template("b.html")
c = env.get_template("c.html")
assert a.render(test="x").strip() == "bar|x"
assert b.render(test="x").strip() == "bar|x"
assert c.render(test="x").strip() == "bar|x"
def test_overlay_scopes(self):
class MagicScopeExtension(Extension):
tags = set(["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"
def babel_extract(fileobj, keywords, comment_tags, options):
"""
Simple extractor to get some basic Babel support.
"""
env = Environment()
for lineno, sg, pl in env.get_translations_for_string(fileobj.read()):
yield lineno, None, (sg, pl), ''
def test_debug(self):
env = Environment(extensions=["jinja.ext.debug"])
t = env.from_string("Hello\n{% debug %}\nGoodbye")
out = t.render()
for value in ("context", "cycler", "filters", "abs", "tests", "!="):
assert "'{}'".format(value) in out
def test_nonvolatile(self):
env = Environment(extensions=["jinja.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_scoped_block_after_inheritance(self, env):
env = Environment(loader=DictLoader({
"layout.html":
"""
{% block useless %}{% endblock %}
""",
"index.html":
"""
{%- extends 'layout.html' %}
{% from 'helpers.html' import foo with context %}
{% block useless %}
{% for x in [1, 2, 3] %}
{% block testing scoped %}
{{ foo(x) }}
{% endblock %}
{% endfor %}
{% endblock %}
""",
"helpers.html":
"""
{% macro foo(x) %}{{ the_foo + x }}{% endmacro %}
""",
}))
rv = env.get_template("index.html").render(the_foo=42).split()
assert rv == ["43", "44", "45"]
def test_raw4(self, env):
# The trailing dash of the {% raw -%} cleans both the spaces and
# newlines up to the first character of data.
env = Environment(lstrip_blocks=True, trim_blocks=False)
tmpl = env.from_string(
"bar\n{%- raw -%}\n\n \n 2 spaces\n space{%- endraw -%}\nfoo")
assert tmpl.render() == "bar2 spaces\n spacefoo"
def test_choice_loader(self, choice_loader):
env = Environment(loader=choice_loader)
tmpl = env.get_template("justdict.html")
assert tmpl.render().strip() == "FOO"
tmpl = env.get_template("test.html")
assert tmpl.render().strip() == "BAR"
pytest.raises(TemplateNotFound, env.get_template, "missing.html")
def test_lstrip_blocks_false_with_no_lstrip(self, env):
# Test that + is a NOP (but does not cause an error) if lstrip_blocks=False
env = Environment(lstrip_blocks=False, trim_blocks=False)
tmpl = env.from_string(""" {% if True %}\n {% endif %}""")
assert tmpl.render() == " \n "
tmpl = env.from_string(""" {%+ if True %}\n {%+ endif %}""")
assert tmpl.render() == " \n "
def test_set_and_include(self):
env = Environment(loader=DictLoader(
{
"inc": "bar",
"main": '{% set foo = "foo" %}{{ foo }}{% include "inc" %}',
}))
assert env.get_template("main").render() == "foobar"
def test_basic_scope_behavior(self):
# This is what the old with statement compiled down to
class ScopeExt(Extension):
tags = set(["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"
def test_erb_syntax(self, env):
env = Environment("<%", "%>", "<%=", "%>", "<%#", "%>")
tmpl = env.from_string("""\
<%# I'm a comment, I'm not interesting %>\
<% for item in seq -%>
<%= item %>
<%- endfor %>""")
assert tmpl.render(seq=list(range(5))) == "01234"
def test_do(self):
env = Environment(extensions=["jinja.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_comment_syntax(self, env):
env = Environment("<!--", "-->", "${", "}", "<!--#", "-->")
tmpl = env.from_string("""\
<!--# I'm a comment, I'm not interesting -->\
<!-- for item in seq --->
${item}
<!--- endfor -->""")
assert tmpl.render(seq=list(range(5))) == "01234"
def test_loop_include(self):
env = Environment(loader=DictLoader({
"inc":
"{{ i }}",
"main":
'{% for i in [1, 2, 3] %}{% include "inc" %}{% endfor %}',
}))
assert env.get_template("main").render() == "123"
def test_urlize_rel_policy(self):
env = Environment()
env.policies["urlize.rel"] = None
tmpl = env.from_string(
'{{ "foo http://www.example.com/ bar"|urlize }}')
assert tmpl.render() == (
'foo <a href="http://www.example.com/">http://www.example.com/</a> bar'
)
def test_include(self, env_trim):
env_trim = Environment(
loader=DictLoader(
{"include": "{% macro test(foo) %}[{{ foo }}]{% endmacro %}"}
)
)
tmpl = env_trim.from_string('{% from "include" import test %}{{ test("foo") }}')
assert tmpl.render() == "[foo]"
def test_php_syntax(self, env):
env = Environment("<?", "?>", "<?=", "?>", "<!--", "-->")
tmpl = env.from_string("""\
<!-- I'm a comment, I'm not interesting -->\
<? for item in seq -?>
<?= item ?>
<?- endfor ?>""")
assert tmpl.render(seq=list(range(5))) == "01234"
