python27/guestbook/jinja2/testsuite/regression.py

   1 # -*- coding: utf-8 -*-
   2 """
   3     jinja2.testsuite.regression
   4     ~~~~~~~~~~~~~~~~~~~~~~~~~~~
   5
   6     Tests corner cases and bugs.
   7
   8     :copyright: (c) 2010 by the Jinja Team.
   9     :license: BSD, see LICENSE for more details.
  10 """
  11 import unittest
  12
  13 from jinja2.testsuite import JinjaTestCase
  14
  15 from jinja2 import Template, Environment, DictLoader, TemplateSyntaxError, \
  16      TemplateNotFound, PrefixLoader
  17
  18 env = Environment()
  19
  20
  21 class CornerTestCase(JinjaTestCase):
  22
  23     def test_assigned_scoping(self):
  24         t = env.from_string('''
  25         {%- for item in (1, 2, 3, 4) -%}
  26             [{{ item }}]
  27         {%- endfor %}
  28         {{- item -}}
  29         ''')
  30         assert t.render(item=42) == '[1][2][3][4]42'
  31
  32         t = env.from_string('''
  33         {%- for item in (1, 2, 3, 4) -%}
  34             [{{ item }}]
  35         {%- endfor %}
  36         {%- set item = 42 %}
  37         {{- item -}}
  38         ''')
  39         assert t.render() == '[1][2][3][4]42'
  40
  41         t = env.from_string('''
  42         {%- set item = 42 %}
  43         {%- for item in (1, 2, 3, 4) -%}
  44             [{{ item }}]
  45         {%- endfor %}
  46         {{- item -}}
  47         ''')
  48         assert t.render() == '[1][2][3][4]42'
  49
  50     def test_closure_scoping(self):
  51         t = env.from_string('''
  52         {%- set wrapper = "<FOO>" %}
  53         {%- for item in (1, 2, 3, 4) %}
  54             {%- macro wrapper() %}[{{ item }}]{% endmacro %}
  55             {{- wrapper() }}
  56         {%- endfor %}
  57         {{- wrapper -}}
  58         ''')
  59         assert t.render() == '[1][2][3][4]<FOO>'
  60
  61         t = env.from_string('''
  62         {%- for item in (1, 2, 3, 4) %}
  63             {%- macro wrapper() %}[{{ item }}]{% endmacro %}
  64             {{- wrapper() }}
  65         {%- endfor %}
  66         {%- set wrapper = "<FOO>" %}
  67         {{- wrapper -}}
  68         ''')
  69         assert t.render() == '[1][2][3][4]<FOO>'
  70
  71         t = env.from_string('''
  72         {%- for item in (1, 2, 3, 4) %}
  73             {%- macro wrapper() %}[{{ item }}]{% endmacro %}
  74             {{- wrapper() }}
  75         {%- endfor %}
  76         {{- wrapper -}}
  77         ''')
  78         assert t.render(wrapper=23) == '[1][2][3][4]23'
  79
  80
  81 class BugTestCase(JinjaTestCase):
  82
  83     def test_keyword_folding(self):
  84         env = Environment()
  85         env.filters['testing'] = lambda value, some: value + some
  86         assert env.from_string("{{ 'test'|testing(some='stuff') }}") \
  87                .render() == 'teststuff'
  88
  89     def test_extends_output_bugs(self):
  90         env = Environment(loader=DictLoader({
  91             'parent.html': '(({% block title %}{% endblock %}))'
  92         }))
  93
  94         t = env.from_string('{% if expr %}{% extends "parent.html" %}{% endif %}'
  95                             '[[{% block title %}title{% endblock %}]]'
  96                             '{% for item in [1, 2, 3] %}({{ item }}){% endfor %}')
  97         assert t.render(expr=False) == '[[title]](1)(2)(3)'
  98         assert t.render(expr=True) == '((title))'
  99
 100     def test_urlize_filter_escaping(self):
 101         tmpl = env.from_string('{{ "http://www.example.org/<foo"|urlize }}')
 102         assert tmpl.render() == '<a href="http://www.example.org/&lt;foo">http://www.example.org/&lt;foo</a>'
 103
 104     def test_loop_call_loop(self):
 105         tmpl = env.from_string('''
 106
 107         {% macro test() %}
 108             {{ caller() }}
 109         {% endmacro %}
 110
 111         {% for num1 in range(5) %}
 112             {% call test() %}
 113                 {% for num2 in range(10) %}
 114                     {{ loop.index }}
 115                 {% endfor %}
 116             {% endcall %}
 117         {% endfor %}
 118
 119         ''')
 120
 121         assert tmpl.render().split() == map(unicode, range(1, 11)) * 5
 122
 123     def test_weird_inline_comment(self):
 124         env = Environment(line_statement_prefix='%')
 125         self.assert_raises(TemplateSyntaxError, env.from_string,
 126                            '% for item in seq {# missing #}\n...% endfor')
 127
 128     def test_old_macro_loop_scoping_bug(self):
 129         tmpl = env.from_string('{% for i in (1, 2) %}{{ i }}{% endfor %}'
 130                                '{% macro i() %}3{% endmacro %}{{ i() }}')
 131         assert tmpl.render() == '123'
 132
 133     def test_partial_conditional_assignments(self):
 134         tmpl = env.from_string('{% if b %}{% set a = 42 %}{% endif %}{{ a }}')
 135         assert tmpl.render(a=23) == '23'
 136         assert tmpl.render(b=True) == '42'
 137
 138     def test_stacked_locals_scoping_bug(self):
 139         env = Environment(line_statement_prefix='#')
 140         t = env.from_string('''\
 141 # for j in [1, 2]:
 142 #   set x = 1
 143 #   for i in [1, 2]:
 144 #     print x
 145 #     if i % 2 == 0:
 146 #       set x = x + 1
 147 #     endif
 148 #   endfor
 149 # endfor
 150 # if a
 151 #   print 'A'
 152 # elif b
 153 #   print 'B'
 154 # elif c == d
 155 #   print 'C'
 156 # else
 157 #   print 'D'
 158 # endif
 159     ''')
 160         assert t.render(a=0, b=False, c=42, d=42.0) == '1111C'
 161
 162     def test_stacked_locals_scoping_bug_twoframe(self):
 163         t = Template('''
 164             {% set x = 1 %}
 165             {% for item in foo %}
 166                 {% if item == 1 %}
 167                     {% set x = 2 %}
 168                 {% endif %}
 169             {% endfor %}
 170             {{ x }}
 171         ''')
 172         rv = t.render(foo=[1]).strip()
 173         assert rv == u'1'
 174
 175     def test_call_with_args(self):
 176         t = Template("""{% macro dump_users(users) -%}
 177         <ul>
 178           {%- for user in users -%}
 179             <li><p>{{ user.username|e }}</p>{{ caller(user) }}</li>
 180           {%- endfor -%}
 181           </ul>
 182         {%- endmacro -%}
 183
 184         {% call(user) dump_users(list_of_user) -%}
 185           <dl>
 186             <dl>Realname</dl>
 187             <dd>{{ user.realname|e }}</dd>
 188             <dl>Description</dl>
 189             <dd>{{ user.description }}</dd>
 190           </dl>
 191         {% endcall %}""")
 192
 193         assert [x.strip() for x in t.render(list_of_user=[{
 194             'username':'apo',
 195             'realname':'something else',
 196             'description':'test'
 197         }]).splitlines()] == [
 198             u'<ul><li><p>apo</p><dl>',
 199             u'<dl>Realname</dl>',
 200             u'<dd>something else</dd>',
 201             u'<dl>Description</dl>',
 202             u'<dd>test</dd>',
 203             u'</dl>',
 204             u'</li></ul>'
 205         ]
 206
 207     def test_empty_if_condition_fails(self):
 208         self.assert_raises(TemplateSyntaxError, Template, '{% if %}....{% endif %}')
 209         self.assert_raises(TemplateSyntaxError, Template, '{% if foo %}...{% elif %}...{% endif %}')
 210         self.assert_raises(TemplateSyntaxError, Template, '{% for x in %}..{% endfor %}')
 211
 212     def test_recursive_loop_bug(self):
 213         tpl1 = Template("""
 214         {% for p in foo recursive%}
 215             {{p.bar}}
 216             {% for f in p.fields recursive%}
 217                 {{f.baz}}
 218                 {{p.bar}}
 219                 {% if f.rec %}
 220                     {{ loop(f.sub) }}
 221                 {% endif %}
 222             {% endfor %}
 223         {% endfor %}
 224         """)
 225
 226         tpl2 = Template("""
 227         {% for p in foo%}
 228             {{p.bar}}
 229             {% for f in p.fields recursive%}
 230                 {{f.baz}}
 231                 {{p.bar}}
 232                 {% if f.rec %}
 233                     {{ loop(f.sub) }}
 234                 {% endif %}
 235             {% endfor %}
 236         {% endfor %}
 237         """)
 238
 239     def test_correct_prefix_loader_name(self):
 240         env = Environment(loader=PrefixLoader({
 241             'foo':  DictLoader({})
 242         }))
 243         try:
 244             env.get_template('foo/bar.html')
 245         except TemplateNotFound, e:
 246             assert e.name == 'foo/bar.html'
 247         else:
 248             assert False, 'expected error here'
 249
 250
 251 def suite():
 252     suite = unittest.TestSuite()
 253     suite.addTest(unittest.makeSuite(CornerTestCase))
 254     suite.addTest(unittest.makeSuite(BugTestCase))
 255     return suite