def test_uri_adjust(self):
tl = lookup.TemplateLookup(directories=["/foo/bar"])
assert (tl.filename_to_uri("/foo/bar/etc/lala/index.html") ==
"/etc/lala/index.html")
tl = lookup.TemplateLookup(directories=["./foo/bar"])
assert (tl.filename_to_uri("./foo/bar/etc/index.html") ==
"/etc/index.html")
def test_uri_adjust(self):
tl = lookup.TemplateLookup(directories=['/foo/bar'])
assert tl.filename_to_uri('/foo/bar/etc/lala/index.html') == \
'/etc/lala/index.html'
tl = lookup.TemplateLookup(directories=['./foo/bar'])
assert tl.filename_to_uri('./foo/bar/etc/index.html') == \
'/etc/index.html'
def test_custom_tag_2(self):
collection = lookup.TemplateLookup()
collection.put_string("base.html", """
<%def name="foo(x, y)">
foo: ${x} ${y}
</%def>
<%def name="bat(g)"><%
return "the bat! %s" % g
%></%def>
<%def name="bar(x)">
${caller.body(z=x)}
</%def>
""")
collection.put_string("index.html", """
<%namespace name="myns" file="base.html"/>
<%myns:foo x="${'some x'}" y="some y"/>
<%myns:bar x="${myns.bat(10)}" args="z">
record: ${z}
</%myns:bar>
""")
assert result_lines(collection.get_template("index.html").render()) == [
'foo: some x some y',
'record: the bat! 10'
]
def test_inheritance_two(self):
collection = lookup.TemplateLookup()
collection.put_string("base.html", """
<%def name="foo()">
base.foo
</%def>
<%def name="bat()">
base.bat
</%def>
""")
collection.put_string("lib.html", """
<%inherit file="base.html"/>
<%def name="bar()">
lib.bar
${parent.foo()}
${self.foo()}
${parent.bat()}
${self.bat()}
</%def>
<%def name="foo()">
lib.foo
</%def>
""")
collection.put_string("front.html", """
<%namespace name="lib" file="lib.html"/>
${lib.bar()}
""")
assert result_lines(collection.get_template("front.html").render()) == ['lib.bar', 'base.foo', 'lib.foo', 'base.bat', 'base.bat']
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_includes(self):
"""test that an included template also has its full hierarchy invoked."""
collection = lookup.TemplateLookup()
collection.put_string(
"base", """
<%def name="a()">base_a</%def>
This is the base.
${next.body()}
End base.
""")
collection.put_string(
"index", """
<%inherit file="base"/>
this is index.
a is: ${self.a()}
<%include file="secondary"/>
""")
collection.put_string(
"secondary", """
<%inherit file="base"/>
this is secondary.
a is: ${self.a()}
""")
assert result_lines(collection.get_template("index").render()) == [
'This is the base.', 'this is index.', 'a is: base_a',
'This is the base.', 'this is secondary.', 'a is: base_a',
'End base.', 'End base.'
]
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 __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.look_up = lookup.TemplateLookup([self.get_template_path()],
input_encoding='utf-8',
output_encoding='utf-8')
self.con = None
self.time1 = time.time()
def test_ccall_import(self):
collection = lookup.TemplateLookup()
collection.put_string("functions.html","""
<%def name="foo()">
this is foo
</%def>
<%def name="bar()">
this is bar.
${caller.body()}
${caller.lala()}
</%def>
""")
collection.put_string("index.html", """
<%namespace name="func" file="functions.html" import="*"/>
<%call expr="bar()">
this is index embedded
foo is ${foo()}
<%def name="lala()">
this is lala ${foo()}
</%def>
</%call>
""")
#print collection.get_template("index.html").code
#print collection.get_template("functions.html").code
assert result_lines(collection.get_template("index.html").render()) == [
"this is bar.",
"this is index embedded",
"foo is",
"this is foo",
"this is lala",
"this is foo"
]
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_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_nonexistent_namespace_uri(self):
collection = lookup.TemplateLookup()
collection.put_string(
"main.html",
"""
<%namespace name="defs" file="eefs.html"/>
this is main. ${defs.def1("hi")}
${defs.def2("there")}
""",
)
collection.put_string(
"defs.html",
"""
<%def name="def1(s)">
def1: ${s}
</%def>
<%def name="def2(x)">
def2: ${x}
</%def>
""",
)
assert_raises_message_with_given_cause(
exceptions.TemplateLookupException,
"Can't locate template for uri 'eefs.html",
exceptions.TopLevelLookupException,
collection.get_template("main.html").render,
)
def test_import_calledfromdef(self):
l = lookup.TemplateLookup()
l.put_string(
"a",
"""
<%def name="table()">
im table
</%def>
""",
)
l.put_string(
"b",
"""
<%namespace file="a" import="table"/>
<%
def table2():
table()
return ""
%>
${table2()}
""",
)
t = l.get_template("b")
assert flatten_result(t.render()) == "im table"
def test_context(self):
"""test that namespace callables get access to the current context"""
collection = lookup.TemplateLookup()
collection.put_string(
"main.html",
"""
<%namespace name="comp" file="defs.html"/>
this is main. ${comp.def1()}
${comp.def2("there")}
""",
)
collection.put_string(
"defs.html",
"""
<%def name="def1()">
def1: x is ${x}
</%def>
<%def name="def2(x)">
def2: x is ${x}
</%def>
""",
)
assert (flatten_result(
collection.get_template("main.html").render(x="context x")) ==
"this is main. def1: x is context x def2: x is there")
def test_template(self):
collection = lookup.TemplateLookup()
collection.put_string(
"main.html",
"""
<%namespace name="comp" file="defs.html"/>
this is main. ${comp.def1("hi")}
${comp.def2("there")}
""",
)
collection.put_string(
"defs.html",
"""
<%def name="def1(s)">
def1: ${s}
</%def>
<%def name="def2(x)">
def2: ${x}
</%def>
""",
)
assert (flatten_result(collection.get_template("main.html").render())
== "this is main. def1: hi def2: there")
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_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_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]',
]
assert m.kwargs == {'data_dir': module_base, 'type': 'file'}
def test_overload(self):
collection = lookup.TemplateLookup()
collection.put_string('main.html', """
<%namespace name="comp" file="defs.html">
<%def name="def1(x, y)">
overridden def1 ${x}, ${y}
</%def>
</%namespace>
this is main. ${comp.def1("hi", "there")}
${comp.def2("there")}
""")
collection.put_string('defs.html', """
<%def name="def1(s)">
def1: ${s}
</%def>
<%def name="def2(x)">
def2: ${x}
</%def>
""")
assert flatten_result(collection.get_template('main.html').render()) == "this is main. overridden def1 hi, there def2: there"
def test_pageargs_2(self):
collection = lookup.TemplateLookup()
collection.put_string(
"base", """
this is the base.
${next.body(**context.kwargs)}
<%def name="foo(**kwargs)">
${next.body(**kwargs)}
</%def>
<%def name="bar(**otherargs)">
${next.body(z=16, **context.kwargs)}
</%def>
${foo(x=12, y=15, z=8)}
${bar(x=19, y=17)}
""")
collection.put_string(
"index", """
<%inherit file="base"/>
<%page args="x, y, z=7"/>
pageargs: ${x}, ${y}, ${z}
""")
assert result_lines(
collection.get_template('index').render(x=5, y=10)) == [
"this is the base.", "pageargs: 5, 10, 7",
"pageargs: 12, 15, 8", "pageargs: 5, 10, 16"
]
def test_in_remote_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>
""")
collection.put_string("index.html", """
<%namespace name="main" file="main.html"/>
this is index
${main.bar()}
""")
assert result_lines(collection.get_template("index.html").render()) == [
"this is index",
"this is bar, foo is" ,
"this is ns.html->bar"
]
def test_basic(self):
collection = lookup.TemplateLookup()
collection.put_string(
'main', """
<%inherit file="base"/>
<%def name="header()">
main header.
</%def>
this is the content.
""")
collection.put_string(
'base', """
This is base.
header: ${self.header()}
body: ${self.body()}
footer: ${self.footer()}
<%def name="footer()">
this is the footer. header again ${next.header()}
</%def>
""")
assert result_lines(collection.get_template('main').render()) == [
'This is base.', 'header:', 'main header.', 'body:',
'this is the content.', 'footer:',
'this is the footer. header again', 'main header.'
]
def test_ccall(self):
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
caller body: ${caller.body()}
</%def>
""")
collection.put_string("index.html", """
<%inherit file="base.html"/>
this is index
<%call expr="self.foo.bar()">
call body
</%call>
""")
assert result_lines(collection.get_template("index.html").render()) == [
"this is index",
"this is ns.html->bar",
"caller body:",
"call body"
]
def _load_templates(self, config):
""" load templates
@dict: configuration of ldapcherry
"""
# definition of the template directory
self.template_dir = self._get_param('resources', 'templates.dir',
config)
cherrypy.log.error(msg="loading templates from dir '%(dir)s'" %
{'dir': self.template_dir},
severity=logging.DEBUG)
# preload templates
self.temp_lookup = lookup.TemplateLookup(
directories=self.template_dir,
input_encoding='utf-8',
default_filters=['unicode', 'h'])
# load each template
self.temp = {}
for t in (
'index.tmpl',
'error.tmpl',
'login.tmpl',
'404.tmpl',
'searchadmin.tmpl',
'searchuser.tmpl',
'adduser.tmpl',
'roles.tmpl',
'groups.tmpl',
'form.tmpl',
'selfmodify.tmpl',
'modify.tmpl',
'service_unavailable.tmpl',
'reset_password_req.tmpl',
'reset_password_set.tmpl',
):
self.temp[t] = self.temp_lookup.get_template(t)
def test_scope_nine(self):
"""test that 'enclosing scope' doesnt
get exported to other templates"""
l = lookup.TemplateLookup()
l.put_string(
"main",
"""
<%
x = 5
%>
this is main. <%include file="secondary"/>
""",
)
l.put_string(
"secondary",
"""
this is secondary. x is ${x}
""",
)
eq_(
flatten_result(l.get_template("main").render(x=2)),
"this is main. this is secondary. x is 2",
)
def test_dont_accept_relative_outside_of_root(self):
"""test the mechanics of an include where
the include goes outside of the path"""
tl = lookup.TemplateLookup(
directories=[os.path.join(config.template_base, "subdir")])
index = tl.get_template("index.html")
ctx = runtime.Context(FastEncodingBuffer())
ctx._with_template = index
assert_raises_message(
exceptions.TemplateLookupException,
'Template uri "../index.html" is invalid - it '
"cannot be relative outside of the root path",
runtime._lookup_template,
ctx,
"../index.html",
index.uri,
)
assert_raises_message(
exceptions.TemplateLookupException,
'Template uri "../othersubdir/foo.html" is invalid - it '
"cannot be relative outside of the root path",
runtime._lookup_template,
ctx,
"../othersubdir/foo.html",
index.uri,
)
# this is OK since the .. cancels out
runtime._lookup_template(ctx, "foo/../index.html", index.uri)
def tpl_txt_gen_iter(tpl_path,
count=None,
environ=None,
func_factory_map=None):
if environ is None:
environ = TplTxtGenEnviron()
environ.tpl_path = tpl_path
environ.count = count
environ.root_dir = os.path.dirname(environ.tpl_path)
environ.tpl_name = os.path.basename(environ.tpl_path)
environ.tpl_lookup = mako_lookup.TemplateLookup(
directories=(environ.root_dir, ))
environ.tpl = environ.tpl_lookup.get_template(environ.tpl_name)
if func_factory_map is None:
func_factory_map = DEFAULT_FUNC_FACTORY_MAP
func_factories = {
func_name: func_factory_map[func_name](weakref.ref(environ))
for func_name in func_factory_map
}
for i in count_iter(environ.count):
tpl_kwargs = {
func_name: func_factories[func_name]()
for func_name in func_factories
}
yield environ.tpl.render(**tpl_kwargs)
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_check_not_found(self):
tl = lookup.TemplateLookup()
tl.put_string("foo", "this is a template")
f = tl.get_template("foo")
assert f.uri in tl._collection
f.filename = "nonexistent"
self.assertRaises(exceptions.TemplateLookupException, tl.get_template,
"foo")
assert f.uri not in tl._collection
def test_module_imports_2(self):
collection = lookup.TemplateLookup()
collection.put_string('main.html', """
<%namespace import="foo1, foo2" module="test.foo.test_ns"/>
this is main. ${foo1()}
${foo2("hi")}
""")
assert flatten_result(collection.get_template('main.html').render()) == "this is main. this is foo1. this is foo2, x is hi"
