Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Browse files

Split up testsuite and moved it to flask.testsuite. This fixes #246

  • Loading branch information...
commit 4cb6eea8f1e1edc707874f72cbca43a0f698ec7d 1 parent 85ed1bf
@mitsuhiko authored
Showing with 2,575 additions and 2,336 deletions.
  1. +121 −0 flask/testsuite/__init__.py
  2. +992 −0 flask/testsuite/basic.py
  3. +423 −0 flask/testsuite/blueprints.py
  4. +177 −0 flask/testsuite/config.py
  5. +38 −0 flask/testsuite/deprecations.py
  6. +38 −0 flask/testsuite/examples.py
  7. +295 −0 flask/testsuite/helpers.py
  8. +103 −0 flask/testsuite/signals.py
  9. 0  {tests → flask/testsuite}/static/index.html
  10. 0  {tests → flask/testsuite}/templates/_macro.html
  11. 0  {tests → flask/testsuite}/templates/context_template.html
  12. 0  {tests → flask/testsuite}/templates/escaping_template.html
  13. 0  {tests → flask/testsuite}/templates/mail.txt
  14. 0  {tests → flask/testsuite}/templates/nested/nested.txt
  15. 0  {tests → flask/testsuite}/templates/simple_template.html
  16. 0  {tests → flask/testsuite}/templates/template_filter.html
  17. +141 −0 flask/testsuite/templating.py
  18. 0  {tests → flask/testsuite/test_apps}/blueprintapp/__init__.py
  19. 0  {tests/moduleapp → flask/testsuite/test_apps/blueprintapp}/apps/__init__.py
  20. 0  {tests → flask/testsuite/test_apps}/blueprintapp/apps/admin/__init__.py
  21. 0  {tests/moduleapp → flask/testsuite/test_apps/blueprintapp}/apps/admin/static/css/test.css
  22. 0  {tests/moduleapp → flask/testsuite/test_apps/blueprintapp}/apps/admin/static/test.txt
  23. 0  ...p/apps/admin/templates → flask/testsuite/test_apps/blueprintapp/apps/admin/templates/admin}/index.html
  24. 0  {tests → flask/testsuite/test_apps}/blueprintapp/apps/frontend/__init__.py
  25. 0  ...ontend/templates → flask/testsuite/test_apps/blueprintapp/apps/frontend/templates/frontend}/index.html
  26. +4 −0 flask/testsuite/test_apps/config_module_app.py
  27. +4 −0 flask/testsuite/test_apps/config_package_app/__init__.py
  28. 0  {tests → flask/testsuite/test_apps}/moduleapp/__init__.py
  29. 0  {tests/blueprintapp → flask/testsuite/test_apps/moduleapp}/apps/__init__.py
  30. 0  {tests → flask/testsuite/test_apps}/moduleapp/apps/admin/__init__.py
  31. 0  {tests/blueprintapp → flask/testsuite/test_apps/moduleapp}/apps/admin/static/css/test.css
  32. 0  {tests/blueprintapp → flask/testsuite/test_apps/moduleapp}/apps/admin/static/test.txt
  33. 0  ...tapp/apps/admin/templates/admin → flask/testsuite/test_apps/moduleapp/apps/admin/templates}/index.html
  34. 0  {tests → flask/testsuite/test_apps}/moduleapp/apps/frontend/__init__.py
  35. 0  .../frontend/templates/frontend → flask/testsuite/test_apps/moduleapp/apps/frontend/templates}/index.html
  36. 0  {tests → flask/testsuite/test_apps}/subdomaintestmodule/__init__.py
  37. 0  {tests → flask/testsuite/test_apps}/subdomaintestmodule/static/hello.txt
  38. +121 −0 flask/testsuite/testing.py
  39. +117 −0 flask/testsuite/views.py
  40. 0  {tests → scripts}/flaskext_test.py
  41. +1 −7 setup.py
  42. +0 −2,329 tests/flask_tests.py
View
121 flask/testsuite/__init__.py
@@ -0,0 +1,121 @@
+# -*- coding: utf-8 -*-
+"""
+ flask.testsuite
+ ~~~~~~~~~~~~~~~
+
+ Tests Flask itself. The majority of Flask is already tested
+ as part of Werkzeug.
+
+ :copyright: (c) 2011 by Armin Ronacher.
+ :license: BSD, see LICENSE for more details.
+"""
+import os
+import sys
+import flask
+import warnings
+import unittest
+from StringIO import StringIO
+from functools import update_wrapper
+from contextlib import contextmanager
+from werkzeug.utils import import_string, find_modules
+
+
+def add_to_path(path):
+ def _samefile(x, y):
+ try:
+ return os.path.samefile(x, y)
+ except (IOError, OSError):
+ return False
+ for entry in sys.path:
+ try:
+ if os.path.samefile(path, entry):
+ return
+ except (OSError, IOError):
+ pass
+ sys.path.append(path)
+
+
+def setup_paths():
+ add_to_path(os.path.abspath(os.path.join(
+ os.path.dirname(__file__), 'test_apps')))
+
+
+def iter_suites():
+ for module in find_modules(__name__):
+ mod = import_string(module)
+ if hasattr(mod, 'suite'):
+ yield mod.suite()
+
+
+@contextmanager
+def catch_warnings():
+ """Catch warnings in a with block in a list"""
+ # make sure deprecation warnings are active in tests
+ warnings.simplefilter('default', category=DeprecationWarning)
+
+ filters = warnings.filters
+ warnings.filters = filters[:]
+ old_showwarning = warnings.showwarning
+ log = []
+ def showwarning(message, category, filename, lineno, file=None, line=None):
+ log.append(locals())
+ try:
+ warnings.showwarning = showwarning
+ yield log
+ finally:
+ warnings.filters = filters
+ warnings.showwarning = old_showwarning
+
+
+@contextmanager
+def catch_stderr():
+ """Catch stderr in a StringIO"""
+ old_stderr = sys.stderr
+ sys.stderr = rv = StringIO()
+ try:
+ yield rv
+ finally:
+ sys.stderr = old_stderr
+
+
+def emits_module_deprecation_warning(f):
+ def new_f(self, *args, **kwargs):
+ with catch_warnings() as log:
+ f(self, *args, **kwargs)
+ self.assert_(log, 'expected deprecation warning')
+ for entry in log:
+ self.assert_('Modules are deprecated' in str(entry['message']))
+ return update_wrapper(new_f, f)
+
+
+class FlaskTestCase(unittest.TestCase):
+
+ def ensure_clean_request_context(self):
+ # make sure we're not leaking a request context since we are
+ # testing flask internally in debug mode in a few cases
+ self.assert_equal(flask._request_ctx_stack.top, None)
+
+ def setup(self):
+ pass
+
+ def teardown(self):
+ pass
+
+ def setUp(self):
+ self.setup()
+
+ def tearDown(self):
+ unittest.TestCase.tearDown(self)
+ self.ensure_clean_request_context()
+ self.teardown()
+
+ def assert_equal(self, x, y):
+ return self.assertEqual(x, y)
+
+
+def suite():
+ setup_paths()
+ suite = unittest.TestSuite()
+ for other_suite in iter_suites():
+ suite.addTest(other_suite)
+ return suite
View
992 flask/testsuite/basic.py
@@ -0,0 +1,992 @@
+# -*- coding: utf-8 -*-
+"""
+ flask.testsuite.basic
+ ~~~~~~~~~~~~~~~~~~~~~
+
+ The basic functionality.
+
+ :copyright: (c) 2011 by Armin Ronacher.
+ :license: BSD, see LICENSE for more details.
+"""
+import re
+import flask
+import unittest
+from datetime import datetime
+from threading import Thread
+from flask.testsuite import FlaskTestCase, emits_module_deprecation_warning
+from werkzeug.exceptions import BadRequest, NotFound
+from werkzeug.http import parse_date
+
+
+class BasicFunctionalityTestCase(FlaskTestCase):
+
+ def test_options_work(self):
+ app = flask.Flask(__name__)
+ @app.route('/', methods=['GET', 'POST'])
+ def index():
+ return 'Hello World'
+ rv = app.test_client().open('/', method='OPTIONS')
+ assert sorted(rv.allow) == ['GET', 'HEAD', 'OPTIONS', 'POST']
+ assert rv.data == ''
+
+ def test_options_on_multiple_rules(self):
+ app = flask.Flask(__name__)
+ @app.route('/', methods=['GET', 'POST'])
+ def index():
+ return 'Hello World'
+ @app.route('/', methods=['PUT'])
+ def index_put():
+ return 'Aha!'
+ rv = app.test_client().open('/', method='OPTIONS')
+ assert sorted(rv.allow) == ['GET', 'HEAD', 'OPTIONS', 'POST', 'PUT']
+
+ def test_options_handling_disabled(self):
+ app = flask.Flask(__name__)
+ def index():
+ return 'Hello World!'
+ index.provide_automatic_options = False
+ app.route('/')(index)
+ rv = app.test_client().open('/', method='OPTIONS')
+ assert rv.status_code == 405
+
+ app = flask.Flask(__name__)
+ def index2():
+ return 'Hello World!'
+ index2.provide_automatic_options = True
+ app.route('/', methods=['OPTIONS'])(index2)
+ rv = app.test_client().open('/', method='OPTIONS')
+ assert sorted(rv.allow) == ['OPTIONS']
+
+ def test_request_dispatching(self):
+ app = flask.Flask(__name__)
+ @app.route('/')
+ def index():
+ return flask.request.method
+ @app.route('/more', methods=['GET', 'POST'])
+ def more():
+ return flask.request.method
+
+ c = app.test_client()
+ assert c.get('/').data == 'GET'
+ rv = c.post('/')
+ assert rv.status_code == 405
+ assert sorted(rv.allow) == ['GET', 'HEAD', 'OPTIONS']
+ rv = c.head('/')
+ assert rv.status_code == 200
+ assert not rv.data # head truncates
+ assert c.post('/more').data == 'POST'
+ assert c.get('/more').data == 'GET'
+ rv = c.delete('/more')
+ assert rv.status_code == 405
+ assert sorted(rv.allow) == ['GET', 'HEAD', 'OPTIONS', 'POST']
+
+ def test_url_mapping(self):
+ app = flask.Flask(__name__)
+ def index():
+ return flask.request.method
+ def more():
+ return flask.request.method
+
+ app.add_url_rule('/', 'index', index)
+ app.add_url_rule('/more', 'more', more, methods=['GET', 'POST'])
+
+ c = app.test_client()
+ assert c.get('/').data == 'GET'
+ rv = c.post('/')
+ assert rv.status_code == 405
+ assert sorted(rv.allow) == ['GET', 'HEAD', 'OPTIONS']
+ rv = c.head('/')
+ assert rv.status_code == 200
+ assert not rv.data # head truncates
+ assert c.post('/more').data == 'POST'
+ assert c.get('/more').data == 'GET'
+ rv = c.delete('/more')
+ assert rv.status_code == 405
+ assert sorted(rv.allow) == ['GET', 'HEAD', 'OPTIONS', 'POST']
+
+ def test_werkzeug_routing(self):
+ from werkzeug.routing import Submount, Rule
+ app = flask.Flask(__name__)
+ app.url_map.add(Submount('/foo', [
+ Rule('/bar', endpoint='bar'),
+ Rule('/', endpoint='index')
+ ]))
+ def bar():
+ return 'bar'
+ def index():
+ return 'index'
+ app.view_functions['bar'] = bar
+ app.view_functions['index'] = index
+
+ c = app.test_client()
+ assert c.get('/foo/').data == 'index'
+ assert c.get('/foo/bar').data == 'bar'
+
+ def test_endpoint_decorator(self):
+ from werkzeug.routing import Submount, Rule
+ app = flask.Flask(__name__)
+ app.url_map.add(Submount('/foo', [
+ Rule('/bar', endpoint='bar'),
+ Rule('/', endpoint='index')
+ ]))
+
+ @app.endpoint('bar')
+ def bar():
+ return 'bar'
+
+ @app.endpoint('index')
+ def index():
+ return 'index'
+
+ c = app.test_client()
+ assert c.get('/foo/').data == 'index'
+ assert c.get('/foo/bar').data == 'bar'
+
+ def test_session(self):
+ app = flask.Flask(__name__)
+ app.secret_key = 'testkey'
+ @app.route('/set', methods=['POST'])
+ def set():
+ flask.session['value'] = flask.request.form['value']
+ return 'value set'
+ @app.route('/get')
+ def get():
+ return flask.session['value']
+
+ c = app.test_client()
+ assert c.post('/set', data={'value': '42'}).data == 'value set'
+ assert c.get('/get').data == '42'
+
+ def test_session_using_server_name(self):
+ app = flask.Flask(__name__)
+ app.config.update(
+ SECRET_KEY='foo',
+ SERVER_NAME='example.com'
+ )
+ @app.route('/')
+ def index():
+ flask.session['testing'] = 42
+ return 'Hello World'
+ rv = app.test_client().get('/', 'http://example.com/')
+ assert 'domain=.example.com' in rv.headers['set-cookie'].lower()
+ assert 'httponly' in rv.headers['set-cookie'].lower()
+
+ def test_session_using_server_name_and_port(self):
+ app = flask.Flask(__name__)
+ app.config.update(
+ SECRET_KEY='foo',
+ SERVER_NAME='example.com:8080'
+ )
+ @app.route('/')
+ def index():
+ flask.session['testing'] = 42
+ return 'Hello World'
+ rv = app.test_client().get('/', 'http://example.com:8080/')
+ assert 'domain=.example.com' in rv.headers['set-cookie'].lower()
+ assert 'httponly' in rv.headers['set-cookie'].lower()
+
+ def test_session_using_application_root(self):
+ class PrefixPathMiddleware(object):
+ def __init__(self, app, prefix):
+ self.app = app
+ self.prefix = prefix
+ def __call__(self, environ, start_response):
+ environ['SCRIPT_NAME'] = self.prefix
+ return self.app(environ, start_response)
+
+ app = flask.Flask(__name__)
+ app.wsgi_app = PrefixPathMiddleware(app.wsgi_app, '/bar')
+ app.config.update(
+ SECRET_KEY='foo',
+ APPLICATION_ROOT='/bar'
+ )
+ @app.route('/')
+ def index():
+ flask.session['testing'] = 42
+ return 'Hello World'
+ rv = app.test_client().get('/', 'http://example.com:8080/')
+ assert 'path=/bar' in rv.headers['set-cookie'].lower()
+
+ def test_missing_session(self):
+ app = flask.Flask(__name__)
+ def expect_exception(f, *args, **kwargs):
+ try:
+ f(*args, **kwargs)
+ except RuntimeError, e:
+ assert e.args and 'session is unavailable' in e.args[0]
+ else:
+ assert False, 'expected exception'
+ with app.test_request_context():
+ assert flask.session.get('missing_key') is None
+ expect_exception(flask.session.__setitem__, 'foo', 42)
+ expect_exception(flask.session.pop, 'foo')
+
+ def test_session_expiration(self):
+ permanent = True
+ app = flask.Flask(__name__)
+ app.secret_key = 'testkey'
+ @app.route('/')
+ def index():
+ flask.session['test'] = 42
+ flask.session.permanent = permanent
+ return ''
+
+ @app.route('/test')
+ def test():
+ return unicode(flask.session.permanent)
+
+ client = app.test_client()
+ rv = client.get('/')
+ assert 'set-cookie' in rv.headers
+ match = re.search(r'\bexpires=([^;]+)', rv.headers['set-cookie'])
+ expires = parse_date(match.group())
+ expected = datetime.utcnow() + app.permanent_session_lifetime
+ assert expires.year == expected.year
+ assert expires.month == expected.month
+ assert expires.day == expected.day
+
+ rv = client.get('/test')
+ assert rv.data == 'True'
+
+ permanent = False
+ rv = app.test_client().get('/')
+ assert 'set-cookie' in rv.headers
+ match = re.search(r'\bexpires=([^;]+)', rv.headers['set-cookie'])
+ assert match is None
+
+ def test_flashes(self):
+ app = flask.Flask(__name__)
+ app.secret_key = 'testkey'
+
+ with app.test_request_context():
+ assert not flask.session.modified
+ flask.flash('Zap')
+ flask.session.modified = False
+ flask.flash('Zip')
+ assert flask.session.modified
+ assert list(flask.get_flashed_messages()) == ['Zap', 'Zip']
+
+ def test_extended_flashing(self):
+ app = flask.Flask(__name__)
+ app.secret_key = 'testkey'
+
+ @app.route('/')
+ def index():
+ flask.flash(u'Hello World')
+ flask.flash(u'Hello World', 'error')
+ flask.flash(flask.Markup(u'<em>Testing</em>'), 'warning')
+ return ''
+
+ @app.route('/test')
+ def test():
+ messages = flask.get_flashed_messages(with_categories=True)
+ assert len(messages) == 3
+ assert messages[0] == ('message', u'Hello World')
+ assert messages[1] == ('error', u'Hello World')
+ assert messages[2] == ('warning', flask.Markup(u'<em>Testing</em>'))
+ return ''
+ messages = flask.get_flashed_messages()
+ assert len(messages) == 3
+ assert messages[0] == u'Hello World'
+ assert messages[1] == u'Hello World'
+ assert messages[2] == flask.Markup(u'<em>Testing</em>')
+
+ c = app.test_client()
+ c.get('/')
+ c.get('/test')
+
+ def test_request_processing(self):
+ app = flask.Flask(__name__)
+ evts = []
+ @app.before_request
+ def before_request():
+ evts.append('before')
+ @app.after_request
+ def after_request(response):
+ response.data += '|after'
+ evts.append('after')
+ return response
+ @app.route('/')
+ def index():
+ assert 'before' in evts
+ assert 'after' not in evts
+ return 'request'
+ assert 'after' not in evts
+ rv = app.test_client().get('/').data
+ assert 'after' in evts
+ assert rv == 'request|after'
+
+ def test_teardown_request_handler(self):
+ called = []
+ app = flask.Flask(__name__)
+ @app.teardown_request
+ def teardown_request(exc):
+ called.append(True)
+ return "Ignored"
+ @app.route('/')
+ def root():
+ return "Response"
+ rv = app.test_client().get('/')
+ assert rv.status_code == 200
+ assert 'Response' in rv.data
+ assert len(called) == 1
+
+ def test_teardown_request_handler_debug_mode(self):
+ called = []
+ app = flask.Flask(__name__)
+ app.testing = True
+ @app.teardown_request
+ def teardown_request(exc):
+ called.append(True)
+ return "Ignored"
+ @app.route('/')
+ def root():
+ return "Response"
+ rv = app.test_client().get('/')
+ assert rv.status_code == 200
+ assert 'Response' in rv.data
+ assert len(called) == 1
+
+ def test_teardown_request_handler_error(self):
+ called = []
+ app = flask.Flask(__name__)
+ @app.teardown_request
+ def teardown_request1(exc):
+ assert type(exc) == ZeroDivisionError
+ called.append(True)
+ # This raises a new error and blows away sys.exc_info(), so we can
+ # test that all teardown_requests get passed the same original
+ # exception.
+ try:
+ raise TypeError
+ except:
+ pass
+ @app.teardown_request
+ def teardown_request2(exc):
+ assert type(exc) == ZeroDivisionError
+ called.append(True)
+ # This raises a new error and blows away sys.exc_info(), so we can
+ # test that all teardown_requests get passed the same original
+ # exception.
+ try:
+ raise TypeError
+ except:
+ pass
+ @app.route('/')
+ def fails():
+ 1/0
+ rv = app.test_client().get('/')
+ assert rv.status_code == 500
+ assert 'Internal Server Error' in rv.data
+ assert len(called) == 2
+
+ def test_before_after_request_order(self):
+ called = []
+ app = flask.Flask(__name__)
+ @app.before_request
+ def before1():
+ called.append(1)
+ @app.before_request
+ def before2():
+ called.append(2)
+ @app.after_request
+ def after1(response):
+ called.append(4)
+ return response
+ @app.after_request
+ def after2(response):
+ called.append(3)
+ return response
+ @app.teardown_request
+ def finish1(exc):
+ called.append(6)
+ @app.teardown_request
+ def finish2(exc):
+ called.append(5)
+ @app.route('/')
+ def index():
+ return '42'
+ rv = app.test_client().get('/')
+ assert rv.data == '42'
+ assert called == [1, 2, 3, 4, 5, 6]
+
+ def test_error_handling(self):
+ app = flask.Flask(__name__)
+ @app.errorhandler(404)
+ def not_found(e):
+ return 'not found', 404
+ @app.errorhandler(500)
+ def internal_server_error(e):
+ return 'internal server error', 500
+ @app.route('/')
+ def index():
+ flask.abort(404)
+ @app.route('/error')
+ def error():
+ 1 // 0
+ c = app.test_client()
+ rv = c.get('/')
+ assert rv.status_code == 404
+ assert rv.data == 'not found'
+ rv = c.get('/error')
+ assert rv.status_code == 500
+ assert 'internal server error' == rv.data
+
+ def test_before_request_and_routing_errors(self):
+ app = flask.Flask(__name__)
+ @app.before_request
+ def attach_something():
+ flask.g.something = 'value'
+ @app.errorhandler(404)
+ def return_something(error):
+ return flask.g.something, 404
+ rv = app.test_client().get('/')
+ assert rv.status_code == 404
+ assert rv.data == 'value'
+
+ def test_user_error_handling(self):
+ class MyException(Exception):
+ pass
+
+ app = flask.Flask(__name__)
+ @app.errorhandler(MyException)
+ def handle_my_exception(e):
+ assert isinstance(e, MyException)
+ return '42'
+ @app.route('/')
+ def index():
+ raise MyException()
+
+ c = app.test_client()
+ assert c.get('/').data == '42'
+
+ def test_trapping_of_bad_request_key_errors(self):
+ app = flask.Flask(__name__)
+ app.testing = True
+ @app.route('/fail')
+ def fail():
+ flask.request.form['missing_key']
+ c = app.test_client()
+ assert c.get('/fail').status_code == 400
+
+ app.config['TRAP_BAD_REQUEST_ERRORS'] = True
+ c = app.test_client()
+ try:
+ c.get('/fail')
+ except KeyError, e:
+ assert isinstance(e, BadRequest)
+ else:
+ self.fail('Expected exception')
+
+ def test_trapping_of_all_http_exceptions(self):
+ app = flask.Flask(__name__)
+ app.testing = True
+ app.config['TRAP_HTTP_EXCEPTIONS'] = True
+ @app.route('/fail')
+ def fail():
+ flask.abort(404)
+
+ c = app.test_client()
+ try:
+ c.get('/fail')
+ except NotFound, e:
+ pass
+ else:
+ self.fail('Expected exception')
+
+ def test_enctype_debug_helper(self):
+ from flask.debughelpers import DebugFilesKeyError
+ app = flask.Flask(__name__)
+ app.debug = True
+ @app.route('/fail', methods=['POST'])
+ def index():
+ return flask.request.files['foo'].filename
+
+ # with statement is important because we leave an exception on the
+ # stack otherwise and we want to ensure that this is not the case
+ # to not negatively affect other tests.
+ with app.test_client() as c:
+ try:
+ c.post('/fail', data={'foo': 'index.txt'})
+ except DebugFilesKeyError, e:
+ assert 'no file contents were transmitted' in str(e)
+ assert 'This was submitted: "index.txt"' in str(e)
+ else:
+ self.fail('Expected exception')
+
+ def test_teardown_on_pop(self):
+ buffer = []
+ app = flask.Flask(__name__)
+ @app.teardown_request
+ def end_of_request(exception):
+ buffer.append(exception)
+
+ ctx = app.test_request_context()
+ ctx.push()
+ assert buffer == []
+ ctx.pop()
+ assert buffer == [None]
+
+ def test_response_creation(self):
+ app = flask.Flask(__name__)
+ @app.route('/unicode')
+ def from_unicode():
+ return u'Hällo Wörld'
+ @app.route('/string')
+ def from_string():
+ return u'Hällo Wörld'.encode('utf-8')
+ @app.route('/args')
+ def from_tuple():
+ return 'Meh', 400, {'X-Foo': 'Testing'}, 'text/plain'
+ c = app.test_client()
+ assert c.get('/unicode').data == u'Hällo Wörld'.encode('utf-8')
+ assert c.get('/string').data == u'Hällo Wörld'.encode('utf-8')
+ rv = c.get('/args')
+ assert rv.data == 'Meh'
+ assert rv.headers['X-Foo'] == 'Testing'
+ assert rv.status_code == 400
+ assert rv.mimetype == 'text/plain'
+
+ def test_make_response(self):
+ app = flask.Flask(__name__)
+ with app.test_request_context():
+ rv = flask.make_response()
+ assert rv.status_code == 200
+ assert rv.data == ''
+ assert rv.mimetype == 'text/html'
+
+ rv = flask.make_response('Awesome')
+ assert rv.status_code == 200
+ assert rv.data == 'Awesome'
+ assert rv.mimetype == 'text/html'
+
+ rv = flask.make_response('W00t', 404)
+ assert rv.status_code == 404
+ assert rv.data == 'W00t'
+ assert rv.mimetype == 'text/html'
+
+ def test_url_generation(self):
+ app = flask.Flask(__name__)
+ @app.route('/hello/<name>', methods=['POST'])
+ def hello():
+ pass
+ with app.test_request_context():
+ assert flask.url_for('hello', name='test x') == '/hello/test%20x'
+ assert flask.url_for('hello', name='test x', _external=True) \
+ == 'http://localhost/hello/test%20x'
+
+ def test_custom_converters(self):
+ from werkzeug.routing import BaseConverter
+ class ListConverter(BaseConverter):
+ def to_python(self, value):
+ return value.split(',')
+ def to_url(self, value):
+ base_to_url = super(ListConverter, self).to_url
+ return ','.join(base_to_url(x) for x in value)
+ app = flask.Flask(__name__)
+ app.url_map.converters['list'] = ListConverter
+ @app.route('/<list:args>')
+ def index(args):
+ return '|'.join(args)
+ c = app.test_client()
+ assert c.get('/1,2,3').data == '1|2|3'
+
+ def test_static_files(self):
+ app = flask.Flask(__name__)
+ rv = app.test_client().get('/static/index.html')
+ assert rv.status_code == 200
+ assert rv.data.strip() == '<h1>Hello World!</h1>'
+ with app.test_request_context():
+ assert flask.url_for('static', filename='index.html') \
+ == '/static/index.html'
+
+ def test_none_response(self):
+ app = flask.Flask(__name__)
+ @app.route('/')
+ def test():
+ return None
+ try:
+ app.test_client().get('/')
+ except ValueError, e:
+ assert str(e) == 'View function did not return a response'
+ pass
+ else:
+ assert "Expected ValueError"
+
+ def test_request_locals(self):
+ self.assert_equal(repr(flask.g), '<LocalProxy unbound>')
+ self.assertFalse(flask.g)
+
+ def test_proper_test_request_context(self):
+ app = flask.Flask(__name__)
+ app.config.update(
+ SERVER_NAME='localhost.localdomain:5000'
+ )
+
+ @app.route('/')
+ def index():
+ return None
+
+ @app.route('/', subdomain='foo')
+ def sub():
+ return None
+
+ with app.test_request_context('/'):
+ assert flask.url_for('index', _external=True) == 'http://localhost.localdomain:5000/'
+
+ with app.test_request_context('/'):
+ assert flask.url_for('sub', _external=True) == 'http://foo.localhost.localdomain:5000/'
+
+ try:
+ with app.test_request_context('/', environ_overrides={'HTTP_HOST': 'localhost'}):
+ pass
+ except Exception, e:
+ assert isinstance(e, ValueError)
+ assert str(e) == "the server name provided " + \
+ "('localhost.localdomain:5000') does not match the " + \
+ "server name from the WSGI environment ('localhost')", str(e)
+
+ try:
+ app.config.update(SERVER_NAME='localhost')
+ with app.test_request_context('/', environ_overrides={'SERVER_NAME': 'localhost'}):
+ pass
+ except ValueError, e:
+ raise ValueError(
+ "No ValueError exception should have been raised \"%s\"" % e
+ )
+
+ try:
+ app.config.update(SERVER_NAME='localhost:80')
+ with app.test_request_context('/', environ_overrides={'SERVER_NAME': 'localhost:80'}):
+ pass
+ except ValueError, e:
+ raise ValueError(
+ "No ValueError exception should have been raised \"%s\"" % e
+ )
+
+ def test_test_app_proper_environ(self):
+ app = flask.Flask(__name__)
+ app.config.update(
+ SERVER_NAME='localhost.localdomain:5000'
+ )
+ @app.route('/')
+ def index():
+ return 'Foo'
+
+ @app.route('/', subdomain='foo')
+ def subdomain():
+ return 'Foo SubDomain'
+
+ try:
+ rv = app.test_client().get('/')
+ assert rv.data == 'Foo'
+ except ValueError, e:
+ raise ValueError(
+ "No ValueError exception should have been raised \"%s\"" % e
+ )
+
+ try:
+ rv = app.test_client().get('/', 'http://localhost.localdomain:5000')
+ assert rv.data == 'Foo'
+ except ValueError, e:
+ raise ValueError(
+ "No ValueError exception should have been raised \"%s\"" % e
+ )
+
+ try:
+ rv = app.test_client().get('/', 'https://localhost.localdomain:5000')
+ assert rv.data == 'Foo'
+ except ValueError, e:
+ raise ValueError(
+ "No ValueError exception should have been raised \"%s\"" % e
+ )
+
+ try:
+ app.config.update(SERVER_NAME='localhost.localdomain')
+ rv = app.test_client().get('/', 'https://localhost.localdomain')
+ assert rv.data == 'Foo'
+ except ValueError, e:
+ raise ValueError(
+ "No ValueError exception should have been raised \"%s\"" % e
+ )
+
+ try:
+ app.config.update(SERVER_NAME='localhost.localdomain:443')
+ rv = app.test_client().get('/', 'https://localhost.localdomain')
+ assert rv.data == 'Foo'
+ except ValueError, e:
+ assert str(e) == "the server name provided " + \
+ "('localhost.localdomain:443') does not match the " + \
+ "server name from the WSGI environment ('localhost.localdomain')", str(e)
+
+ try:
+ app.config.update(SERVER_NAME='localhost.localdomain')
+ app.test_client().get('/', 'http://foo.localhost')
+ except ValueError, e:
+ assert str(e) == "the server name provided " + \
+ "('localhost.localdomain') does not match the " + \
+ "server name from the WSGI environment ('foo.localhost')", str(e)
+
+ try:
+ rv = app.test_client().get('/', 'http://foo.localhost.localdomain')
+ assert rv.data == 'Foo SubDomain'
+ except ValueError, e:
+ raise ValueError(
+ "No ValueError exception should have been raised \"%s\"" % e
+ )
+
+ def test_exception_propagation(self):
+ def apprunner(configkey):

maybe rather "config_key" as in the code below?

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
+ app = flask.Flask(__name__)
+ @app.route('/')
+ def index():
+ 1/0
+ c = app.test_client()
+ if config_key is not None:
+ app.config[config_key] = True
+ try:
+ resp = c.get('/')
+ except Exception:
+ pass
+ else:
+ self.fail('expected exception')
+ else:
+ assert c.get('/').status_code == 500
+
+ # we have to run this test in an isolated thread because if the
+ # debug flag is set to true and an exception happens the context is
+ # not torn down. This causes other tests that run after this fail
+ # when they expect no exception on the stack.
+ for config_key in 'TESTING', 'PROPAGATE_EXCEPTIONS', 'DEBUG', None:
+ t = Thread(target=apprunner, args=(config_key,))
+ t.start()
+ t.join()
+
+ def test_max_content_length(self):
+ app = flask.Flask(__name__)
+ app.config['MAX_CONTENT_LENGTH'] = 64
+ @app.before_request
+ def always_first():
+ flask.request.form['myfile']
+ assert False
+ @app.route('/accept', methods=['POST'])
+ def accept_file():
+ flask.request.form['myfile']
+ assert False
+ @app.errorhandler(413)
+ def catcher(error):
+ return '42'
+
+ c = app.test_client()
+ rv = c.post('/accept', data={'myfile': 'foo' * 100})
+ assert rv.data == '42'
+
+ def test_url_processors(self):
+ app = flask.Flask(__name__)
+
+ @app.url_defaults
+ def add_language_code(endpoint, values):
+ if flask.g.lang_code is not None and \
+ app.url_map.is_endpoint_expecting(endpoint, 'lang_code'):
+ values.setdefault('lang_code', flask.g.lang_code)
+
+ @app.url_value_preprocessor
+ def pull_lang_code(endpoint, values):
+ flask.g.lang_code = values.pop('lang_code', None)
+
+ @app.route('/<lang_code>/')
+ def index():
+ return flask.url_for('about')
+
+ @app.route('/<lang_code>/about')
+ def about():
+ return flask.url_for('something_else')
+
+ @app.route('/foo')
+ def something_else():
+ return flask.url_for('about', lang_code='en')
+
+ c = app.test_client()
+
+ self.assert_equal(c.get('/de/').data, '/de/about')
+ self.assert_equal(c.get('/de/about').data, '/foo')
+ self.assert_equal(c.get('/foo').data, '/en/about')
+
+ def test_debug_mode_complains_after_first_request(self):
+ app = flask.Flask(__name__)
+ app.debug = True
+ @app.route('/')
+ def index():
+ return 'Awesome'
+ self.assert_(not app.got_first_request)
+ self.assert_equal(app.test_client().get('/').data, 'Awesome')
+ try:
+ @app.route('/foo')
+ def broken():
+ return 'Meh'
+ except AssertionError, e:
+ self.assert_('A setup function was called' in str(e))
+ else:
+ self.fail('Expected exception')
+
+ app.debug = False
+ @app.route('/foo')
+ def working():
+ return 'Meh'
+ self.assert_equal(app.test_client().get('/foo').data, 'Meh')
+ self.assert_(app.got_first_request)
+
+ def test_before_first_request_functions(self):
+ got = []
+ app = flask.Flask(__name__)
+ @app.before_first_request
+ def foo():
+ got.append(42)
+ c = app.test_client()
+ c.get('/')
+ self.assert_equal(got, [42])
+ c.get('/')
+ self.assert_equal(got, [42])
+ self.assert_(app.got_first_request)
+
+ def test_routing_redirect_debugging(self):
+ app = flask.Flask(__name__)
+ app.debug = True
+ @app.route('/foo/', methods=['GET', 'POST'])
+ def foo():
+ return 'success'
+ with app.test_client() as c:
+ try:
+ c.post('/foo', data={})
+ except AssertionError, e:
+ self.assert_('http://localhost/foo/' in str(e))
+ self.assert_('Make sure to directly send your POST-request '
+ 'to this URL' in str(e))
+ else:
+ self.fail('Expected exception')
+
+ rv = c.get('/foo', data={}, follow_redirects=True)
+ self.assert_equal(rv.data, 'success')
+
+ app.debug = False
+ with app.test_client() as c:
+ rv = c.post('/foo', data={}, follow_redirects=True)
+ self.assert_equal(rv.data, 'success')
+
+
+class ContextTestCase(FlaskTestCase):
+
+ def test_context_binding(self):
+ app = flask.Flask(__name__)
+ @app.route('/')
+ def index():
+ return 'Hello %s!' % flask.request.args['name']
+ @app.route('/meh')
+ def meh():
+ return flask.request.url
+
+ with app.test_request_context('/?name=World'):
+ assert index() == 'Hello World!'
+ with app.test_request_context('/meh'):
+ assert meh() == 'http://localhost/meh'
+ assert flask._request_ctx_stack.top is None
+
+ def test_context_test(self):
+ app = flask.Flask(__name__)
+ assert not flask.request
+ assert not flask.has_request_context()
+ ctx = app.test_request_context()
+ ctx.push()
+ try:
+ assert flask.request
+ assert flask.has_request_context()
+ finally:
+ ctx.pop()
+
+ def test_manual_context_binding(self):
+ app = flask.Flask(__name__)
+ @app.route('/')
+ def index():
+ return 'Hello %s!' % flask.request.args['name']
+
+ ctx = app.test_request_context('/?name=World')
+ ctx.push()
+ assert index() == 'Hello World!'
+ ctx.pop()
+ try:
+ index()
+ except RuntimeError:
+ pass
+ else:
+ assert 0, 'expected runtime error'
+
+
+class SubdomainTestCase(FlaskTestCase):
+
+ def test_basic_support(self):
+ app = flask.Flask(__name__)
+ app.config['SERVER_NAME'] = 'localhost'
+ @app.route('/')
+ def normal_index():
+ return 'normal index'
+ @app.route('/', subdomain='test')
+ def test_index():
+ return 'test index'
+
+ c = app.test_client()
+ rv = c.get('/', 'http://localhost/')
+ assert rv.data == 'normal index'
+
+ rv = c.get('/', 'http://test.localhost/')
+ assert rv.data == 'test index'
+
+ @emits_module_deprecation_warning
+ def test_module_static_path_subdomain(self):
+ app = flask.Flask(__name__)
+ app.config['SERVER_NAME'] = 'example.com'
+ from subdomaintestmodule import mod
+ app.register_module(mod)
+ c = app.test_client()
+ rv = c.get('/static/hello.txt', 'http://foo.example.com/')
+ assert rv.data.strip() == 'Hello Subdomain'
+
+ def test_subdomain_matching(self):
+ app = flask.Flask(__name__)
+ app.config['SERVER_NAME'] = 'localhost'
+ @app.route('/', subdomain='<user>')
+ def index(user):
+ return 'index for %s' % user
+
+ c = app.test_client()
+ rv = c.get('/', 'http://mitsuhiko.localhost/')
+ assert rv.data == 'index for mitsuhiko'
+
+ @emits_module_deprecation_warning
+ def test_module_subdomain_support(self):
+ app = flask.Flask(__name__)
+ mod = flask.Module(__name__, 'test', subdomain='testing')
+ app.config['SERVER_NAME'] = 'localhost'
+
+ @mod.route('/test')
+ def test():
+ return 'Test'
+
+ @mod.route('/outside', subdomain='xtesting')
+ def bar():
+ return 'Outside'
+
+ app.register_module(mod)
+
+ c = app.test_client()
+ rv = c.get('/test', 'http://testing.localhost/')
+ assert rv.data == 'Test'
+ rv = c.get('/outside', 'http://xtesting.localhost/')
+ assert rv.data == 'Outside'
+
+
+def suite():
+ suite = unittest.TestSuite()
+ suite.addTest(unittest.makeSuite(BasicFunctionalityTestCase))
+ suite.addTest(unittest.makeSuite(ContextTestCase))
+ suite.addTest(unittest.makeSuite(SubdomainTestCase))
+ return suite
View
423 flask/testsuite/blueprints.py
@@ -0,0 +1,423 @@
+# -*- coding: utf-8 -*-
+"""
+ flask.testsuite.blueprints
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+ Blueprints (and currently modules)
+
+ :copyright: (c) 2011 by Armin Ronacher.
+ :license: BSD, see LICENSE for more details.
+"""
+import flask
+import unittest
+import warnings
+from flask.testsuite import FlaskTestCase, emits_module_deprecation_warning
+from werkzeug.exceptions import NotFound
+from jinja2 import TemplateNotFound
+
+
+# import moduleapp here because it uses deprecated features and we don't
+# want to see the warnings
+warnings.simplefilter('ignore', DeprecationWarning)
+from moduleapp import app as moduleapp
+warnings.simplefilter('default', DeprecationWarning)
+
+
+class ModuleTestCase(FlaskTestCase):
+
+ @emits_module_deprecation_warning
+ def test_basic_module(self):
+ app = flask.Flask(__name__)
+ admin = flask.Module(__name__, 'admin', url_prefix='/admin')
+ @admin.route('/')
+ def admin_index():
+ return 'admin index'
+ @admin.route('/login')
+ def admin_login():
+ return 'admin login'
+ @admin.route('/logout')
+ def admin_logout():
+ return 'admin logout'
+ @app.route('/')
+ def index():
+ return 'the index'
+ app.register_module(admin)
+ c = app.test_client()
+ assert c.get('/').data == 'the index'
+ assert c.get('/admin/').data == 'admin index'
+ assert c.get('/admin/login').data == 'admin login'
+ assert c.get('/admin/logout').data == 'admin logout'
+
+ @emits_module_deprecation_warning
+ def test_default_endpoint_name(self):
+ app = flask.Flask(__name__)
+ mod = flask.Module(__name__, 'frontend')
+ def index():
+ return 'Awesome'
+ mod.add_url_rule('/', view_func=index)
+ app.register_module(mod)
+ rv = app.test_client().get('/')
+ assert rv.data == 'Awesome'
+ with app.test_request_context():
+ assert flask.url_for('frontend.index') == '/'
+
+ @emits_module_deprecation_warning
+ def test_request_processing(self):
+ catched = []
+ app = flask.Flask(__name__)
+ admin = flask.Module(__name__, 'admin', url_prefix='/admin')
+ @admin.before_request
+ def before_admin_request():
+ catched.append('before-admin')
+ @admin.after_request
+ def after_admin_request(response):
+ catched.append('after-admin')
+ return response
+ @admin.route('/')
+ def admin_index():
+ return 'the admin'
+ @app.before_request
+ def before_request():
+ catched.append('before-app')
+ @app.after_request
+ def after_request(response):
+ catched.append('after-app')
+ return response
+ @app.route('/')
+ def index():
+ return 'the index'
+ app.register_module(admin)
+ c = app.test_client()
+
+ assert c.get('/').data == 'the index'
+ assert catched == ['before-app', 'after-app']
+ del catched[:]
+
+ assert c.get('/admin/').data == 'the admin'
+ assert catched == ['before-app', 'before-admin',
+ 'after-admin', 'after-app']
+
+ @emits_module_deprecation_warning
+ def test_context_processors(self):
+ app = flask.Flask(__name__)
+ admin = flask.Module(__name__, 'admin', url_prefix='/admin')
+ @app.context_processor
+ def inject_all_regualr():
+ return {'a': 1}
+ @admin.context_processor
+ def inject_admin():
+ return {'b': 2}
+ @admin.app_context_processor
+ def inject_all_module():
+ return {'c': 3}
+ @app.route('/')
+ def index():
+ return flask.render_template_string('{{ a }}{{ b }}{{ c }}')
+ @admin.route('/')
+ def admin_index():
+ return flask.render_template_string('{{ a }}{{ b }}{{ c }}')
+ app.register_module(admin)
+ c = app.test_client()
+ assert c.get('/').data == '13'
+ assert c.get('/admin/').data == '123'
+
+ @emits_module_deprecation_warning
+ def test_late_binding(self):
+ app = flask.Flask(__name__)
+ admin = flask.Module(__name__, 'admin')
+ @admin.route('/')
+ def index():
+ return '42'
+ app.register_module(admin, url_prefix='/admin')
+ assert app.test_client().get('/admin/').data == '42'
+
+ @emits_module_deprecation_warning
+ def test_error_handling(self):
+ app = flask.Flask(__name__)
+ admin = flask.Module(__name__, 'admin')
+ @admin.app_errorhandler(404)
+ def not_found(e):
+ return 'not found', 404
+ @admin.app_errorhandler(500)
+ def internal_server_error(e):
+ return 'internal server error', 500
+ @admin.route('/')
+ def index():
+ flask.abort(404)
+ @admin.route('/error')
+ def error():
+ 1 // 0
+ app.register_module(admin)
+ c = app.test_client()
+ rv = c.get('/')
+ assert rv.status_code == 404
+ assert rv.data == 'not found'
+ rv = c.get('/error')
+ assert rv.status_code == 500
+ assert 'internal server error' == rv.data
+
+ def test_templates_and_static(self):
+ app = moduleapp
+ app.testing = True
+ c = app.test_client()
+
+ rv = c.get('/')
+ assert rv.data == 'Hello from the Frontend'
+ rv = c.get('/admin/')
+ assert rv.data == 'Hello from the Admin'
+ rv = c.get('/admin/index2')
+ assert rv.data == 'Hello from the Admin'
+ rv = c.get('/admin/static/test.txt')
+ assert rv.data.strip() == 'Admin File'
+ rv = c.get('/admin/static/css/test.css')
+ assert rv.data.strip() == '/* nested file */'
+
+ with app.test_request_context():
+ assert flask.url_for('admin.static', filename='test.txt') \
+ == '/admin/static/test.txt'
+
+ with app.test_request_context():
+ try:
+ flask.render_template('missing.html')
+ except TemplateNotFound, e:
+ assert e.name == 'missing.html'
+ else:
+ assert 0, 'expected exception'
+
+ with flask.Flask(__name__).test_request_context():
+ assert flask.render_template('nested/nested.txt') == 'I\'m nested'
+
+ def test_safe_access(self):
+ app = moduleapp
+
+ with app.test_request_context():
+ f = app.view_functions['admin.static']
+
+ try:
+ f('/etc/passwd')
+ except NotFound:
+ pass
+ else:
+ assert 0, 'expected exception'
+ try:
+ f('../__init__.py')
+ except NotFound:
+ pass
+ else:
+ assert 0, 'expected exception'
+
+ # testcase for a security issue that may exist on windows systems
+ import os
+ import ntpath
+ old_path = os.path
+ os.path = ntpath
+ try:
+ try:
+ f('..\\__init__.py')
+ except NotFound:
+ pass
+ else:
+ assert 0, 'expected exception'
+ finally:
+ os.path = old_path
+
+ @emits_module_deprecation_warning
+ def test_endpoint_decorator(self):
+ from werkzeug.routing import Submount, Rule
+ from flask import Module
+
+ app = flask.Flask(__name__)
+ app.testing = True
+ app.url_map.add(Submount('/foo', [
+ Rule('/bar', endpoint='bar'),
+ Rule('/', endpoint='index')
+ ]))
+ module = Module(__name__, __name__)
+
+ @module.endpoint('bar')
+ def bar():
+ return 'bar'
+
+ @module.endpoint('index')
+ def index():
+ return 'index'
+
+ app.register_module(module)
+
+ c = app.test_client()
+ assert c.get('/foo/').data == 'index'
+ assert c.get('/foo/bar').data == 'bar'
+
+
+class BlueprintTestCase(FlaskTestCase):
+
+ def test_blueprint_specific_error_handling(self):
+ frontend = flask.Blueprint('frontend', __name__)
+ backend = flask.Blueprint('backend', __name__)
+ sideend = flask.Blueprint('sideend', __name__)
+
+ @frontend.errorhandler(403)
+ def frontend_forbidden(e):
+ return 'frontend says no', 403
+
+ @frontend.route('/frontend-no')
+ def frontend_no():
+ flask.abort(403)
+
+ @backend.errorhandler(403)
+ def backend_forbidden(e):
+ return 'backend says no', 403
+
+ @backend.route('/backend-no')
+ def backend_no():
+ flask.abort(403)
+
+ @sideend.route('/what-is-a-sideend')
+ def sideend_no():
+ flask.abort(403)
+
+ app = flask.Flask(__name__)
+ app.register_blueprint(frontend)
+ app.register_blueprint(backend)
+ app.register_blueprint(sideend)
+
+ @app.errorhandler(403)
+ def app_forbidden(e):
+ return 'application itself says no', 403
+
+ c = app.test_client()
+
+ assert c.get('/frontend-no').data == 'frontend says no'
+ assert c.get('/backend-no').data == 'backend says no'
+ assert c.get('/what-is-a-sideend').data == 'application itself says no'
+
+ def test_blueprint_url_definitions(self):
+ bp = flask.Blueprint('test', __name__)
+
+ @bp.route('/foo', defaults={'baz': 42})
+ def foo(bar, baz):
+ return '%s/%d' % (bar, baz)
+
+ @bp.route('/bar')
+ def bar(bar):
+ return unicode(bar)
+
+ app = flask.Flask(__name__)
+ app.register_blueprint(bp, url_prefix='/1', url_defaults={'bar': 23})
+ app.register_blueprint(bp, url_prefix='/2', url_defaults={'bar': 19})
+
+ c = app.test_client()
+ self.assert_equal(c.get('/1/foo').data, u'23/42')
+ self.assert_equal(c.get('/2/foo').data, u'19/42')
+ self.assert_equal(c.get('/1/bar').data, u'23')
+ self.assert_equal(c.get('/2/bar').data, u'19')
+
+ def test_blueprint_url_processors(self):
+ bp = flask.Blueprint('frontend', __name__, url_prefix='/<lang_code>')
+
+ @bp.url_defaults
+ def add_language_code(endpoint, values):
+ values.setdefault('lang_code', flask.g.lang_code)
+
+ @bp.url_value_preprocessor
+ def pull_lang_code(endpoint, values):
+ flask.g.lang_code = values.pop('lang_code')
+
+ @bp.route('/')
+ def index():
+ return flask.url_for('.about')
+
+ @bp.route('/about')
+ def about():
+ return flask.url_for('.index')
+
+ app = flask.Flask(__name__)
+ app.register_blueprint(bp)
+
+ c = app.test_client()
+
+ self.assert_equal(c.get('/de/').data, '/de/about')
+ self.assert_equal(c.get('/de/about').data, '/de/')
+
+ def test_templates_and_static(self):
+ from blueprintapp import app
+ c = app.test_client()
+
+ rv = c.get('/')
+ assert rv.data == 'Hello from the Frontend'
+ rv = c.get('/admin/')
+ assert rv.data == 'Hello from the Admin'
+ rv = c.get('/admin/index2')
+ assert rv.data == 'Hello from the Admin'
+ rv = c.get('/admin/static/test.txt')
+ assert rv.data.strip() == 'Admin File'
+ rv = c.get('/admin/static/css/test.css')
+ assert rv.data.strip() == '/* nested file */'
+
+ with app.test_request_context():
+ assert flask.url_for('admin.static', filename='test.txt') \
+ == '/admin/static/test.txt'
+
+ with app.test_request_context():
+ try:
+ flask.render_template('missing.html')
+ except TemplateNotFound, e:
+ assert e.name == 'missing.html'
+ else:
+ assert 0, 'expected exception'
+
+ with flask.Flask(__name__).test_request_context():
+ assert flask.render_template('nested/nested.txt') == 'I\'m nested'
+
+ def test_templates_list(self):
+ from blueprintapp import app
+ templates = sorted(app.jinja_env.list_templates())
+ self.assert_equal(templates, ['admin/index.html',
+ 'frontend/index.html'])
+
+ def test_dotted_names(self):
+ frontend = flask.Blueprint('myapp.frontend', __name__)
+ backend = flask.Blueprint('myapp.backend', __name__)
+
+ @frontend.route('/fe')
+ def frontend_index():
+ return flask.url_for('myapp.backend.backend_index')
+
+ @frontend.route('/fe2')
+ def frontend_page2():
+ return flask.url_for('.frontend_index')
+
+ @backend.route('/be')
+ def backend_index():
+ return flask.url_for('myapp.frontend.frontend_index')
+
+ app = flask.Flask(__name__)
+ app.register_blueprint(frontend)
+ app.register_blueprint(backend)
+
+ c = app.test_client()
+ self.assert_equal(c.get('/fe').data.strip(), '/be')
+ self.assert_equal(c.get('/fe2').data.strip(), '/fe')
+ self.assert_equal(c.get('/be').data.strip(), '/fe')
+
+ def test_empty_url_defaults(self):
+ bp = flask.Blueprint('bp', __name__)
+
+ @bp.route('/', defaults={'page': 1})
+ @bp.route('/page/<int:page>')
+ def something(page):
+ return str(page)
+
+ app = flask.Flask(__name__)
+ app.register_blueprint(bp)
+
+ c = app.test_client()
+ self.assert_equal(c.get('/').data, '1')
+ self.assert_equal(c.get('/page/2').data, '2')
+
+
+def suite():
+ suite = unittest.TestSuite()
+ suite.addTest(unittest.makeSuite(BlueprintTestCase))
+ suite.addTest(unittest.makeSuite(ModuleTestCase))
+ return suite
View
177 flask/testsuite/config.py
@@ -0,0 +1,177 @@
+# -*- coding: utf-8 -*-
+"""
+ flask.testsuite.config
+ ~~~~~~~~~~~~~~~~~~~~~~
+
+ Configuration and instances.
+
+ :copyright: (c) 2011 by Armin Ronacher.
+ :license: BSD, see LICENSE for more details.
+"""
+import os
+import sys
+import flask
+import unittest
+from flask.testsuite import FlaskTestCase
+
+
+# config keys used for the ConfigTestCase
+TEST_KEY = 'foo'
+SECRET_KEY = 'devkey'
+
+
+class ConfigTestCase(FlaskTestCase):
+
+ def common_object_test(self, app):
+ assert app.secret_key == 'devkey'
+ assert app.config['TEST_KEY'] == 'foo'
+ assert 'ConfigTestCase' not in app.config
+
+ def test_config_from_file(self):
+ app = flask.Flask(__name__)
+ app.config.from_pyfile(__file__.rsplit('.')[0] + '.py')
+ self.common_object_test(app)
+
+ def test_config_from_object(self):
+ app = flask.Flask(__name__)
+ app.config.from_object(__name__)
+ self.common_object_test(app)
+
+ def test_config_from_class(self):
+ class Base(object):
+ TEST_KEY = 'foo'
+ class Test(Base):
+ SECRET_KEY = 'devkey'
+ app = flask.Flask(__name__)
+ app.config.from_object(Test)
+ self.common_object_test(app)
+
+ def test_config_from_envvar(self):
+ env = os.environ
+ try:
+ os.environ = {}
+ app = flask.Flask(__name__)
+ try:
+ app.config.from_envvar('FOO_SETTINGS')
+ except RuntimeError, e:
+ assert "'FOO_SETTINGS' is not set" in str(e)
+ else:
+ assert 0, 'expected exception'
+ assert not app.config.from_envvar('FOO_SETTINGS', silent=True)
+
+ os.environ = {'FOO_SETTINGS': __file__.rsplit('.')[0] + '.py'}
+ assert app.config.from_envvar('FOO_SETTINGS')
+ self.common_object_test(app)
+ finally:
+ os.environ = env
+
+ def test_config_missing(self):
+ app = flask.Flask(__name__)
+ try:
+ app.config.from_pyfile('missing.cfg')
+ except IOError, e:
+ msg = str(e)
+ assert msg.startswith('[Errno 2] Unable to load configuration '
+ 'file (No such file or directory):')
+ assert msg.endswith("missing.cfg'")
+ else:
+ assert 0, 'expected config'
+ assert not app.config.from_pyfile('missing.cfg', silent=True)
+
+
+class InstanceTestCase(FlaskTestCase):
+
+ def test_explicit_instance_paths(self):
+ here = os.path.abspath(os.path.dirname(__file__))
+ try:
+ flask.Flask(__name__, instance_path='instance')
+ except ValueError, e:
+ self.assert_('must be absolute' in str(e))
+ else:
+ self.fail('Expected value error')
+
+ app = flask.Flask(__name__, instance_path=here)
+ self.assert_equal(app.instance_path, here)
+
+ def test_uninstalled_module_paths(self):
+ from config_module_app import app
+ here = os.path.abspath(os.path.dirname(__file__))
+ self.assert_equal(app.instance_path, os.path.join(here, 'test_apps', 'instance'))
+
+ def test_uninstalled_package_paths(self):
+ from config_package_app import app
+ here = os.path.abspath(os.path.dirname(__file__))
+ self.assert_equal(app.instance_path, os.path.join(here, 'test_apps', 'instance'))
+
+ def test_installed_module_paths(self):
+ import types
+ expected_prefix = os.path.abspath('foo')
+ mod = types.ModuleType('myapp')
+ mod.__file__ = os.path.join(expected_prefix, 'lib', 'python2.5',
+ 'site-packages', 'myapp.py')
+ sys.modules['myapp'] = mod
+ try:
+ mod.app = flask.Flask(mod.__name__)
+ self.assert_equal(mod.app.instance_path,
+ os.path.join(expected_prefix, 'var',
+ 'myapp-instance'))
+ finally:
+ sys.modules['myapp'] = None
+
+ def test_installed_package_paths(self):
+ import types
+ expected_prefix = os.path.abspath('foo')
+ package_path = os.path.join(expected_prefix, 'lib', 'python2.5',
+ 'site-packages', 'myapp')
+ mod = types.ModuleType('myapp')
+ mod.__path__ = [package_path]
+ mod.__file__ = os.path.join(package_path, '__init__.py')
+ sys.modules['myapp'] = mod
+ try:
+ mod.app = flask.Flask(mod.__name__)
+ self.assert_equal(mod.app.instance_path,
+ os.path.join(expected_prefix, 'var',
+ 'myapp-instance'))
+ finally:
+ sys.modules['myapp'] = None
+
+ def test_prefix_installed_paths(self):
+ import types
+ expected_prefix = os.path.abspath(sys.prefix)
+ package_path = os.path.join(expected_prefix, 'lib', 'python2.5',
+ 'site-packages', 'myapp')
+ mod = types.ModuleType('myapp')
+ mod.__path__ = [package_path]
+ mod.__file__ = os.path.join(package_path, '__init__.py')
+ sys.modules['myapp'] = mod
+ try:
+ mod.app = flask.Flask(mod.__name__)
+ self.assert_equal(mod.app.instance_path,
+ os.path.join(expected_prefix, 'var',
+ 'myapp-instance'))
+ finally:
+ sys.modules['myapp'] = None
+
+ def test_egg_installed_paths(self):
+ import types
+ expected_prefix = os.path.abspath(sys.prefix)
+ package_path = os.path.join(expected_prefix, 'lib', 'python2.5',
+ 'site-packages', 'MyApp.egg', 'myapp')
+ mod = types.ModuleType('myapp')
+ mod.__path__ = [package_path]
+ mod.__file__ = os.path.join(package_path, '__init__.py')
+ sys.modules['myapp'] = mod
+ try:
+ mod.app = flask.Flask(mod.__name__)
+ self.assert_equal(mod.app.instance_path,
+ os.path.join(expected_prefix, 'var',
+ 'myapp-instance'))
+ finally:
+ sys.modules['myapp'] = None
+
+
+def suite():
+ suite = unittest.TestSuite()
+ suite.addTest(unittest.makeSuite(ConfigTestCase))
+ suite.addTest(unittest.makeSuite(InstanceTestCase))
+ return suite
View
38 flask/testsuite/deprecations.py
@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+"""
+ flask.testsuite.deprecations
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+ Tests deprecation support.
+
+ :copyright: (c) 2011 by Armin Ronacher.
+ :license: BSD, see LICENSE for more details.
+"""
+import flask
+import unittest
+from flask.testsuite import FlaskTestCase, catch_warnings
+
+
+class DeprecationsTestCase(FlaskTestCase):
+
+ def test_init_jinja_globals(self):
+ class MyFlask(flask.Flask):
+ def init_jinja_globals(self):
+ self.jinja_env.globals['foo'] = '42'
+
+ with catch_warnings() as log:
+ app = MyFlask(__name__)
+ @app.route('/')
+ def foo():
+ return app.jinja_env.globals['foo']
+
+ c = app.test_client()
+ assert c.get('/').data == '42'
+ assert len(log) == 1
+ assert 'init_jinja_globals' in str(log[0]['message'])
+
+
+def suite():
+ suite = unittest.TestSuite()
+ suite.addTest(unittest.makeSuite(DeprecationsTestCase))
+ return suite
View
38 flask/testsuite/examples.py
@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+"""
+ flask.testsuite.examples
+ ~~~~~~~~~~~~~~~~~~~~~~~~
+
+ Tests the examples.
+
+ :copyright: (c) 2011 by Armin Ronacher.
+ :license: BSD, see LICENSE for more details.
+"""
+import os
+import unittest
+from flask.testsuite import add_to_path
+
+
+def setup_path():
+ example_path = os.path.join(os.path.dirname(__file__),
+ os.pardir, os.pardir, 'examples')
+ add_to_path(os.path.join(example_path, 'flaskr'))
+ add_to_path(os.path.join(example_path, 'minitwit'))
+
+
+def suite():
+ setup_path()
+ suite = unittest.TestSuite()
+ try:
+ from minitwit_tests import MiniTwitTestCase
+ except ImportError:
+ pass
+ else:
+ suite.addTest(unittest.makeSuite(MiniTwitTestCase))
+ try:
+ from flaskr_tests import FlaskrTestCase
+ except ImportError:
+ pass
+ else:
+ suite.addTest(unittest.makeSuite(FlaskrTestCase))
+ return suite
View
295 flask/testsuite/helpers.py
@@ -0,0 +1,295 @@
+# -*- coding: utf-8 -*-
+"""
+ flask.testsuite.helpers
+ ~~~~~~~~~~~~~~~~~~~~~~~
+
+ Various helpers.
+
+ :copyright: (c) 2011 by Armin Ronacher.
+ :license: BSD, see LICENSE for more details.
+"""
+import os
+import flask
+import unittest
+from logging import StreamHandler
+from StringIO import StringIO
+from flask.testsuite import FlaskTestCase, catch_warnings, catch_stderr
+from werkzeug.http import parse_options_header
+
+
+def has_encoding(name):
+ try:
+ import codecs
+ codecs.lookup(name)
+ return True
+ except LookupError:
+ return False
+
+
+class JSONTestCase(FlaskTestCase):
+
+ def test_json_bad_requests(self):
+ app = flask.Flask(__name__)
+ @app.route('/json', methods=['POST'])
+ def return_json():
+ return unicode(flask.request.json)
+ c = app.test_client()
+ rv = c.post('/json', data='malformed', content_type='application/json')
+ self.assert_equal(rv.status_code, 400)
+
+ def test_json_body_encoding(self):
+ app = flask.Flask(__name__)
+ app.testing = True
+ @app.route('/')
+ def index():
+ return flask.request.json
+
+ c = app.test_client()
+ resp = c.get('/', data=u'"Hällo Wörld"'.encode('iso-8859-15'),
+ content_type='application/json; charset=iso-8859-15')
+ assert resp.data == u'Hällo Wörld'.encode('utf-8')
+
+ def test_jsonify(self):
+ d = dict(a=23, b=42, c=[1, 2, 3])
+ app = flask.Flask(__name__)
+ @app.route('/kw')
+ def return_kwargs():
+ return flask.jsonify(**d)
+ @app.route('/dict')
+ def return_dict():
+ return flask.jsonify(d)
+ c = app.test_client()
+ for url in '/kw', '/dict':
+ rv = c.get(url)
+ assert rv.mimetype == 'application/json'
+ assert flask.json.loads(rv.data) == d
+
+ def test_json_attr(self):
+ app = flask.Flask(__name__)
+ @app.route('/add', methods=['POST'])
+ def add():
+ return unicode(flask.request.json['a'] + flask.request.json['b'])
+ c = app.test_client()
+ rv = c.post('/add', data=flask.json.dumps({'a': 1, 'b': 2}),
+ content_type='application/json')
+ assert rv.data == '3'
+
+ def test_template_escaping(self):
+ app = flask.Flask(__name__)
+ render = flask.render_template_string
+ with app.test_request_context():
+ rv = render('{{ "</script>"|tojson|safe }}')
+ assert rv == '"<\\/script>"'
+ rv = render('{{ "<\0/script>"|tojson|safe }}')
+ assert rv == '"<\\u0000\\/script>"'
+
+ def test_modified_url_encoding(self):
+ class ModifiedRequest(flask.Request):
+ url_charset = 'euc-kr'
+ app = flask.Flask(__name__)
+ app.request_class = ModifiedRequest
+ app.url_map.charset = 'euc-kr'
+
+ @app.route('/')
+ def index():
+ return flask.request.args['foo']
+
+ rv = app.test_client().get(u'/?foo=정상처리'.encode('euc-kr'))
+ assert rv.status_code == 200
+ assert rv.data == u'정상처리'.encode('utf-8')
+
+ if not has_encoding('euc-kr'):
+ test_modified_url_encoding = None
+
+
+class SendfileTestCase(FlaskTestCase):
+
+ def test_send_file_regular(self):
+ app = flask.Flask(__name__)
+ with app.test_request_context():
+ rv = flask.send_file('static/index.html')
+ assert rv.direct_passthrough
+ assert rv.mimetype == 'text/html'
+ with app.open_resource('static/index.html') as f:
+ assert rv.data == f.read()
+
+ def test_send_file_xsendfile(self):
+ app = flask.Flask(__name__)
+ app.use_x_sendfile = True
+ with app.test_request_context():
+ rv = flask.send_file('static/index.html')
+ assert rv.direct_passthrough
+ assert 'x-sendfile' in rv.headers
+ assert rv.headers['x-sendfile'] == \
+ os.path.join(app.root_path, 'static/index.html')
+ assert rv.mimetype == 'text/html'
+
+ def test_send_file_object(self):
+ app = flask.Flask(__name__)
+ with catch_warnings() as captured:
+ with app.test_request_context():
+ f = open(os.path.join(app.root_path, 'static/index.html'))
+ rv = flask.send_file(f)
+ with app.open_resource('static/index.html') as f:
+ assert rv.data == f.read()
+ assert rv.mimetype == 'text/html'
+ # mimetypes + etag
+ assert len(captured) == 2
+
+ app.use_x_sendfile = True
+ with catch_warnings() as captured:
+ with app.test_request_context():
+ f = open(os.path.join(app.root_path, 'static/index.html'))
+ rv = flask.send_file(f)
+ assert rv.mimetype == 'text/html'
+ assert 'x-sendfile' in rv.headers
+ assert rv.headers['x-sendfile'] == \
+ os.path.join(app.root_path, 'static/index.html')
+ # mimetypes + etag
+ assert len(captured) == 2
+
+ app.use_x_sendfile = False
+ with app.test_request_context():
+ with catch_warnings() as captured:
+ f = StringIO('Test')
+ rv = flask.send_file(f)
+ assert rv.data == 'Test'
+ assert rv.mimetype == 'application/octet-stream'
+ # etags
+ assert len(captured) == 1
+ with catch_warnings() as captured:
+ f = StringIO('Test')
+ rv = flask.send_file(f, mimetype='text/plain')
+ assert rv.data == 'Test'
+ assert rv.mimetype == 'text/plain'
+ # etags
+ assert len(captured) == 1
+
+ app.use_x_sendfile = True
+ with catch_warnings() as captured:
+ with app.test_request_context():
+ f = StringIO('Test')
+ rv = flask.send_file(f)
+ assert 'x-sendfile' not in rv.headers
+ # etags
+ assert len(captured) == 1
+
+ def test_attachment(self):
+ app = flask.Flask(__name__)
+ with catch_warnings() as captured:
+ with app.test_request_context():
+ f = open(os.path.join(app.root_path, 'static/index.html'))
+ rv = flask.send_file(f, as_attachment=True)
+ value, options = parse_options_header(rv.headers['Content-Disposition'])
+ assert value == 'attachment'
+ # mimetypes + etag
+ assert len(captured) == 2
+
+ with app.test_request_context():
+ assert options['filename'] == 'index.html'
+ rv = flask.send_file('static/index.html', as_attachment=True)
+ value, options = parse_options_header(rv.headers['Content-Disposition'])
+ assert value == 'attachment'
+ assert options['filename'] == 'index.html'
+
+ with app.test_request_context():
+ rv = flask.send_file(StringIO('Test'), as_attachment=True,
+ attachment_filename='index.txt',
+ add_etags=False)
+ assert rv.mimetype == 'text/plain'
+ value, options = parse_options_header(rv.headers['Content-Disposition'])
+ assert value == 'attachment'
+ assert options['filename'] == 'index.txt'
+
+
+class LoggingTestCase(FlaskTestCase):
+
+ def test_logger_cache(self):
+ app = flask.Flask(__name__)
+ logger1 = app.logger
+ assert app.logger is logger1
+ assert logger1.name == __name__
+ app.logger_name = __name__ + '/test_logger_cache'
+ assert app.logger is not logger1
+
+ def test_debug_log(self):
+ app = flask.Flask(__name__)
+ app.debug = True
+
+ @app.route('/')
+ def index():
+ app.logger.warning('the standard library is dead')
+ app.logger.debug('this is a debug statement')
+ return ''
+
+ @app.route('/exc')
+ def exc():
+ 1/0
+
+ with app.test_client() as c:
+ with catch_stderr() as err:
+ c.get('/')
+ out = err.getvalue()
+ assert 'WARNING in helpers [' in out
+ assert os.path.basename(__file__.rsplit('.')[0] + '.py') in out
+ assert 'the standard library is dead' in out
+ assert 'this is a debug statement' in out
+
+ with catch_stderr() as err:
+ try:
+ c.get('/exc')
+ except ZeroDivisionError:
+ pass
+ else:
+ assert False, 'debug log ate the exception'
+
+ def test_exception_logging(self):
+ out = StringIO()
+ app = flask.Flask(__name__)
+ app.logger_name = 'flask_tests/test_exception_logging'
+ app.logger.addHandler(StreamHandler(out))
+
+ @app.route('/')
+ def index():
+ 1/0
+
+ rv = app.test_client().get('/')
+ assert rv.status_code == 500
+ assert 'Internal Server Error' in rv.data
+
+ err = out.getvalue()
+ assert 'Exception on / [GET]' in err
+ assert 'Traceback (most recent call last):' in err
+ assert '1/0' in err
+ assert 'ZeroDivisionError:' in err
+
+ def test_processor_exceptions(self):
+ app = flask.Flask(__name__)
+ @app.before_request
+ def before_request():
+ if trigger == 'before':
+ 1/0
+ @app.after_request
+ def after_request(response):
+ if trigger == 'after':
+ 1/0
+ return response
+ @app.route('/')
+ def index():
+ return 'Foo'
+ @app.errorhandler(500)
+ def internal_server_error(e):
+ return 'Hello Server Error', 500
+ for trigger in 'before', 'after':
+ rv = app.test_client().get('/')
+ assert rv.status_code == 500
+ assert rv.data == 'Hello Server Error'
+
+
+def suite():
+ suite = unittest.TestSuite()
+ if flask.json_available:
+ suite.addTest(unittest.makeSuite(JSONTestCase))
+ suite.addTest(unittest.makeSuite(SendfileTestCase))
+ suite.addTest(unittest.makeSuite(LoggingTestCase))
+ return suite
View
103 flask/testsuite/signals.py
@@ -0,0 +1,103 @@
+# -*- coding: utf-8 -*-
+"""
+ flask.testsuite.signals
+ ~~~~~~~~~~~~~~~~~~~~~~~
+
+ Signalling.
+
+ :copyright: (c) 2011 by Armin Ronacher.
+ :license: BSD, see LICENSE for more details.
+"""
+import flask
+import unittest
+from flask.testsuite import FlaskTestCase
+
+
+class SignalsTestCase(FlaskTestCase):
+
+ def test_template_rendered(self):
+ app = flask.Flask(__name__)
+
+ @app.route('/')
+ def index():
+ return flask.render_template('simple_template.html', whiskey=42)
+
+ recorded = []
+ def record(sender, template, context):
+ recorded.append((template, context))
+
+ flask.template_rendered.connect(record, app)
+ try:
+ app.test_client().get('/')
+ assert len(recorded) == 1
+ template, context = recorded[0]
+ assert template.name == 'simple_template.html'
+ assert context['whiskey'] == 42
+ finally:
+ flask.template_rendered.disconnect(record, app)
+
+ def test_request_signals(self):
+ app = flask.Flask(__name__)
+ calls = []
+
+ def before_request_signal(sender):
+ calls.append('before-signal')
+
+ def after_request_signal(sender, response):
+ assert response.data == 'stuff'
+ calls.append('after-signal')
+
+ @app.before_request
+ def before_request_handler():
+ calls.append('before-handler')
+
+ @app.after_request
+ def after_request_handler(response):
+ calls.append('after-handler')
+ response.data = 'stuff'
+ return response
+
+ @app.route('/')
+ def index():
+ calls.append('handler')
+ return 'ignored anyway'
+
+ flask.request_started.connect(before_request_signal, app)
+ flask.request_finished.connect(after_request_signal, app)
+
+ try:
+ rv = app.test_client().get('/')
+ assert rv.data == 'stuff'
+
+ assert calls == ['before-signal', 'before-handler',
+ 'handler', 'after-handler',
+ 'after-signal']
+ finally:
+ flask.request_started.disconnect(before_request_signal, app)
+ flask.request_finished.disconnect(after_request_signal, app)
+
+ def test_request_exception_signal(self):
+ app = flask.Flask(__name__)
+ recorded = []
+
+ @app.route('/')
+ def index():
+ 1/0
+
+ def record(sender, exception):
+ recorded.append(exception)
+
+ flask.got_request_exception.connect(record, app)
+ try:
+ assert app.test_client().get('/').status_code == 500
+ assert len(recorded) == 1
+ assert isinstance(recorded[0], ZeroDivisionError)
+ finally:
+ flask.got_request_exception.disconnect(record, app)
+
+
+def suite():
+ suite = unittest.TestSuite()
+ if flask.signals_available:
+ suite.addTest(unittest.makeSuite(SignalsTestCase))
+ return suite
View
0  tests/static/index.html → flask/testsuite/static/index.html
File renamed without changes
View
0  tests/templates/_macro.html → flask/testsuite/templates/_macro.html
File renamed without changes
View
0  tests/templates/context_template.html → flask/testsuite/templates/context_template.html
File renamed without changes
View
0  tests/templates/escaping_template.html → flask/testsuite/templates/escaping_template.html
File renamed without changes
View
0  tests/templates/mail.txt → flask/testsuite/templates/mail.txt
File renamed without changes
View
0  tests/templates/nested/nested.txt → flask/testsuite/templates/nested/nested.txt
File renamed without changes
View
0  tests/templates/simple_template.html → flask/testsuite/templates/simple_template.html
File renamed without changes
View
0  tests/templates/template_filter.html → flask/testsuite/templates/template_filter.html
File renamed without changes
View
141 flask/testsuite/templating.py
@@ -0,0 +1,141 @@
+# -*- coding: utf-8 -*-
+"""
+ flask.testsuite.templating
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+ Template functionality
+
+ :copyright: (c) 2011 by Armin Ronacher.
+ :license: BSD, see LICENSE for more details.
+"""
+import flask
+import unittest
+from flask.testsuite import FlaskTestCase
+
+
+class TemplatingTestCase(FlaskTestCase):
+
+ def test_context_processing(self):
+ app = flask.Flask(__name__)
+ @app.context_processor
+ def context_processor():
+ return {'injected_value': 42}
+ @app.route('/')
+ def index():
+ return flask.render_template('context_template.html', value=23)
+ rv = app.test_client().get('/')
+ assert rv.data == '<p>23|42'
+
+ def test_original_win(self):
+ app = flask.Flask(__name__)
+ @app.route('/')
+ def index():
+ return flask.render_template_string('{{ config }}', config=42)
+ rv = app.test_client().get('/')
+ assert rv.data == '42'
+
+ def test_standard_context(self):
+ app = flask.Flask(__name__)
+ app.secret_key = 'development key'
+ @app.route('/')
+ def index():
+ flask.g.foo = 23
+ flask.session['test'] = 'aha'
+ return flask.render_template_string('''
+ {{ request.args.foo }}
+ {{ g.foo }}
+ {{ config.DEBUG }}
+ {{ session.test }}
+ ''')
+ rv = app.test_client().get('/?foo=42')
+ assert rv.data.split() == ['42', '23', 'False', 'aha']
+
+ def test_escaping(self):
+ text = '<p>Hello World!'
+ app = flask.Flask(__name__)
+ @app.route('/')
+ def index():
+ return flask.render_template('escaping_template.html', text=text,
+ html=flask.Markup(text))
+ lines = app.test_client().get('/').data.splitlines()
+ assert lines == [
+ '&lt;p&gt;Hello World!',
+ '<p>Hello World!',
+ '<p>Hello World!',
+ '<p>Hello World!',
+ '&lt;p&gt;Hello World!',
+ '<p>Hello World!'
+ ]
+
+ def test_no_escaping(self):
+ app = flask.Flask(__name__)
+ with app.test_request_context():
+ assert flask.render_template_string('{{ foo }}',
+ foo='<test>') == '<test>'
+ assert flask.render_template('mail.txt', foo='<test>') \
+ == '<test> Mail'
+
+ def test_macros(self):
+ app = flask.Flask(__name__)
+ with app.test_request_context():
+ macro = flask.get_template_attribute('_macro.html', 'hello')
+ assert macro('World') == 'Hello World!'
+
+ def test_template_filter(self):
+ app = flask.Flask(__name__)
+ @app.template_filter()
+ def my_reverse(s):
+ return s[::-1]
+ assert 'my_reverse' in app.jinja_env.filters.keys()
+ assert app.jinja_env.filters['my_reverse'] == my_reverse
+ assert app.jinja_env.filters['my_reverse']('abcd') == 'dcba'
+
+ def test_template_filter_with_name(self):
+ app = flask.Flask(__name__)
+ @app.template_filter('strrev')
+ def my_reverse(s):
+ return s[::-1]
+ assert 'strrev' in app.jinja_env.filters.keys()
+ assert app.jinja_env.filters['strrev'] == my_reverse
+ assert app.jinja_env.filters['strrev']('abcd') == 'dcba'
+
+ def test_template_filter_with_template(self):
+ app = flask.Flask(__name__)
+ @app.template_filter()
+ def super_reverse(s):
+ return s[::-1]
+ @app.route('/')
+ def index():
+ return flask.render_template('template_filter.html', value='abcd')
+ rv = app.test_client().get('/')
+ assert rv.data == 'dcba'
+
+ def test_template_filter_with_name_and_template(self):
+ app = flask.Flask(__name__)
+ @app.template_filter('super_reverse')
+ def my_reverse(s):
+ return s[::-1]
+ @app.route('/')
+ def index():
+ return flask.render_template('template_filter.html', value='abcd')
+ rv = app.test_client().get('/')
+ assert rv.data == 'dcba'
+
+ def test_custom_template_loader(self):
+ class MyFlask(flask.Flask):
+ def create_global_jinja_loader(self):
+ from jinja2 import DictLoader
+ return DictLoader({'index.html': 'Hello Custom World!'})
+ app = MyFlask(__name__)
+ @app.route('/')
+ def index():
+ return flask.render_template('index.html')
+ c = app.test_client()
+ rv = c.get('/')
+ assert rv.data == 'Hello Custom World!'
+
+
+def suite():
+ suite = unittest.TestSuite()
+ suite.addTest(unittest.makeSuite(TemplatingTestCase))
+ return suite
View
0  tests/blueprintapp/__init__.py → flask/testsuite/test_apps/blueprintapp/__init__.py
File renamed without changes
View
0  tests/moduleapp/apps/__init__.py → ...testsuite/test_apps/blueprintapp/apps/__init__.py
File renamed without changes
View
0  tests/blueprintapp/apps/admin/__init__.py → ...ite/test_apps/blueprintapp/apps/admin/__init__.py
File renamed without changes
View
0  tests/moduleapp/apps/admin/static/css/test.css → ..._apps/blueprintapp/apps/admin/static/css/test.css
File renamed without changes
View
0  tests/moduleapp/apps/admin/static/test.txt → ...test_apps/blueprintapp/apps/admin/static/test.txt
File renamed without changes
View
0  tests/moduleapp/apps/admin/templates/index.html → ...lueprintapp/apps/admin/templates/admin/index.html
File renamed without changes
View
0  tests/blueprintapp/apps/frontend/__init__.py → .../test_apps/blueprintapp/apps/frontend/__init__.py
File renamed without changes
View
0  tests/moduleapp/apps/frontend/templates/index.html → ...ntapp/apps/frontend/templates/frontend/index.html
File renamed without changes
View
4 flask/testsuite/test_apps/config_module_app.py
@@ -0,0 +1,4 @@
+import os
+import flask
+here = os.path.abspath(os.path.dirname(__file__))
+app = flask.Flask(__name__)