def test_recursive_loop_compile(self, env):
Template("""
{% for p in foo recursive%}
{{p.bar}}
{% for f in p.fields recursive%}
{{f.baz}}
{{p.bar}}
{% if f.rec %}
{{ loop(f.sub) }}
{% endif %}
{% endfor %}
{% endfor %}
""")
Template("""
{% for p in foo%}
{{p.bar}}
{% for f in p.fields recursive%}
{{f.baz}}
{{p.bar}}
{% if f.rec %}
{{ loop(f.sub) }}
{% endif %}
{% endfor %}
{% endfor %}
""")
def test_call_with_args(self, env):
t = Template("""{% macro dump_users(users) -%}
<ul>
{%- for user in users -%}
<li><p>{{ user.username|e }}</p>{{ caller(user) }}</li>
{%- endfor -%}
</ul>
{%- endmacro -%}
{% call(user) dump_users(list_of_user) -%}
<dl>
<dl>Realname</dl>
<dd>{{ user.realname|e }}</dd>
<dl>Description</dl>
<dd>{{ user.description }}</dd>
</dl>
{% endcall %}""")
assert [
x.strip() for x in t.render(list_of_user=[{
"username": "******",
"realname": "something else",
"description": "test",
}]).splitlines()
] == [
u"<ul><li><p>apo</p><dl>",
u"<dl>Realname</dl>",
u"<dd>something else</dd>",
u"<dl>Description</dl>",
u"<dd>test</dd>",
u"</dl>",
u"</li></ul>",
]
def test_iterator_not_advanced_early():
t = Template("{% for _, g in gs %}{{ loop.index }} {{ g|list }}\n{% endfor %}")
out = t.render(
gs=itertools.groupby([(1, "a"), (1, "b"), (2, "c"), (3, "d")], lambda x: x[0])
)
# groupby groups depend on the current position of the iterator. If
# it was advanced early, the lists would appear empty.
assert out == "1 [(1, 'a'), (1, 'b')]\n2 [(2, 'c')]\n3 [(3, 'd')]\n"
def test_generator_stop():
class X(object):
def __getattr__(self, name):
raise StopIteration()
t = Template("a{{ bad.bar() }}b")
with pytest.raises(RuntimeError):
t.render(bad=X())
def test_else_loop_bug(self, env):
t = Template("""
{% for x in y %}
{{ loop.index0 }}
{% else %}
{% for i in range(3) %}{{ i }}{% endfor %}
{% endfor %}
""")
assert t.render(y=[]).strip() == "012"
def test_stacked_locals_scoping_bug_twoframe(self, env):
t = Template("""
{% set x = 1 %}
{% for item in foo %}
{% if item == 1 %}
{% set x = 2 %}
{% endif %}
{% endfor %}
{{ x }}
""")
rv = t.render(foo=[1]).strip()
assert rv == u"1"
def test_contextfunction_callable_classes(self, env):
from jinja.utils import contextfunction
class CallableClass(object):
@contextfunction
def __call__(self, ctx):
return ctx.resolve("hello")
tpl = Template("""{{ callableclass() }}""")
output = tpl.render(callableclass=CallableClass(), hello="TEST")
expected = "TEST"
assert output == expected
def parse_vars(yamlin):
# save the initial object
if 'global_yaml' not in globals():
global global_yaml
global_yaml = yamlin
# recursively go through the object
if isinstance(yamlin, list):
yamlout = []
for sub in yamlin:
yamlout.append(parse_vars(sub))
elif isinstance(yamlin, dict):
yamlout = {}
for sub in yamlin:
yamlout[sub] = parse_vars(yamlin[sub])
# treat each string as jinja template
elif isinstance(yamlin, str):
yamlout = Template(yamlin).render(global_yaml)
# be sure nothing gets lost
else:
yamlout = yamlin
return yamlout
def test_loop_idx0():
t = Template(TEST_IDX0_TEMPLATE_STR_1)
lst = [10]
excepted_render = "[(len=1, revindex0=0, index0=0, val=10)]"
assert excepted_render == t.render(lst=lst)
def assert_error(code, expected):
with pytest.raises(TemplateSyntaxError, match=expected):
Template(code)