mirror of https://github.com/mitsuhiko/flask.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
370 lines
12 KiB
370 lines
12 KiB
# -*- coding: utf-8 -*- |
|
""" |
|
Flask Tests |
|
~~~~~~~~~~~ |
|
|
|
Tests Flask itself. The majority of Flask is already tested |
|
as part of Werkzeug. |
|
|
|
:copyright: (c) 2010 by Armin Ronacher. |
|
:license: BSD, see LICENSE for more details. |
|
""" |
|
from __future__ import with_statement |
|
import os |
|
import sys |
|
import flask |
|
import unittest |
|
import tempfile |
|
import warnings |
|
|
|
|
|
example_path = os.path.join(os.path.dirname(__file__), '..', 'examples') |
|
sys.path.append(os.path.join(example_path, 'flaskr')) |
|
sys.path.append(os.path.join(example_path, 'minitwit')) |
|
|
|
|
|
class ContextTestCase(unittest.TestCase): |
|
|
|
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' |
|
|
|
|
|
class BasicFunctionalityTestCase(unittest.TestCase): |
|
|
|
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'] |
|
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', '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'] |
|
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', 'POST'] |
|
|
|
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_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_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_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_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' in rv.data |
|
|
|
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_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' |
|
|
|
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): |
|
return ','.join(super(ListConverter, self).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): |
|
warnings.filterwarnings('error', 'View function did not return') |
|
app = flask.Flask(__name__) |
|
@app.route('/') |
|
def test(): |
|
return None |
|
try: |
|
app.test_client().get('/') |
|
except Warning: |
|
pass |
|
else: |
|
assert "Expected warning" |
|
|
|
|
|
class JSONTestCase(unittest.TestCase): |
|
|
|
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__) |
|
with app.test_request_context(): |
|
rv = flask.render_template_string('{{ "</script>"|tojson|safe }}') |
|
assert rv == '"<\\/script>"' |
|
rv = flask.render_template_string('{{ "<\0/script>"|tojson|safe }}') |
|
assert rv == '"<\\u0000\\/script>"' |
|
|
|
|
|
class TemplatingTestCase(unittest.TestCase): |
|
|
|
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_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 == [ |
|
'<p>Hello World!', |
|
'<p>Hello World!', |
|
'<p>Hello World!', |
|
'<p>Hello World!', |
|
'<p>Hello World!', |
|
'<p>Hello World!' |
|
] |
|
|
|
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 suite(): |
|
from minitwit_tests import MiniTwitTestCase |
|
from flaskr_tests import FlaskrTestCase |
|
suite = unittest.TestSuite() |
|
suite.addTest(unittest.makeSuite(ContextTestCase)) |
|
suite.addTest(unittest.makeSuite(BasicFunctionalityTestCase)) |
|
suite.addTest(unittest.makeSuite(TemplatingTestCase)) |
|
if flask.json_available: |
|
suite.addTest(unittest.makeSuite(JSONTestCase)) |
|
suite.addTest(unittest.makeSuite(MiniTwitTestCase)) |
|
suite.addTest(unittest.makeSuite(FlaskrTestCase)) |
|
return suite |
|
|
|
|
|
if __name__ == '__main__': |
|
unittest.main(defaultTest='suite')
|
|
|