api.py (7492B)
1 #Embedded file name: C:\BuildAgent\work\20d73f1b24eed06e\eve\release\V24.01\carbon\common\lib\jinja2\testsuite\api.py 2 import unittest 3 from jinja2.testsuite import JinjaTestCase 4 from jinja2 import Environment, Undefined, DebugUndefined, StrictUndefined, UndefinedError, meta, is_undefined, Template, DictLoader 5 from jinja2.utils import Cycler 6 env = Environment() 7 8 class ExtendedAPITestCase(JinjaTestCase): 9 10 def test_item_and_attribute(self): 11 from jinja2.sandbox import SandboxedEnvironment 12 for env in (Environment(), SandboxedEnvironment()): 13 tmpl = env.from_string('{{ foo.items()|list }}') 14 tmpl = env.from_string('{{ foo|attr("items")()|list }}') 15 tmpl = env.from_string('{{ foo["items"] }}') 16 17 def test_finalizer(self): 18 19 def finalize_none_empty(value): 20 if value is None: 21 value = u'' 22 return value 23 24 env = Environment(finalize=finalize_none_empty) 25 tmpl = env.from_string('{% for item in seq %}|{{ item }}{% endfor %}') 26 tmpl = env.from_string('<{{ none }}>') 27 28 def test_cycler(self): 29 items = (1, 2, 3) 30 c = Cycler(*items) 31 for item in items + items: 32 pass 33 34 c.next() 35 c.reset() 36 37 def test_expressions(self): 38 expr = env.compile_expression('foo') 39 expr2 = env.compile_expression('foo', undefined_to_none=False) 40 expr = env.compile_expression('42 + foo') 41 42 def test_template_passthrough(self): 43 t = Template('Content') 44 45 def test_autoescape_autoselect(self): 46 47 def select_autoescape(name): 48 if name is None or '.' not in name: 49 return False 50 return name.endswith('.html') 51 52 env = Environment(autoescape=select_autoescape, loader=DictLoader({'test.txt': '{{ foo }}', 53 'test.html': '{{ foo }}'})) 54 t = env.get_template('test.txt') 55 t = env.get_template('test.html') 56 t = env.from_string('{{ foo }}') 57 58 59 class MetaTestCase(JinjaTestCase): 60 61 def test_find_undeclared_variables(self): 62 ast = env.parse('{% set foo = 42 %}{{ bar + foo }}') 63 x = meta.find_undeclared_variables(ast) 64 ast = env.parse('{% set foo = 42 %}{{ bar + foo }}{% macro meh(x) %}{{ x }}{% endmacro %}{% for item in seq %}{{ muh(item) + meh(seq) }}{% endfor %}') 65 x = meta.find_undeclared_variables(ast) 66 67 def test_find_refererenced_templates(self): 68 ast = env.parse('{% extends "layout.html" %}{% include helper %}') 69 i = meta.find_referenced_templates(ast) 70 ast = env.parse('{% extends "layout.html" %}{% from "test.html" import a, b as c %}{% import "meh.html" as meh %}{% include "muh.html" %}') 71 i = meta.find_referenced_templates(ast) 72 73 def test_find_included_templates(self): 74 ast = env.parse('{% include ["foo.html", "bar.html"] %}') 75 i = meta.find_referenced_templates(ast) 76 ast = env.parse('{% include ("foo.html", "bar.html") %}') 77 i = meta.find_referenced_templates(ast) 78 ast = env.parse('{% include ["foo.html", "bar.html", foo] %}') 79 i = meta.find_referenced_templates(ast) 80 ast = env.parse('{% include ("foo.html", "bar.html", foo) %}') 81 i = meta.find_referenced_templates(ast) 82 83 84 class StreamingTestCase(JinjaTestCase): 85 86 def test_basic_streaming(self): 87 tmpl = env.from_string('<ul>{% for item in seq %}<li>{{ loop.index }} - {{ item }}</li>{%- endfor %}</ul>') 88 stream = tmpl.stream(seq=range(4)) 89 self.assert_equal(stream.next(), '<ul>') 90 self.assert_equal(stream.next(), '<li>1 - 0</li>') 91 self.assert_equal(stream.next(), '<li>2 - 1</li>') 92 self.assert_equal(stream.next(), '<li>3 - 2</li>') 93 self.assert_equal(stream.next(), '<li>4 - 3</li>') 94 self.assert_equal(stream.next(), '</ul>') 95 96 def test_buffered_streaming(self): 97 tmpl = env.from_string('<ul>{% for item in seq %}<li>{{ loop.index }} - {{ item }}</li>{%- endfor %}</ul>') 98 stream = tmpl.stream(seq=range(4)) 99 stream.enable_buffering(size=3) 100 self.assert_equal(stream.next(), u'<ul><li>1 - 0</li><li>2 - 1</li>') 101 self.assert_equal(stream.next(), u'<li>3 - 2</li><li>4 - 3</li></ul>') 102 103 def test_streaming_behavior(self): 104 tmpl = env.from_string('') 105 stream = tmpl.stream() 106 stream.enable_buffering(20) 107 stream.disable_buffering() 108 109 110 class UndefinedTestCase(JinjaTestCase): 111 112 def test_stopiteration_is_undefined(self): 113 114 def test(): 115 raise StopIteration() 116 117 t = Template('A{{ test() }}B') 118 t = Template('A{{ test().missingattribute }}B') 119 self.assert_raises(UndefinedError, t.render, test=test) 120 121 def test_undefined_and_special_attributes(self): 122 try: 123 Undefined('Foo').__dict__ 124 except AttributeError: 125 pass 126 127 def test_default_undefined(self): 128 env = Environment(undefined=Undefined) 129 self.assert_equal(env.from_string('{{ missing }}').render(), u'') 130 self.assert_raises(UndefinedError, env.from_string('{{ missing.attribute }}').render) 131 self.assert_equal(env.from_string('{{ missing|list }}').render(), '[]') 132 self.assert_equal(env.from_string('{{ missing is not defined }}').render(), 'True') 133 self.assert_equal(env.from_string('{{ foo.missing }}').render(foo=42), '') 134 self.assert_equal(env.from_string('{{ not missing }}').render(), 'True') 135 136 def test_debug_undefined(self): 137 env = Environment(undefined=DebugUndefined) 138 self.assert_equal(env.from_string('{{ missing }}').render(), '{{ missing }}') 139 self.assert_raises(UndefinedError, env.from_string('{{ missing.attribute }}').render) 140 self.assert_equal(env.from_string('{{ missing|list }}').render(), '[]') 141 self.assert_equal(env.from_string('{{ missing is not defined }}').render(), 'True') 142 self.assert_equal(env.from_string('{{ foo.missing }}').render(foo=42), u"{{ no such element: int object['missing'] }}") 143 self.assert_equal(env.from_string('{{ not missing }}').render(), 'True') 144 145 def test_strict_undefined(self): 146 env = Environment(undefined=StrictUndefined) 147 self.assert_raises(UndefinedError, env.from_string('{{ missing }}').render) 148 self.assert_raises(UndefinedError, env.from_string('{{ missing.attribute }}').render) 149 self.assert_raises(UndefinedError, env.from_string('{{ missing|list }}').render) 150 self.assert_equal(env.from_string('{{ missing is not defined }}').render(), 'True') 151 self.assert_raises(UndefinedError, env.from_string('{{ foo.missing }}').render, foo=42) 152 self.assert_raises(UndefinedError, env.from_string('{{ not missing }}').render) 153 154 def test_indexing_gives_undefined(self): 155 t = Template('{{ var[42].foo }}') 156 self.assert_raises(UndefinedError, t.render, var=0) 157 158 def test_none_gives_proper_error(self): 159 try: 160 Environment().getattr(None, 'split')() 161 except UndefinedError as e: 162 pass 163 164 def test_object_repr(self): 165 try: 166 Undefined(obj=42, name='upper')() 167 except UndefinedError as e: 168 pass 169 170 171 def suite(): 172 suite = unittest.TestSuite() 173 suite.addTest(unittest.makeSuite(ExtendedAPITestCase)) 174 suite.addTest(unittest.makeSuite(MetaTestCase)) 175 suite.addTest(unittest.makeSuite(StreamingTestCase)) 176 suite.addTest(unittest.makeSuite(UndefinedTestCase)) 177 return suite