mirror of https://github.com/lukechilds/node.git
Browse Source
PR-URL: https://github.com/nodejs/node/pull/7796 Reviewed-By: bnoordhuis - Ben Noordhuis <info@bnoordhuis.nl> Reviewed-By: jasnell - James M Snell <jasnell@gmail.com>v7.x
Ali Ijaz Sheikh
9 years ago
20 changed files with 0 additions and 3721 deletions
@ -1,74 +0,0 @@ |
|||
# -*- coding: utf-8 -*- |
|||
""" |
|||
jinja2.testsuite.conftest |
|||
~~~~~~~~~~~~~~~~~~~~~~~~~ |
|||
|
|||
Configuration and Fixtures for the tests |
|||
|
|||
:copyright: (c) 2010 by the Jinja Team. |
|||
:license: BSD, see LICENSE for more details. |
|||
""" |
|||
import pytest |
|||
import os |
|||
import re |
|||
import sys |
|||
|
|||
from traceback import format_exception |
|||
from jinja2 import loaders |
|||
from jinja2._compat import PY2 |
|||
from jinja2 import Environment |
|||
|
|||
|
|||
@pytest.fixture |
|||
def env(): |
|||
'''returns a new environment. |
|||
''' |
|||
return Environment() |
|||
|
|||
|
|||
@pytest.fixture |
|||
def dict_loader(): |
|||
'''returns DictLoader |
|||
''' |
|||
return loaders.DictLoader({ |
|||
'justdict.html': 'FOO' |
|||
}) |
|||
|
|||
|
|||
@pytest.fixture |
|||
def package_loader(): |
|||
'''returns PackageLoader initialized from templates |
|||
''' |
|||
return loaders.PackageLoader('res', 'templates') |
|||
|
|||
|
|||
@pytest.fixture |
|||
def filesystem_loader(): |
|||
'''returns FileSystemLoader initialized to res/templates directory |
|||
''' |
|||
here = os.path.dirname(os.path.abspath(__file__)) |
|||
return loaders.FileSystemLoader(here + '/res/templates') |
|||
|
|||
|
|||
@pytest.fixture |
|||
def function_loader(): |
|||
'''returns a FunctionLoader |
|||
''' |
|||
return loaders.FunctionLoader({'justfunction.html': 'FOO'}.get) |
|||
|
|||
|
|||
@pytest.fixture |
|||
def choice_loader(dict_loader, package_loader): |
|||
'''returns a ChoiceLoader |
|||
''' |
|||
return loaders.ChoiceLoader([dict_loader, package_loader]) |
|||
|
|||
|
|||
@pytest.fixture |
|||
def prefix_loader(filesystem_loader, dict_loader): |
|||
'''returns a PrefixLoader |
|||
''' |
|||
return loaders.PrefixLoader({ |
|||
'a': filesystem_loader, |
|||
'b': dict_loader |
|||
}) |
|||
@ -1,3 +0,0 @@ |
|||
Before |
|||
{{ fail() }} |
|||
After |
|||
@ -1 +0,0 @@ |
|||
FOO |
|||
@ -1,4 +0,0 @@ |
|||
Foo |
|||
{% for item in broken %} |
|||
... |
|||
{% endif %} |
|||
@ -1 +0,0 @@ |
|||
BAR |
|||
@ -1,327 +0,0 @@ |
|||
# -*- coding: utf-8 -*- |
|||
""" |
|||
jinja2.testsuite.api |
|||
~~~~~~~~~~~~~~~~~~~~ |
|||
|
|||
Tests the public API and related stuff. |
|||
|
|||
:copyright: (c) 2010 by the Jinja Team. |
|||
:license: BSD, see LICENSE for more details. |
|||
""" |
|||
import os |
|||
import tempfile |
|||
import shutil |
|||
|
|||
import pytest |
|||
from jinja2 import Environment, Undefined, DebugUndefined, \ |
|||
StrictUndefined, UndefinedError, meta, \ |
|||
is_undefined, Template, DictLoader, make_logging_undefined |
|||
from jinja2.compiler import CodeGenerator |
|||
from jinja2.runtime import Context |
|||
from jinja2.utils import Cycler |
|||
|
|||
|
|||
@pytest.mark.api |
|||
@pytest.mark.extended |
|||
class TestExtendedAPI(): |
|||
|
|||
def test_item_and_attribute(self, env): |
|||
from jinja2.sandbox import SandboxedEnvironment |
|||
|
|||
for env in Environment(), SandboxedEnvironment(): |
|||
# the |list is necessary for python3 |
|||
tmpl = env.from_string('{{ foo.items()|list }}') |
|||
assert tmpl.render(foo={'items': 42}) == "[('items', 42)]" |
|||
tmpl = env.from_string('{{ foo|attr("items")()|list }}') |
|||
assert tmpl.render(foo={'items': 42}) == "[('items', 42)]" |
|||
tmpl = env.from_string('{{ foo["items"] }}') |
|||
assert tmpl.render(foo={'items': 42}) == '42' |
|||
|
|||
def test_finalizer(self, env): |
|||
def finalize_none_empty(value): |
|||
if value is None: |
|||
value = u'' |
|||
return value |
|||
env = Environment(finalize=finalize_none_empty) |
|||
tmpl = env.from_string('{% for item in seq %}|{{ item }}{% endfor %}') |
|||
assert tmpl.render(seq=(None, 1, "foo")) == '||1|foo' |
|||
tmpl = env.from_string('<{{ none }}>') |
|||
assert tmpl.render() == '<>' |
|||
|
|||
def test_cycler(self, env): |
|||
items = 1, 2, 3 |
|||
c = Cycler(*items) |
|||
for item in items + items: |
|||
assert c.current == item |
|||
assert next(c) == item |
|||
next(c) |
|||
assert c.current == 2 |
|||
c.reset() |
|||
assert c.current == 1 |
|||
|
|||
def test_expressions(self, env): |
|||
expr = env.compile_expression("foo") |
|||
assert expr() is None |
|||
assert expr(foo=42) == 42 |
|||
expr2 = env.compile_expression("foo", undefined_to_none=False) |
|||
assert is_undefined(expr2()) |
|||
|
|||
expr = env.compile_expression("42 + foo") |
|||
assert expr(foo=42) == 84 |
|||
|
|||
def test_template_passthrough(self, env): |
|||
t = Template('Content') |
|||
assert env.get_template(t) is t |
|||
assert env.select_template([t]) is t |
|||
assert env.get_or_select_template([t]) is t |
|||
assert env.get_or_select_template(t) is t |
|||
|
|||
def test_autoescape_autoselect(self, env): |
|||
def select_autoescape(name): |
|||
if name is None or '.' not in name: |
|||
return False |
|||
return name.endswith('.html') |
|||
env = Environment(autoescape=select_autoescape, |
|||
loader=DictLoader({ |
|||
'test.txt': '{{ foo }}', |
|||
'test.html': '{{ foo }}' |
|||
})) |
|||
t = env.get_template('test.txt') |
|||
assert t.render(foo='<foo>') == '<foo>' |
|||
t = env.get_template('test.html') |
|||
assert t.render(foo='<foo>') == '<foo>' |
|||
t = env.from_string('{{ foo }}') |
|||
assert t.render(foo='<foo>') == '<foo>' |
|||
|
|||
|
|||
@pytest.mark.api |
|||
@pytest.mark.meta |
|||
class TestMeta(): |
|||
|
|||
def test_find_undeclared_variables(self, env): |
|||
ast = env.parse('{% set foo = 42 %}{{ bar + foo }}') |
|||
x = meta.find_undeclared_variables(ast) |
|||
assert x == set(['bar']) |
|||
|
|||
ast = env.parse('{% set foo = 42 %}{{ bar + foo }}' |
|||
'{% macro meh(x) %}{{ x }}{% endmacro %}' |
|||
'{% for item in seq %}{{ muh(item) + meh(seq) }}' |
|||
'{% endfor %}') |
|||
x = meta.find_undeclared_variables(ast) |
|||
assert x == set(['bar', 'seq', 'muh']) |
|||
|
|||
def test_find_refererenced_templates(self, env): |
|||
ast = env.parse('{% extends "layout.html" %}{% include helper %}') |
|||
i = meta.find_referenced_templates(ast) |
|||
assert next(i) == 'layout.html' |
|||
assert next(i) is None |
|||
assert list(i) == [] |
|||
|
|||
ast = env.parse('{% extends "layout.html" %}' |
|||
'{% from "test.html" import a, b as c %}' |
|||
'{% import "meh.html" as meh %}' |
|||
'{% include "muh.html" %}') |
|||
i = meta.find_referenced_templates(ast) |
|||
assert list(i) == ['layout.html', 'test.html', 'meh.html', 'muh.html'] |
|||
|
|||
def test_find_included_templates(self, env): |
|||
ast = env.parse('{% include ["foo.html", "bar.html"] %}') |
|||
i = meta.find_referenced_templates(ast) |
|||
assert list(i) == ['foo.html', 'bar.html'] |
|||
|
|||
ast = env.parse('{% include ("foo.html", "bar.html") %}') |
|||
i = meta.find_referenced_templates(ast) |
|||
assert list(i) == ['foo.html', 'bar.html'] |
|||
|
|||
ast = env.parse('{% include ["foo.html", "bar.html", foo] %}') |
|||
i = meta.find_referenced_templates(ast) |
|||
assert list(i) == ['foo.html', 'bar.html', None] |
|||
|
|||
ast = env.parse('{% include ("foo.html", "bar.html", foo) %}') |
|||
i = meta.find_referenced_templates(ast) |
|||
assert list(i) == ['foo.html', 'bar.html', None] |
|||
|
|||
|
|||
@pytest.mark.api |
|||
@pytest.mark.streaming |
|||
class TestStreaming(): |
|||
|
|||
def test_basic_streaming(self, env): |
|||
tmpl = env.from_string("<ul>{% for item in seq %}<li>{{ loop.index " |
|||
"}} - {{ item }}</li>{%- endfor %}</ul>") |
|||
stream = tmpl.stream(seq=list(range(4))) |
|||
assert next(stream) == '<ul>' |
|||
assert next(stream) == '<li>1 - 0</li>' |
|||
assert next(stream) == '<li>2 - 1</li>' |
|||
assert next(stream) == '<li>3 - 2</li>' |
|||
assert next(stream) == '<li>4 - 3</li>' |
|||
assert next(stream) == '</ul>' |
|||
|
|||
def test_buffered_streaming(self, env): |
|||
tmpl = env.from_string("<ul>{% for item in seq %}<li>{{ loop.index " |
|||
"}} - {{ item }}</li>{%- endfor %}</ul>") |
|||
stream = tmpl.stream(seq=list(range(4))) |
|||
stream.enable_buffering(size=3) |
|||
assert next(stream) == u'<ul><li>1 - 0</li><li>2 - 1</li>' |
|||
assert next(stream) == u'<li>3 - 2</li><li>4 - 3</li></ul>' |
|||
|
|||
def test_streaming_behavior(self, env): |
|||
tmpl = env.from_string("") |
|||
stream = tmpl.stream() |
|||
assert not stream.buffered |
|||
stream.enable_buffering(20) |
|||
assert stream.buffered |
|||
stream.disable_buffering() |
|||
assert not stream.buffered |
|||
|
|||
def test_dump_stream(self, env): |
|||
tmp = tempfile.mkdtemp() |
|||
try: |
|||
tmpl = env.from_string(u"\u2713") |
|||
stream = tmpl.stream() |
|||
stream.dump(os.path.join(tmp, 'dump.txt'), 'utf-8') |
|||
with open(os.path.join(tmp, 'dump.txt'), 'rb') as f: |
|||
assert f.read() == b'\xe2\x9c\x93' |
|||
finally: |
|||
shutil.rmtree(tmp) |
|||
|
|||
|
|||
@pytest.mark.api |
|||
@pytest.mark.undefined |
|||
class TestUndefined(): |
|||
|
|||
def test_stopiteration_is_undefined(self): |
|||
def test(): |
|||
raise StopIteration() |
|||
t = Template('A{{ test() }}B') |
|||
assert t.render(test=test) == 'AB' |
|||
t = Template('A{{ test().missingattribute }}B') |
|||
pytest.raises(UndefinedError, t.render, test=test) |
|||
|
|||
def test_undefined_and_special_attributes(self): |
|||
try: |
|||
Undefined('Foo').__dict__ |
|||
except AttributeError: |
|||
pass |
|||
else: |
|||
assert False, "Expected actual attribute error" |
|||
|
|||
def test_logging_undefined(self): |
|||
_messages = [] |
|||
|
|||
class DebugLogger(object): |
|||
def warning(self, msg, *args): |
|||
_messages.append('W:' + msg % args) |
|||
|
|||
def error(self, msg, *args): |
|||
_messages.append('E:' + msg % args) |
|||
|
|||
logging_undefined = make_logging_undefined(DebugLogger()) |
|||
env = Environment(undefined=logging_undefined) |
|||
assert env.from_string('{{ missing }}').render() == u'' |
|||
pytest.raises(UndefinedError, |
|||
env.from_string('{{ missing.attribute }}').render) |
|||
assert env.from_string('{{ missing|list }}').render() == '[]' |
|||
assert env.from_string('{{ missing is not defined }}').render() \ |
|||
== 'True' |
|||
assert env.from_string('{{ foo.missing }}').render(foo=42) == '' |
|||
assert env.from_string('{{ not missing }}').render() == 'True' |
|||
assert _messages == [ |
|||
'W:Template variable warning: missing is undefined', |
|||
"E:Template variable error: 'missing' is undefined", |
|||
'W:Template variable warning: missing is undefined', |
|||
'W:Template variable warning: int object has no attribute missing', |
|||
'W:Template variable warning: missing is undefined', |
|||
] |
|||
|
|||
def test_default_undefined(self): |
|||
env = Environment(undefined=Undefined) |
|||
assert env.from_string('{{ missing }}').render() == u'' |
|||
pytest.raises(UndefinedError, |
|||
env.from_string('{{ missing.attribute }}').render) |
|||
assert env.from_string('{{ missing|list }}').render() == '[]' |
|||
assert env.from_string('{{ missing is not defined }}').render() \ |
|||
== 'True' |
|||
assert env.from_string('{{ foo.missing }}').render(foo=42) == '' |
|||
assert env.from_string('{{ not missing }}').render() == 'True' |
|||
|
|||
def test_debug_undefined(self): |
|||
env = Environment(undefined=DebugUndefined) |
|||
assert env.from_string('{{ missing }}').render() == '{{ missing }}' |
|||
pytest.raises(UndefinedError, |
|||
env.from_string('{{ missing.attribute }}').render) |
|||
assert env.from_string('{{ missing|list }}').render() == '[]' |
|||
assert env.from_string('{{ missing is not defined }}').render() \ |
|||
== 'True' |
|||
assert env.from_string('{{ foo.missing }}').render(foo=42) \ |
|||
== u"{{ no such element: int object['missing'] }}" |
|||
assert env.from_string('{{ not missing }}').render() == 'True' |
|||
|
|||
def test_strict_undefined(self): |
|||
env = Environment(undefined=StrictUndefined) |
|||
pytest.raises(UndefinedError, env.from_string('{{ missing }}').render) |
|||
pytest.raises(UndefinedError, |
|||
env.from_string('{{ missing.attribute }}').render) |
|||
pytest.raises(UndefinedError, |
|||
env.from_string('{{ missing|list }}').render) |
|||
assert env.from_string('{{ missing is not defined }}').render() \ |
|||
== 'True' |
|||
pytest.raises(UndefinedError, |
|||
env.from_string('{{ foo.missing }}').render, foo=42) |
|||
pytest.raises(UndefinedError, |
|||
env.from_string('{{ not missing }}').render) |
|||
assert env.from_string('{{ missing|default("default", true) }}')\ |
|||
.render() == 'default' |
|||
|
|||
def test_indexing_gives_undefined(self): |
|||
t = Template("{{ var[42].foo }}") |
|||
pytest.raises(UndefinedError, t.render, var=0) |
|||
|
|||
def test_none_gives_proper_error(self): |
|||
try: |
|||
Environment().getattr(None, 'split')() |
|||
except UndefinedError as e: |
|||
assert e.message == "'None' has no attribute 'split'" |
|||
else: |
|||
assert False, 'expected exception' |
|||
|
|||
def test_object_repr(self): |
|||
try: |
|||
Undefined(obj=42, name='upper')() |
|||
except UndefinedError as e: |
|||
assert e.message == "'int object' has no attribute 'upper'" |
|||
else: |
|||
assert False, 'expected exception' |
|||
|
|||
|
|||
@pytest.mark.api |
|||
@pytest.mark.lowlevel |
|||
class TestLowLevel(): |
|||
|
|||
def test_custom_code_generator(self): |
|||
class CustomCodeGenerator(CodeGenerator): |
|||
def visit_Const(self, node, frame=None): |
|||
# This method is pure nonsense, but works fine for testing... |
|||
if node.value == 'foo': |
|||
self.write(repr('bar')) |
|||
else: |
|||
super(CustomCodeGenerator, self).visit_Const(node, frame) |
|||
|
|||
class CustomEnvironment(Environment): |
|||
code_generator_class = CustomCodeGenerator |
|||
|
|||
env = CustomEnvironment() |
|||
tmpl = env.from_string('{% set foo = "foo" %}{{ foo }}') |
|||
assert tmpl.render() == 'bar' |
|||
|
|||
def test_custom_context(self): |
|||
class CustomContext(Context): |
|||
def resolve(self, key): |
|||
return 'resolve-' + key |
|||
|
|||
class CustomEnvironment(Environment): |
|||
context_class = CustomContext |
|||
|
|||
env = CustomEnvironment() |
|||
tmpl = env.from_string('{{ foo }}') |
|||
assert tmpl.render() == 'resolve-foo' |
|||
@ -1,32 +0,0 @@ |
|||
# -*- coding: utf-8 -*- |
|||
""" |
|||
jinja2.testsuite.bytecode_cache |
|||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
|||
|
|||
Test bytecode caching |
|||
|
|||
:copyright: (c) 2010 by the Jinja Team. |
|||
:license: BSD, see LICENSE for more details. |
|||
""" |
|||
import pytest |
|||
from jinja2 import Environment |
|||
from jinja2.bccache import FileSystemBytecodeCache |
|||
from jinja2.exceptions import TemplateNotFound |
|||
|
|||
|
|||
@pytest.fixture |
|||
def env(package_loader): |
|||
bytecode_cache = FileSystemBytecodeCache() |
|||
return Environment( |
|||
loader=package_loader, |
|||
bytecode_cache=bytecode_cache, |
|||
) |
|||
|
|||
|
|||
@pytest.mark.byte_code_cache |
|||
class TestByteCodeCache(): |
|||
|
|||
def test_simple(self, env): |
|||
tmpl = env.get_template('test.html') |
|||
assert tmpl.render().strip() == 'BAR' |
|||
pytest.raises(TemplateNotFound, env.get_template, 'missing.html') |
|||
@ -1,337 +0,0 @@ |
|||
# -*- coding: utf-8 -*- |
|||
""" |
|||
jinja2.testsuite.core_tags |
|||
~~~~~~~~~~~~~~~~~~~~~~~~~~ |
|||
|
|||
Test the core tags like for and if. |
|||
|
|||
:copyright: (c) 2010 by the Jinja Team. |
|||
:license: BSD, see LICENSE for more details. |
|||
""" |
|||
import pytest |
|||
from jinja2 import Environment, TemplateSyntaxError, UndefinedError, \ |
|||
DictLoader |
|||
|
|||
|
|||
@pytest.fixture |
|||
def env_trim(): |
|||
return Environment(trim_blocks=True) |
|||
|
|||
|
|||
@pytest.mark.core_tags |
|||
@pytest.mark.for_loop |
|||
class TestForLoop(): |
|||
|
|||
def test_simple(self, env): |
|||
tmpl = env.from_string('{% for item in seq %}{{ item }}{% endfor %}') |
|||
assert tmpl.render(seq=list(range(10))) == '0123456789' |
|||
|
|||
def test_else(self, env): |
|||
tmpl = env.from_string( |
|||
'{% for item in seq %}XXX{% else %}...{% endfor %}') |
|||
assert tmpl.render() == '...' |
|||
|
|||
def test_empty_blocks(self, env): |
|||
tmpl = env.from_string('<{% for item in seq %}{% else %}{% endfor %}>') |
|||
assert tmpl.render() == '<>' |
|||
|
|||
def test_context_vars(self, env): |
|||
slist = [42, 24] |
|||
for seq in [slist, iter(slist), reversed(slist), (_ for _ in slist)]: |
|||
tmpl = env.from_string('''{% for item in seq -%} |
|||
{{ loop.index }}|{{ loop.index0 }}|{{ loop.revindex }}|{{ |
|||
loop.revindex0 }}|{{ loop.first }}|{{ loop.last }}|{{ |
|||
loop.length }}###{% endfor %}''') |
|||
one, two, _ = tmpl.render(seq=seq).split('###') |
|||
(one_index, one_index0, one_revindex, one_revindex0, one_first, |
|||
one_last, one_length) = one.split('|') |
|||
(two_index, two_index0, two_revindex, two_revindex0, two_first, |
|||
two_last, two_length) = two.split('|') |
|||
|
|||
assert int(one_index) == 1 and int(two_index) == 2 |
|||
assert int(one_index0) == 0 and int(two_index0) == 1 |
|||
assert int(one_revindex) == 2 and int(two_revindex) == 1 |
|||
assert int(one_revindex0) == 1 and int(two_revindex0) == 0 |
|||
assert one_first == 'True' and two_first == 'False' |
|||
assert one_last == 'False' and two_last == 'True' |
|||
assert one_length == two_length == '2' |
|||
|
|||
def test_cycling(self, env): |
|||
tmpl = env.from_string('''{% for item in seq %}{{ |
|||
loop.cycle('<1>', '<2>') }}{% endfor %}{% |
|||
for item in seq %}{{ loop.cycle(*through) }}{% endfor %}''') |
|||
output = tmpl.render(seq=list(range(4)), through=('<1>', '<2>')) |
|||
assert output == '<1><2>' * 4 |
|||
|
|||
def test_scope(self, env): |
|||
tmpl = env.from_string('{% for item in seq %}{% endfor %}{{ item }}') |
|||
output = tmpl.render(seq=list(range(10))) |
|||
assert not output |
|||
|
|||
def test_varlen(self, env): |
|||
def inner(): |
|||
for item in range(5): |
|||
yield item |
|||
tmpl = env.from_string('{% for item in iter %}{{ item }}{% endfor %}') |
|||
output = tmpl.render(iter=inner()) |
|||
assert output == '01234' |
|||
|
|||
def test_noniter(self, env): |
|||
tmpl = env.from_string('{% for item in none %}...{% endfor %}') |
|||
pytest.raises(TypeError, tmpl.render) |
|||
|
|||
def test_recursive(self, env): |
|||
tmpl = env.from_string('''{% for item in seq recursive -%} |
|||
[{{ item.a }}{% if item.b %}<{{ loop(item.b) }}>{% endif %}] |
|||
{%- endfor %}''') |
|||
assert tmpl.render(seq=[ |
|||
dict(a=1, b=[dict(a=1), dict(a=2)]), |
|||
dict(a=2, b=[dict(a=1), dict(a=2)]), |
|||
dict(a=3, b=[dict(a='a')]) |
|||
]) == '[1<[1][2]>][2<[1][2]>][3<[a]>]' |
|||
|
|||
def test_recursive_depth0(self, env): |
|||
tmpl = env.from_string('''{% for item in seq recursive -%} |
|||
[{{ loop.depth0 }}:{{ item.a }}{% if item.b %}<{{ loop(item.b) }}>{% endif %}] |
|||
{%- endfor %}''') |
|||
assert tmpl.render(seq=[ |
|||
dict(a=1, b=[dict(a=1), dict(a=2)]), |
|||
dict(a=2, b=[dict(a=1), dict(a=2)]), |
|||
dict(a=3, b=[dict(a='a')]) |
|||
]) == '[0:1<[1:1][1:2]>][0:2<[1:1][1:2]>][0:3<[1:a]>]' |
|||
|
|||
def test_recursive_depth(self, env): |
|||
tmpl = env.from_string('''{% for item in seq recursive -%} |
|||
[{{ loop.depth }}:{{ item.a }}{% if item.b %}<{{ loop(item.b) }}>{% endif %}] |
|||
{%- endfor %}''') |
|||
assert tmpl.render(seq=[ |
|||
dict(a=1, b=[dict(a=1), dict(a=2)]), |
|||
dict(a=2, b=[dict(a=1), dict(a=2)]), |
|||
dict(a=3, b=[dict(a='a')]) |
|||
]) == '[1:1<[2:1][2:2]>][1:2<[2:1][2:2]>][1:3<[2:a]>]' |
|||
|
|||
def test_looploop(self, env): |
|||
tmpl = env.from_string('''{% for row in table %} |
|||
{%- set rowloop = loop -%} |
|||
{% for cell in row -%} |
|||
[{{ rowloop.index }}|{{ loop.index }}] |
|||
{%- endfor %} |
|||
{%- endfor %}''') |
|||
assert tmpl.render(table=['ab', 'cd']) == '[1|1][1|2][2|1][2|2]' |
|||
|
|||
def test_reversed_bug(self, env): |
|||
tmpl = env.from_string('{% for i in items %}{{ i }}' |
|||
'{% if not loop.last %}' |
|||
',{% endif %}{% endfor %}') |
|||
assert tmpl.render(items=reversed([3, 2, 1])) == '1,2,3' |
|||
|
|||
def test_loop_errors(self, env): |
|||
tmpl = env.from_string('''{% for item in [1] if loop.index |
|||
== 0 %}...{% endfor %}''') |
|||
pytest.raises(UndefinedError, tmpl.render) |
|||
tmpl = env.from_string('''{% for item in [] %}...{% else |
|||
%}{{ loop }}{% endfor %}''') |
|||
assert tmpl.render() == '' |
|||
|
|||
def test_loop_filter(self, env): |
|||
tmpl = env.from_string('{% for item in range(10) if item ' |
|||
'is even %}[{{ item }}]{% endfor %}') |
|||
assert tmpl.render() == '[0][2][4][6][8]' |
|||
tmpl = env.from_string(''' |
|||
{%- for item in range(10) if item is even %}[{{ |
|||
loop.index }}:{{ item }}]{% endfor %}''') |
|||
assert tmpl.render() == '[1:0][2:2][3:4][4:6][5:8]' |
|||
|
|||
def test_loop_unassignable(self, env): |
|||
pytest.raises(TemplateSyntaxError, env.from_string, |
|||
'{% for loop in seq %}...{% endfor %}') |
|||
|
|||
def test_scoped_special_var(self, env): |
|||
t = env.from_string( |
|||
'{% for s in seq %}[{{ loop.first }}{% for c in s %}' |
|||
'|{{ loop.first }}{% endfor %}]{% endfor %}') |
|||
assert t.render(seq=('ab', 'cd')) \ |
|||
== '[True|True|False][False|True|False]' |
|||
|
|||
def test_scoped_loop_var(self, env): |
|||
t = env.from_string('{% for x in seq %}{{ loop.first }}' |
|||
'{% for y in seq %}{% endfor %}{% endfor %}') |
|||
assert t.render(seq='ab') == 'TrueFalse' |
|||
t = env.from_string('{% for x in seq %}{% for y in seq %}' |
|||
'{{ loop.first }}{% endfor %}{% endfor %}') |
|||
assert t.render(seq='ab') == 'TrueFalseTrueFalse' |
|||
|
|||
def test_recursive_empty_loop_iter(self, env): |
|||
t = env.from_string(''' |
|||
{%- for item in foo recursive -%}{%- endfor -%} |
|||
''') |
|||
assert t.render(dict(foo=[])) == '' |
|||
|
|||
def test_call_in_loop(self, env): |
|||
t = env.from_string(''' |
|||
{%- macro do_something() -%} |
|||
[{{ caller() }}] |
|||
{%- endmacro %} |
|||
|
|||
{%- for i in [1, 2, 3] %} |
|||
{%- call do_something() -%} |
|||
{{ i }} |
|||
{%- endcall %} |
|||
{%- endfor -%} |
|||
''') |
|||
assert t.render() == '[1][2][3]' |
|||
|
|||
def test_scoping_bug(self, env): |
|||
t = env.from_string(''' |
|||
{%- for item in foo %}...{{ item }}...{% endfor %} |
|||
{%- macro item(a) %}...{{ a }}...{% endmacro %} |
|||
{{- item(2) -}} |
|||
''') |
|||
assert t.render(foo=(1,)) == '...1......2...' |
|||
|
|||
def test_unpacking(self, env): |
|||
tmpl = env.from_string('{% for a, b, c in [[1, 2, 3]] %}' |
|||
'{{ a }}|{{ b }}|{{ c }}{% endfor %}') |
|||
assert tmpl.render() == '1|2|3' |
|||
|
|||
|
|||
@pytest.mark.core_tags |
|||
@pytest.mark.if_condition |
|||
class TestIfCondition(): |
|||
|
|||
def test_simple(self, env): |
|||
tmpl = env.from_string('''{% if true %}...{% endif %}''') |
|||
assert tmpl.render() == '...' |
|||
|
|||
def test_elif(self, env): |
|||
tmpl = env.from_string('''{% if false %}XXX{% elif true |
|||
%}...{% else %}XXX{% endif %}''') |
|||
assert tmpl.render() == '...' |
|||
|
|||
def test_else(self, env): |
|||
tmpl = env.from_string('{% if false %}XXX{% else %}...{% endif %}') |
|||
assert tmpl.render() == '...' |
|||
|
|||
def test_empty(self, env): |
|||
tmpl = env.from_string('[{% if true %}{% else %}{% endif %}]') |
|||
assert tmpl.render() == '[]' |
|||
|
|||
def test_complete(self, env): |
|||
tmpl = env.from_string('{% if a %}A{% elif b %}B{% elif c == d %}' |
|||
'C{% else %}D{% endif %}') |
|||
assert tmpl.render(a=0, b=False, c=42, d=42.0) == 'C' |
|||
|
|||
def test_no_scope(self, env): |
|||
tmpl = env.from_string( |
|||
'{% if a %}{% set foo = 1 %}{% endif %}{{ foo }}') |
|||
assert tmpl.render(a=True) == '1' |
|||
tmpl = env.from_string( |
|||
'{% if true %}{% set foo = 1 %}{% endif %}{{ foo }}') |
|||
assert tmpl.render() == '1' |
|||
|
|||
|
|||
@pytest.mark.core_tags |
|||
@pytest.mark.macros |
|||
class TestMacros(): |
|||
def test_simple(self, env_trim): |
|||
tmpl = env_trim.from_string('''\ |
|||
{% macro say_hello(name) %}Hello {{ name }}!{% endmacro %} |
|||
{{ say_hello('Peter') }}''') |
|||
assert tmpl.render() == 'Hello Peter!' |
|||
|
|||
def test_scoping(self, env_trim): |
|||
tmpl = env_trim.from_string('''\ |
|||
{% macro level1(data1) %} |
|||
{% macro level2(data2) %}{{ data1 }}|{{ data2 }}{% endmacro %} |
|||
{{ level2('bar') }}{% endmacro %} |
|||
{{ level1('foo') }}''') |
|||
assert tmpl.render() == 'foo|bar' |
|||
|
|||
def test_arguments(self, env_trim): |
|||
tmpl = env_trim.from_string('''\ |
|||
{% macro m(a, b, c='c', d='d') %}{{ a }}|{{ b }}|{{ c }}|{{ d }}{% endmacro %} |
|||
{{ m() }}|{{ m('a') }}|{{ m('a', 'b') }}|{{ m(1, 2, 3) }}''') |
|||
assert tmpl.render() == '||c|d|a||c|d|a|b|c|d|1|2|3|d' |
|||
|
|||
def test_arguments_defaults_nonsense(self, env_trim): |
|||
pytest.raises(TemplateSyntaxError, env_trim.from_string, '''\ |
|||
{% macro m(a, b=1, c) %}a={{ a }}, b={{ b }}, c={{ c }}{% endmacro %}''') |
|||
|
|||
def test_caller_defaults_nonsense(self, env_trim): |
|||
pytest.raises(TemplateSyntaxError, env_trim.from_string, '''\ |
|||
{% macro a() %}{{ caller() }}{% endmacro %} |
|||
{% call(x, y=1, z) a() %}{% endcall %}''') |
|||
|
|||
def test_varargs(self, env_trim): |
|||
tmpl = env_trim.from_string('''\ |
|||
{% macro test() %}{{ varargs|join('|') }}{% endmacro %}\ |
|||
{{ test(1, 2, 3) }}''') |
|||
assert tmpl.render() == '1|2|3' |
|||
|
|||
def test_simple_call(self, env_trim): |
|||
tmpl = env_trim.from_string('''\ |
|||
{% macro test() %}[[{{ caller() }}]]{% endmacro %}\ |
|||
{% call test() %}data{% endcall %}''') |
|||
assert tmpl.render() == '[[data]]' |
|||
|
|||
def test_complex_call(self, env_trim): |
|||
tmpl = env_trim.from_string('''\ |
|||
{% macro test() %}[[{{ caller('data') }}]]{% endmacro %}\ |
|||
{% call(data) test() %}{{ data }}{% endcall %}''') |
|||
assert tmpl.render() == '[[data]]' |
|||
|
|||
def test_caller_undefined(self, env_trim): |
|||
tmpl = env_trim.from_string('''\ |
|||
{% set caller = 42 %}\ |
|||
{% macro test() %}{{ caller is not defined }}{% endmacro %}\ |
|||
{{ test() }}''') |
|||
assert tmpl.render() == 'True' |
|||
|
|||
def test_include(self, env_trim): |
|||
env_trim = Environment( |
|||
loader=DictLoader({ |
|||
'include': '{% macro test(foo) %}[{{ foo }}]{% endmacro %}' |
|||
}) |
|||
) |
|||
tmpl = env_trim.from_string( |
|||
'{% from "include" import test %}{{ test("foo") }}') |
|||
assert tmpl.render() == '[foo]' |
|||
|
|||
def test_macro_api(self, env_trim): |
|||
tmpl = env_trim.from_string( |
|||
'{% macro foo(a, b) %}{% endmacro %}' |
|||
'{% macro bar() %}{{ varargs }}{{ kwargs }}{% endmacro %}' |
|||
'{% macro baz() %}{{ caller() }}{% endmacro %}') |
|||
assert tmpl.module.foo.arguments == ('a', 'b') |
|||
assert tmpl.module.foo.defaults == () |
|||
assert tmpl.module.foo.name == 'foo' |
|||
assert not tmpl.module.foo.caller |
|||
assert not tmpl.module.foo.catch_kwargs |
|||
assert not tmpl.module.foo.catch_varargs |
|||
assert tmpl.module.bar.arguments == () |
|||
assert tmpl.module.bar.defaults == () |
|||
assert not tmpl.module.bar.caller |
|||
assert tmpl.module.bar.catch_kwargs |
|||
assert tmpl.module.bar.catch_varargs |
|||
assert tmpl.module.baz.caller |
|||
|
|||
def test_callself(self, env_trim): |
|||
tmpl = env_trim.from_string('{% macro foo(x) %}{{ x }}{% if x > 1 %}|' |
|||
'{{ foo(x - 1) }}{% endif %}{% endmacro %}' |
|||
'{{ foo(5) }}') |
|||
assert tmpl.render() == '5|4|3|2|1' |
|||
|
|||
|
|||
@pytest.mark.core_tags |
|||
@pytest.mark.set |
|||
class TestSet(): |
|||
|
|||
def test_normal(self, env_trim): |
|||
tmpl = env_trim.from_string('{% set foo = 1 %}{{ foo }}') |
|||
assert tmpl.render() == '1' |
|||
assert tmpl.module.foo == 1 |
|||
|
|||
def test_block(self, env_trim): |
|||
tmpl = env_trim.from_string('{% set foo %}42{% endset %}{{ foo }}') |
|||
assert tmpl.render() == '42' |
|||
assert tmpl.module.foo == u'42' |
|||
@ -1,73 +0,0 @@ |
|||
# -*- coding: utf-8 -*- |
|||
""" |
|||
jinja2.testsuite.debug |
|||
~~~~~~~~~~~~~~~~~~~~~~ |
|||
|
|||
Tests the debug system. |
|||
|
|||
:copyright: (c) 2010 by the Jinja Team. |
|||
:license: BSD, see LICENSE for more details. |
|||
""" |
|||
import pytest |
|||
|
|||
import re |
|||
|
|||
import sys |
|||
from traceback import format_exception |
|||
|
|||
from jinja2 import Environment, TemplateSyntaxError |
|||
from traceback import format_exception |
|||
|
|||
|
|||
@pytest.fixture |
|||
def fs_env(filesystem_loader): |
|||
'''returns a new environment. |
|||
''' |
|||
return Environment(loader=filesystem_loader) |
|||
|
|||
|
|||
@pytest.mark.debug |
|||
class TestDebug(): |
|||
|
|||
def assert_traceback_matches(self, callback, expected_tb): |
|||
try: |
|||
callback() |
|||
except Exception as e: |
|||
tb = format_exception(*sys.exc_info()) |
|||
if re.search(expected_tb.strip(), ''.join(tb)) is None: |
|||
assert False, ('Traceback did not match:\n\n%s\nexpected:\n%s' % |
|||
(''.join(tb), expected_tb)) |
|||
else: |
|||
assert False, 'Expected exception' |
|||
|
|||
def test_runtime_error(self, fs_env): |
|||
def test(): |
|||
tmpl.render(fail=lambda: 1 / 0) |
|||
tmpl = fs_env.get_template('broken.html') |
|||
self.assert_traceback_matches(test, r''' |
|||
File ".*?broken.html", line 2, in (top-level template code|<module>) |
|||
\{\{ fail\(\) \}\} |
|||
File ".*debug?.pyc?", line \d+, in <lambda> |
|||
tmpl\.render\(fail=lambda: 1 / 0\) |
|||
ZeroDivisionError: (int(eger)? )?division (or modulo )?by zero |
|||
''') |
|||
|
|||
def test_syntax_error(self, fs_env): |
|||
# XXX: the .*? is necessary for python3 which does not hide |
|||
# some of the stack frames we don't want to show. Not sure |
|||
# what's up with that, but that is not that critical. Should |
|||
# be fixed though. |
|||
self.assert_traceback_matches(lambda: fs_env.get_template('syntaxerror.html'), r'''(?sm) |
|||
File ".*?syntaxerror.html", line 4, in (template|<module>) |
|||
\{% endif %\}.*? |
|||
(jinja2\.exceptions\.)?TemplateSyntaxError: Encountered unknown tag 'endif'. Jinja was looking for the following tags: 'endfor' or 'else'. The innermost block that needs to be closed is 'for'. |
|||
''') |
|||
|
|||
def test_regular_syntax_error(self, fs_env): |
|||
def test(): |
|||
raise TemplateSyntaxError('wtf', 42) |
|||
self.assert_traceback_matches(test, r''' |
|||
File ".*debug.pyc?", line \d+, in test |
|||
raise TemplateSyntaxError\('wtf', 42\) |
|||
(jinja2\.exceptions\.)?TemplateSyntaxError: wtf |
|||
line 42''') |
|||
@ -1,467 +0,0 @@ |
|||
# -*- coding: utf-8 -*- |
|||
""" |
|||
jinja2.testsuite.ext |
|||
~~~~~~~~~~~~~~~~~~~~ |
|||
|
|||
Tests for the extensions. |
|||
|
|||
:copyright: (c) 2010 by the Jinja Team. |
|||
:license: BSD, see LICENSE for more details. |
|||
""" |
|||
import re |
|||
import pytest |
|||
|
|||
from jinja2 import Environment, DictLoader, contextfunction, nodes |
|||
from jinja2.exceptions import TemplateAssertionError |
|||
from jinja2.ext import Extension |
|||
from jinja2.lexer import Token, count_newlines |
|||
from jinja2._compat import BytesIO, itervalues, text_type |
|||
|
|||
importable_object = 23 |
|||
|
|||
_gettext_re = re.compile(r'_\((.*?)\)(?s)') |
|||
|
|||
|
|||
i18n_templates = { |
|||
'master.html': '<title>{{ page_title|default(_("missing")) }}</title>' |
|||
'{% block body %}{% endblock %}', |
|||
'child.html': '{% extends "master.html" %}{% block body %}' |
|||
'{% trans %}watch out{% endtrans %}{% endblock %}', |
|||
'plural.html': '{% trans user_count %}One user online{% pluralize %}' |
|||
'{{ user_count }} users online{% endtrans %}', |
|||
'plural2.html': '{% trans user_count=get_user_count() %}{{ user_count }}s' |
|||
'{% pluralize %}{{ user_count }}p{% endtrans %}', |
|||
'stringformat.html': '{{ _("User: %(num)s")|format(num=user_count) }}' |
|||
} |
|||
|
|||
newstyle_i18n_templates = { |
|||
'master.html': '<title>{{ page_title|default(_("missing")) }}</title>' |
|||
'{% block body %}{% endblock %}', |
|||
'child.html': '{% extends "master.html" %}{% block body %}' |
|||
'{% trans %}watch out{% endtrans %}{% endblock %}', |
|||
'plural.html': '{% trans user_count %}One user online{% pluralize %}' |
|||
'{{ user_count }} users online{% endtrans %}', |
|||
'stringformat.html': '{{ _("User: %(num)s", num=user_count) }}', |
|||
'ngettext.html': '{{ ngettext("%(num)s apple", "%(num)s apples", apples) }}', |
|||
'ngettext_long.html': '{% trans num=apples %}{{ num }} apple{% pluralize %}' |
|||
'{{ num }} apples{% endtrans %}', |
|||
'transvars1.html': '{% trans %}User: {{ num }}{% endtrans %}', |
|||
'transvars2.html': '{% trans num=count %}User: {{ num }}{% endtrans %}', |
|||
'transvars3.html': '{% trans count=num %}User: {{ count }}{% endtrans %}', |
|||
'novars.html': '{% trans %}%(hello)s{% endtrans %}', |
|||
'vars.html': '{% trans %}{{ foo }}%(foo)s{% endtrans %}', |
|||
'explicitvars.html': '{% trans foo="42" %}%(foo)s{% endtrans %}' |
|||
} |
|||
|
|||
|
|||
languages = { |
|||
'de': { |
|||
'missing': u'fehlend', |
|||
'watch out': u'pass auf', |
|||
'One user online': u'Ein Benutzer online', |
|||
'%(user_count)s users online': u'%(user_count)s Benutzer online', |
|||
'User: %(num)s': u'Benutzer: %(num)s', |
|||
'User: %(count)s': u'Benutzer: %(count)s', |
|||
'%(num)s apple': u'%(num)s Apfel', |
|||
'%(num)s apples': u'%(num)s Äpfel' |
|||
} |
|||
} |
|||
|
|||
|
|||
@contextfunction |
|||
def gettext(context, string): |
|||
language = context.get('LANGUAGE', 'en') |
|||
return languages.get(language, {}).get(string, string) |
|||
|
|||
|
|||
@contextfunction |
|||
def ngettext(context, s, p, n): |
|||
language = context.get('LANGUAGE', 'en') |
|||
if n != 1: |
|||
return languages.get(language, {}).get(p, p) |
|||
return languages.get(language, {}).get(s, s) |
|||
|
|||
|
|||
i18n_env = Environment( |
|||
loader=DictLoader(i18n_templates), |
|||
extensions=['jinja2.ext.i18n'] |
|||
) |
|||
i18n_env.globals.update({ |
|||
'_': gettext, |
|||
'gettext': gettext, |
|||
'ngettext': ngettext |
|||
}) |
|||
|
|||
newstyle_i18n_env = Environment( |
|||
loader=DictLoader(newstyle_i18n_templates), |
|||
extensions=['jinja2.ext.i18n'] |
|||
) |
|||
newstyle_i18n_env.install_gettext_callables(gettext, ngettext, newstyle=True) |
|||
|
|||
|
|||
class TestExtension(Extension): |
|||
tags = set(['test']) |
|||
ext_attr = 42 |
|||
|
|||
def parse(self, parser): |
|||
return nodes.Output([self.call_method('_dump', [ |
|||
nodes.EnvironmentAttribute('sandboxed'), |
|||
self.attr('ext_attr'), |
|||
nodes.ImportedName(__name__ + '.importable_object'), |
|||
nodes.ContextReference() |
|||
])]).set_lineno(next(parser.stream).lineno) |
|||
|
|||
def _dump(self, sandboxed, ext_attr, imported_object, context): |
|||
return '%s|%s|%s|%s' % ( |
|||
sandboxed, |
|||
ext_attr, |
|||
imported_object, |
|||
context.blocks |
|||
) |
|||
|
|||
|
|||
class PreprocessorExtension(Extension): |
|||
|
|||
def preprocess(self, source, name, filename=None): |
|||
return source.replace('[[TEST]]', '({{ foo }})') |
|||
|
|||
|
|||
class StreamFilterExtension(Extension): |
|||
|
|||
def filter_stream(self, stream): |
|||
for token in stream: |
|||
if token.type == 'data': |
|||
for t in self.interpolate(token): |
|||
yield t |
|||
else: |
|||
yield token |
|||
|
|||
def interpolate(self, token): |
|||
pos = 0 |
|||
end = len(token.value) |
|||
lineno = token.lineno |
|||
while 1: |
|||
match = _gettext_re.search(token.value, pos) |
|||
if match is None: |
|||
break |
|||
value = token.value[pos:match.start()] |
|||
if value: |
|||
yield Token(lineno, 'data', value) |
|||
lineno += count_newlines(token.value) |
|||
yield Token(lineno, 'variable_begin', None) |
|||
yield Token(lineno, 'name', 'gettext') |
|||
yield Token(lineno, 'lparen', None) |
|||
yield Token(lineno, 'string', match.group(1)) |
|||
yield Token(lineno, 'rparen', None) |
|||
yield Token(lineno, 'variable_end', None) |
|||
pos = match.end() |
|||
if pos < end: |
|||
yield Token(lineno, 'data', token.value[pos:]) |
|||
|
|||
|
|||
@pytest.mark.ext |
|||
class TestExtensions(): |
|||
|
|||
def test_extend_late(self): |
|||
env = Environment() |
|||
env.add_extension('jinja2.ext.autoescape') |
|||
t = env.from_string( |
|||
'{% autoescape true %}{{ "<test>" }}{% endautoescape %}') |
|||
assert t.render() == '<test>' |
|||
|
|||
def test_loop_controls(self): |
|||
env = Environment(extensions=['jinja2.ext.loopcontrols']) |
|||
|
|||
tmpl = env.from_string(''' |
|||
{%- for item in [1, 2, 3, 4] %} |
|||
{%- if item % 2 == 0 %}{% continue %}{% endif -%} |
|||
{{ item }} |
|||
{%- endfor %}''') |
|||
assert tmpl.render() == '13' |
|||
|
|||
tmpl = env.from_string(''' |
|||
{%- for item in [1, 2, 3, 4] %} |
|||
{%- if item > 2 %}{% break %}{% endif -%} |
|||
{{ item }} |
|||
{%- endfor %}''') |
|||
assert tmpl.render() == '12' |
|||
|
|||
def test_do(self): |
|||
env = Environment(extensions=['jinja2.ext.do']) |
|||
tmpl = env.from_string(''' |
|||
{%- set items = [] %} |
|||
{%- for char in "foo" %} |
|||
{%- do items.append(loop.index0 ~ char) %} |
|||
{%- endfor %}{{ items|join(', ') }}''') |
|||
assert tmpl.render() == '0f, 1o, 2o' |
|||
|
|||
def test_with(self): |
|||
env = Environment(extensions=['jinja2.ext.with_']) |
|||
tmpl = env.from_string('''\ |
|||
{% with a=42, b=23 -%} |
|||
{{ a }} = {{ b }} |
|||
{% endwith -%} |
|||
{{ a }} = {{ b }}\ |
|||
''') |
|||
assert [x.strip() for x in tmpl.render(a=1, b=2).splitlines()] \ |
|||
== ['42 = 23', '1 = 2'] |
|||
|
|||
def test_extension_nodes(self): |
|||
env = Environment(extensions=[TestExtension]) |
|||
tmpl = env.from_string('{% test %}') |
|||
assert tmpl.render() == 'False|42|23|{}' |
|||
|
|||
def test_identifier(self): |
|||
assert TestExtension.identifier == __name__ + '.TestExtension' |
|||
|
|||
def test_rebinding(self): |
|||
original = Environment(extensions=[TestExtension]) |
|||
overlay = original.overlay() |
|||
for env in original, overlay: |
|||
for ext in itervalues(env.extensions): |
|||
assert ext.environment is env |
|||
|
|||
def test_preprocessor_extension(self): |
|||
env = Environment(extensions=[PreprocessorExtension]) |
|||
tmpl = env.from_string('{[[TEST]]}') |
|||
assert tmpl.render(foo=42) == '{(42)}' |
|||
|
|||
def test_streamfilter_extension(self): |
|||
env = Environment(extensions=[StreamFilterExtension]) |
|||
env.globals['gettext'] = lambda x: x.upper() |
|||
tmpl = env.from_string('Foo _(bar) Baz') |
|||
out = tmpl.render() |
|||
assert out == 'Foo BAR Baz' |
|||
|
|||
def test_extension_ordering(self): |
|||
class T1(Extension): |
|||
priority = 1 |
|||
|
|||
class T2(Extension): |
|||
priority = 2 |
|||
env = Environment(extensions=[T1, T2]) |
|||
ext = list(env.iter_extensions()) |
|||
assert ext[0].__class__ is T1 |
|||
assert ext[1].__class__ is T2 |
|||
|
|||
|
|||
@pytest.mark.ext |
|||
class TestInternationalization(): |
|||
|
|||
def test_trans(self): |
|||
tmpl = i18n_env.get_template('child.html') |
|||
assert tmpl.render(LANGUAGE='de') == '<title>fehlend</title>pass auf' |
|||
|
|||
def test_trans_plural(self): |
|||
tmpl = i18n_env.get_template('plural.html') |
|||
assert tmpl.render(LANGUAGE='de', user_count=1) \ |
|||
== 'Ein Benutzer online' |
|||
assert tmpl.render(LANGUAGE='de', user_count=2) == '2 Benutzer online' |
|||
|
|||
def test_trans_plural_with_functions(self): |
|||
tmpl = i18n_env.get_template('plural2.html') |
|||
|
|||
def get_user_count(): |
|||
get_user_count.called += 1 |
|||
return 1 |
|||
get_user_count.called = 0 |
|||
assert tmpl.render(LANGUAGE='de', get_user_count=get_user_count) \ |
|||
== '1s' |
|||
assert get_user_count.called == 1 |
|||
|
|||
def test_complex_plural(self): |
|||
tmpl = i18n_env.from_string( |
|||
'{% trans foo=42, count=2 %}{{ count }} item{% ' |
|||
'pluralize count %}{{ count }} items{% endtrans %}') |
|||
assert tmpl.render() == '2 items' |
|||
pytest.raises(TemplateAssertionError, i18n_env.from_string, |
|||
'{% trans foo %}...{% pluralize bar %}...{% endtrans %}') |
|||
|
|||
def test_trans_stringformatting(self): |
|||
tmpl = i18n_env.get_template('stringformat.html') |
|||
assert tmpl.render(LANGUAGE='de', user_count=5) == 'Benutzer: 5' |
|||
|
|||
def test_extract(self): |
|||
from jinja2.ext import babel_extract |
|||
source = BytesIO(''' |
|||
{{ gettext('Hello World') }} |
|||
{% trans %}Hello World{% endtrans %} |
|||
{% trans %}{{ users }} user{% pluralize %}{{ users }} users{% endtrans %} |
|||
'''.encode('ascii')) # make python 3 happy |
|||
assert list(babel_extract(source, |
|||
('gettext', 'ngettext', '_'), [], {})) == [ |
|||
(2, 'gettext', u'Hello World', []), |
|||
(3, 'gettext', u'Hello World', []), |
|||
(4, 'ngettext', (u'%(users)s user', u'%(users)s users', None), []) |
|||
] |
|||
|
|||
def test_comment_extract(self): |
|||
from jinja2.ext import babel_extract |
|||
source = BytesIO(''' |
|||
{# trans first #} |
|||
{{ gettext('Hello World') }} |
|||
{% trans %}Hello World{% endtrans %}{# trans second #} |
|||
{#: third #} |
|||
{% trans %}{{ users }} user{% pluralize %}{{ users }} users{% endtrans %} |
|||
'''.encode('utf-8')) # make python 3 happy |
|||
assert list(babel_extract(source, |
|||
('gettext', 'ngettext', '_'), |
|||
['trans', ':'], {})) == [ |
|||
(3, 'gettext', u'Hello World', ['first']), |
|||
(4, 'gettext', u'Hello World', ['second']), |
|||
(6, 'ngettext', (u'%(users)s user', u'%(users)s users', None), |
|||
['third']) |
|||
] |
|||
|
|||
|
|||
@pytest.mark.ext |
|||
class TestNewstyleInternationalization(): |
|||
|
|||
def test_trans(self): |
|||
tmpl = newstyle_i18n_env.get_template('child.html') |
|||
assert tmpl.render(LANGUAGE='de') == '<title>fehlend</title>pass auf' |
|||
|
|||
def test_trans_plural(self): |
|||
tmpl = newstyle_i18n_env.get_template('plural.html') |
|||
assert tmpl.render(LANGUAGE='de', user_count=1) \ |
|||
== 'Ein Benutzer online' |
|||
assert tmpl.render(LANGUAGE='de', user_count=2) == '2 Benutzer online' |
|||
|
|||
def test_complex_plural(self): |
|||
tmpl = newstyle_i18n_env.from_string( |
|||
'{% trans foo=42, count=2 %}{{ count }} item{% ' |
|||
'pluralize count %}{{ count }} items{% endtrans %}') |
|||
assert tmpl.render() == '2 items' |
|||
pytest.raises(TemplateAssertionError, i18n_env.from_string, |
|||
'{% trans foo %}...{% pluralize bar %}...{% endtrans %}') |
|||
|
|||
def test_trans_stringformatting(self): |
|||
tmpl = newstyle_i18n_env.get_template('stringformat.html') |
|||
assert tmpl.render(LANGUAGE='de', user_count=5) == 'Benutzer: 5' |
|||
|
|||
def test_newstyle_plural(self): |
|||
tmpl = newstyle_i18n_env.get_template('ngettext.html') |
|||
assert tmpl.render(LANGUAGE='de', apples=1) == '1 Apfel' |
|||
assert tmpl.render(LANGUAGE='de', apples=5) == u'5 Äpfel' |
|||
|
|||
def test_autoescape_support(self): |
|||
env = Environment(extensions=['jinja2.ext.autoescape', |
|||
'jinja2.ext.i18n']) |
|||
env.install_gettext_callables( |
|||
lambda x: u'<strong>Wert: %(name)s</strong>', |
|||
lambda s, p, n: s, newstyle=True) |
|||
t = env.from_string('{% autoescape ae %}{{ gettext("foo", name=' |
|||
'"<test>") }}{% endautoescape %}') |
|||
assert t.render(ae=True) == '<strong>Wert: <test></strong>' |
|||
assert t.render(ae=False) == '<strong>Wert: <test></strong>' |
|||
|
|||
def test_num_used_twice(self): |
|||
tmpl = newstyle_i18n_env.get_template('ngettext_long.html') |
|||
assert tmpl.render(apples=5, LANGUAGE='de') == u'5 Äpfel' |
|||
|
|||
def test_num_called_num(self): |
|||
source = newstyle_i18n_env.compile(''' |
|||
{% trans num=3 %}{{ num }} apple{% pluralize |
|||
%}{{ num }} apples{% endtrans %} |
|||
''', raw=True) |
|||
# quite hacky, but the only way to properly test that. The idea is |
|||
# that the generated code does not pass num twice (although that |
|||
# would work) for better performance. This only works on the |
|||
# newstyle gettext of course |
|||
assert re.search(r"l_ngettext, u?'\%\(num\)s apple', u?'\%\(num\)s " |
|||
r"apples', 3", source) is not None |
|||
|
|||
def test_trans_vars(self): |
|||
t1 = newstyle_i18n_env.get_template('transvars1.html') |
|||
t2 = newstyle_i18n_env.get_template('transvars2.html') |
|||
t3 = newstyle_i18n_env.get_template('transvars3.html') |
|||
assert t1.render(num=1, LANGUAGE='de') == 'Benutzer: 1' |
|||
assert t2.render(count=23, LANGUAGE='de') == 'Benutzer: 23' |
|||
assert t3.render(num=42, LANGUAGE='de') == 'Benutzer: 42' |
|||
|
|||
def test_novars_vars_escaping(self): |
|||
t = newstyle_i18n_env.get_template('novars.html') |
|||
assert t.render() == '%(hello)s' |
|||
t = newstyle_i18n_env.get_template('vars.html') |
|||
assert t.render(foo='42') == '42%(foo)s' |
|||
t = newstyle_i18n_env.get_template('explicitvars.html') |
|||
assert t.render() == '%(foo)s' |
|||
|
|||
|
|||
@pytest.mark.ext |
|||
class TestAutoEscape(): |
|||
|
|||
def test_scoped_setting(self): |
|||
env = Environment(extensions=['jinja2.ext.autoescape'], |
|||
autoescape=True) |
|||
tmpl = env.from_string(''' |
|||
{{ "<HelloWorld>" }} |
|||
{% autoescape false %} |
|||
{{ "<HelloWorld>" }} |
|||
{% endautoescape %} |
|||
{{ "<HelloWorld>" }} |
|||
''') |
|||
assert tmpl.render().split() == \ |
|||
[u'<HelloWorld>', u'<HelloWorld>', u'<HelloWorld>'] |
|||
|
|||
env = Environment(extensions=['jinja2.ext.autoescape'], |
|||
autoescape=False) |
|||
tmpl = env.from_string(''' |
|||
{{ "<HelloWorld>" }} |
|||
{% autoescape true %} |
|||
{{ "<HelloWorld>" }} |
|||
{% endautoescape %} |
|||
{{ "<HelloWorld>" }} |
|||
''') |
|||
assert tmpl.render().split() == \ |
|||
[u'<HelloWorld>', u'<HelloWorld>', u'<HelloWorld>'] |
|||
|
|||
def test_nonvolatile(self): |
|||
env = Environment(extensions=['jinja2.ext.autoescape'], |
|||
autoescape=True) |
|||
tmpl = env.from_string('{{ {"foo": "<test>"}|xmlattr|escape }}') |
|||
assert tmpl.render() == ' foo="<test>"' |
|||
tmpl = env.from_string('{% autoescape false %}{{ {"foo": "<test>"}' |
|||
'|xmlattr|escape }}{% endautoescape %}') |
|||
assert tmpl.render() == ' foo="&lt;test&gt;"' |
|||
|
|||
def test_volatile(self): |
|||
env = Environment(extensions=['jinja2.ext.autoescape'], |
|||
autoescape=True) |
|||
tmpl = env.from_string('{% autoescape foo %}{{ {"foo": "<test>"}' |
|||
'|xmlattr|escape }}{% endautoescape %}') |
|||
assert tmpl.render(foo=False) == ' foo="&lt;test&gt;"' |
|||
assert tmpl.render(foo=True) == ' foo="<test>"' |
|||
|
|||
def test_scoping(self): |
|||
env = Environment(extensions=['jinja2.ext.autoescape']) |
|||
tmpl = env.from_string( |
|||
'{% autoescape true %}{% set x = "<x>" %}{{ x }}' |
|||
'{% endautoescape %}{{ x }}{{ "<y>" }}') |
|||
assert tmpl.render(x=1) == '<x>1<y>' |
|||
|
|||
def test_volatile_scoping(self): |
|||
env = Environment(extensions=['jinja2.ext.autoescape']) |
|||
tmplsource = ''' |
|||
{% autoescape val %} |
|||
{% macro foo(x) %} |
|||
[{{ x }}] |
|||
{% endmacro %} |
|||
{{ foo().__class__.__name__ }} |
|||
{% endautoescape %} |
|||
{{ '<testing>' }} |
|||
''' |
|||
tmpl = env.from_string(tmplsource) |
|||
assert tmpl.render(val=True).split()[0] == 'Markup' |
|||
assert tmpl.render(val=False).split()[0] == text_type.__name__ |
|||
|
|||
# looking at the source we should see <testing> there in raw |
|||
# (and then escaped as well) |
|||
env = Environment(extensions=['jinja2.ext.autoescape']) |
|||
pysource = env.compile(tmplsource, raw=True) |
|||
assert '<testing>\\n' in pysource |
|||
|
|||
env = Environment(extensions=['jinja2.ext.autoescape'], |
|||
autoescape=True) |
|||
pysource = env.compile(tmplsource, raw=True) |
|||
assert '<testing>\\n' in pysource |
|||
@ -1,558 +0,0 @@ |
|||
# -*- coding: utf-8 -*- |
|||
""" |
|||
jinja2.testsuite.filters |
|||
~~~~~~~~~~~~~~~~~~~~~~~~ |
|||
|
|||
Tests for the jinja filters. |
|||
|
|||
:copyright: (c) 2010 by the Jinja Team. |
|||
:license: BSD, see LICENSE for more details. |
|||
""" |
|||
import pytest |
|||
from jinja2 import Markup, Environment |
|||
from jinja2._compat import text_type, implements_to_string |
|||
|
|||
|
|||
@pytest.mark.filter |
|||
class TestFilter(): |
|||
|
|||
def test_filter_calling(self, env): |
|||
rv = env.call_filter('sum', [1, 2, 3]) |
|||
assert rv == 6 |
|||
|
|||
def test_capitalize(self, env): |
|||
tmpl = env.from_string('{{ "foo bar"|capitalize }}') |
|||
assert tmpl.render() == 'Foo bar' |
|||
|
|||
def test_center(self, env): |
|||
tmpl = env.from_string('{{ "foo"|center(9) }}') |
|||
assert tmpl.render() == ' foo ' |
|||
|
|||
def test_default(self, env): |
|||
tmpl = env.from_string( |
|||
"{{ missing|default('no') }}|{{ false|default('no') }}|" |
|||
"{{ false|default('no', true) }}|{{ given|default('no') }}" |
|||
) |
|||
assert tmpl.render(given='yes') == 'no|False|no|yes' |
|||
|
|||
def test_dictsort(self, env): |
|||
tmpl = env.from_string( |
|||
'{{ foo|dictsort }}|' |
|||
'{{ foo|dictsort(true) }}|' |
|||
'{{ foo|dictsort(false, "value") }}' |
|||
) |
|||
out = tmpl.render(foo={"aa": 0, "b": 1, "c": 2, "AB": 3}) |
|||
assert out == ("[('aa', 0), ('AB', 3), ('b', 1), ('c', 2)]|" |
|||
"[('AB', 3), ('aa', 0), ('b', 1), ('c', 2)]|" |
|||
"[('aa', 0), ('b', 1), ('c', 2), ('AB', 3)]") |
|||
|
|||
def test_batch(self, env): |
|||
tmpl = env.from_string("{{ foo|batch(3)|list }}|" |
|||
"{{ foo|batch(3, 'X')|list }}") |
|||
out = tmpl.render(foo=list(range(10))) |
|||
assert out == ("[[0, 1, 2], [3, 4, 5], [6, 7, 8], [9]]|" |
|||
"[[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 'X', 'X']]") |
|||
|
|||
def test_slice(self, env): |
|||
tmpl = env.from_string('{{ foo|slice(3)|list }}|' |
|||
'{{ foo|slice(3, "X")|list }}') |
|||
out = tmpl.render(foo=list(range(10))) |
|||
assert out == ("[[0, 1, 2, 3], [4, 5, 6], [7, 8, 9]]|" |
|||
"[[0, 1, 2, 3], [4, 5, 6, 'X'], [7, 8, 9, 'X']]") |
|||
|
|||
def test_escape(self, env): |
|||
tmpl = env.from_string('''{{ '<">&'|escape }}''') |
|||
out = tmpl.render() |
|||
assert out == '<">&' |
|||
|
|||
def test_striptags(self, env): |
|||
tmpl = env.from_string('''{{ foo|striptags }}''') |
|||
out = tmpl.render(foo=' <p>just a small \n <a href="#">' |
|||
'example</a> link</p>\n<p>to a webpage</p> ' |
|||
'<!-- <p>and some commented stuff</p> -->') |
|||
assert out == 'just a small example link to a webpage' |
|||
|
|||
def test_filesizeformat(self, env): |
|||
tmpl = env.from_string( |
|||
'{{ 100|filesizeformat }}|' |
|||
'{{ 1000|filesizeformat }}|' |
|||
'{{ 1000000|filesizeformat }}|' |
|||
'{{ 1000000000|filesizeformat }}|' |
|||
'{{ 1000000000000|filesizeformat }}|' |
|||
'{{ 100|filesizeformat(true) }}|' |
|||
'{{ 1000|filesizeformat(true) }}|' |
|||
'{{ 1000000|filesizeformat(true) }}|' |
|||
'{{ 1000000000|filesizeformat(true) }}|' |
|||
'{{ 1000000000000|filesizeformat(true) }}' |
|||
) |
|||
out = tmpl.render() |
|||
assert out == ( |
|||
'100 Bytes|1.0 kB|1.0 MB|1.0 GB|1.0 TB|100 Bytes|' |
|||
'1000 Bytes|976.6 KiB|953.7 MiB|931.3 GiB' |
|||
) |
|||
|
|||
def test_filesizeformat_issue59(self, env): |
|||
tmpl = env.from_string( |
|||
'{{ 300|filesizeformat }}|' |
|||
'{{ 3000|filesizeformat }}|' |
|||
'{{ 3000000|filesizeformat }}|' |
|||
'{{ 3000000000|filesizeformat }}|' |
|||
'{{ 3000000000000|filesizeformat }}|' |
|||
'{{ 300|filesizeformat(true) }}|' |
|||
'{{ 3000|filesizeformat(true) }}|' |
|||
'{{ 3000000|filesizeformat(true) }}' |
|||
) |
|||
out = tmpl.render() |
|||
assert out == ( |
|||
'300 Bytes|3.0 kB|3.0 MB|3.0 GB|3.0 TB|300 Bytes|' |
|||
'2.9 KiB|2.9 MiB' |
|||
) |
|||
|
|||
def test_first(self, env): |
|||
tmpl = env.from_string('{{ foo|first }}') |
|||
out = tmpl.render(foo=list(range(10))) |
|||
assert out == '0' |
|||
|
|||
def test_float(self, env): |
|||
tmpl = env.from_string('{{ "42"|float }}|' |
|||
'{{ "ajsghasjgd"|float }}|' |
|||
'{{ "32.32"|float }}') |
|||
out = tmpl.render() |
|||
assert out == '42.0|0.0|32.32' |
|||
|
|||
def test_format(self, env): |
|||
tmpl = env.from_string('''{{ "%s|%s"|format("a", "b") }}''') |
|||
out = tmpl.render() |
|||
assert out == 'a|b' |
|||
|
|||
def test_indent(self, env): |
|||
tmpl = env.from_string('{{ foo|indent(2) }}|{{ foo|indent(2, true) }}') |
|||
text = '\n'.join([' '.join(['foo', 'bar'] * 2)] * 2) |
|||
out = tmpl.render(foo=text) |
|||
assert out == ('foo bar foo bar\n foo bar foo bar| ' |
|||
'foo bar foo bar\n foo bar foo bar') |
|||
|
|||
def test_int(self, env): |
|||
tmpl = env.from_string('{{ "42"|int }}|{{ "ajsghasjgd"|int }}|' |
|||
'{{ "32.32"|int }}|{{ "0x4d32"|int(0, 16) }}|' |
|||
'{{ "011"|int(0, 8)}}|{{ "0x33FU"|int(0, 16) }}') |
|||
out = tmpl.render() |
|||
assert out == '42|0|32|19762|9|0' |
|||
|
|||
def test_join(self, env): |
|||
tmpl = env.from_string('{{ [1, 2, 3]|join("|") }}') |
|||
out = tmpl.render() |
|||
assert out == '1|2|3' |
|||
|
|||
env2 = Environment(autoescape=True) |
|||
tmpl = env2.from_string( |
|||
'{{ ["<foo>", "<span>foo</span>"|safe]|join }}') |
|||
assert tmpl.render() == '<foo><span>foo</span>' |
|||
|
|||
def test_join_attribute(self, env): |
|||
class User(object): |
|||
def __init__(self, username): |
|||
self.username = username |
|||
tmpl = env.from_string('''{{ users|join(', ', 'username') }}''') |
|||
assert tmpl.render(users=map(User, ['foo', 'bar'])) == 'foo, bar' |
|||
|
|||
def test_last(self, env): |
|||
tmpl = env.from_string('''{{ foo|last }}''') |
|||
out = tmpl.render(foo=list(range(10))) |
|||
assert out == '9' |
|||
|
|||
def test_length(self, env): |
|||
tmpl = env.from_string('''{{ "hello world"|length }}''') |
|||
out = tmpl.render() |
|||
assert out == '11' |
|||
|
|||
def test_lower(self, env): |
|||
tmpl = env.from_string('''{{ "FOO"|lower }}''') |
|||
out = tmpl.render() |
|||
assert out == 'foo' |
|||
|
|||
def test_pprint(self, env): |
|||
from pprint import pformat |
|||
tmpl = env.from_string('''{{ data|pprint }}''') |
|||
data = list(range(1000)) |
|||
assert tmpl.render(data=data) == pformat(data) |
|||
|
|||
def test_random(self, env): |
|||
tmpl = env.from_string('''{{ seq|random }}''') |
|||
seq = list(range(100)) |
|||
for _ in range(10): |
|||
assert int(tmpl.render(seq=seq)) in seq |
|||
|
|||
def test_reverse(self, env): |
|||
tmpl = env.from_string('{{ "foobar"|reverse|join }}|' |
|||
'{{ [1, 2, 3]|reverse|list }}') |
|||
assert tmpl.render() == 'raboof|[3, 2, 1]' |
|||
|
|||
def test_string(self, env): |
|||
x = [1, 2, 3, 4, 5] |
|||
tmpl = env.from_string('''{{ obj|string }}''') |
|||
assert tmpl.render(obj=x) == text_type(x) |
|||
|
|||
def test_title(self, env): |
|||
tmpl = env.from_string('''{{ "foo bar"|title }}''') |
|||
assert tmpl.render() == "Foo Bar" |
|||
tmpl = env.from_string('''{{ "foo's bar"|title }}''') |
|||
assert tmpl.render() == "Foo's Bar" |
|||
tmpl = env.from_string('''{{ "foo bar"|title }}''') |
|||
assert tmpl.render() == "Foo Bar" |
|||
tmpl = env.from_string('''{{ "f bar f"|title }}''') |
|||
assert tmpl.render() == "F Bar F" |
|||
tmpl = env.from_string('''{{ "foo-bar"|title }}''') |
|||
assert tmpl.render() == "Foo-Bar" |
|||
tmpl = env.from_string('''{{ "foo\tbar"|title }}''') |
|||
assert tmpl.render() == "Foo\tBar" |
|||
tmpl = env.from_string('''{{ "FOO\tBAR"|title }}''') |
|||
assert tmpl.render() == "Foo\tBar" |
|||
|
|||
class Foo: |
|||
def __str__(self): |
|||
return 'foo-bar' |
|||
|
|||
tmpl = env.from_string('''{{ data|title }}''') |
|||
out = tmpl.render(data=Foo()) |
|||
assert out == 'Foo-Bar' |
|||
|
|||
def test_truncate(self, env): |
|||
tmpl = env.from_string( |
|||
'{{ data|truncate(15, true, ">>>") }}|' |
|||
'{{ data|truncate(15, false, ">>>") }}|' |
|||
'{{ smalldata|truncate(15) }}' |
|||
) |
|||
out = tmpl.render(data='foobar baz bar' * 1000, |
|||
smalldata='foobar baz bar') |
|||
msg = 'Current output: %s' % out |
|||
assert out == 'foobar baz b>>>|foobar baz >>>|foobar baz bar', msg |
|||
|
|||
def test_truncate_very_short(self, env): |
|||
tmpl = env.from_string( |
|||
'{{ "foo bar baz"|truncate(9) }}|' |
|||
'{{ "foo bar baz"|truncate(9, true) }}' |
|||
) |
|||
out = tmpl.render() |
|||
assert out == 'foo ...|foo ba...', out |
|||
|
|||
def test_truncate_end_length(self, env): |
|||
tmpl = env.from_string('{{ "Joel is a slug"|truncate(9, true) }}') |
|||
out = tmpl.render() |
|||
assert out == 'Joel i...', 'Current output: %s' % out |
|||
|
|||
def test_upper(self, env): |
|||
tmpl = env.from_string('{{ "foo"|upper }}') |
|||
assert tmpl.render() == 'FOO' |
|||
|
|||
def test_urlize(self, env): |
|||
tmpl = env.from_string( |
|||
'{{ "foo http://www.example.com/ bar"|urlize }}') |
|||
assert tmpl.render() == 'foo <a href="http://www.example.com/">'\ |
|||
'http://www.example.com/</a> bar' |
|||
|
|||
def test_urlize_target_parameter(self, env): |
|||
tmpl = env.from_string( |
|||
'{{ "foo http://www.example.com/ bar"|urlize(target="_blank") }}' |
|||
) |
|||
assert tmpl.render() \ |
|||
== 'foo <a href="http://www.example.com/" target="_blank">'\ |
|||
'http://www.example.com/</a> bar' |
|||
tmpl = env.from_string( |
|||
'{{ "foo http://www.example.com/ bar"|urlize(target=42) }}' |
|||
) |
|||
assert tmpl.render() == 'foo <a href="http://www.example.com/">'\ |
|||
'http://www.example.com/</a> bar' |
|||
|
|||
def test_wordcount(self, env): |
|||
tmpl = env.from_string('{{ "foo bar baz"|wordcount }}') |
|||
assert tmpl.render() == '3' |
|||
|
|||
def test_block(self, env): |
|||
tmpl = env.from_string( |
|||
'{% filter lower|escape %}<HEHE>{% endfilter %}' |
|||
) |
|||
assert tmpl.render() == '<hehe>' |
|||
|
|||
def test_chaining(self, env): |
|||
tmpl = env.from_string( |
|||
'''{{ ['<foo>', '<bar>']|first|upper|escape }}''' |
|||
) |
|||
assert tmpl.render() == '<FOO>' |
|||
|
|||
def test_sum(self, env): |
|||
tmpl = env.from_string('''{{ [1, 2, 3, 4, 5, 6]|sum }}''') |
|||
assert tmpl.render() == '21' |
|||
|
|||
def test_sum_attributes(self, env): |
|||
tmpl = env.from_string('''{{ values|sum('value') }}''') |
|||
assert tmpl.render(values=[ |
|||
{'value': 23}, |
|||
{'value': 1}, |
|||
{'value': 18}, |
|||
]) == '42' |
|||
|
|||
def test_sum_attributes_nested(self, env): |
|||
tmpl = env.from_string('''{{ values|sum('real.value') }}''') |
|||
assert tmpl.render(values=[ |
|||
{'real': {'value': 23}}, |
|||
{'real': {'value': 1}}, |
|||
{'real': {'value': 18}}, |
|||
]) == '42' |
|||
|
|||
def test_sum_attributes_tuple(self, env): |
|||
tmpl = env.from_string('''{{ values.items()|sum('1') }}''') |
|||
assert tmpl.render(values={ |
|||
'foo': 23, |
|||
'bar': 1, |
|||
'baz': 18, |
|||
}) == '42' |
|||
|
|||
def test_abs(self, env): |
|||
tmpl = env.from_string('''{{ -1|abs }}|{{ 1|abs }}''') |
|||
assert tmpl.render() == '1|1', tmpl.render() |
|||
|
|||
def test_round_positive(self, env): |
|||
tmpl = env.from_string('{{ 2.7|round }}|{{ 2.1|round }}|' |
|||
"{{ 2.1234|round(3, 'floor') }}|" |
|||
"{{ 2.1|round(0, 'ceil') }}") |
|||
assert tmpl.render() == '3.0|2.0|2.123|3.0', tmpl.render() |
|||
|
|||
def test_round_negative(self, env): |
|||
tmpl = env.from_string('{{ 21.3|round(-1)}}|' |
|||
"{{ 21.3|round(-1, 'ceil')}}|" |
|||
"{{ 21.3|round(-1, 'floor')}}") |
|||
assert tmpl.render() == '20.0|30.0|20.0', tmpl.render() |
|||
|
|||
def test_xmlattr(self, env): |
|||
tmpl = env.from_string( |
|||
"{{ {'foo': 42, 'bar': 23, 'fish': none, " |
|||
"'spam': missing, 'blub:blub': '<?>'}|xmlattr }}") |
|||
out = tmpl.render().split() |
|||
assert len(out) == 3 |
|||
assert 'foo="42"' in out |
|||
assert 'bar="23"' in out |
|||
assert 'blub:blub="<?>"' in out |
|||
|
|||
def test_sort1(self, env): |
|||
tmpl = env.from_string( |
|||
'{{ [2, 3, 1]|sort }}|{{ [2, 3, 1]|sort(true) }}') |
|||
assert tmpl.render() == '[1, 2, 3]|[3, 2, 1]' |
|||
|
|||
def test_sort2(self, env): |
|||
tmpl = env.from_string('{{ "".join(["c", "A", "b", "D"]|sort) }}') |
|||
assert tmpl.render() == 'AbcD' |
|||
|
|||
def test_sort3(self, env): |
|||
tmpl = env.from_string('''{{ ['foo', 'Bar', 'blah']|sort }}''') |
|||
assert tmpl.render() == "['Bar', 'blah', 'foo']" |
|||
|
|||
def test_sort4(self, env): |
|||
@implements_to_string |
|||
class Magic(object): |
|||
def __init__(self, value): |
|||
self.value = value |
|||
|
|||
def __str__(self): |
|||
return text_type(self.value) |
|||
tmpl = env.from_string('''{{ items|sort(attribute='value')|join }}''') |
|||
assert tmpl.render(items=map(Magic, [3, 2, 4, 1])) == '1234' |
|||
|
|||
def test_groupby(self, env): |
|||
tmpl = env.from_string(''' |
|||
{%- for grouper, list in [{'foo': 1, 'bar': 2}, |
|||
{'foo': 2, 'bar': 3}, |
|||
{'foo': 1, 'bar': 1}, |
|||
{'foo': 3, 'bar': 4}]|groupby('foo') -%} |
|||
{{ grouper }}{% for x in list %}: {{ x.foo }}, {{ x.bar }}{% endfor %}| |
|||
{%- endfor %}''') |
|||
assert tmpl.render().split('|') == [ |
|||
"1: 1, 2: 1, 1", |
|||
"2: 2, 3", |
|||
"3: 3, 4", |
|||
"" |
|||
] |
|||
|
|||
def test_groupby_tuple_index(self, env): |
|||
tmpl = env.from_string(''' |
|||
{%- for grouper, list in [('a', 1), ('a', 2), ('b', 1)]|groupby(0) -%} |
|||
{{ grouper }}{% for x in list %}:{{ x.1 }}{% endfor %}| |
|||
{%- endfor %}''') |
|||
assert tmpl.render() == 'a:1:2|b:1|' |
|||
|
|||
def test_groupby_multidot(self, env): |
|||
class Date(object): |
|||
def __init__(self, day, month, year): |
|||
self.day = day |
|||
self.month = month |
|||
self.year = year |
|||
|
|||
class Article(object): |
|||
def __init__(self, title, *date): |
|||
self.date = Date(*date) |
|||
self.title = title |
|||
articles = [ |
|||
Article('aha', 1, 1, 1970), |
|||
Article('interesting', 2, 1, 1970), |
|||
Article('really?', 3, 1, 1970), |
|||
Article('totally not', 1, 1, 1971) |
|||
] |
|||
tmpl = env.from_string(''' |
|||
{%- for year, list in articles|groupby('date.year') -%} |
|||
{{ year }}{% for x in list %}[{{ x.title }}]{% endfor %}| |
|||
{%- endfor %}''') |
|||
assert tmpl.render(articles=articles).split('|') == [ |
|||
'1970[aha][interesting][really?]', |
|||
'1971[totally not]', |
|||
'' |
|||
] |
|||
|
|||
def test_filtertag(self, env): |
|||
tmpl = env.from_string("{% filter upper|replace('FOO', 'foo') %}" |
|||
"foobar{% endfilter %}") |
|||
assert tmpl.render() == 'fooBAR' |
|||
|
|||
def test_replace(self, env): |
|||
env = Environment() |
|||
tmpl = env.from_string('{{ string|replace("o", 42) }}') |
|||
assert tmpl.render(string='<foo>') == '<f4242>' |
|||
env = Environment(autoescape=True) |
|||
tmpl = env.from_string('{{ string|replace("o", 42) }}') |
|||
assert tmpl.render(string='<foo>') == '<f4242>' |
|||
tmpl = env.from_string('{{ string|replace("<", 42) }}') |
|||
assert tmpl.render(string='<foo>') == '42foo>' |
|||
tmpl = env.from_string('{{ string|replace("o", ">x<") }}') |
|||
assert tmpl.render(string=Markup('foo')) == 'f>x<>x<' |
|||
|
|||
def test_forceescape(self, env): |
|||
tmpl = env.from_string('{{ x|forceescape }}') |
|||
assert tmpl.render(x=Markup('<div />')) == u'<div />' |
|||
|
|||
def test_safe(self, env): |
|||
env = Environment(autoescape=True) |
|||
tmpl = env.from_string('{{ "<div>foo</div>"|safe }}') |
|||
assert tmpl.render() == '<div>foo</div>' |
|||
tmpl = env.from_string('{{ "<div>foo</div>" }}') |
|||
assert tmpl.render() == '<div>foo</div>' |
|||
|
|||
def test_urlencode(self, env): |
|||
env = Environment(autoescape=True) |
|||
tmpl = env.from_string('{{ "Hello, world!"|urlencode }}') |
|||
assert tmpl.render() == 'Hello%2C%20world%21' |
|||
tmpl = env.from_string('{{ o|urlencode }}') |
|||
assert tmpl.render(o=u"Hello, world\u203d") \ |
|||
== "Hello%2C%20world%E2%80%BD" |
|||
assert tmpl.render(o=(("f", 1),)) == "f=1" |
|||
assert tmpl.render(o=(('f', 1), ("z", 2))) == "f=1&z=2" |
|||
assert tmpl.render(o=((u"\u203d", 1),)) == "%E2%80%BD=1" |
|||
assert tmpl.render(o={u"\u203d": 1}) == "%E2%80%BD=1" |
|||
assert tmpl.render(o={0: 1}) == "0=1" |
|||
|
|||
def test_simple_map(self, env): |
|||
env = Environment() |
|||
tmpl = env.from_string('{{ ["1", "2", "3"]|map("int")|sum }}') |
|||
assert tmpl.render() == '6' |
|||
|
|||
def test_attribute_map(self, env): |
|||
class User(object): |
|||
def __init__(self, name): |
|||
self.name = name |
|||
env = Environment() |
|||
users = [ |
|||
User('john'), |
|||
User('jane'), |
|||
User('mike'), |
|||
] |
|||
tmpl = env.from_string('{{ users|map(attribute="name")|join("|") }}') |
|||
assert tmpl.render(users=users) == 'john|jane|mike' |
|||
|
|||
def test_empty_map(self, env): |
|||
env = Environment() |
|||
tmpl = env.from_string('{{ none|map("upper")|list }}') |
|||
assert tmpl.render() == '[]' |
|||
|
|||
def test_simple_select(self, env): |
|||
env = Environment() |
|||
tmpl = env.from_string('{{ [1, 2, 3, 4, 5]|select("odd")|join("|") }}') |
|||
assert tmpl.render() == '1|3|5' |
|||
|
|||
def test_bool_select(self, env): |
|||
env = Environment() |
|||
tmpl = env.from_string( |
|||
'{{ [none, false, 0, 1, 2, 3, 4, 5]|select|join("|") }}' |
|||
) |
|||
assert tmpl.render() == '1|2|3|4|5' |
|||
|
|||
def test_simple_reject(self, env): |
|||
env = Environment() |
|||
tmpl = env.from_string('{{ [1, 2, 3, 4, 5]|reject("odd")|join("|") }}') |
|||
assert tmpl.render() == '2|4' |
|||
|
|||
def test_bool_reject(self, env): |
|||
env = Environment() |
|||
tmpl = env.from_string( |
|||
'{{ [none, false, 0, 1, 2, 3, 4, 5]|reject|join("|") }}' |
|||
) |
|||
assert tmpl.render() == 'None|False|0' |
|||
|
|||
def test_simple_select_attr(self, env): |
|||
class User(object): |
|||
def __init__(self, name, is_active): |
|||
self.name = name |
|||
self.is_active = is_active |
|||
env = Environment() |
|||
users = [ |
|||
User('john', True), |
|||
User('jane', True), |
|||
User('mike', False), |
|||
] |
|||
tmpl = env.from_string( |
|||
'{{ users|selectattr("is_active")|' |
|||
'map(attribute="name")|join("|") }}' |
|||
) |
|||
assert tmpl.render(users=users) == 'john|jane' |
|||
|
|||
def test_simple_reject_attr(self, env): |
|||
class User(object): |
|||
def __init__(self, name, is_active): |
|||
self.name = name |
|||
self.is_active = is_active |
|||
env = Environment() |
|||
users = [ |
|||
User('john', True), |
|||
User('jane', True), |
|||
User('mike', False), |
|||
] |
|||
tmpl = env.from_string('{{ users|rejectattr("is_active")|' |
|||
'map(attribute="name")|join("|") }}') |
|||
assert tmpl.render(users=users) == 'mike' |
|||
|
|||
def test_func_select_attr(self, env): |
|||
class User(object): |
|||
def __init__(self, id, name): |
|||
self.id = id |
|||
self.name = name |
|||
env = Environment() |
|||
users = [ |
|||
User(1, 'john'), |
|||
User(2, 'jane'), |
|||
User(3, 'mike'), |
|||
] |
|||
tmpl = env.from_string('{{ users|selectattr("id", "odd")|' |
|||
'map(attribute="name")|join("|") }}') |
|||
assert tmpl.render(users=users) == 'john|mike' |
|||
|
|||
def test_func_reject_attr(self, env): |
|||
class User(object): |
|||
def __init__(self, id, name): |
|||
self.id = id |
|||
self.name = name |
|||
env = Environment() |
|||
users = [ |
|||
User(1, 'john'), |
|||
User(2, 'jane'), |
|||
User(3, 'mike'), |
|||
] |
|||
tmpl = env.from_string('{{ users|rejectattr("id", "odd")|' |
|||
'map(attribute="name")|join("|") }}') |
|||
assert tmpl.render(users=users) == 'jane' |
|||
@ -1,148 +0,0 @@ |
|||
# -*- coding: utf-8 -*- |
|||
""" |
|||
jinja2.testsuite.imports |
|||
~~~~~~~~~~~~~~~~~~~~~~~~ |
|||
|
|||
Tests the import features (with includes). |
|||
|
|||
:copyright: (c) 2010 by the Jinja Team. |
|||
:license: BSD, see LICENSE for more details. |
|||
""" |
|||
import pytest |
|||
|
|||
from jinja2 import Environment, DictLoader |
|||
from jinja2.exceptions import TemplateNotFound, TemplatesNotFound |
|||
|
|||
|
|||
@pytest.fixture |
|||
def test_env(): |
|||
env = Environment(loader=DictLoader(dict( |
|||
module='{% macro test() %}[{{ foo }}|{{ bar }}]{% endmacro %}', |
|||
header='[{{ foo }}|{{ 23 }}]', |
|||
o_printer='({{ o }})' |
|||
))) |
|||
env.globals['bar'] = 23 |
|||
return env |
|||
|
|||
|
|||
@pytest.mark.imports |
|||
class TestImports(): |
|||
|
|||
def test_context_imports(self, test_env): |
|||
t = test_env.from_string('{% import "module" as m %}{{ m.test() }}') |
|||
assert t.render(foo=42) == '[|23]' |
|||
t = test_env.from_string( |
|||
'{% import "module" as m without context %}{{ m.test() }}' |
|||
) |
|||
assert t.render(foo=42) == '[|23]' |
|||
t = test_env.from_string( |
|||
'{% import "module" as m with context %}{{ m.test() }}' |
|||
) |
|||
assert t.render(foo=42) == '[42|23]' |
|||
t = test_env.from_string('{% from "module" import test %}{{ test() }}') |
|||
assert t.render(foo=42) == '[|23]' |
|||
t = test_env.from_string( |
|||
'{% from "module" import test without context %}{{ test() }}' |
|||
) |
|||
assert t.render(foo=42) == '[|23]' |
|||
t = test_env.from_string( |
|||
'{% from "module" import test with context %}{{ test() }}' |
|||
) |
|||
assert t.render(foo=42) == '[42|23]' |
|||
|
|||
def test_trailing_comma(self, test_env): |
|||
test_env.from_string('{% from "foo" import bar, baz with context %}') |
|||
test_env.from_string('{% from "foo" import bar, baz, with context %}') |
|||
test_env.from_string('{% from "foo" import bar, with context %}') |
|||
test_env.from_string('{% from "foo" import bar, with, context %}') |
|||
test_env.from_string('{% from "foo" import bar, with with context %}') |
|||
|
|||
def test_exports(self, test_env): |
|||
m = test_env.from_string(''' |
|||
{% macro toplevel() %}...{% endmacro %} |
|||
{% macro __private() %}...{% endmacro %} |
|||
{% set variable = 42 %} |
|||
{% for item in [1] %} |
|||
{% macro notthere() %}{% endmacro %} |
|||
{% endfor %} |
|||
''').module |
|||
assert m.toplevel() == '...' |
|||
assert not hasattr(m, '__missing') |
|||
assert m.variable == 42 |
|||
assert not hasattr(m, 'notthere') |
|||
|
|||
|
|||
@pytest.mark.imports |
|||
@pytest.mark.includes |
|||
class TestIncludes(): |
|||
|
|||
def test_context_include(self, test_env): |
|||
t = test_env.from_string('{% include "header" %}') |
|||
assert t.render(foo=42) == '[42|23]' |
|||
t = test_env.from_string('{% include "header" with context %}') |
|||
assert t.render(foo=42) == '[42|23]' |
|||
t = test_env.from_string('{% include "header" without context %}') |
|||
assert t.render(foo=42) == '[|23]' |
|||
|
|||
def test_choice_includes(self, test_env): |
|||
t = test_env.from_string('{% include ["missing", "header"] %}') |
|||
assert t.render(foo=42) == '[42|23]' |
|||
|
|||
t = test_env.from_string( |
|||
'{% include ["missing", "missing2"] ignore missing %}' |
|||
) |
|||
assert t.render(foo=42) == '' |
|||
|
|||
t = test_env.from_string('{% include ["missing", "missing2"] %}') |
|||
pytest.raises(TemplateNotFound, t.render) |
|||
try: |
|||
t.render() |
|||
except TemplatesNotFound as e: |
|||
assert e.templates == ['missing', 'missing2'] |
|||
assert e.name == 'missing2' |
|||
else: |
|||
assert False, 'thou shalt raise' |
|||
|
|||
def test_includes(t, **ctx): |
|||
ctx['foo'] = 42 |
|||
assert t.render(ctx) == '[42|23]' |
|||
|
|||
t = test_env.from_string('{% include ["missing", "header"] %}') |
|||
test_includes(t) |
|||
t = test_env.from_string('{% include x %}') |
|||
test_includes(t, x=['missing', 'header']) |
|||
t = test_env.from_string('{% include [x, "header"] %}') |
|||
test_includes(t, x='missing') |
|||
t = test_env.from_string('{% include x %}') |
|||
test_includes(t, x='header') |
|||
t = test_env.from_string('{% include x %}') |
|||
test_includes(t, x='header') |
|||
t = test_env.from_string('{% include [x] %}') |
|||
test_includes(t, x='header') |
|||
|
|||
def test_include_ignoring_missing(self, test_env): |
|||
t = test_env.from_string('{% include "missing" %}') |
|||
pytest.raises(TemplateNotFound, t.render) |
|||
for extra in '', 'with context', 'without context': |
|||
t = test_env.from_string('{% include "missing" ignore missing ' + |
|||
extra + ' %}') |
|||
assert t.render() == '' |
|||
|
|||
def test_context_include_with_overrides(self, test_env): |
|||
env = Environment(loader=DictLoader(dict( |
|||
main="{% for item in [1, 2, 3] %}{% include 'item' %}{% endfor %}", |
|||
item="{{ item }}" |
|||
))) |
|||
assert env.get_template("main").render() == "123" |
|||
|
|||
def test_unoptimized_scopes(self, test_env): |
|||
t = test_env.from_string(""" |
|||
{% macro outer(o) %} |
|||
{% macro inner() %} |
|||
{% include "o_printer" %} |
|||
{% endmacro %} |
|||
{{ inner() }} |
|||
{% endmacro %} |
|||
{{ outer("FOO") }} |
|||
""") |
|||
assert t.render().strip() == '(FOO)' |
|||
@ -1,248 +0,0 @@ |
|||
# -*- coding: utf-8 -*- |
|||
""" |
|||
jinja2.testsuite.inheritance |
|||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
|||
|
|||
Tests the template inheritance feature. |
|||
|
|||
:copyright: (c) 2010 by the Jinja Team. |
|||
:license: BSD, see LICENSE for more details. |
|||
""" |
|||
import pytest |
|||
|
|||
from jinja2 import Environment, DictLoader, TemplateError |
|||
|
|||
|
|||
LAYOUTTEMPLATE = '''\ |
|||
|{% block block1 %}block 1 from layout{% endblock %} |
|||
|{% block block2 %}block 2 from layout{% endblock %} |
|||
|{% block block3 %} |
|||
{% block block4 %}nested block 4 from layout{% endblock %} |
|||
{% endblock %}|''' |
|||
|
|||
LEVEL1TEMPLATE = '''\ |
|||
{% extends "layout" %} |
|||
{% block block1 %}block 1 from level1{% endblock %}''' |
|||
|
|||
LEVEL2TEMPLATE = '''\ |
|||
{% extends "level1" %} |
|||
{% block block2 %}{% block block5 %}nested block 5 from level2{% |
|||
endblock %}{% endblock %}''' |
|||
|
|||
LEVEL3TEMPLATE = '''\ |
|||
{% extends "level2" %} |
|||
{% block block5 %}block 5 from level3{% endblock %} |
|||
{% block block4 %}block 4 from level3{% endblock %} |
|||
''' |
|||
|
|||
LEVEL4TEMPLATE = '''\ |
|||
{% extends "level3" %} |
|||
{% block block3 %}block 3 from level4{% endblock %} |
|||
''' |
|||
|
|||
WORKINGTEMPLATE = '''\ |
|||
{% extends "layout" %} |
|||
{% block block1 %} |
|||
{% if false %} |
|||
{% block block2 %} |
|||
this should workd |
|||
{% endblock %} |
|||
{% endif %} |
|||
{% endblock %} |
|||
''' |
|||
|
|||
DOUBLEEXTENDS = '''\ |
|||
{% extends "layout" %} |
|||
{% extends "layout" %} |
|||
{% block block1 %} |
|||
{% if false %} |
|||
{% block block2 %} |
|||
this should workd |
|||
{% endblock %} |
|||
{% endif %} |
|||
{% endblock %} |
|||
''' |
|||
|
|||
|
|||
@pytest.fixture |
|||
def env(): |
|||
return Environment(loader=DictLoader({ |
|||
'layout': LAYOUTTEMPLATE, |
|||
'level1': LEVEL1TEMPLATE, |
|||
'level2': LEVEL2TEMPLATE, |
|||
'level3': LEVEL3TEMPLATE, |
|||
'level4': LEVEL4TEMPLATE, |
|||
'working': WORKINGTEMPLATE, |
|||
'doublee': DOUBLEEXTENDS, |
|||
}), trim_blocks=True) |
|||
|
|||
|
|||
@pytest.mark.inheritance |
|||
class TestInheritance(): |
|||
|
|||
def test_layout(self, env): |
|||
tmpl = env.get_template('layout') |
|||
assert tmpl.render() == ('|block 1 from layout|block 2 from ' |
|||
'layout|nested block 4 from layout|') |
|||
|
|||
def test_level1(self, env): |
|||
tmpl = env.get_template('level1') |
|||
assert tmpl.render() == ('|block 1 from level1|block 2 from ' |
|||
'layout|nested block 4 from layout|') |
|||
|
|||
def test_level2(self, env): |
|||
tmpl = env.get_template('level2') |
|||
assert tmpl.render() == ('|block 1 from level1|nested block 5 from ' |
|||
'level2|nested block 4 from layout|') |
|||
|
|||
def test_level3(self, env): |
|||
tmpl = env.get_template('level3') |
|||
assert tmpl.render() == ('|block 1 from level1|block 5 from level3|' |
|||
'block 4 from level3|') |
|||
|
|||
def test_level4(self, env): |
|||
tmpl = env.get_template('level4') |
|||
assert tmpl.render() == ('|block 1 from level1|block 5 from ' |
|||
'level3|block 3 from level4|') |
|||
|
|||
def test_super(self, env): |
|||
env = Environment(loader=DictLoader({ |
|||
'a': '{% block intro %}INTRO{% endblock %}|' |
|||
'BEFORE|{% block data %}INNER{% endblock %}|AFTER', |
|||
'b': '{% extends "a" %}{% block data %}({{ ' |
|||
'super() }}){% endblock %}', |
|||
'c': '{% extends "b" %}{% block intro %}--{{ ' |
|||
'super() }}--{% endblock %}\n{% block data ' |
|||
'%}[{{ super() }}]{% endblock %}' |
|||
})) |
|||
tmpl = env.get_template('c') |
|||
assert tmpl.render() == '--INTRO--|BEFORE|[(INNER)]|AFTER' |
|||
|
|||
def test_working(self, env): |
|||
tmpl = env.get_template('working') |
|||
|
|||
def test_reuse_blocks(self, env): |
|||
tmpl = env.from_string('{{ self.foo() }}|{% block foo %}42' |
|||
'{% endblock %}|{{ self.foo() }}') |
|||
assert tmpl.render() == '42|42|42' |
|||
|
|||
def test_preserve_blocks(self, env): |
|||
env = Environment(loader=DictLoader({ |
|||
'a': '{% if false %}{% block x %}A{% endblock %}' |
|||
'{% endif %}{{ self.x() }}', |
|||
'b': '{% extends "a" %}{% block x %}B{{ super() }}{% endblock %}' |
|||
})) |
|||
tmpl = env.get_template('b') |
|||
assert tmpl.render() == 'BA' |
|||
|
|||
def test_dynamic_inheritance(self, env): |
|||
env = Environment(loader=DictLoader({ |
|||
'master1': 'MASTER1{% block x %}{% endblock %}', |
|||
'master2': 'MASTER2{% block x %}{% endblock %}', |
|||
'child': '{% extends master %}{% block x %}CHILD{% endblock %}' |
|||
})) |
|||
tmpl = env.get_template('child') |
|||
for m in range(1, 3): |
|||
assert tmpl.render(master='master%d' % m) == 'MASTER%dCHILD' % m |
|||
|
|||
def test_multi_inheritance(self, env): |
|||
env = Environment(loader=DictLoader({ |
|||
'master1': 'MASTER1{% block x %}{% endblock %}', |
|||
'master2': 'MASTER2{% block x %}{% endblock %}', |
|||
'child': |
|||
'''{% if master %}{% extends master %}{% else %}{% extends |
|||
'master1' %}{% endif %}{% block x %}CHILD{% endblock %}''' |
|||
})) |
|||
tmpl = env.get_template('child') |
|||
assert tmpl.render(master='master2') == 'MASTER2CHILD' |
|||
assert tmpl.render(master='master1') == 'MASTER1CHILD' |
|||
assert tmpl.render() == 'MASTER1CHILD' |
|||
|
|||
def test_scoped_block(self, env): |
|||
env = Environment(loader=DictLoader({ |
|||
'master.html': '{% for item in seq %}[{% block item scoped %}' |
|||
'{% endblock %}]{% endfor %}' |
|||
})) |
|||
t = env.from_string('{% extends "master.html" %}{% block item %}' |
|||
'{{ item }}{% endblock %}') |
|||
assert t.render(seq=list(range(5))) == '[0][1][2][3][4]' |
|||
|
|||
def test_super_in_scoped_block(self, env): |
|||
env = Environment(loader=DictLoader({ |
|||
'master.html': '{% for item in seq %}[{% block item scoped %}' |
|||
'{{ item }}{% endblock %}]{% endfor %}' |
|||
})) |
|||
t = env.from_string('{% extends "master.html" %}{% block item %}' |
|||
'{{ super() }}|{{ item * 2 }}{% endblock %}') |
|||
assert t.render(seq=list(range(5))) == '[0|0][1|2][2|4][3|6][4|8]' |
|||
|
|||
def test_scoped_block_after_inheritance(self, env): |
|||
env = Environment(loader=DictLoader({ |
|||
'layout.html': ''' |
|||
{% block useless %}{% endblock %} |
|||
''', |
|||
'index.html': ''' |
|||
{%- extends 'layout.html' %} |
|||
{% from 'helpers.html' import foo with context %} |
|||
{% block useless %} |
|||
{% for x in [1, 2, 3] %} |
|||
{% block testing scoped %} |
|||
{{ foo(x) }} |
|||
{% endblock %} |
|||
{% endfor %} |
|||
{% endblock %} |
|||
''', |
|||
'helpers.html': ''' |
|||
{% macro foo(x) %}{{ the_foo + x }}{% endmacro %} |
|||
''' |
|||
})) |
|||
rv = env.get_template('index.html').render(the_foo=42).split() |
|||
assert rv == ['43', '44', '45'] |
|||
|
|||
|
|||
@pytest.mark.inheritance |
|||
class TestBugFix(): |
|||
|
|||
def test_fixed_macro_scoping_bug(self, env): |
|||
assert Environment(loader=DictLoader({ |
|||
'test.html': '''\ |
|||
{% extends 'details.html' %} |
|||
|
|||
{% macro my_macro() %} |
|||
my_macro |
|||
{% endmacro %} |
|||
|
|||
{% block inner_box %} |
|||
{{ my_macro() }} |
|||
{% endblock %} |
|||
''', |
|||
'details.html': '''\ |
|||
{% extends 'standard.html' %} |
|||
|
|||
{% macro my_macro() %} |
|||
my_macro |
|||
{% endmacro %} |
|||
|
|||
{% block content %} |
|||
{% block outer_box %} |
|||
outer_box |
|||
{% block inner_box %} |
|||
inner_box |
|||
{% endblock %} |
|||
{% endblock %} |
|||
{% endblock %} |
|||
''', |
|||
'standard.html': ''' |
|||
{% block content %} {% endblock %} |
|||
''' |
|||
})).get_template("test.html").render().split() \ |
|||
== [u'outer_box', u'my_macro'] |
|||
|
|||
def test_double_extends(self, env): |
|||
"""Ensures that a template with more than 1 {% extends ... %} usage |
|||
raises a ``TemplateError``. |
|||
""" |
|||
try: |
|||
tmpl = env.get_template('doublee') |
|||
except Exception as e: |
|||
assert isinstance(e, TemplateError) |
|||
@ -1,609 +0,0 @@ |
|||
# -*- coding: utf-8 -*- |
|||
""" |
|||
jinja2.testsuite.lexnparse |
|||
~~~~~~~~~~~~~~~~~~~~~~~~~~ |
|||
|
|||
All the unittests regarding lexing, parsing and syntax. |
|||
|
|||
:copyright: (c) 2010 by the Jinja Team. |
|||
:license: BSD, see LICENSE for more details. |
|||
""" |
|||
import pytest |
|||
|
|||
from jinja2 import Environment, Template, TemplateSyntaxError, \ |
|||
UndefinedError, nodes |
|||
from jinja2._compat import iteritems, text_type, PY2 |
|||
from jinja2.lexer import Token, TokenStream, TOKEN_EOF, \ |
|||
TOKEN_BLOCK_BEGIN, TOKEN_BLOCK_END |
|||
|
|||
|
|||
# how does a string look like in jinja syntax? |
|||
if PY2: |
|||
def jinja_string_repr(string): |
|||
return repr(string)[1:] |
|||
else: |
|||
jinja_string_repr = repr |
|||
|
|||
|
|||
@pytest.mark.lexnparse |
|||
@pytest.mark.tokenstream |
|||
class TestTokenStream(): |
|||
test_tokens = [Token(1, TOKEN_BLOCK_BEGIN, ''), |
|||
Token(2, TOKEN_BLOCK_END, ''), |
|||
] |
|||
|
|||
def test_simple(self, env): |
|||
ts = TokenStream(self.test_tokens, "foo", "bar") |
|||
assert ts.current.type is TOKEN_BLOCK_BEGIN |
|||
assert bool(ts) |
|||
assert not bool(ts.eos) |
|||
next(ts) |
|||
assert ts.current.type is TOKEN_BLOCK_END |
|||
assert bool(ts) |
|||
assert not bool(ts.eos) |
|||
next(ts) |
|||
assert ts.current.type is TOKEN_EOF |
|||
assert not bool(ts) |
|||
assert bool(ts.eos) |
|||
|
|||
def test_iter(self, env): |
|||
token_types = [ |
|||
t.type for t in TokenStream(self.test_tokens, "foo", "bar") |
|||
] |
|||
assert token_types == ['block_begin', 'block_end', ] |
|||
|
|||
|
|||
@pytest.mark.lexnparse |
|||
@pytest.mark.lexer |
|||
class TestLexer(): |
|||
|
|||
def test_raw1(self, env): |
|||
tmpl = env.from_string( |
|||
'{% raw %}foo{% endraw %}|' |
|||
'{%raw%}{{ bar }}|{% baz %}{% endraw %}') |
|||
assert tmpl.render() == 'foo|{{ bar }}|{% baz %}' |
|||
|
|||
def test_raw2(self, env): |
|||
tmpl = env.from_string('1 {%- raw -%} 2 {%- endraw -%} 3') |
|||
assert tmpl.render() == '123' |
|||
|
|||
def test_balancing(self, env): |
|||
env = Environment('{%', '%}', '${', '}') |
|||
tmpl = env.from_string('''{% for item in seq |
|||
%}${{'foo': item}|upper}{% endfor %}''') |
|||
assert tmpl.render(seq=list(range(3))) \ |
|||
== "{'FOO': 0}{'FOO': 1}{'FOO': 2}" |
|||
|
|||
def test_comments(self, env): |
|||
env = Environment('<!--', '-->', '{', '}') |
|||
tmpl = env.from_string('''\ |
|||
<ul> |
|||
<!--- for item in seq --> |
|||
<li>{item}</li> |
|||
<!--- endfor --> |
|||
</ul>''') |
|||
assert tmpl.render(seq=list(range(3))) \ |
|||
== ("<ul>\n <li>0</li>\n ""<li>1</li>\n <li>2</li>\n</ul>") |
|||
|
|||
def test_string_escapes(self, env): |
|||
for char in u'\0', u'\u2668', u'\xe4', u'\t', u'\r', u'\n': |
|||
tmpl = env.from_string('{{ %s }}' % jinja_string_repr(char)) |
|||
assert tmpl.render() == char |
|||
assert env.from_string('{{ "\N{HOT SPRINGS}" }}').render() == u'\u2668' |
|||
|
|||
def test_bytefallback(self, env): |
|||
from pprint import pformat |
|||
tmpl = env.from_string(u'''{{ 'foo'|pprint }}|{{ 'bär'|pprint }}''') |
|||
assert tmpl.render() == pformat('foo') + '|' + pformat(u'bär') |
|||
|
|||
def test_operators(self, env): |
|||
from jinja2.lexer import operators |
|||
for test, expect in iteritems(operators): |
|||
if test in '([{}])': |
|||
continue |
|||
stream = env.lexer.tokenize('{{ %s }}' % test) |
|||
next(stream) |
|||
assert stream.current.type == expect |
|||
|
|||
def test_normalizing(self, env): |
|||
for seq in '\r', '\r\n', '\n': |
|||
env = Environment(newline_sequence=seq) |
|||
tmpl = env.from_string('1\n2\r\n3\n4\n') |
|||
result = tmpl.render() |
|||
assert result.replace(seq, 'X') == '1X2X3X4' |
|||
|
|||
def test_trailing_newline(self, env): |
|||
for keep in [True, False]: |
|||
env = Environment(keep_trailing_newline=keep) |
|||
for template, expected in [ |
|||
('', {}), |
|||
('no\nnewline', {}), |
|||
('with\nnewline\n', {False: 'with\nnewline'}), |
|||
('with\nseveral\n\n\n', {False: 'with\nseveral\n\n'}), |
|||
]: |
|||
tmpl = env.from_string(template) |
|||
expect = expected.get(keep, template) |
|||
result = tmpl.render() |
|||
assert result == expect, (keep, template, result, expect) |
|||
|
|||
|
|||
@pytest.mark.lexnparse |
|||
@pytest.mark.parser |
|||
class TestParser(): |
|||
|
|||
def test_php_syntax(self, env): |
|||
env = Environment('<?', '?>', '<?=', '?>', '<!--', '-->') |
|||
tmpl = env.from_string('''\ |
|||
<!-- I'm a comment, I'm not interesting -->\ |
|||
<? for item in seq -?> |
|||
<?= item ?> |
|||
<?- endfor ?>''') |
|||
assert tmpl.render(seq=list(range(5))) == '01234' |
|||
|
|||
def test_erb_syntax(self, env): |
|||
env = Environment('<%', '%>', '<%=', '%>', '<%#', '%>') |
|||
tmpl = env.from_string('''\ |
|||
<%# I'm a comment, I'm not interesting %>\ |
|||
<% for item in seq -%> |
|||
<%= item %> |
|||
<%- endfor %>''') |
|||
assert tmpl.render(seq=list(range(5))) == '01234' |
|||
|
|||
def test_comment_syntax(self, env): |
|||
env = Environment('<!--', '-->', '${', '}', '<!--#', '-->') |
|||
tmpl = env.from_string('''\ |
|||
<!--# I'm a comment, I'm not interesting -->\ |
|||
<!-- for item in seq ---> |
|||
${item} |
|||
<!--- endfor -->''') |
|||
assert tmpl.render(seq=list(range(5))) == '01234' |
|||
|
|||
def test_balancing(self, env): |
|||
tmpl = env.from_string('''{{{'foo':'bar'}.foo}}''') |
|||
assert tmpl.render() == 'bar' |
|||
|
|||
def test_start_comment(self, env): |
|||
tmpl = env.from_string('''{# foo comment |
|||
and bar comment #} |
|||
{% macro blub() %}foo{% endmacro %} |
|||
{{ blub() }}''') |
|||
assert tmpl.render().strip() == 'foo' |
|||
|
|||
def test_line_syntax(self, env): |
|||
env = Environment('<%', '%>', '${', '}', '<%#', '%>', '%') |
|||
tmpl = env.from_string('''\ |
|||
<%# regular comment %> |
|||
% for item in seq: |
|||
${item} |
|||
% endfor''') |
|||
assert [ |
|||
int(x.strip()) for x in tmpl.render(seq=list(range(5))).split() |
|||
] == list(range(5)) |
|||
|
|||
env = Environment('<%', '%>', '${', '}', '<%#', '%>', '%', '##') |
|||
tmpl = env.from_string('''\ |
|||
<%# regular comment %> |
|||
% for item in seq: |
|||
${item} ## the rest of the stuff |
|||
% endfor''') |
|||
assert [ |
|||
int(x.strip()) for x in tmpl.render(seq=list(range(5))).split() |
|||
] == list(range(5)) |
|||
|
|||
def test_line_syntax_priority(self, env): |
|||
# XXX: why is the whitespace there in front of the newline? |
|||
env = Environment('{%', '%}', '${', '}', '/*', '*/', '##', '#') |
|||
tmpl = env.from_string('''\ |
|||
/* ignore me. |
|||
I'm a multiline comment */ |
|||
## for item in seq: |
|||
* ${item} # this is just extra stuff |
|||
## endfor''') |
|||
assert tmpl.render(seq=[1, 2]).strip() == '* 1\n* 2' |
|||
env = Environment('{%', '%}', '${', '}', '/*', '*/', '#', '##') |
|||
tmpl = env.from_string('''\ |
|||
/* ignore me. |
|||
I'm a multiline comment */ |
|||
# for item in seq: |
|||
* ${item} ## this is just extra stuff |
|||
## extra stuff i just want to ignore |
|||
# endfor''') |
|||
assert tmpl.render(seq=[1, 2]).strip() == '* 1\n\n* 2' |
|||
|
|||
def test_error_messages(self, env): |
|||
def assert_error(code, expected): |
|||
try: |
|||
Template(code) |
|||
except TemplateSyntaxError as e: |
|||
assert str(e) == expected, 'unexpected error message' |
|||
else: |
|||
assert False, 'that was supposed to be an error' |
|||
|
|||
assert_error('{% for item in seq %}...{% endif %}', |
|||
"Encountered unknown tag 'endif'. Jinja was looking " |
|||
"for the following tags: 'endfor' or 'else'. The " |
|||
"innermost block that needs to be closed is 'for'.") |
|||
assert_error( |
|||
'{% if foo %}{% for item in seq %}...{% endfor %}{% endfor %}', |
|||
"Encountered unknown tag 'endfor'. Jinja was looking for " |
|||
"the following tags: 'elif' or 'else' or 'endif'. The " |
|||
"innermost block that needs to be closed is 'if'.") |
|||
assert_error('{% if foo %}', |
|||
"Unexpected end of template. Jinja was looking for the " |
|||
"following tags: 'elif' or 'else' or 'endif'. The " |
|||
"innermost block that needs to be closed is 'if'.") |
|||
assert_error('{% for item in seq %}', |
|||
"Unexpected end of template. Jinja was looking for the " |
|||
"following tags: 'endfor' or 'else'. The innermost block " |
|||
"that needs to be closed is 'for'.") |
|||
assert_error( |
|||
'{% block foo-bar-baz %}', |
|||
"Block names in Jinja have to be valid Python identifiers " |
|||
"and may not contain hyphens, use an underscore instead.") |
|||
assert_error('{% unknown_tag %}', |
|||
"Encountered unknown tag 'unknown_tag'.") |
|||
|
|||
|
|||
@pytest.mark.lexnparse |
|||
@pytest.mark.syntax |
|||
class TestSyntax(): |
|||
|
|||
def test_call(self, env): |
|||
env = Environment() |
|||
env.globals['foo'] = lambda a, b, c, e, g: a + b + c + e + g |
|||
tmpl = env.from_string( |
|||
"{{ foo('a', c='d', e='f', *['b'], **{'g': 'h'}) }}" |
|||
) |
|||
assert tmpl.render() == 'abdfh' |
|||
|
|||
def test_slicing(self, env): |
|||
tmpl = env.from_string('{{ [1, 2, 3][:] }}|{{ [1, 2, 3][::-1] }}') |
|||
assert tmpl.render() == '[1, 2, 3]|[3, 2, 1]' |
|||
|
|||
def test_attr(self, env): |
|||
tmpl = env.from_string("{{ foo.bar }}|{{ foo['bar'] }}") |
|||
assert tmpl.render(foo={'bar': 42}) == '42|42' |
|||
|
|||
def test_subscript(self, env): |
|||
tmpl = env.from_string("{{ foo[0] }}|{{ foo[-1] }}") |
|||
assert tmpl.render(foo=[0, 1, 2]) == '0|2' |
|||
|
|||
def test_tuple(self, env): |
|||
tmpl = env.from_string('{{ () }}|{{ (1,) }}|{{ (1, 2) }}') |
|||
assert tmpl.render() == '()|(1,)|(1, 2)' |
|||
|
|||
def test_math(self, env): |
|||
tmpl = env.from_string('{{ (1 + 1 * 2) - 3 / 2 }}|{{ 2**3 }}') |
|||
assert tmpl.render() == '1.5|8' |
|||
|
|||
def test_div(self, env): |
|||
tmpl = env.from_string('{{ 3 // 2 }}|{{ 3 / 2 }}|{{ 3 % 2 }}') |
|||
assert tmpl.render() == '1|1.5|1' |
|||
|
|||
def test_unary(self, env): |
|||
tmpl = env.from_string('{{ +3 }}|{{ -3 }}') |
|||
assert tmpl.render() == '3|-3' |
|||
|
|||
def test_concat(self, env): |
|||
tmpl = env.from_string("{{ [1, 2] ~ 'foo' }}") |
|||
assert tmpl.render() == '[1, 2]foo' |
|||
|
|||
def test_compare(self, env): |
|||
tmpl = env.from_string('{{ 1 > 0 }}|{{ 1 >= 1 }}|{{ 2 < 3 }}|' |
|||
'{{ 2 == 2 }}|{{ 1 <= 1 }}') |
|||
assert tmpl.render() == 'True|True|True|True|True' |
|||
|
|||
def test_inop(self, env): |
|||
tmpl = env.from_string('{{ 1 in [1, 2, 3] }}|{{ 1 not in [1, 2, 3] }}') |
|||
assert tmpl.render() == 'True|False' |
|||
|
|||
def test_literals(self, env): |
|||
tmpl = env.from_string('{{ [] }}|{{ {} }}|{{ () }}') |
|||
assert tmpl.render().lower() == '[]|{}|()' |
|||
|
|||
def test_bool(self, env): |
|||
tmpl = env.from_string('{{ true and false }}|{{ false ' |
|||
'or true }}|{{ not false }}') |
|||
assert tmpl.render() == 'False|True|True' |
|||
|
|||
def test_grouping(self, env): |
|||
tmpl = env.from_string( |
|||
'{{ (true and false) or (false and true) and not false }}') |
|||
assert tmpl.render() == 'False' |
|||
|
|||
def test_django_attr(self, env): |
|||
tmpl = env.from_string('{{ [1, 2, 3].0 }}|{{ [[1]].0.0 }}') |
|||
assert tmpl.render() == '1|1' |
|||
|
|||
def test_conditional_expression(self, env): |
|||
tmpl = env.from_string('''{{ 0 if true else 1 }}''') |
|||
assert tmpl.render() == '0' |
|||
|
|||
def test_short_conditional_expression(self, env): |
|||
tmpl = env.from_string('<{{ 1 if false }}>') |
|||
assert tmpl.render() == '<>' |
|||
|
|||
tmpl = env.from_string('<{{ (1 if false).bar }}>') |
|||
pytest.raises(UndefinedError, tmpl.render) |
|||
|
|||
def test_filter_priority(self, env): |
|||
tmpl = env.from_string('{{ "foo"|upper + "bar"|upper }}') |
|||
assert tmpl.render() == 'FOOBAR' |
|||
|
|||
def test_function_calls(self, env): |
|||
tests = [ |
|||
(True, '*foo, bar'), |
|||
(True, '*foo, *bar'), |
|||
(True, '*foo, bar=42'), |
|||
(True, '**foo, *bar'), |
|||
(True, '**foo, bar'), |
|||
(False, 'foo, bar'), |
|||
(False, 'foo, bar=42'), |
|||
(False, 'foo, bar=23, *args'), |
|||
(False, 'a, b=c, *d, **e'), |
|||
(False, '*foo, **bar') |
|||
] |
|||
for should_fail, sig in tests: |
|||
if should_fail: |
|||
pytest.raises(TemplateSyntaxError, |
|||
env.from_string, '{{ foo(%s) }}' % sig) |
|||
else: |
|||
env.from_string('foo(%s)' % sig) |
|||
|
|||
def test_tuple_expr(self, env): |
|||
for tmpl in [ |
|||
'{{ () }}', |
|||
'{{ (1, 2) }}', |
|||
'{{ (1, 2,) }}', |
|||
'{{ 1, }}', |
|||
'{{ 1, 2 }}', |
|||
'{% for foo, bar in seq %}...{% endfor %}', |
|||
'{% for x in foo, bar %}...{% endfor %}', |
|||
'{% for x in foo, %}...{% endfor %}' |
|||
]: |
|||
assert env.from_string(tmpl) |
|||
|
|||
def test_trailing_comma(self, env): |
|||
tmpl = env.from_string('{{ (1, 2,) }}|{{ [1, 2,] }}|{{ {1: 2,} }}') |
|||
assert tmpl.render().lower() == '(1, 2)|[1, 2]|{1: 2}' |
|||
|
|||
def test_block_end_name(self, env): |
|||
env.from_string('{% block foo %}...{% endblock foo %}') |
|||
pytest.raises(TemplateSyntaxError, env.from_string, |
|||
'{% block x %}{% endblock y %}') |
|||
|
|||
def test_constant_casing(self, env): |
|||
for const in True, False, None: |
|||
tmpl = env.from_string('{{ %s }}|{{ %s }}|{{ %s }}' % ( |
|||
str(const), str(const).lower(), str(const).upper() |
|||
)) |
|||
assert tmpl.render() == '%s|%s|' % (const, const) |
|||
|
|||
def test_test_chaining(self, env): |
|||
pytest.raises(TemplateSyntaxError, env.from_string, |
|||
'{{ foo is string is sequence }}') |
|||
assert env.from_string( |
|||
'{{ 42 is string or 42 is number }}' |
|||
).render() == 'True' |
|||
|
|||
def test_string_concatenation(self, env): |
|||
tmpl = env.from_string('{{ "foo" "bar" "baz" }}') |
|||
assert tmpl.render() == 'foobarbaz' |
|||
|
|||
def test_notin(self, env): |
|||
bar = range(100) |
|||
tmpl = env.from_string('''{{ not 42 in bar }}''') |
|||
assert tmpl.render(bar=bar) == text_type(not 42 in bar) |
|||
|
|||
def test_implicit_subscribed_tuple(self, env): |
|||
class Foo(object): |
|||
def __getitem__(self, x): |
|||
return x |
|||
t = env.from_string('{{ foo[1, 2] }}') |
|||
assert t.render(foo=Foo()) == u'(1, 2)' |
|||
|
|||
def test_raw2(self, env): |
|||
tmpl = env.from_string('{% raw %}{{ FOO }} and {% BAR %}{% endraw %}') |
|||
assert tmpl.render() == '{{ FOO }} and {% BAR %}' |
|||
|
|||
def test_const(self, env): |
|||
tmpl = env.from_string( |
|||
'{{ true }}|{{ false }}|{{ none }}|' |
|||
'{{ none is defined }}|{{ missing is defined }}') |
|||
assert tmpl.render() == 'True|False|None|True|False' |
|||
|
|||
def test_neg_filter_priority(self, env): |
|||
node = env.parse('{{ -1|foo }}') |
|||
assert isinstance(node.body[0].nodes[0], nodes.Filter) |
|||
assert isinstance(node.body[0].nodes[0].node, nodes.Neg) |
|||
|
|||
def test_const_assign(self, env): |
|||
constass1 = '''{% set true = 42 %}''' |
|||
constass2 = '''{% for none in seq %}{% endfor %}''' |
|||
for tmpl in constass1, constass2: |
|||
pytest.raises(TemplateSyntaxError, env.from_string, tmpl) |
|||
|
|||
def test_localset(self, env): |
|||
tmpl = env.from_string('''{% set foo = 0 %}\ |
|||
{% for item in [1, 2] %}{% set foo = 1 %}{% endfor %}\ |
|||
{{ foo }}''') |
|||
assert tmpl.render() == '0' |
|||
|
|||
def test_parse_unary(self, env): |
|||
tmpl = env.from_string('{{ -foo["bar"] }}') |
|||
assert tmpl.render(foo={'bar': 42}) == '-42' |
|||
tmpl = env.from_string('{{ -foo["bar"]|abs }}') |
|||
assert tmpl.render(foo={'bar': 42}) == '42' |
|||
|
|||
|
|||
@pytest.mark.lexnparse |
|||
@pytest.mark.lstripblocks |
|||
class TestLstripBlocks(): |
|||
|
|||
def test_lstrip(self, env): |
|||
env = Environment(lstrip_blocks=True, trim_blocks=False) |
|||
tmpl = env.from_string(''' {% if True %}\n {% endif %}''') |
|||
assert tmpl.render() == "\n" |
|||
|
|||
def test_lstrip_trim(self, env): |
|||
env = Environment(lstrip_blocks=True, trim_blocks=True) |
|||
tmpl = env.from_string(''' {% if True %}\n {% endif %}''') |
|||
assert tmpl.render() == "" |
|||
|
|||
def test_no_lstrip(self, env): |
|||
env = Environment(lstrip_blocks=True, trim_blocks=False) |
|||
tmpl = env.from_string(''' {%+ if True %}\n {%+ endif %}''') |
|||
assert tmpl.render() == " \n " |
|||
|
|||
def test_lstrip_endline(self, env): |
|||
env = Environment(lstrip_blocks=True, trim_blocks=False) |
|||
tmpl = env.from_string( |
|||
''' hello{% if True %}\n goodbye{% endif %}''') |
|||
assert tmpl.render() == " hello\n goodbye" |
|||
|
|||
def test_lstrip_inline(self, env): |
|||
env = Environment(lstrip_blocks=True, trim_blocks=False) |
|||
tmpl = env.from_string(''' {% if True %}hello {% endif %}''') |
|||
assert tmpl.render() == 'hello ' |
|||
|
|||
def test_lstrip_nested(self, env): |
|||
env = Environment(lstrip_blocks=True, trim_blocks=False) |
|||
tmpl = env.from_string( |
|||
''' {% if True %}a {% if True %}b {% endif %}c {% endif %}''') |
|||
assert tmpl.render() == 'a b c ' |
|||
|
|||
def test_lstrip_left_chars(self, env): |
|||
env = Environment(lstrip_blocks=True, trim_blocks=False) |
|||
tmpl = env.from_string(''' abc {% if True %} |
|||
hello{% endif %}''') |
|||
assert tmpl.render() == ' abc \n hello' |
|||
|
|||
def test_lstrip_embeded_strings(self, env): |
|||
env = Environment(lstrip_blocks=True, trim_blocks=False) |
|||
tmpl = env.from_string(''' {% set x = " {% str %} " %}{{ x }}''') |
|||
assert tmpl.render() == ' {% str %} ' |
|||
|
|||
def test_lstrip_preserve_leading_newlines(self, env): |
|||
env = Environment(lstrip_blocks=True, trim_blocks=False) |
|||
tmpl = env.from_string('''\n\n\n{% set hello = 1 %}''') |
|||
assert tmpl.render() == '\n\n\n' |
|||
|
|||
def test_lstrip_comment(self, env): |
|||
env = Environment(lstrip_blocks=True, trim_blocks=False) |
|||
tmpl = env.from_string(''' {# if True #} |
|||
hello |
|||
{#endif#}''') |
|||
assert tmpl.render() == '\nhello\n' |
|||
|
|||
def test_lstrip_angle_bracket_simple(self, env): |
|||
env = Environment('<%', '%>', '${', '}', '<%#', '%>', '%', '##', |
|||
lstrip_blocks=True, trim_blocks=True) |
|||
tmpl = env.from_string(''' <% if True %>hello <% endif %>''') |
|||
assert tmpl.render() == 'hello ' |
|||
|
|||
def test_lstrip_angle_bracket_comment(self, env): |
|||
env = Environment('<%', '%>', '${', '}', '<%#', '%>', '%', '##', |
|||
lstrip_blocks=True, trim_blocks=True) |
|||
tmpl = env.from_string(''' <%# if True %>hello <%# endif %>''') |
|||
assert tmpl.render() == 'hello ' |
|||
|
|||
def test_lstrip_angle_bracket(self, env): |
|||
env = Environment('<%', '%>', '${', '}', '<%#', '%>', '%', '##', |
|||
lstrip_blocks=True, trim_blocks=True) |
|||
tmpl = env.from_string('''\ |
|||
<%# regular comment %> |
|||
<% for item in seq %> |
|||
${item} ## the rest of the stuff |
|||
<% endfor %>''') |
|||
assert tmpl.render(seq=range(5)) == \ |
|||
''.join('%s\n' % x for x in range(5)) |
|||
|
|||
def test_lstrip_angle_bracket_compact(self, env): |
|||
env = Environment('<%', '%>', '${', '}', '<%#', '%>', '%', '##', |
|||
lstrip_blocks=True, trim_blocks=True) |
|||
tmpl = env.from_string('''\ |
|||
<%#regular comment%> |
|||
<%for item in seq%> |
|||
${item} ## the rest of the stuff |
|||
<%endfor%>''') |
|||
assert tmpl.render(seq=range(5)) == \ |
|||
''.join('%s\n' % x for x in range(5)) |
|||
|
|||
def test_php_syntax_with_manual(self, env): |
|||
env = Environment('<?', '?>', '<?=', '?>', '<!--', '-->', |
|||
lstrip_blocks=True, trim_blocks=True) |
|||
tmpl = env.from_string('''\ |
|||
<!-- I'm a comment, I'm not interesting --> |
|||
<? for item in seq -?> |
|||
<?= item ?> |
|||
<?- endfor ?>''') |
|||
assert tmpl.render(seq=range(5)) == '01234' |
|||
|
|||
def test_php_syntax(self, env): |
|||
env = Environment('<?', '?>', '<?=', '?>', '<!--', '-->', |
|||
lstrip_blocks=True, trim_blocks=True) |
|||
tmpl = env.from_string('''\ |
|||
<!-- I'm a comment, I'm not interesting --> |
|||
<? for item in seq ?> |
|||
<?= item ?> |
|||
<? endfor ?>''') |
|||
assert tmpl.render(seq=range(5)) \ |
|||
== ''.join(' %s\n' % x for x in range(5)) |
|||
|
|||
def test_php_syntax_compact(self, env): |
|||
env = Environment('<?', '?>', '<?=', '?>', '<!--', '-->', |
|||
lstrip_blocks=True, trim_blocks=True) |
|||
tmpl = env.from_string('''\ |
|||
<!-- I'm a comment, I'm not interesting --> |
|||
<?for item in seq?> |
|||
<?=item?> |
|||
<?endfor?>''') |
|||
assert tmpl.render(seq=range(5)) \ |
|||
== ''.join(' %s\n' % x for x in range(5)) |
|||
|
|||
def test_erb_syntax(self, env): |
|||
env = Environment('<%', '%>', '<%=', '%>', '<%#', '%>', |
|||
lstrip_blocks=True, trim_blocks=True) |
|||
# env.from_string('') |
|||
# for n,r in env.lexer.rules.iteritems(): |
|||
# print n |
|||
# print env.lexer.rules['root'][0][0].pattern |
|||
# print "'%s'" % tmpl.render(seq=range(5)) |
|||
tmpl = env.from_string('''\ |
|||
<%# I'm a comment, I'm not interesting %> |
|||
<% for item in seq %> |
|||
<%= item %> |
|||
<% endfor %> |
|||
''') |
|||
assert tmpl.render(seq=range(5)) \ |
|||
== ''.join(' %s\n' % x for x in range(5)) |
|||
|
|||
def test_erb_syntax_with_manual(self, env): |
|||
env = Environment('<%', '%>', '<%=', '%>', '<%#', '%>', |
|||
lstrip_blocks=True, trim_blocks=True) |
|||
tmpl = env.from_string('''\ |
|||
<%# I'm a comment, I'm not interesting %> |
|||
<% for item in seq -%> |
|||
<%= item %> |
|||
<%- endfor %>''') |
|||
assert tmpl.render(seq=range(5)) == '01234' |
|||
|
|||
def test_erb_syntax_no_lstrip(self, env): |
|||
env = Environment('<%', '%>', '<%=', '%>', '<%#', '%>', |
|||
lstrip_blocks=True, trim_blocks=True) |
|||
tmpl = env.from_string('''\ |
|||
<%# I'm a comment, I'm not interesting %> |
|||
<%+ for item in seq -%> |
|||
<%= item %> |
|||
<%- endfor %>''') |
|||
assert tmpl.render(seq=range(5)) == ' 01234' |
|||
|
|||
def test_comment_syntax(self, env): |
|||
env = Environment('<!--', '-->', '${', '}', '<!--#', '-->', |
|||
lstrip_blocks=True, trim_blocks=True) |
|||
tmpl = env.from_string('''\ |
|||
<!--# I'm a comment, I'm not interesting -->\ |
|||
<!-- for item in seq ---> |
|||
${item} |
|||
<!--- endfor -->''') |
|||
assert tmpl.render(seq=range(5)) == '01234' |
|||
@ -1,220 +0,0 @@ |
|||
# -*- coding: utf-8 -*- |
|||
""" |
|||
jinja2.testsuite.loader |
|||
~~~~~~~~~~~~~~~~~~~~~~~ |
|||
|
|||
Test the loaders. |
|||
|
|||
:copyright: (c) 2010 by the Jinja Team. |
|||
:license: BSD, see LICENSE for more details. |
|||
""" |
|||
import os |
|||
import sys |
|||
import tempfile |
|||
import shutil |
|||
import pytest |
|||
|
|||
from jinja2 import Environment, loaders |
|||
from jinja2._compat import PYPY, PY2 |
|||
from jinja2.loaders import split_template_path |
|||
from jinja2.exceptions import TemplateNotFound |
|||
|
|||
|
|||
@pytest.mark.loaders |
|||
class TestLoaders(): |
|||
|
|||
def test_dict_loader(self, dict_loader): |
|||
env = Environment(loader=dict_loader) |
|||
tmpl = env.get_template('justdict.html') |
|||
assert tmpl.render().strip() == 'FOO' |
|||
pytest.raises(TemplateNotFound, env.get_template, 'missing.html') |
|||
|
|||
def test_package_loader(self, package_loader): |
|||
env = Environment(loader=package_loader) |
|||
tmpl = env.get_template('test.html') |
|||
assert tmpl.render().strip() == 'BAR' |
|||
pytest.raises(TemplateNotFound, env.get_template, 'missing.html') |
|||
|
|||
def test_filesystem_loader(self, filesystem_loader): |
|||
env = Environment(loader=filesystem_loader) |
|||
tmpl = env.get_template('test.html') |
|||
assert tmpl.render().strip() == 'BAR' |
|||
tmpl = env.get_template('foo/test.html') |
|||
assert tmpl.render().strip() == 'FOO' |
|||
pytest.raises(TemplateNotFound, env.get_template, 'missing.html') |
|||
|
|||
def test_choice_loader(self, choice_loader): |
|||
env = Environment(loader=choice_loader) |
|||
tmpl = env.get_template('justdict.html') |
|||
assert tmpl.render().strip() == 'FOO' |
|||
tmpl = env.get_template('test.html') |
|||
assert tmpl.render().strip() == 'BAR' |
|||
pytest.raises(TemplateNotFound, env.get_template, 'missing.html') |
|||
|
|||
def test_function_loader(self, function_loader): |
|||
env = Environment(loader=function_loader) |
|||
tmpl = env.get_template('justfunction.html') |
|||
assert tmpl.render().strip() == 'FOO' |
|||
pytest.raises(TemplateNotFound, env.get_template, 'missing.html') |
|||
|
|||
def test_prefix_loader(self, prefix_loader): |
|||
env = Environment(loader=prefix_loader) |
|||
tmpl = env.get_template('a/test.html') |
|||
assert tmpl.render().strip() == 'BAR' |
|||
tmpl = env.get_template('b/justdict.html') |
|||
assert tmpl.render().strip() == 'FOO' |
|||
pytest.raises(TemplateNotFound, env.get_template, 'missing') |
|||
|
|||
def test_caching(self): |
|||
changed = False |
|||
|
|||
class TestLoader(loaders.BaseLoader): |
|||
def get_source(self, environment, template): |
|||
return u'foo', None, lambda: not changed |
|||
env = Environment(loader=TestLoader(), cache_size=-1) |
|||
tmpl = env.get_template('template') |
|||
assert tmpl is env.get_template('template') |
|||
changed = True |
|||
assert tmpl is not env.get_template('template') |
|||
changed = False |
|||
|
|||
env = Environment(loader=TestLoader(), cache_size=0) |
|||
assert env.get_template('template') \ |
|||
is not env.get_template('template') |
|||
|
|||
env = Environment(loader=TestLoader(), cache_size=2) |
|||
t1 = env.get_template('one') |
|||
t2 = env.get_template('two') |
|||
assert t2 is env.get_template('two') |
|||
assert t1 is env.get_template('one') |
|||
t3 = env.get_template('three') |
|||
assert 'one' in env.cache |
|||
assert 'two' not in env.cache |
|||
assert 'three' in env.cache |
|||
|
|||
def test_dict_loader_cache_invalidates(self): |
|||
mapping = {'foo': "one"} |
|||
env = Environment(loader=loaders.DictLoader(mapping)) |
|||
assert env.get_template('foo').render() == "one" |
|||
mapping['foo'] = "two" |
|||
assert env.get_template('foo').render() == "two" |
|||
|
|||
def test_split_template_path(self): |
|||
assert split_template_path('foo/bar') == ['foo', 'bar'] |
|||
assert split_template_path('./foo/bar') == ['foo', 'bar'] |
|||
pytest.raises(TemplateNotFound, split_template_path, '../foo') |
|||
|
|||
|
|||
@pytest.mark.loaders |
|||
@pytest.mark.moduleloader |
|||
class TestModuleLoader(): |
|||
archive = None |
|||
|
|||
def compile_down(self, prefix_loader, zip='deflated', py_compile=False): |
|||
log = [] |
|||
self.reg_env = Environment(loader=prefix_loader) |
|||
if zip is not None: |
|||
fd, self.archive = tempfile.mkstemp(suffix='.zip') |
|||
os.close(fd) |
|||
else: |
|||
self.archive = tempfile.mkdtemp() |
|||
self.reg_env.compile_templates(self.archive, zip=zip, |
|||
log_function=log.append, |
|||
py_compile=py_compile) |
|||
self.mod_env = Environment(loader=loaders.ModuleLoader(self.archive)) |
|||
return ''.join(log) |
|||
|
|||
def teardown(self): |
|||
if hasattr(self, 'mod_env'): |
|||
if os.path.isfile(self.archive): |
|||
os.remove(self.archive) |
|||
else: |
|||
shutil.rmtree(self.archive) |
|||
self.archive = None |
|||
|
|||
def test_log(self, prefix_loader): |
|||
log = self.compile_down(prefix_loader) |
|||
assert 'Compiled "a/foo/test.html" as ' \ |
|||
'tmpl_a790caf9d669e39ea4d280d597ec891c4ef0404a' in log |
|||
assert 'Finished compiling templates' in log |
|||
assert 'Could not compile "a/syntaxerror.html": ' \ |
|||
'Encountered unknown tag \'endif\'' in log |
|||
|
|||
def _test_common(self): |
|||
tmpl1 = self.reg_env.get_template('a/test.html') |
|||
tmpl2 = self.mod_env.get_template('a/test.html') |
|||
assert tmpl1.render() == tmpl2.render() |
|||
|
|||
tmpl1 = self.reg_env.get_template('b/justdict.html') |
|||
tmpl2 = self.mod_env.get_template('b/justdict.html') |
|||
assert tmpl1.render() == tmpl2.render() |
|||
|
|||
def test_deflated_zip_compile(self, prefix_loader): |
|||
self.compile_down(prefix_loader, zip='deflated') |
|||
self._test_common() |
|||
|
|||
def test_stored_zip_compile(self, prefix_loader): |
|||
self.compile_down(prefix_loader, zip='stored') |
|||
self._test_common() |
|||
|
|||
def test_filesystem_compile(self, prefix_loader): |
|||
self.compile_down(prefix_loader, zip=None) |
|||
self._test_common() |
|||
|
|||
def test_weak_references(self, prefix_loader): |
|||
self.compile_down(prefix_loader) |
|||
tmpl = self.mod_env.get_template('a/test.html') |
|||
key = loaders.ModuleLoader.get_template_key('a/test.html') |
|||
name = self.mod_env.loader.module.__name__ |
|||
|
|||
assert hasattr(self.mod_env.loader.module, key) |
|||
assert name in sys.modules |
|||
|
|||
# unset all, ensure the module is gone from sys.modules |
|||
self.mod_env = tmpl = None |
|||
|
|||
try: |
|||
import gc |
|||
gc.collect() |
|||
except: |
|||
pass |
|||
|
|||
assert name not in sys.modules |
|||
|
|||
# This test only makes sense on non-pypy python 2 |
|||
@pytest.mark.skipif( |
|||
not (PY2 and not PYPY), |
|||
reason='This test only makes sense on non-pypy python 2') |
|||
def test_byte_compilation(self, prefix_loader): |
|||
log = self.compile_down(prefix_loader, py_compile=True) |
|||
assert 'Byte-compiled "a/test.html"' in log |
|||
tmpl1 = self.mod_env.get_template('a/test.html') |
|||
mod = self.mod_env.loader.module. \ |
|||
tmpl_3c4ddf650c1a73df961a6d3d2ce2752f1b8fd490 |
|||
assert mod.__file__.endswith('.pyc') |
|||
|
|||
def test_choice_loader(self, prefix_loader): |
|||
log = self.compile_down(prefix_loader) |
|||
|
|||
self.mod_env.loader = loaders.ChoiceLoader([ |
|||
self.mod_env.loader, |
|||
loaders.DictLoader({'DICT_SOURCE': 'DICT_TEMPLATE'}) |
|||
]) |
|||
|
|||
tmpl1 = self.mod_env.get_template('a/test.html') |
|||
assert tmpl1.render() == 'BAR' |
|||
tmpl2 = self.mod_env.get_template('DICT_SOURCE') |
|||
assert tmpl2.render() == 'DICT_TEMPLATE' |
|||
|
|||
def test_prefix_loader(self, prefix_loader): |
|||
log = self.compile_down(prefix_loader) |
|||
|
|||
self.mod_env.loader = loaders.PrefixLoader({ |
|||
'MOD': self.mod_env.loader, |
|||
'DICT': loaders.DictLoader({'test.html': 'DICT_TEMPLATE'}) |
|||
}) |
|||
|
|||
tmpl1 = self.mod_env.get_template('MOD/a/test.html') |
|||
assert tmpl1.render() == 'BAR' |
|||
tmpl2 = self.mod_env.get_template('DICT/test.html') |
|||
assert tmpl2.render() == 'DICT_TEMPLATE' |
|||
@ -1,278 +0,0 @@ |
|||
# -*- coding: utf-8 -*- |
|||
""" |
|||
jinja2.testsuite.regression |
|||
~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
|||
|
|||
Tests corner cases and bugs. |
|||
|
|||
:copyright: (c) 2010 by the Jinja Team. |
|||
:license: BSD, see LICENSE for more details. |
|||
""" |
|||
import pytest |
|||
|
|||
from jinja2 import Template, Environment, DictLoader, TemplateSyntaxError, \ |
|||
TemplateNotFound, PrefixLoader |
|||
from jinja2._compat import text_type |
|||
|
|||
|
|||
@pytest.mark.regression |
|||
class TestCorner(): |
|||
|
|||
def test_assigned_scoping(self, env): |
|||
t = env.from_string(''' |
|||
{%- for item in (1, 2, 3, 4) -%} |
|||
[{{ item }}] |
|||
{%- endfor %} |
|||
{{- item -}} |
|||
''') |
|||
assert t.render(item=42) == '[1][2][3][4]42' |
|||
|
|||
t = env.from_string(''' |
|||
{%- for item in (1, 2, 3, 4) -%} |
|||
[{{ item }}] |
|||
{%- endfor %} |
|||
{%- set item = 42 %} |
|||
{{- item -}} |
|||
''') |
|||
assert t.render() == '[1][2][3][4]42' |
|||
|
|||
t = env.from_string(''' |
|||
{%- set item = 42 %} |
|||
{%- for item in (1, 2, 3, 4) -%} |
|||
[{{ item }}] |
|||
{%- endfor %} |
|||
{{- item -}} |
|||
''') |
|||
assert t.render() == '[1][2][3][4]42' |
|||
|
|||
def test_closure_scoping(self, env): |
|||
t = env.from_string(''' |
|||
{%- set wrapper = "<FOO>" %} |
|||
{%- for item in (1, 2, 3, 4) %} |
|||
{%- macro wrapper() %}[{{ item }}]{% endmacro %} |
|||
{{- wrapper() }} |
|||
{%- endfor %} |
|||
{{- wrapper -}} |
|||
''') |
|||
assert t.render() == '[1][2][3][4]<FOO>' |
|||
|
|||
t = env.from_string(''' |
|||
{%- for item in (1, 2, 3, 4) %} |
|||
{%- macro wrapper() %}[{{ item }}]{% endmacro %} |
|||
{{- wrapper() }} |
|||
{%- endfor %} |
|||
{%- set wrapper = "<FOO>" %} |
|||
{{- wrapper -}} |
|||
''') |
|||
assert t.render() == '[1][2][3][4]<FOO>' |
|||
|
|||
t = env.from_string(''' |
|||
{%- for item in (1, 2, 3, 4) %} |
|||
{%- macro wrapper() %}[{{ item }}]{% endmacro %} |
|||
{{- wrapper() }} |
|||
{%- endfor %} |
|||
{{- wrapper -}} |
|||
''') |
|||
assert t.render(wrapper=23) == '[1][2][3][4]23' |
|||
|
|||
|
|||
@pytest.mark.regression |
|||
class TestBug(): |
|||
|
|||
def test_keyword_folding(self, env): |
|||
env = Environment() |
|||
env.filters['testing'] = lambda value, some: value + some |
|||
assert env.from_string("{{ 'test'|testing(some='stuff') }}") \ |
|||
.render() == 'teststuff' |
|||
|
|||
def test_extends_output_bugs(self, env): |
|||
env = Environment(loader=DictLoader({ |
|||
'parent.html': '(({% block title %}{% endblock %}))' |
|||
})) |
|||
|
|||
t = env.from_string( |
|||
'{% if expr %}{% extends "parent.html" %}{% endif %}' |
|||
'[[{% block title %}title{% endblock %}]]' |
|||
'{% for item in [1, 2, 3] %}({{ item }}){% endfor %}' |
|||
) |
|||
assert t.render(expr=False) == '[[title]](1)(2)(3)' |
|||
assert t.render(expr=True) == '((title))' |
|||
|
|||
def test_urlize_filter_escaping(self, env): |
|||
tmpl = env.from_string('{{ "http://www.example.org/<foo"|urlize }}') |
|||
assert tmpl.render() == '<a href="http://www.example.org/<foo">'\ |
|||
'http://www.example.org/<foo</a>' |
|||
|
|||
def test_loop_call_loop(self, env): |
|||
tmpl = env.from_string(''' |
|||
|
|||
{% macro test() %} |
|||
{{ caller() }} |
|||
{% endmacro %} |
|||
|
|||
{% for num1 in range(5) %} |
|||
{% call test() %} |
|||
{% for num2 in range(10) %} |
|||
{{ loop.index }} |
|||
{% endfor %} |
|||
{% endcall %} |
|||
{% endfor %} |
|||
|
|||
''') |
|||
|
|||
assert tmpl.render().split() \ |
|||
== [text_type(x) for x in range(1, 11)] * 5 |
|||
|
|||
def test_weird_inline_comment(self, env): |
|||
env = Environment(line_statement_prefix='%') |
|||
pytest.raises(TemplateSyntaxError, env.from_string, |
|||
'% for item in seq {# missing #}\n...% endfor') |
|||
|
|||
def test_old_macro_loop_scoping_bug(self, env): |
|||
tmpl = env.from_string('{% for i in (1, 2) %}{{ i }}{% endfor %}' |
|||
'{% macro i() %}3{% endmacro %}{{ i() }}') |
|||
assert tmpl.render() == '123' |
|||
|
|||
def test_partial_conditional_assignments(self, env): |
|||
tmpl = env.from_string('{% if b %}{% set a = 42 %}{% endif %}{{ a }}') |
|||
assert tmpl.render(a=23) == '23' |
|||
assert tmpl.render(b=True) == '42' |
|||
|
|||
def test_stacked_locals_scoping_bug(self, env): |
|||
env = Environment(line_statement_prefix='#') |
|||
t = env.from_string('''\ |
|||
# for j in [1, 2]: |
|||
# set x = 1 |
|||
# for i in [1, 2]: |
|||
# print x |
|||
# if i % 2 == 0: |
|||
# set x = x + 1 |
|||
# endif |
|||
# endfor |
|||
# endfor |
|||
# if a |
|||
# print 'A' |
|||
# elif b |
|||
# print 'B' |
|||
# elif c == d |
|||
# print 'C' |
|||
# else |
|||
# print 'D' |
|||
# endif |
|||
''') |
|||
assert t.render(a=0, b=False, c=42, d=42.0) == '1111C' |
|||
|
|||
def test_stacked_locals_scoping_bug_twoframe(self, env): |
|||
t = Template(''' |
|||
{% set x = 1 %} |
|||
{% for item in foo %} |
|||
{% if item == 1 %} |
|||
{% set x = 2 %} |
|||
{% endif %} |
|||
{% endfor %} |
|||
{{ x }} |
|||
''') |
|||
rv = t.render(foo=[1]).strip() |
|||
assert rv == u'1' |
|||
|
|||
def test_call_with_args(self, env): |
|||
t = Template("""{% macro dump_users(users) -%} |
|||
<ul> |
|||
{%- for user in users -%} |
|||
<li><p>{{ user.username|e }}</p>{{ caller(user) }}</li> |
|||
{%- endfor -%} |
|||
</ul> |
|||
{%- endmacro -%} |
|||
|
|||
{% call(user) dump_users(list_of_user) -%} |
|||
<dl> |
|||
<dl>Realname</dl> |
|||
<dd>{{ user.realname|e }}</dd> |
|||
<dl>Description</dl> |
|||
<dd>{{ user.description }}</dd> |
|||
</dl> |
|||
{% endcall %}""") |
|||
|
|||
assert [x.strip() for x in t.render(list_of_user=[{ |
|||
'username': 'apo', |
|||
'realname': 'something else', |
|||
'description': 'test' |
|||
}]).splitlines()] == [ |
|||
u'<ul><li><p>apo</p><dl>', |
|||
u'<dl>Realname</dl>', |
|||
u'<dd>something else</dd>', |
|||
u'<dl>Description</dl>', |
|||
u'<dd>test</dd>', |
|||
u'</dl>', |
|||
u'</li></ul>' |
|||
] |
|||
|
|||
def test_empty_if_condition_fails(self, env): |
|||
pytest.raises(TemplateSyntaxError, |
|||
Template, '{% if %}....{% endif %}') |
|||
pytest.raises(TemplateSyntaxError, |
|||
Template, '{% if foo %}...{% elif %}...{% endif %}') |
|||
pytest.raises(TemplateSyntaxError, |
|||
Template, '{% for x in %}..{% endfor %}') |
|||
|
|||
def test_recursive_loop_bug(self, env): |
|||
tpl1 = Template(""" |
|||
{% for p in foo recursive%} |
|||
{{p.bar}} |
|||
{% for f in p.fields recursive%} |
|||
{{f.baz}} |
|||
{{p.bar}} |
|||
{% if f.rec %} |
|||
{{ loop(f.sub) }} |
|||
{% endif %} |
|||
{% endfor %} |
|||
{% endfor %} |
|||
""") |
|||
|
|||
tpl2 = Template(""" |
|||
{% for p in foo%} |
|||
{{p.bar}} |
|||
{% for f in p.fields recursive%} |
|||
{{f.baz}} |
|||
{{p.bar}} |
|||
{% if f.rec %} |
|||
{{ loop(f.sub) }} |
|||
{% endif %} |
|||
{% endfor %} |
|||
{% endfor %} |
|||
""") |
|||
|
|||
def test_else_loop_bug(self, env): |
|||
t = Template(''' |
|||
{% for x in y %} |
|||
{{ loop.index0 }} |
|||
{% else %} |
|||
{% for i in range(3) %}{{ i }}{% endfor %} |
|||
{% endfor %} |
|||
''') |
|||
assert t.render(y=[]).strip() == '012' |
|||
|
|||
def test_correct_prefix_loader_name(self, env): |
|||
env = Environment(loader=PrefixLoader({ |
|||
'foo': DictLoader({}) |
|||
})) |
|||
try: |
|||
env.get_template('foo/bar.html') |
|||
except TemplateNotFound as e: |
|||
assert e.name == 'foo/bar.html' |
|||
else: |
|||
assert False, 'expected error here' |
|||
|
|||
def test_contextfunction_callable_classes(self, env): |
|||
from jinja2.utils import contextfunction |
|||
|
|||
class CallableClass(object): |
|||
@contextfunction |
|||
def __call__(self, ctx): |
|||
return ctx.resolve('hello') |
|||
|
|||
tpl = Template("""{{ callableclass() }}""") |
|||
output = tpl.render(callableclass=CallableClass(), hello='TEST') |
|||
expected = 'TEST' |
|||
|
|||
assert output == expected |
|||
@ -1,161 +0,0 @@ |
|||
# -*- coding: utf-8 -*- |
|||
""" |
|||
jinja2.testsuite.security |
|||
~~~~~~~~~~~~~~~~~~~~~~~~~ |
|||
|
|||
Checks the sandbox and other security features. |
|||
|
|||
:copyright: (c) 2010 by the Jinja Team. |
|||
:license: BSD, see LICENSE for more details. |
|||
""" |
|||
import pytest |
|||
|
|||
from jinja2 import Environment |
|||
from jinja2.sandbox import SandboxedEnvironment, \ |
|||
ImmutableSandboxedEnvironment, unsafe |
|||
from jinja2 import Markup, escape |
|||
from jinja2.exceptions import SecurityError, TemplateSyntaxError, \ |
|||
TemplateRuntimeError |
|||
from jinja2._compat import text_type |
|||
|
|||
|
|||
class PrivateStuff(object): |
|||
|
|||
def bar(self): |
|||
return 23 |
|||
|
|||
@unsafe |
|||
def foo(self): |
|||
return 42 |
|||
|
|||
def __repr__(self): |
|||
return 'PrivateStuff' |
|||
|
|||
|
|||
class PublicStuff(object): |
|||
bar = lambda self: 23 |
|||
_foo = lambda self: 42 |
|||
|
|||
def __repr__(self): |
|||
return 'PublicStuff' |
|||
|
|||
|
|||
@pytest.mark.sandbox |
|||
class TestSandbox(): |
|||
|
|||
def test_unsafe(self, env): |
|||
env = SandboxedEnvironment() |
|||
pytest.raises(SecurityError, env.from_string("{{ foo.foo() }}").render, |
|||
foo=PrivateStuff()) |
|||
assert env.from_string("{{ foo.bar() }}").render(foo=PrivateStuff()) == '23' |
|||
|
|||
pytest.raises(SecurityError, |
|||
env.from_string("{{ foo._foo() }}").render, |
|||
foo=PublicStuff()) |
|||
assert env.from_string("{{ foo.bar() }}").render(foo=PublicStuff()) == '23' |
|||
assert env.from_string("{{ foo.__class__ }}").render(foo=42) == '' |
|||
assert env.from_string("{{ foo.func_code }}").render(foo=lambda:None) == '' |
|||
# security error comes from __class__ already. |
|||
pytest.raises(SecurityError, env.from_string( |
|||
"{{ foo.__class__.__subclasses__() }}").render, foo=42) |
|||
|
|||
def test_immutable_environment(self, env): |
|||
env = ImmutableSandboxedEnvironment() |
|||
pytest.raises(SecurityError, env.from_string( |
|||
'{{ [].append(23) }}').render) |
|||
pytest.raises(SecurityError, env.from_string( |
|||
'{{ {1:2}.clear() }}').render) |
|||
|
|||
def test_restricted(self, env): |
|||
env = SandboxedEnvironment() |
|||
pytest.raises(TemplateSyntaxError, env.from_string, |
|||
"{% for item.attribute in seq %}...{% endfor %}") |
|||
pytest.raises(TemplateSyntaxError, env.from_string, |
|||
"{% for foo, bar.baz in seq %}...{% endfor %}") |
|||
|
|||
def test_markup_operations(self, env): |
|||
# adding two strings should escape the unsafe one |
|||
unsafe = '<script type="application/x-some-script">alert("foo");</script>' |
|||
safe = Markup('<em>username</em>') |
|||
assert unsafe + safe == text_type(escape(unsafe)) + text_type(safe) |
|||
|
|||
# string interpolations are safe to use too |
|||
assert Markup('<em>%s</em>') % '<bad user>' == \ |
|||
'<em><bad user></em>' |
|||
assert Markup('<em>%(username)s</em>') % { |
|||
'username': '<bad user>' |
|||
} == '<em><bad user></em>' |
|||
|
|||
# an escaped object is markup too |
|||
assert type(Markup('foo') + 'bar') is Markup |
|||
|
|||
# and it implements __html__ by returning itself |
|||
x = Markup("foo") |
|||
assert x.__html__() is x |
|||
|
|||
# it also knows how to treat __html__ objects |
|||
class Foo(object): |
|||
def __html__(self): |
|||
return '<em>awesome</em>' |
|||
|
|||
def __unicode__(self): |
|||
return 'awesome' |
|||
assert Markup(Foo()) == '<em>awesome</em>' |
|||
assert Markup('<strong>%s</strong>') % Foo() == \ |
|||
'<strong><em>awesome</em></strong>' |
|||
|
|||
# escaping and unescaping |
|||
assert escape('"<>&\'') == '"<>&'' |
|||
assert Markup("<em>Foo & Bar</em>").striptags() == "Foo & Bar" |
|||
assert Markup("<test>").unescape() == "<test>" |
|||
|
|||
def test_template_data(self, env): |
|||
env = Environment(autoescape=True) |
|||
t = env.from_string('{% macro say_hello(name) %}' |
|||
'<p>Hello {{ name }}!</p>{% endmacro %}' |
|||
'{{ say_hello("<blink>foo</blink>") }}') |
|||
escaped_out = '<p>Hello <blink>foo</blink>!</p>' |
|||
assert t.render() == escaped_out |
|||
assert text_type(t.module) == escaped_out |
|||
assert escape(t.module) == escaped_out |
|||
assert t.module.say_hello('<blink>foo</blink>') == escaped_out |
|||
assert escape(t.module.say_hello('<blink>foo</blink>')) == escaped_out |
|||
|
|||
def test_attr_filter(self, env): |
|||
env = SandboxedEnvironment() |
|||
tmpl = env.from_string('{{ cls|attr("__subclasses__")() }}') |
|||
pytest.raises(SecurityError, tmpl.render, cls=int) |
|||
|
|||
def test_binary_operator_intercepting(self, env): |
|||
def disable_op(left, right): |
|||
raise TemplateRuntimeError('that operator so does not work') |
|||
for expr, ctx, rv in ('1 + 2', {}, '3'), ('a + 2', {'a': 2}, '4'): |
|||
env = SandboxedEnvironment() |
|||
env.binop_table['+'] = disable_op |
|||
t = env.from_string('{{ %s }}' % expr) |
|||
assert t.render(ctx) == rv |
|||
env.intercepted_binops = frozenset(['+']) |
|||
t = env.from_string('{{ %s }}' % expr) |
|||
try: |
|||
t.render(ctx) |
|||
except TemplateRuntimeError as e: |
|||
pass |
|||
else: |
|||
assert False, 'expected runtime error' |
|||
|
|||
def test_unary_operator_intercepting(self, env): |
|||
def disable_op(arg): |
|||
raise TemplateRuntimeError('that operator so does not work') |
|||
for expr, ctx, rv in ('-1', {}, '-1'), ('-a', {'a': 2}, '-2'): |
|||
env = SandboxedEnvironment() |
|||
env.unop_table['-'] = disable_op |
|||
t = env.from_string('{{ %s }}' % expr) |
|||
assert t.render(ctx) == rv |
|||
env.intercepted_unops = frozenset(['-']) |
|||
t = env.from_string('{{ %s }}' % expr) |
|||
try: |
|||
t.render(ctx) |
|||
except TemplateRuntimeError as e: |
|||
pass |
|||
else: |
|||
assert False, 'expected runtime error' |
|||
@ -1,104 +0,0 @@ |
|||
# -*- coding: utf-8 -*- |
|||
""" |
|||
jinja2.testsuite.tests |
|||
~~~~~~~~~~~~~~~~~~~~~~ |
|||
|
|||
Who tests the tests? |
|||
|
|||
:copyright: (c) 2010 by the Jinja Team. |
|||
:license: BSD, see LICENSE for more details. |
|||
""" |
|||
import pytest |
|||
|
|||
from jinja2 import Markup, Environment |
|||
|
|||
|
|||
@pytest.mark.test_tests |
|||
class TestTestsCase(): |
|||
|
|||
def test_defined(self, env): |
|||
tmpl = env.from_string('{{ missing is defined }}|' |
|||
'{{ true is defined }}') |
|||
assert tmpl.render() == 'False|True' |
|||
|
|||
def test_even(self, env): |
|||
tmpl = env.from_string('''{{ 1 is even }}|{{ 2 is even }}''') |
|||
assert tmpl.render() == 'False|True' |
|||
|
|||
def test_odd(self, env): |
|||
tmpl = env.from_string('''{{ 1 is odd }}|{{ 2 is odd }}''') |
|||
assert tmpl.render() == 'True|False' |
|||
|
|||
def test_lower(self, env): |
|||
tmpl = env.from_string('''{{ "foo" is lower }}|{{ "FOO" is lower }}''') |
|||
assert tmpl.render() == 'True|False' |
|||
|
|||
def test_typechecks(self, env): |
|||
tmpl = env.from_string(''' |
|||
{{ 42 is undefined }} |
|||
{{ 42 is defined }} |
|||
{{ 42 is none }} |
|||
{{ none is none }} |
|||
{{ 42 is number }} |
|||
{{ 42 is string }} |
|||
{{ "foo" is string }} |
|||
{{ "foo" is sequence }} |
|||
{{ [1] is sequence }} |
|||
{{ range is callable }} |
|||
{{ 42 is callable }} |
|||
{{ range(5) is iterable }} |
|||
{{ {} is mapping }} |
|||
{{ mydict is mapping }} |
|||
{{ [] is mapping }} |
|||
{{ 10 is number }} |
|||
{{ (10 ** 100) is number }} |
|||
{{ 3.14159 is number }} |
|||
{{ complex is number }} |
|||
''') |
|||
|
|||
class MyDict(dict): |
|||
pass |
|||
|
|||
assert tmpl.render(mydict=MyDict(), complex=complex(1, 2)).split() == [ |
|||
'False', 'True', 'False', 'True', 'True', 'False', |
|||
'True', 'True', 'True', 'True', 'False', 'True', |
|||
'True', 'True', 'False', 'True', 'True', 'True', 'True' |
|||
] |
|||
|
|||
def test_sequence(self, env): |
|||
tmpl = env.from_string( |
|||
'{{ [1, 2, 3] is sequence }}|' |
|||
'{{ "foo" is sequence }}|' |
|||
'{{ 42 is sequence }}' |
|||
) |
|||
assert tmpl.render() == 'True|True|False' |
|||
|
|||
def test_upper(self, env): |
|||
tmpl = env.from_string('{{ "FOO" is upper }}|{{ "foo" is upper }}') |
|||
assert tmpl.render() == 'True|False' |
|||
|
|||
def test_equalto(self, env): |
|||
tmpl = env.from_string('{{ foo is equalto 12 }}|' |
|||
'{{ foo is equalto 0 }}|' |
|||
'{{ foo is equalto (3 * 4) }}|' |
|||
'{{ bar is equalto "baz" }}|' |
|||
'{{ bar is equalto "zab" }}|' |
|||
'{{ bar is equalto ("ba" + "z") }}|' |
|||
'{{ bar is equalto bar }}|' |
|||
'{{ bar is equalto foo }}') |
|||
assert tmpl.render(foo=12, bar="baz") \ |
|||
== 'True|False|True|True|False|True|True|False' |
|||
|
|||
def test_sameas(self, env): |
|||
tmpl = env.from_string('{{ foo is sameas false }}|' |
|||
'{{ 0 is sameas false }}') |
|||
assert tmpl.render(foo=False) == 'True|False' |
|||
|
|||
def test_no_paren_for_arg1(self, env): |
|||
tmpl = env.from_string('{{ foo is sameas none }}') |
|||
assert tmpl.render(foo=None) == 'True' |
|||
|
|||
def test_escaped(self, env): |
|||
env = Environment(autoescape=True) |
|||
tmpl = env.from_string('{{ x is escaped }}|{{ y is escaped }}') |
|||
assert tmpl.render(x='foo', y=Markup('foo')) == 'False|True' |
|||
@ -1,76 +0,0 @@ |
|||
# -*- coding: utf-8 -*- |
|||
""" |
|||
jinja2.testsuite.utils |
|||
~~~~~~~~~~~~~~~~~~~~~~ |
|||
|
|||
Tests utilities jinja uses. |
|||
|
|||
:copyright: (c) 2010 by the Jinja Team. |
|||
:license: BSD, see LICENSE for more details. |
|||
""" |
|||
import gc |
|||
|
|||
import pytest |
|||
|
|||
import pickle |
|||
|
|||
from jinja2.utils import LRUCache, escape, object_type_repr |
|||
|
|||
|
|||
@pytest.mark.utils |
|||
@pytest.mark.lrucache |
|||
class TestLRUCache(): |
|||
|
|||
def test_simple(self): |
|||
d = LRUCache(3) |
|||
d["a"] = 1 |
|||
d["b"] = 2 |
|||
d["c"] = 3 |
|||
d["a"] |
|||
d["d"] = 4 |
|||
assert len(d) == 3 |
|||
assert 'a' in d and 'c' in d and 'd' in d and 'b' not in d |
|||
|
|||
def test_pickleable(self): |
|||
cache = LRUCache(2) |
|||
cache["foo"] = 42 |
|||
cache["bar"] = 23 |
|||
cache["foo"] |
|||
|
|||
for protocol in range(3): |
|||
copy = pickle.loads(pickle.dumps(cache, protocol)) |
|||
assert copy.capacity == cache.capacity |
|||
assert copy._mapping == cache._mapping |
|||
assert copy._queue == cache._queue |
|||
|
|||
|
|||
@pytest.mark.utils |
|||
@pytest.mark.helpers |
|||
class TestHelpers(): |
|||
|
|||
def test_object_type_repr(self): |
|||
class X(object): |
|||
pass |
|||
assert object_type_repr(42) == 'int object' |
|||
assert object_type_repr([]) == 'list object' |
|||
assert object_type_repr(X()) == 'test_utils.X object' |
|||
assert object_type_repr(None) == 'None' |
|||
assert object_type_repr(Ellipsis) == 'Ellipsis' |
|||
|
|||
|
|||
@pytest.mark.utils |
|||
@pytest.mark.markupleak |
|||
@pytest.mark.skipif(hasattr(escape, 'func_code'), |
|||
reason='this test only tests the c extension') |
|||
class TestMarkupLeak(): |
|||
|
|||
def test_markup_leaks(self): |
|||
counts = set() |
|||
for count in range(20): |
|||
for item in range(1000): |
|||
escape("foo") |
|||
escape("<foo>") |
|||
escape(u"foo") |
|||
escape(u"<foo>") |
|||
counts.add(len(gc.get_objects())) |
|||
assert len(counts) == 1, 'ouch, c extension seems to leak objects' |
|||
Loading…
Reference in new issue