def test_cache_loader_change(self):
loader1 = loaders.DictLoader({"foo": "one"})
loader2 = loaders.DictLoader({"foo": "two"})
env = Environment(loader=loader1, cache_size=2)
assert env.get_template("foo").render() == "one"
env.loader = loader2
assert env.get_template("foo").render() == "two"
def test_cache_loader_change(self):
loader1 = loaders.DictLoader({'foo': 'one'})
loader2 = loaders.DictLoader({'foo': 'two'})
env = Environment(loader=loader1, cache_size=2)
assert env.get_template('foo').render() == 'one'
env.loader = loader2
assert env.get_template('foo').render() == 'two'
def test_choice_loader(self):
log = self.compile_down(py_compile=True)
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')
self.assert_equal(tmpl1.render(), 'BAR')
tmpl2 = self.mod_env.get_template('DICT_SOURCE')
self.assert_equal(tmpl2.render(), 'DICT_TEMPLATE')
def test_prefix_loader(self):
log = self.compile_down(py_compile=True)
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')
self.assert_equal(tmpl1.render(), 'BAR')
tmpl2 = self.mod_env.get_template('DICT/test.html')
self.assert_equal(tmpl2.render(), 'DICT_TEMPLATE')
def test_choice_loader(self, prefix_loader):
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):
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"
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_limited_size_cache(self):
mapping = {'one': 'foo', 'two': 'bar', 'three': 'baz'}
loader = loaders.DictLoader(mapping)
env = Environment(loader=loader, 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 (id(loader), 'one') in env.cache
assert (id(loader), 'two') not in env.cache
assert (id(loader), 'three') in env.cache
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'
def test_limited_size_cache(self):
mapping = {"one": "foo", "two": "bar", "three": "baz"}
loader = loaders.DictLoader(mapping)
env = Environment(loader=loader, 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")
env.get_template("three")
loader_ref = weakref.ref(loader)
assert (loader_ref, "one") in env.cache
assert (loader_ref, "two") not in env.cache
assert (loader_ref, "three") in env.cache
def render_target(project_loader: loaders.BaseLoader,
project_variables: typing.Mapping[str, str],
target: TargetConfig):
variables = dict(project_variables)
variables.update(target.variables)
layout = build_layout(target.transaction)
layout_loader = loaders.DictLoader({"layout": layout})
target_loader = loaders.ChoiceLoader([project_loader, layout_loader])
render_text = render_abstract(target.schema_template,
target_loader,
variables)
return render_text
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"
the same time.
:copyright: (c) 2010 by the Jinja Team.
:license: BSD, see LICENSE for more details.
"""
import os
import re
import sys
import unittest
from traceback import format_exception
from jinja2 import loaders
from jinja2._compat import PY2
here = os.path.dirname(os.path.abspath(__file__))
dict_loader = loaders.DictLoader({'justdict.html': 'FOO'})
package_loader = loaders.PackageLoader('jinja2.testsuite.res', 'templates')
filesystem_loader = loaders.FileSystemLoader(here + '/res/templates')
function_loader = loaders.FunctionLoader({'justfunction.html': 'FOO'}.get)
choice_loader = loaders.ChoiceLoader([dict_loader, package_loader])
prefix_loader = loaders.PrefixLoader({
'a': filesystem_loader,
'b': dict_loader
})
class JinjaTestCase(unittest.TestCase):
### use only these methods for testing. If you need standard
### unittest method, wrap them!
def dict_loader():
'''returns DictLoader
'''
return loaders.DictLoader({'justdict.html': 'FOO'})
def dict_loader():
"""returns DictLoader"""
return loaders.DictLoader({"justdict.html": "FOO"})
def test_no_cache(self):
mapping = {"foo": "one"}
env = Environment(loader=loaders.DictLoader(mapping), cache_size=0)
assert env.get_template("foo") is not env.get_template("foo")
def test_no_cache(self):
mapping = {'foo': 'one'}
env = Environment(loader=loaders.DictLoader(mapping), cache_size=0)
assert env.get_template('foo') is not env.get_template('foo')
def test():
dict_loader = loaders.DictLoader({
"__init__.py":
"""# -*- coding: utf-8 -*-
from __future__ import print_function
from flask import Blueprint
module = Blueprint("{{ bp_name }}", __name__, template_folder="templates", static_folder="static")
from . import views""",
"views.py":
"""# -*- coding: utf-8 -*-
'''
For URL Query parameter, use request.args
search = request.args.get("search")
page = request.args.get("page")
For Form input, use request.form
email = request.form.get('email')
password = request.form.get('password')
For data type application/json, use request.data
# data in string format and you have to parse into dictionary
data = request.data
dataDict = json.loads(data)
'''
from __future__ import print_function
from flask import current_app, render_template, abort, request, make_response, flash, redirect, url_for, json
from flask_login import current_user, login_required
from . import module
{%- if messages %} {%- endif %}
@module.route('/hello/')
@module.route('/hello/<name>', methods=['GET', 'POST'])
def hello(name=None):
current_app.logger.debug('A value for debugging')
current_app.logger.error('An error occurred')
resp = make_response(render_template("{{ bp_name }}/hello.html", user=name))
resp.headers['Content-type'] = 'text/xml; charset=utf-8'
return resp
@module.route("/page/", defaults={"page": 4, "per_page":1}, methods=["GET", "POST"])
@module.route("/page/<int:page>/<int:per_page>", methods=["GET", "POST"])
def pagination(page, per_page):
#page = 4
#per_page = 1
offset = (page - 1) * per_page
# 分页方法
users = User.query.offset(offset).limit(per_page)
# 等同于下面的 slice 方法
# users = User.query.slice(3, 4)
return users
@module.route("{{ uri }}")
def run():
bad_var = '<script>alert("gotcha");</script>'
return render_template("{{ bp_name }}/index.html", name="names demo", number=2, script=bad_var)""",
})
env = Environment(loader=dict_loader)
tmpl = env.get_template("__init__.py")
print(tmpl.render(bp_name="xxx").strip())
tmpl = env.get_template("views.py")
print(tmpl.render(bp_name="xxxx", uri="/xxx/xxx/<int:aa>").strip())
print(index_html)
