| from mako.template import Template | |
| from mako.testing.assertions import eq_ | |
| from mako.testing.fixtures import TemplateTest | |
| from mako.testing.helpers import flatten_result | |
| from mako.testing.helpers import result_lines | |
| class CallTest(TemplateTest): | |
| def test_call(self): | |
| t = Template( | |
| """ | |
| <%def name="foo()"> | |
| hi im foo ${caller.body(y=5)} | |
| </%def> | |
| <%call expr="foo()" args="y, **kwargs"> | |
| this is the body, y is ${y} | |
| </%call> | |
| """ | |
| ) | |
| assert result_lines(t.render()) == [ | |
| "hi im foo", | |
| "this is the body, y is 5", | |
| ] | |
| 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_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_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_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_conditional_call(self): | |
| """test that 'caller' is non-None only if the immediate <%def> was | |
| called via <%call>""" | |
| t = Template( | |
| """ | |
| <%def name="a()"> | |
| % if caller: | |
| ${ caller.body() } \\ | |
| % endif | |
| AAA | |
| ${ b() } | |
| </%def> | |
| <%def name="b()"> | |
| % if caller: | |
| ${ caller.body() } \\ | |
| % endif | |
| BBB | |
| ${ c() } | |
| </%def> | |
| <%def name="c()"> | |
| % if caller: | |
| ${ caller.body() } \\ | |
| % endif | |
| CCC | |
| </%def> | |
| <%call expr="a()"> | |
| CALL | |
| </%call> | |
| """ | |
| ) | |
| assert result_lines(t.render()) == ["CALL", "AAA", "BBB", "CCC"] | |
| 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_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_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_nested_call_3(self): | |
| template = Template( | |
| """\ | |
| <%def name="A()"> | |
| ${caller.body()} | |
| </%def> | |
| <%def name="B()"> | |
| ${caller.foo()} | |
| </%def> | |
| <%call expr="A()"> | |
| <%call expr="B()"> | |
| <%def name="foo()"> | |
| foo | |
| </%def> | |
| </%call> | |
| </%call> | |
| """ | |
| ) | |
| assert flatten_result(template.render()) == "foo" | |
| def test_nested_call_4(self): | |
| base = """ | |
| <%def name="A()"> | |
| A_def | |
| ${caller.body()} | |
| </%def> | |
| <%def name="B()"> | |
| B_def | |
| ${caller.body()} | |
| </%def> | |
| """ | |
| template = Template( | |
| base | |
| + """ | |
| <%def name="C()"> | |
| C_def | |
| <%self:B> | |
| <%self:A> | |
| A_body | |
| </%self:A> | |
| B_body | |
| ${caller.body()} | |
| </%self:B> | |
| </%def> | |
| <%self:C> | |
| C_body | |
| </%self:C> | |
| """ | |
| ) | |
| eq_( | |
| flatten_result(template.render()), | |
| "C_def B_def A_def A_body B_body C_body", | |
| ) | |
| template = Template( | |
| base | |
| + """ | |
| <%def name="C()"> | |
| C_def | |
| <%self:B> | |
| B_body | |
| ${caller.body()} | |
| <%self:A> | |
| A_body | |
| </%self:A> | |
| </%self:B> | |
| </%def> | |
| <%self:C> | |
| C_body | |
| </%self:C> | |
| """ | |
| ) | |
| eq_( | |
| flatten_result(template.render()), | |
| "C_def B_def B_body C_body A_def A_body", | |
| ) | |
| 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_call_in_nested(self): | |
| t = Template( | |
| """ | |
| <%def name="a()"> | |
| this is a ${b()} | |
| <%def name="b()"> | |
| this is b | |
| <%call expr="c()"> | |
| this is the body in b's call | |
| </%call> | |
| </%def> | |
| <%def name="c()"> | |
| this is c: ${caller.body()} | |
| </%def> | |
| </%def> | |
| ${a()} | |
| """ | |
| ) | |
| assert result_lines(t.render()) == [ | |
| "this is a", | |
| "this is b", | |
| "this is c:", | |
| "this is the body in b's call", | |
| ] | |
| def test_composed_def(self): | |
| t = Template( | |
| """ | |
| <%def name="f()"><f>${caller.body()}</f></%def> | |
| <%def name="g()"><g>${caller.body()}</g></%def> | |
| <%def name="fg()"> | |
| <%self:f><%self:g>${caller.body()}</%self:g></%self:f> | |
| </%def> | |
| <%self:fg>fgbody</%self:fg> | |
| """ | |
| ) | |
| assert result_lines(t.render()) == ["<f><g>fgbody</g></f>"] | |
| def test_regular_defs(self): | |
| t = Template( | |
| """ | |
| <%! | |
| @runtime.supports_caller | |
| def a(context): | |
| context.write("this is a") | |
| if context['caller']: | |
| context['caller'].body() | |
| context.write("a is done") | |
| return '' | |
| %> | |
| <%def name="b()"> | |
| this is b | |
| our body: ${caller.body()} | |
| ${a(context)} | |
| </%def> | |
| test 1 | |
| <%call expr="a(context)"> | |
| this is the body | |
| </%call> | |
| test 2 | |
| <%call expr="b()"> | |
| this is the body | |
| </%call> | |
| test 3 | |
| <%call expr="b()"> | |
| this is the body | |
| <%call expr="b()"> | |
| this is the nested body | |
| </%call> | |
| </%call> | |
| """ | |
| ) | |
| assert result_lines(t.render()) == [ | |
| "test 1", | |
| "this is a", | |
| "this is the body", | |
| "a is done", | |
| "test 2", | |
| "this is b", | |
| "our body:", | |
| "this is the body", | |
| "this is aa is done", | |
| "test 3", | |
| "this is b", | |
| "our body:", | |
| "this is the body", | |
| "this is b", | |
| "our body:", | |
| "this is the nested body", | |
| "this is aa is done", | |
| "this is aa is done", | |
| ] | |
| def test_call_in_nested_2(self): | |
| t = Template( | |
| """ | |
| <%def name="a()"> | |
| <%def name="d()"> | |
| not this d | |
| </%def> | |
| this is a ${b()} | |
| <%def name="b()"> | |
| <%def name="d()"> | |
| not this d either | |
| </%def> | |
| this is b | |
| <%call expr="c()"> | |
| <%def name="d()"> | |
| this is d | |
| </%def> | |
| this is the body in b's call | |
| </%call> | |
| </%def> | |
| <%def name="c()"> | |
| this is c: ${caller.body()} | |
| the embedded "d" is: ${caller.d()} | |
| </%def> | |
| </%def> | |
| ${a()} | |
| """ | |
| ) | |
| assert result_lines(t.render()) == [ | |
| "this is a", | |
| "this is b", | |
| "this is c:", | |
| "this is the body in b's call", | |
| 'the embedded "d" is:', | |
| "this is d", | |
| ] | |
| class SelfCacheTest(TemplateTest): | |
| """this test uses a now non-public API.""" | |
| 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", | |
| ] |