Newer
Older
from mako.template import Template
import unittest
import re
class ComponentTest(unittest.TestCase):
def test_component_noargs(self):
template = Template("""
${mycomp()}
<%component name="mycomp">
hello mycomp ${variable}
</%component>
""")
print template.code
assert template.render(variable='hi').strip() == """hello mycomp hi"""
def test_component_blankargs(self):
template = Template("""
<%component name="mycomp()">
hello mycomp ${variable}
</%component>
${mycomp()}""")
#print template.code
assert template.render(variable='hi').strip() == """hello mycomp hi"""
def test_component_args(self):
template = Template("""
<%component name="mycomp(a, b)">
hello mycomp ${variable}, ${a}, ${b}
</%component>
${mycomp(5, 6)}""")
#print template.code
assert template.render(variable='hi', a=5, b=6).strip() == """hello mycomp hi, 5, 6"""
def test_outer_scope(self):
t = Template("""
<%component name="a">
a: x is ${x}
</%component>
<%component name="b">
<%
x = 10
%>
b. x is ${x}. ${a()}
</%component>
${b()}
""")
#print t.code
print t.render(x=5)
def test_inter_component(self):
"""test components calling each other"""
template = Template("""
${b()}
<%component name="a">\
im a
</%component>
<%component name="b">
im b
and heres a: ${a()}
</%component>
<%component name="c">
im c
</%component>
""")
#print template.code
# check that "a" is declared in "b", but not in "c"
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
assert template.render().strip() == "im b\nand heres a: im a"
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
def test_local_names(self):
template = """
<%component name="a">
this is a, and y is ${y}
</%component>
${a()}
<%
y = 7
%>
${a()}
"""
t = Template(template)
print t.code
result = t.render()
result = re.sub(r'[\s\n]+', ' ', result).strip()
assert result == "this is a, and y is None this is a, and y is 7"
def test_local_names_2(self):
template = """
y is ${y}
<%
y = 7
%>
y is ${y}
"""
t = Template(template)
result = t.render()
result = re.sub(r'[\s\n]+', ' ', result).strip()
assert result == "y is None y is 7"
def test_local_names_3(self):
"""test in place assignment/undeclared variable combinations
i.e. things like 'x=x+1', x is declared and undeclared at the same time"""
template = Template("""
hi
<%component name="a">
y is ${y}
<%
x = x + y
a = 3
%>
x is ${x}
</%component>
${a()}
""")
result = template.render(x=5, y=10)
result = re.sub(r'[\s\n]+', ' ', result).strip()
assert result == "hi y is 10 x is 15"
class NestedComponentTest(unittest.TestCase):
def test_nested_component(self):
template = """
${hi()}
<%component name="hi">
hey, im hi.
and heres ${foo()}, ${bar()}
<%component name="foo">
this is foo
</%component>
<%component name="bar">
this is bar
</%component>
</%component>
"""
t = Template(template)
print t.code
result = t.render()
result = re.sub(r'[\s\n]+', ' ', result).strip()
assert result == "hey, im hi. and heres this is foo , this is bar"
def test_nested_with_args(self):
template = Template("""
${a()}
<%component name="a">
<%component name="b(x, y=2)">
b x is ${x} y is ${y}
</%component>
a ${b(5)}
</%component>
""")
#print template.code
result = template.render()
#print result
result = re.sub(r'[\s\n]+', ' ', result).strip()
assert result == "a b x is 5 y is 2"
def test_nested_component_2(self):
template = Template("""
${a()}
<%component name="a">
<%component name="b">
<%component name="c">
comp c
</%component>
${c()}
</%component>
${b()}
</%component>
""")
print template.code
def test_nested_nested_component(self):
template = """
${a()}
<%component name="a">
a_b1
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
</%component>
<%component name="b2">
a_b2 ${c1()}
<%component name="c1">
a_b2_c1
</%component>
</%component>
<%component name="b3">
a_b3 ${c1()}
<%component name="c1">
a_b3_c1 heres x: ${x}
<%
y = 7
%>
y is ${y}
</%component>
<%component name="c2">
a_b3_c2
y is ${y}
c1 is ${c1()}
</%component>
${c2()}
</%component>
${b1()} ${b2()} ${b3()}
</%component>
"""
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
t = Template(template, format_exceptions=False)
print t.code
result = t.render(x=5)
result = re.sub(r'[\s\n]+', ' ', result).strip()
#print result
assert result == "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_component_2(self):
template = """
<%component name="a">
this is a ${b()}
<%component name="b">
this is b
${c()}
</%component>
<%component name="c">
this is c
</%component>
</%component>
${a()}
"""
t = Template(template)
print t.code
def test_local_local_names(self):
"""test assignment of variables inside nested components, which requires extra scoping logic"""
template = """
heres y: ${y}
<%component name="a">
<%component name="b">
b, heres y: ${y}
<%
y = 19
%>
b, heres c: ${c()}
b, heres y again: ${y}
</%component>
a, heres y: ${y}
<%
y = 10
x = 12
%>
a, now heres y: ${y}
a, heres b: ${b()}
<%component name="c">
this is c
</%component>
</%component>
<%
y = 7
%>
now heres y ${y}
${a()}
heres y again: ${y}
"""
t = Template(template, format_exceptions=False)
print t.code
result = t.render(y=5)
result = re.sub(r'[\s\n]+', ' ', result).strip()
Mike Bayer
committed
assert result == "heres y: 5 now heres y 7 a, heres y: 7 a, now heres y: 10 a, heres b: b, heres y: 10 b, heres c: this is c b, heres y again: 19 heres y again: 7"
def test_outer_scope(self):
t = Template("""
<%component name="a">
a: x is ${x}
</%component>
<%component name="b">
<%component name="c">
<%
x = 10
%>
c. x is ${x}. ${a()}
</%component>
b. ${c()}
</%component>
${b()}
""")
print t.code
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
class ExceptionTest(unittest.TestCase):
def test_raise(self):
template = Template("""
<%
raise Exception("this is a test")
%>
""", format_exceptions=False)
try:
template.render()
assert False
except Exception, e:
assert str(e) == "this is a test"
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)
assert template.render().strip() == """error message is this is a test"""
if __name__ == '__main__':
unittest.main()