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_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_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_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_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 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_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} """) if compat.py3k: 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" ] else: assert result_lines(collection.get_template('index').render_unicode(x=5,y=10)) == [ "this is the base.", "pageargs: (type: <type '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]', ] eq_(m.kwargs, {'dir': module_base, 'type': 'file'})
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_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_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_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_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_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_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_multilevel_nesting(self): collection = lookup.TemplateLookup() collection.put_string('main', """ <%inherit file="layout"/> <%def name="d()">main_d</%def> main_body ${parent.d()} full stack from the top: ${self.name} ${parent.name} ${parent.context['parent'].name} ${parent.context['parent'].context['parent'].name} """) collection.put_string('layout', """ <%inherit file="general"/> <%def name="d()">layout_d</%def> layout_body parent name: ${parent.name} ${parent.d()} ${parent.context['parent'].d()} ${next.body()} """) collection.put_string('general', """ <%inherit file="base"/> <%def name="d()">general_d</%def> general_body ${next.d()} ${next.context['next'].d()} ${next.body()} """) collection.put_string('base', """ base_body full stack from the base: ${self.name} ${self.context['parent'].name} ${self.context['parent'].context['parent'].name} ${self.context['parent'].context['parent'].context['parent'].name} ${next.body()} <%def name="d()">base_d</%def> """) assert result_lines(collection.get_template('main').render()) == [ 'base_body', 'full stack from the base:', 'self:main self:layout self:general self:base', 'general_body', 'layout_d', 'main_d', 'layout_body', 'parent name: self:general', 'general_d', 'base_d', 'main_body layout_d', 'full stack from the top:', 'self:main self:layout self:general self:base' ]
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"
def test_module(self): collection = lookup.TemplateLookup() collection.put_string( 'main.html', """ <%namespace name="comp" module="test.sample_module_namespace"/> this is main. ${comp.foo1()} ${comp.foo2("hi")} """) assert flatten_result(collection.get_template('main.html').render( )) == "this is main. this is foo1. this is foo2, x is hi"
def test_namespaces(self): """test that templates used via <%namespace> have access to an inheriting 'self', and that the full 'self' is also exported.""" collection = lookup.TemplateLookup() collection.put_string( "base", """ <%def name="a()">base_a</%def> <%def name="b()">base_b</%def> This is the base. ${next.body()} """) collection.put_string( "layout", """ <%inherit file="base"/> <%def name="a()">layout_a</%def> This is the layout.. ${next.body()} """) collection.put_string( "index", """ <%inherit file="base"/> <%namespace name="sc" file="secondary"/> this is index. a is: ${self.a()} sc.a is: ${sc.a()} sc.b is: ${sc.b()} sc.c is: ${sc.c()} sc.body is: ${sc.body()} """) collection.put_string( "secondary", """ <%inherit file="layout"/> <%def name="c()">secondary_c. a is ${self.a()} b is ${self.b()} d is ${self.d()}</%def> <%def name="d()">secondary_d.</%def> this is secondary. a is: ${self.a()} c is: ${self.c()} """) assert result_lines(collection.get_template('index').render()) == [ 'This is the base.', 'this is index.', 'a is: base_a', 'sc.a is: layout_a', 'sc.b is: base_b', 'sc.c is: secondary_c. a is layout_a b is base_b d is secondary_d.', 'sc.body is:', 'this is secondary.', 'a is: layout_a', 'c is: secondary_c. a is layout_a b is base_b d is secondary_d.' ]
def test_pageargs_err(self): collection = lookup.TemplateLookup() collection.put_string("base", """ this is the base. ${next.body()} """) collection.put_string("index", """ <%inherit file="base"/> <%page args="x, y, z=7"/> print ${x}, ${y}, ${z} """) try: print(collection.get_template('index').render(x=5,y=10)) assert False except TypeError: assert True
def test_dynamic(self): collection = lookup.TemplateLookup() collection.put_string( 'a', """ <%namespace name="b" file="${context['b_def']}"/> a. b: ${b.body()} """) collection.put_string('b', """ b. """) eq_(flatten_result(collection.get_template('a').render(b_def='b')), "a. b: b.")
def test_attr_raise(self): l = lookup.TemplateLookup() l.put_string( "foo.html", """ <%def name="foo()"> </%def> """) l.put_string( "bar.html", """ <%namespace name="foo" file="foo.html"/> ${foo.notfoo()} """) self.assertRaises(AttributeError, l.get_template("bar.html").render)
def test_toplevel(self): collection = lookup.TemplateLookup() collection.put_string("base", """ this is the base. ${next.body()} """) collection.put_string("index", """ <%inherit file="base"/> this is the body """) assert result_lines(collection.get_template('index').render()) == [ "this is the base.", "this is the body" ] assert result_lines(collection.get_template('index').get_def("body").render()) == [ "this is the body" ]
def test_getattr(self): collection = lookup.TemplateLookup() collection.put_string( "main.html", """ <%namespace name="foo" file="ns.html"/> <% if hasattr(foo, 'lala'): foo.lala() if not hasattr(foo, 'hoho'): context.write('foo has no hoho.') %> """) collection.put_string( "ns.html", """ <%def name="lala()">this is lala.</%def> """) assert flatten_result(collection.get_template( "main.html").render()) == "this is lala.foo has no hoho."
def test_dont_pollute_self(self): # test that get_namespace() doesn't modify the original context # incompatibly collection = lookup.TemplateLookup() collection.put_string( "base.html", """ <%def name="foo()"> <% foo = local.get_namespace("foo.html") %> </%def> name: ${self.name} name via bar: ${bar()} ${next.body()} name: ${self.name} name via bar: ${bar()} <%def name="bar()"> ${self.name} </%def> """) collection.put_string( "page.html", """ <%inherit file="base.html"/> ${self.foo()} hello world """) collection.put_string("foo.html", """<%inherit file="base.html"/>""") assert result_lines(collection.get_template("page.html").render()) == [ "name: self:page.html", "name via bar:", "self:page.html", "hello world", "name: self:page.html", "name via bar:", "self:page.html" ]
def test_import(self): collection = lookup.TemplateLookup() collection.put_string( "functions.html", """ <%def name="foo()"> this is foo </%def> <%def name="bar()"> this is bar </%def> <%def name="lala()"> this is lala </%def> """) collection.put_string( "func2.html", """ <%def name="a()"> this is a </%def> <%def name="b()"> this is b </%def> """) collection.put_string( "index.html", """ <%namespace file="functions.html" import="*"/> <%namespace file="func2.html" import="a, b"/> ${foo()} ${bar()} ${lala()} ${a()} ${b()} ${x} """) assert result_lines( collection.get_template("index.html").render( bar="this is bar", x="this is x")) == [ "this is foo", "this is bar", "this is lala", "this is a", "this is b", "this is x" ]
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_in_call(self): collection = lookup.TemplateLookup() collection.put_string( "/layout.html", """ Super layout! <%call expr="self.grid()"> ${next.body()} </%call> Oh yea! <%def name="grid()"> Parent grid ${caller.body()} End Parent </%def> """) collection.put_string( "/subdir/layout.html", """ ${next.body()} <%def name="grid()"> Subdir grid ${caller.body()} End subdir </%def> <%inherit file="/layout.html"/> """) collection.put_string( "/subdir/renderedtemplate.html", """ Holy smokes! <%inherit file="/subdir/layout.html"/> """) #print collection.get_template("/layout.html").code #print collection.get_template("/subdir/renderedtemplate.html").render() assert result_lines( collection.get_template( "/subdir/renderedtemplate.html").render()) == [ "Super layout!", "Subdir grid", "Holy smokes!", "End subdir", "Oh yea!" ]
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' ]