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

Tests pass now.

Browse source
This commit is contained in:
Markus Unterwaditzer 2014-08-31 21:56:15 +02:00
parent 961db8ad72
commit 8fa5e32d9a
24 changed files with 421 additions and 530 deletions
Download patch file Download diff file Expand all files Collapse all files

36
examples/blueprintexample/blueprintexample_test.py
View file

@ -1,36 +0,0 @@
# -*- coding: utf-8 -*-
"""
Blueprint Example Tests
~~~~~~~~~~~~~~
Tests the Blueprint example app
"""
import blueprintexample
import unittest
class BlueprintExampleTestCase(unittest.TestCase):
def setUp(self):
self.app = blueprintexample.app.test_client()
def test_urls(self):
r = self.app.get('/')
self.assertEquals(r.status_code, 200)
r = self.app.get('/hello')
self.assertEquals(r.status_code, 200)
r = self.app.get('/world')
self.assertEquals(r.status_code, 200)
#second blueprint instance
r = self.app.get('/pages/hello')
self.assertEquals(r.status_code, 200)
r = self.app.get('/pages/world')
self.assertEquals(r.status_code, 200)
if __name__ == '__main__':
unittest.main()

33
examples/blueprintexample/test_blueprintexample.py Normal file
View file

@ -0,0 +1,33 @@
# -*- coding: utf-8 -*-
"""
Blueprint Example Tests
~~~~~~~~~~~~~~
Tests the Blueprint example app
"""
import pytest
import blueprintexample
@pytest.fixture
def client():
return blueprintexample.app.test_client()
def test_urls(client):
r = client.get('/')
assert r.status_code == 200
r = client.get('/hello')
assert r.status_code == 200
r = client.get('/world')
assert r.status_code == 200
# second blueprint instance
r = client.get('/pages/hello')
assert r.status_code == 200
r = client.get('/pages/world')
assert r.status_code == 200

76
examples/flaskr/flaskr_tests.py
View file

@ -1,76 +0,0 @@
# -*- coding: utf-8 -*-
"""
Flaskr Tests
~~~~~~~~~~~~
Tests the Flaskr application.
:copyright: (c) 2014 by Armin Ronacher.
:license: BSD, see LICENSE for more details.
"""
import os
import flaskr
import unittest
import tempfile
class FlaskrTestCase(unittest.TestCase):
def setUp(self):
"""Before each test, set up a blank database"""
self.db_fd, flaskr.app.config['DATABASE'] = tempfile.mkstemp()
flaskr.app.config['TESTING'] = True
self.app = flaskr.app.test_client()
with flaskr.app.app_context():
flaskr.init_db()
def tearDown(self):
"""Get rid of the database again after each test."""
os.close(self.db_fd)
os.unlink(flaskr.app.config['DATABASE'])
def login(self, username, password):
return self.app.post('/login', data=dict(
username=username,
password=password
), follow_redirects=True)
def logout(self):
return self.app.get('/logout', follow_redirects=True)
# testing functions
def test_empty_db(self):
"""Start with a blank database."""
rv = self.app.get('/')
assert b'No entries here so far' in rv.data
def test_login_logout(self):
"""Make sure login and logout works"""
rv = self.login(flaskr.app.config['USERNAME'],
flaskr.app.config['PASSWORD'])
assert b'You were logged in' in rv.data
rv = self.logout()
assert b'You were logged out' in rv.data
rv = self.login(flaskr.app.config['USERNAME'] + 'x',
flaskr.app.config['PASSWORD'])
assert b'Invalid username' in rv.data
rv = self.login(flaskr.app.config['USERNAME'],
flaskr.app.config['PASSWORD'] + 'x')
assert b'Invalid password' in rv.data
def test_messages(self):
"""Test that messages work"""
self.login(flaskr.app.config['USERNAME'],
flaskr.app.config['PASSWORD'])
rv = self.app.post('/add', data=dict(
title='<Hello>',
text='<strong>HTML</strong> allowed here'
), follow_redirects=True)
assert b'No entries here so far' not in rv.data
assert b'&lt;Hello&gt;' in rv.data
assert b'<strong>HTML</strong> allowed here' in rv.data
if __name__ == '__main__':
unittest.main()

77
examples/flaskr/test_flaskr.py Normal file
View file

@ -0,0 +1,77 @@
# -*- coding: utf-8 -*-
"""
Flaskr Tests
~~~~~~~~~~~~
Tests the Flaskr application.
:copyright: (c) 2014 by Armin Ronacher.
:license: BSD, see LICENSE for more details.
"""
import pytest
import os
import flaskr
import tempfile
@pytest.fixture
def client(request):
db_fd, flaskr.app.config['DATABASE'] = tempfile.mkstemp()
flaskr.app.config['TESTING'] = True
client = flaskr.app.test_client()
with flaskr.app.app_context():
flaskr.init_db()
def teardown():
os.close(db_fd)
os.unlink(flaskr.app.config['DATABASE'])
request.addfinalizer(teardown)
return client
def login(client, username, password):
return client.post('/login', data=dict(
username=username,
password=password
), follow_redirects=True)
def logout(client):
return client.get('/logout', follow_redirects=True)
def test_empty_db(client):
"""Start with a blank database."""
rv = client.get('/')
assert b'No entries here so far' in rv.data
def test_login_logout(client):
"""Make sure login and logout works"""
rv = login(client, flaskr.app.config['USERNAME'],
flaskr.app.config['PASSWORD'])
assert b'You were logged in' in rv.data
rv = logout(client)
assert b'You were logged out' in rv.data
rv = login(client, flaskr.app.config['USERNAME'] + 'x',
flaskr.app.config['PASSWORD'])
assert b'Invalid username' in rv.data
rv = login(client, flaskr.app.config['USERNAME'],
flaskr.app.config['PASSWORD'] + 'x')
assert b'Invalid password' in rv.data
def test_messages(client):
"""Test that messages work"""
login(client, flaskr.app.config['USERNAME'],
flaskr.app.config['PASSWORD'])
rv = client.post('/add', data=dict(
title='<Hello>',
text='<strong>HTML</strong> allowed here'
), follow_redirects=True)
assert b'No entries here so far' not in rv.data
assert b'&lt;Hello&gt;' in rv.data
assert b'<strong>HTML</strong> allowed here' in rv.data

150
examples/minitwit/minitwit_tests.py
View file

@ -1,150 +0,0 @@
# -*- coding: utf-8 -*-
"""
MiniTwit Tests
~~~~~~~~~~~~~~
Tests the MiniTwit application.
:copyright: (c) 2014 by Armin Ronacher.
:license: BSD, see LICENSE for more details.
"""
import os
import minitwit
import unittest
import tempfile
class MiniTwitTestCase(unittest.TestCase):
def setUp(self):
"""Before each test, set up a blank database"""
self.db_fd, minitwit.app.config['DATABASE'] = tempfile.mkstemp()
self.app = minitwit.app.test_client()
with minitwit.app.app_context():
minitwit.init_db()
def tearDown(self):
"""Get rid of the database again after each test."""
os.close(self.db_fd)
os.unlink(minitwit.app.config['DATABASE'])
# helper functions
def register(self, username, password, password2=None, email=None):
"""Helper function to register a user"""
if password2 is None:
password2 = password
if email is None:
email = username + '@example.com'
return self.app.post('/register', data={
'username': username,
'password': password,
'password2': password2,
'email': email,
}, follow_redirects=True)
def login(self, username, password):
"""Helper function to login"""
return self.app.post('/login', data={
'username': username,
'password': password
}, follow_redirects=True)
def register_and_login(self, username, password):
"""Registers and logs in in one go"""
self.register(username, password)
return self.login(username, password)
def logout(self):
"""Helper function to logout"""
return self.app.get('/logout', follow_redirects=True)
def add_message(self, text):
"""Records a message"""
rv = self.app.post('/add_message', data={'text': text},
follow_redirects=True)
if text:
assert b'Your message was recorded' in rv.data
return rv
# testing functions
def test_register(self):
"""Make sure registering works"""
rv = self.register('user1', 'default')
assert b'You were successfully registered ' \
b'and can login now' in rv.data
rv = self.register('user1', 'default')
assert b'The username is already taken' in rv.data
rv = self.register('', 'default')
assert b'You have to enter a username' in rv.data
rv = self.register('meh', '')
assert b'You have to enter a password' in rv.data
rv = self.register('meh', 'x', 'y')
assert b'The two passwords do not match' in rv.data
rv = self.register('meh', 'foo', email='broken')
assert b'You have to enter a valid email address' in rv.data
def test_login_logout(self):
"""Make sure logging in and logging out works"""
rv = self.register_and_login('user1', 'default')
assert b'You were logged in' in rv.data
rv = self.logout()
assert b'You were logged out' in rv.data
rv = self.login('user1', 'wrongpassword')
assert b'Invalid password' in rv.data
rv = self.login('user2', 'wrongpassword')
assert b'Invalid username' in rv.data
def test_message_recording(self):
"""Check if adding messages works"""
self.register_and_login('foo', 'default')
self.add_message('test message 1')
self.add_message('<test message 2>')
rv = self.app.get('/')
assert b'test message 1' in rv.data
assert b'&lt;test message 2&gt;' in rv.data
def test_timelines(self):
"""Make sure that timelines work"""
self.register_and_login('foo', 'default')
self.add_message('the message by foo')
self.logout()
self.register_and_login('bar', 'default')
self.add_message('the message by bar')
rv = self.app.get('/public')
assert b'the message by foo' in rv.data
assert b'the message by bar' in rv.data
# bar's timeline should just show bar's message
rv = self.app.get('/')
assert b'the message by foo' not in rv.data
assert b'the message by bar' in rv.data
# now let's follow foo
rv = self.app.get('/foo/follow', follow_redirects=True)
assert b'You are now following &#34;foo&#34;' in rv.data
# we should now see foo's message
rv = self.app.get('/')
assert b'the message by foo' in rv.data
assert b'the message by bar' in rv.data
# but on the user's page we only want the user's message
rv = self.app.get('/bar')
assert b'the message by foo' not in rv.data
assert b'the message by bar' in rv.data
rv = self.app.get('/foo')
assert b'the message by foo' in rv.data
assert b'the message by bar' not in rv.data
# now unfollow and check if that worked
rv = self.app.get('/foo/unfollow', follow_redirects=True)
assert b'You are no longer following &#34;foo&#34;' in rv.data
rv = self.app.get('/')
assert b'the message by foo' not in rv.data
assert b'the message by bar' in rv.data
if __name__ == '__main__':
unittest.main()

151
examples/minitwit/test_minitwit.py Normal file
View file

@ -0,0 +1,151 @@
# -*- coding: utf-8 -*-
"""
MiniTwit Tests
~~~~~~~~~~~~~~
Tests the MiniTwit application.
:copyright: (c) 2014 by Armin Ronacher.
:license: BSD, see LICENSE for more details.
"""
import os
import minitwit
import tempfile
import pytest
@pytest.fixture
def client(request):
db_fd, minitwit.app.config['DATABASE'] = tempfile.mkstemp()
client = minitwit.app.test_client()
with minitwit.app.app_context():
minitwit.init_db()
def teardown():
"""Get rid of the database again after each test."""
os.close(db_fd)
os.unlink(minitwit.app.config['DATABASE'])
request.addfinalizer(teardown)
return client
def register(client, username, password, password2=None, email=None):
"""Helper function to register a user"""
if password2 is None:
password2 = password
if email is None:
email = username + '@example.com'
return client.post('/register', data={
'username': username,
'password': password,
'password2': password2,
'email': email,
}, follow_redirects=True)
def login(client, username, password):
"""Helper function to login"""
return client.post('/login', data={
'username': username,
'password': password
}, follow_redirects=True)
def register_and_login(client, username, password):
"""Registers and logs in in one go"""
register(client, username, password)
return login(client, username, password)
def logout(client):
"""Helper function to logout"""
return client.get('/logout', follow_redirects=True)
def add_message(client, text):
"""Records a message"""
rv = client.post('/add_message', data={'text': text},
follow_redirects=True)
if text:
assert b'Your message was recorded' in rv.data
return rv
def test_register(client):
"""Make sure registering works"""
rv = register(client, 'user1', 'default')
assert b'You were successfully registered ' \
b'and can login now' in rv.data
rv = register(client, 'user1', 'default')
assert b'The username is already taken' in rv.data
rv = register(client, '', 'default')
assert b'You have to enter a username' in rv.data
rv = register(client, 'meh', '')
assert b'You have to enter a password' in rv.data
rv = register(client, 'meh', 'x', 'y')
assert b'The two passwords do not match' in rv.data
rv = register(client, 'meh', 'foo', email='broken')
assert b'You have to enter a valid email address' in rv.data
def test_login_logout(client):
"""Make sure logging in and logging out works"""
rv = register_and_login(client, 'user1', 'default')
assert b'You were logged in' in rv.data
rv = logout(client)
assert b'You were logged out' in rv.data
rv = login(client, 'user1', 'wrongpassword')
assert b'Invalid password' in rv.data
rv = login(client, 'user2', 'wrongpassword')
assert b'Invalid username' in rv.data
def test_message_recording(client):
"""Check if adding messages works"""
register_and_login(client, 'foo', 'default')
add_message(client, 'test message 1')
add_message(client, '<test message 2>')
rv = client.get('/')
assert b'test message 1' in rv.data
assert b'&lt;test message 2&gt;' in rv.data
def test_timelines(client):
"""Make sure that timelines work"""
register_and_login(client, 'foo', 'default')
add_message(client, 'the message by foo')
logout(client)
register_and_login(client, 'bar', 'default')
add_message(client, 'the message by bar')
rv = client.get('/public')
assert b'the message by foo' in rv.data
assert b'the message by bar' in rv.data
# bar's timeline should just show bar's message
rv = client.get('/')
assert b'the message by foo' not in rv.data
assert b'the message by bar' in rv.data
# now let's follow foo
rv = client.get('/foo/follow', follow_redirects=True)
assert b'You are now following &#34;foo&#34;' in rv.data
# we should now see foo's message
rv = client.get('/')
assert b'the message by foo' in rv.data
assert b'the message by bar' in rv.data
# but on the user's page we only want the user's message
rv = client.get('/bar')
assert b'the message by foo' not in rv.data
assert b'the message by bar' in rv.data
rv = client.get('/foo')
assert b'the message by foo' in rv.data
assert b'the message by bar' not in rv.data
# now unfollow and check if that worked
rv = client.get('/foo/unfollow', follow_redirects=True)
assert b'You are no longer following &#34;foo&#34;' in rv.data
rv = client.get('/')
assert b'the message by foo' not in rv.data
assert b'the message by bar' in rv.data

3
setup.cfg
View file

@ -1,3 +1,6 @@
[pytest]
norecursedirs= scripts docs
[aliases]
release = egg_info -RDb ''

169
tests/__init__.py
View file

@ -11,16 +11,15 @@
"""
from __future__ import print_function
import pytest
import os
import sys
import flask
import warnings
import unittest
from functools import update_wrapper
from contextlib import contextmanager
from werkzeug.utils import import_string, find_modules
from flask._compat import reraise, StringIO
from flask._compat import StringIO
def add_to_path(path):
@ -43,29 +42,6 @@ def add_to_path(path):
sys.path.insert(0, path)
def iter_suites():
"""Yields all testsuites."""
for module in find_modules(__name__):
mod = import_string(module)
if hasattr(mod, 'suite'):
yield mod.suite()
def find_all_tests(suite):
"""Yields all the tests and their names from a given suite."""
suites = [suite]
while suites:
s = suites.pop()
try:
suites.extend(s)
except TypeError:
yield s, '%s.%s.%s' % (
s.__class__.__module__,
s.__class__.__name__,
s._testMethodName
)
@contextmanager
def catch_warnings():
"""Catch warnings in a with block in a list"""
@ -76,6 +52,7 @@ def catch_warnings():
warnings.filters = filters[:]
old_showwarning = warnings.showwarning
log = []
def showwarning(message, category, filename, lineno, file=None, line=None):
log.append(locals())
try:
@ -107,12 +84,23 @@ def emits_module_deprecation_warning(f):
return update_wrapper(new_f, f)
class FlaskTestCase(unittest.TestCase):
class TestFlask(object):
"""Baseclass for all the tests that Flask uses. Use these methods
for testing instead of the camelcased ones in the baseclass for
consistency.
"""
@pytest.fixture(autouse=True)
def setup_path(self, monkeypatch):
monkeypatch.syspath_prepend(
os.path.abspath(os.path.join(
os.path.dirname(__file__), 'test_apps'))
)
@pytest.fixture(autouse=True)
def leak_detector(self, request):
request.addfinalizer(self.ensure_clean_request_context)
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
@ -121,133 +109,42 @@ class FlaskTestCase(unittest.TestCase):
leaks.append(flask._request_ctx_stack.pop())
self.assert_equal(leaks, [])
def setup_method(self, method):
self.setup()
def teardown_method(self, method):
self.teardown()
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)
assert x == y
def assert_raises(self, exc_type, callable=None, *args, **kwargs):
catcher = _ExceptionCatcher(self, exc_type)
if callable is None:
return catcher
with catcher:
callable(*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):
self.assertTrue(x, msg)
assert x
assert_ = assert_true
def assert_false(self, x, msg=None):
self.assertFalse(x, msg)
assert not x
def assert_in(self, x, y):
self.assertIn(x, y)
assert x in y
def assert_not_in(self, x, y):
self.assertNotIn(x, y)
assert x not in y
def assert_isinstance(self, obj, cls):
self.assertIsInstance(obj, cls)
assert isinstance(obj, cls)
if sys.version_info[:2] == (2, 6):
def assertIn(self, x, y):
assert x in y, "%r unexpectedly not in %r" % (x, y)
def assertNotIn(self, x, y):
assert x not in y, "%r unexpectedly in %r" % (x, y)
def assertIsInstance(self, x, y):
assert isinstance(x, y), "not isinstance(%r, %r)" % (x, y)
class _ExceptionCatcher(object):
def __init__(self, test_case, exc_type):
self.test_case = test_case
self.exc_type = exc_type
def __enter__(self):
return self
def __exit__(self, exc_type, exc_value, tb):
exception_name = self.exc_type.__name__
if exc_type is None:
self.test_case.fail('Expected exception of type %r' %
exception_name)
elif not issubclass(exc_type, self.exc_type):
reraise(exc_type, exc_value, tb)
return True
class BetterLoader(unittest.TestLoader):
"""A nicer loader that solves two problems. First of all we are setting
up tests from different sources and we're doing this programmatically
which breaks the default loading logic so this is required anyways.
Secondly this loader has a nicer interpolation for test names than the
default one so you can just do ``run-tests.py ViewTestCase`` and it
will work.
"""
def getRootSuite(self):
return suite()
def loadTestsFromName(self, name, module=None):
root = self.getRootSuite()
if name == 'suite':
return root
all_tests = []
for testcase, testname in find_all_tests(root):
if testname == name or \
testname.endswith('.' + name) or \
('.' + name + '.') in testname or \
testname.startswith(name + '.'):
all_tests.append(testcase)
if not all_tests:
raise LookupError('could not find test case for "%s"' % name)
if len(all_tests) == 1:
return all_tests[0]
rv = unittest.TestSuite()
for test in all_tests:
rv.addTest(test)
return rv
def setup_path():
add_to_path(os.path.abspath(os.path.join(
os.path.dirname(__file__), 'test_apps')))
def suite():
"""A testsuite that has all the Flask tests. You can use this
function to integrate the Flask tests into your own testsuite
in case you want to test that monkeypatches to Flask do not
break it.
"""
setup_path()
suite = unittest.TestSuite()
for other_suite in iter_suites():
suite.addTest(other_suite)
return suite
def main():
"""Runs the testsuite as command line application."""
try:
unittest.main(testLoader=BetterLoader(), defaultTest='suite')
except Exception as e:
print('Error: %s' % e)
def fail(self, msg):
raise AssertionError(msg)

8
tests/test_appctx.py
View file

@ -11,10 +11,10 @@
import flask
import unittest
from tests import FlaskTestCase
from tests import TestFlask
class AppContextTestCase(FlaskTestCase):
class TestAppContext(TestFlask):
def test_basic_url_generation(self):
app = flask.Flask(__name__)
@ -109,10 +109,10 @@ class AppContextTestCase(FlaskTestCase):
return u''
c = app.test_client()
c.get('/')
self.assertEqual(called, ['request', 'app'])
self.assert_equal(called, ['request', 'app'])
def suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(AppContextTestCase))
suite.addTest(unittest.makeSuite(TestAppContext))
return suite

2
tests/test_apps/importerror.py
View file

@ -1,2 +1,2 @@
# NoImportsTestCase
# TestNoImports
raise NotImplementedError

47
tests/test_basic.py
View file

@ -17,14 +17,14 @@ import pickle
import unittest
from datetime import datetime
from threading import Thread
from tests import FlaskTestCase, emits_module_deprecation_warning
from tests import TestFlask, emits_module_deprecation_warning
from flask._compat import text_type
from werkzeug.exceptions import BadRequest, NotFound, Forbidden
from werkzeug.http import parse_date
from werkzeug.routing import BuildError
class BasicFunctionalityTestCase(FlaskTestCase):
class TestBasicFunctionality(TestFlask):
def test_options_work(self):
app = flask.Flask(__name__)
@ -522,8 +522,8 @@ class BasicFunctionalityTestCase(FlaskTestCase):
return 'Test'
c = app.test_client()
resp = c.get('/')
self.assertEqual(resp.status_code, 200)
self.assertEqual(resp.headers['X-Foo'], 'a header')
self.assert_equal(resp.status_code, 200)
self.assert_equal(resp.headers['X-Foo'], 'a header')
def test_teardown_request_handler(self):
called = []
@ -840,22 +840,22 @@ class BasicFunctionalityTestCase(FlaskTestCase):
with app.test_request_context():
rv = flask.make_response(
flask.jsonify({'msg': 'W00t'}), 400)
self.assertEqual(rv.status_code, 400)
self.assertEqual(rv.data, b'{\n "msg": "W00t"\n}')
self.assertEqual(rv.mimetype, 'application/json')
self.assert_equal(rv.status_code, 400)
self.assert_equal(rv.data, b'{\n "msg": "W00t"\n}')
self.assert_equal(rv.mimetype, 'application/json')
rv = flask.make_response(
flask.Response(''), 400)
self.assertEqual(rv.status_code, 400)
self.assertEqual(rv.data, b'')
self.assertEqual(rv.mimetype, 'text/html')
self.assert_equal(rv.status_code, 400)
self.assert_equal(rv.data, b'')
self.assert_equal(rv.mimetype, 'text/html')
rv = flask.make_response(
flask.Response('', headers={'Content-Type': 'text/html'}),
400, [('X-Foo', 'bar')])
self.assertEqual(rv.status_code, 400)
self.assertEqual(rv.headers['Content-Type'], 'text/html')
self.assertEqual(rv.headers['X-Foo'], 'bar')
self.assert_equal(rv.status_code, 400)
self.assert_equal(rv.headers['Content-Type'], 'text/html')
self.assert_equal(rv.headers['X-Foo'], 'bar')
def test_url_generation(self):
app = flask.Flask(__name__)
@ -872,7 +872,7 @@ class BasicFunctionalityTestCase(FlaskTestCase):
# Test base case, a URL which results in a BuildError.
with app.test_request_context():
self.assertRaises(BuildError, flask.url_for, 'spam')
self.assert_raises(BuildError, flask.url_for, 'spam')
# Verify the error is re-raised if not the current exception.
try:
@ -883,7 +883,7 @@ class BasicFunctionalityTestCase(FlaskTestCase):
try:
raise RuntimeError('Test case where BuildError is not current.')
except RuntimeError:
self.assertRaises(BuildError, app.handle_url_build_error, error, 'spam', {})
self.assert_raises(BuildError, app.handle_url_build_error, error, 'spam', {})
# Test a custom handler.
def handler(error, endpoint, values):
@ -936,7 +936,7 @@ class BasicFunctionalityTestCase(FlaskTestCase):
def test_request_locals(self):
self.assert_equal(repr(flask.g), '<LocalProxy unbound>')
self.assertFalse(flask.g)
self.assert_false(flask.g)
def test_test_app_proper_environ(self):
app = flask.Flask(__name__)
@ -1205,9 +1205,9 @@ class BasicFunctionalityTestCase(FlaskTestCase):
assert flask.url_for('123') == '/bar/123'
c = app.test_client()
self.assertEqual(c.get('/foo/').data, b'foo')
self.assertEqual(c.get('/bar/').data, b'bar')
self.assertEqual(c.get('/bar/123').data, b'123')
self.assert_equal(c.get('/foo/').data, b'foo')
self.assert_equal(c.get('/bar/').data, b'bar')
self.assert_equal(c.get('/bar/123').data, b'123')
def test_preserve_only_once(self):
app = flask.Flask(__name__)
@ -1286,7 +1286,7 @@ class BasicFunctionalityTestCase(FlaskTestCase):
self.assert_equal(sorted(flask.g), ['bar', 'foo'])
class SubdomainTestCase(FlaskTestCase):
class TestSubdomain(TestFlask):
def test_basic_support(self):
app = flask.Flask(__name__)
@ -1355,10 +1355,3 @@ class SubdomainTestCase(FlaskTestCase):
self.assert_equal(rv.data, b'a')
rv = app.test_client().open('/b/')
self.assert_equal(rv.data, b'b')
def suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(BasicFunctionalityTestCase))
suite.addTest(unittest.makeSuite(SubdomainTestCase))
return suite

22
tests/test_blueprints.py
View file

@ -11,13 +11,13 @@
import flask
import unittest
from tests import FlaskTestCase
from tests import TestFlask
from flask._compat import text_type
from werkzeug.http import parse_cache_control_header
from jinja2 import TemplateNotFound
class BlueprintTestCase(FlaskTestCase):
class TestBlueprint(TestFlask):
def test_blueprint_specific_error_handling(self):
frontend = flask.Blueprint('frontend', __name__)
@ -303,11 +303,11 @@ class BlueprintTestCase(FlaskTestCase):
return flask.request.endpoint
c = app.test_client()
self.assertEqual(c.get('/').data, b'index')
self.assertEqual(c.get('/py/foo').data, b'bp.foo')
self.assertEqual(c.get('/py/bar').data, b'bp.bar')
self.assertEqual(c.get('/py/bar/123').data, b'bp.123')
self.assertEqual(c.get('/py/bar/foo').data, b'bp.bar_foo')
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')
def test_route_decorator_custom_endpoint_with_dots(self):
bp = flask.Blueprint('bp', __name__)
@ -337,14 +337,14 @@ class BlueprintTestCase(FlaskTestCase):
def foo_foo_foo():
pass
self.assertRaises(
self.assert_raises(
AssertionError,
lambda: bp.add_url_rule(
'/bar/123', endpoint='bar.123', view_func=foo_foo_foo
)
)
self.assertRaises(
self.assert_raises(
AssertionError,
bp.route('/bar/123', endpoint='bar.123'),
lambda: None
@ -354,7 +354,7 @@ class BlueprintTestCase(FlaskTestCase):
app.register_blueprint(bp, url_prefix='/py')
c = app.test_client()
self.assertEqual(c.get('/py/foo').data, b'bp.foo')
self.assert_equal(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
@ -581,5 +581,5 @@ class BlueprintTestCase(FlaskTestCase):
def suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(BlueprintTestCase))
suite.addTest(unittest.makeSuite(TestBlueprint))
return suite

16
tests/test_config.py
View file

@ -15,21 +15,21 @@ import flask
import pkgutil
import unittest
from contextlib import contextmanager
from tests import FlaskTestCase
from tests import TestFlask
from flask._compat import PY2
# config keys used for the ConfigTestCase
# config keys used for the TestConfig
TEST_KEY = 'foo'
SECRET_KEY = 'devkey'
class ConfigTestCase(FlaskTestCase):
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('ConfigTestCase', app.config)
self.assert_not_in('TestConfig', app.config)
def test_config_from_file(self):
app = flask.Flask(__name__)
@ -117,7 +117,7 @@ class ConfigTestCase(FlaskTestCase):
self.assert_true(msg.endswith("missing.cfg'"))
else:
self.fail('expected IOError')
self.assertFalse(app.config.from_envvar('FOO_SETTINGS', silent=True))
self.assert_false(app.config.from_envvar('FOO_SETTINGS', silent=True))
finally:
os.environ = env
@ -207,7 +207,7 @@ def patch_pkgutil_get_loader(wrapper_class=LimitedLoaderMockWrapper):
pkgutil.get_loader = old_get_loader
class InstanceTestCase(FlaskTestCase):
class TestInstance(TestFlask):
def test_explicit_instance_paths(self):
here = os.path.abspath(os.path.dirname(__file__))
@ -379,6 +379,6 @@ class InstanceTestCase(FlaskTestCase):
def suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(ConfigTestCase))
suite.addTest(unittest.makeSuite(InstanceTestCase))
suite.addTest(unittest.makeSuite(TestConfig))
suite.addTest(unittest.makeSuite(TestInstance))
return suite

6
tests/test_deprecations.py
View file

@ -11,14 +11,14 @@
import flask
import unittest
from tests import FlaskTestCase, catch_warnings
from tests import TestFlask, catch_warnings
class DeprecationsTestCase(FlaskTestCase):
class TestDeprecations(TestFlask):
"""not used currently"""
def suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(DeprecationsTestCase))
suite.addTest(unittest.makeSuite(TestDeprecations))
return suite

8
tests/test_examples.py
View file

@ -24,15 +24,15 @@ def suite():
setup_path()
suite = unittest.TestSuite()
try:
from minitwit_tests import MiniTwitTestCase
from minitwit_tests import TestMiniTwit
except ImportError:
pass
else:
suite.addTest(unittest.makeSuite(MiniTwitTestCase))
suite.addTest(unittest.makeSuite(TestMiniTwit))
try:
from flaskr_tests import FlaskrTestCase
from flaskr_tests import TestFlaskr
except ImportError:
pass
else:
suite.addTest(unittest.makeSuite(FlaskrTestCase))
suite.addTest(unittest.makeSuite(TestFlaskr))
return suite

6
tests/test_ext.py
View file

@ -15,10 +15,10 @@ try:
from imp import reload as reload_module
except ImportError:
reload_module = reload
from tests import FlaskTestCase
from tests import TestFlask
from flask._compat import PY2
class ExtImportHookTestCase(FlaskTestCase):
class TestExtImportHook(TestFlask):
def setup(self):
# we clear this out for various reasons. The most important one is
@ -132,5 +132,5 @@ class ExtImportHookTestCase(FlaskTestCase):
def suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(ExtImportHookTestCase))
suite.addTest(unittest.makeSuite(TestExtImportHook))
return suite

34
tests/test_helpers.py
View file

@ -13,7 +13,7 @@ import os
import flask
import unittest
from logging import StreamHandler
from tests import FlaskTestCase, catch_warnings, catch_stderr
from tests import TestFlask, catch_warnings, catch_stderr
from werkzeug.http import parse_cache_control_header, parse_options_header
from flask._compat import StringIO, text_type
@ -27,7 +27,7 @@ def has_encoding(name):
return False
class JSONTestCase(FlaskTestCase):
class TestJSON(TestFlask):
def test_json_bad_requests(self):
app = flask.Flask(__name__)
@ -148,7 +148,7 @@ class JSONTestCase(FlaskTestCase):
rv = c.post('/', data=flask.json.dumps({
'x': {'_foo': 42}
}), content_type='application/json')
self.assertEqual(rv.data, b'"<42>"')
self.assert_equal(rv.data, b'"<42>"')
def test_modified_url_encoding(self):
class ModifiedRequest(flask.Request):
@ -240,7 +240,7 @@ class JSONTestCase(FlaskTestCase):
except AssertionError:
self.assert_equal(lines, sorted_by_str)
class SendfileTestCase(FlaskTestCase):
class TestSendfile(TestFlask):
def test_send_file_regular(self):
app = flask.Flask(__name__)
@ -422,7 +422,7 @@ class SendfileTestCase(FlaskTestCase):
rv.close()
class LoggingTestCase(FlaskTestCase):
class TestLogging(TestFlask):
def test_logger_cache(self):
app = flask.Flask(__name__)
@ -450,7 +450,7 @@ class LoggingTestCase(FlaskTestCase):
with catch_stderr() as err:
c.get('/')
out = err.getvalue()
self.assert_in('WARNING in helpers [', out)
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)
@ -572,7 +572,7 @@ class LoggingTestCase(FlaskTestCase):
'/myview/create')
class NoImportsTestCase(FlaskTestCase):
class TestNoImports(TestFlask):
"""Test Flasks are created without import.
Avoiding ``__import__`` helps create Flask instances where there are errors
@ -590,7 +590,7 @@ class NoImportsTestCase(FlaskTestCase):
self.fail('Flask(import_name) is importing import_name.')
class StreamingTestCase(FlaskTestCase):
class TestStreaming(TestFlask):
def test_streaming_with_context(self):
app = flask.Flask(__name__)
@ -604,7 +604,7 @@ class StreamingTestCase(FlaskTestCase):
return flask.Response(flask.stream_with_context(generate()))
c = app.test_client()
rv = c.get('/?name=World')
self.assertEqual(rv.data, b'Hello World!')
self.assert_equal(rv.data, b'Hello World!')
def test_streaming_with_context_as_decorator(self):
app = flask.Flask(__name__)
@ -619,7 +619,7 @@ class StreamingTestCase(FlaskTestCase):
return flask.Response(generate())
c = app.test_client()
rv = c.get('/?name=World')
self.assertEqual(rv.data, b'Hello World!')
self.assert_equal(rv.data, b'Hello World!')
def test_streaming_with_context_and_custom_close(self):
app = flask.Flask(__name__)
@ -645,16 +645,16 @@ class StreamingTestCase(FlaskTestCase):
Wrapper(generate())))
c = app.test_client()
rv = c.get('/?name=World')
self.assertEqual(rv.data, b'Hello World!')
self.assertEqual(called, [42])
self.assert_equal(rv.data, b'Hello World!')
self.assert_equal(called, [42])
def suite():
suite = unittest.TestSuite()
if flask.json_available:
suite.addTest(unittest.makeSuite(JSONTestCase))
suite.addTest(unittest.makeSuite(SendfileTestCase))
suite.addTest(unittest.makeSuite(LoggingTestCase))
suite.addTest(unittest.makeSuite(NoImportsTestCase))
suite.addTest(unittest.makeSuite(StreamingTestCase))
suite.addTest(unittest.makeSuite(TestJSON))
suite.addTest(unittest.makeSuite(TestSendfile))
suite.addTest(unittest.makeSuite(TestLogging))
suite.addTest(unittest.makeSuite(TestNoImports))
suite.addTest(unittest.makeSuite(TestStreaming))
return suite

27
tests/test_regression.py
View file

@ -9,14 +9,15 @@
:license: BSD, see LICENSE for more details.
"""
import pytest
import os
import gc
import sys
import flask
import threading
import unittest
from werkzeug.exceptions import NotFound
from tests import FlaskTestCase
from tests import TestFlask
_gc_lock = threading.Lock()
@ -51,13 +52,16 @@ class _NoLeakAsserter(object):
gc.enable()
class MemoryTestCase(FlaskTestCase):
@pytest.mark.skipif(os.environ.get('RUN_FLASK_MEMORY_TESTS') != '1',
reason='Turned off due to envvar.')
class TestMemory(TestFlask):
def assert_no_leak(self):
return _NoLeakAsserter(self)
def test_memory_consumption(self):
app = flask.Flask(__name__)
@app.route('/')
def index():
return flask.render_template('simple_template.html', whiskey=42)
@ -84,33 +88,28 @@ class MemoryTestCase(FlaskTestCase):
safe_join('/foo', '..')
class ExceptionTestCase(FlaskTestCase):
class TestException(TestFlask):
def test_aborting(self):
class Foo(Exception):
whatever = 42
app = flask.Flask(__name__)
app.testing = True
@app.errorhandler(Foo)
def handle_foo(e):
return str(e.whatever)
@app.route('/')
def index():
raise flask.abort(flask.redirect(flask.url_for('test')))
@app.route('/test')
def test():
raise Foo()
with app.test_client() as c:
rv = c.get('/')
self.assertEqual(rv.headers['Location'], 'http://localhost/test')
self.assert_equal(rv.headers['Location'], 'http://localhost/test')
rv = c.get('/test')
self.assertEqual(rv.data, b'42')
def suite():
suite = unittest.TestSuite()
if os.environ.get('RUN_FLASK_MEMORY_TESTS') == '1':
suite.addTest(unittest.makeSuite(MemoryTestCase))
suite.addTest(unittest.makeSuite(ExceptionTestCase))
return suite
self.assert_equal(rv.data, b'42')

6
tests/test_reqctx.py
View file

@ -15,10 +15,10 @@ try:
from greenlet import greenlet
except ImportError:
greenlet = None
from tests import FlaskTestCase
from tests import TestFlask
class RequestContextTestCase(FlaskTestCase):
class TestRequestContext(TestFlask):
def test_teardown_on_pop(self):
buffer = []
@ -197,5 +197,5 @@ class RequestContextTestCase(FlaskTestCase):
def suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(RequestContextTestCase))
suite.addTest(unittest.makeSuite(TestRequestContext))
return suite

6
tests/test_signals.py
View file

@ -11,10 +11,10 @@
import flask
import unittest
from tests import FlaskTestCase
from tests import TestFlask
class SignalsTestCase(FlaskTestCase):
class TestSignals(TestFlask):
def test_template_rendered(self):
app = flask.Flask(__name__)
@ -149,5 +149,5 @@ class SignalsTestCase(FlaskTestCase):
def suite():
suite = unittest.TestSuite()
if flask.signals_available:
suite.addTest(unittest.makeSuite(SignalsTestCase))
suite.addTest(unittest.makeSuite(TestSignals))
return suite

6
tests/test_subclassing.py
View file

@ -12,11 +12,11 @@
import flask
import unittest
from logging import StreamHandler
from tests import FlaskTestCase
from tests import TestFlask
from flask._compat import StringIO
class FlaskSubclassingTestCase(FlaskTestCase):
class TestFlaskSubclassing(TestFlask):
def test_suppressed_exception_logging(self):
class SuppressedFlask(flask.Flask):
@ -42,5 +42,5 @@ class FlaskSubclassingTestCase(FlaskTestCase):
def suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(FlaskSubclassingTestCase))
suite.addTest(unittest.makeSuite(TestFlaskSubclassing))
return suite

6
tests/test_templating.py
View file

@ -14,10 +14,10 @@ import unittest
import logging
from jinja2 import TemplateNotFound
from tests import FlaskTestCase
from tests import TestFlask
class TemplatingTestCase(FlaskTestCase):
class TestTemplating(TestFlask):
def test_context_processing(self):
app = flask.Flask(__name__)
@ -348,5 +348,5 @@ class TemplatingTestCase(FlaskTestCase):
def suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(TemplatingTestCase))
suite.addTest(unittest.makeSuite(TestTemplating))
return suite

50
tests/test_testing.py
View file

@ -8,14 +8,15 @@
:copyright: (c) 2014 by Armin Ronacher.
:license: BSD, see LICENSE for more details.
"""
import pytest
import flask
import unittest
from tests import FlaskTestCase
from tests import TestFlask
from flask._compat import text_type
class TestToolsTestCase(FlaskTestCase):
class TestTestTools(TestFlask):
def test_environ_defaults_from_config(self):
app = flask.Flask(__name__)
@ -212,46 +213,45 @@ class TestToolsTestCase(FlaskTestCase):
self.assert_true('vodka' in flask.request.args)
class SubdomainTestCase(FlaskTestCase):
class TestSubdomain(TestFlask):
def setUp(self):
self.app = flask.Flask(__name__)
self.app.config['SERVER_NAME'] = 'example.com'
self.client = self.app.test_client()
@pytest.fixture
def app(self, request):
app = flask.Flask(__name__)
app.config['SERVER_NAME'] = 'example.com'
self._ctx = self.app.test_request_context()
self._ctx.push()
ctx = app.test_request_context()
ctx.push()
def tearDown(self):
if self._ctx is not None:
self._ctx.pop()
def teardown():
if ctx is not None:
ctx.pop()
request.addfinalizer(teardown)
return app
def test_subdomain(self):
@self.app.route('/', subdomain='<company_id>')
@pytest.fixture
def client(self, app):
return app.test_client()
def test_subdomain(self, app, client):
@app.route('/', subdomain='<company_id>')
def view(company_id):
return company_id
url = flask.url_for('view', company_id='xxx')
response = self.client.get(url)
response = client.get(url)
self.assert_equal(200, response.status_code)
self.assert_equal(b'xxx', response.data)
def test_nosubdomain(self):
@self.app.route('/<company_id>')
def test_nosubdomain(self, app, client):
@app.route('/<company_id>')
def view(company_id):
return company_id
url = flask.url_for('view', company_id='xxx')
response = self.client.get(url)
response = client.get(url)
self.assert_equal(200, response.status_code)
self.assert_equal(b'xxx', response.data)
def suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(TestToolsTestCase))
suite.addTest(unittest.makeSuite(SubdomainTestCase))
return suite

6
tests/test_views.py
View file

@ -12,10 +12,10 @@
import flask
import flask.views
import unittest
from tests import FlaskTestCase
from tests import TestFlask
from werkzeug.http import parse_set_header
class ViewTestCase(FlaskTestCase):
class TestView(TestFlask):
def common_test(self, app):
c = app.test_client()
@ -165,5 +165,5 @@ class ViewTestCase(FlaskTestCase):
def suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(ViewTestCase))
suite.addTest(unittest.makeSuite(TestView))
return suite