maya-chen/flask
1
0
Fork 0
forked from orbit-oss/flask
Code Pull requests Activity

Rewrite assertion methods

Browse source
This commit is contained in:
Markus Unterwaditzer 2014-09-02 05:26:52 +02:00
parent dd6b2574c9
commit 5da2c00419
14 changed files with 694 additions and 719 deletions
Download patch file Download diff file Expand all files Collapse all files

34
tests/__init__.py
View file

@ -78,9 +78,9 @@ def emits_module_deprecation_warning(f):
def new_f(self, *args, **kwargs):
with catch_warnings() as log:
f(self, *args, **kwargs)
self.assert_true(log, 'expected deprecation warning')
assert log, 'expected deprecation warning'
for entry in log:
self.assert_in('Modules are deprecated', str(entry['message']))
assert 'Modules are deprecated' in str(entry['message'])
return update_wrapper(new_f, f)
@ -107,7 +107,7 @@ class TestFlask(object):
leaks = []
while flask._request_ctx_stack.top is not None:
leaks.append(flask._request_ctx_stack.pop())
self.assert_equal(leaks, [])
assert leaks == []
def setup_method(self, method):
self.setup()
@ -120,31 +120,3 @@ class TestFlask(object):
def teardown(self):
pass
def assert_equal(self, x, y):
assert x == y
def assert_raises(self, exc_type, callable=None, *args, **kwargs):
if callable:
return pytest.raises(exc_type, callable, *args, **kwargs)
else:
return pytest.raises(exc_type)
def assert_true(self, x, msg=None):
assert x
assert_ = assert_true
def assert_false(self, x, msg=None):
assert not x
def assert_in(self, x, y):
assert x in y
def assert_not_in(self, x, y):
assert x not in y
def assert_isinstance(self, obj, cls):
assert isinstance(obj, cls)
def fail(self, msg):
raise AssertionError(msg)

33
tests/test_appctx.py
View file

@ -9,6 +9,8 @@
:license: BSD, see LICENSE for more details.
"""
import pytest
import flask
import unittest
from tests import TestFlask
@ -27,29 +29,29 @@ class TestAppContext(TestFlask):
with app.app_context():
rv = flask.url_for('index')
self.assert_equal(rv, 'https://localhost/')
assert rv == 'https://localhost/'
def test_url_generation_requires_server_name(self):
app = flask.Flask(__name__)
with app.app_context():
with self.assert_raises(RuntimeError):
with pytest.raises(RuntimeError):
flask.url_for('index')
def test_url_generation_without_context_fails(self):
with self.assert_raises(RuntimeError):
with pytest.raises(RuntimeError):
flask.url_for('index')
def test_request_context_means_app_context(self):
app = flask.Flask(__name__)
with app.test_request_context():
self.assert_equal(flask.current_app._get_current_object(), app)
self.assert_equal(flask._app_ctx_stack.top, None)
assert flask.current_app._get_current_object() == app
assert flask._app_ctx_stack.top == None
def test_app_context_provides_current_app(self):
app = flask.Flask(__name__)
with app.app_context():
self.assert_equal(flask.current_app._get_current_object(), app)
self.assert_equal(flask._app_ctx_stack.top, None)
assert flask.current_app._get_current_object() == app
assert flask._app_ctx_stack.top == None
def test_app_tearing_down(self):
cleanup_stuff = []
@ -61,7 +63,7 @@ class TestAppContext(TestFlask):
with app.app_context():
pass
self.assert_equal(cleanup_stuff, [None])
assert cleanup_stuff == [None]
def test_app_tearing_down_with_previous_exception(self):
cleanup_stuff = []
@ -78,7 +80,7 @@ class TestAppContext(TestFlask):
with app.app_context():
pass
self.assert_equal(cleanup_stuff, [None])
assert cleanup_stuff == [None]
def test_custom_app_ctx_globals_class(self):
class CustomRequestGlobals(object):
@ -87,8 +89,7 @@ class TestAppContext(TestFlask):
app = flask.Flask(__name__)
app.app_ctx_globals_class = CustomRequestGlobals
with app.app_context():
self.assert_equal(
flask.render_template_string('{{ g.spam }}'), 'eggs')
assert flask.render_template_string('{{ g.spam }}') == 'eggs'
def test_context_refcounts(self):
called = []
@ -104,12 +105,14 @@ class TestAppContext(TestFlask):
with flask._app_ctx_stack.top:
with flask._request_ctx_stack.top:
pass
self.assert_true(flask._request_ctx_stack.top.request.environ
['werkzeug.request'] is not None)
env = flask._request_ctx_stack.top.request.environ
assert env['werkzeug.request'] is not None
return u''
c = app.test_client()
c.get('/')
self.assert_equal(called, ['request', 'app'])
res = c.get('/')
assert res.status_code == 200
assert res.data == u''
assert called == ['request', 'app']
def suite():

505
tests/test_basic.py
View file

File diff suppressed because it is too large Load diff

150
tests/test_blueprints.py
View file

@ -9,6 +9,8 @@
:license: BSD, see LICENSE for more details.
"""
import pytest
import flask
import unittest
from tests import TestFlask
@ -55,9 +57,9 @@ class TestBlueprint(TestFlask):
c = app.test_client()
self.assert_equal(c.get('/frontend-no').data, b'frontend says no')
self.assert_equal(c.get('/backend-no').data, b'backend says no')
self.assert_equal(c.get('/what-is-a-sideend').data, b'application itself says no')
assert c.get('/frontend-no').data == b'frontend says no'
assert c.get('/backend-no').data == b'backend says no'
assert c.get('/what-is-a-sideend').data == b'application itself says no'
def test_blueprint_specific_user_error_handling(self):
class MyDecoratorException(Exception):
@ -69,11 +71,11 @@ class TestBlueprint(TestFlask):
@blue.errorhandler(MyDecoratorException)
def my_decorator_exception_handler(e):
self.assert_true(isinstance(e, MyDecoratorException))
assert isinstance(e, MyDecoratorException)
return 'boom'
def my_function_exception_handler(e):
self.assert_true(isinstance(e, MyFunctionException))
assert isinstance(e, MyFunctionException)
return 'bam'
blue.register_error_handler(MyFunctionException, my_function_exception_handler)
@ -89,8 +91,8 @@ class TestBlueprint(TestFlask):
c = app.test_client()
self.assert_equal(c.get('/decorator').data, b'boom')
self.assert_equal(c.get('/function').data, b'bam')
assert c.get('/decorator').data == b'boom'
assert c.get('/function').data == b'bam'
def test_blueprint_url_definitions(self):
bp = flask.Blueprint('test', __name__)
@ -108,10 +110,10 @@ class TestBlueprint(TestFlask):
app.register_blueprint(bp, url_prefix='/2', url_defaults={'bar': 19})
c = app.test_client()
self.assert_equal(c.get('/1/foo').data, b'23/42')
self.assert_equal(c.get('/2/foo').data, b'19/42')
self.assert_equal(c.get('/1/bar').data, b'23')
self.assert_equal(c.get('/2/bar').data, b'19')
assert c.get('/1/foo').data == b'23/42'
assert c.get('/2/foo').data == b'19/42'
assert c.get('/1/bar').data == b'23'
assert c.get('/2/bar').data == b'19'
def test_blueprint_url_processors(self):
bp = flask.Blueprint('frontend', __name__, url_prefix='/<lang_code>')
@ -137,24 +139,24 @@ class TestBlueprint(TestFlask):
c = app.test_client()
self.assert_equal(c.get('/de/').data, b'/de/about')
self.assert_equal(c.get('/de/about').data, b'/de/')
assert c.get('/de/').data == b'/de/about'
assert c.get('/de/about').data == b'/de/'
def test_templates_and_static(self):
from blueprintapp import app
c = app.test_client()
rv = c.get('/')
self.assert_equal(rv.data, b'Hello from the Frontend')
assert rv.data == b'Hello from the Frontend'
rv = c.get('/admin/')
self.assert_equal(rv.data, b'Hello from the Admin')
assert rv.data == b'Hello from the Admin'
rv = c.get('/admin/index2')
self.assert_equal(rv.data, b'Hello from the Admin')
assert rv.data == b'Hello from the Admin'
rv = c.get('/admin/static/test.txt')
self.assert_equal(rv.data.strip(), b'Admin File')
assert rv.data.strip() == b'Admin File'
rv.close()
rv = c.get('/admin/static/css/test.css')
self.assert_equal(rv.data.strip(), b'/* nested file */')
assert rv.data.strip() == b'/* nested file */'
rv.close()
# try/finally, in case other tests use this app for Blueprint tests.
@ -166,25 +168,24 @@ class TestBlueprint(TestFlask):
app.config['SEND_FILE_MAX_AGE_DEFAULT'] = expected_max_age
rv = c.get('/admin/static/css/test.css')
cc = parse_cache_control_header(rv.headers['Cache-Control'])
self.assert_equal(cc.max_age, expected_max_age)
assert cc.max_age == expected_max_age
rv.close()
finally:
app.config['SEND_FILE_MAX_AGE_DEFAULT'] = max_age_default
with app.test_request_context():
self.assert_equal(flask.url_for('admin.static', filename='test.txt'),
'/admin/static/test.txt')
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 as e:
self.assert_equal(e.name, 'missing.html')
assert e.name == 'missing.html'
else:
self.assert_true(0, 'expected exception')
assert 0, 'expected exception'
with flask.Flask(__name__).test_request_context():
self.assert_equal(flask.render_template('nested/nested.txt'), 'I\'m nested')
assert flask.render_template('nested/nested.txt') == 'I\'m nested'
def test_default_static_cache_timeout(self):
app = flask.Flask(__name__)
@ -205,7 +206,7 @@ class TestBlueprint(TestFlask):
app.config['SEND_FILE_MAX_AGE_DEFAULT'] = unexpected_max_age
rv = blueprint.send_static_file('index.html')
cc = parse_cache_control_header(rv.headers['Cache-Control'])
self.assert_equal(cc.max_age, 100)
assert cc.max_age == 100
rv.close()
finally:
app.config['SEND_FILE_MAX_AGE_DEFAULT'] = max_age_default
@ -213,8 +214,7 @@ class TestBlueprint(TestFlask):
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'])
assert templates == ['admin/index.html', 'frontend/index.html']
def test_dotted_names(self):
frontend = flask.Blueprint('myapp.frontend', __name__)
@ -237,9 +237,9 @@ class TestBlueprint(TestFlask):
app.register_blueprint(backend)
c = app.test_client()
self.assert_equal(c.get('/fe').data.strip(), b'/be')
self.assert_equal(c.get('/fe2').data.strip(), b'/fe')
self.assert_equal(c.get('/be').data.strip(), b'/fe')
assert c.get('/fe').data.strip() == b'/be'
assert c.get('/fe2').data.strip() == b'/fe'
assert c.get('/be').data.strip() == b'/fe'
def test_dotted_names_from_app(self):
app = flask.Flask(__name__)
@ -258,7 +258,7 @@ class TestBlueprint(TestFlask):
with app.test_client() as c:
rv = c.get('/')
self.assert_equal(rv.data, b'/test/')
assert rv.data == b'/test/'
def test_empty_url_defaults(self):
bp = flask.Blueprint('bp', __name__)
@ -272,8 +272,8 @@ class TestBlueprint(TestFlask):
app.register_blueprint(bp)
c = app.test_client()
self.assert_equal(c.get('/').data, b'1')
self.assert_equal(c.get('/page/2').data, b'2')
assert c.get('/').data == b'1'
assert c.get('/page/2').data == b'2'
def test_route_decorator_custom_endpoint(self):
@ -303,11 +303,11 @@ class TestBlueprint(TestFlask):
return flask.request.endpoint
c = app.test_client()
self.assert_equal(c.get('/').data, b'index')
self.assert_equal(c.get('/py/foo').data, b'bp.foo')
self.assert_equal(c.get('/py/bar').data, b'bp.bar')
self.assert_equal(c.get('/py/bar/123').data, b'bp.123')
self.assert_equal(c.get('/py/bar/foo').data, b'bp.bar_foo')
assert c.get('/').data == b'index'
assert c.get('/py/foo').data == b'bp.foo'
assert c.get('/py/bar').data == b'bp.bar'
assert c.get('/py/bar/123').data == b'bp.123'
assert c.get('/py/bar/foo').data == b'bp.bar_foo'
def test_route_decorator_custom_endpoint_with_dots(self):
bp = flask.Blueprint('bp', __name__)
@ -337,14 +337,14 @@ class TestBlueprint(TestFlask):
def foo_foo_foo():
pass
self.assert_raises(
pytest.raises(
AssertionError,
lambda: bp.add_url_rule(
'/bar/123', endpoint='bar.123', view_func=foo_foo_foo
)
)
self.assert_raises(
pytest.raises(
AssertionError,
bp.route('/bar/123', endpoint='bar.123'),
lambda: None
@ -354,7 +354,7 @@ class TestBlueprint(TestFlask):
app.register_blueprint(bp, url_prefix='/py')
c = app.test_client()
self.assert_equal(c.get('/py/foo').data, b'bp.foo')
assert c.get('/py/foo').data == b'bp.foo'
# The rule's didn't actually made it through
rv = c.get('/py/bar')
assert rv.status_code == 404
@ -368,9 +368,9 @@ class TestBlueprint(TestFlask):
return s[::-1]
app = flask.Flask(__name__)
app.register_blueprint(bp, url_prefix='/py')
self.assert_in('my_reverse', app.jinja_env.filters.keys())
self.assert_equal(app.jinja_env.filters['my_reverse'], my_reverse)
self.assert_equal(app.jinja_env.filters['my_reverse']('abcd'), 'dcba')
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_add_template_filter(self):
bp = flask.Blueprint('bp', __name__)
@ -379,9 +379,9 @@ class TestBlueprint(TestFlask):
bp.add_app_template_filter(my_reverse)
app = flask.Flask(__name__)
app.register_blueprint(bp, url_prefix='/py')
self.assert_in('my_reverse', app.jinja_env.filters.keys())
self.assert_equal(app.jinja_env.filters['my_reverse'], my_reverse)
self.assert_equal(app.jinja_env.filters['my_reverse']('abcd'), 'dcba')
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):
bp = flask.Blueprint('bp', __name__)
@ -390,9 +390,9 @@ class TestBlueprint(TestFlask):
return s[::-1]
app = flask.Flask(__name__)
app.register_blueprint(bp, url_prefix='/py')
self.assert_in('strrev', app.jinja_env.filters.keys())
self.assert_equal(app.jinja_env.filters['strrev'], my_reverse)
self.assert_equal(app.jinja_env.filters['strrev']('abcd'), 'dcba')
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_add_template_filter_with_name(self):
bp = flask.Blueprint('bp', __name__)
@ -401,9 +401,9 @@ class TestBlueprint(TestFlask):
bp.add_app_template_filter(my_reverse, 'strrev')
app = flask.Flask(__name__)
app.register_blueprint(bp, url_prefix='/py')
self.assert_in('strrev', app.jinja_env.filters.keys())
self.assert_equal(app.jinja_env.filters['strrev'], my_reverse)
self.assert_equal(app.jinja_env.filters['strrev']('abcd'), 'dcba')
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):
bp = flask.Blueprint('bp', __name__)
@ -416,7 +416,7 @@ class TestBlueprint(TestFlask):
def index():
return flask.render_template('template_filter.html', value='abcd')
rv = app.test_client().get('/')
self.assert_equal(rv.data, b'dcba')
assert rv.data == b'dcba'
def test_template_filter_after_route_with_template(self):
app = flask.Flask(__name__)
@ -429,7 +429,7 @@ class TestBlueprint(TestFlask):
return s[::-1]
app.register_blueprint(bp, url_prefix='/py')
rv = app.test_client().get('/')
self.assert_equal(rv.data, b'dcba')
assert rv.data == b'dcba'
def test_add_template_filter_with_template(self):
bp = flask.Blueprint('bp', __name__)
@ -442,7 +442,7 @@ class TestBlueprint(TestFlask):
def index():
return flask.render_template('template_filter.html', value='abcd')
rv = app.test_client().get('/')
self.assert_equal(rv.data, b'dcba')
assert rv.data == b'dcba'
def test_template_filter_with_name_and_template(self):
bp = flask.Blueprint('bp', __name__)
@ -455,7 +455,7 @@ class TestBlueprint(TestFlask):
def index():
return flask.render_template('template_filter.html', value='abcd')
rv = app.test_client().get('/')
self.assert_equal(rv.data, b'dcba')
assert rv.data == b'dcba'
def test_add_template_filter_with_name_and_template(self):
bp = flask.Blueprint('bp', __name__)
@ -468,7 +468,7 @@ class TestBlueprint(TestFlask):
def index():
return flask.render_template('template_filter.html', value='abcd')
rv = app.test_client().get('/')
self.assert_equal(rv.data, b'dcba')
assert rv.data == b'dcba'
def test_template_test(self):
bp = flask.Blueprint('bp', __name__)
@ -477,9 +477,9 @@ class TestBlueprint(TestFlask):
return isinstance(value, bool)
app = flask.Flask(__name__)
app.register_blueprint(bp, url_prefix='/py')
self.assert_in('is_boolean', app.jinja_env.tests.keys())
self.assert_equal(app.jinja_env.tests['is_boolean'], is_boolean)
self.assert_true(app.jinja_env.tests['is_boolean'](False))
assert 'is_boolean' in app.jinja_env.tests.keys()
assert app.jinja_env.tests['is_boolean'] == is_boolean
assert app.jinja_env.tests['is_boolean'](False)
def test_add_template_test(self):
bp = flask.Blueprint('bp', __name__)
@ -488,9 +488,9 @@ class TestBlueprint(TestFlask):
bp.add_app_template_test(is_boolean)
app = flask.Flask(__name__)
app.register_blueprint(bp, url_prefix='/py')
self.assert_in('is_boolean', app.jinja_env.tests.keys())
self.assert_equal(app.jinja_env.tests['is_boolean'], is_boolean)
self.assert_true(app.jinja_env.tests['is_boolean'](False))
assert 'is_boolean' in app.jinja_env.tests.keys()
assert app.jinja_env.tests['is_boolean'] == is_boolean
assert app.jinja_env.tests['is_boolean'](False)
def test_template_test_with_name(self):
bp = flask.Blueprint('bp', __name__)
@ -499,9 +499,9 @@ class TestBlueprint(TestFlask):
return isinstance(value, bool)
app = flask.Flask(__name__)
app.register_blueprint(bp, url_prefix='/py')
self.assert_in('boolean', app.jinja_env.tests.keys())
self.assert_equal(app.jinja_env.tests['boolean'], is_boolean)
self.assert_true(app.jinja_env.tests['boolean'](False))
assert 'boolean' in app.jinja_env.tests.keys()
assert app.jinja_env.tests['boolean'] == is_boolean
assert app.jinja_env.tests['boolean'](False)
def test_add_template_test_with_name(self):
bp = flask.Blueprint('bp', __name__)
@ -510,9 +510,9 @@ class TestBlueprint(TestFlask):
bp.add_app_template_test(is_boolean, 'boolean')
app = flask.Flask(__name__)
app.register_blueprint(bp, url_prefix='/py')
self.assert_in('boolean', app.jinja_env.tests.keys())
self.assert_equal(app.jinja_env.tests['boolean'], is_boolean)
self.assert_true(app.jinja_env.tests['boolean'](False))
assert 'boolean' in app.jinja_env.tests.keys()
assert app.jinja_env.tests['boolean'] == is_boolean
assert app.jinja_env.tests['boolean'](False)
def test_template_test_with_template(self):
bp = flask.Blueprint('bp', __name__)
@ -525,7 +525,7 @@ class TestBlueprint(TestFlask):
def index():
return flask.render_template('template_test.html', value=False)
rv = app.test_client().get('/')
self.assert_in(b'Success!', rv.data)
assert b'Success!' in rv.data
def test_template_test_after_route_with_template(self):
app = flask.Flask(__name__)
@ -538,7 +538,7 @@ class TestBlueprint(TestFlask):
return isinstance(value, bool)
app.register_blueprint(bp, url_prefix='/py')
rv = app.test_client().get('/')
self.assert_in(b'Success!', rv.data)
assert b'Success!' in rv.data
def test_add_template_test_with_template(self):
bp = flask.Blueprint('bp', __name__)
@ -551,7 +551,7 @@ class TestBlueprint(TestFlask):
def index():
return flask.render_template('template_test.html', value=False)
rv = app.test_client().get('/')
self.assert_in(b'Success!', rv.data)
assert b'Success!' in rv.data
def test_template_test_with_name_and_template(self):
bp = flask.Blueprint('bp', __name__)
@ -564,7 +564,7 @@ class TestBlueprint(TestFlask):
def index():
return flask.render_template('template_test.html', value=False)
rv = app.test_client().get('/')
self.assert_in(b'Success!', rv.data)
assert b'Success!' in rv.data
def test_add_template_test_with_name_and_template(self):
bp = flask.Blueprint('bp', __name__)
@ -577,7 +577,7 @@ class TestBlueprint(TestFlask):
def index():
return flask.render_template('template_test.html', value=False)
rv = app.test_client().get('/')
self.assert_in(b'Success!', rv.data)
assert b'Success!' in rv.data
def suite():
suite = unittest.TestSuite()

66
tests/test_config.py
View file

@ -30,9 +30,9 @@ SECRET_KEY = 'devkey'
class TestConfig(TestFlask):
def common_object_test(self, app):
self.assert_equal(app.secret_key, 'devkey')
self.assert_equal(app.config['TEST_KEY'], 'foo')
self.assert_not_in('TestConfig', app.config)
assert app.secret_key == 'devkey'
assert app.config['TEST_KEY'] == 'foo'
assert 'TestConfig' not in app.config
def test_config_from_file(self):
app = flask.Flask(__name__)
@ -73,7 +73,7 @@ class TestConfig(TestFlask):
self.common_object_test(app)
app = flask.Flask(__name__)
with self.assert_raises(TypeError):
with pytest.raises(TypeError):
app.config.from_mapping(
{}, {}
)
@ -95,13 +95,13 @@ class TestConfig(TestFlask):
try:
app.config.from_envvar('FOO_SETTINGS')
except RuntimeError as e:
self.assert_true("'FOO_SETTINGS' is not set" in str(e))
assert "'FOO_SETTINGS' is not set" in str(e)
else:
self.assert_true(0, 'expected exception')
self.assert_false(app.config.from_envvar('FOO_SETTINGS', silent=True))
assert 0, 'expected exception'
assert not app.config.from_envvar('FOO_SETTINGS', silent=True)
os.environ = {'FOO_SETTINGS': __file__.rsplit('.', 1)[0] + '.py'}
self.assert_true(app.config.from_envvar('FOO_SETTINGS'))
assert app.config.from_envvar('FOO_SETTINGS')
self.common_object_test(app)
finally:
os.environ = env
@ -115,12 +115,12 @@ class TestConfig(TestFlask):
app.config.from_envvar('FOO_SETTINGS')
except IOError as e:
msg = str(e)
self.assert_true(msg.startswith('[Errno 2] Unable to load configuration '
'file (No such file or directory):'))
self.assert_true(msg.endswith("missing.cfg'"))
assert msg.startswith('[Errno 2] Unable to load configuration '
'file (No such file or directory):')
assert msg.endswith("missing.cfg'")
else:
self.fail('expected IOError')
self.assert_false(app.config.from_envvar('FOO_SETTINGS', silent=True))
assert False, 'expected IOError'
assert not app.config.from_envvar('FOO_SETTINGS', silent=True)
finally:
os.environ = env
@ -130,12 +130,12 @@ class TestConfig(TestFlask):
app.config.from_pyfile('missing.cfg')
except IOError as e:
msg = str(e)
self.assert_true(msg.startswith('[Errno 2] Unable to load configuration '
'file (No such file or directory):'))
self.assert_true(msg.endswith("missing.cfg'"))
assert msg.startswith('[Errno 2] Unable to load configuration '
'file (No such file or directory):')
assert msg.endswith("missing.cfg'")
else:
self.assert_true(0, 'expected config')
self.assert_false(app.config.from_pyfile('missing.cfg', silent=True))
assert 0, 'expected config'
assert not app.config.from_pyfile('missing.cfg', silent=True)
def test_config_missing_json(self):
app = flask.Flask(__name__)
@ -143,12 +143,12 @@ class TestConfig(TestFlask):
app.config.from_json('missing.json')
except IOError as e:
msg = str(e)
self.assert_true(msg.startswith('[Errno 2] Unable to load configuration '
'file (No such file or directory):'))
self.assert_true(msg.endswith("missing.json'"))
assert msg.startswith('[Errno 2] Unable to load configuration '
'file (No such file or directory):')
assert msg.endswith("missing.json'")
else:
self.assert_true(0, 'expected config')
self.assert_false(app.config.from_json('missing.json', silent=True))
assert 0, 'expected config'
assert not app.config.from_json('missing.json', silent=True)
def test_custom_config_class(self):
class Config(flask.Config):
@ -156,14 +156,14 @@ class TestConfig(TestFlask):
class Flask(flask.Flask):
config_class = Config
app = Flask(__name__)
self.assert_isinstance(app.config, Config)
assert isinstance(app.config, Config)
app.config.from_object(__name__)
self.common_object_test(app)
def test_session_lifetime(self):
app = flask.Flask(__name__)
app.config['PERMANENT_SESSION_LIFETIME'] = 42
self.assert_equal(app.permanent_session_lifetime.seconds, 42)
assert app.permanent_session_lifetime.seconds == 42
def test_get_namespace(self):
app = flask.Flask(__name__)
@ -172,13 +172,13 @@ class TestConfig(TestFlask):
app.config['BAR_STUFF_1'] = 'bar stuff 1'
app.config['BAR_STUFF_2'] = 'bar stuff 2'
foo_options = app.config.get_namespace('FOO_')
self.assert_equal(2, len(foo_options))
self.assert_equal('foo option 1', foo_options['option_1'])
self.assert_equal('foo option 2', foo_options['option_2'])
assert 2 == len(foo_options)
assert 'foo option 1' == foo_options['option_1']
assert 'foo option 2' == foo_options['option_2']
bar_options = app.config.get_namespace('BAR_', lowercase=False)
self.assert_equal(2, len(bar_options))
self.assert_equal('bar stuff 1', bar_options['STUFF_1'])
self.assert_equal('bar stuff 2', bar_options['STUFF_2'])
assert 2 == len(bar_options)
assert 'bar stuff 1' == bar_options['STUFF_1']
assert 'bar stuff 2' == bar_options['STUFF_2']
class TestInstance(TestFlask):
@ -188,7 +188,7 @@ class TestInstance(TestFlask):
assert 'must be absolute' in str(excinfo.value)
app = flask.Flask(__name__, instance_path=str(apps_tmpdir))
self.assert_equal(app.instance_path, str(apps_tmpdir))
assert app.instance_path == str(apps_tmpdir)
def test_main_module_paths(self, apps_tmpdir, purge_module):
app = apps_tmpdir.join('main_app.py')
@ -285,7 +285,7 @@ class TestInstance(TestFlask):
return self
sys.meta_path.append(Loader())
try:
with self.assert_raises(AttributeError):
with pytest.raises(AttributeError):
flask.Flask(__name__)
finally:
sys.meta_path.pop()

53
tests/test_ext.py
View file

@ -11,6 +11,8 @@
import sys
import unittest
import pytest
try:
from imp import reload as reload_module
except ImportError:
@ -41,70 +43,70 @@ class TestExtImportHook(TestFlask):
if cls.__module__ == 'flask.exthook' and \
cls.__name__ == 'ExtensionImporter':
import_hooks += 1
self.assert_equal(import_hooks, 1)
assert import_hooks == 1
def teardown(self):
from flask import ext
for key in ext.__dict__:
self.assert_not_in('.', key)
assert '.' not in key
def test_flaskext_new_simple_import_normal(self):
from flask.ext.newext_simple import ext_id
self.assert_equal(ext_id, 'newext_simple')
assert ext_id == 'newext_simple'
def test_flaskext_new_simple_import_module(self):
from flask.ext import newext_simple
self.assert_equal(newext_simple.ext_id, 'newext_simple')
self.assert_equal(newext_simple.__name__, 'flask_newext_simple')
assert newext_simple.ext_id == 'newext_simple'
assert newext_simple.__name__ == 'flask_newext_simple'
def test_flaskext_new_package_import_normal(self):
from flask.ext.newext_package import ext_id
self.assert_equal(ext_id, 'newext_package')
assert ext_id == 'newext_package'
def test_flaskext_new_package_import_module(self):
from flask.ext import newext_package
self.assert_equal(newext_package.ext_id, 'newext_package')
self.assert_equal(newext_package.__name__, 'flask_newext_package')
assert newext_package.ext_id == 'newext_package'
assert newext_package.__name__ == 'flask_newext_package'
def test_flaskext_new_package_import_submodule_function(self):
from flask.ext.newext_package.submodule import test_function
self.assert_equal(test_function(), 42)
assert test_function() == 42
def test_flaskext_new_package_import_submodule(self):
from flask.ext.newext_package import submodule
self.assert_equal(submodule.__name__, 'flask_newext_package.submodule')
self.assert_equal(submodule.test_function(), 42)
assert submodule.__name__ == 'flask_newext_package.submodule'
assert submodule.test_function() == 42
def test_flaskext_old_simple_import_normal(self):
from flask.ext.oldext_simple import ext_id
self.assert_equal(ext_id, 'oldext_simple')
assert ext_id == 'oldext_simple'
def test_flaskext_old_simple_import_module(self):
from flask.ext import oldext_simple
self.assert_equal(oldext_simple.ext_id, 'oldext_simple')
self.assert_equal(oldext_simple.__name__, 'flaskext.oldext_simple')
assert oldext_simple.ext_id == 'oldext_simple'
assert oldext_simple.__name__ == 'flaskext.oldext_simple'
def test_flaskext_old_package_import_normal(self):
from flask.ext.oldext_package import ext_id
self.assert_equal(ext_id, 'oldext_package')
assert ext_id == 'oldext_package'
def test_flaskext_old_package_import_module(self):
from flask.ext import oldext_package
self.assert_equal(oldext_package.ext_id, 'oldext_package')
self.assert_equal(oldext_package.__name__, 'flaskext.oldext_package')
assert oldext_package.ext_id == 'oldext_package'
assert oldext_package.__name__ == 'flaskext.oldext_package'
def test_flaskext_old_package_import_submodule(self):
from flask.ext.oldext_package import submodule
self.assert_equal(submodule.__name__, 'flaskext.oldext_package.submodule')
self.assert_equal(submodule.test_function(), 42)
assert submodule.__name__ == 'flaskext.oldext_package.submodule'
assert submodule.test_function() == 42
def test_flaskext_old_package_import_submodule_function(self):
from flask.ext.oldext_package.submodule import test_function
self.assert_equal(test_function(), 42)
assert test_function() == 42
def test_flaskext_broken_package_no_module_caching(self):
for x in range(2):
with self.assert_raises(ImportError):
with pytest.raises(ImportError):
import flask.ext.broken
def test_no_error_swallowing(self):
@ -112,13 +114,13 @@ class TestExtImportHook(TestFlask):
import flask.ext.broken
except ImportError:
exc_type, exc_value, tb = sys.exc_info()
self.assert_true(exc_type is ImportError)
assert exc_type is ImportError
if PY2:
message = 'No module named missing_module'
else:
message = 'No module named \'missing_module\''
self.assert_equal(str(exc_value), message)
self.assert_true(tb.tb_frame.f_globals is globals())
assert str(exc_value) == message
assert tb.tb_frame.f_globals is globals()
# reraise() adds a second frame so we need to skip that one too.
# On PY3 we even have another one :(
@ -127,7 +129,8 @@ class TestExtImportHook(TestFlask):
next = next.tb_next
import os.path
self.assert_in(os.path.join('flask_broken', '__init__.py'), next.tb_frame.f_code.co_filename)
assert os.path.join('flask_broken', '__init__.py') in \
next.tb_frame.f_code.co_filename
def suite():

194
tests/test_helpers.py
View file

@ -9,6 +9,8 @@
:license: BSD, see LICENSE for more details.
"""
import pytest
import os
import flask
import unittest
@ -36,7 +38,7 @@ class TestJSON(TestFlask):
return flask.jsonify(foo=text_type(flask.request.get_json()))
c = app.test_client()
rv = c.post('/json', data='malformed', content_type='application/json')
self.assert_equal(rv.status_code, 400)
assert rv.status_code == 400
def test_json_custom_mimetypes(self):
app = flask.Flask(__name__)
@ -45,7 +47,7 @@ class TestJSON(TestFlask):
return flask.request.get_json()
c = app.test_client()
rv = c.post('/json', data='"foo"', content_type='application/x+json')
self.assert_equal(rv.data, b'foo')
assert rv.data == b'foo'
def test_json_body_encoding(self):
app = flask.Flask(__name__)
@ -57,7 +59,7 @@ class TestJSON(TestFlask):
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')
self.assert_equal(resp.data, u'Hällo Wörld'.encode('utf-8'))
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])
@ -71,8 +73,8 @@ class TestJSON(TestFlask):
c = app.test_client()
for url in '/kw', '/dict':
rv = c.get(url)
self.assert_equal(rv.mimetype, 'application/json')
self.assert_equal(flask.json.loads(rv.data), d)
assert rv.mimetype == 'application/json'
assert flask.json.loads(rv.data) == d
def test_json_as_unicode(self):
app = flask.Flask(__name__)
@ -80,12 +82,12 @@ class TestJSON(TestFlask):
app.config['JSON_AS_ASCII'] = True
with app.app_context():
rv = flask.json.dumps(u'\N{SNOWMAN}')
self.assert_equal(rv, '"\\u2603"')
assert rv == '"\\u2603"'
app.config['JSON_AS_ASCII'] = False
with app.app_context():
rv = flask.json.dumps(u'\N{SNOWMAN}')
self.assert_equal(rv, u'"\u2603"')
assert rv == u'"\u2603"'
def test_json_attr(self):
app = flask.Flask(__name__)
@ -96,29 +98,28 @@ class TestJSON(TestFlask):
c = app.test_client()
rv = c.post('/add', data=flask.json.dumps({'a': 1, 'b': 2}),
content_type='application/json')
self.assert_equal(rv.data, b'3')
assert rv.data == b'3'
def test_template_escaping(self):
app = flask.Flask(__name__)
render = flask.render_template_string
with app.test_request_context():
rv = flask.json.htmlsafe_dumps('</script>')
self.assert_equal(rv, u'"\\u003c/script\\u003e"')
self.assert_equal(type(rv), text_type)
assert rv == u'"\\u003c/script\\u003e"'
assert type(rv) == text_type
rv = render('{{ "</script>"|tojson }}')
self.assert_equal(rv, '"\\u003c/script\\u003e"')
assert rv == '"\\u003c/script\\u003e"'
rv = render('{{ "<\0/script>"|tojson }}')
self.assert_equal(rv, '"\\u003c\\u0000/script\\u003e"')
assert rv == '"\\u003c\\u0000/script\\u003e"'
rv = render('{{ "<!--<script>"|tojson }}')
self.assert_equal(rv, '"\\u003c!--\\u003cscript\\u003e"')
assert rv == '"\\u003c!--\\u003cscript\\u003e"'
rv = render('{{ "&"|tojson }}')
self.assert_equal(rv, '"\\u0026"')
assert rv == '"\\u0026"'
rv = render('{{ "\'"|tojson }}')
self.assert_equal(rv, '"\\u0027"')
assert rv == '"\\u0027"'
rv = render("<a ng-data='{{ data|tojson }}'></a>",
data={'x': ["foo", "bar", "baz'"]})
self.assert_equal(rv,
'<a ng-data=\'{"x": ["foo", "bar", "baz\\u0027"]}\'></a>')
assert rv == '<a ng-data=\'{"x": ["foo", "bar", "baz\\u0027"]}\'></a>'
def test_json_customization(self):
class X(object):
@ -148,7 +149,7 @@ class TestJSON(TestFlask):
rv = c.post('/', data=flask.json.dumps({
'x': {'_foo': 42}
}), content_type='application/json')
self.assert_equal(rv.data, b'"<42>"')
assert rv.data == b'"<42>"'
def test_modified_url_encoding(self):
class ModifiedRequest(flask.Request):
@ -163,8 +164,8 @@ class TestJSON(TestFlask):
return flask.request.args['foo']
rv = app.test_client().get(u'/?foo=정상처리'.encode('euc-kr'))
self.assert_equal(rv.status_code, 200)
self.assert_equal(rv.data, u'정상처리'.encode('utf-8'))
assert rv.status_code == 200
assert rv.data == u'정상처리'.encode('utf-8')
if not has_encoding('euc-kr'):
test_modified_url_encoding = None
@ -172,7 +173,7 @@ class TestJSON(TestFlask):
def test_json_key_sorting(self):
app = flask.Flask(__name__)
app.testing = True
self.assert_equal(app.config['JSON_SORT_KEYS'], True)
assert app.config['JSON_SORT_KEYS'] == True
d = dict.fromkeys(range(20), 'foo')
@app.route('/')
@ -236,9 +237,9 @@ class TestJSON(TestFlask):
]
try:
self.assert_equal(lines, sorted_by_int)
assert lines == sorted_by_int
except AssertionError:
self.assert_equal(lines, sorted_by_str)
assert lines == sorted_by_str
class TestSendfile(TestFlask):
@ -246,11 +247,11 @@ class TestSendfile(TestFlask):
app = flask.Flask(__name__)
with app.test_request_context():
rv = flask.send_file('static/index.html')
self.assert_true(rv.direct_passthrough)
self.assert_equal(rv.mimetype, 'text/html')
assert rv.direct_passthrough
assert rv.mimetype == 'text/html'
with app.open_resource('static/index.html') as f:
rv.direct_passthrough = False
self.assert_equal(rv.data, f.read())
assert rv.data == f.read()
rv.close()
def test_send_file_xsendfile(self):
@ -258,11 +259,11 @@ class TestSendfile(TestFlask):
app.use_x_sendfile = True
with app.test_request_context():
rv = flask.send_file('static/index.html')
self.assert_true(rv.direct_passthrough)
self.assert_in('x-sendfile', rv.headers)
self.assert_equal(rv.headers['x-sendfile'],
os.path.join(app.root_path, 'static/index.html'))
self.assert_equal(rv.mimetype, 'text/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'
rv.close()
def test_send_file_object(self):
@ -273,24 +274,24 @@ class TestSendfile(TestFlask):
rv = flask.send_file(f)
rv.direct_passthrough = False
with app.open_resource('static/index.html') as f:
self.assert_equal(rv.data, f.read())
self.assert_equal(rv.mimetype, 'text/html')
assert rv.data == f.read()
assert rv.mimetype == 'text/html'
rv.close()
# mimetypes + etag
self.assert_equal(len(captured), 2)
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)
self.assert_equal(rv.mimetype, 'text/html')
self.assert_in('x-sendfile', rv.headers)
self.assert_equal(rv.headers['x-sendfile'],
os.path.join(app.root_path, 'static/index.html'))
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')
rv.close()
# mimetypes + etag
self.assert_equal(len(captured), 2)
assert len(captured) == 2
app.use_x_sendfile = False
with app.test_request_context():
@ -298,11 +299,11 @@ class TestSendfile(TestFlask):
f = StringIO('Test')
rv = flask.send_file(f)
rv.direct_passthrough = False
self.assert_equal(rv.data, b'Test')
self.assert_equal(rv.mimetype, 'application/octet-stream')
assert rv.data == b'Test'
assert rv.mimetype == 'application/octet-stream'
rv.close()
# etags
self.assert_equal(len(captured), 1)
assert len(captured) == 1
with catch_warnings() as captured:
class PyStringIO(object):
def __init__(self, *args, **kwargs):
@ -313,30 +314,30 @@ class TestSendfile(TestFlask):
f.name = 'test.txt'
rv = flask.send_file(f)
rv.direct_passthrough = False
self.assert_equal(rv.data, b'Test')
self.assert_equal(rv.mimetype, 'text/plain')
assert rv.data == b'Test'
assert rv.mimetype == 'text/plain'
rv.close()
# attachment_filename and etags
self.assert_equal(len(captured), 3)
assert len(captured) == 3
with catch_warnings() as captured:
f = StringIO('Test')
rv = flask.send_file(f, mimetype='text/plain')
rv.direct_passthrough = False
self.assert_equal(rv.data, b'Test')
self.assert_equal(rv.mimetype, 'text/plain')
assert rv.data == b'Test'
assert rv.mimetype == 'text/plain'
rv.close()
# etags
self.assert_equal(len(captured), 1)
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)
self.assert_not_in('x-sendfile', rv.headers)
assert 'x-sendfile' not in rv.headers
rv.close()
# etags
self.assert_equal(len(captured), 1)
assert len(captured) == 1
def test_attachment(self):
app = flask.Flask(__name__)
@ -345,27 +346,27 @@ class TestSendfile(TestFlask):
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'])
self.assert_equal(value, 'attachment')
assert value == 'attachment'
rv.close()
# mimetypes + etag
self.assert_equal(len(captured), 2)
assert len(captured) == 2
with app.test_request_context():
self.assert_equal(options['filename'], 'index.html')
assert options['filename'] == 'index.html'
rv = flask.send_file('static/index.html', as_attachment=True)
value, options = parse_options_header(rv.headers['Content-Disposition'])
self.assert_equal(value, 'attachment')
self.assert_equal(options['filename'], 'index.html')
assert value == 'attachment'
assert options['filename'] == 'index.html'
rv.close()
with app.test_request_context():
rv = flask.send_file(StringIO('Test'), as_attachment=True,
attachment_filename='index.txt',
add_etags=False)
self.assert_equal(rv.mimetype, 'text/plain')
assert rv.mimetype == 'text/plain'
value, options = parse_options_header(rv.headers['Content-Disposition'])
self.assert_equal(value, 'attachment')
self.assert_equal(options['filename'], 'index.txt')
assert value == 'attachment'
assert options['filename'] == 'index.txt'
rv.close()
def test_static_file(self):
@ -375,24 +376,24 @@ class TestSendfile(TestFlask):
# Test with static file handler.
rv = app.send_static_file('index.html')
cc = parse_cache_control_header(rv.headers['Cache-Control'])
self.assert_equal(cc.max_age, 12 * 60 * 60)
assert cc.max_age == 12 * 60 * 60
rv.close()
# Test again with direct use of send_file utility.
rv = flask.send_file('static/index.html')
cc = parse_cache_control_header(rv.headers['Cache-Control'])
self.assert_equal(cc.max_age, 12 * 60 * 60)
assert cc.max_age == 12 * 60 * 60
rv.close()
app.config['SEND_FILE_MAX_AGE_DEFAULT'] = 3600
with app.test_request_context():
# Test with static file handler.
rv = app.send_static_file('index.html')
cc = parse_cache_control_header(rv.headers['Cache-Control'])
self.assert_equal(cc.max_age, 3600)
assert cc.max_age == 3600
rv.close()
# Test again with direct use of send_file utility.
rv = flask.send_file('static/index.html')
cc = parse_cache_control_header(rv.headers['Cache-Control'])
self.assert_equal(cc.max_age, 3600)
assert cc.max_age == 3600
rv.close()
class StaticFileApp(flask.Flask):
def get_send_file_max_age(self, filename):
@ -402,12 +403,12 @@ class TestSendfile(TestFlask):
# Test with static file handler.
rv = app.send_static_file('index.html')
cc = parse_cache_control_header(rv.headers['Cache-Control'])
self.assert_equal(cc.max_age, 10)
assert cc.max_age == 10
rv.close()
# Test again with direct use of send_file utility.
rv = flask.send_file('static/index.html')
cc = parse_cache_control_header(rv.headers['Cache-Control'])
self.assert_equal(cc.max_age, 10)
assert cc.max_age == 10
rv.close()
def test_send_from_directory(self):
@ -418,7 +419,7 @@ class TestSendfile(TestFlask):
with app.test_request_context():
rv = flask.send_from_directory('static', 'hello.txt')
rv.direct_passthrough = False
self.assert_equal(rv.data.strip(), b'Hello Subdomain')
assert rv.data.strip() == b'Hello Subdomain'
rv.close()
@ -427,10 +428,10 @@ class TestLogging(TestFlask):
def test_logger_cache(self):
app = flask.Flask(__name__)
logger1 = app.logger
self.assert_true(app.logger is logger1)
self.assert_equal(logger1.name, __name__)
assert app.logger is logger1
assert logger1.name == __name__
app.logger_name = __name__ + '/test_logger_cache'
self.assert_true(app.logger is not logger1)
assert app.logger is not logger1
def test_debug_log(self):
app = flask.Flask(__name__)
@ -450,10 +451,10 @@ class TestLogging(TestFlask):
with catch_stderr() as err:
c.get('/')
out = err.getvalue()
self.assert_in('WARNING in test_helpers [', out)
self.assert_in(os.path.basename(__file__.rsplit('.', 1)[0] + '.py'), out)
self.assert_in('the standard library is dead', out)
self.assert_in('this is a debug statement', out)
assert 'WARNING in test_helpers [' in out
assert os.path.basename(__file__.rsplit('.', 1)[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:
@ -461,14 +462,14 @@ class TestLogging(TestFlask):
except ZeroDivisionError:
pass
else:
self.assert_true(False, 'debug log ate the exception')
assert False, 'debug log ate the exception'
def test_debug_log_override(self):
app = flask.Flask(__name__)
app.debug = True
app.logger_name = 'flask_tests/test_debug_log_override'
app.logger.level = 10
self.assert_equal(app.logger.level, 10)
assert app.logger.level == 10
def test_exception_logging(self):
out = StringIO()
@ -482,14 +483,14 @@ class TestLogging(TestFlask):
1 // 0
rv = app.test_client().get('/')
self.assert_equal(rv.status_code, 500)
self.assert_in(b'Internal Server Error', rv.data)
assert rv.status_code == 500
assert b'Internal Server Error' in rv.data
err = out.getvalue()
self.assert_in('Exception on / [GET]', err)
self.assert_in('Traceback (most recent call last):', err)
self.assert_in('1 // 0', err)
self.assert_in('ZeroDivisionError:', err)
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__)
@ -511,8 +512,8 @@ class TestLogging(TestFlask):
return 'Hello Server Error', 500
for trigger in 'before', 'after':
rv = app.test_client().get('/')
self.assert_equal(rv.status_code, 500)
self.assert_equal(rv.data, b'Hello Server Error')
assert rv.status_code == 500
assert rv.data == b'Hello Server Error'
def test_url_for_with_anchor(self):
app = flask.Flask(__name__)
@ -520,8 +521,7 @@ class TestLogging(TestFlask):
def index():
return '42'
with app.test_request_context():
self.assert_equal(flask.url_for('index', _anchor='x y'),
'/#x%20y')
assert flask.url_for('index', _anchor='x y') == '/#x%20y'
def test_url_for_with_scheme(self):
app = flask.Flask(__name__)
@ -529,10 +529,7 @@ class TestLogging(TestFlask):
def index():
return '42'
with app.test_request_context():
self.assert_equal(flask.url_for('index',
_external=True,
_scheme='https'),
'https://localhost/')
assert flask.url_for('index', _external=True, _scheme='https') == 'https://localhost/'
def test_url_for_with_scheme_not_external(self):
app = flask.Flask(__name__)
@ -540,7 +537,7 @@ class TestLogging(TestFlask):
def index():
return '42'
with app.test_request_context():
self.assert_raises(ValueError,
pytest.raises(ValueError,
flask.url_for,
'index',
_scheme='https')
@ -564,12 +561,9 @@ class TestLogging(TestFlask):
view_func=myview)
with app.test_request_context():
self.assert_equal(flask.url_for('myview', _method='GET'),
'/myview/')
self.assert_equal(flask.url_for('myview', id=42, _method='GET'),
'/myview/42')
self.assert_equal(flask.url_for('myview', _method='POST'),
'/myview/create')
assert flask.url_for('myview', _method='GET') == '/myview/'
assert flask.url_for('myview', id=42, _method='GET') == '/myview/42'
assert flask.url_for('myview', _method='POST') == '/myview/create'
class TestNoImports(TestFlask):
@ -587,7 +581,7 @@ class TestNoImports(TestFlask):
try:
flask.Flask('importerror')
except NotImplementedError:
self.fail('Flask(import_name) is importing import_name.')
assert False, 'Flask(import_name) is importing import_name.'
class TestStreaming(TestFlask):
@ -604,7 +598,7 @@ class TestStreaming(TestFlask):
return flask.Response(flask.stream_with_context(generate()))
c = app.test_client()
rv = c.get('/?name=World')
self.assert_equal(rv.data, b'Hello World!')
assert rv.data == b'Hello World!'
def test_streaming_with_context_as_decorator(self):
app = flask.Flask(__name__)
@ -619,7 +613,7 @@ class TestStreaming(TestFlask):
return flask.Response(generate())
c = app.test_client()
rv = c.get('/?name=World')
self.assert_equal(rv.data, b'Hello World!')
assert rv.data == b'Hello World!'
def test_streaming_with_context_and_custom_close(self):
app = flask.Flask(__name__)
@ -645,8 +639,8 @@ class TestStreaming(TestFlask):
Wrapper(generate())))
c = app.test_client()
rv = c.get('/?name=World')
self.assert_equal(rv.data, b'Hello World!')
self.assert_equal(called, [42])
assert rv.data == b'Hello World!'
assert called == [42]
def suite():

10
tests/test_regression.py
View file

@ -69,8 +69,8 @@ class TestMemory(TestFlask):
def fire():
with app.test_client() as c:
rv = c.get('/')
self.assert_equal(rv.status_code, 200)
self.assert_equal(rv.data, b'<h1>42</h1>')
assert rv.status_code == 200
assert rv.data == b'<h1>42</h1>'
# Trigger caches
fire()
@ -84,7 +84,7 @@ class TestMemory(TestFlask):
def test_safe_join_toplevel_pardir(self):
from flask.helpers import safe_join
with self.assert_raises(NotFound):
with pytest.raises(NotFound):
safe_join('/foo', '..')
@ -110,6 +110,6 @@ class TestException(TestFlask):
with app.test_client() as c:
rv = c.get('/')
self.assert_equal(rv.headers['Location'], 'http://localhost/test')
assert rv.headers['Location'] == 'http://localhost/test'
rv = c.get('/test')
self.assert_equal(rv.data, b'42')
assert rv.data == b'42'

95
tests/test_reqctx.py
View file

@ -9,6 +9,8 @@
:license: BSD, see LICENSE for more details.
"""
import pytest
import flask
import unittest
try:
@ -29,9 +31,9 @@ class TestRequestContext(TestFlask):
ctx = app.test_request_context()
ctx.push()
self.assert_equal(buffer, [])
assert buffer == []
ctx.pop()
self.assert_equal(buffer, [None])
assert buffer == [None]
def test_teardown_with_previous_exception(self):
buffer = []
@ -46,8 +48,8 @@ class TestRequestContext(TestFlask):
pass
with app.test_request_context():
self.assert_equal(buffer, [])
self.assert_equal(buffer, [None])
assert buffer == []
assert buffer == [None]
def test_proper_test_request_context(self):
app = flask.Flask(__name__)
@ -64,37 +66,30 @@ class TestRequestContext(TestFlask):
return None
with app.test_request_context('/'):
self.assert_equal(flask.url_for('index', _external=True), 'http://localhost.localdomain:5000/')
assert flask.url_for('index', _external=True) == \
'http://localhost.localdomain:5000/'
with app.test_request_context('/'):
self.assert_equal(flask.url_for('sub', _external=True), 'http://foo.localhost.localdomain:5000/')
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 as e:
self.assert_true(isinstance(e, ValueError))
self.assert_equal(str(e), "the server name provided " +
"('localhost.localdomain:5000') does not match the " + \
"server name from the WSGI environment ('localhost')")
try:
app.config.update(SERVER_NAME='localhost')
with app.test_request_context('/', environ_overrides={'SERVER_NAME': 'localhost'}):
pass
except ValueError as e:
raise ValueError(
"No ValueError exception should have been raised \"%s\"" % e
assert str(e) == (
"the server name provided "
"('localhost.localdomain:5000') does not match the "
"server name from the WSGI environment ('localhost')"
)
try:
app.config.update(SERVER_NAME='localhost:80')
with app.test_request_context('/', environ_overrides={'SERVER_NAME': 'localhost:80'}):
pass
except ValueError as e:
raise ValueError(
"No ValueError exception should have been raised \"%s\"" % e
)
app.config.update(SERVER_NAME='localhost')
with app.test_request_context('/', environ_overrides={'SERVER_NAME': 'localhost'}):
pass
app.config.update(SERVER_NAME='localhost:80')
with app.test_request_context('/', environ_overrides={'SERVER_NAME': 'localhost:80'}):
pass
def test_context_binding(self):
app = flask.Flask(__name__)
@ -106,20 +101,20 @@ class TestRequestContext(TestFlask):
return flask.request.url
with app.test_request_context('/?name=World'):
self.assert_equal(index(), 'Hello World!')
assert index() == 'Hello World!'
with app.test_request_context('/meh'):
self.assert_equal(meh(), 'http://localhost/meh')
self.assert_true(flask._request_ctx_stack.top is None)
assert meh() == 'http://localhost/meh'
assert flask._request_ctx_stack.top is None
def test_context_test(self):
app = flask.Flask(__name__)
self.assert_false(flask.request)
self.assert_false(flask.has_request_context())
assert not flask.request
assert not flask.has_request_context()
ctx = app.test_request_context()
ctx.push()
try:
self.assert_true(flask.request)
self.assert_true(flask.has_request_context())
assert flask.request
assert flask.has_request_context()
finally:
ctx.pop()
@ -131,14 +126,14 @@ class TestRequestContext(TestFlask):
ctx = app.test_request_context('/?name=World')
ctx.push()
self.assert_equal(index(), 'Hello World!')
assert index() == 'Hello World!'
ctx.pop()
try:
index()
except RuntimeError:
pass
else:
self.assert_true(0, 'expected runtime error')
assert 0, 'expected runtime error'
def test_greenlet_context_copying(self):
app = flask.Flask(__name__)
@ -148,23 +143,23 @@ class TestRequestContext(TestFlask):
def index():
reqctx = flask._request_ctx_stack.top.copy()
def g():
self.assert_false(flask.request)
self.assert_false(flask.current_app)
assert not flask.request
assert not flask.current_app
with reqctx:
self.assert_true(flask.request)
self.assert_equal(flask.current_app, app)
self.assert_equal(flask.request.path, '/')
self.assert_equal(flask.request.args['foo'], 'bar')
self.assert_false(flask.request)
assert flask.request
assert flask.current_app == app
assert flask.request.path == '/'
assert flask.request.args['foo'] == 'bar'
assert not flask.request
return 42
greenlets.append(greenlet(g))
return 'Hello World!'
rv = app.test_client().get('/?foo=bar')
self.assert_equal(rv.data, b'Hello World!')
assert rv.data == b'Hello World!'
result = greenlets[0].run()
self.assert_equal(result, 42)
assert result == 42
def test_greenlet_context_copying_api(self):
app = flask.Flask(__name__)
@ -175,19 +170,19 @@ class TestRequestContext(TestFlask):
reqctx = flask._request_ctx_stack.top.copy()
@flask.copy_current_request_context
def g():
self.assert_true(flask.request)
self.assert_equal(flask.current_app, app)
self.assert_equal(flask.request.path, '/')
self.assert_equal(flask.request.args['foo'], 'bar')
assert flask.request
assert flask.current_app == app
assert flask.request.path == '/'
assert flask.request.args['foo'] == 'bar'
return 42
greenlets.append(greenlet(g))
return 'Hello World!'
rv = app.test_client().get('/?foo=bar')
self.assert_equal(rv.data, b'Hello World!')
assert rv.data == b'Hello World!'
result = greenlets[0].run()
self.assert_equal(result, 42)
assert result == 42
# Disable test if we don't have greenlets available
if greenlet is None:

33
tests/test_signals.py
View file

@ -42,10 +42,10 @@ class TestSignals(TestFlask):
flask.template_rendered.connect(record, app)
try:
app.test_client().get('/')
self.assert_equal(len(recorded), 1)
assert len(recorded) == 1
template, context = recorded[0]
self.assert_equal(template.name, 'simple_template.html')
self.assert_equal(context['whiskey'], 42)
assert template.name == 'simple_template.html'
assert context['whiskey'] == 42
finally:
flask.template_rendered.disconnect(record, app)
@ -57,7 +57,7 @@ class TestSignals(TestFlask):
calls.append('before-signal')
def after_request_signal(sender, response):
self.assert_equal(response.data, b'stuff')
assert response.data == b'stuff'
calls.append('after-signal')
@app.before_request
@ -80,11 +80,10 @@ class TestSignals(TestFlask):
try:
rv = app.test_client().get('/')
self.assert_equal(rv.data, b'stuff')
assert rv.data == b'stuff'
self.assert_equal(calls, ['before-signal', 'before-handler',
'handler', 'after-handler',
'after-signal'])
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)
@ -102,9 +101,9 @@ class TestSignals(TestFlask):
flask.got_request_exception.connect(record, app)
try:
self.assert_equal(app.test_client().get('/').status_code, 500)
self.assert_equal(len(recorded), 1)
self.assert_true(isinstance(recorded[0], ZeroDivisionError))
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)
@ -127,9 +126,9 @@ class TestSignals(TestFlask):
try:
with app.test_client() as c:
rv = c.get('/')
self.assert_equal(rv.data, b'Hello')
self.assert_equal(recorded, ['push'])
self.assert_equal(recorded, ['push', 'pop'])
assert rv.data == b'Hello'
assert recorded == ['push']
assert recorded == ['push', 'pop']
finally:
flask.appcontext_pushed.disconnect(record_push, app)
flask.appcontext_popped.disconnect(record_pop, app)
@ -153,9 +152,9 @@ class TestSignals(TestFlask):
client = app.test_client()
with client.session_transaction():
client.get('/')
self.assert_equal(len(recorded), 1)
assert len(recorded) == 1
message, category = recorded[0]
self.assert_equal(message, 'This is a flash message')
self.assert_equal(category, 'notice')
assert message == 'This is a flash message'
assert category == 'notice'
finally:
flask.message_flashed.disconnect(record, app)

6
tests/test_subclassing.py
View file

@ -33,11 +33,11 @@ class TestFlaskSubclassing(TestFlask):
1 // 0
rv = app.test_client().get('/')
self.assert_equal(rv.status_code, 500)
self.assert_in(b'Internal Server Error', rv.data)
assert rv.status_code == 500
assert b'Internal Server Error' in rv.data
err = out.getvalue()
self.assert_equal(err, '')
assert err == ''
def suite():

128
tests/test_templating.py
View file

@ -28,7 +28,7 @@ class TestTemplating(TestFlask):
def index():
return flask.render_template('context_template.html', value=23)
rv = app.test_client().get('/')
self.assert_equal(rv.data, b'<p>23|42')
assert rv.data == b'<p>23|42'
def test_original_win(self):
app = flask.Flask(__name__)
@ -36,7 +36,7 @@ class TestTemplating(TestFlask):
def index():
return flask.render_template_string('{{ config }}', config=42)
rv = app.test_client().get('/')
self.assert_equal(rv.data, b'42')
assert rv.data == b'42'
def test_request_less_rendering(self):
app = flask.Flask(__name__)
@ -48,7 +48,7 @@ class TestTemplating(TestFlask):
with app.app_context():
rv = flask.render_template_string('Hello {{ config.WORLD_NAME }} '
'{{ foo }}')
self.assert_equal(rv, 'Hello Special World 42')
assert rv == 'Hello Special World 42'
def test_standard_context(self):
app = flask.Flask(__name__)
@ -64,7 +64,7 @@ class TestTemplating(TestFlask):
{{ session.test }}
''')
rv = app.test_client().get('/?foo=42')
self.assert_equal(rv.data.split(), [b'42', b'23', b'False', b'aha'])
assert rv.data.split() == [b'42', b'23', b'False', b'aha']
def test_escaping(self):
text = '<p>Hello World!'
@ -74,64 +74,64 @@ class TestTemplating(TestFlask):
return flask.render_template('escaping_template.html', text=text,
html=flask.Markup(text))
lines = app.test_client().get('/').data.splitlines()
self.assert_equal(lines, [
assert lines == [
b'&lt;p&gt;Hello World!',
b'<p>Hello World!',
b'<p>Hello World!',
b'<p>Hello World!',
b'&lt;p&gt;Hello World!',
b'<p>Hello World!'
])
]
def test_no_escaping(self):
app = flask.Flask(__name__)
with app.test_request_context():
self.assert_equal(flask.render_template_string('{{ foo }}',
foo='<test>'), '<test>')
self.assert_equal(flask.render_template('mail.txt', foo='<test>'),
'<test> Mail')
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')
self.assert_equal(macro('World'), 'Hello World!')
assert macro('World') == 'Hello World!'
def test_template_filter(self):
app = flask.Flask(__name__)
@app.template_filter()
def my_reverse(s):
return s[::-1]
self.assert_in('my_reverse', app.jinja_env.filters.keys())
self.assert_equal(app.jinja_env.filters['my_reverse'], my_reverse)
self.assert_equal(app.jinja_env.filters['my_reverse']('abcd'), 'dcba')
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_add_template_filter(self):
app = flask.Flask(__name__)
def my_reverse(s):
return s[::-1]
app.add_template_filter(my_reverse)
self.assert_in('my_reverse', app.jinja_env.filters.keys())
self.assert_equal(app.jinja_env.filters['my_reverse'], my_reverse)
self.assert_equal(app.jinja_env.filters['my_reverse']('abcd'), 'dcba')
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]
self.assert_in('strrev', app.jinja_env.filters.keys())
self.assert_equal(app.jinja_env.filters['strrev'], my_reverse)
self.assert_equal(app.jinja_env.filters['strrev']('abcd'), 'dcba')
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_add_template_filter_with_name(self):
app = flask.Flask(__name__)
def my_reverse(s):
return s[::-1]
app.add_template_filter(my_reverse, 'strrev')
self.assert_in('strrev', app.jinja_env.filters.keys())
self.assert_equal(app.jinja_env.filters['strrev'], my_reverse)
self.assert_equal(app.jinja_env.filters['strrev']('abcd'), 'dcba')
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__)
@ -142,7 +142,7 @@ class TestTemplating(TestFlask):
def index():
return flask.render_template('template_filter.html', value='abcd')
rv = app.test_client().get('/')
self.assert_equal(rv.data, b'dcba')
assert rv.data == b'dcba'
def test_add_template_filter_with_template(self):
app = flask.Flask(__name__)
@ -153,7 +153,7 @@ class TestTemplating(TestFlask):
def index():
return flask.render_template('template_filter.html', value='abcd')
rv = app.test_client().get('/')
self.assert_equal(rv.data, b'dcba')
assert rv.data == b'dcba'
def test_template_filter_with_name_and_template(self):
app = flask.Flask(__name__)
@ -164,7 +164,7 @@ class TestTemplating(TestFlask):
def index():
return flask.render_template('template_filter.html', value='abcd')
rv = app.test_client().get('/')
self.assert_equal(rv.data, b'dcba')
assert rv.data == b'dcba'
def test_add_template_filter_with_name_and_template(self):
app = flask.Flask(__name__)
@ -175,43 +175,43 @@ class TestTemplating(TestFlask):
def index():
return flask.render_template('template_filter.html', value='abcd')
rv = app.test_client().get('/')
self.assert_equal(rv.data, b'dcba')
assert rv.data == b'dcba'
def test_template_test(self):
app = flask.Flask(__name__)
@app.template_test()
def boolean(value):
return isinstance(value, bool)
self.assert_in('boolean', app.jinja_env.tests.keys())
self.assert_equal(app.jinja_env.tests['boolean'], boolean)
self.assert_true(app.jinja_env.tests['boolean'](False))
assert 'boolean' in app.jinja_env.tests.keys()
assert app.jinja_env.tests['boolean'] == boolean
assert app.jinja_env.tests['boolean'](False)
def test_add_template_test(self):
app = flask.Flask(__name__)
def boolean(value):
return isinstance(value, bool)
app.add_template_test(boolean)
self.assert_in('boolean', app.jinja_env.tests.keys())
self.assert_equal(app.jinja_env.tests['boolean'], boolean)
self.assert_true(app.jinja_env.tests['boolean'](False))
assert 'boolean' in app.jinja_env.tests.keys()
assert app.jinja_env.tests['boolean'] == boolean
assert app.jinja_env.tests['boolean'](False)
def test_template_test_with_name(self):
app = flask.Flask(__name__)
@app.template_test('boolean')
def is_boolean(value):
return isinstance(value, bool)
self.assert_in('boolean', app.jinja_env.tests.keys())
self.assert_equal(app.jinja_env.tests['boolean'], is_boolean)
self.assert_true(app.jinja_env.tests['boolean'](False))
assert 'boolean' in app.jinja_env.tests.keys()
assert app.jinja_env.tests['boolean'] == is_boolean
assert app.jinja_env.tests['boolean'](False)
def test_add_template_test_with_name(self):
app = flask.Flask(__name__)
def is_boolean(value):
return isinstance(value, bool)
app.add_template_test(is_boolean, 'boolean')
self.assert_in('boolean', app.jinja_env.tests.keys())
self.assert_equal(app.jinja_env.tests['boolean'], is_boolean)
self.assert_true(app.jinja_env.tests['boolean'](False))
assert 'boolean' in app.jinja_env.tests.keys()
assert app.jinja_env.tests['boolean'] == is_boolean
assert app.jinja_env.tests['boolean'](False)
def test_template_test_with_template(self):
app = flask.Flask(__name__)
@ -222,7 +222,7 @@ class TestTemplating(TestFlask):
def index():
return flask.render_template('template_test.html', value=False)
rv = app.test_client().get('/')
self.assert_in(b'Success!', rv.data)
assert b'Success!' in rv.data
def test_add_template_test_with_template(self):
app = flask.Flask(__name__)
@ -233,7 +233,7 @@ class TestTemplating(TestFlask):
def index():
return flask.render_template('template_test.html', value=False)
rv = app.test_client().get('/')
self.assert_in(b'Success!', rv.data)
assert b'Success!' in rv.data
def test_template_test_with_name_and_template(self):
app = flask.Flask(__name__)
@ -244,7 +244,7 @@ class TestTemplating(TestFlask):
def index():
return flask.render_template('template_test.html', value=False)
rv = app.test_client().get('/')
self.assert_in(b'Success!', rv.data)
assert b'Success!' in rv.data
def test_add_template_test_with_name_and_template(self):
app = flask.Flask(__name__)
@ -255,19 +255,19 @@ class TestTemplating(TestFlask):
def index():
return flask.render_template('template_test.html', value=False)
rv = app.test_client().get('/')
self.assert_in(b'Success!', rv.data)
assert b'Success!' in rv.data
def test_add_template_global(self):
app = flask.Flask(__name__)
@app.template_global()
def get_stuff():
return 42
self.assert_in('get_stuff', app.jinja_env.globals.keys())
self.assert_equal(app.jinja_env.globals['get_stuff'], get_stuff)
self.assert_true(app.jinja_env.globals['get_stuff'](), 42)
assert 'get_stuff' in app.jinja_env.globals.keys()
assert app.jinja_env.globals['get_stuff'] == get_stuff
assert app.jinja_env.globals['get_stuff'](), 42
with app.app_context():
rv = flask.render_template_string('{{ get_stuff() }}')
self.assert_equal(rv, '42')
assert rv == '42'
def test_custom_template_loader(self):
class MyFlask(flask.Flask):
@ -280,7 +280,7 @@ class TestTemplating(TestFlask):
return flask.render_template('index.html')
c = app.test_client()
rv = c.get('/')
self.assert_equal(rv.data, b'Hello Custom World!')
assert rv.data == b'Hello Custom World!'
def test_iterable_loader(self):
app = flask.Flask(__name__)
@ -296,15 +296,15 @@ class TestTemplating(TestFlask):
value=23)
rv = app.test_client().get('/')
self.assert_equal(rv.data, b'<h1>Jameson</h1>')
assert rv.data == b'<h1>Jameson</h1>'
def test_templates_auto_reload(self):
app = flask.Flask(__name__)
self.assert_true(app.config['TEMPLATES_AUTO_RELOAD'])
self.assert_true(app.jinja_env.auto_reload)
assert app.config['TEMPLATES_AUTO_RELOAD']
assert app.jinja_env.auto_reload
app = flask.Flask(__name__)
app.config['TEMPLATES_AUTO_RELOAD'] = False
self.assert_false(app.jinja_env.auto_reload)
assert not app.jinja_env.auto_reload
def test_template_loader_debugging(self):
from blueprintapp import app
@ -314,17 +314,15 @@ class TestTemplating(TestFlask):
def handle(x, record):
called.append(True)
text = str(record.msg)
self.assert_('1: trying loader of application '
'"blueprintapp"' in text)
self.assert_('2: trying loader of blueprint "admin" '
'(blueprintapp.apps.admin)' in text)
self.assert_('trying loader of blueprint "frontend" '
'(blueprintapp.apps.frontend)' in text)
self.assert_('Error: the template could not be found' in text)
self.assert_('looked up from an endpoint that belongs to '
'the blueprint "frontend"' in text)
self.assert_(
'See http://flask.pocoo.org/docs/blueprints/#templates' in text)
assert '1: trying loader of application "blueprintapp"' in text
assert ('2: trying loader of blueprint "admin" '
'(blueprintapp.apps.admin)') in text
assert ('trying loader of blueprint "frontend" '
'(blueprintapp.apps.frontend)') in text
assert 'Error: the template could not be found' in text
assert ('looked up from an endpoint that belongs to '
'the blueprint "frontend"') in text
assert 'See http://flask.pocoo.org/docs/blueprints/#templates' in text
with app.test_client() as c:
try:
@ -336,14 +334,14 @@ class TestTemplating(TestFlask):
try:
c.get('/missing')
except TemplateNotFound as e:
self.assert_('missing_template.html' in str(e))
assert 'missing_template.html' in str(e)
else:
self.fail('Expected template not found exception.')
finally:
app.logger.handlers[:] = old_handlers
app.config['EXPLAIN_TEMPLATE_LOADING'] = old_load_setting
self.assert_equal(len(called), 1)
assert len(called) == 1
def suite():

74
tests/test_testing.py
View file

@ -28,10 +28,10 @@ class TestTestTools(TestFlask):
return flask.request.url
ctx = app.test_request_context()
self.assert_equal(ctx.request.url, 'http://example.com:1234/foo/')
assert ctx.request.url == 'http://example.com:1234/foo/'
with app.test_client() as c:
rv = c.get('/')
self.assert_equal(rv.data, b'http://example.com:1234/foo/')
assert rv.data == b'http://example.com:1234/foo/'
def test_environ_defaults(self):
app = flask.Flask(__name__)
@ -41,10 +41,10 @@ class TestTestTools(TestFlask):
return flask.request.url
ctx = app.test_request_context()
self.assert_equal(ctx.request.url, 'http://localhost/')
assert ctx.request.url == 'http://localhost/'
with app.test_client() as c:
rv = c.get('/')
self.assert_equal(rv.data, b'http://localhost/')
assert rv.data == b'http://localhost/'
def test_redirect_keep_session(self):
app = flask.Flask(__name__)
@ -89,14 +89,14 @@ class TestTestTools(TestFlask):
with app.test_client() as c:
with c.session_transaction() as sess:
self.assert_equal(len(sess), 0)
assert len(sess) == 0
sess['foo'] = [42]
self.assert_equal(len(sess), 1)
assert len(sess) == 1
rv = c.get('/')
self.assert_equal(rv.data, b'[42]')
assert rv.data == b'[42]'
with c.session_transaction() as sess:
self.assert_equal(len(sess), 1)
self.assert_equal(sess['foo'], [42])
assert len(sess) == 1
assert sess['foo'] == [42]
def test_session_transactions_no_null_sessions(self):
app = flask.Flask(__name__)
@ -107,9 +107,9 @@ class TestTestTools(TestFlask):
with c.session_transaction() as sess:
pass
except RuntimeError as e:
self.assert_in('Session backend did not open a session', str(e))
assert 'Session backend did not open a session' in str(e)
else:
self.fail('Expected runtime error')
assert False, 'Expected runtime error'
def test_session_transactions_keep_context(self):
app = flask.Flask(__name__)
@ -119,9 +119,9 @@ class TestTestTools(TestFlask):
with app.test_client() as c:
rv = c.get('/')
req = flask.request._get_current_object()
self.assert_true(req is not None)
assert req is not None
with c.session_transaction():
self.assert_true(req is flask.request._get_current_object())
assert req is flask.request._get_current_object()
def test_session_transaction_needs_cookies(self):
app = flask.Flask(__name__)
@ -131,9 +131,9 @@ class TestTestTools(TestFlask):
with c.session_transaction() as s:
pass
except RuntimeError as e:
self.assert_in('cookies', str(e))
assert 'cookies' in str(e)
else:
self.fail('Expected runtime error')
assert False, 'Expected runtime error'
def test_test_client_context_binding(self):
app = flask.Flask(__name__)
@ -149,14 +149,14 @@ class TestTestTools(TestFlask):
with app.test_client() as c:
resp = c.get('/')
self.assert_equal(flask.g.value, 42)
self.assert_equal(resp.data, b'Hello World!')
self.assert_equal(resp.status_code, 200)
assert flask.g.value == 42
assert resp.data == b'Hello World!'
assert resp.status_code == 200
resp = c.get('/other')
self.assert_false(hasattr(flask.g, 'value'))
self.assert_in(b'Internal Server Error', resp.data)
self.assert_equal(resp.status_code, 500)
assert not hasattr(flask.g, 'value')
assert b'Internal Server Error' in resp.data
assert resp.status_code == 500
flask.g.value = 23
try:
@ -171,10 +171,10 @@ class TestTestTools(TestFlask):
c = app.test_client()
with c:
self.assert_equal(c.get('/').status_code, 404)
assert c.get('/').status_code == 404
with c:
self.assert_equal(c.get('/').status_code, 404)
assert c.get('/').status_code == 404
def test_test_client_calls_teardown_handlers(self):
app = flask.Flask(__name__)
@ -184,19 +184,19 @@ class TestTestTools(TestFlask):
called.append(error)
with app.test_client() as c:
self.assert_equal(called, [])
assert called == []
c.get('/')
self.assert_equal(called, [])
self.assert_equal(called, [None])
assert called == []
assert called == [None]
del called[:]
with app.test_client() as c:
self.assert_equal(called, [])
assert called == []
c.get('/')
self.assert_equal(called, [])
assert called == []
c.get('/')
self.assert_equal(called, [None])
self.assert_equal(called, [None, None])
assert called == [None]
assert called == [None, None]
def test_full_url_request(self):
app = flask.Flask(__name__)
@ -208,9 +208,9 @@ class TestTestTools(TestFlask):
with app.test_client() as c:
rv = c.post('http://domain.com/action?vodka=42', data={'gin': 43})
self.assert_equal(rv.status_code, 200)
self.assert_true('gin' in flask.request.form)
self.assert_true('vodka' in flask.request.args)
assert rv.status_code == 200
assert 'gin' in flask.request.form
assert 'vodka' in flask.request.args
class TestSubdomain(TestFlask):
@ -241,8 +241,8 @@ class TestSubdomain(TestFlask):
url = flask.url_for('view', company_id='xxx')
response = client.get(url)
self.assert_equal(200, response.status_code)
self.assert_equal(b'xxx', response.data)
assert 200 == response.status_code
assert b'xxx' == response.data
def test_nosubdomain(self, app, client):
@ -253,5 +253,5 @@ class TestSubdomain(TestFlask):
url = flask.url_for('view', company_id='xxx')
response = client.get(url)
self.assert_equal(200, response.status_code)
self.assert_equal(b'xxx', response.data)
assert 200 == response.status_code
assert b'xxx' == response.data

32
tests/test_views.py
View file

@ -9,6 +9,8 @@
:license: BSD, see LICENSE for more details.
"""
import pytest
import flask
import flask.views
import unittest
@ -20,11 +22,11 @@ class TestView(TestFlask):
def common_test(self, app):
c = app.test_client()
self.assert_equal(c.get('/').data, b'GET')
self.assert_equal(c.post('/').data, b'POST')
self.assert_equal(c.put('/').status_code, 405)
assert c.get('/').data == b'GET'
assert c.post('/').data == b'POST'
assert c.put('/').status_code == 405
meths = parse_set_header(c.open('/', method='OPTIONS').headers['Allow'])
self.assert_equal(sorted(meths), ['GET', 'HEAD', 'OPTIONS', 'POST'])
assert sorted(meths) == ['GET', 'HEAD', 'OPTIONS', 'POST']
def test_basic_view(self):
app = flask.Flask(__name__)
@ -87,7 +89,7 @@ class TestView(TestFlask):
c = app.test_client()
meths = parse_set_header(c.open('/', method='OPTIONS').headers['Allow'])
self.assert_equal(sorted(meths), ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST'])
assert sorted(meths) == ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST']
def test_view_decorators(self):
app = flask.Flask(__name__)
@ -107,8 +109,8 @@ class TestView(TestFlask):
app.add_url_rule('/', view_func=Index.as_view('index'))
c = app.test_client()
rv = c.get('/')
self.assert_equal(rv.headers['X-Parachute'], 'awesome')
self.assert_equal(rv.data, b'Awesome')
assert rv.headers['X-Parachute'] == 'awesome'
assert rv.data == b'Awesome'
def test_implicit_head(self):
app = flask.Flask(__name__)
@ -122,11 +124,11 @@ class TestView(TestFlask):
app.add_url_rule('/', view_func=Index.as_view('index'))
c = app.test_client()
rv = c.get('/')
self.assert_equal(rv.data, b'Blub')
self.assert_equal(rv.headers['X-Method'], 'GET')
assert rv.data == b'Blub'
assert rv.headers['X-Method'] == 'GET'
rv = c.head('/')
self.assert_equal(rv.data, b'')
self.assert_equal(rv.headers['X-Method'], 'HEAD')
assert rv.data == b''
assert rv.headers['X-Method'] == 'HEAD'
def test_explicit_head(self):
app = flask.Flask(__name__)
@ -140,10 +142,10 @@ class TestView(TestFlask):
app.add_url_rule('/', view_func=Index.as_view('index'))
c = app.test_client()
rv = c.get('/')
self.assert_equal(rv.data, b'GET')
assert rv.data == b'GET'
rv = c.head('/')
self.assert_equal(rv.data, b'')
self.assert_equal(rv.headers['X-Method'], 'HEAD')
assert rv.data == b''
assert rv.headers['X-Method'] == 'HEAD'
def test_endpoint_override(self):
app = flask.Flask(__name__)
@ -156,7 +158,7 @@ class TestView(TestFlask):
app.add_url_rule('/', view_func=Index.as_view('index'))
with self.assert_raises(AssertionError):
with pytest.raises(AssertionError):
app.add_url_rule('/', view_func=Index.as_view('index'))
# But these tests should still pass. We just log a warning.