File Manager

X7ROOT File Manager

Current Path: /usr/lib/python2.7/site-packages/jinja2/testsuite

usr / lib / python2.7 / site-packages / jinja2 / testsuite /

📁 ..
📄 __init__.py(4.53 KB)
📄 __init__.pyc(6.32 KB)
📄 __init__.pyo(6.32 KB)
📄 api.py(10.14 KB)
📄 api.pyc(12.96 KB)
📄 api.pyo(11.26 KB)
📄 bytecode_cache.py(928 B)
📄 bytecode_cache.pyc(1.6 KB)
📄 bytecode_cache.pyo(1.52 KB)
📄 core_tags.py(11.58 KB)
📄 core_tags.pyc(17.46 KB)
📄 core_tags.pyo(14.64 KB)
📄 debug.py(1.89 KB)
📄 debug.pyc(3.05 KB)
📄 debug.pyo(3.05 KB)
📄 doctests.py(905 B)
📄 doctests.pyc(1.16 KB)
📄 doctests.pyo(1.16 KB)
📄 ext.py(17.66 KB)
📄 ext.pyc(22.57 KB)
📄 ext.pyo(18.96 KB)
📄 filters.py(18.72 KB)
📄 filters.pyc(28.54 KB)
📄 filters.pyo(24.28 KB)
📄 imports.py(5.21 KB)
📄 imports.pyc(6.66 KB)
📄 imports.pyo(5.69 KB)
📄 inheritance.py(8.05 KB)
📄 inheritance.pyc(10.33 KB)
📄 inheritance.pyo(8.32 KB)
📄 lexnparse.py(21.79 KB)
📄 lexnparse.pyc(32.97 KB)
📄 lexnparse.pyo(27.24 KB)
📄 loader.py(7.97 KB)
📄 loader.pyc(10.38 KB)
📄 loader.pyo(9 KB)
📄 regression.py(8.19 KB)
📄 regression.pyc(11.46 KB)
📄 regression.pyo(9.96 KB)
📁 res
📄 security.py(6.06 KB)
📄 security.pyc(8.37 KB)
📄 security.pyo(7.4 KB)
📄 tests.py(2.8 KB)
📄 tests.pyc(4.7 KB)
📄 tests.pyo(4.05 KB)
📄 utils.py(2.18 KB)
📄 utils.pyc(3.49 KB)
📄 utils.pyo(3.19 KB)

Editing: imports.py

# -*- 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 unittest

from jinja2.testsuite import JinjaTestCase

from jinja2 import Environment, DictLoader
from jinja2.exceptions import TemplateNotFound, TemplatesNotFound

test_env = Environment(loader=DictLoader(dict(
    module='{% macro test() %}[{{ foo }}|{{ bar }}]{% endmacro %}',
    header='[{{ foo }}|{{ 23 }}]',
    o_printer='({{ o }})'
)))
test_env.globals['bar'] = 23

class ImportsTestCase(JinjaTestCase):

def test_context_imports(self):
        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.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):
        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')

class IncludesTestCase(JinjaTestCase):

def test_context_include(self):
        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):
        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"] %}')
        self.assert_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):
        t = test_env.from_string('{% include "missing" %}')
        self.assert_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):
        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):
        t = test_env.from_string("""
            {% macro outer(o) %}
            {% macro inner() %}
            {% include "o_printer" %}
            {% endmacro %}
            {{ inner() }}
            {% endmacro %}
            {{ outer("FOO") }}
        """)
        assert t.render().strip() == '(FOO)'

def suite():
    suite = unittest.TestSuite()
    suite.addTest(unittest.makeSuite(ImportsTestCase))
    suite.addTest(unittest.makeSuite(IncludesTestCase))
    return suite

X7ROOT File Manager

Editing: imports.py

Upload File

Create Folder