playground
/
flask
mirror of https://github.com/mitsuhiko/flask.git
1
0
Fork 0
Code Issues Releases Activity
Browse Source

Fight the generic asserts!

pull/309/head
Armin Ronacher 13 years ago
parent
2b830af2ef
commit
3069e2d7f7
8 changed files with 212 additions and 212 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 212
      flask/testsuite/basic.py
  2. 74
      flask/testsuite/blueprints.py
  3. 4
      flask/testsuite/config.py
  4. 4
      flask/testsuite/deprecations.py
  5. 78
      flask/testsuite/helpers.py
  6. 18
      flask/testsuite/signals.py
  7. 26
      flask/testsuite/templating.py
  8. 8
      flask/testsuite/testing.py

212
flask/testsuite/basic.py
Unescape View File

@ -26,8 +26,8 @@ class BasicFunctionalityTestCase(FlaskTestCase):
def index():
return 'Hello World'
rv = app.test_client().open('/', method='OPTIONS')
assert sorted(rv.allow) == ['GET', 'HEAD', 'OPTIONS', 'POST']
assert rv.data == ''
self.assert_equal(sorted(rv.allow), ['GET', 'HEAD', 'OPTIONS', 'POST'])
self.assert_equal(rv.data, '')
def test_options_on_multiple_rules(self):
app = flask.Flask(__name__)
@ -38,7 +38,7 @@ class BasicFunctionalityTestCase(FlaskTestCase):
def index_put():
return 'Aha!'
rv = app.test_client().open('/', method='OPTIONS')
assert sorted(rv.allow) == ['GET', 'HEAD', 'OPTIONS', 'POST', 'PUT']
self.assert_equal(sorted(rv.allow), ['GET', 'HEAD', 'OPTIONS', 'POST', 'PUT'])
def test_options_handling_disabled(self):
app = flask.Flask(__name__)
@ -47,7 +47,7 @@ class BasicFunctionalityTestCase(FlaskTestCase):
index.provide_automatic_options = False
app.route('/')(index)
rv = app.test_client().open('/', method='OPTIONS')
assert rv.status_code == 405
self.assert_equal(rv.status_code, 405)
app = flask.Flask(__name__)
def index2():
@ -55,7 +55,7 @@ class BasicFunctionalityTestCase(FlaskTestCase):
index2.provide_automatic_options = True
app.route('/', methods=['OPTIONS'])(index2)
rv = app.test_client().open('/', method='OPTIONS')
assert sorted(rv.allow) == ['OPTIONS']
self.assert_equal(sorted(rv.allow), ['OPTIONS'])
def test_request_dispatching(self):
app = flask.Flask(__name__)
@ -67,18 +67,18 @@ class BasicFunctionalityTestCase(FlaskTestCase):
return flask.request.method
c = app.test_client()
assert c.get('/').data == 'GET'
self.assert_equal(c.get('/').data, 'GET')
rv = c.post('/')
assert rv.status_code == 405
assert sorted(rv.allow) == ['GET', 'HEAD', 'OPTIONS']
self.assert_equal(rv.status_code, 405)
self.assert_equal(sorted(rv.allow), ['GET', 'HEAD', 'OPTIONS'])
rv = c.head('/')
assert rv.status_code == 200
self.assert_equal(rv.status_code, 200)
assert not rv.data # head truncates
assert c.post('/more').data == 'POST'
assert c.get('/more').data == 'GET'
self.assert_equal(c.post('/more').data, 'POST')
self.assert_equal(c.get('/more').data, 'GET')
rv = c.delete('/more')
assert rv.status_code == 405
assert sorted(rv.allow) == ['GET', 'HEAD', 'OPTIONS', 'POST']
self.assert_equal(rv.status_code, 405)
self.assert_equal(sorted(rv.allow), ['GET', 'HEAD', 'OPTIONS', 'POST'])
def test_url_mapping(self):
app = flask.Flask(__name__)
@ -91,18 +91,18 @@ class BasicFunctionalityTestCase(FlaskTestCase):
app.add_url_rule('/more', 'more', more, methods=['GET', 'POST'])
c = app.test_client()
assert c.get('/').data == 'GET'
self.assert_equal(c.get('/').data, 'GET')
rv = c.post('/')
assert rv.status_code == 405
assert sorted(rv.allow) == ['GET', 'HEAD', 'OPTIONS']
self.assert_equal(rv.status_code, 405)
self.assert_equal(sorted(rv.allow), ['GET', 'HEAD', 'OPTIONS'])
rv = c.head('/')
assert rv.status_code == 200
self.assert_equal(rv.status_code, 200)
assert not rv.data # head truncates
assert c.post('/more').data == 'POST'
assert c.get('/more').data == 'GET'
self.assert_equal(c.post('/more').data, 'POST')
self.assert_equal(c.get('/more').data, 'GET')
rv = c.delete('/more')
assert rv.status_code == 405
assert sorted(rv.allow) == ['GET', 'HEAD', 'OPTIONS', 'POST']
self.assert_equal(rv.status_code, 405)
self.assert_equal(sorted(rv.allow), ['GET', 'HEAD', 'OPTIONS', 'POST'])
def test_werkzeug_routing(self):
from werkzeug.routing import Submount, Rule
@ -119,8 +119,8 @@ class BasicFunctionalityTestCase(FlaskTestCase):
app.view_functions['index'] = index
c = app.test_client()
assert c.get('/foo/').data == 'index'
assert c.get('/foo/bar').data == 'bar'
self.assert_equal(c.get('/foo/').data, 'index')
self.assert_equal(c.get('/foo/bar').data, 'bar')
def test_endpoint_decorator(self):
from werkzeug.routing import Submount, Rule
@ -139,8 +139,8 @@ class BasicFunctionalityTestCase(FlaskTestCase):
return 'index'
c = app.test_client()
assert c.get('/foo/').data == 'index'
assert c.get('/foo/bar').data == 'bar'
self.assert_equal(c.get('/foo/').data, 'index')
self.assert_equal(c.get('/foo/bar').data, 'bar')
def test_session(self):
app = flask.Flask(__name__)
@ -154,8 +154,8 @@ class BasicFunctionalityTestCase(FlaskTestCase):
return flask.session['value']
c = app.test_client()
assert c.post('/set', data={'value': '42'}).data == 'value set'
assert c.get('/get').data == '42'
self.assert_equal(c.post('/set', data={'value': '42'}).data, 'value set')
self.assert_equal(c.get('/get').data, '42')
def test_session_using_server_name(self):
app = flask.Flask(__name__)
@ -241,12 +241,12 @@ class BasicFunctionalityTestCase(FlaskTestCase):
match = re.search(r'\bexpires=([^;]+)', rv.headers['set-cookie'])
expires = parse_date(match.group())
expected = datetime.utcnow() + app.permanent_session_lifetime
assert expires.year == expected.year
assert expires.month == expected.month
assert expires.day == expected.day
self.assert_equal(expires.year, expected.year)
self.assert_equal(expires.month, expected.month)
self.assert_equal(expires.day, expected.day)
rv = client.get('/test')
assert rv.data == 'True'
self.assert_equal(rv.data, 'True')
permanent = False
rv = app.test_client().get('/')
@ -264,7 +264,7 @@ class BasicFunctionalityTestCase(FlaskTestCase):
flask.session.modified = False
flask.flash('Zip')
assert flask.session.modified
assert list(flask.get_flashed_messages()) == ['Zap', 'Zip']
self.assert_equal(list(flask.get_flashed_messages()), ['Zap', 'Zip'])
def test_extended_flashing(self):
app = flask.Flask(__name__)
@ -280,16 +280,16 @@ class BasicFunctionalityTestCase(FlaskTestCase):
@app.route('/test')
def test():
messages = flask.get_flashed_messages(with_categories=True)
assert len(messages) == 3
assert messages[0] == ('message', u'Hello World')
assert messages[1] == ('error', u'Hello World')
assert messages[2] == ('warning', flask.Markup(u'<em>Testing</em>'))
self.assert_equal(len(messages), 3)
self.assert_equal(messages[0], ('message', u'Hello World'))
self.assert_equal(messages[1], ('error', u'Hello World'))
self.assert_equal(messages[2], ('warning', flask.Markup(u'<em>Testing</em>')))
return ''
messages = flask.get_flashed_messages()
assert len(messages) == 3
assert messages[0] == u'Hello World'
assert messages[1] == u'Hello World'
assert messages[2] == flask.Markup(u'<em>Testing</em>')
self.assert_equal(len(messages), 3)
self.assert_equal(messages[0], u'Hello World')
self.assert_equal(messages[1], u'Hello World')
self.assert_equal(messages[2], flask.Markup(u'<em>Testing</em>'))
c = app.test_client()
c.get('/')
@ -314,7 +314,7 @@ class BasicFunctionalityTestCase(FlaskTestCase):
assert 'after' not in evts
rv = app.test_client().get('/').data
assert 'after' in evts
assert rv == 'request|after'
self.assert_equal(rv, 'request|after')
def test_teardown_request_handler(self):
called = []
@ -327,9 +327,9 @@ class BasicFunctionalityTestCase(FlaskTestCase):
def root():
return "Response"
rv = app.test_client().get('/')
assert rv.status_code == 200
self.assert_equal(rv.status_code, 200)
assert 'Response' in rv.data
assert len(called) == 1
self.assert_equal(len(called), 1)
def test_teardown_request_handler_debug_mode(self):
called = []
@ -343,16 +343,16 @@ class BasicFunctionalityTestCase(FlaskTestCase):
def root():
return "Response"
rv = app.test_client().get('/')
assert rv.status_code == 200
self.assert_equal(rv.status_code, 200)
assert 'Response' in rv.data
assert len(called) == 1
self.assert_equal(len(called), 1)
def test_teardown_request_handler_error(self):
called = []
app = flask.Flask(__name__)
@app.teardown_request
def teardown_request1(exc):
assert type(exc) == ZeroDivisionError
self.assert_equal(type(exc), ZeroDivisionError)
called.append(True)
# This raises a new error and blows away sys.exc_info(), so we can
# test that all teardown_requests get passed the same original
@ -363,7 +363,7 @@ class BasicFunctionalityTestCase(FlaskTestCase):
pass
@app.teardown_request
def teardown_request2(exc):
assert type(exc) == ZeroDivisionError
self.assert_equal(type(exc), ZeroDivisionError)
called.append(True)
# This raises a new error and blows away sys.exc_info(), so we can
# test that all teardown_requests get passed the same original
@ -376,9 +376,9 @@ class BasicFunctionalityTestCase(FlaskTestCase):
def fails():
1/0
rv = app.test_client().get('/')
assert rv.status_code == 500
self.assert_equal(rv.status_code, 500)
assert 'Internal Server Error' in rv.data
assert len(called) == 2
self.assert_equal(len(called), 2)
def test_before_after_request_order(self):
called = []
@ -407,8 +407,8 @@ class BasicFunctionalityTestCase(FlaskTestCase):
def index():
return '42'
rv = app.test_client().get('/')
assert rv.data == '42'
assert called == [1, 2, 3, 4, 5, 6]
self.assert_equal(rv.data, '42')
self.assert_equal(called, [1, 2, 3, 4, 5, 6])
def test_error_handling(self):
app = flask.Flask(__name__)
@ -426,11 +426,11 @@ class BasicFunctionalityTestCase(FlaskTestCase):
1 // 0
c = app.test_client()
rv = c.get('/')
assert rv.status_code == 404
assert rv.data == 'not found'
self.assert_equal(rv.status_code, 404)
self.assert_equal(rv.data, 'not found')
rv = c.get('/error')
assert rv.status_code == 500
assert 'internal server error' == rv.data
self.assert_equal(rv.status_code, 500)
self.assert_equal('internal server error', rv.data)
def test_before_request_and_routing_errors(self):
app = flask.Flask(__name__)
@ -441,8 +441,8 @@ class BasicFunctionalityTestCase(FlaskTestCase):
def return_something(error):
return flask.g.something, 404
rv = app.test_client().get('/')
assert rv.status_code == 404
assert rv.data == 'value'
self.assert_equal(rv.status_code, 404)
self.assert_equal(rv.data, 'value')
def test_user_error_handling(self):
class MyException(Exception):
@ -458,7 +458,7 @@ class BasicFunctionalityTestCase(FlaskTestCase):
raise MyException()
c = app.test_client()
assert c.get('/').data == '42'
self.assert_equal(c.get('/').data, '42')
def test_trapping_of_bad_request_key_errors(self):
app = flask.Flask(__name__)
@ -467,7 +467,7 @@ class BasicFunctionalityTestCase(FlaskTestCase):
def fail():
flask.request.form['missing_key']
c = app.test_client()
assert c.get('/fail').status_code == 400
self.assert_equal(c.get('/fail').status_code, 400)
app.config['TRAP_BAD_REQUEST_ERRORS'] = True
c = app.test_client()
@ -523,9 +523,9 @@ class BasicFunctionalityTestCase(FlaskTestCase):
ctx = app.test_request_context()
ctx.push()
assert buffer == []
self.assert_equal(buffer, [])
ctx.pop()
assert buffer == [None]
self.assert_equal(buffer, [None])
def test_response_creation(self):
app = flask.Flask(__name__)
@ -539,31 +539,31 @@ class BasicFunctionalityTestCase(FlaskTestCase):
def from_tuple():
return 'Meh', 400, {'X-Foo': 'Testing'}, 'text/plain'
c = app.test_client()
assert c.get('/unicode').data == u'Hällo Wörld'.encode('utf-8')
assert c.get('/string').data == u'Hällo Wörld'.encode('utf-8')
self.assert_equal(c.get('/unicode').data, u'Hällo Wörld'.encode('utf-8'))
self.assert_equal(c.get('/string').data, u'Hällo Wörld'.encode('utf-8'))
rv = c.get('/args')
assert rv.data == 'Meh'
assert rv.headers['X-Foo'] == 'Testing'
assert rv.status_code == 400
assert rv.mimetype == 'text/plain'
self.assert_equal(rv.data, 'Meh')
self.assert_equal(rv.headers['X-Foo'], 'Testing')
self.assert_equal(rv.status_code, 400)
self.assert_equal(rv.mimetype, 'text/plain')
def test_make_response(self):
app = flask.Flask(__name__)
with app.test_request_context():
rv = flask.make_response()
assert rv.status_code == 200
assert rv.data == ''
assert rv.mimetype == 'text/html'
self.assert_equal(rv.status_code, 200)
self.assert_equal(rv.data, '')
self.assert_equal(rv.mimetype, 'text/html')
rv = flask.make_response('Awesome')
assert rv.status_code == 200
assert rv.data == 'Awesome'
assert rv.mimetype == 'text/html'
self.assert_equal(rv.status_code, 200)
self.assert_equal(rv.data, 'Awesome')
self.assert_equal(rv.mimetype, 'text/html')
rv = flask.make_response('W00t', 404)
assert rv.status_code == 404
assert rv.data == 'W00t'
assert rv.mimetype == 'text/html'
self.assert_equal(rv.status_code, 404)
self.assert_equal(rv.data, 'W00t')
self.assert_equal(rv.mimetype, 'text/html')
def test_url_generation(self):
app = flask.Flask(__name__)
@ -571,7 +571,7 @@ class BasicFunctionalityTestCase(FlaskTestCase):
def hello():
pass
with app.test_request_context():
assert flask.url_for('hello', name='test x') == '/hello/test%20x'
self.assert_equal(flask.url_for('hello', name='test x'), '/hello/test%20x')
assert flask.url_for('hello', name='test x', _external=True) \
== 'http://localhost/hello/test%20x'
@ -589,13 +589,13 @@ class BasicFunctionalityTestCase(FlaskTestCase):
def index(args):
return '|'.join(args)
c = app.test_client()
assert c.get('/1,2,3').data == '1|2|3'
self.assert_equal(c.get('/1,2,3').data, '1|2|3')
def test_static_files(self):
app = flask.Flask(__name__)
rv = app.test_client().get('/static/index.html')
assert rv.status_code == 200
assert rv.data.strip() == '<h1>Hello World!</h1>'
self.assert_equal(rv.status_code, 200)
self.assert_equal(rv.data.strip(), '<h1>Hello World!</h1>')
with app.test_request_context():
assert flask.url_for('static', filename='index.html') \
== '/static/index.html'
@ -608,7 +608,7 @@ class BasicFunctionalityTestCase(FlaskTestCase):
try:
app.test_client().get('/')
except ValueError, e:
assert str(e) == 'View function did not return a response'
self.assert_equal(str(e), 'View function did not return a response')
pass
else:
assert "Expected ValueError"
@ -632,19 +632,19 @@ class BasicFunctionalityTestCase(FlaskTestCase):
return None
with app.test_request_context('/'):
assert flask.url_for('index', _external=True) == 'http://localhost.localdomain:5000/'
self.assert_equal(flask.url_for('index', _external=True), 'http://localhost.localdomain:5000/')
with app.test_request_context('/'):
assert flask.url_for('sub', _external=True) == 'http://foo.localhost.localdomain:5000/'
self.assert_equal(flask.url_for('sub', _external=True), 'http://foo.localhost.localdomain:5000/')
try:
with app.test_request_context('/', environ_overrides={'HTTP_HOST': 'localhost'}):
pass
except Exception, e:
assert isinstance(e, ValueError)
assert str(e) == "the server name provided " + \
self.assert_equal(str(e), "the server name provided " +
"('localhost.localdomain:5000') does not match the " + \
"server name from the WSGI environment ('localhost')", str(e)
"server name from the WSGI environment ('localhost')")
try:
app.config.update(SERVER_NAME='localhost')
@ -679,7 +679,7 @@ class BasicFunctionalityTestCase(FlaskTestCase):
try:
rv = app.test_client().get('/')
assert rv.data == 'Foo'
self.assert_equal(rv.data, 'Foo')
except ValueError, e:
raise ValueError(
"No ValueError exception should have been raised \"%s\"" % e
@ -687,7 +687,7 @@ class BasicFunctionalityTestCase(FlaskTestCase):
try:
rv = app.test_client().get('/', 'http://localhost.localdomain:5000')
assert rv.data == 'Foo'
self.assert_equal(rv.data, 'Foo')
except ValueError, e:
raise ValueError(
"No ValueError exception should have been raised \"%s\"" % e
@ -695,7 +695,7 @@ class BasicFunctionalityTestCase(FlaskTestCase):
try:
rv = app.test_client().get('/', 'https://localhost.localdomain:5000')
assert rv.data == 'Foo'
self.assert_equal(rv.data, 'Foo')
except ValueError, e:
raise ValueError(
"No ValueError exception should have been raised \"%s\"" % e
@ -704,7 +704,7 @@ class BasicFunctionalityTestCase(FlaskTestCase):
try:
app.config.update(SERVER_NAME='localhost.localdomain')
rv = app.test_client().get('/', 'https://localhost.localdomain')
assert rv.data == 'Foo'
self.assert_equal(rv.data, 'Foo')
except ValueError, e:
raise ValueError(
"No ValueError exception should have been raised \"%s\"" % e
@ -713,23 +713,23 @@ class BasicFunctionalityTestCase(FlaskTestCase):
try:
app.config.update(SERVER_NAME='localhost.localdomain:443')
rv = app.test_client().get('/', 'https://localhost.localdomain')
assert rv.data == 'Foo'
self.assert_equal(rv.data, 'Foo')
except ValueError, e:
assert str(e) == "the server name provided " + \
self.assert_equal(str(e), "the server name provided " +
"('localhost.localdomain:443') does not match the " + \
"server name from the WSGI environment ('localhost.localdomain')", str(e)
"server name from the WSGI environment ('localhost.localdomain')")
try:
app.config.update(SERVER_NAME='localhost.localdomain')
app.test_client().get('/', 'http://foo.localhost')
except ValueError, e:
assert str(e) == "the server name provided " + \
self.assert_equal(str(e), "the server name provided " + \
"('localhost.localdomain') does not match the " + \
"server name from the WSGI environment ('foo.localhost')", str(e)
"server name from the WSGI environment ('foo.localhost')")
try:
rv = app.test_client().get('/', 'http://foo.localhost.localdomain')
assert rv.data == 'Foo SubDomain'
self.assert_equal(rv.data, 'Foo SubDomain')
except ValueError, e:
raise ValueError(
"No ValueError exception should have been raised \"%s\"" % e
@ -751,7 +751,7 @@ class BasicFunctionalityTestCase(FlaskTestCase):
else:
self.fail('expected exception')
else:
assert c.get('/').status_code == 500
self.assert_equal(c.get('/').status_code, 500)
# we have to run this test in an isolated thread because if the
# debug flag is set to true and an exception happens the context is
@ -779,7 +779,7 @@ class BasicFunctionalityTestCase(FlaskTestCase):
c = app.test_client()
rv = c.post('/accept', data={'myfile': 'foo' * 100})
assert rv.data == '42'
self.assert_equal(rv.data, '42')
def test_url_processors(self):
app = flask.Flask(__name__)
@ -886,9 +886,9 @@ class ContextTestCase(FlaskTestCase):
return flask.request.url
with app.test_request_context('/?name=World'):
assert index() == 'Hello World!'
self.assert_equal(index(), 'Hello World!')
with app.test_request_context('/meh'):
assert meh() == 'http://localhost/meh'
self.assert_equal(meh(), 'http://localhost/meh')
assert flask._request_ctx_stack.top is None
def test_context_test(self):
@ -911,7 +911,7 @@ class ContextTestCase(FlaskTestCase):
ctx = app.test_request_context('/?name=World')
ctx.push()
assert index() == 'Hello World!'
self.assert_equal(index(), 'Hello World!')
ctx.pop()
try:
index()
@ -935,10 +935,10 @@ class SubdomainTestCase(FlaskTestCase):
c = app.test_client()
rv = c.get('/', 'http://localhost/')
assert rv.data == 'normal index'
self.assert_equal(rv.data, 'normal index')
rv = c.get('/', 'http://test.localhost/')
assert rv.data == 'test index'
self.assert_equal(rv.data, 'test index')
@emits_module_deprecation_warning
def test_module_static_path_subdomain(self):
@ -948,7 +948,7 @@ class SubdomainTestCase(FlaskTestCase):
app.register_module(mod)
c = app.test_client()
rv = c.get('/static/hello.txt', 'http://foo.example.com/')
assert rv.data.strip() == 'Hello Subdomain'
self.assert_equal(rv.data.strip(), 'Hello Subdomain')
def test_subdomain_matching(self):
app = flask.Flask(__name__)
@ -959,7 +959,7 @@ class SubdomainTestCase(FlaskTestCase):
c = app.test_client()
rv = c.get('/', 'http://mitsuhiko.localhost/')
assert rv.data == 'index for mitsuhiko'
self.assert_equal(rv.data, 'index for mitsuhiko')
@emits_module_deprecation_warning
def test_module_subdomain_support(self):
@ -979,9 +979,9 @@ class SubdomainTestCase(FlaskTestCase):
c = app.test_client()
rv = c.get('/test', 'http://testing.localhost/')
assert rv.data == 'Test'
self.assert_equal(rv.data, 'Test')
rv = c.get('/outside', 'http://xtesting.localhost/')
assert rv.data == 'Outside'
self.assert_equal(rv.data, 'Outside')
def suite():

74
flask/testsuite/blueprints.py
Unescape View File

@ -43,10 +43,10 @@ class ModuleTestCase(FlaskTestCase):
return 'the index'
app.register_module(admin)
c = app.test_client()
assert c.get('/').data == 'the index'
assert c.get('/admin/').data == 'admin index'
assert c.get('/admin/login').data == 'admin login'
assert c.get('/admin/logout').data == 'admin logout'
self.assert_equal(c.get('/').data, 'the index')
self.assert_equal(c.get('/admin/').data, 'admin index')
self.assert_equal(c.get('/admin/login').data, 'admin login')
self.assert_equal(c.get('/admin/logout').data, 'admin logout')
@emits_module_deprecation_warning
def test_default_endpoint_name(self):
@ -57,9 +57,9 @@ class ModuleTestCase(FlaskTestCase):
mod.add_url_rule('/', view_func=index)
app.register_module(mod)
rv = app.test_client().get('/')
assert rv.data == 'Awesome'
self.assert_equal(rv.data, 'Awesome')
with app.test_request_context():
assert flask.url_for('frontend.index') == '/'
self.assert_equal(flask.url_for('frontend.index'), '/')
@emits_module_deprecation_warning
def test_request_processing(self):
@ -89,13 +89,13 @@ class ModuleTestCase(FlaskTestCase):
app.register_module(admin)
c = app.test_client()
assert c.get('/').data == 'the index'
assert catched == ['before-app', 'after-app']
self.assert_equal(c.get('/').data, 'the index')
self.assert_equal(catched, ['before-app', 'after-app'])
del catched[:]
assert c.get('/admin/').data == 'the admin'
assert catched == ['before-app', 'before-admin',
'after-admin', 'after-app']
self.assert_equal(c.get('/admin/').data, 'the admin')
self.assert_equal(catched, ['before-app', 'before-admin',
'after-admin', 'after-app'])
@emits_module_deprecation_warning
def test_context_processors(self):
@ -118,8 +118,8 @@ class ModuleTestCase(FlaskTestCase):
return flask.render_template_string('{{ a }}{{ b }}{{ c }}')
app.register_module(admin)
c = app.test_client()
assert c.get('/').data == '13'
assert c.get('/admin/').data == '123'
self.assert_equal(c.get('/').data, '13')
self.assert_equal(c.get('/admin/').data, '123')
@emits_module_deprecation_warning
def test_late_binding(self):
@ -129,7 +129,7 @@ class ModuleTestCase(FlaskTestCase):
def index():
return '42'
app.register_module(admin, url_prefix='/admin')
assert app.test_client().get('/admin/').data == '42'
self.assert_equal(app.test_client().get('/admin/').data, '42')
@emits_module_deprecation_warning
def test_error_handling(self):
@ -150,11 +150,11 @@ class ModuleTestCase(FlaskTestCase):
app.register_module(admin)
c = app.test_client()
rv = c.get('/')
assert rv.status_code == 404
assert rv.data == 'not found'
self.assert_equal(rv.status_code, 404)
self.assert_equal(rv.data, 'not found')
rv = c.get('/error')
assert rv.status_code == 500
assert 'internal server error' == rv.data
self.assert_equal(rv.status_code, 500)
self.assert_equal('internal server error', rv.data)
def test_templates_and_static(self):
app = moduleapp
@ -162,15 +162,15 @@ class ModuleTestCase(FlaskTestCase):
c = app.test_client()
rv = c.get('/')
assert rv.data == 'Hello from the Frontend'
self.assert_equal(rv.data, 'Hello from the Frontend')
rv = c.get('/admin/')
assert rv.data == 'Hello from the Admin'
self.assert_equal(rv.data, 'Hello from the Admin')
rv = c.get('/admin/index2')
assert rv.data == 'Hello from the Admin'
self.assert_equal(rv.data, 'Hello from the Admin')
rv = c.get('/admin/static/test.txt')
assert rv.data.strip() == 'Admin File'
self.assert_equal(rv.data.strip(), 'Admin File')
rv = c.get('/admin/static/css/test.css')
assert rv.data.strip() == '/* nested file */'
self.assert_equal(rv.data.strip(), '/* nested file */')
with app.test_request_context():
assert flask.url_for('admin.static', filename='test.txt') \
@ -180,12 +180,12 @@ class ModuleTestCase(FlaskTestCase):
try:
flask.render_template('missing.html')
except TemplateNotFound, e:
assert e.name == 'missing.html'
self.assert_equal(e.name, 'missing.html')
else:
assert 0, 'expected exception'
with flask.Flask(__name__).test_request_context():
assert flask.render_template('nested/nested.txt') == 'I\'m nested'
self.assert_equal(flask.render_template('nested/nested.txt'), 'I\'m nested')
def test_safe_access(self):
app = moduleapp
@ -245,8 +245,8 @@ class ModuleTestCase(FlaskTestCase):
app.register_module(module)
c = app.test_client()
assert c.get('/foo/').data == 'index'
assert c.get('/foo/bar').data == 'bar'
self.assert_equal(c.get('/foo/').data, 'index')
self.assert_equal(c.get('/foo/bar').data, 'bar')
class BlueprintTestCase(FlaskTestCase):
@ -287,9 +287,9 @@ class BlueprintTestCase(FlaskTestCase):
c = app.test_client()
assert c.get('/frontend-no').data == 'frontend says no'
assert c.get('/backend-no').data == 'backend says no'
assert c.get('/what-is-a-sideend').data == 'application itself says no'
self.assert_equal(c.get('/frontend-no').data, 'frontend says no')
self.assert_equal(c.get('/backend-no').data, 'backend says no')
self.assert_equal(c.get('/what-is-a-sideend').data, 'application itself says no')
def test_blueprint_url_definitions(self):
bp = flask.Blueprint('test', __name__)
@ -344,15 +344,15 @@ class BlueprintTestCase(FlaskTestCase):
c = app.test_client()
rv = c.get('/')
assert rv.data == 'Hello from the Frontend'
self.assert_equal(rv.data, 'Hello from the Frontend')
rv = c.get('/admin/')
assert rv.data == 'Hello from the Admin'
self.assert_equal(rv.data, 'Hello from the Admin')
rv = c.get('/admin/index2')
assert rv.data == 'Hello from the Admin'
self.assert_equal(rv.data, 'Hello from the Admin')
rv = c.get('/admin/static/test.txt')
assert rv.data.strip() == 'Admin File'
self.assert_equal(rv.data.strip(), 'Admin File')
rv = c.get('/admin/static/css/test.css')
assert rv.data.strip() == '/* nested file */'
self.assert_equal(rv.data.strip(), '/* nested file */')
with app.test_request_context():
assert flask.url_for('admin.static', filename='test.txt') \
@ -362,12 +362,12 @@ class BlueprintTestCase(FlaskTestCase):
try:
flask.render_template('missing.html')
except TemplateNotFound, e:
assert e.name == 'missing.html'
self.assert_equal(e.name, 'missing.html')
else:
assert 0, 'expected exception'
with flask.Flask(__name__).test_request_context():
assert flask.render_template('nested/nested.txt') == 'I\'m nested'
self.assert_equal(flask.render_template('nested/nested.txt'), 'I\'m nested')
def test_templates_list(self):
from blueprintapp import app

4
flask/testsuite/config.py
Unescape View File

@ -23,8 +23,8 @@ SECRET_KEY = 'devkey'
class ConfigTestCase(FlaskTestCase):
def common_object_test(self, app):
assert app.secret_key == 'devkey'
assert app.config['TEST_KEY'] == 'foo'
self.assert_equal(app.secret_key, 'devkey')
self.assert_equal(app.config['TEST_KEY'], 'foo')
assert 'ConfigTestCase' not in app.config
def test_config_from_file(self):

4
flask/testsuite/deprecations.py
Unescape View File

@ -27,8 +27,8 @@ class DeprecationsTestCase(FlaskTestCase):
return app.jinja_env.globals['foo']
c = app.test_client()
assert c.get('/').data == '42'
assert len(log) == 1
self.assert_equal(c.get('/').data, '42')
self.assert_equal(len(log), 1)
assert 'init_jinja_globals' in str(log[0]['message'])

78
flask/testsuite/helpers.py
Unescape View File

@ -47,7 +47,7 @@ class JSONTestCase(FlaskTestCase):
c = app.test_client()
resp = c.get('/', data=u'"Hällo Wörld"'.encode('iso-8859-15'),
content_type='application/json; charset=iso-8859-15')
assert resp.data == u'Hällo Wörld'.encode('utf-8')
self.assert_equal(resp.data, u'Hällo Wörld'.encode('utf-8'))
def test_jsonify(self):
d = dict(a=23, b=42, c=[1, 2, 3])
@ -61,8 +61,8 @@ class JSONTestCase(FlaskTestCase):
c = app.test_client()
for url in '/kw', '/dict':
rv = c.get(url)
assert rv.mimetype == 'application/json'
assert flask.json.loads(rv.data) == d
self.assert_equal(rv.mimetype, 'application/json')
self.assert_equal(flask.json.loads(rv.data), d)
def test_json_attr(self):
app = flask.Flask(__name__)
@ -72,16 +72,16 @@ class JSONTestCase(FlaskTestCase):
c = app.test_client()
rv = c.post('/add', data=flask.json.dumps({'a': 1, 'b': 2}),
content_type='application/json')
assert rv.data == '3'
self.assert_equal(rv.data, '3')
def test_template_escaping(self):
app = flask.Flask(__name__)
render = flask.render_template_string
with app.test_request_context():
rv = render('{{ "</script>"|tojson|safe }}')
assert rv == '"<\\/script>"'
self.assert_equal(rv, '"<\\/script>"')
rv = render('{{ "<\0/script>"|tojson|safe }}')
assert rv == '"<\\u0000\\/script>"'
self.assert_equal(rv, '"<\\u0000\\/script>"')
def test_modified_url_encoding(self):
class ModifiedRequest(flask.Request):
@ -95,8 +95,8 @@ class JSONTestCase(FlaskTestCase):
return flask.request.args['foo']
rv = app.test_client().get(u'/?foo=정상처리'.encode('euc-kr'))
assert rv.status_code == 200
assert rv.data == u'정상처리'.encode('utf-8')
self.assert_equal(rv.status_code, 200)
self.assert_equal(rv.data, u'정상처리'.encode('utf-8'))
if not has_encoding('euc-kr'):
test_modified_url_encoding = None
@ -109,9 +109,9 @@ class SendfileTestCase(FlaskTestCase):
with app.test_request_context():
rv = flask.send_file('static/index.html')
assert rv.direct_passthrough
assert rv.mimetype == 'text/html'
self.assert_equal(rv.mimetype, 'text/html')
with app.open_resource('static/index.html') as f:
assert rv.data == f.read()
self.assert_equal(rv.data, f.read())
def test_send_file_xsendfile(self):
app = flask.Flask(__name__)
@ -120,9 +120,9 @@ class SendfileTestCase(FlaskTestCase):
rv = flask.send_file('static/index.html')
assert rv.direct_passthrough
assert 'x-sendfile' in rv.headers
assert rv.headers['x-sendfile'] == \
os.path.join(app.root_path, 'static/index.html')
assert rv.mimetype == 'text/html'
self.assert_equal(rv.headers['x-sendfile'],
os.path.join(app.root_path, 'static/index.html'))
self.assert_equal(rv.mimetype, 'text/html')
def test_send_file_object(self):
app = flask.Flask(__name__)
@ -131,39 +131,39 @@ class SendfileTestCase(FlaskTestCase):
f = open(os.path.join(app.root_path, 'static/index.html'))
rv = flask.send_file(f)
with app.open_resource('static/index.html') as f:
assert rv.data == f.read()
assert rv.mimetype == 'text/html'
self.assert_equal(rv.data, f.read())
self.assert_equal(rv.mimetype, 'text/html')
# mimetypes + etag
assert len(captured) == 2
self.assert_equal(len(captured), 2)
app.use_x_sendfile = True
with catch_warnings() as captured:
with app.test_request_context():
f = open(os.path.join(app.root_path, 'static/index.html'))
rv = flask.send_file(f)
assert rv.mimetype == 'text/html'
self.assert_equal(rv.mimetype, 'text/html')
assert 'x-sendfile' in rv.headers
assert rv.headers['x-sendfile'] == \
os.path.join(app.root_path, 'static/index.html')
self.assert_equal(rv.headers['x-sendfile'],
os.path.join(app.root_path, 'static/index.html'))
# mimetypes + etag
assert len(captured) == 2
self.assert_equal(len(captured), 2)
app.use_x_sendfile = False
with app.test_request_context():
with catch_warnings() as captured:
f = StringIO('Test')
rv = flask.send_file(f)
assert rv.data == 'Test'
assert rv.mimetype == 'application/octet-stream'
self.assert_equal(rv.data, 'Test')
self.assert_equal(rv.mimetype, 'application/octet-stream')
# etags
assert len(captured) == 1
self.assert_equal(len(captured), 1)
with catch_warnings() as captured:
f = StringIO('Test')
rv = flask.send_file(f, mimetype='text/plain')
assert rv.data == 'Test'
assert rv.mimetype == 'text/plain'
self.assert_equal(rv.data, 'Test')
self.assert_equal(rv.mimetype, 'text/plain')
# etags
assert len(captured) == 1
self.assert_equal(len(captured), 1)
app.use_x_sendfile = True
with catch_warnings() as captured:
@ -172,7 +172,7 @@ class SendfileTestCase(FlaskTestCase):
rv = flask.send_file(f)
assert 'x-sendfile' not in rv.headers
# etags
assert len(captured) == 1
self.assert_equal(len(captured), 1)
def test_attachment(self):
app = flask.Flask(__name__)
@ -181,25 +181,25 @@ class SendfileTestCase(FlaskTestCase):
f = open(os.path.join(app.root_path, 'static/index.html'))
rv = flask.send_file(f, as_attachment=True)
value, options = parse_options_header(rv.headers['Content-Disposition'])
assert value == 'attachment'
self.assert_equal(value, 'attachment')
# mimetypes + etag
assert len(captured) == 2
self.assert_equal(len(captured), 2)
with app.test_request_context():
assert options['filename'] == 'index.html'
self.assert_equal(options['filename'], 'index.html')
rv = flask.send_file('static/index.html', as_attachment=True)
value, options = parse_options_header(rv.headers['Content-Disposition'])
assert value == 'attachment'
assert options['filename'] == 'index.html'
self.assert_equal(value, 'attachment')
self.assert_equal(options['filename'], 'index.html')
with app.test_request_context():
rv = flask.send_file(StringIO('Test'), as_attachment=True,
attachment_filename='index.txt',
add_etags=False)
assert rv.mimetype == 'text/plain'
self.assert_equal(rv.mimetype, 'text/plain')
value, options = parse_options_header(rv.headers['Content-Disposition'])
assert value == 'attachment'
assert options['filename'] == 'index.txt'
self.assert_equal(value, 'attachment')
self.assert_equal(options['filename'], 'index.txt')
class LoggingTestCase(FlaskTestCase):
@ -208,7 +208,7 @@ class LoggingTestCase(FlaskTestCase):
app = flask.Flask(__name__)
logger1 = app.logger
assert app.logger is logger1
assert logger1.name == __name__
self.assert_equal(logger1.name, __name__)
app.logger_name = __name__ + '/test_logger_cache'
assert app.logger is not logger1
@ -254,7 +254,7 @@ class LoggingTestCase(FlaskTestCase):
1/0
rv = app.test_client().get('/')
assert rv.status_code == 500
self.assert_equal(rv.status_code, 500)
assert 'Internal Server Error' in rv.data
err = out.getvalue()
@ -282,8 +282,8 @@ class LoggingTestCase(FlaskTestCase):
return 'Hello Server Error', 500
for trigger in 'before', 'after':
rv = app.test_client().get('/')
assert rv.status_code == 500
assert rv.data == 'Hello Server Error'
self.assert_equal(rv.status_code, 500)
self.assert_equal(rv.data, 'Hello Server Error')
def suite():

18
flask/testsuite/signals.py
Unescape View File

@ -29,10 +29,10 @@ class SignalsTestCase(FlaskTestCase):
flask.template_rendered.connect(record, app)
try:
app.test_client().get('/')
assert len(recorded) == 1
self.assert_equal(len(recorded), 1)
template, context = recorded[0]
assert template.name == 'simple_template.html'
assert context['whiskey'] == 42
self.assert_equal(template.name, 'simple_template.html')
self.assert_equal(context['whiskey'], 42)
finally:
flask.template_rendered.disconnect(record, app)
@ -44,7 +44,7 @@ class SignalsTestCase(FlaskTestCase):
calls.append('before-signal')
def after_request_signal(sender, response):
assert response.data == 'stuff'
self.assert_equal(response.data, 'stuff')
calls.append('after-signal')
@app.before_request
@ -67,11 +67,11 @@ class SignalsTestCase(FlaskTestCase):
try:
rv = app.test_client().get('/')
assert rv.data == 'stuff'
self.assert_equal(rv.data, 'stuff')
assert calls == ['before-signal', 'before-handler',
self.assert_equal(calls, ['before-signal', 'before-handler',
'handler', 'after-handler',
'after-signal']
'after-signal'])
finally:
flask.request_started.disconnect(before_request_signal, app)
flask.request_finished.disconnect(after_request_signal, app)
@ -89,8 +89,8 @@ class SignalsTestCase(FlaskTestCase):
flask.got_request_exception.connect(record, app)
try:
assert app.test_client().get('/').status_code == 500
assert len(recorded) == 1
self.assert_equal(app.test_client().get('/').status_code, 500)
self.assert_equal(len(recorded), 1)
assert isinstance(recorded[0], ZeroDivisionError)
finally:
flask.got_request_exception.disconnect(record, app)

26
flask/testsuite/templating.py
Unescape View File

@ -24,7 +24,7 @@ class TemplatingTestCase(FlaskTestCase):
def index():
return flask.render_template('context_template.html', value=23)
rv = app.test_client().get('/')
assert rv.data == '<p>23|42'
self.assert_equal(rv.data, '<p>23|42')
def test_original_win(self):
app = flask.Flask(__name__)
@ -32,7 +32,7 @@ class TemplatingTestCase(FlaskTestCase):
def index():
return flask.render_template_string('{{ config }}', config=42)
rv = app.test_client().get('/')
assert rv.data == '42'
self.assert_equal(rv.data, '42')
def test_standard_context(self):
app = flask.Flask(__name__)
@ -48,7 +48,7 @@ class TemplatingTestCase(FlaskTestCase):
{{ session.test }}
''')
rv = app.test_client().get('/?foo=42')
assert rv.data.split() == ['42', '23', 'False', 'aha']
self.assert_equal(rv.data.split(), ['42', '23', 'False', 'aha'])
def test_escaping(self):
text = '<p>Hello World!'
@ -58,14 +58,14 @@ class TemplatingTestCase(FlaskTestCase):
return flask.render_template('escaping_template.html', text=text,
html=flask.Markup(text))
lines = app.test_client().get('/').data.splitlines()
assert lines == [
self.assert_equal(lines, [
'&lt;p&gt;Hello World!',
'<p>Hello World!',
'<p>Hello World!',
'<p>Hello World!',
'&lt;p&gt;Hello World!',
'<p>Hello World!'
]
])
def test_no_escaping(self):
app = flask.Flask(__name__)
@ -79,7 +79,7 @@ class TemplatingTestCase(FlaskTestCase):
app = flask.Flask(__name__)
with app.test_request_context():
macro = flask.get_template_attribute('_macro.html', 'hello')
assert macro('World') == 'Hello World!'
self.assert_equal(macro('World'), 'Hello World!')
def test_template_filter(self):
app = flask.Flask(__name__)
@ -87,8 +87,8 @@ class TemplatingTestCase(FlaskTestCase):
def my_reverse(s):
return s[::-1]
assert 'my_reverse' in app.jinja_env.filters.keys()
assert app.jinja_env.filters['my_reverse'] == my_reverse
assert app.jinja_env.filters['my_reverse']('abcd') == 'dcba'
self.assert_equal(app.jinja_env.filters['my_reverse'], my_reverse)
self.assert_equal(app.jinja_env.filters['my_reverse']('abcd'), 'dcba')
def test_template_filter_with_name(self):
app = flask.Flask(__name__)
@ -96,8 +96,8 @@ class TemplatingTestCase(FlaskTestCase):
def my_reverse(s):
return s[::-1]
assert 'strrev' in app.jinja_env.filters.keys()
assert app.jinja_env.filters['strrev'] == my_reverse
assert app.jinja_env.filters['strrev']('abcd') == 'dcba'
self.assert_equal(app.jinja_env.filters['strrev'], my_reverse)
self.assert_equal(app.jinja_env.filters['strrev']('abcd'), 'dcba')
def test_template_filter_with_template(self):
app = flask.Flask(__name__)
@ -108,7 +108,7 @@ class TemplatingTestCase(FlaskTestCase):
def index():
return flask.render_template('template_filter.html', value='abcd')
rv = app.test_client().get('/')
assert rv.data == 'dcba'
self.assert_equal(rv.data, 'dcba')
def test_template_filter_with_name_and_template(self):
app = flask.Flask(__name__)
@ -119,7 +119,7 @@ class TemplatingTestCase(FlaskTestCase):
def index():
return flask.render_template('template_filter.html', value='abcd')
rv = app.test_client().get('/')
assert rv.data == 'dcba'
self.assert_equal(rv.data, 'dcba')
def test_custom_template_loader(self):
class MyFlask(flask.Flask):
@ -132,7 +132,7 @@ class TemplatingTestCase(FlaskTestCase):
return flask.render_template('index.html')
c = app.test_client()
rv = c.get('/')
assert rv.data == 'Hello Custom World!'
self.assert_equal(rv.data, 'Hello Custom World!')
def suite():

8
flask/testsuite/testing.py
Unescape View File

@ -97,14 +97,14 @@ class TestToolsTestCase(FlaskTestCase):
with app.test_client() as c:
resp = c.get('/')
assert flask.g.value == 42
assert resp.data == 'Hello World!'
assert resp.status_code == 200
self.assert_equal(flask.g.value, 42)
self.assert_equal(resp.data, 'Hello World!')
self.assert_equal(resp.status_code, 200)
resp = c.get('/other')
assert not hasattr(flask.g, 'value')
assert 'Internal Server Error' in resp.data
assert resp.status_code == 500
self.assert_equal(resp.status_code, 500)
flask.g.value = 23
try:

Write Preview
Loading…
Cancel
Save