Rewrite assertion methods

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():