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

74
flask/testsuite/blueprints.py
Unescape View File

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

4
flask/testsuite/config.py
Unescape View File

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

18
flask/testsuite/signals.py
Unescape View File

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

26
flask/testsuite/templating.py
Unescape View File

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

8
flask/testsuite/testing.py
Unescape View File

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

Write Preview
Loading…
Cancel
Save