test/test_def.py - third_party/mako - Git at Google

 from mako.template import Template
 from mako import lookup
 from test import TemplateTest
 from test.util import flatten_result, result_lines
 from test import eq_, assert_raises, requires_python_3
 from mako import compat

 class DefTest(TemplateTest):
     def test_def_noargs(self):
         template = Template("""

         ${mycomp()}

         <%def name="mycomp()">
             hello mycomp ${variable}
         </%def>

         """)
         eq_(
             template.render(variable='hi').strip(),
             """hello mycomp hi"""
         )

     def test_def_blankargs(self):
         template = Template("""
         <%def name="mycomp()">
             hello mycomp ${variable}
         </%def>

         ${mycomp()}""")
         eq_(
             template.render(variable='hi').strip(),
             "hello mycomp hi"
         )

     def test_def_args(self):
         template = Template("""
         <%def name="mycomp(a, b)">
             hello mycomp ${variable}, ${a}, ${b}
         </%def>

         ${mycomp(5, 6)}""")
         eq_(
             template.render(variable='hi', a=5, b=6).strip(),
             """hello mycomp hi, 5, 6"""
         )

     @requires_python_3
     def test_def_py3k_args(self):
         template = Template("""
         <%def name="kwonly(one, two, *three, four, five=5, **six)">
             look at all these args: ${one} ${two} ${three[0]} ${four} ${five} ${six['seven']}
         </%def>

         ${kwonly('one', 'two', 'three', four='four', seven='seven')}""")
         eq_(
             template.render(one=1, two=2, three=(3,), six=6).strip(),
             """look at all these args: one two three four 5 seven"""
         )

     def test_inter_def(self):
         """test defs calling each other"""
         template = Template("""
         ${b()}

         <%def name="a()">\
         im a
         </%def>

         <%def name="b()">
         im b
         and heres a:  ${a()}
         </%def>

         <%def name="c()">
         im c
         </%def>
 """)
         # check that "a" is declared in "b", but not in "c"
         if compat.py3k:
             assert "a" not in template.module.render_c.__code__.co_varnames
             assert "a" in template.module.render_b.__code__.co_varnames
         else:
             assert "a" not in template.module.render_c.func_code.co_varnames
             assert "a" in template.module.render_b.func_code.co_varnames

         # then test output
         eq_(
             flatten_result(template.render()),
             "im b and heres a: im a"
         )

     def test_toplevel(self):
         """test calling a def from the top level"""

         template = Template("""

             this is the body

             <%def name="a()">
                 this is a
             </%def>

             <%def name="b(x, y)">
                 this is b, ${x} ${y}
             </%def>

         """)

         self._do_test(template.get_def("a"),
                     "this is a",
                     filters=flatten_result)
         self._do_test(template.get_def("b"),
                     "this is b, 10 15",
                     template_args={'x': 10, 'y': 15},
                     filters=flatten_result)
         self._do_test(template.get_def("body"),
                     "this is the body",
                     filters=flatten_result)

         # test that args outside of the dict can be used
         self._do_test(template.get_def("a"), "this is a",
                         filters=flatten_result,
                         template_args={'q': 5, 'zq': 'test'})

 class ScopeTest(TemplateTest):
     """test scoping rules.  The key is, enclosing
     scope always takes precedence over contextual scope."""

     def test_scope_one(self):
         self._do_memory_test("""
         <%def name="a()">
             this is a, and y is ${y}
         </%def>

         ${a()}

         <%
             y = 7
         %>

         ${a()}

 """,
             "this is a, and y is None this is a, and y is 7",
             filters=flatten_result,
             template_args={'y': None}
         )

     def test_scope_two(self):
         t = Template("""
         y is ${y}

         <%
             y = 7
         %>

         y is ${y}
 """)
         try:
             t.render(y=None)
             assert False
         except UnboundLocalError:
             assert True

     def test_scope_four(self):
         """test that variables are pulled
         from 'enclosing' scope before context."""
         t = Template("""
             <%
                 x = 5
             %>
             <%def name="a()">
                 this is a. x is ${x}.
             </%def>

             <%def name="b()">
                 <%
                     x = 9
                 %>
                 this is b. x is ${x}.
                 calling a. ${a()}
             </%def>

             ${b()}
 """)
         eq_(
             flatten_result(t.render()),
             "this is b. x is 9. calling a. this is a. x is 5."
         )

     def test_scope_five(self):
         """test that variables are pulled from
         'enclosing' scope before context."""
         # same as test four, but adds a scope around it.
         t = Template("""
             <%def name="enclosing()">
             <%
                 x = 5
             %>
             <%def name="a()">
                 this is a. x is ${x}.
             </%def>

             <%def name="b()">
                 <%
                     x = 9
                 %>
                 this is b. x is ${x}.
                 calling a. ${a()}
             </%def>

             ${b()}
             </%def>
             ${enclosing()}
 """)
         eq_(
             flatten_result(t.render()),
             "this is b. x is 9. calling a. this is a. x is 5."
         )

     def test_scope_six(self):
         """test that the initial context counts
         as 'enclosing' scope, for plain defs"""
         t = Template("""

         <%def name="a()">
             a: x is ${x}
         </%def>

         <%def name="b()">
             <%
                 x = 10
             %>
             b. x is ${x}.  ${a()}
         </%def>

         ${b()}
     """)
         eq_(
             flatten_result(t.render(x=5)),
             "b. x is 10. a: x is 5"
         )

     def test_scope_seven(self):
         """test that the initial context counts
         as 'enclosing' scope, for nested defs"""
         t = Template("""
         <%def name="enclosing()">
             <%def name="a()">
                 a: x is ${x}
             </%def>

             <%def name="b()">
                 <%
                     x = 10
                 %>
                 b. x is ${x}.  ${a()}
             </%def>

             ${b()}
         </%def>
         ${enclosing()}
     """)
         eq_(
             flatten_result(t.render(x=5)),
             "b. x is 10. a: x is 5"
         )

     def test_scope_eight(self):
         """test that the initial context counts
         as 'enclosing' scope, for nested defs"""
         t = Template("""
         <%def name="enclosing()">
             <%def name="a()">
                 a: x is ${x}
             </%def>

             <%def name="b()">
                 <%
                     x = 10
                 %>

                 b. x is ${x}.  ${a()}
             </%def>

             ${b()}
         </%def>
         ${enclosing()}
     """)
         eq_(
             flatten_result(t.render(x=5)),
             "b. x is 10. a: x is 5"
         )

     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_scope_ten(self):
         t = Template("""
             <%def name="a()">
                 <%def name="b()">
                     <%
                         y = 19
                     %>
                     b/c: ${c()}
                     b/y: ${y}
                 </%def>
                 <%def name="c()">
                     c/y: ${y}
                 </%def>

                 <%
                     # we assign to "y".  but the 'enclosing
                     # scope' of "b" and "c" is from
                     # the "y" on the outside
                     y = 10
                 %>
                 a/y: ${y}
                 a/b: ${b()}
             </%def>

             <%
                 y = 7
             %>
             main/a: ${a()}
             main/y: ${y}
     """)
         eq_(
             flatten_result(t.render()),
             "main/a: a/y: 10 a/b: b/c: c/y: 10 b/y: 19 main/y: 7"
         )

     def test_scope_eleven(self):
         t = Template("""
             x is ${x}
             <%def name="a(x)">
                 this is a, ${b()}
                 <%def name="b()">
                     this is b, x is ${x}
                 </%def>
             </%def>

             ${a(x=5)}
 """)
         eq_(
             result_lines(t.render(x=10)),
         [
             "x is 10",
             "this is a,",
             "this is b, x is 5"
         ])

     def test_unbound_scope(self):
         t = Template("""
             <%
                 y = 10
             %>
             <%def name="a()">
                 y is: ${y}
                 <%
                     # should raise error ?
                     y = 15
                 %>
                 y is ${y}
             </%def>
             ${a()}
 """)
         assert_raises(
             UnboundLocalError,
             t.render
             )

     def test_unbound_scope_two(self):
         t = Template("""
             <%def name="enclosing()">
             <%
                 y = 10
             %>
             <%def name="a()">
                 y is: ${y}
                 <%
                     # should raise error ?
                     y = 15
                 %>
                 y is ${y}
             </%def>
             ${a()}
             </%def>
             ${enclosing()}
 """)
         try:
             print(t.render())
             assert False
         except UnboundLocalError:
             assert True

     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_inline_expression_from_arg_one(self):
         """test that cache_key=${foo} gets its value from
         the 'foo' argument in the <%def> tag,
         and strict_undefined doesn't complain.

         this is #191.

         """
         t = Template("""
         <%def name="layout(foo)" cached="True" cache_key="${foo}">
         foo: ${foo}
         </%def>

         ${layout(3)}
         """, strict_undefined=True,
             cache_impl="plain")

         eq_(
             result_lines(t.render()),
             ["foo: 3"]
         )

     def test_interpret_expression_from_arg_two(self):
         """test that cache_key=${foo} gets its value from
         the 'foo' argument regardless of it being passed
         from the context.

         This is here testing that there's no change
         to existing behavior before and after #191.

         """
         t = Template("""
         <%def name="layout(foo)" cached="True" cache_key="${foo}">
         foo: ${value}
         </%def>

         ${layout(3)}
         """, cache_impl="plain")

         eq_(
             result_lines(t.render(foo='foo', value=1)),
             ["foo: 1"]
         )
         eq_(
             result_lines(t.render(foo='bar', value=2)),
             ["foo: 1"]
         )

 class NestedDefTest(TemplateTest):
     def test_nested_def(self):
         t = Template("""

         ${hi()}

         <%def name="hi()">
             hey, im hi.
             and heres ${foo()}, ${bar()}

             <%def name="foo()">
                 this is foo
             </%def>

             <%def name="bar()">
                 this is bar
             </%def>
         </%def>
 """)
         eq_(
             flatten_result(t.render()),
             "hey, im hi. and heres this is foo , this is bar"
         )

     def test_nested_2(self):
         t = Template("""
             x is ${x}
             <%def name="a()">
                 this is a, x is ${x}
                 ${b()}
                 <%def name="b()">
                     this is b: ${x}
                 </%def>
             </%def>
             ${a()}
 """)

         eq_(
             flatten_result(t.render(x=10)),
             "x is 10 this is a, x is 10 this is b: 10"
         )

     def test_nested_with_args(self):
         t = Template("""
         ${a()}
         <%def name="a()">
             <%def name="b(x, y=2)">
                 b x is ${x} y is ${y}
             </%def>
             a ${b(5)}
         </%def>
 """)
         eq_(
             flatten_result(t.render()),
             "a b x is 5 y is 2"
         )

     def test_nested_def_2(self):
         template = Template("""
         ${a()}
         <%def name="a()">
             <%def name="b()">
                 <%def name="c()">
                     comp c
                 </%def>
                 ${c()}
             </%def>
             ${b()}
         </%def>
 """)
         eq_(
             flatten_result(template.render()),
             "comp c"
         )

     def test_nested_nested_def(self):
         t = Template("""

         ${a()}
         <%def name="a()">
             a
             <%def name="b1()">
                 a_b1
             </%def>
             <%def name="b2()">
                 a_b2 ${c1()}
                 <%def name="c1()">
                     a_b2_c1
                 </%def>
             </%def>
             <%def name="b3()">
                 a_b3 ${c1()}
                 <%def name="c1()">
                     a_b3_c1 heres x: ${x}
                     <%
                         y = 7
                     %>
                     y is ${y}
                 </%def>
                 <%def name="c2()">
                     a_b3_c2
                     y is ${y}
                     c1 is ${c1()}
                 </%def>
                 ${c2()}
             </%def>

             ${b1()} ${b2()}  ${b3()}
         </%def>
 """)
         eq_(
             flatten_result(t.render(x=5, y=None)),
             "a a_b1 a_b2 a_b2_c1 a_b3 a_b3_c1 "
             "heres x: 5 y is 7 a_b3_c2 y is "
             "None c1 is a_b3_c1 heres x: 5 y is 7"
         )

     def test_nested_nested_def_2(self):
         t = Template("""
         <%def name="a()">
             this is a ${b()}
             <%def name="b()">
                 this is b
                 ${c()}
             </%def>

             <%def name="c()">
                 this is c
             </%def>
         </%def>
         ${a()}
 """)
         eq_(
             flatten_result(t.render()),
             "this is a this is b this is c"
         )

     def test_outer_scope(self):
         t = Template("""
         <%def name="a()">
             a: x is ${x}
         </%def>

         <%def name="b()">
             <%def name="c()">
             <%
                 x = 10
             %>
             c. x is ${x}.  ${a()}
             </%def>

             b. ${c()}
         </%def>

         ${b()}

         x is ${x}
 """)
         eq_(
             flatten_result(t.render(x=5)),
             "b. c. x is 10. a: x is 5 x is 5"
         )

 class ExceptionTest(TemplateTest):
     def test_raise(self):
         template = Template("""
             <%
                 raise Exception("this is a test")
             %>
     """, format_exceptions=False)
         assert_raises(
             Exception,
             template.render
             )

     def test_handler(self):
         def handle(context, error):
             context.write("error message is " + str(error))
             return True

         template = Template("""
             <%
                 raise Exception("this is a test")
             %>
     """, error_handler=handle)
         eq_(
             template.render().strip(),
             "error message is this is a test"
         )
	from mako.template import Template
	from mako import lookup
	from test import TemplateTest
	from test.util import flatten_result, result_lines
	from test import eq_, assert_raises, requires_python_3
	from mako import compat

	class DefTest(TemplateTest):
	def test_def_noargs(self):
	template = Template("""

	${mycomp()}

	<%def name="mycomp()">
	hello mycomp ${variable}
	</%def>

	""")
	eq_(
	template.render(variable='hi').strip(),
	"""hello mycomp hi"""
	)

	def test_def_blankargs(self):
	template = Template("""
	<%def name="mycomp()">
	hello mycomp ${variable}
	</%def>

	${mycomp()}""")
	eq_(
	template.render(variable='hi').strip(),
	"hello mycomp hi"
	)

	def test_def_args(self):
	template = Template("""
	<%def name="mycomp(a, b)">
	hello mycomp ${variable}, ${a}, ${b}
	</%def>

	${mycomp(5, 6)}""")
	eq_(
	template.render(variable='hi', a=5, b=6).strip(),
	"""hello mycomp hi, 5, 6"""
	)

	@requires_python_3
	def test_def_py3k_args(self):
	template = Template("""
	<%def name="kwonly(one, two, three, four, five=5, *six)">
	look at all these args: ${one} ${two} ${three[0]} ${four} ${five} ${six['seven']}
	</%def>

	${kwonly('one', 'two', 'three', four='four', seven='seven')}""")
	eq_(
	template.render(one=1, two=2, three=(3,), six=6).strip(),
	"""look at all these args: one two three four 5 seven"""
	)

	def test_inter_def(self):
	"""test defs calling each other"""
	template = Template("""
	${b()}

	<%def name="a()">\
	im a
	</%def>

	<%def name="b()">
	im b
	and heres a: ${a()}
	</%def>

	<%def name="c()">
	im c
	</%def>
	""")
	# check that "a" is declared in "b", but not in "c"
	if compat.py3k:
	assert "a" not in template.module.render_c.__code__.co_varnames
	assert "a" in template.module.render_b.__code__.co_varnames
	else:
	assert "a" not in template.module.render_c.func_code.co_varnames
	assert "a" in template.module.render_b.func_code.co_varnames

	# then test output
	eq_(
	flatten_result(template.render()),
	"im b and heres a: im a"
	)

	def test_toplevel(self):
	"""test calling a def from the top level"""

	template = Template("""

	this is the body

	<%def name="a()">
	this is a
	</%def>

	<%def name="b(x, y)">
	this is b, ${x} ${y}
	</%def>

	""")

	self._do_test(template.get_def("a"),
	"this is a",
	filters=flatten_result)
	self._do_test(template.get_def("b"),
	"this is b, 10 15",
	template_args={'x': 10, 'y': 15},
	filters=flatten_result)
	self._do_test(template.get_def("body"),
	"this is the body",
	filters=flatten_result)

	# test that args outside of the dict can be used
	self._do_test(template.get_def("a"), "this is a",
	filters=flatten_result,
	template_args={'q': 5, 'zq': 'test'})

	class ScopeTest(TemplateTest):
	"""test scoping rules. The key is, enclosing
	scope always takes precedence over contextual scope."""

	def test_scope_one(self):
	self._do_memory_test("""
	<%def name="a()">
	this is a, and y is ${y}
	</%def>

	${a()}

	<%
	y = 7
	%>

	${a()}

	""",
	"this is a, and y is None this is a, and y is 7",
	filters=flatten_result,
	template_args={'y': None}
	)

	def test_scope_two(self):
	t = Template("""
	y is ${y}

	<%
	y = 7
	%>

	y is ${y}
	""")
	try:
	t.render(y=None)
	assert False
	except UnboundLocalError:
	assert True

	def test_scope_four(self):
	"""test that variables are pulled
	from 'enclosing' scope before context."""
	t = Template("""
	<%
	x = 5
	%>
	<%def name="a()">
	this is a. x is ${x}.
	</%def>

	<%def name="b()">
	<%
	x = 9
	%>
	this is b. x is ${x}.
	calling a. ${a()}
	</%def>

	${b()}
	""")
	eq_(
	flatten_result(t.render()),
	"this is b. x is 9. calling a. this is a. x is 5."
	)

	def test_scope_five(self):
	"""test that variables are pulled from
	'enclosing' scope before context."""
	# same as test four, but adds a scope around it.
	t = Template("""
	<%def name="enclosing()">
	<%
	x = 5
	%>
	<%def name="a()">
	this is a. x is ${x}.
	</%def>

	<%def name="b()">
	<%
	x = 9
	%>
	this is b. x is ${x}.
	calling a. ${a()}
	</%def>

	${b()}
	</%def>
	${enclosing()}
	""")
	eq_(
	flatten_result(t.render()),
	"this is b. x is 9. calling a. this is a. x is 5."
	)

	def test_scope_six(self):
	"""test that the initial context counts
	as 'enclosing' scope, for plain defs"""
	t = Template("""

	<%def name="a()">
	a: x is ${x}
	</%def>

	<%def name="b()">
	<%
	x = 10
	%>
	b. x is ${x}. ${a()}
	</%def>

	${b()}
	""")
	eq_(
	flatten_result(t.render(x=5)),
	"b. x is 10. a: x is 5"
	)

	def test_scope_seven(self):
	"""test that the initial context counts
	as 'enclosing' scope, for nested defs"""
	t = Template("""
	<%def name="enclosing()">
	<%def name="a()">
	a: x is ${x}
	</%def>

	<%def name="b()">
	<%
	x = 10
	%>
	b. x is ${x}. ${a()}
	</%def>

	${b()}
	</%def>
	${enclosing()}
	""")
	eq_(
	flatten_result(t.render(x=5)),
	"b. x is 10. a: x is 5"
	)

	def test_scope_eight(self):
	"""test that the initial context counts
	as 'enclosing' scope, for nested defs"""
	t = Template("""
	<%def name="enclosing()">
	<%def name="a()">
	a: x is ${x}
	</%def>

	<%def name="b()">
	<%
	x = 10
	%>

	b. x is ${x}. ${a()}
	</%def>

	${b()}
	</%def>
	${enclosing()}
	""")
	eq_(
	flatten_result(t.render(x=5)),
	"b. x is 10. a: x is 5"
	)

	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_scope_ten(self):
	t = Template("""
	<%def name="a()">
	<%def name="b()">
	<%
	y = 19
	%>
	b/c: ${c()}
	b/y: ${y}
	</%def>
	<%def name="c()">
	c/y: ${y}
	</%def>

	<%
	# we assign to "y". but the 'enclosing
	# scope' of "b" and "c" is from
	# the "y" on the outside
	y = 10
	%>
	a/y: ${y}
	a/b: ${b()}
	</%def>

	<%
	y = 7
	%>
	main/a: ${a()}
	main/y: ${y}
	""")
	eq_(
	flatten_result(t.render()),
	"main/a: a/y: 10 a/b: b/c: c/y: 10 b/y: 19 main/y: 7"
	)

	def test_scope_eleven(self):
	t = Template("""
	x is ${x}
	<%def name="a(x)">
	this is a, ${b()}
	<%def name="b()">
	this is b, x is ${x}
	</%def>
	</%def>

	${a(x=5)}
	""")
	eq_(
	result_lines(t.render(x=10)),
	[
	"x is 10",
	"this is a,",
	"this is b, x is 5"
	])

	def test_unbound_scope(self):
	t = Template("""
	<%
	y = 10
	%>
	<%def name="a()">
	y is: ${y}
	<%
	# should raise error ?
	y = 15
	%>
	y is ${y}
	</%def>
	${a()}
	""")
	assert_raises(
	UnboundLocalError,
	t.render
	)

	def test_unbound_scope_two(self):
	t = Template("""
	<%def name="enclosing()">
	<%
	y = 10
	%>
	<%def name="a()">
	y is: ${y}
	<%
	# should raise error ?
	y = 15
	%>
	y is ${y}
	</%def>
	${a()}
	</%def>
	${enclosing()}
	""")
	try:
	print(t.render())
	assert False
	except UnboundLocalError:
	assert True

	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_inline_expression_from_arg_one(self):
	"""test that cache_key=${foo} gets its value from
	the 'foo' argument in the <%def> tag,
	and strict_undefined doesn't complain.

	this is #191.

	"""
	t = Template("""
	<%def name="layout(foo)" cached="True" cache_key="${foo}">
	foo: ${foo}
	</%def>

	${layout(3)}
	""", strict_undefined=True,
	cache_impl="plain")

	eq_(
	result_lines(t.render()),
	["foo: 3"]
	)

	def test_interpret_expression_from_arg_two(self):
	"""test that cache_key=${foo} gets its value from
	the 'foo' argument regardless of it being passed
	from the context.

	This is here testing that there's no change
	to existing behavior before and after #191.

	"""
	t = Template("""
	<%def name="layout(foo)" cached="True" cache_key="${foo}">
	foo: ${value}
	</%def>

	${layout(3)}
	""", cache_impl="plain")

	eq_(
	result_lines(t.render(foo='foo', value=1)),
	["foo: 1"]
	)
	eq_(
	result_lines(t.render(foo='bar', value=2)),
	["foo: 1"]
	)

	class NestedDefTest(TemplateTest):
	def test_nested_def(self):
	t = Template("""

	${hi()}

	<%def name="hi()">
	hey, im hi.
	and heres ${foo()}, ${bar()}

	<%def name="foo()">
	this is foo
	</%def>

	<%def name="bar()">
	this is bar
	</%def>
	</%def>
	""")
	eq_(
	flatten_result(t.render()),
	"hey, im hi. and heres this is foo , this is bar"
	)

	def test_nested_2(self):
	t = Template("""
	x is ${x}
	<%def name="a()">
	this is a, x is ${x}
	${b()}
	<%def name="b()">
	this is b: ${x}
	</%def>
	</%def>
	${a()}
	""")

	eq_(
	flatten_result(t.render(x=10)),
	"x is 10 this is a, x is 10 this is b: 10"
	)

	def test_nested_with_args(self):
	t = Template("""
	${a()}
	<%def name="a()">
	<%def name="b(x, y=2)">
	b x is ${x} y is ${y}
	</%def>
	a ${b(5)}
	</%def>
	""")
	eq_(
	flatten_result(t.render()),
	"a b x is 5 y is 2"
	)

	def test_nested_def_2(self):
	template = Template("""
	${a()}
	<%def name="a()">
	<%def name="b()">
	<%def name="c()">
	comp c
	</%def>
	${c()}
	</%def>
	${b()}
	</%def>
	""")
	eq_(
	flatten_result(template.render()),
	"comp c"
	)

	def test_nested_nested_def(self):
	t = Template("""

	${a()}
	<%def name="a()">
	a
	<%def name="b1()">
	a_b1
	</%def>
	<%def name="b2()">
	a_b2 ${c1()}
	<%def name="c1()">
	a_b2_c1
	</%def>
	</%def>
	<%def name="b3()">
	a_b3 ${c1()}
	<%def name="c1()">
	a_b3_c1 heres x: ${x}
	<%
	y = 7
	%>
	y is ${y}
	</%def>
	<%def name="c2()">
	a_b3_c2
	y is ${y}
	c1 is ${c1()}
	</%def>
	${c2()}
	</%def>

	${b1()} ${b2()} ${b3()}
	</%def>
	""")
	eq_(
	flatten_result(t.render(x=5, y=None)),
	"a a_b1 a_b2 a_b2_c1 a_b3 a_b3_c1 "
	"heres x: 5 y is 7 a_b3_c2 y is "
	"None c1 is a_b3_c1 heres x: 5 y is 7"
	)

	def test_nested_nested_def_2(self):
	t = Template("""
	<%def name="a()">
	this is a ${b()}
	<%def name="b()">
	this is b
	${c()}
	</%def>

	<%def name="c()">
	this is c
	</%def>
	</%def>
	${a()}
	""")
	eq_(
	flatten_result(t.render()),
	"this is a this is b this is c"
	)

	def test_outer_scope(self):
	t = Template("""
	<%def name="a()">
	a: x is ${x}
	</%def>

	<%def name="b()">
	<%def name="c()">
	<%
	x = 10
	%>
	c. x is ${x}. ${a()}
	</%def>

	b. ${c()}
	</%def>

	${b()}

	x is ${x}
	""")
	eq_(
	flatten_result(t.render(x=5)),
	"b. c. x is 10. a: x is 5 x is 5"
	)

	class ExceptionTest(TemplateTest):
	def test_raise(self):
	template = Template("""
	<%
	raise Exception("this is a test")
	%>
	""", format_exceptions=False)
	assert_raises(
	Exception,
	template.render
	)

	def test_handler(self):
	def handle(context, error):
	context.write("error message is " + str(error))
	return True

	template = Template("""
	<%
	raise Exception("this is a test")
	%>
	""", error_handler=handle)
	eq_(
	template.render().strip(),
	"error message is this is a test"
	)