def test_strict(self):
t = Template(
"""
% if x is UNDEFINED:
undefined
% else:
x: ${x}
% endif
""",
strict_undefined=True,
)
assert result_lines(t.render(x=12)) == ["x: 12"]
assert_raises(NameError, t.render, y=12)
l = TemplateLookup(strict_undefined=True)
l.put_string("a", "some template")
l.put_string(
"b",
"""
<%namespace name='a' file='a' import='*'/>
% if x is UNDEFINED:
undefined
% else:
x: ${x}
% endif
""",
)
assert result_lines(t.render(x=12)) == ["x: 12"]
assert_raises(NameError, t.render, y=12)
def test_dynamic_key_with_funcargs(self):
t = Template("""
<%def name="foo(num=5)" cached="True" cache_key="foo_${str(num)}">
hi
</%def>
${foo()}
""")
m = self._install_mock_cache(t)
t.render()
t.render()
assert result_lines(t.render()) == ["hi"]
assert m.key == "foo_5"
t = Template("""
<%def name="foo(*args, **kwargs)" cached="True"
cache_key="foo_${kwargs['bar']}">
hi
</%def>
${foo(1, 2, bar='lala')}
""")
m = self._install_mock_cache(t)
t.render()
assert result_lines(t.render()) == ["hi"]
assert m.key == "foo_lala"
t = Template("""
<%page args="bar='hi'" cache_key="foo_${bar}" cached="True"/>
hi
""")
m = self._install_mock_cache(t)
t.render()
assert result_lines(t.render()) == ["hi"]
assert m.key == "foo_hi"
def test_dynamic(self):
collection = lookup.TemplateLookup()
collection.put_string(
"base",
"""
this is the base.
${next.body()}
""",
)
collection.put_string(
"index",
"""
<%!
def dyn(context):
if context.get('base', None) is not None:
return 'base'
else:
return None
%>
<%inherit file="${dyn(context)}"/>
this is index.
""",
)
assert result_lines(
collection.get_template("index").render()) == ["this is index."]
assert result_lines(
collection.get_template("index").render(base=True)) == [
"this is the base.", "this is index."
]
def test_undefined(self):
t = Template("""
% if x is UNDEFINED:
undefined
% else:
x: ${x}
% endif
""")
assert result_lines(t.render(x=12)) == ["x: 12"]
assert result_lines(t.render(y=12)) == ["undefined"]
def test_invalidate(self):
t = Template("""
<%%def name="foo()" cached="True">
foo: ${x}
</%%def>
<%%def name="bar()" cached="True" cache_type='dbm' cache_dir='%s'>
bar: ${x}
</%%def>
${foo()} ${bar()}
""" % module_base)
self._install_mock_cache(t)
assert result_lines(t.render(x=1)) == ["foo: 1", "bar: 1"]
assert result_lines(t.render(x=2)) == ["foo: 1", "bar: 1"]
t.cache.invalidate_def("foo")
assert result_lines(t.render(x=3)) == ["foo: 3", "bar: 1"]
t.cache.invalidate_def("bar")
assert result_lines(t.render(x=4)) == ["foo: 3", "bar: 4"]
t = Template("""
<%%page cached="True" cache_type="dbm" cache_dir="%s"/>
page: ${x}
""" % module_base)
self._install_mock_cache(t)
assert result_lines(t.render(x=1)) == ["page: 1"]
assert result_lines(t.render(x=2)) == ["page: 1"]
t.cache.invalidate_body()
assert result_lines(t.render(x=3)) == ["page: 3"]
assert result_lines(t.render(x=4)) == ["page: 3"]
def test_lookup(self):
l = TemplateLookup(cache_impl="mock")
l.put_string(
"x",
"""
<%page cached="True" />
${y}
""",
)
t = l.get_template("x")
self._install_mock_cache(t)
assert result_lines(t.render(y=5)) == ["5"]
assert result_lines(t.render(y=7)) == ["5"]
assert isinstance(t.cache.impl, MockCacheImpl)
def test_module_roundtrip(self):
lookup = TemplateLookup()
template = Template(
"""
<%inherit file="base.html"/>
% for x in range(5):
${x}
% endfor
""",
lookup=lookup,
)
base = Template(
"""
This is base.
${self.body()}
""",
lookup=lookup,
)
lookup.put_template("base.html", base)
lookup.put_template("template.html", template)
assert result_lines(template.render()) == [
"This is base.",
"0",
"1",
"2",
"3",
"4",
]
lookup = TemplateLookup()
template = ModuleTemplate(template.module, lookup=lookup)
base = ModuleTemplate(base.module, lookup=lookup)
lookup.put_template("base.html", base)
lookup.put_template("template.html", template)
assert result_lines(template.render()) == [
"This is base.",
"0",
"1",
"2",
"3",
"4",
]
def test_nested_call(self):
"""test %calls that are nested inside each other"""
t = Template(
"""
<%def name="foo()">
${caller.body(x=10)}
</%def>
x is ${x}
<%def name="bar()">
bar: ${caller.body()}
</%def>
<%call expr="foo()" args="x">
this is foo body: ${x}
<%call expr="bar()">
this is bar body: ${x}
</%call>
</%call>
"""
)
assert result_lines(t.render(x=5)) == [
"x is 5",
"this is foo body: 10",
"bar:",
"this is bar body: 10",
]
def test_chained_call(self):
"""test %calls that are chained through their targets"""
t = Template(
"""
<%def name="a()">
this is a.
<%call expr="b()">
this is a's ccall. heres my body: ${caller.body()}
</%call>
</%def>
<%def name="b()">
this is b. heres my body: ${caller.body()}
whats in the body's caller's body ?
${context.caller_stack[-2].body()}
</%def>
<%call expr="a()">
heres the main templ call
</%call>
"""
)
assert result_lines(t.render()) == [
"this is a.",
"this is b. heres my body:",
"this is a's ccall. heres my body:",
"heres the main templ call",
"whats in the body's caller's body ?",
"heres the main templ call",
]
def test_stack_pop(self):
t = Template(
"""
<%def name="links()" buffered="True">
Some links
</%def>
<%def name="wrapper(links)">
<h1>${caller.body()}</h1>
${links}
</%def>
## links() pushes a stack frame on. when complete,
## 'nextcaller' must be restored
<%call expr="wrapper(links())">
Some title
</%call>
"""
)
assert result_lines(t.render()) == [
"<h1>",
"Some title",
"</h1>",
"Some links",
]
def test_fileargs_pagetag(self):
t = Template("""
<%%page cache_dir='%s' cache_type='dbm'/>
<%%!
callcount = [0]
%%>
<%%def name="foo()" cached="True">
this is foo
<%%
callcount[0] += 1
%%>
</%%def>
${foo()}
${foo()}
${foo()}
callcount: ${callcount}
""" % module_base)
m = self._install_mock_cache(t)
assert result_lines(t.render()) == [
"this is foo",
"this is foo",
"this is foo",
"callcount: [1]",
]
eq_(m.kwargs, {"dir": module_base, "type": "dbm"})
def test_new_syntax(self):
"""test foo:bar syntax, including multiline args and expression
eval."""
# note the trailing whitespace in the bottom ${} expr, need to strip
# that off < python 2.7
t = Template(
"""
<%def name="foo(x, y, q, z)">
${x}
${y}
${q}
${",".join("%s->%s" % (a, b) for a, b in z)}
</%def>
<%self:foo x="this is x" y="${'some ' + 'y'}" q="
this
is
q"
z="${[
(1, 2),
(3, 4),
(5, 6)
]
}"/>
"""
)
eq_(
result_lines(t.render()),
["this is x", "some y", "this", "is", "q", "1->2,3->4,5->6"],
)
def test_chained_call_in_nested(self):
t = Template(
"""
<%def name="embedded()">
<%def name="a()">
this is a.
<%call expr="b()">
this is a's ccall. heres my body: ${caller.body()}
</%call>
</%def>
<%def name="b()">
this is b. heres my body: ${caller.body()}
whats in the body's caller's body ? """
"""${context.caller_stack[-2].body()}
</%def>
<%call expr="a()">
heres the main templ call
</%call>
</%def>
${embedded()}
"""
)
# print t.code
# print result_lines(t.render())
assert result_lines(t.render()) == [
"this is a.",
"this is b. heres my body:",
"this is a's ccall. heres my body:",
"heres the main templ call",
"whats in the body's caller's body ?",
"heres the main templ call",
]
def test_inheritance(self):
"""test namespace initialization in a base inherited template that
doesnt otherwise access the namespace"""
collection = lookup.TemplateLookup()
collection.put_string(
"base.html",
"""
<%namespace name="foo" file="ns.html" inheritable="True"/>
${next.body()}
""",
)
collection.put_string(
"ns.html",
"""
<%def name="bar()">
this is ns.html->bar
</%def>
""",
)
collection.put_string(
"index.html",
"""
<%inherit file="base.html"/>
this is index
${self.foo.bar()}
""",
)
assert result_lines(
collection.get_template("index.html").render()) == [
"this is index", "this is ns.html->bar"
]
def test_in_def(self):
collection = lookup.TemplateLookup()
collection.put_string(
"main.html",
"""
<%namespace name="foo" file="ns.html"/>
this is main. ${bar()}
<%def name="bar()">
this is bar, foo is ${foo.bar()}
</%def>
""",
)
collection.put_string(
"ns.html",
"""
<%def name="bar()">
this is ns.html->bar
</%def>
""",
)
assert result_lines(collection.get_template("main.html").render()) == [
"this is main.",
"this is bar, foo is",
"this is ns.html->bar",
]
def test_def(self):
t = Template("""
<%!
callcount = [0]
%>
<%def name="foo()" cached="True">
this is foo
<%
callcount[0] += 1
%>
</%def>
${foo()}
${foo()}
${foo()}
callcount: ${callcount}
""")
m = self._install_mock_cache(t)
assert result_lines(t.render()) == [
"this is foo",
"this is foo",
"this is foo",
"callcount: [1]",
]
assert m.kwargs == {}
def test_fileargs_lookup(self):
l = lookup.TemplateLookup(cache_dir=module_base, cache_type="file")
l.put_string(
"test",
"""
<%!
callcount = [0]
%>
<%def name="foo()" cached="True">
this is foo
<%
callcount[0] += 1
%>
</%def>
${foo()}
${foo()}
${foo()}
callcount: ${callcount}
""",
)
t = l.get_template("test")
m = self._install_mock_cache(t)
assert result_lines(l.get_template("test").render()) == [
"this is foo",
"this is foo",
"this is foo",
"callcount: [1]",
]
eq_(m.kwargs, {"dir": module_base, "type": "file"})
def test_compound_call(self):
t = Template(
"""
<%def name="bar()">
this is bar
</%def>
<%def name="comp1()">
this comp1 should not be called
</%def>
<%def name="foo()">
foo calling comp1: ${caller.comp1(x=5)}
foo calling body: ${caller.body()}
</%def>
<%call expr="foo()">
<%def name="comp1(x)">
this is comp1, ${x}
</%def>
this is the body, ${comp1(6)}
</%call>
${bar()}
"""
)
assert result_lines(t.render()) == [
"foo calling comp1:",
"this is comp1, 5",
"foo calling body:",
"this is the body,",
"this is comp1, 6",
"this is bar",
]
def test_control(self):
t = Template("""
## this is a template.
% for x in y:
% if 'test' in x:
yes x has test
% else:
no x does not have test
%endif
%endfor
""")
assert result_lines(
t.render(y=[
{
"test": "one"
},
{
"foo": "bar"
},
{
"foo": "bar",
"test": "two"
},
])) == [
"yes x has test", "no x does not have test", "yes x has test"
]
def test_nested_call_2(self):
t = Template(
"""
x is ${x}
<%def name="foo()">
${caller.foosub(x=10)}
</%def>
<%def name="bar()">
bar: ${caller.barsub()}
</%def>
<%call expr="foo()">
<%def name="foosub(x)">
this is foo body: ${x}
<%call expr="bar()">
<%def name="barsub()">
this is bar body: ${x}
</%def>
</%call>
</%def>
</%call>
"""
)
assert result_lines(t.render(x=5)) == [
"x is 5",
"this is foo body: 10",
"bar:",
"this is bar body: 10",
]
def test_fileargs_implicit(self):
l = lookup.TemplateLookup(module_directory=module_base)
l.put_string(
"test",
"""
<%!
callcount = [0]
%>
<%def name="foo()" cached="True" cache_type='dbm'>
this is foo
<%
callcount[0] += 1
%>
</%def>
${foo()}
${foo()}
${foo()}
callcount: ${callcount}
""",
)
m = self._install_mock_cache(l.get_template("test"))
assert result_lines(l.get_template("test").render()) == [
"this is foo",
"this is foo",
"this is foo",
"callcount: [1]",
]
eq_(m.kwargs, {"type": "dbm"})
def test_basic(self):
t = Template(
"""
<%!
cached = None
%>
<%def name="foo()">
<%
global cached
if cached:
return "cached: " + cached
__M_writer = context._push_writer()
%>
this is foo
<%
buf, __M_writer = context._pop_buffer_and_writer()
cached = buf.getvalue()
return cached
%>
</%def>
${foo()}
${foo()}
"""
)
assert result_lines(t.render()) == [
"this is foo",
"cached:",
"this is foo",
]
def test_pageargs(self):
collection = lookup.TemplateLookup()
collection.put_string(
"base",
"""
this is the base.
<%
sorted_ = pageargs.items()
sorted_ = sorted(sorted_)
%>
pageargs: (type: ${type(pageargs)}) ${sorted_}
<%def name="foo()">
${next.body(**context.kwargs)}
</%def>
${foo()}
""",
)
collection.put_string(
"index",
"""
<%inherit file="base"/>
<%page args="x, y, z=7"/>
print ${x}, ${y}, ${z}
""",
)
assert result_lines(
collection.get_template("index").render_unicode(x=5, y=10)) == [
"this is the base.",
"pageargs: (type: <class 'dict'>) [('x', 5), ('y', 10)]",
"print 5, 10, 7",
]
def test_ccall_caller(self):
t = Template(
"""
<%def name="outer_func()">
OUTER BEGIN
<%call expr="caller.inner_func()">
INNER CALL
</%call>
OUTER END
</%def>
<%call expr="outer_func()">
<%def name="inner_func()">
INNER BEGIN
${caller.body()}
INNER END
</%def>
</%call>
"""
)
# print t.code
assert result_lines(t.render()) == [
"OUTER BEGIN",
"INNER BEGIN",
"INNER CALL",
"INNER END",
"OUTER END",
]
def test_dynamic_key_with_imports(self):
lookup = TemplateLookup()
lookup.put_string(
"foo.html",
"""
<%!
callcount = [0]
%>
<%namespace file="ns.html" import="*"/>
<%page cached="True" cache_key="${foo}"/>
this is foo
<%
callcount[0] += 1
%>
callcount: ${callcount}
""",
)
lookup.put_string("ns.html", """""")
t = lookup.get_template("foo.html")
m = self._install_mock_cache(t)
t.render(foo="somekey")
t.render(foo="somekey")
assert result_lines(t.render(foo="somekey")) == [
"this is foo",
"callcount: [1]",
]
assert m.kwargs == {}
def test_closure_import(self):
collection = lookup.TemplateLookup()
collection.put_string(
"functions.html",
"""
<%def name="foo()">
this is foo
</%def>
<%def name="bar()">
this is bar
</%def>
""",
)
collection.put_string(
"index.html",
"""
<%namespace file="functions.html" import="*"/>
<%def name="cl1()">
${foo()}
</%def>
<%def name="cl2()">
${bar()}
</%def>
${cl1()}
${cl2()}
""",
)
assert result_lines(
collection.get_template("index.html").render(
bar="this is bar",
x="this is x")) == ["this is foo", "this is bar"]
def test_fileargs_deftag(self):
t = Template("""
<%%!
callcount = [0]
%%>
<%%def name="foo()" cached="True" cache_type='file' cache_dir='%s'>
this is foo
<%%
callcount[0] += 1
%%>
</%%def>
${foo()}
${foo()}
${foo()}
callcount: ${callcount}
""" % module_base)
m = self._install_mock_cache(t)
assert result_lines(t.render()) == [
"this is foo",
"this is foo",
"this is foo",
"callcount: [1]",
]
assert m.kwargs == {"type": "file", "dir": module_base}
def test_canget_kwargs(self):
"""test that arguments passed to the body()
function are accessible by top-level defs"""
l = lookup.TemplateLookup()
l.put_string(
"base",
"""
${next.body(x=12)}
""",
)
l.put_string(
"main",
"""
<%inherit file="base"/>
<%page args="x"/>
this is main. x is ${x}
${a()}
<%def name="a(**args)">
this is a, x is ${x}
</%def>
""",
)
# test via inheritance
eq_(
result_lines(l.get_template("main").render()),
["this is main. x is 12", "this is a, x is 12"],
)
l.put_string(
"another",
"""
<%namespace name="ns" file="main"/>
${ns.body(x=15)}
""",
)
# test via namespace
eq_(
result_lines(l.get_template("another").render()),
["this is main. x is 15", "this is a, x is 15"],
)
def test_attr(self):
l = lookup.TemplateLookup()
l.put_string(
"foo.html",
"""
<%!
foofoo = "foo foo"
onlyfoo = "only foo"
%>
<%inherit file="base.html"/>
<%def name="setup()">
<%
self.attr.foolala = "foo lala"
%>
</%def>
${self.attr.basefoo}
${self.attr.foofoo}
${self.attr.onlyfoo}
${self.attr.lala}
${self.attr.foolala}
""",
)
l.put_string(
"base.html",
"""
<%!
basefoo = "base foo 1"
foofoo = "base foo 2"
%>
<%
self.attr.lala = "base lala"
%>
${self.attr.basefoo}
${self.attr.foofoo}
${self.attr.onlyfoo}
${self.attr.lala}
${self.setup()}
${self.attr.foolala}
body
${self.body()}
""",
)
assert result_lines(l.get_template("foo.html").render()) == [
"base foo 1",
"foo foo",
"only foo",
"base lala",
"foo lala",
"body",
"base foo 1",
"foo foo",
"only foo",
"base lala",
"foo lala",
]
def test_subdir(self):
t = tl.get_template("/subdir/index.html")
assert result_lines(t.render()) == [
"this is sub index",
"this is include 2",
]
assert (tl.get_template("/subdir/index.html").module_id ==
"_subdir_index_html")
