Rewrite assertion methods

10 years ago · 5da2c00419
14 changed files with 694 additions and 719 deletions
--- a/tests/init.py
+++ b/tests/init.py
@ -78,9 +78,9 @@ def emits_module_deprecation_warning(f):
    def new_f(self, *args, **kwargs):
        with catch_warnings() as log:
            f(self, *args, **kwargs)
-            self.assert_true(log, 'expected deprecation warning')
+            assert log, 'expected deprecation warning'
            for entry in log:
-                self.assert_in('Modules are deprecated', str(entry['message']))
+                assert 'Modules are deprecated' in str(entry['message'])
    return update_wrapper(new_f, f)


@ -107,7 +107,7 @@ class TestFlask(object):
        leaks = []
        while flask._request_ctx_stack.top is not None:
            leaks.append(flask._request_ctx_stack.pop())
-        self.assert_equal(leaks, [])
+        assert leaks == []

    def setup_method(self, method):
        self.setup()
@ -120,31 +120,3 @@ class TestFlask(object):

    def teardown(self):
        pass
-
-    def assert_equal(self, x, y):
-        assert x == y
-
-    def assert_raises(self, exc_type, callable=None, *args, **kwargs):
-        if callable:
-            return pytest.raises(exc_type, callable, *args, **kwargs)
-        else:
-            return pytest.raises(exc_type)
-
-    def assert_true(self, x, msg=None):
-        assert x
-    assert_ = assert_true
-
-    def assert_false(self, x, msg=None):
-        assert not x
-
-    def assert_in(self, x, y):
-        assert x in y
-
-    def assert_not_in(self, x, y):
-        assert x not in y
-
-    def assert_isinstance(self, obj, cls):
-        assert isinstance(obj, cls)
-
-    def fail(self, msg):
-        raise AssertionError(msg)
--- a/tests/test_appctx.py
+++ b/tests/test_appctx.py
@ -9,6 +9,8 @@
    :license: BSD, see LICENSE for more details.
 """

+import pytest
+
 import flask
 import unittest
 from tests import TestFlask
@ -27,29 +29,29 @@ class TestAppContext(TestFlask):

        with app.app_context():
            rv = flask.url_for('index')
-            self.assert_equal(rv, 'https://localhost/')
+            assert rv == 'https://localhost/'

    def test_url_generation_requires_server_name(self):
        app = flask.Flask(__name__)
        with app.app_context():
-            with self.assert_raises(RuntimeError):
+            with pytest.raises(RuntimeError):
                flask.url_for('index')

    def test_url_generation_without_context_fails(self):
-        with self.assert_raises(RuntimeError):
+        with pytest.raises(RuntimeError):
            flask.url_for('index')

    def test_request_context_means_app_context(self):
        app = flask.Flask(__name__)
        with app.test_request_context():
-            self.assert_equal(flask.current_app._get_current_object(), app)
-        self.assert_equal(flask._app_ctx_stack.top, None)
+            assert flask.current_app._get_current_object() == app
+        assert flask._app_ctx_stack.top == None

    def test_app_context_provides_current_app(self):
        app = flask.Flask(__name__)
        with app.app_context():
-            self.assert_equal(flask.current_app._get_current_object(), app)
-        self.assert_equal(flask._app_ctx_stack.top, None)
+            assert flask.current_app._get_current_object() == app
+        assert flask._app_ctx_stack.top == None

    def test_app_tearing_down(self):
        cleanup_stuff = []
@ -61,7 +63,7 @@ class TestAppContext(TestFlask):
        with app.app_context():
            pass

-        self.assert_equal(cleanup_stuff, [None])
+        assert cleanup_stuff == [None]

    def test_app_tearing_down_with_previous_exception(self):
        cleanup_stuff = []
@ -78,7 +80,7 @@ class TestAppContext(TestFlask):
        with app.app_context():
            pass

-        self.assert_equal(cleanup_stuff, [None])
+        assert cleanup_stuff == [None]

    def test_custom_app_ctx_globals_class(self):
        class CustomRequestGlobals(object):
@ -87,8 +89,7 @@ class TestAppContext(TestFlask):
        app = flask.Flask(__name__)
        app.app_ctx_globals_class = CustomRequestGlobals
        with app.app_context():
-            self.assert_equal(
-                flask.render_template_string('{{ g.spam }}'), 'eggs')
+            assert flask.render_template_string('{{ g.spam }}') == 'eggs'

    def test_context_refcounts(self):
        called = []
@ -104,12 +105,14 @@ class TestAppContext(TestFlask):
            with flask._app_ctx_stack.top:
                with flask._request_ctx_stack.top:
                    pass
-            self.assert_true(flask._request_ctx_stack.top.request.environ
-                ['werkzeug.request'] is not None)
+            env = flask._request_ctx_stack.top.request.environ
+            assert env['werkzeug.request'] is not None
            return u''
        c = app.test_client()
-        c.get('/')
-        self.assert_equal(called, ['request', 'app'])
+        res = c.get('/')
+        assert res.status_code == 200
+        assert res.data == u''
+        assert called == ['request', 'app']


 def suite():
--- a/tests/test_basic.py
+++ b/tests/test_basic.py
--- a/tests/test_blueprints.py
+++ b/tests/test_blueprints.py
@ -9,6 +9,8 @@
    :license: BSD, see LICENSE for more details.
 """

+import pytest
+
 import flask
 import unittest
 from tests import TestFlask
@ -55,9 +57,9 @@ class TestBlueprint(TestFlask):

        c = app.test_client()

-        self.assert_equal(c.get('/frontend-no').data, b'frontend says no')
-        self.assert_equal(c.get('/backend-no').data, b'backend says no')
-        self.assert_equal(c.get('/what-is-a-sideend').data, b'application itself says no')
+        assert c.get('/frontend-no').data == b'frontend says no'
+        assert c.get('/backend-no').data == b'backend says no'
+        assert c.get('/what-is-a-sideend').data == b'application itself says no'

    def test_blueprint_specific_user_error_handling(self):
        class MyDecoratorException(Exception):
@ -69,11 +71,11 @@ class TestBlueprint(TestFlask):

        @blue.errorhandler(MyDecoratorException)
        def my_decorator_exception_handler(e):
-            self.assert_true(isinstance(e, MyDecoratorException))
+            assert isinstance(e, MyDecoratorException)
            return 'boom'

        def my_function_exception_handler(e):
-            self.assert_true(isinstance(e, MyFunctionException))
+            assert isinstance(e, MyFunctionException)
            return 'bam'
        blue.register_error_handler(MyFunctionException, my_function_exception_handler)

@ -89,8 +91,8 @@ class TestBlueprint(TestFlask):

        c = app.test_client()

-        self.assert_equal(c.get('/decorator').data, b'boom')
-        self.assert_equal(c.get('/function').data, b'bam')
+        assert c.get('/decorator').data == b'boom'
+        assert c.get('/function').data == b'bam'

    def test_blueprint_url_definitions(self):
        bp = flask.Blueprint('test', __name__)
@ -108,10 +110,10 @@ class TestBlueprint(TestFlask):
        app.register_blueprint(bp, url_prefix='/2', url_defaults={'bar': 19})

        c = app.test_client()
-        self.assert_equal(c.get('/1/foo').data, b'23/42')
-        self.assert_equal(c.get('/2/foo').data, b'19/42')
-        self.assert_equal(c.get('/1/bar').data, b'23')
-        self.assert_equal(c.get('/2/bar').data, b'19')
+        assert c.get('/1/foo').data == b'23/42'
+        assert c.get('/2/foo').data == b'19/42'
+        assert c.get('/1/bar').data == b'23'
+        assert c.get('/2/bar').data == b'19'

    def test_blueprint_url_processors(self):
        bp = flask.Blueprint('frontend', __name__, url_prefix='/<lang_code>')
@ -137,24 +139,24 @@ class TestBlueprint(TestFlask):

        c = app.test_client()

-        self.assert_equal(c.get('/de/').data, b'/de/about')
-        self.assert_equal(c.get('/de/about').data, b'/de/')
+        assert c.get('/de/').data == b'/de/about'
+        assert c.get('/de/about').data == b'/de/'

    def test_templates_and_static(self):
        from blueprintapp import app
        c = app.test_client()

        rv = c.get('/')
-        self.assert_equal(rv.data, b'Hello from the Frontend')
+        assert rv.data == b'Hello from the Frontend'
        rv = c.get('/admin/')
-        self.assert_equal(rv.data, b'Hello from the Admin')
+        assert rv.data == b'Hello from the Admin'
        rv = c.get('/admin/index2')
-        self.assert_equal(rv.data, b'Hello from the Admin')
+        assert rv.data == b'Hello from the Admin'
        rv = c.get('/admin/static/test.txt')
-        self.assert_equal(rv.data.strip(), b'Admin File')
+        assert rv.data.strip() == b'Admin File'
        rv.close()
        rv = c.get('/admin/static/css/test.css')
-        self.assert_equal(rv.data.strip(), b'/* nested file */')
+        assert rv.data.strip() == b'/* nested file */'
        rv.close()

        # try/finally, in case other tests use this app for Blueprint tests.
@ -166,25 +168,24 @@ class TestBlueprint(TestFlask):
            app.config['SEND_FILE_MAX_AGE_DEFAULT'] = expected_max_age
            rv = c.get('/admin/static/css/test.css')
            cc = parse_cache_control_header(rv.headers['Cache-Control'])
-            self.assert_equal(cc.max_age, expected_max_age)
+            assert cc.max_age == expected_max_age
            rv.close()
        finally:
            app.config['SEND_FILE_MAX_AGE_DEFAULT'] = max_age_default

        with app.test_request_context():
-            self.assert_equal(flask.url_for('admin.static', filename='test.txt'),
-                              '/admin/static/test.txt')
+            assert flask.url_for('admin.static', filename='test.txt') == '/admin/static/test.txt'

        with app.test_request_context():
            try:
                flask.render_template('missing.html')
            except TemplateNotFound as e:
-                self.assert_equal(e.name, 'missing.html')
+                assert e.name == 'missing.html'
            else:
-                self.assert_true(0, 'expected exception')
+                assert 0, 'expected exception'

        with flask.Flask(__name__).test_request_context():
-            self.assert_equal(flask.render_template('nested/nested.txt'), 'I\'m nested')
+            assert flask.render_template('nested/nested.txt') == 'I\'m nested'

    def test_default_static_cache_timeout(self):
        app = flask.Flask(__name__)
@ -205,7 +206,7 @@ class TestBlueprint(TestFlask):
                app.config['SEND_FILE_MAX_AGE_DEFAULT'] = unexpected_max_age
                rv = blueprint.send_static_file('index.html')
                cc = parse_cache_control_header(rv.headers['Cache-Control'])
-                self.assert_equal(cc.max_age, 100)
+                assert cc.max_age == 100
                rv.close()
        finally:
            app.config['SEND_FILE_MAX_AGE_DEFAULT'] = max_age_default
@ -213,8 +214,7 @@ class TestBlueprint(TestFlask):
    def test_templates_list(self):
        from blueprintapp import app
        templates = sorted(app.jinja_env.list_templates())
-        self.assert_equal(templates, ['admin/index.html',
-                                     'frontend/index.html'])
+        assert templates == ['admin/index.html', 'frontend/index.html']

    def test_dotted_names(self):
        frontend = flask.Blueprint('myapp.frontend', __name__)
@ -237,9 +237,9 @@ class TestBlueprint(TestFlask):
        app.register_blueprint(backend)

        c = app.test_client()
-        self.assert_equal(c.get('/fe').data.strip(), b'/be')
-        self.assert_equal(c.get('/fe2').data.strip(), b'/fe')
-        self.assert_equal(c.get('/be').data.strip(), b'/fe')
+        assert c.get('/fe').data.strip() == b'/be'
+        assert c.get('/fe2').data.strip() == b'/fe'
+        assert c.get('/be').data.strip() == b'/fe'

    def test_dotted_names_from_app(self):
        app = flask.Flask(__name__)
@ -258,7 +258,7 @@ class TestBlueprint(TestFlask):

        with app.test_client() as c:
            rv = c.get('/')
-            self.assert_equal(rv.data, b'/test/')
+            assert rv.data == b'/test/'

    def test_empty_url_defaults(self):
        bp = flask.Blueprint('bp', __name__)
@ -272,8 +272,8 @@ class TestBlueprint(TestFlask):
        app.register_blueprint(bp)

        c = app.test_client()
-        self.assert_equal(c.get('/').data, b'1')
-        self.assert_equal(c.get('/page/2').data, b'2')
+        assert c.get('/').data == b'1'
+        assert c.get('/page/2').data == b'2'

    def test_route_decorator_custom_endpoint(self):

@ -303,11 +303,11 @@ class TestBlueprint(TestFlask):
            return flask.request.endpoint

        c = app.test_client()
-        self.assert_equal(c.get('/').data, b'index')
-        self.assert_equal(c.get('/py/foo').data, b'bp.foo')
-        self.assert_equal(c.get('/py/bar').data, b'bp.bar')
-        self.assert_equal(c.get('/py/bar/123').data, b'bp.123')
-        self.assert_equal(c.get('/py/bar/foo').data, b'bp.bar_foo')
+        assert c.get('/').data == b'index'
+        assert c.get('/py/foo').data == b'bp.foo'
+        assert c.get('/py/bar').data == b'bp.bar'
+        assert c.get('/py/bar/123').data == b'bp.123'
+        assert c.get('/py/bar/foo').data == b'bp.bar_foo'

    def test_route_decorator_custom_endpoint_with_dots(self):
        bp = flask.Blueprint('bp', __name__)
@ -337,14 +337,14 @@ class TestBlueprint(TestFlask):
        def foo_foo_foo():
            pass

-        self.assert_raises(
+        pytest.raises(
            AssertionError,
            lambda: bp.add_url_rule(
                '/bar/123', endpoint='bar.123', view_func=foo_foo_foo
            )
        )

-        self.assert_raises(
+        pytest.raises(
            AssertionError,
            bp.route('/bar/123', endpoint='bar.123'),
            lambda: None
@ -354,7 +354,7 @@ class TestBlueprint(TestFlask):
        app.register_blueprint(bp, url_prefix='/py')

        c = app.test_client()
-        self.assert_equal(c.get('/py/foo').data, b'bp.foo')
+        assert c.get('/py/foo').data == b'bp.foo'
        # The rule's didn't actually made it through
        rv = c.get('/py/bar')
        assert rv.status_code == 404
@ -368,9 +368,9 @@ class TestBlueprint(TestFlask):
            return s[::-1]
        app = flask.Flask(__name__)
        app.register_blueprint(bp, url_prefix='/py')
-        self.assert_in('my_reverse', app.jinja_env.filters.keys())
-        self.assert_equal(app.jinja_env.filters['my_reverse'], my_reverse)
-        self.assert_equal(app.jinja_env.filters['my_reverse']('abcd'), 'dcba')
+        assert 'my_reverse' in app.jinja_env.filters.keys()
+        assert app.jinja_env.filters['my_reverse'] == my_reverse
+        assert app.jinja_env.filters['my_reverse']('abcd') == 'dcba'

    def test_add_template_filter(self):
        bp = flask.Blueprint('bp', __name__)
@ -379,9 +379,9 @@ class TestBlueprint(TestFlask):
        bp.add_app_template_filter(my_reverse)
        app = flask.Flask(__name__)
        app.register_blueprint(bp, url_prefix='/py')
-        self.assert_in('my_reverse', app.jinja_env.filters.keys())
-        self.assert_equal(app.jinja_env.filters['my_reverse'], my_reverse)
-        self.assert_equal(app.jinja_env.filters['my_reverse']('abcd'), 'dcba')
+        assert 'my_reverse' in app.jinja_env.filters.keys()
+        assert app.jinja_env.filters['my_reverse'] == my_reverse
+        assert app.jinja_env.filters['my_reverse']('abcd') == 'dcba'

    def test_template_filter_with_name(self):
        bp = flask.Blueprint('bp', __name__)
@ -390,9 +390,9 @@ class TestBlueprint(TestFlask):
            return s[::-1]
        app = flask.Flask(__name__)
        app.register_blueprint(bp, url_prefix='/py')
-        self.assert_in('strrev', app.jinja_env.filters.keys())
-        self.assert_equal(app.jinja_env.filters['strrev'], my_reverse)
-        self.assert_equal(app.jinja_env.filters['strrev']('abcd'), 'dcba')
+        assert 'strrev' in app.jinja_env.filters.keys()
+        assert app.jinja_env.filters['strrev'] == my_reverse
+        assert app.jinja_env.filters['strrev']('abcd') == 'dcba'

    def test_add_template_filter_with_name(self):
        bp = flask.Blueprint('bp', __name__)
@ -401,9 +401,9 @@ class TestBlueprint(TestFlask):
        bp.add_app_template_filter(my_reverse, 'strrev')
        app = flask.Flask(__name__)
        app.register_blueprint(bp, url_prefix='/py')
-        self.assert_in('strrev', app.jinja_env.filters.keys())
-        self.assert_equal(app.jinja_env.filters['strrev'], my_reverse)
-        self.assert_equal(app.jinja_env.filters['strrev']('abcd'), 'dcba')
+        assert 'strrev' in app.jinja_env.filters.keys()
+        assert app.jinja_env.filters['strrev'] == my_reverse
+        assert app.jinja_env.filters['strrev']('abcd') == 'dcba'

    def test_template_filter_with_template(self):
        bp = flask.Blueprint('bp', __name__)
@ -416,7 +416,7 @@ class TestBlueprint(TestFlask):
        def index():
            return flask.render_template('template_filter.html', value='abcd')
        rv = app.test_client().get('/')
-        self.assert_equal(rv.data, b'dcba')
+        assert rv.data == b'dcba'

    def test_template_filter_after_route_with_template(self):
        app = flask.Flask(__name__)
@ -429,7 +429,7 @@ class TestBlueprint(TestFlask):
            return s[::-1]
        app.register_blueprint(bp, url_prefix='/py')
        rv = app.test_client().get('/')
-        self.assert_equal(rv.data, b'dcba')
+        assert rv.data == b'dcba'

    def test_add_template_filter_with_template(self):
        bp = flask.Blueprint('bp', __name__)
@ -442,7 +442,7 @@ class TestBlueprint(TestFlask):
        def index():
            return flask.render_template('template_filter.html', value='abcd')
        rv = app.test_client().get('/')
-        self.assert_equal(rv.data, b'dcba')
+        assert rv.data == b'dcba'

    def test_template_filter_with_name_and_template(self):
        bp = flask.Blueprint('bp', __name__)
@ -455,7 +455,7 @@ class TestBlueprint(TestFlask):
        def index():
            return flask.render_template('template_filter.html', value='abcd')
        rv = app.test_client().get('/')
-        self.assert_equal(rv.data, b'dcba')
+        assert rv.data == b'dcba'

    def test_add_template_filter_with_name_and_template(self):
        bp = flask.Blueprint('bp', __name__)
@ -468,7 +468,7 @@ class TestBlueprint(TestFlask):
        def index():
            return flask.render_template('template_filter.html', value='abcd')
        rv = app.test_client().get('/')
-        self.assert_equal(rv.data, b'dcba')
+        assert rv.data == b'dcba'

    def test_template_test(self):
        bp = flask.Blueprint('bp', __name__)
@ -477,9 +477,9 @@ class TestBlueprint(TestFlask):
            return isinstance(value, bool)
        app = flask.Flask(__name__)
        app.register_blueprint(bp, url_prefix='/py')
-        self.assert_in('is_boolean', app.jinja_env.tests.keys())
-        self.assert_equal(app.jinja_env.tests['is_boolean'], is_boolean)
-        self.assert_true(app.jinja_env.tests['is_boolean'](False))
+        assert 'is_boolean' in app.jinja_env.tests.keys()
+        assert app.jinja_env.tests['is_boolean'] == is_boolean
+        assert app.jinja_env.tests['is_boolean'](False)

    def test_add_template_test(self):
        bp = flask.Blueprint('bp', __name__)
@ -488,9 +488,9 @@ class TestBlueprint(TestFlask):
        bp.add_app_template_test(is_boolean)
        app = flask.Flask(__name__)
        app.register_blueprint(bp, url_prefix='/py')
-        self.assert_in('is_boolean', app.jinja_env.tests.keys())
-        self.assert_equal(app.jinja_env.tests['is_boolean'], is_boolean)
-        self.assert_true(app.jinja_env.tests['is_boolean'](False))
+        assert 'is_boolean' in app.jinja_env.tests.keys()
+        assert app.jinja_env.tests['is_boolean'] == is_boolean
+        assert app.jinja_env.tests['is_boolean'](False)

    def test_template_test_with_name(self):
        bp = flask.Blueprint('bp', __name__)
@ -499,9 +499,9 @@ class TestBlueprint(TestFlask):
            return isinstance(value, bool)
        app = flask.Flask(__name__)
        app.register_blueprint(bp, url_prefix='/py')
-        self.assert_in('boolean', app.jinja_env.tests.keys())
-        self.assert_equal(app.jinja_env.tests['boolean'], is_boolean)
-        self.assert_true(app.jinja_env.tests['boolean'](False))
+        assert 'boolean' in app.jinja_env.tests.keys()
+        assert app.jinja_env.tests['boolean'] == is_boolean
+        assert app.jinja_env.tests['boolean'](False)

    def test_add_template_test_with_name(self):
        bp = flask.Blueprint('bp', __name__)
@ -510,9 +510,9 @@ class TestBlueprint(TestFlask):
        bp.add_app_template_test(is_boolean, 'boolean')
        app = flask.Flask(__name__)
        app.register_blueprint(bp, url_prefix='/py')
-        self.assert_in('boolean', app.jinja_env.tests.keys())
-        self.assert_equal(app.jinja_env.tests['boolean'], is_boolean)
-        self.assert_true(app.jinja_env.tests['boolean'](False))
+        assert 'boolean' in app.jinja_env.tests.keys()
+        assert app.jinja_env.tests['boolean'] == is_boolean
+        assert app.jinja_env.tests['boolean'](False)

    def test_template_test_with_template(self):
        bp = flask.Blueprint('bp', __name__)
@ -525,7 +525,7 @@ class TestBlueprint(TestFlask):
        def index():
            return flask.render_template('template_test.html', value=False)
        rv = app.test_client().get('/')
-        self.assert_in(b'Success!', rv.data)
+        assert b'Success!' in rv.data

    def test_template_test_after_route_with_template(self):
        app = flask.Flask(__name__)
@ -538,7 +538,7 @@ class TestBlueprint(TestFlask):
            return isinstance(value, bool)
        app.register_blueprint(bp, url_prefix='/py')
        rv = app.test_client().get('/')
-        self.assert_in(b'Success!', rv.data)
+        assert b'Success!' in rv.data

    def test_add_template_test_with_template(self):
        bp = flask.Blueprint('bp', __name__)
@ -551,7 +551,7 @@ class TestBlueprint(TestFlask):
        def index():
            return flask.render_template('template_test.html', value=False)
        rv = app.test_client().get('/')
-        self.assert_in(b'Success!', rv.data)
+        assert b'Success!' in rv.data

    def test_template_test_with_name_and_template(self):
        bp = flask.Blueprint('bp', __name__)
@ -564,7 +564,7 @@ class TestBlueprint(TestFlask):
        def index():
            return flask.render_template('template_test.html', value=False)
        rv = app.test_client().get('/')
-        self.assert_in(b'Success!', rv.data)
+        assert b'Success!' in rv.data

    def test_add_template_test_with_name_and_template(self):
        bp = flask.Blueprint('bp', __name__)
@ -577,7 +577,7 @@ class TestBlueprint(TestFlask):
        def index():
            return flask.render_template('template_test.html', value=False)
        rv = app.test_client().get('/')
-        self.assert_in(b'Success!', rv.data)
+        assert b'Success!' in rv.data

 def suite():
    suite = unittest.TestSuite()
--- a/tests/test_config.py
+++ b/tests/test_config.py
@ -30,9 +30,9 @@ SECRET_KEY = 'devkey'
 class TestConfig(TestFlask):

    def common_object_test(self, app):
-        self.assert_equal(app.secret_key, 'devkey')
-        self.assert_equal(app.config['TEST_KEY'], 'foo')
-        self.assert_not_in('TestConfig', app.config)
+        assert app.secret_key == 'devkey'
+        assert app.config['TEST_KEY'] == 'foo'
+        assert 'TestConfig' not in app.config

    def test_config_from_file(self):
        app = flask.Flask(__name__)
@ -73,7 +73,7 @@ class TestConfig(TestFlask):
        self.common_object_test(app)

        app = flask.Flask(__name__)
-        with self.assert_raises(TypeError):
+        with pytest.raises(TypeError):
            app.config.from_mapping(
                {}, {}
            )
@ -95,13 +95,13 @@ class TestConfig(TestFlask):
            try:
                app.config.from_envvar('FOO_SETTINGS')
            except RuntimeError as e:
-                self.assert_true("'FOO_SETTINGS' is not set" in str(e))
+                assert "'FOO_SETTINGS' is not set" in str(e)
            else:
-                self.assert_true(0, 'expected exception')
-            self.assert_false(app.config.from_envvar('FOO_SETTINGS', silent=True))
+                assert 0, 'expected exception'
+            assert not app.config.from_envvar('FOO_SETTINGS', silent=True)

            os.environ = {'FOO_SETTINGS': __file__.rsplit('.', 1)[0] + '.py'}
-            self.assert_true(app.config.from_envvar('FOO_SETTINGS'))
+            assert app.config.from_envvar('FOO_SETTINGS')
            self.common_object_test(app)
        finally:
            os.environ = env
@ -115,12 +115,12 @@ class TestConfig(TestFlask):
                app.config.from_envvar('FOO_SETTINGS')
            except IOError as e:
                msg = str(e)
-                self.assert_true(msg.startswith('[Errno 2] Unable to load configuration '
-                                            'file (No such file or directory):'))
-                self.assert_true(msg.endswith("missing.cfg'"))
+                assert msg.startswith('[Errno 2] Unable to load configuration '
+                                      'file (No such file or directory):')
+                assert msg.endswith("missing.cfg'")
            else:
-                self.fail('expected IOError')
-            self.assert_false(app.config.from_envvar('FOO_SETTINGS', silent=True))
+                assert False, 'expected IOError'
+            assert not app.config.from_envvar('FOO_SETTINGS', silent=True)
        finally:
            os.environ = env

@ -130,12 +130,12 @@ class TestConfig(TestFlask):
            app.config.from_pyfile('missing.cfg')
        except IOError as e:
            msg = str(e)
-            self.assert_true(msg.startswith('[Errno 2] Unable to load configuration '
-                                        'file (No such file or directory):'))
-            self.assert_true(msg.endswith("missing.cfg'"))
+            assert msg.startswith('[Errno 2] Unable to load configuration '
+                                  'file (No such file or directory):')
+            assert msg.endswith("missing.cfg'")
        else:
-            self.assert_true(0, 'expected config')
-        self.assert_false(app.config.from_pyfile('missing.cfg', silent=True))
+            assert 0, 'expected config'
+        assert not app.config.from_pyfile('missing.cfg', silent=True)

    def test_config_missing_json(self):
        app = flask.Flask(__name__)
@ -143,12 +143,12 @@ class TestConfig(TestFlask):
            app.config.from_json('missing.json')
        except IOError as e:
            msg = str(e)
-            self.assert_true(msg.startswith('[Errno 2] Unable to load configuration '
-                                            'file (No such file or directory):'))
-            self.assert_true(msg.endswith("missing.json'"))
+            assert msg.startswith('[Errno 2] Unable to load configuration '
+                                  'file (No such file or directory):')
+            assert msg.endswith("missing.json'")
        else:
-            self.assert_true(0, 'expected config')
-        self.assert_false(app.config.from_json('missing.json', silent=True))
+            assert 0, 'expected config'
+        assert not app.config.from_json('missing.json', silent=True)

    def test_custom_config_class(self):
        class Config(flask.Config):
@ -156,14 +156,14 @@ class TestConfig(TestFlask):
        class Flask(flask.Flask):
            config_class = Config
        app = Flask(__name__)
-        self.assert_isinstance(app.config, Config)
+        assert isinstance(app.config, Config)
        app.config.from_object(__name__)
        self.common_object_test(app)

    def test_session_lifetime(self):
        app = flask.Flask(__name__)
        app.config['PERMANENT_SESSION_LIFETIME'] = 42
-        self.assert_equal(app.permanent_session_lifetime.seconds, 42)
+        assert app.permanent_session_lifetime.seconds == 42

    def test_get_namespace(self):
        app = flask.Flask(__name__)
@ -172,13 +172,13 @@ class TestConfig(TestFlask):
        app.config['BAR_STUFF_1'] = 'bar stuff 1'
        app.config['BAR_STUFF_2'] = 'bar stuff 2'
        foo_options = app.config.get_namespace('FOO_')
-        self.assert_equal(2, len(foo_options))
-        self.assert_equal('foo option 1', foo_options['option_1'])
-        self.assert_equal('foo option 2', foo_options['option_2'])
+        assert 2 == len(foo_options)
+        assert 'foo option 1' == foo_options['option_1']
+        assert 'foo option 2' == foo_options['option_2']
        bar_options = app.config.get_namespace('BAR_', lowercase=False)
-        self.assert_equal(2, len(bar_options))
-        self.assert_equal('bar stuff 1', bar_options['STUFF_1'])
-        self.assert_equal('bar stuff 2', bar_options['STUFF_2'])
+        assert 2 == len(bar_options)
+        assert 'bar stuff 1' == bar_options['STUFF_1']
+        assert 'bar stuff 2' == bar_options['STUFF_2']


 class TestInstance(TestFlask):
@ -188,7 +188,7 @@ class TestInstance(TestFlask):
        assert 'must be absolute' in str(excinfo.value)

        app = flask.Flask(__name__, instance_path=str(apps_tmpdir))
-        self.assert_equal(app.instance_path, str(apps_tmpdir))
+        assert app.instance_path == str(apps_tmpdir)

    def test_main_module_paths(self, apps_tmpdir, purge_module):
        app = apps_tmpdir.join('main_app.py')
@ -285,7 +285,7 @@ class TestInstance(TestFlask):
                    return self
            sys.meta_path.append(Loader())
            try:
-                with self.assert_raises(AttributeError):
+                with pytest.raises(AttributeError):
                    flask.Flask(__name__)
            finally:
                sys.meta_path.pop()
--- a/tests/test_ext.py
+++ b/tests/test_ext.py
@ -11,6 +11,8 @@

 import sys
 import unittest
+import pytest
+
 try:
    from imp import reload as reload_module
 except ImportError:
@ -41,70 +43,70 @@ class TestExtImportHook(TestFlask):
            if cls.__module__ == 'flask.exthook' and \
               cls.__name__ == 'ExtensionImporter':
                import_hooks += 1
-        self.assert_equal(import_hooks, 1)
+        assert import_hooks == 1

    def teardown(self):
        from flask import ext
        for key in ext.__dict__:
-            self.assert_not_in('.', key)
+            assert '.' not in key

    def test_flaskext_new_simple_import_normal(self):
        from flask.ext.newext_simple import ext_id
-        self.assert_equal(ext_id, 'newext_simple')
+        assert ext_id == 'newext_simple'

    def test_flaskext_new_simple_import_module(self):
        from flask.ext import newext_simple
-        self.assert_equal(newext_simple.ext_id, 'newext_simple')
-        self.assert_equal(newext_simple.__name__, 'flask_newext_simple')
+        assert newext_simple.ext_id == 'newext_simple'
+        assert newext_simple.__name__ == 'flask_newext_simple'

    def test_flaskext_new_package_import_normal(self):
        from flask.ext.newext_package import ext_id
-        self.assert_equal(ext_id, 'newext_package')
+        assert ext_id == 'newext_package'

    def test_flaskext_new_package_import_module(self):
        from flask.ext import newext_package
-        self.assert_equal(newext_package.ext_id, 'newext_package')
-        self.assert_equal(newext_package.__name__, 'flask_newext_package')
+        assert newext_package.ext_id == 'newext_package'
+        assert newext_package.__name__ == 'flask_newext_package'

    def test_flaskext_new_package_import_submodule_function(self):
        from flask.ext.newext_package.submodule import test_function
-        self.assert_equal(test_function(), 42)
+        assert test_function() == 42

    def test_flaskext_new_package_import_submodule(self):
        from flask.ext.newext_package import submodule
-        self.assert_equal(submodule.__name__, 'flask_newext_package.submodule')
-        self.assert_equal(submodule.test_function(), 42)
+        assert submodule.__name__ == 'flask_newext_package.submodule'
+        assert submodule.test_function() == 42

    def test_flaskext_old_simple_import_normal(self):
        from flask.ext.oldext_simple import ext_id
-        self.assert_equal(ext_id, 'oldext_simple')
+        assert ext_id == 'oldext_simple'

    def test_flaskext_old_simple_import_module(self):
        from flask.ext import oldext_simple
-        self.assert_equal(oldext_simple.ext_id, 'oldext_simple')
-        self.assert_equal(oldext_simple.__name__, 'flaskext.oldext_simple')
+        assert oldext_simple.ext_id == 'oldext_simple'
+        assert oldext_simple.__name__ == 'flaskext.oldext_simple'

    def test_flaskext_old_package_import_normal(self):
        from flask.ext.oldext_package import ext_id
-        self.assert_equal(ext_id, 'oldext_package')
+        assert ext_id == 'oldext_package'

    def test_flaskext_old_package_import_module(self):
        from flask.ext import oldext_package
-        self.assert_equal(oldext_package.ext_id, 'oldext_package')
-        self.assert_equal(oldext_package.__name__, 'flaskext.oldext_package')
+        assert oldext_package.ext_id == 'oldext_package'
+        assert oldext_package.__name__ == 'flaskext.oldext_package'

    def test_flaskext_old_package_import_submodule(self):
        from flask.ext.oldext_package import submodule
-        self.assert_equal(submodule.__name__, 'flaskext.oldext_package.submodule')
-        self.assert_equal(submodule.test_function(), 42)
+        assert submodule.__name__ == 'flaskext.oldext_package.submodule'
+        assert submodule.test_function() == 42

    def test_flaskext_old_package_import_submodule_function(self):
        from flask.ext.oldext_package.submodule import test_function
-        self.assert_equal(test_function(), 42)
+        assert test_function() == 42

    def test_flaskext_broken_package_no_module_caching(self):
        for x in range(2):
-            with self.assert_raises(ImportError):
+            with pytest.raises(ImportError):
                import flask.ext.broken

    def test_no_error_swallowing(self):
@ -112,13 +114,13 @@ class TestExtImportHook(TestFlask):
            import flask.ext.broken
        except ImportError:
            exc_type, exc_value, tb = sys.exc_info()
-            self.assert_true(exc_type is ImportError)
+            assert exc_type is ImportError
            if PY2:
                message = 'No module named missing_module'
            else:
                message = 'No module named \'missing_module\''
-            self.assert_equal(str(exc_value), message)
-            self.assert_true(tb.tb_frame.f_globals is globals())
+            assert str(exc_value) == message
+            assert tb.tb_frame.f_globals is globals()

            # reraise() adds a second frame so we need to skip that one too.
            # On PY3 we even have another one :(
@ -127,7 +129,8 @@ class TestExtImportHook(TestFlask):
                next = next.tb_next
            
            import os.path
-            self.assert_in(os.path.join('flask_broken', '__init__.py'), next.tb_frame.f_code.co_filename)
+            assert os.path.join('flask_broken', '__init__.py') in \
+                next.tb_frame.f_code.co_filename


 def suite():
--- a/tests/test_helpers.py
+++ b/tests/test_helpers.py
@ -9,6 +9,8 @@
    :license: BSD, see LICENSE for more details.
 """

+import pytest
+
 import os
 import flask
 import unittest
@ -36,7 +38,7 @@ class TestJSON(TestFlask):
            return flask.jsonify(foo=text_type(flask.request.get_json()))
        c = app.test_client()
        rv = c.post('/json', data='malformed', content_type='application/json')
-        self.assert_equal(rv.status_code, 400)
+        assert rv.status_code == 400

    def test_json_custom_mimetypes(self):
        app = flask.Flask(__name__)
@ -45,7 +47,7 @@ class TestJSON(TestFlask):
            return flask.request.get_json()
        c = app.test_client()
        rv = c.post('/json', data='"foo"', content_type='application/x+json')
-        self.assert_equal(rv.data, b'foo')
+        assert rv.data == b'foo'

    def test_json_body_encoding(self):
        app = flask.Flask(__name__)
@ -57,7 +59,7 @@ class TestJSON(TestFlask):
        c = app.test_client()
        resp = c.get('/', data=u'"Hällo Wörld"'.encode('iso-8859-15'),
                     content_type='application/json; charset=iso-8859-15')
-        self.assert_equal(resp.data, u'Hällo Wörld'.encode('utf-8'))
+        assert resp.data == u'Hällo Wörld'.encode('utf-8')

    def test_jsonify(self):
        d = dict(a=23, b=42, c=[1, 2, 3])
@ -71,8 +73,8 @@ class TestJSON(TestFlask):
        c = app.test_client()
        for url in '/kw', '/dict':
            rv = c.get(url)
-            self.assert_equal(rv.mimetype, 'application/json')
-            self.assert_equal(flask.json.loads(rv.data), d)
+            assert rv.mimetype == 'application/json'
+            assert flask.json.loads(rv.data) == d

    def test_json_as_unicode(self):
        app = flask.Flask(__name__)
@ -80,12 +82,12 @@ class TestJSON(TestFlask):
        app.config['JSON_AS_ASCII'] = True
        with app.app_context():
            rv = flask.json.dumps(u'\N{SNOWMAN}')
-            self.assert_equal(rv, '"\\u2603"')
+            assert rv == '"\\u2603"'

        app.config['JSON_AS_ASCII'] = False
        with app.app_context():
            rv = flask.json.dumps(u'\N{SNOWMAN}')
-            self.assert_equal(rv, u'"\u2603"')
+            assert rv == u'"\u2603"'

    def test_json_attr(self):
        app = flask.Flask(__name__)
@ -96,29 +98,28 @@ class TestJSON(TestFlask):
        c = app.test_client()
        rv = c.post('/add', data=flask.json.dumps({'a': 1, 'b': 2}),
                            content_type='application/json')
-        self.assert_equal(rv.data, b'3')
+        assert rv.data == b'3'

    def test_template_escaping(self):
        app = flask.Flask(__name__)
        render = flask.render_template_string
        with app.test_request_context():
            rv = flask.json.htmlsafe_dumps('</script>')
-            self.assert_equal(rv, u'"\\u003c/script\\u003e"')
-            self.assert_equal(type(rv), text_type)
+            assert rv == u'"\\u003c/script\\u003e"'
+            assert type(rv) == text_type
            rv = render('{{ "</script>"|tojson }}')
-            self.assert_equal(rv, '"\\u003c/script\\u003e"')
+            assert rv == '"\\u003c/script\\u003e"'
            rv = render('{{ "<\0/script>"|tojson }}')
-            self.assert_equal(rv, '"\\u003c\\u0000/script\\u003e"')
+            assert rv == '"\\u003c\\u0000/script\\u003e"'
            rv = render('{{ "<!--<script>"|tojson }}')
-            self.assert_equal(rv, '"\\u003c!--\\u003cscript\\u003e"')
+            assert rv == '"\\u003c!--\\u003cscript\\u003e"'
            rv = render('{{ "&"|tojson }}')
-            self.assert_equal(rv, '"\\u0026"')
+            assert rv == '"\\u0026"'
            rv = render('{{ "\'"|tojson }}')
-            self.assert_equal(rv, '"\\u0027"')
+            assert rv == '"\\u0027"'
            rv = render("<a ng-data='{{ data|tojson }}'></a>",
                data={'x': ["foo", "bar", "baz'"]})
-            self.assert_equal(rv,
-                '<a ng-data=\'{"x": ["foo", "bar", "baz\\u0027"]}\'></a>')
+            assert rv == '<a ng-data=\'{"x": ["foo", "bar", "baz\\u0027"]}\'></a>'

    def test_json_customization(self):
        class X(object):
@ -148,7 +149,7 @@ class TestJSON(TestFlask):
        rv = c.post('/', data=flask.json.dumps({
            'x': {'_foo': 42}
        }), content_type='application/json')
-        self.assert_equal(rv.data, b'"<42>"')
+        assert rv.data == b'"<42>"'

    def test_modified_url_encoding(self):
        class ModifiedRequest(flask.Request):
@ -163,8 +164,8 @@ class TestJSON(TestFlask):
            return flask.request.args['foo']

        rv = app.test_client().get(u'/?foo=정상처리'.encode('euc-kr'))
-        self.assert_equal(rv.status_code, 200)
-        self.assert_equal(rv.data, u'정상처리'.encode('utf-8'))
+        assert rv.status_code == 200
+        assert rv.data == u'정상처리'.encode('utf-8')

    if not has_encoding('euc-kr'):
        test_modified_url_encoding = None
@ -172,7 +173,7 @@ class TestJSON(TestFlask):
    def test_json_key_sorting(self):
        app = flask.Flask(__name__)
        app.testing = True
-        self.assert_equal(app.config['JSON_SORT_KEYS'], True)
+        assert app.config['JSON_SORT_KEYS'] == True
        d = dict.fromkeys(range(20), 'foo')

        @app.route('/')
@ -236,9 +237,9 @@ class TestJSON(TestFlask):
        ]

        try:
-            self.assert_equal(lines, sorted_by_int)
+            assert lines == sorted_by_int
        except AssertionError:
-            self.assert_equal(lines, sorted_by_str)
+            assert lines == sorted_by_str

 class TestSendfile(TestFlask):

@ -246,11 +247,11 @@ class TestSendfile(TestFlask):
        app = flask.Flask(__name__)
        with app.test_request_context():
            rv = flask.send_file('static/index.html')
-            self.assert_true(rv.direct_passthrough)
-            self.assert_equal(rv.mimetype, 'text/html')
+            assert rv.direct_passthrough
+            assert rv.mimetype == 'text/html'
            with app.open_resource('static/index.html') as f:
                rv.direct_passthrough = False
-                self.assert_equal(rv.data, f.read())
+                assert rv.data == f.read()
            rv.close()

    def test_send_file_xsendfile(self):
@ -258,11 +259,11 @@ class TestSendfile(TestFlask):
        app.use_x_sendfile = True
        with app.test_request_context():
            rv = flask.send_file('static/index.html')
-            self.assert_true(rv.direct_passthrough)
-            self.assert_in('x-sendfile', rv.headers)
-            self.assert_equal(rv.headers['x-sendfile'],
-                os.path.join(app.root_path, 'static/index.html'))
-            self.assert_equal(rv.mimetype, 'text/html')
+            assert rv.direct_passthrough
+            assert 'x-sendfile' in rv.headers
+            assert rv.headers['x-sendfile'] == \
+                os.path.join(app.root_path, 'static/index.html')
+            assert rv.mimetype == 'text/html'
            rv.close()

    def test_send_file_object(self):
@ -273,24 +274,24 @@ class TestSendfile(TestFlask):
                rv = flask.send_file(f)
                rv.direct_passthrough = False
                with app.open_resource('static/index.html') as f:
-                    self.assert_equal(rv.data, f.read())
-                self.assert_equal(rv.mimetype, 'text/html')
+                    assert rv.data == f.read()
+                assert rv.mimetype == 'text/html'
                rv.close()
            # mimetypes + etag
-            self.assert_equal(len(captured), 2)
+            assert len(captured) == 2

        app.use_x_sendfile = True
        with catch_warnings() as captured:
            with app.test_request_context():
                f = open(os.path.join(app.root_path, 'static/index.html'))
                rv = flask.send_file(f)
-                self.assert_equal(rv.mimetype, 'text/html')
-                self.assert_in('x-sendfile', rv.headers)
-                self.assert_equal(rv.headers['x-sendfile'],
-                    os.path.join(app.root_path, 'static/index.html'))
+                assert rv.mimetype == 'text/html'
+                assert 'x-sendfile' in rv.headers
+                assert rv.headers['x-sendfile'] == \
+                    os.path.join(app.root_path, 'static/index.html')
                rv.close()
            # mimetypes + etag
-            self.assert_equal(len(captured), 2)
+            assert len(captured) == 2

        app.use_x_sendfile = False
        with app.test_request_context():
@ -298,11 +299,11 @@ class TestSendfile(TestFlask):
                f = StringIO('Test')
                rv = flask.send_file(f)
                rv.direct_passthrough = False
-                self.assert_equal(rv.data, b'Test')
-                self.assert_equal(rv.mimetype, 'application/octet-stream')
+                assert rv.data == b'Test'
+                assert rv.mimetype == 'application/octet-stream'
                rv.close()
            # etags
-            self.assert_equal(len(captured), 1)
+            assert len(captured) == 1
            with catch_warnings() as captured:
                class PyStringIO(object):
                    def __init__(self, *args, **kwargs):
@ -313,30 +314,30 @@ class TestSendfile(TestFlask):
                f.name = 'test.txt'
                rv = flask.send_file(f)
                rv.direct_passthrough = False
-                self.assert_equal(rv.data, b'Test')
-                self.assert_equal(rv.mimetype, 'text/plain')
+                assert rv.data == b'Test'
+                assert rv.mimetype == 'text/plain'
                rv.close()
            # attachment_filename and etags
-            self.assert_equal(len(captured), 3)
+            assert len(captured) == 3
            with catch_warnings() as captured:
                f = StringIO('Test')
                rv = flask.send_file(f, mimetype='text/plain')
                rv.direct_passthrough = False
-                self.assert_equal(rv.data, b'Test')
-                self.assert_equal(rv.mimetype, 'text/plain')
+                assert rv.data == b'Test'
+                assert rv.mimetype == 'text/plain'
                rv.close()
            # etags
-            self.assert_equal(len(captured), 1)
+            assert len(captured) == 1

        app.use_x_sendfile = True
        with catch_warnings() as captured:
            with app.test_request_context():
                f = StringIO('Test')
                rv = flask.send_file(f)
-                self.assert_not_in('x-sendfile', rv.headers)
+                assert 'x-sendfile' not in rv.headers
                rv.close()
            # etags
-            self.assert_equal(len(captured), 1)
+            assert len(captured) == 1

    def test_attachment(self):
        app = flask.Flask(__name__)
@ -345,27 +346,27 @@ class TestSendfile(TestFlask):
                f = open(os.path.join(app.root_path, 'static/index.html'))
                rv = flask.send_file(f, as_attachment=True)
                value, options = parse_options_header(rv.headers['Content-Disposition'])
-                self.assert_equal(value, 'attachment')
+                assert value == 'attachment'
                rv.close()
            # mimetypes + etag
-            self.assert_equal(len(captured), 2)
+            assert len(captured) == 2

        with app.test_request_context():
-            self.assert_equal(options['filename'], 'index.html')
+            assert options['filename'] == 'index.html'
            rv = flask.send_file('static/index.html', as_attachment=True)
            value, options = parse_options_header(rv.headers['Content-Disposition'])
-            self.assert_equal(value, 'attachment')
-            self.assert_equal(options['filename'], 'index.html')
+            assert value == 'attachment'
+            assert options['filename'] == 'index.html'
            rv.close()

        with app.test_request_context():
            rv = flask.send_file(StringIO('Test'), as_attachment=True,
                                 attachment_filename='index.txt',
                                 add_etags=False)
-            self.assert_equal(rv.mimetype, 'text/plain')
+            assert rv.mimetype == 'text/plain'
            value, options = parse_options_header(rv.headers['Content-Disposition'])
-            self.assert_equal(value, 'attachment')
-            self.assert_equal(options['filename'], 'index.txt')
+            assert value == 'attachment'
+            assert options['filename'] == 'index.txt'
            rv.close()

    def test_static_file(self):
@ -375,24 +376,24 @@ class TestSendfile(TestFlask):
            # Test with static file handler.
            rv = app.send_static_file('index.html')
            cc = parse_cache_control_header(rv.headers['Cache-Control'])
-            self.assert_equal(cc.max_age, 12 * 60 * 60)
+            assert cc.max_age == 12 * 60 * 60
            rv.close()
            # Test again with direct use of send_file utility.
            rv = flask.send_file('static/index.html')
            cc = parse_cache_control_header(rv.headers['Cache-Control'])
-            self.assert_equal(cc.max_age, 12 * 60 * 60)
+            assert cc.max_age == 12 * 60 * 60
            rv.close()
        app.config['SEND_FILE_MAX_AGE_DEFAULT'] = 3600
        with app.test_request_context():
            # Test with static file handler.
            rv = app.send_static_file('index.html')
            cc = parse_cache_control_header(rv.headers['Cache-Control'])
-            self.assert_equal(cc.max_age, 3600)
+            assert cc.max_age == 3600
            rv.close()
            # Test again with direct use of send_file utility.
            rv = flask.send_file('static/index.html')
            cc = parse_cache_control_header(rv.headers['Cache-Control'])
-            self.assert_equal(cc.max_age, 3600)
+            assert cc.max_age == 3600
            rv.close()
        class StaticFileApp(flask.Flask):
            def get_send_file_max_age(self, filename):
@ -402,12 +403,12 @@ class TestSendfile(TestFlask):
            # Test with static file handler.
            rv = app.send_static_file('index.html')
            cc = parse_cache_control_header(rv.headers['Cache-Control'])
-            self.assert_equal(cc.max_age, 10)
+            assert cc.max_age == 10
            rv.close()
            # Test again with direct use of send_file utility.
            rv = flask.send_file('static/index.html')
            cc = parse_cache_control_header(rv.headers['Cache-Control'])
-            self.assert_equal(cc.max_age, 10)
+            assert cc.max_age == 10
            rv.close()

    def test_send_from_directory(self):
@ -418,7 +419,7 @@ class TestSendfile(TestFlask):
        with app.test_request_context():
            rv = flask.send_from_directory('static', 'hello.txt')
            rv.direct_passthrough = False
-            self.assert_equal(rv.data.strip(), b'Hello Subdomain')
+            assert rv.data.strip() == b'Hello Subdomain'
            rv.close()


@ -427,10 +428,10 @@ class TestLogging(TestFlask):
    def test_logger_cache(self):
        app = flask.Flask(__name__)
        logger1 = app.logger
-        self.assert_true(app.logger is logger1)
-        self.assert_equal(logger1.name, __name__)
+        assert app.logger is logger1
+        assert logger1.name == __name__
        app.logger_name = __name__ + '/test_logger_cache'
-        self.assert_true(app.logger is not logger1)
+        assert app.logger is not logger1

    def test_debug_log(self):
        app = flask.Flask(__name__)
@ -450,10 +451,10 @@ class TestLogging(TestFlask):
            with catch_stderr() as err:
                c.get('/')
                out = err.getvalue()
-                self.assert_in('WARNING in test_helpers [', out)
-                self.assert_in(os.path.basename(__file__.rsplit('.', 1)[0] + '.py'), out)
-                self.assert_in('the standard library is dead', out)
-                self.assert_in('this is a debug statement', out)
+                assert 'WARNING in test_helpers [' in out
+                assert os.path.basename(__file__.rsplit('.', 1)[0] + '.py') in out
+                assert 'the standard library is dead' in out
+                assert 'this is a debug statement' in out

            with catch_stderr() as err:
                try:
@ -461,14 +462,14 @@ class TestLogging(TestFlask):
                except ZeroDivisionError:
                    pass
                else:
-                    self.assert_true(False, 'debug log ate the exception')
+                    assert False, 'debug log ate the exception'

    def test_debug_log_override(self):
        app = flask.Flask(__name__)
        app.debug = True
        app.logger_name = 'flask_tests/test_debug_log_override'
        app.logger.level = 10
-        self.assert_equal(app.logger.level, 10)
+        assert app.logger.level == 10

    def test_exception_logging(self):
        out = StringIO()
@ -482,14 +483,14 @@ class TestLogging(TestFlask):
            1 // 0

        rv = app.test_client().get('/')
-        self.assert_equal(rv.status_code, 500)
-        self.assert_in(b'Internal Server Error', rv.data)
+        assert rv.status_code == 500
+        assert b'Internal Server Error' in rv.data

        err = out.getvalue()
-        self.assert_in('Exception on / [GET]', err)
-        self.assert_in('Traceback (most recent call last):', err)
-        self.assert_in('1 // 0', err)
-        self.assert_in('ZeroDivisionError:', err)
+        assert 'Exception on / [GET]' in err
+        assert 'Traceback (most recent call last):' in err
+        assert '1 // 0' in err
+        assert 'ZeroDivisionError:' in err

    def test_processor_exceptions(self):
        app = flask.Flask(__name__)
@ -511,8 +512,8 @@ class TestLogging(TestFlask):
            return 'Hello Server Error', 500
        for trigger in 'before', 'after':
            rv = app.test_client().get('/')
-            self.assert_equal(rv.status_code, 500)
-            self.assert_equal(rv.data, b'Hello Server Error')
+            assert rv.status_code == 500
+            assert rv.data == b'Hello Server Error'

    def test_url_for_with_anchor(self):
        app = flask.Flask(__name__)
@ -520,8 +521,7 @@ class TestLogging(TestFlask):
        def index():
            return '42'
        with app.test_request_context():
-            self.assert_equal(flask.url_for('index', _anchor='x y'),
-                              '/#x%20y')
+            assert flask.url_for('index', _anchor='x y') == '/#x%20y'

    def test_url_for_with_scheme(self):
        app = flask.Flask(__name__)
@ -529,10 +529,7 @@ class TestLogging(TestFlask):
        def index():
            return '42'
        with app.test_request_context():
-            self.assert_equal(flask.url_for('index',
-                                            _external=True,
-                                            _scheme='https'),
-                              'https://localhost/')
+            assert flask.url_for('index', _external=True, _scheme='https') == 'https://localhost/'

    def test_url_for_with_scheme_not_external(self):
        app = flask.Flask(__name__)
@ -540,7 +537,7 @@ class TestLogging(TestFlask):
        def index():
            return '42'
        with app.test_request_context():
-            self.assert_raises(ValueError,
+            pytest.raises(ValueError,
                               flask.url_for,
                               'index',
                               _scheme='https')
@ -564,12 +561,9 @@ class TestLogging(TestFlask):
                         view_func=myview)

        with app.test_request_context():
-            self.assert_equal(flask.url_for('myview', _method='GET'),
-                              '/myview/')
-            self.assert_equal(flask.url_for('myview', id=42, _method='GET'),
-                              '/myview/42')
-            self.assert_equal(flask.url_for('myview', _method='POST'),
-                              '/myview/create')
+            assert flask.url_for('myview', _method='GET') == '/myview/'
+            assert flask.url_for('myview', id=42, _method='GET') == '/myview/42'
+            assert flask.url_for('myview', _method='POST') == '/myview/create'


 class TestNoImports(TestFlask):
@ -587,7 +581,7 @@ class TestNoImports(TestFlask):
        try:
            flask.Flask('importerror')
        except NotImplementedError:
-            self.fail('Flask(import_name) is importing import_name.')
+            assert False, 'Flask(import_name) is importing import_name.'


 class TestStreaming(TestFlask):
@ -604,7 +598,7 @@ class TestStreaming(TestFlask):
            return flask.Response(flask.stream_with_context(generate()))
        c = app.test_client()
        rv = c.get('/?name=World')
-        self.assert_equal(rv.data, b'Hello World!')
+        assert rv.data == b'Hello World!'

    def test_streaming_with_context_as_decorator(self):
        app = flask.Flask(__name__)
@ -619,7 +613,7 @@ class TestStreaming(TestFlask):
            return flask.Response(generate())
        c = app.test_client()
        rv = c.get('/?name=World')
-        self.assert_equal(rv.data, b'Hello World!')
+        assert rv.data == b'Hello World!'

    def test_streaming_with_context_and_custom_close(self):
        app = flask.Flask(__name__)
@ -645,8 +639,8 @@ class TestStreaming(TestFlask):
                Wrapper(generate())))
        c = app.test_client()
        rv = c.get('/?name=World')
-        self.assert_equal(rv.data, b'Hello World!')
-        self.assert_equal(called, [42])
+        assert rv.data == b'Hello World!'
+        assert called == [42]


 def suite():
--- a/tests/test_regression.py
+++ b/tests/test_regression.py
@ -69,8 +69,8 @@ class TestMemory(TestFlask):
        def fire():
            with app.test_client() as c:
                rv = c.get('/')
-                self.assert_equal(rv.status_code, 200)
-                self.assert_equal(rv.data, b'<h1>42</h1>')
+                assert rv.status_code == 200
+                assert rv.data == b'<h1>42</h1>'

        # Trigger caches
        fire()
@ -84,7 +84,7 @@ class TestMemory(TestFlask):

    def test_safe_join_toplevel_pardir(self):
        from flask.helpers import safe_join
-        with self.assert_raises(NotFound):
+        with pytest.raises(NotFound):
            safe_join('/foo', '..')


@ -110,6 +110,6 @@ class TestException(TestFlask):

        with app.test_client() as c:
            rv = c.get('/')
-            self.assert_equal(rv.headers['Location'], 'http://localhost/test')
+            assert rv.headers['Location'] == 'http://localhost/test'
            rv = c.get('/test')
-            self.assert_equal(rv.data, b'42')
+            assert rv.data == b'42'
--- a/tests/test_reqctx.py
+++ b/tests/test_reqctx.py
@ -9,6 +9,8 @@
    :license: BSD, see LICENSE for more details.
 """

+import pytest
+
 import flask
 import unittest
 try:
@ -29,9 +31,9 @@ class TestRequestContext(TestFlask):

        ctx = app.test_request_context()
        ctx.push()
-        self.assert_equal(buffer, [])
+        assert buffer == []
        ctx.pop()
-        self.assert_equal(buffer, [None])
+        assert buffer == [None]

    def test_teardown_with_previous_exception(self):
        buffer = []
@ -46,8 +48,8 @@ class TestRequestContext(TestFlask):
            pass

        with app.test_request_context():
-            self.assert_equal(buffer, [])
-        self.assert_equal(buffer, [None])
+            assert buffer == []
+        assert buffer == [None]

    def test_proper_test_request_context(self):
        app = flask.Flask(__name__)
@ -64,37 +66,30 @@ class TestRequestContext(TestFlask):
            return None

        with app.test_request_context('/'):
-            self.assert_equal(flask.url_for('index', _external=True), 'http://localhost.localdomain:5000/')
+            assert flask.url_for('index', _external=True) == \
+                'http://localhost.localdomain:5000/'

        with app.test_request_context('/'):
-            self.assert_equal(flask.url_for('sub', _external=True), 'http://foo.localhost.localdomain:5000/')
+            assert flask.url_for('sub', _external=True) == \
+                'http://foo.localhost.localdomain:5000/'

        try:
            with app.test_request_context('/', environ_overrides={'HTTP_HOST': 'localhost'}):
                pass
-        except Exception as e:
-            self.assert_true(isinstance(e, ValueError))
-            self.assert_equal(str(e), "the server name provided " +
-                    "('localhost.localdomain:5000') does not match the " + \
-                    "server name from the WSGI environment ('localhost')")
-
-        try:
-            app.config.update(SERVER_NAME='localhost')
-            with app.test_request_context('/', environ_overrides={'SERVER_NAME': 'localhost'}):
-                pass
        except ValueError as e:
-            raise ValueError(
-                "No ValueError exception should have been raised \"%s\"" % e
+            assert str(e) == (
+                "the server name provided "
+                "('localhost.localdomain:5000') does not match the "
+                "server name from the WSGI environment ('localhost')"
            )

-        try:
-            app.config.update(SERVER_NAME='localhost:80')
-            with app.test_request_context('/', environ_overrides={'SERVER_NAME': 'localhost:80'}):
-                pass
-        except ValueError as e:
-            raise ValueError(
-                "No ValueError exception should have been raised \"%s\"" % e
-            )
+        app.config.update(SERVER_NAME='localhost')
+        with app.test_request_context('/', environ_overrides={'SERVER_NAME': 'localhost'}):
+            pass
+
+        app.config.update(SERVER_NAME='localhost:80')
+        with app.test_request_context('/', environ_overrides={'SERVER_NAME': 'localhost:80'}):
+            pass

    def test_context_binding(self):
        app = flask.Flask(__name__)
@ -106,20 +101,20 @@ class TestRequestContext(TestFlask):
            return flask.request.url

        with app.test_request_context('/?name=World'):
-            self.assert_equal(index(), 'Hello World!')
+            assert index() == 'Hello World!'
        with app.test_request_context('/meh'):
-            self.assert_equal(meh(), 'http://localhost/meh')
-        self.assert_true(flask._request_ctx_stack.top is None)
+            assert meh() == 'http://localhost/meh'
+        assert flask._request_ctx_stack.top is None

    def test_context_test(self):
        app = flask.Flask(__name__)
-        self.assert_false(flask.request)
-        self.assert_false(flask.has_request_context())
+        assert not flask.request
+        assert not flask.has_request_context()
        ctx = app.test_request_context()
        ctx.push()
        try:
-            self.assert_true(flask.request)
-            self.assert_true(flask.has_request_context())
+            assert flask.request
+            assert flask.has_request_context()
        finally:
            ctx.pop()

@ -131,14 +126,14 @@ class TestRequestContext(TestFlask):

        ctx = app.test_request_context('/?name=World')
        ctx.push()
-        self.assert_equal(index(), 'Hello World!')
+        assert index() == 'Hello World!'
        ctx.pop()
        try:
            index()
        except RuntimeError:
            pass
        else:
-            self.assert_true(0, 'expected runtime error')
+            assert 0, 'expected runtime error'

    def test_greenlet_context_copying(self):
        app = flask.Flask(__name__)
@ -148,23 +143,23 @@ class TestRequestContext(TestFlask):
        def index():
            reqctx = flask._request_ctx_stack.top.copy()
            def g():
-                self.assert_false(flask.request)
-                self.assert_false(flask.current_app)
+                assert not flask.request
+                assert not flask.current_app
                with reqctx:
-                    self.assert_true(flask.request)
-                    self.assert_equal(flask.current_app, app)
-                    self.assert_equal(flask.request.path, '/')
-                    self.assert_equal(flask.request.args['foo'], 'bar')
-                self.assert_false(flask.request)
+                    assert flask.request
+                    assert flask.current_app == app
+                    assert flask.request.path == '/'
+                    assert flask.request.args['foo'] == 'bar'
+                assert not flask.request
                return 42
            greenlets.append(greenlet(g))
            return 'Hello World!'

        rv = app.test_client().get('/?foo=bar')
-        self.assert_equal(rv.data, b'Hello World!')
+        assert rv.data == b'Hello World!'

        result = greenlets[0].run()
-        self.assert_equal(result, 42)
+        assert result == 42

    def test_greenlet_context_copying_api(self):
        app = flask.Flask(__name__)
@ -175,19 +170,19 @@ class TestRequestContext(TestFlask):
            reqctx = flask._request_ctx_stack.top.copy()
            @flask.copy_current_request_context
            def g():
-                self.assert_true(flask.request)
-                self.assert_equal(flask.current_app, app)
-                self.assert_equal(flask.request.path, '/')
-                self.assert_equal(flask.request.args['foo'], 'bar')
+                assert flask.request
+                assert flask.current_app == app
+                assert flask.request.path == '/'
+                assert flask.request.args['foo'] == 'bar'
                return 42
            greenlets.append(greenlet(g))
            return 'Hello World!'

        rv = app.test_client().get('/?foo=bar')
-        self.assert_equal(rv.data, b'Hello World!')
+        assert rv.data == b'Hello World!'

        result = greenlets[0].run()
-        self.assert_equal(result, 42)
+        assert result == 42

    # Disable test if we don't have greenlets available
    if greenlet is None:
--- a/tests/test_signals.py
+++ b/tests/test_signals.py
@ -42,10 +42,10 @@ class TestSignals(TestFlask):
        flask.template_rendered.connect(record, app)
        try:
            app.test_client().get('/')
-            self.assert_equal(len(recorded), 1)
+            assert len(recorded) == 1
            template, context = recorded[0]
-            self.assert_equal(template.name, 'simple_template.html')
-            self.assert_equal(context['whiskey'], 42)
+            assert template.name == 'simple_template.html'
+            assert context['whiskey'] == 42
        finally:
            flask.template_rendered.disconnect(record, app)

@ -57,7 +57,7 @@ class TestSignals(TestFlask):
            calls.append('before-signal')

        def after_request_signal(sender, response):
-            self.assert_equal(response.data, b'stuff')
+            assert response.data == b'stuff'
            calls.append('after-signal')

        @app.before_request
@ -80,11 +80,10 @@ class TestSignals(TestFlask):

        try:
            rv = app.test_client().get('/')
-            self.assert_equal(rv.data, b'stuff')
+            assert rv.data == b'stuff'

-            self.assert_equal(calls, ['before-signal', 'before-handler',
-                                      'handler', 'after-handler',
-                                      'after-signal'])
+            assert calls == ['before-signal', 'before-handler', 'handler',
+                             'after-handler', 'after-signal']
        finally:
            flask.request_started.disconnect(before_request_signal, app)
            flask.request_finished.disconnect(after_request_signal, app)
@ -102,9 +101,9 @@ class TestSignals(TestFlask):

        flask.got_request_exception.connect(record, app)
        try:
-            self.assert_equal(app.test_client().get('/').status_code, 500)
-            self.assert_equal(len(recorded), 1)
-            self.assert_true(isinstance(recorded[0], ZeroDivisionError))
+            assert app.test_client().get('/').status_code == 500
+            assert len(recorded) == 1
+            assert isinstance(recorded[0], ZeroDivisionError)
        finally:
            flask.got_request_exception.disconnect(record, app)

@ -127,9 +126,9 @@ class TestSignals(TestFlask):
        try:
            with app.test_client() as c:
                rv = c.get('/')
-                self.assert_equal(rv.data, b'Hello')
-                self.assert_equal(recorded, ['push'])
-            self.assert_equal(recorded, ['push', 'pop'])
+                assert rv.data == b'Hello'
+                assert recorded == ['push']
+            assert recorded == ['push', 'pop']
        finally:
            flask.appcontext_pushed.disconnect(record_push, app)
            flask.appcontext_popped.disconnect(record_pop, app)
@ -153,9 +152,9 @@ class TestSignals(TestFlask):
            client = app.test_client()
            with client.session_transaction():
                client.get('/')
-                self.assert_equal(len(recorded), 1)
+                assert len(recorded) == 1
                message, category = recorded[0]
-                self.assert_equal(message, 'This is a flash message')
-                self.assert_equal(category, 'notice')
+                assert message == 'This is a flash message'
+                assert category == 'notice'
        finally:
            flask.message_flashed.disconnect(record, app)
--- a/tests/test_subclassing.py
+++ b/tests/test_subclassing.py
@ -33,11 +33,11 @@ class TestFlaskSubclassing(TestFlask):
            1 // 0

        rv = app.test_client().get('/')
-        self.assert_equal(rv.status_code, 500)
-        self.assert_in(b'Internal Server Error', rv.data)
+        assert rv.status_code == 500
+        assert b'Internal Server Error' in rv.data

        err = out.getvalue()
-        self.assert_equal(err, '')
+        assert err == ''


 def suite():
--- a/tests/test_templating.py
+++ b/tests/test_templating.py
@ -28,7 +28,7 @@ class TestTemplating(TestFlask):
        def index():
            return flask.render_template('context_template.html', value=23)
        rv = app.test_client().get('/')
-        self.assert_equal(rv.data, b'<p>23|42')
+        assert rv.data == b'<p>23|42'

    def test_original_win(self):
        app = flask.Flask(__name__)
@ -36,7 +36,7 @@ class TestTemplating(TestFlask):
        def index():
            return flask.render_template_string('{{ config }}', config=42)
        rv = app.test_client().get('/')
-        self.assert_equal(rv.data, b'42')
+        assert rv.data == b'42'

    def test_request_less_rendering(self):
        app = flask.Flask(__name__)
@ -48,7 +48,7 @@ class TestTemplating(TestFlask):
        with app.app_context():
            rv = flask.render_template_string('Hello {{ config.WORLD_NAME }} '
                                              '{{ foo }}')
-            self.assert_equal(rv, 'Hello Special World 42')
+            assert rv == 'Hello Special World 42'

    def test_standard_context(self):
        app = flask.Flask(__name__)
@ -64,7 +64,7 @@ class TestTemplating(TestFlask):
                {{ session.test }}
            ''')
        rv = app.test_client().get('/?foo=42')
-        self.assert_equal(rv.data.split(), [b'42', b'23', b'False', b'aha'])
+        assert rv.data.split() == [b'42', b'23', b'False', b'aha']

    def test_escaping(self):
        text = '<p>Hello World!'
@ -74,64 +74,64 @@ class TestTemplating(TestFlask):
            return flask.render_template('escaping_template.html', text=text,
                                         html=flask.Markup(text))
        lines = app.test_client().get('/').data.splitlines()
-        self.assert_equal(lines, [
+        assert lines == [
            b'&lt;p&gt;Hello World!',
            b'<p>Hello World!',
            b'<p>Hello World!',
            b'<p>Hello World!',
            b'&lt;p&gt;Hello World!',
            b'<p>Hello World!'
-        ])
+        ]

    def test_no_escaping(self):
        app = flask.Flask(__name__)
        with app.test_request_context():
-            self.assert_equal(flask.render_template_string('{{ foo }}',
-                              foo='<test>'), '<test>')
-            self.assert_equal(flask.render_template('mail.txt', foo='<test>'),
-                              '<test> Mail')
+            assert flask.render_template_string(
+                '{{ foo }}', foo='<test>') == '<test>'
+            assert flask.render_template('mail.txt', foo='<test>') == \
+                '<test> Mail'

    def test_macros(self):
        app = flask.Flask(__name__)
        with app.test_request_context():
            macro = flask.get_template_attribute('_macro.html', 'hello')
-            self.assert_equal(macro('World'), 'Hello World!')
+            assert macro('World') == 'Hello World!'

    def test_template_filter(self):
        app = flask.Flask(__name__)
        @app.template_filter()
        def my_reverse(s):
            return s[::-1]
-        self.assert_in('my_reverse', app.jinja_env.filters.keys())
-        self.assert_equal(app.jinja_env.filters['my_reverse'], my_reverse)
-        self.assert_equal(app.jinja_env.filters['my_reverse']('abcd'), 'dcba')
+        assert 'my_reverse' in app.jinja_env.filters.keys()
+        assert app.jinja_env.filters['my_reverse'] == my_reverse
+        assert app.jinja_env.filters['my_reverse']('abcd') == 'dcba'

    def test_add_template_filter(self):
        app = flask.Flask(__name__)
        def my_reverse(s):
            return s[::-1]
        app.add_template_filter(my_reverse)
-        self.assert_in('my_reverse', app.jinja_env.filters.keys())
-        self.assert_equal(app.jinja_env.filters['my_reverse'], my_reverse)
-        self.assert_equal(app.jinja_env.filters['my_reverse']('abcd'), 'dcba')
+        assert 'my_reverse' in app.jinja_env.filters.keys()
+        assert app.jinja_env.filters['my_reverse'] == my_reverse
+        assert app.jinja_env.filters['my_reverse']('abcd') == 'dcba'

    def test_template_filter_with_name(self):
        app = flask.Flask(__name__)
        @app.template_filter('strrev')
        def my_reverse(s):
            return s[::-1]
-        self.assert_in('strrev', app.jinja_env.filters.keys())
-        self.assert_equal(app.jinja_env.filters['strrev'], my_reverse)
-        self.assert_equal(app.jinja_env.filters['strrev']('abcd'), 'dcba')
+        assert 'strrev' in app.jinja_env.filters.keys()
+        assert app.jinja_env.filters['strrev'] == my_reverse
+        assert app.jinja_env.filters['strrev']('abcd') == 'dcba'

    def test_add_template_filter_with_name(self):
        app = flask.Flask(__name__)
        def my_reverse(s):
            return s[::-1]
        app.add_template_filter(my_reverse, 'strrev')
-        self.assert_in('strrev', app.jinja_env.filters.keys())
-        self.assert_equal(app.jinja_env.filters['strrev'], my_reverse)
-        self.assert_equal(app.jinja_env.filters['strrev']('abcd'), 'dcba')
+        assert 'strrev' in app.jinja_env.filters.keys()
+        assert app.jinja_env.filters['strrev'] == my_reverse
+        assert app.jinja_env.filters['strrev']('abcd') == 'dcba'

    def test_template_filter_with_template(self):
        app = flask.Flask(__name__)
@ -142,7 +142,7 @@ class TestTemplating(TestFlask):
        def index():
            return flask.render_template('template_filter.html', value='abcd')
        rv = app.test_client().get('/')
-        self.assert_equal(rv.data, b'dcba')
+        assert rv.data == b'dcba'

    def test_add_template_filter_with_template(self):
        app = flask.Flask(__name__)
@ -153,7 +153,7 @@ class TestTemplating(TestFlask):
        def index():
            return flask.render_template('template_filter.html', value='abcd')
        rv = app.test_client().get('/')
-        self.assert_equal(rv.data, b'dcba')
+        assert rv.data == b'dcba'

    def test_template_filter_with_name_and_template(self):
        app = flask.Flask(__name__)
@ -164,7 +164,7 @@ class TestTemplating(TestFlask):
        def index():
            return flask.render_template('template_filter.html', value='abcd')
        rv = app.test_client().get('/')
-        self.assert_equal(rv.data, b'dcba')
+        assert rv.data == b'dcba'

    def test_add_template_filter_with_name_and_template(self):
        app = flask.Flask(__name__)
@ -175,43 +175,43 @@ class TestTemplating(TestFlask):
        def index():
            return flask.render_template('template_filter.html', value='abcd')
        rv = app.test_client().get('/')
-        self.assert_equal(rv.data, b'dcba')
+        assert rv.data == b'dcba'

    def test_template_test(self):
        app = flask.Flask(__name__)
        @app.template_test()
        def boolean(value):
            return isinstance(value, bool)
-        self.assert_in('boolean', app.jinja_env.tests.keys())
-        self.assert_equal(app.jinja_env.tests['boolean'], boolean)
-        self.assert_true(app.jinja_env.tests['boolean'](False))
+        assert 'boolean' in app.jinja_env.tests.keys()
+        assert app.jinja_env.tests['boolean'] == boolean
+        assert app.jinja_env.tests['boolean'](False)

    def test_add_template_test(self):
        app = flask.Flask(__name__)
        def boolean(value):
            return isinstance(value, bool)
        app.add_template_test(boolean)
-        self.assert_in('boolean', app.jinja_env.tests.keys())
-        self.assert_equal(app.jinja_env.tests['boolean'], boolean)
-        self.assert_true(app.jinja_env.tests['boolean'](False))
+        assert 'boolean' in app.jinja_env.tests.keys()
+        assert app.jinja_env.tests['boolean'] == boolean
+        assert app.jinja_env.tests['boolean'](False)

    def test_template_test_with_name(self):
        app = flask.Flask(__name__)
        @app.template_test('boolean')
        def is_boolean(value):
            return isinstance(value, bool)
-        self.assert_in('boolean', app.jinja_env.tests.keys())
-        self.assert_equal(app.jinja_env.tests['boolean'], is_boolean)
-        self.assert_true(app.jinja_env.tests['boolean'](False))
+        assert 'boolean' in app.jinja_env.tests.keys()
+        assert app.jinja_env.tests['boolean'] == is_boolean
+        assert app.jinja_env.tests['boolean'](False)

    def test_add_template_test_with_name(self):
        app = flask.Flask(__name__)
        def is_boolean(value):
            return isinstance(value, bool)
        app.add_template_test(is_boolean, 'boolean')
-        self.assert_in('boolean', app.jinja_env.tests.keys())
-        self.assert_equal(app.jinja_env.tests['boolean'], is_boolean)
-        self.assert_true(app.jinja_env.tests['boolean'](False))
+        assert 'boolean' in app.jinja_env.tests.keys()
+        assert app.jinja_env.tests['boolean'] == is_boolean
+        assert app.jinja_env.tests['boolean'](False)

    def test_template_test_with_template(self):
        app = flask.Flask(__name__)
@ -222,7 +222,7 @@ class TestTemplating(TestFlask):
        def index():
            return flask.render_template('template_test.html', value=False)
        rv = app.test_client().get('/')
-        self.assert_in(b'Success!', rv.data)
+        assert b'Success!' in rv.data

    def test_add_template_test_with_template(self):
        app = flask.Flask(__name__)
@ -233,7 +233,7 @@ class TestTemplating(TestFlask):
        def index():
            return flask.render_template('template_test.html', value=False)
        rv = app.test_client().get('/')
-        self.assert_in(b'Success!', rv.data)
+        assert b'Success!' in rv.data

    def test_template_test_with_name_and_template(self):
        app = flask.Flask(__name__)
@ -244,7 +244,7 @@ class TestTemplating(TestFlask):
        def index():
            return flask.render_template('template_test.html', value=False)
        rv = app.test_client().get('/')
-        self.assert_in(b'Success!', rv.data)
+        assert b'Success!' in rv.data

    def test_add_template_test_with_name_and_template(self):
        app = flask.Flask(__name__)
@ -255,19 +255,19 @@ class TestTemplating(TestFlask):
        def index():
            return flask.render_template('template_test.html', value=False)
        rv = app.test_client().get('/')
-        self.assert_in(b'Success!', rv.data)
+        assert b'Success!' in rv.data

    def test_add_template_global(self):
        app = flask.Flask(__name__)
        @app.template_global()
        def get_stuff():
            return 42
-        self.assert_in('get_stuff', app.jinja_env.globals.keys())
-        self.assert_equal(app.jinja_env.globals['get_stuff'], get_stuff)
-        self.assert_true(app.jinja_env.globals['get_stuff'](), 42)
+        assert 'get_stuff' in app.jinja_env.globals.keys()
+        assert app.jinja_env.globals['get_stuff'] == get_stuff
+        assert app.jinja_env.globals['get_stuff'](), 42
        with app.app_context():
            rv = flask.render_template_string('{{ get_stuff() }}')
-            self.assert_equal(rv, '42')
+            assert rv == '42'

    def test_custom_template_loader(self):
        class MyFlask(flask.Flask):
@ -280,7 +280,7 @@ class TestTemplating(TestFlask):
            return flask.render_template('index.html')
        c = app.test_client()
        rv = c.get('/')
-        self.assert_equal(rv.data, b'Hello Custom World!')
+        assert rv.data == b'Hello Custom World!'

    def test_iterable_loader(self):
        app = flask.Flask(__name__)
@ -296,15 +296,15 @@ class TestTemplating(TestFlask):
                value=23)

        rv = app.test_client().get('/')
-        self.assert_equal(rv.data, b'<h1>Jameson</h1>')
+        assert rv.data == b'<h1>Jameson</h1>'

    def test_templates_auto_reload(self):
        app = flask.Flask(__name__)
-        self.assert_true(app.config['TEMPLATES_AUTO_RELOAD'])
-        self.assert_true(app.jinja_env.auto_reload)
+        assert app.config['TEMPLATES_AUTO_RELOAD']
+        assert app.jinja_env.auto_reload
        app = flask.Flask(__name__)
        app.config['TEMPLATES_AUTO_RELOAD'] = False
-        self.assert_false(app.jinja_env.auto_reload)
+        assert not app.jinja_env.auto_reload

    def test_template_loader_debugging(self):
        from blueprintapp import app
@ -314,17 +314,15 @@ class TestTemplating(TestFlask):
            def handle(x, record):
                called.append(True)
                text = str(record.msg)
-                self.assert_('1: trying loader of application '
-                             '"blueprintapp"' in text)
-                self.assert_('2: trying loader of blueprint "admin" '
-                             '(blueprintapp.apps.admin)' in text)
-                self.assert_('trying loader of blueprint "frontend" '
-                             '(blueprintapp.apps.frontend)' in text)
-                self.assert_('Error: the template could not be found' in text)
-                self.assert_('looked up from an endpoint that belongs to '
-                             'the blueprint "frontend"' in text)
-                self.assert_(
-                    'See http://flask.pocoo.org/docs/blueprints/#templates' in text)
+                assert '1: trying loader of application "blueprintapp"' in text
+                assert ('2: trying loader of blueprint "admin" '
+                        '(blueprintapp.apps.admin)') in text
+                assert ('trying loader of blueprint "frontend" '
+                        '(blueprintapp.apps.frontend)') in text
+                assert 'Error: the template could not be found' in text
+                assert ('looked up from an endpoint that belongs to '
+                        'the blueprint "frontend"') in text
+                assert 'See http://flask.pocoo.org/docs/blueprints/#templates' in text

        with app.test_client() as c:
            try:
@ -336,14 +334,14 @@ class TestTemplating(TestFlask):
                try:
                    c.get('/missing')
                except TemplateNotFound as e:
-                    self.assert_('missing_template.html' in str(e))
+                    assert 'missing_template.html' in str(e)
                else:
                    self.fail('Expected template not found exception.')
            finally:
                app.logger.handlers[:] = old_handlers
                app.config['EXPLAIN_TEMPLATE_LOADING'] = old_load_setting

-        self.assert_equal(len(called), 1)
+        assert len(called) == 1


 def suite():
--- a/tests/test_testing.py
+++ b/tests/test_testing.py
@ -28,10 +28,10 @@ class TestTestTools(TestFlask):
            return flask.request.url

        ctx = app.test_request_context()
-        self.assert_equal(ctx.request.url, 'http://example.com:1234/foo/')
+        assert ctx.request.url == 'http://example.com:1234/foo/'
        with app.test_client() as c:
            rv = c.get('/')
-            self.assert_equal(rv.data, b'http://example.com:1234/foo/')
+            assert rv.data == b'http://example.com:1234/foo/'

    def test_environ_defaults(self):
        app = flask.Flask(__name__)
@ -41,10 +41,10 @@ class TestTestTools(TestFlask):
            return flask.request.url

        ctx = app.test_request_context()
-        self.assert_equal(ctx.request.url, 'http://localhost/')
+        assert ctx.request.url == 'http://localhost/'
        with app.test_client() as c:
            rv = c.get('/')
-            self.assert_equal(rv.data, b'http://localhost/')
+            assert rv.data == b'http://localhost/'

    def test_redirect_keep_session(self):
        app = flask.Flask(__name__)
@ -89,14 +89,14 @@ class TestTestTools(TestFlask):

        with app.test_client() as c:
            with c.session_transaction() as sess:
-                self.assert_equal(len(sess), 0)
+                assert len(sess) == 0
                sess['foo'] = [42]
-                self.assert_equal(len(sess), 1)
+                assert len(sess) == 1
            rv = c.get('/')
-            self.assert_equal(rv.data, b'[42]')
+            assert rv.data == b'[42]'
            with c.session_transaction() as sess:
-                self.assert_equal(len(sess), 1)
-                self.assert_equal(sess['foo'], [42])
+                assert len(sess) == 1
+                assert sess['foo'] == [42]

    def test_session_transactions_no_null_sessions(self):
        app = flask.Flask(__name__)
@ -107,9 +107,9 @@ class TestTestTools(TestFlask):
                with c.session_transaction() as sess:
                    pass
            except RuntimeError as e:
-                self.assert_in('Session backend did not open a session', str(e))
+                assert 'Session backend did not open a session' in str(e)
            else:
-                self.fail('Expected runtime error')
+                assert False, 'Expected runtime error'

    def test_session_transactions_keep_context(self):
        app = flask.Flask(__name__)
@ -119,9 +119,9 @@ class TestTestTools(TestFlask):
        with app.test_client() as c:
            rv = c.get('/')
            req = flask.request._get_current_object()
-            self.assert_true(req is not None)
+            assert req is not None
            with c.session_transaction():
-                self.assert_true(req is flask.request._get_current_object())
+                assert req is flask.request._get_current_object()

    def test_session_transaction_needs_cookies(self):
        app = flask.Flask(__name__)
@ -131,9 +131,9 @@ class TestTestTools(TestFlask):
            with c.session_transaction() as s:
                pass
        except RuntimeError as e:
-            self.assert_in('cookies', str(e))
+            assert 'cookies' in str(e)
        else:
-            self.fail('Expected runtime error')
+            assert False, 'Expected runtime error'

    def test_test_client_context_binding(self):
        app = flask.Flask(__name__)
@ -149,14 +149,14 @@ class TestTestTools(TestFlask):

        with app.test_client() as c:
            resp = c.get('/')
-            self.assert_equal(flask.g.value, 42)
-            self.assert_equal(resp.data, b'Hello World!')
-            self.assert_equal(resp.status_code, 200)
+            assert flask.g.value == 42
+            assert resp.data == b'Hello World!'
+            assert resp.status_code == 200

            resp = c.get('/other')
-            self.assert_false(hasattr(flask.g, 'value'))
-            self.assert_in(b'Internal Server Error', resp.data)
-            self.assert_equal(resp.status_code, 500)
+            assert not hasattr(flask.g, 'value')
+            assert b'Internal Server Error' in resp.data
+            assert resp.status_code == 500
            flask.g.value = 23

        try:
@ -171,10 +171,10 @@ class TestTestTools(TestFlask):
        c = app.test_client()

        with c:
-            self.assert_equal(c.get('/').status_code, 404)
+            assert c.get('/').status_code == 404

        with c:
-            self.assert_equal(c.get('/').status_code, 404)
+            assert c.get('/').status_code == 404

    def test_test_client_calls_teardown_handlers(self):
        app = flask.Flask(__name__)
@ -184,19 +184,19 @@ class TestTestTools(TestFlask):
            called.append(error)

        with app.test_client() as c:
-            self.assert_equal(called, [])
+            assert called == []
            c.get('/')
-            self.assert_equal(called, [])
-        self.assert_equal(called, [None])
+            assert called == []
+        assert called == [None]

        del called[:]
        with app.test_client() as c:
-            self.assert_equal(called, [])
+            assert called == []
            c.get('/')
-            self.assert_equal(called, [])
+            assert called == []
            c.get('/')
-            self.assert_equal(called, [None])
-        self.assert_equal(called, [None, None])
+            assert called == [None]
+        assert called == [None, None]

    def test_full_url_request(self):
        app = flask.Flask(__name__)
@ -208,9 +208,9 @@ class TestTestTools(TestFlask):

        with app.test_client() as c:
            rv = c.post('http://domain.com/action?vodka=42', data={'gin': 43})
-            self.assert_equal(rv.status_code, 200)
-            self.assert_true('gin' in flask.request.form)
-            self.assert_true('vodka' in flask.request.args)
+            assert rv.status_code == 200
+            assert 'gin' in flask.request.form
+            assert 'vodka' in flask.request.args


 class TestSubdomain(TestFlask):
@ -241,8 +241,8 @@ class TestSubdomain(TestFlask):
        url = flask.url_for('view', company_id='xxx')
        response = client.get(url)

-        self.assert_equal(200, response.status_code)
-        self.assert_equal(b'xxx', response.data)
+        assert 200 == response.status_code
+        assert b'xxx' == response.data


    def test_nosubdomain(self, app, client):
@ -253,5 +253,5 @@ class TestSubdomain(TestFlask):
        url = flask.url_for('view', company_id='xxx')
        response = client.get(url)

-        self.assert_equal(200, response.status_code)
-        self.assert_equal(b'xxx', response.data)
+        assert 200 == response.status_code
+        assert b'xxx' == response.data
--- a/tests/test_views.py
+++ b/tests/test_views.py
@ -9,6 +9,8 @@
    :license: BSD, see LICENSE for more details.
 """

+import pytest
+
 import flask
 import flask.views
 import unittest
@ -20,11 +22,11 @@ class TestView(TestFlask):
    def common_test(self, app):
        c = app.test_client()

-        self.assert_equal(c.get('/').data, b'GET')
-        self.assert_equal(c.post('/').data, b'POST')
-        self.assert_equal(c.put('/').status_code, 405)
+        assert c.get('/').data == b'GET'
+        assert c.post('/').data == b'POST'
+        assert c.put('/').status_code == 405
        meths = parse_set_header(c.open('/', method='OPTIONS').headers['Allow'])
-        self.assert_equal(sorted(meths), ['GET', 'HEAD', 'OPTIONS', 'POST'])
+        assert sorted(meths) == ['GET', 'HEAD', 'OPTIONS', 'POST']

    def test_basic_view(self):
        app = flask.Flask(__name__)
@ -87,7 +89,7 @@ class TestView(TestFlask):
        c = app.test_client()

        meths = parse_set_header(c.open('/', method='OPTIONS').headers['Allow'])
-        self.assert_equal(sorted(meths), ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST'])
+        assert sorted(meths) == ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST']

    def test_view_decorators(self):
        app = flask.Flask(__name__)
@ -107,8 +109,8 @@ class TestView(TestFlask):
        app.add_url_rule('/', view_func=Index.as_view('index'))
        c = app.test_client()
        rv = c.get('/')
-        self.assert_equal(rv.headers['X-Parachute'], 'awesome')
-        self.assert_equal(rv.data, b'Awesome')
+        assert rv.headers['X-Parachute'] == 'awesome'
+        assert rv.data == b'Awesome'

    def test_implicit_head(self):
        app = flask.Flask(__name__)
@ -122,11 +124,11 @@ class TestView(TestFlask):
        app.add_url_rule('/', view_func=Index.as_view('index'))
        c = app.test_client()
        rv = c.get('/')
-        self.assert_equal(rv.data, b'Blub')
-        self.assert_equal(rv.headers['X-Method'], 'GET')
+        assert rv.data == b'Blub'
+        assert rv.headers['X-Method'] == 'GET'
        rv = c.head('/')
-        self.assert_equal(rv.data, b'')
-        self.assert_equal(rv.headers['X-Method'], 'HEAD')
+        assert rv.data == b''
+        assert rv.headers['X-Method'] == 'HEAD'

    def test_explicit_head(self):
        app = flask.Flask(__name__)
@ -140,10 +142,10 @@ class TestView(TestFlask):
        app.add_url_rule('/', view_func=Index.as_view('index'))
        c = app.test_client()
        rv = c.get('/')
-        self.assert_equal(rv.data, b'GET')
+        assert rv.data == b'GET'
        rv = c.head('/')
-        self.assert_equal(rv.data, b'')
-        self.assert_equal(rv.headers['X-Method'], 'HEAD')
+        assert rv.data == b''
+        assert rv.headers['X-Method'] == 'HEAD'

    def test_endpoint_override(self):
        app = flask.Flask(__name__)
@ -156,7 +158,7 @@ class TestView(TestFlask):

        app.add_url_rule('/', view_func=Index.as_view('index'))

-        with self.assert_raises(AssertionError):
+        with pytest.raises(AssertionError):
            app.add_url_rule('/', view_func=Index.as_view('index'))

        # But these tests should still pass. We just log a warning.