from __future__ import with_statement
from attest import Assert
from flask import current_app
from genshi.filters import Translator
from flaskext.genshi import render_template
from tests.utils import flask_tests
i18n = flask_tests()
@i18n.test
def does_translations():
"""Callback interface is able to inject Translator filter"""
genshi = current_app.extensions['genshi']
@genshi.template_parsed
def callback(template):
Translator(lambda s: s.upper()).setup(template)
rendered = Assert(render_template('i18n.html'))
expected = ('<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" '
'"http://www.w3.org/TR/html4/strict.dtd">\n'
'<p>HELLO!</p>')
assert rendered == expected
from __future__ import with_statement
from attest import Assert
from flaskext.genshi import render_template
from tests.utils import flask_tests
modules = flask_tests()
@modules.test
def loads_module_templates(context):
"""Templates can be loaded from module packages"""
rendered = Assert(
render_template('package_mod/module-template.txt', context))
assert rendered == 'Hello modular Rudolf\n'
@modules.test
def overrides_module_templates(context):
"""Module templates can be overridden with application templates"""
rendered = Assert(
render_template('package_mod/nonmodule-template.txt', context))
assert rendered == 'Hello nonmodular Rudolf\n'
from __future__ import with_statement
from attest import Assert
from flaskext.genshi import render_response
from tests.utils import flask_tests
strings = flask_tests()
@strings.test
def renders_strings(context):
"""Strings can be rendered as templates directly"""
rendered = Assert(
render_response(string='The name is $name',
context=context,
method='text'))
assert rendered.data == 'The name is Rudolf'
@strings.test
def fails_without_template_or_string(context):
"""A template or string must be provided to render"""
with Assert.raises(RuntimeError):
render_response(context=context, method='text')
from __future__ import with_statement
from attest import Assert
from flaskext.genshi import render_response
from tests.utils import flask_tests
strings = flask_tests()
@strings.test
def renders_strings(context):
"""Strings can be rendered as templates directly"""
rendered = Assert(render_response(string='The name is $name',
context=context, method='text'))
assert rendered.data == 'The name is Rudolf'
@strings.test
def fails_without_template_or_string(context):
"""A template or string must be provided to render"""
with Assert.raises(RuntimeError):
render_response(context=context, method='text')
from __future__ import with_statement
from attest import Assert
from flaskext.genshi import render_response, render
from tests.utils import flask_tests
rendering = flask_tests()
@rendering.test
def renders_html(context):
"""A html extension results in an HTML doctype and mimetype"""
rendered = Assert(render_response('test.html', context))
expected_data = ('<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" '
'"http://www.w3.org/TR/html4/strict.dtd">\n'
'<body>Hi Rudolf</body>')
assert rendered.mimetype == 'text/html'
assert rendered.data == expected_data
@rendering.test
def renders_text(context):
"""A txt extension results in no doctype and a text/plain mimetype"""
rendered = Assert(render_response('test.txt', context))
assert rendered.mimetype == 'text/plain'
assert rendered.data == 'Hi Rudolf\n'
from __future__ import with_statement
from attest import Assert
from flaskext.genshi import render_response, render
from tests.utils import flask_tests
rendering = flask_tests()
@rendering.test
def renders_html(context):
"""A html extension results in an HTML doctype and mimetype"""
rendered = Assert(render_response('test.html', context))
expected_data = ('<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" '
'"http://www.w3.org/TR/html4/strict.dtd">\n'
'<body>Hi Rudolf</body>')
assert rendered.mimetype == 'text/html'
assert rendered.data == expected_data
@rendering.test
def renders_text(context):
"""A txt extension results in no doctype and a text/plain mimetype"""
rendered = Assert(render_response('test.txt', context))
assert rendered.mimetype == 'text/plain'
assert rendered.data == 'Hi Rudolf\n'
from __future__ import with_statement
from attest import Assert
from flaskext.genshi import render_template
from tests.utils import flask_tests
jinja = flask_tests()
@jinja.test
def provides_jinja_tests_and_filters():
"""Jinja tests and filters should be provided as context dictionaries."""
rendered = Assert(render_template('jinja_tests_and_filters.html'))
expected_data = ('<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" '
'"http://www.w3.org/TR/html4/strict.dtd">\n'
'<p class="odd">\n'
' Hello ...\n'
' <span class="even">\n'
' Hello ...\n'
' </span>\n'
'</p>')
assert rendered == expected_data
from attest import Assert
from genshi.filters import Transformer
from flask import current_app
from flaskext.genshi import render_template
from flatland.out.genshi import setup as flatland_setup
from flatland import Form, String
from tests.utils import flask_tests
class TestForm(Form):
username = String
filters = flask_tests()
@filters.test
def applies_method_filters():
"""Method filters are applied for generated and rendered templates"""
genshi = current_app.extensions['genshi']
@genshi.filter('html')
def prepend_title(template):
return template | Transformer('head/title').prepend('Flask-Genshi - ')
rendered = Assert(render_template('filter.html'))
expected = ('<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" '
'"http://www.w3.org/TR/html4/strict.dtd">\n'
from __future__ import with_statement
from flask import current_app
from flaskext.genshi import render_response
from tests.utils import flask_tests
contexts = flask_tests()
@contexts.test
def updates_context():
"""Render calls update the template context with context processors"""
@current_app.context_processor
def inject_rudolf():
return dict(rudolf='The red-nosed reindeer')
render_response('context.html')
from __future__ import with_statement
from attest import Assert
from flask import current_app
from genshi.filters import Translator
from flaskext.genshi import render_template
from tests.utils import flask_tests
i18n = flask_tests()
@i18n.test
def does_translations():
"""Callback interface is able to inject Translator filter"""
genshi = current_app.extensions['genshi']
@genshi.template_parsed
def callback(template):
Translator(lambda s: s.upper()).setup(template)
rendered = Assert(render_template('i18n.html'))
expected = ('<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" '
'"http://www.w3.org/TR/html4/strict.dtd">\n'
'<p>HELLO!</p>')
assert rendered == expected
from attest import Assert
from genshi.filters import Transformer
from flask import current_app
from flaskext.genshi import render_template
from flatland.out.genshi import setup as flatland_setup
from flatland import Form, String
from tests.utils import flask_tests
class TestForm(Form):
username = String
filters = flask_tests()
@filters.test
def applies_method_filters():
"""Method filters are applied for generated and rendered templates"""
genshi = current_app.extensions['genshi']
@genshi.filter('html')
def prepend_title(template):
return template | Transformer('head/title').prepend('Flask-Genshi - ')
rendered = Assert(render_template('filter.html'))
expected = ('<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" '
'"http://www.w3.org/TR/html4/strict.dtd">\n'
'<html><head><title>Flask-Genshi - Hi!</title></head></html>')
from __future__ import with_statement
from attest import Assert
from flaskext.genshi import render_template
from tests.utils import flask_tests
modules = flask_tests()
@modules.test
def loads_module_templates(context):
"""Templates can be loaded from module packages"""
rendered = Assert(render_template('package_mod/module-template.txt',
context))
assert rendered == 'Hello modular Rudolf\n'
@modules.test
def overrides_module_templates(context):
"""Module templates can be overridden with application templates"""
rendered = Assert(render_template('package_mod/nonmodule-template.txt',
context))
assert rendered == 'Hello nonmodular Rudolf\n'
from tests.utils import flask_tests
@contextmanager
def captured_templates(app):
recorded = Assert([])
def record(app, template, context):
recorded.append((template, context))
template_generated.connect(record, app)
try:
yield recorded
finally:
template_generated.disconnect(record, app)
signals = flask_tests()
@signals.test
def signals_are_emitted(context):
"""Signal is emitted when templates are generated"""
app = current_app._get_current_object()
with captured_templates(app) as templates:
render_template('test.html', context)
assert templates.__len__() == 1
assert templates[0][0].filename == 'test.html'
assert templates[0][1]['name'] == 'Rudolf'
from __future__ import with_statement
from flask import current_app
from flaskext.genshi import render_response
from tests.utils import flask_tests
contexts = flask_tests()
@contexts.test
def updates_context():
"""Render calls update the template context with context processors"""
@current_app.context_processor
def inject_rudolf():
return dict(rudolf='The red-nosed reindeer')
render_response('context.html')
