# HG changeset patch
# User Thomas De Schampheleire <thomas.de.schampheleire@gmail.com>
# Date 1463252666 -7200
# Node ID be1d366f461c0c1a8e15ef2a6bff08dde5aab33d
# Parent  8d4f3a852716e9543c7a4482d4caf3648b19028f
pytest migration: functional: switch to standard assert statements

Use unittest2pytest to replace unittest-style assert statements (e.g.
assertEqual) with standard Python assert statements to benefit from pytest's
improved reporting on assert failures.

The conversion by unittest2pytest was correct, except for line wrapping
problems.

diff -r 8d4f3a852716 -r be1d366f461c kallithea/tests/functional/test_admin_auth_settings.py
--- a/kallithea/tests/functional/test_admin_auth_settings.py	Mon May 09 17:46:34 2016 +0200
+++ b/kallithea/tests/functional/test_admin_auth_settings.py	Sat May 14 21:04:26 2016 +0200
@@ -47,8 +47,7 @@
         self.checkSessionFlash(response, 'Auth settings updated successfully')
 
         new_settings = Setting.get_auth_settings()
-        self.assertEqual(new_settings['auth_ldap_host'], u'dc.example.com',
-                         'fail db write compare')
+        assert new_settings['auth_ldap_host'] == u'dc.example.com', 'fail db write compare'
 
     @skipif(not ldap_lib_installed, reason='skipping due to missing ldap lib')
     def test_ldap_error_form_wrong_port_number(self):
@@ -160,9 +159,9 @@
                            'THE_USER_LASTNAME': 'Doe',
                            }
         )
-        self.assertEqual(response.form['email'].value, 'john@example.org')
-        self.assertEqual(response.form['firstname'].value, 'John')
-        self.assertEqual(response.form['lastname'].value, 'Doe')
+        assert response.form['email'].value == 'john@example.org'
+        assert response.form['firstname'].value == 'John'
+        assert response.form['lastname'].value == 'Doe'
 
 
     def test_container_auth_login_fallback_header(self):
@@ -220,7 +219,7 @@
             url=url(controller='admin/my_account', action='my_account'),
             extra_environ={'REMOTE_USER': 'john'},
         )
-        self.assertNotIn('Log Out', response.normal_body)
+        assert 'Log Out' not in response.normal_body
 
     def test_crowd_save_settings(self):
         self.log_user()
@@ -239,8 +238,7 @@
         self.checkSessionFlash(response, 'Auth settings updated successfully')
 
         new_settings = Setting.get_auth_settings()
-        self.assertEqual(new_settings['auth_crowd_host'], u'hostname',
-                         'fail db write compare')
+        assert new_settings['auth_crowd_host'] == u'hostname', 'fail db write compare'
 
     @skipif(not pam_lib_installed, reason='skipping due to missing pam lib')
     def test_pam_save_settings(self):
@@ -257,5 +255,4 @@
         self.checkSessionFlash(response, 'Auth settings updated successfully')
 
         new_settings = Setting.get_auth_settings()
-        self.assertEqual(new_settings['auth_pam_service'], u'kallithea',
-                         'fail db write compare')
+        assert new_settings['auth_pam_service'] == u'kallithea', 'fail db write compare'
diff -r 8d4f3a852716 -r be1d366f461c kallithea/tests/functional/test_admin_defaults.py
--- a/kallithea/tests/functional/test_admin_defaults.py	Mon May 09 17:46:34 2016 +0200
+++ b/kallithea/tests/functional/test_admin_defaults.py	Sat May 14 21:04:26 2016 +0200
@@ -40,7 +40,7 @@
 
         params.pop('_authentication_token')
         defs = Setting.get_default_repo_settings()
-        self.assertEqual(params, defs)
+        assert params == defs
 
     def test_update_params_false_git(self):
         self.log_user()
@@ -57,7 +57,7 @@
 
         params.pop('_authentication_token')
         defs = Setting.get_default_repo_settings()
-        self.assertEqual(params, defs)
+        assert params == defs
 
     def test_update_browser_fakeout(self):
         response = self.app.post(url('default', id=1), params=dict(_method='put', _authentication_token=self.authentication_token()))
diff -r 8d4f3a852716 -r be1d366f461c kallithea/tests/functional/test_admin_gists.py
--- a/kallithea/tests/functional/test_admin_gists.py	Mon May 09 17:46:34 2016 +0200
+++ b/kallithea/tests/functional/test_admin_gists.py	Sat May 14 21:04:26 2016 +0200
@@ -163,14 +163,14 @@
         gist = _create_gist('gist-show-me', content='GIST CONTENT')
         response = self.app.get(url('formatted_gist',
                                     gist_id=gist.gist_access_id, format='raw'))
-        self.assertEqual(response.body, 'GIST CONTENT')
+        assert response.body == 'GIST CONTENT'
 
     def test_show_as_raw_individual_file(self):
         gist = _create_gist('gist-show-me-raw', content='GIST BODY')
         response = self.app.get(url('formatted_gist_file',
                                     gist_id=gist.gist_access_id, format='raw',
                                     revision='tip', f_path='gist-show-me-raw'))
-        self.assertEqual(response.body, 'GIST BODY')
+        assert response.body == 'GIST BODY'
 
     def test_edit(self):
         response = self.app.get(url('edit_gist', gist_id=1))
diff -r 8d4f3a852716 -r be1d366f461c kallithea/tests/functional/test_admin_notifications.py
--- a/kallithea/tests/functional/test_admin_notifications.py	Mon May 09 17:46:34 2016 +0200
+++ b/kallithea/tests/functional/test_admin_notifications.py	Sat May 14 21:04:26 2016 +0200
@@ -52,18 +52,18 @@
 
         # check DB
         get_notif = lambda un: [x.notification for x in un]
-        self.assertEqual(get_notif(cur_user.notifications), [notification])
-        self.assertEqual(get_notif(u1.notifications), [notification])
-        self.assertEqual(get_notif(u2.notifications), [notification])
+        assert get_notif(cur_user.notifications) == [notification]
+        assert get_notif(u1.notifications) == [notification]
+        assert get_notif(u2.notifications) == [notification]
         cur_usr_id = cur_user.user_id
 
         response = self.app.post(
             url('notification', notification_id=notification.notification_id),
             params={'_method': 'delete', '_authentication_token': self.authentication_token()})
-        self.assertEqual(response.body, 'ok')
+        assert response.body == 'ok'
 
         cur_user = User.get(cur_usr_id)
-        self.assertEqual(cur_user.notifications, [])
+        assert cur_user.notifications == []
 
     def test_show(self):
         self.log_user()
@@ -98,13 +98,10 @@
                                                   body       = notify_body)
 
         description = NotificationModel().make_description(notification)
-        self.assertEqual(
-            description,
-            "{0} sent message {1}".format(
+        assert description == "{0} sent message {1}".format(
                 cur_user.username,
                 h.age(notification.created_on)
                 )
-            )
 
     def test_description_with_datetime(self):
         self.log_user()
@@ -116,10 +113,7 @@
                                                   body       = notify_body)
 
         description = NotificationModel().make_description(notification, False)
-        self.assertEqual(
-            description,
-            "{0} sent message at {1}".format(
+        assert description == "{0} sent message at {1}".format(
                 cur_user.username,
                 h.fmt_date(notification.created_on)
                 )
-            )
diff -r 8d4f3a852716 -r be1d366f461c kallithea/tests/functional/test_admin_repos.py
--- a/kallithea/tests/functional/test_admin_repos.py	Mon May 09 17:46:34 2016 +0200
+++ b/kallithea/tests/functional/test_admin_repos.py	Sat May 14 21:04:26 2016 +0200
@@ -53,7 +53,7 @@
                                                 _authentication_token=self.authentication_token()))
         ## run the check page that triggers the flash message
         response = self.app.get(url('repo_check_home', repo_name=repo_name))
-        self.assertEqual(response.json, {u'result': True})
+        assert response.json == {u'result': True}
         self.checkSessionFlash(response,
                                'Created repository <a href="/%s">%s</a>'
                                % (repo_name, repo_name))
@@ -62,8 +62,8 @@
         new_repo = Session().query(Repository) \
             .filter(Repository.repo_name == repo_name).one()
 
-        self.assertEqual(new_repo.repo_name, repo_name)
-        self.assertEqual(new_repo.description, description)
+        assert new_repo.repo_name == repo_name
+        assert new_repo.description == description
 
         # test if the repository is visible in the list ?
         response = self.app.get(url('summary_home', repo_name=repo_name))
@@ -101,7 +101,7 @@
                                                 _authentication_token=self.authentication_token()))
         ## run the check page that triggers the flash message
         response = self.app.get(url('repo_check_home', repo_name=repo_name_full))
-        self.assertEqual(response.json, {u'result': True})
+        assert response.json == {u'result': True}
         self.checkSessionFlash(response,
                                'Created repository <a href="/%s">%s</a>'
                                % (repo_name_full, repo_name_full))
@@ -110,8 +110,8 @@
             .filter(Repository.repo_name == repo_name_full).one()
         new_repo_id = new_repo.repo_id
 
-        self.assertEqual(new_repo.repo_name, repo_name_full)
-        self.assertEqual(new_repo.description, description)
+        assert new_repo.repo_name == repo_name_full
+        assert new_repo.description == description
 
         # test if the repository is visible in the list ?
         response = self.app.get(url('summary_home', repo_name=repo_name_full))
@@ -120,7 +120,7 @@
 
         inherited_perms = UserRepoToPerm.query() \
             .filter(UserRepoToPerm.repository_id == new_repo_id).all()
-        self.assertEqual(len(inherited_perms), 1)
+        assert len(inherited_perms) == 1
 
         # test if the repository was created on filesystem
         try:
@@ -193,7 +193,7 @@
 
         ## run the check page that triggers the flash message
         response = self.app.get(url('repo_check_home', repo_name=repo_name_full))
-        self.assertEqual(response.json, {u'result': True})
+        assert response.json == {u'result': True}
         self.checkSessionFlash(response,
                                'Created repository <a href="/%s">%s</a>'
                                % (repo_name_full, repo_name_full))
@@ -202,8 +202,8 @@
             .filter(Repository.repo_name == repo_name_full).one()
         new_repo_id = new_repo.repo_id
 
-        self.assertEqual(new_repo.repo_name, repo_name_full)
-        self.assertEqual(new_repo.description, description)
+        assert new_repo.repo_name == repo_name_full
+        assert new_repo.description == description
 
         # test if the repository is visible in the list ?
         response = self.app.get(url('summary_home', repo_name=repo_name_full))
@@ -212,7 +212,7 @@
 
         inherited_perms = UserRepoToPerm.query() \
             .filter(UserRepoToPerm.repository_id == new_repo_id).all()
-        self.assertEqual(len(inherited_perms), 1)
+        assert len(inherited_perms) == 1
 
         # test if the repository was created on filesystem
         try:
@@ -263,8 +263,8 @@
             .filter(Repository.repo_name == repo_name_full).one()
         new_repo_id = new_repo.repo_id
 
-        self.assertEqual(new_repo.repo_name, repo_name_full)
-        self.assertEqual(new_repo.description, description)
+        assert new_repo.repo_name == repo_name_full
+        assert new_repo.description == description
 
         # test if the repository is visible in the list ?
         response = self.app.get(url('summary_home', repo_name=repo_name_full))
@@ -282,12 +282,12 @@
         #check if inherited permissiona are applied
         inherited_perms = UserRepoToPerm.query() \
             .filter(UserRepoToPerm.repository_id == new_repo_id).all()
-        self.assertEqual(len(inherited_perms), 2)
+        assert len(inherited_perms) == 2
 
-        self.assertTrue(TEST_USER_REGULAR_LOGIN in [x.user.username
-                                                    for x in inherited_perms])
-        self.assertTrue('repository.write' in [x.permission.permission_name
-                                               for x in inherited_perms])
+        assert TEST_USER_REGULAR_LOGIN in [x.user.username
+                                                    for x in inherited_perms]
+        assert 'repository.write' in [x.permission.permission_name
+                                               for x in inherited_perms]
 
         RepoModel().delete(repo_name_full)
         RepoGroupModel().delete(group_name)
@@ -340,8 +340,8 @@
         new_repo = Session().query(Repository) \
             .filter(Repository.repo_name == repo_name).one()
 
-        self.assertEqual(new_repo.repo_name, repo_name)
-        self.assertEqual(new_repo.description, description)
+        assert new_repo.repo_name == repo_name
+        assert new_repo.description == description
 
         # test if the repository is visible in the list ?
         response = self.app.get(url('summary_home', repo_name=repo_name))
@@ -365,10 +365,9 @@
         deleted_repo = Session().query(Repository) \
             .filter(Repository.repo_name == repo_name).scalar()
 
-        self.assertEqual(deleted_repo, None)
+        assert deleted_repo == None
 
-        self.assertEqual(os.path.isdir(os.path.join(Ui.get_by_key('paths', '/').ui_value, repo_name)),
-                                  False)
+        assert os.path.isdir(os.path.join(Ui.get_by_key('paths', '/').ui_value, repo_name)) == False
 
     def test_delete_non_ascii(self):
         self.log_user()
@@ -385,7 +384,7 @@
                                                 _authentication_token=self.authentication_token()))
         ## run the check page that triggers the flash message
         response = self.app.get(url('repo_check_home', repo_name=repo_name))
-        self.assertEqual(response.json, {u'result': True})
+        assert response.json == {u'result': True}
         self.checkSessionFlash(response,
                                u'Created repository <a href="/%s">%s</a>'
                                % (urllib.quote(repo_name), repo_name_unicode))
@@ -393,8 +392,8 @@
         new_repo = Session().query(Repository) \
             .filter(Repository.repo_name == repo_name_unicode).one()
 
-        self.assertEqual(new_repo.repo_name, repo_name_unicode)
-        self.assertEqual(new_repo.description, description_unicode)
+        assert new_repo.repo_name == repo_name_unicode
+        assert new_repo.description == description_unicode
 
         # test if the repository is visible in the list ?
         response = self.app.get(url('summary_home', repo_name=repo_name))
@@ -416,10 +415,9 @@
         deleted_repo = Session().query(Repository) \
             .filter(Repository.repo_name == repo_name_unicode).scalar()
 
-        self.assertEqual(deleted_repo, None)
+        assert deleted_repo == None
 
-        self.assertEqual(os.path.isdir(os.path.join(Ui.get_by_key('paths', '/').ui_value, repo_name_unicode)),
-                                  False)
+        assert os.path.isdir(os.path.join(Ui.get_by_key('paths', '/').ui_value, repo_name_unicode)) == False
 
     def test_delete_repo_with_group(self):
         #TODO:
@@ -440,9 +438,9 @@
         self.log_user()
         #initially repository perm should be read
         perm = _get_permission_for_user(user='default', repo=self.REPO)
-        self.assertTrue(len(perm), 1)
-        self.assertEqual(perm[0].permission.permission_name, 'repository.read')
-        self.assertEqual(Repository.get_by_repo_name(self.REPO).private, False)
+        assert len(perm), 1
+        assert perm[0].permission.permission_name == 'repository.read'
+        assert Repository.get_by_repo_name(self.REPO).private == False
 
         response = self.app.put(url('put_repo', repo_name=self.REPO),
                         fixture._get_repo_create_params(repo_private=1,
@@ -452,12 +450,12 @@
                                                 _authentication_token=self.authentication_token()))
         self.checkSessionFlash(response,
                                msg='Repository %s updated successfully' % (self.REPO))
-        self.assertEqual(Repository.get_by_repo_name(self.REPO).private, True)
+        assert Repository.get_by_repo_name(self.REPO).private == True
 
         #now the repo default permission should be None
         perm = _get_permission_for_user(user='default', repo=self.REPO)
-        self.assertTrue(len(perm), 1)
-        self.assertEqual(perm[0].permission.permission_name, 'repository.none')
+        assert len(perm), 1
+        assert perm[0].permission.permission_name == 'repository.none'
 
         response = self.app.put(url('put_repo', repo_name=self.REPO),
                         fixture._get_repo_create_params(repo_private=False,
@@ -467,12 +465,12 @@
                                                 _authentication_token=self.authentication_token()))
         self.checkSessionFlash(response,
                                msg='Repository %s updated successfully' % (self.REPO))
-        self.assertEqual(Repository.get_by_repo_name(self.REPO).private, False)
+        assert Repository.get_by_repo_name(self.REPO).private == False
 
         #we turn off private now the repo default permission should stay None
         perm = _get_permission_for_user(user='default', repo=self.REPO)
-        self.assertTrue(len(perm), 1)
-        self.assertEqual(perm[0].permission.permission_name, 'repository.none')
+        assert len(perm), 1
+        assert perm[0].permission.permission_name == 'repository.none'
 
         #update this permission back
         perm[0].permission = Permission.get_by_key('repository.read')
@@ -591,10 +589,10 @@
                                'Error creating repository %s' % repo_name)
         # repo must not be in db
         repo = Repository.get_by_repo_name(repo_name)
-        self.assertEqual(repo, None)
+        assert repo == None
 
         # repo must not be in filesystem !
-        self.assertFalse(os.path.isdir(os.path.join(Ui.get_by_key('paths', '/').ui_value, repo_name)))
+        assert not os.path.isdir(os.path.join(Ui.get_by_key('paths', '/').ui_value, repo_name))
 
 class TestAdminReposControllerGIT(_BaseTestCase):
     REPO = GIT_REPO
diff -r 8d4f3a852716 -r be1d366f461c kallithea/tests/functional/test_admin_settings.py
--- a/kallithea/tests/functional/test_admin_settings.py	Mon May 09 17:46:34 2016 +0200
+++ b/kallithea/tests/functional/test_admin_settings.py	Sat May 14 21:04:26 2016 +0200
@@ -89,8 +89,7 @@
 
         self.checkSessionFlash(response, 'Updated application settings')
 
-        self.assertEqual(Setting
-                         .get_app_settings()['ga_code'], new_ga_code)
+        assert Setting.get_app_settings()['ga_code'] == new_ga_code
 
         response = response.follow()
         response.mustcontain("""_gaq.push(['_setAccount', '%s']);""" % new_ga_code)
@@ -110,8 +109,7 @@
                                  ))
 
         self.checkSessionFlash(response, 'Updated application settings')
-        self.assertEqual(Setting
-                        .get_app_settings()['ga_code'], new_ga_code)
+        assert Setting.get_app_settings()['ga_code'] == new_ga_code
 
         response = response.follow()
         response.mustcontain(no=["_gaq.push(['_setAccount', '%s']);" % new_ga_code])
@@ -131,8 +129,7 @@
                                  ))
 
         self.checkSessionFlash(response, 'Updated application settings')
-        self.assertEqual(Setting
-                        .get_app_settings()['captcha_private_key'], '1234567890')
+        assert Setting.get_app_settings()['captcha_private_key'] == '1234567890'
 
         response = self.app.get(url('register'))
         response.mustcontain('captcha')
@@ -152,8 +149,7 @@
                                  ))
 
         self.checkSessionFlash(response, 'Updated application settings')
-        self.assertEqual(Setting
-                        .get_app_settings()['captcha_private_key'], '')
+        assert Setting.get_app_settings()['captcha_private_key'] == ''
 
         response = self.app.get(url('register'))
         response.mustcontain(no=['captcha'])
@@ -175,9 +171,7 @@
                                 ))
 
             self.checkSessionFlash(response, 'Updated application settings')
-            self.assertEqual(Setting
-                             .get_app_settings()['title'],
-                             new_title.decode('utf-8'))
+            assert Setting.get_app_settings()['title'] == new_title.decode('utf-8')
 
             response = response.follow()
             response.mustcontain("""<div class="branding">%s</div>""" % new_title)
diff -r 8d4f3a852716 -r be1d366f461c kallithea/tests/functional/test_admin_user_groups.py
--- a/kallithea/tests/functional/test_admin_user_groups.py	Mon May 09 17:46:34 2016 +0200
+++ b/kallithea/tests/functional/test_admin_user_groups.py	Sat May 14 21:04:26 2016 +0200
@@ -60,7 +60,7 @@
         gr = Session().query(UserGroup) \
             .filter(UserGroup.users_group_name == users_group_name).scalar()
 
-        self.assertEqual(gr, None)
+        assert gr == None
 
     def test_default_perms_enable_repository_read_on_group(self):
         self.log_user()
@@ -90,11 +90,9 @@
         perms = UserGroupToPerm.query() \
             .filter(UserGroupToPerm.users_group == ug).all()
 
-        self.assertEqual(
-            sorted([[x.users_group_id, x.permission_id, ] for x in perms]),
-            sorted([[ug.users_group_id, p.permission_id],
+        assert sorted([[x.users_group_id, x.permission_id, ] for x in perms]) == sorted([[ug.users_group_id, p.permission_id],
                     [ug.users_group_id, p2.permission_id],
-                    [ug.users_group_id, p3.permission_id]]))
+                    [ug.users_group_id, p3.permission_id]])
 
         ## DISABLE REPO CREATE ON A GROUP
         response = self.app.put(
@@ -112,11 +110,9 @@
         perms = UserGroupToPerm.query() \
             .filter(UserGroupToPerm.users_group == ug).all()
 
-        self.assertEqual(
-            sorted([[x.users_group_id, x.permission_id, ] for x in perms]),
-            sorted([[ug.users_group_id, p.permission_id],
+        assert sorted([[x.users_group_id, x.permission_id, ] for x in perms]) == sorted([[ug.users_group_id, p.permission_id],
                     [ug.users_group_id, p2.permission_id],
-                    [ug.users_group_id, p3.permission_id]]))
+                    [ug.users_group_id, p3.permission_id]])
 
         # DELETE !
         ug = UserGroup.get_by_group_name(users_group_name)
@@ -127,13 +123,13 @@
         gr = Session().query(UserGroup) \
             .filter(UserGroup.users_group_name == users_group_name).scalar()
 
-        self.assertEqual(gr, None)
+        assert gr == None
         p = Permission.get_by_key('hg.create.repository')
         perms = UserGroupToPerm.query() \
             .filter(UserGroupToPerm.users_group_id == ugid).all()
         perms = [[x.users_group_id,
                   x.permission_id, ] for x in perms]
-        self.assertEqual(perms, [])
+        assert perms == []
 
     def test_default_perms_enable_repository_fork_on_group(self):
         self.log_user()
@@ -163,11 +159,9 @@
         perms = UserGroupToPerm.query() \
             .filter(UserGroupToPerm.users_group == ug).all()
 
-        self.assertEqual(
-            sorted([[x.users_group_id, x.permission_id, ] for x in perms]),
-            sorted([[ug.users_group_id, p.permission_id],
+        assert sorted([[x.users_group_id, x.permission_id, ] for x in perms]) == sorted([[ug.users_group_id, p.permission_id],
                     [ug.users_group_id, p2.permission_id],
-                    [ug.users_group_id, p3.permission_id]]))
+                    [ug.users_group_id, p3.permission_id]])
 
         ## DISABLE REPO CREATE ON A GROUP
         response = self.app.put(url('edit_user_group_default_perms', id=ug.users_group_id),
@@ -183,11 +177,9 @@
         perms = UserGroupToPerm.query() \
             .filter(UserGroupToPerm.users_group == ug).all()
 
-        self.assertEqual(
-            sorted([[x.users_group_id, x.permission_id, ] for x in perms]),
-            sorted([[ug.users_group_id, p.permission_id],
+        assert sorted([[x.users_group_id, x.permission_id, ] for x in perms]) == sorted([[ug.users_group_id, p.permission_id],
                     [ug.users_group_id, p2.permission_id],
-                    [ug.users_group_id, p3.permission_id]]))
+                    [ug.users_group_id, p3.permission_id]])
 
         # DELETE !
         ug = UserGroup.get_by_group_name(users_group_name)
@@ -199,16 +191,13 @@
                            .filter(UserGroup.users_group_name ==
                                    users_group_name).scalar()
 
-        self.assertEqual(gr, None)
+        assert gr == None
         p = Permission.get_by_key('hg.fork.repository')
         perms = UserGroupToPerm.query() \
             .filter(UserGroupToPerm.users_group_id == ugid).all()
         perms = [[x.users_group_id,
                   x.permission_id, ] for x in perms]
-        self.assertEqual(
-            perms,
-            []
-        )
+        assert perms == []
 
     def test_delete_browser_fakeout(self):
         response = self.app.post(url('users_group', id=1),
diff -r 8d4f3a852716 -r be1d366f461c kallithea/tests/functional/test_admin_users.py
--- a/kallithea/tests/functional/test_admin_users.py	Mon May 09 17:46:34 2016 +0200
+++ b/kallithea/tests/functional/test_admin_users.py	Sat May 14 21:04:26 2016 +0200
@@ -70,11 +70,11 @@
         new_user = Session().query(User). \
             filter(User.username == username).one()
 
-        self.assertEqual(new_user.username, username)
-        self.assertEqual(check_password(password, new_user.password), True)
-        self.assertEqual(new_user.name, name)
-        self.assertEqual(new_user.lastname, lastname)
-        self.assertEqual(new_user.email, email)
+        assert new_user.username == username
+        assert check_password(password, new_user.password) == True
+        assert new_user.name == name
+        assert new_user.lastname == lastname
+        assert new_user.email == email
 
         response.follow()
         response = response.follow()
@@ -105,7 +105,8 @@
         def get_user():
             Session().query(User).filter(User.username == username).one()
 
-        self.assertRaises(NoResultFound, get_user), 'found user in database'
+        with pytest.raises(NoResultFound):
+            get_user(), 'found user in database'
 
     def test_new(self):
         self.log_user()
@@ -160,7 +161,7 @@
         updated_params.update({'password_confirmation': ''})
         updated_params.update({'new_password': ''})
 
-        self.assertEqual(params, updated_params)
+        assert params == updated_params
 
     def test_delete(self):
         self.log_user()
@@ -277,8 +278,8 @@
 
         try:
             #User should have None permission on creation repository
-            self.assertEqual(UserModel().has_perm(user, perm_none), False)
-            self.assertEqual(UserModel().has_perm(user, perm_create), False)
+            assert UserModel().has_perm(user, perm_none) == False
+            assert UserModel().has_perm(user, perm_create) == False
 
             response = self.app.post(url('edit_user_perms', id=uid),
                                      params=dict(_method='put',
@@ -289,8 +290,8 @@
             perm_create = Permission.get_by_key('hg.create.repository')
 
             #User should have None permission on creation repository
-            self.assertEqual(UserModel().has_perm(uid, perm_none), False)
-            self.assertEqual(UserModel().has_perm(uid, perm_create), True)
+            assert UserModel().has_perm(uid, perm_none) == False
+            assert UserModel().has_perm(uid, perm_create) == True
         finally:
             UserModel().delete(uid)
             Session().commit()
@@ -308,8 +309,8 @@
 
         try:
             #User should have None permission on creation repository
-            self.assertEqual(UserModel().has_perm(user, perm_none), False)
-            self.assertEqual(UserModel().has_perm(user, perm_create), False)
+            assert UserModel().has_perm(user, perm_none) == False
+            assert UserModel().has_perm(user, perm_create) == False
 
             response = self.app.post(url('edit_user_perms', id=uid),
                                      params=dict(_method='put', _authentication_token=self.authentication_token()))
@@ -318,8 +319,8 @@
             perm_create = Permission.get_by_key('hg.create.repository')
 
             #User should have None permission on creation repository
-            self.assertEqual(UserModel().has_perm(uid, perm_none), True)
-            self.assertEqual(UserModel().has_perm(uid, perm_create), False)
+            assert UserModel().has_perm(uid, perm_none) == True
+            assert UserModel().has_perm(uid, perm_create) == False
         finally:
             UserModel().delete(uid)
             Session().commit()
@@ -337,8 +338,8 @@
 
         try:
             #User should have None permission on creation repository
-            self.assertEqual(UserModel().has_perm(user, perm_none), False)
-            self.assertEqual(UserModel().has_perm(user, perm_fork), False)
+            assert UserModel().has_perm(user, perm_none) == False
+            assert UserModel().has_perm(user, perm_fork) == False
 
             response = self.app.post(url('edit_user_perms', id=uid),
                                      params=dict(_method='put',
@@ -349,8 +350,8 @@
             perm_create = Permission.get_by_key('hg.create.repository')
 
             #User should have None permission on creation repository
-            self.assertEqual(UserModel().has_perm(uid, perm_none), False)
-            self.assertEqual(UserModel().has_perm(uid, perm_create), True)
+            assert UserModel().has_perm(uid, perm_none) == False
+            assert UserModel().has_perm(uid, perm_create) == True
         finally:
             UserModel().delete(uid)
             Session().commit()
@@ -368,8 +369,8 @@
 
         try:
             #User should have None permission on creation repository
-            self.assertEqual(UserModel().has_perm(user, perm_none), False)
-            self.assertEqual(UserModel().has_perm(user, perm_fork), False)
+            assert UserModel().has_perm(user, perm_none) == False
+            assert UserModel().has_perm(user, perm_fork) == False
 
             response = self.app.post(url('edit_user_perms', id=uid),
                                      params=dict(_method='put', _authentication_token=self.authentication_token()))
@@ -378,8 +379,8 @@
             perm_create = Permission.get_by_key('hg.create.repository')
 
             #User should have None permission on creation repository
-            self.assertEqual(UserModel().has_perm(uid, perm_none), True)
-            self.assertEqual(UserModel().has_perm(uid, perm_create), False)
+            assert UserModel().has_perm(uid, perm_none) == True
+            assert UserModel().has_perm(uid, perm_create) == False
         finally:
             UserModel().delete(uid)
             Session().commit()
@@ -487,13 +488,13 @@
 
         #now delete our key
         keys = UserApiKeys.query().filter(UserApiKeys.user_id == user_id).all()
-        self.assertEqual(1, len(keys))
+        assert 1 == len(keys)
 
         response = self.app.post(url('edit_user_api_keys', id=user_id),
                  {'_method': 'delete', 'del_api_key': keys[0].api_key, '_authentication_token': self.authentication_token()})
         self.checkSessionFlash(response, 'API key successfully deleted')
         keys = UserApiKeys.query().filter(UserApiKeys.user_id == user_id).all()
-        self.assertEqual(0, len(keys))
+        assert 0 == len(keys)
 
     def test_reset_main_api_key(self):
         self.log_user()
diff -r 8d4f3a852716 -r be1d366f461c kallithea/tests/functional/test_changelog.py
--- a/kallithea/tests/functional/test_changelog.py	Mon May 09 17:46:34 2016 +0200
+++ b/kallithea/tests/functional/test_changelog.py	Sat May 14 21:04:26 2016 +0200
@@ -133,25 +133,25 @@
         response = self.app.get(url(controller='changelog', action='index',
                                     revision='tip', f_path='/tests',
                                     repo_name=HG_REPO))
-        self.assertEqual(response.status, '302 Found')
+        assert response.status == '302 Found'
 
     def test_index_git_with_filenode_that_is_dirnode(self):
         self.log_user()
         response = self.app.get(url(controller='changelog', action='index',
                                     revision='tip', f_path='/tests',
                                     repo_name=GIT_REPO))
-        self.assertEqual(response.status, '302 Found')
+        assert response.status == '302 Found'
 
     def test_index_hg_with_filenode_not_existing(self):
         self.log_user()
         response = self.app.get(url(controller='changelog', action='index',
                                     revision='tip', f_path='/wrong_path',
                                     repo_name=HG_REPO))
-        self.assertEqual(response.status, '302 Found')
+        assert response.status == '302 Found'
 
     def test_index_git_with_filenode_not_existing(self):
         self.log_user()
         response = self.app.get(url(controller='changelog', action='index',
                                     revision='tip', f_path='/wrong_path',
                                     repo_name=GIT_REPO))
-        self.assertEqual(response.status, '302 Found')
+        assert response.status == '302 Found'
diff -r 8d4f3a852716 -r be1d366f461c kallithea/tests/functional/test_changeset_comments.py
--- a/kallithea/tests/functional/test_changeset_comments.py	Mon May 09 17:46:34 2016 +0200
+++ b/kallithea/tests/functional/test_changeset_comments.py	Sat May 14 21:04:26 2016 +0200
@@ -23,29 +23,28 @@
                                      repo_name=HG_REPO, revision=rev),
                                      params=params, extra_environ={'HTTP_X_PARTIAL_XHR': '1'})
         # Test response...
-        self.assertEqual(response.status, '200 OK')
+        assert response.status == '200 OK'
 
         response = self.app.get(url(controller='changeset', action='index',
                                 repo_name=HG_REPO, revision=rev))
         # test DB
-        self.assertEqual(ChangesetComment.query().count(), 1)
+        assert ChangesetComment.query().count() == 1
         response.mustcontain(
             '''<div class="comments-number">'''
             ''' 1 comment (0 inline, 1 general)'''
         )
 
-        self.assertEqual(Notification.query().count(), 1)
-        self.assertEqual(ChangesetComment.query().count(), 1)
+        assert Notification.query().count() == 1
+        assert ChangesetComment.query().count() == 1
 
         notification = Notification.query().all()[0]
 
         ID = ChangesetComment.query().first().comment_id
-        self.assertEqual(notification.type_,
-                         Notification.TYPE_CHANGESET_COMMENT)
+        assert notification.type_ == Notification.TYPE_CHANGESET_COMMENT
         sbj = (u'/%s/changeset/'
                '27cd5cce30c96924232dffcd24178a07ffeb5dfc#comment-%s' % (HG_REPO, ID))
         print "%s vs %s" % (sbj, notification.subject)
-        self.assertTrue(sbj in notification.subject)
+        assert sbj in notification.subject
 
     def test_create_inline(self):
         self.log_user()
@@ -59,12 +58,12 @@
                                      repo_name=HG_REPO, revision=rev),
                                      params=params, extra_environ={'HTTP_X_PARTIAL_XHR': '1'})
         # Test response...
-        self.assertEqual(response.status, '200 OK')
+        assert response.status == '200 OK'
 
         response = self.app.get(url(controller='changeset', action='index',
                                 repo_name=HG_REPO, revision=rev))
         #test DB
-        self.assertEqual(ChangesetComment.query().count(), 1)
+        assert ChangesetComment.query().count() == 1
         response.mustcontain(
             '''<div class="comments-number">'''
             ''' 1 comment (1 inline, 0 general)'''
@@ -75,17 +74,16 @@
             '''data-line_no="n1" data-target-id="vcswebsimplevcsviewsrepositorypy_n1">'''
         )
 
-        self.assertEqual(Notification.query().count(), 1)
-        self.assertEqual(ChangesetComment.query().count(), 1)
+        assert Notification.query().count() == 1
+        assert ChangesetComment.query().count() == 1
 
         notification = Notification.query().all()[0]
         ID = ChangesetComment.query().first().comment_id
-        self.assertEqual(notification.type_,
-                         Notification.TYPE_CHANGESET_COMMENT)
+        assert notification.type_ == Notification.TYPE_CHANGESET_COMMENT
         sbj = (u'/%s/changeset/'
                '27cd5cce30c96924232dffcd24178a07ffeb5dfc#comment-%s' % (HG_REPO, ID))
         print "%s vs %s" % (sbj, notification.subject)
-        self.assertTrue(sbj in notification.subject)
+        assert sbj in notification.subject
 
     def test_create_with_mention(self):
         self.log_user()
@@ -98,22 +96,22 @@
                                      repo_name=HG_REPO, revision=rev),
                                      params=params, extra_environ={'HTTP_X_PARTIAL_XHR': '1'})
         # Test response...
-        self.assertEqual(response.status, '200 OK')
+        assert response.status == '200 OK'
 
         response = self.app.get(url(controller='changeset', action='index',
                                 repo_name=HG_REPO, revision=rev))
         # test DB
-        self.assertEqual(ChangesetComment.query().count(), 1)
+        assert ChangesetComment.query().count() == 1
         response.mustcontain(
             '''<div class="comments-number">'''
             ''' 1 comment (0 inline, 1 general)'''
         )
 
-        self.assertEqual(Notification.query().count(), 2)
+        assert Notification.query().count() == 2
         users = [x.user.username for x in UserNotification.query().all()]
 
         # test_regular gets notification by @mention
-        self.assertEqual(sorted(users), [TEST_USER_ADMIN_LOGIN, TEST_USER_REGULAR_LOGIN])
+        assert sorted(users) == [TEST_USER_ADMIN_LOGIN, TEST_USER_REGULAR_LOGIN]
 
     def test_delete(self):
         self.log_user()
@@ -126,7 +124,7 @@
                                      params=params, extra_environ={'HTTP_X_PARTIAL_XHR': '1'})
 
         comments = ChangesetComment.query().all()
-        self.assertEqual(len(comments), 1)
+        assert len(comments) == 1
         comment_id = comments[0].comment_id
 
         self.app.post(url(controller='changeset',
@@ -136,7 +134,7 @@
             params={'_method': 'delete', '_authentication_token': self.authentication_token()})
 
         comments = ChangesetComment.query().all()
-        self.assertEqual(len(comments), 0)
+        assert len(comments) == 0
 
         response = self.app.get(url(controller='changeset', action='index',
                                 repo_name=HG_REPO, revision=rev))
diff -r 8d4f3a852716 -r be1d366f461c kallithea/tests/functional/test_compare.py
--- a/kallithea/tests/functional/test_compare.py	Mon May 09 17:46:34 2016 +0200
+++ b/kallithea/tests/functional/test_compare.py	Sat May 14 21:04:26 2016 +0200
@@ -455,7 +455,7 @@
         cs0 = fixture.commit_change(repo=r1_name, filename='file1',
                 content='line1', message='commit1', vcs_type='hg', newfile=True)
         Session().commit()
-        self.assertEqual(repo1.scm_instance.revisions, [cs0.raw_id])
+        assert repo1.scm_instance.revisions == [cs0.raw_id]
         #fork the repo1
         repo2 = fixture.create_repo(u'one-fork', repo_type='hg',
                                     repo_description='diff-test',
@@ -463,7 +463,7 @@
                                     clone_uri=repo1.repo_full_path,
                                     fork_of='one')
         Session().commit()
-        self.assertEqual(repo2.scm_instance.revisions, [cs0.raw_id])
+        assert repo2.scm_instance.revisions == [cs0.raw_id]
         self.r2_id = repo2.repo_id
         r2_name = repo2.repo_name
 
@@ -535,7 +535,7 @@
                 content='line1', message='commit1', vcs_type='git',
                 newfile=True)
         Session().commit()
-        self.assertEqual(repo1.scm_instance.revisions, [cs0.raw_id])
+        assert repo1.scm_instance.revisions == [cs0.raw_id]
         #fork the repo1
         repo2 = fixture.create_repo(u'one-git-fork', repo_type='git',
                                     repo_description='diff-test',
@@ -543,7 +543,7 @@
                                     clone_uri=repo1.repo_full_path,
                                     fork_of='one-git')
         Session().commit()
-        self.assertEqual(repo2.scm_instance.revisions, [cs0.raw_id])
+        assert repo2.scm_instance.revisions == [cs0.raw_id]
         self.r2_id = repo2.repo_id
         r2_name = repo2.repo_name
 
diff -r 8d4f3a852716 -r be1d366f461c kallithea/tests/functional/test_files.py
--- a/kallithea/tests/functional/test_files.py	Mon May 09 17:46:34 2016 +0200
+++ b/kallithea/tests/functional/test_files.py	Sat May 14 21:04:26 2016 +0200
@@ -115,7 +115,7 @@
                                     revision='tip',
                                     f_path='vcs/nodes.py'),
                                 extra_environ={'HTTP_X_PARTIAL_XHR': '1'},)
-        self.assertEqual(response.body, HG_NODE_HISTORY)
+        assert response.body == HG_NODE_HISTORY
 
     def test_file_source_history_git(self):
         self.log_user()
@@ -124,7 +124,7 @@
                                     revision='master',
                                     f_path='vcs/nodes.py'),
                                 extra_environ={'HTTP_X_PARTIAL_XHR': '1'},)
-        self.assertEqual(response.body, GIT_NODE_HISTORY)
+        assert response.body == GIT_NODE_HISTORY
 
     def test_file_annotation(self):
         self.log_user()
@@ -154,7 +154,7 @@
                                     annotate=True),
                                 extra_environ={'HTTP_X_PARTIAL_XHR': '1'})
 
-        self.assertEqual(response.body, HG_NODE_HISTORY)
+        assert response.body == HG_NODE_HISTORY
 
     def test_file_annotation_history_git(self):
         self.log_user()
@@ -165,7 +165,7 @@
                                     annotate=True),
                                 extra_environ={'HTTP_X_PARTIAL_XHR': '1'})
 
-        self.assertEqual(response.body, GIT_NODE_HISTORY)
+        assert response.body == GIT_NODE_HISTORY
 
     def test_file_authors(self):
         self.log_user()
@@ -199,14 +199,14 @@
                                         repo_name=HG_REPO,
                                         fname=fname))
 
-            self.assertEqual(response.status, '200 OK')
+            assert response.status == '200 OK'
             heads = [
                 ('Pragma', 'no-cache'),
                 ('Cache-Control', 'no-cache'),
                 ('Content-Disposition', 'attachment; filename=%s' % filename),
                 ('Content-Type', '%s; charset=utf-8' % info[0]),
             ]
-            self.assertEqual(response.response._headers.items(), heads)
+            assert response.response._headers.items() == heads
 
     def test_archival_wrong_ext(self):
         self.log_user()
@@ -242,8 +242,8 @@
                                     revision='27cd5cce30c96924232dffcd24178a07ffeb5dfc',
                                     f_path='vcs/nodes.py'))
 
-        self.assertEqual(response.content_disposition, "attachment; filename=nodes.py")
-        self.assertEqual(response.content_type, mimetypes.guess_type("nodes.py")[0])
+        assert response.content_disposition == "attachment; filename=nodes.py"
+        assert response.content_type == mimetypes.guess_type("nodes.py")[0]
 
     def test_raw_file_wrong_cs(self):
         self.log_user()
@@ -280,7 +280,7 @@
                                     revision='27cd5cce30c96924232dffcd24178a07ffeb5dfc',
                                     f_path='vcs/nodes.py'))
 
-        self.assertEqual(response.content_type, "text/plain")
+        assert response.content_type == "text/plain"
 
     def test_raw_wrong_cs(self):
         self.log_user()
diff -r 8d4f3a852716 -r be1d366f461c kallithea/tests/functional/test_forks.py
--- a/kallithea/tests/functional/test_forks.py	Mon May 09 17:46:34 2016 +0200
+++ b/kallithea/tests/functional/test_forks.py	Sat May 14 21:04:26 2016 +0200
@@ -121,8 +121,8 @@
         fork_repo = Session().query(Repository) \
             .filter(Repository.repo_name == fork_name_full).one()
 
-        self.assertEqual(fork_repo.repo_name, fork_name_full)
-        self.assertEqual(fork_repo.fork.repo_name, repo_name)
+        assert fork_repo.repo_name == fork_name_full
+        assert fork_repo.fork.repo_name == repo_name
 
         # test if the repository is visible in the list ?
         response = self.app.get(url('summary_home', repo_name=fork_name_full))
@@ -164,8 +164,8 @@
         fork_repo = Session().query(Repository) \
             .filter(Repository.repo_name == fork_name).one()
 
-        self.assertEqual(fork_repo.repo_name, fork_name)
-        self.assertEqual(fork_repo.fork.repo_name, repo_name)
+        assert fork_repo.repo_name == fork_name
+        assert fork_repo.fork.repo_name == repo_name
 
         # test if the repository is visible in the list ?
         response = self.app.get(url('summary_home', repo_name=fork_name))
@@ -180,7 +180,7 @@
         forks = Repository.query() \
             .filter(Repository.repo_type == self.REPO_TYPE) \
             .filter(Repository.fork_id != None).all()
-        self.assertEqual(1, len(forks))
+        assert 1 == len(forks)
 
         # set read permissions for this
         RepoModel().grant_user_permission(repo=forks[0],
@@ -200,7 +200,7 @@
         forks = Repository.query() \
             .filter(Repository.repo_type == self.REPO_TYPE) \
             .filter(Repository.fork_id != None).all()
-        self.assertEqual(1, len(forks))
+        assert 1 == len(forks)
 
         # set none
         RepoModel().grant_user_permission(repo=forks[0],
diff -r 8d4f3a852716 -r be1d366f461c kallithea/tests/functional/test_login.py
--- a/kallithea/tests/functional/test_login.py	Mon May 09 17:46:34 2016 +0200
+++ b/kallithea/tests/functional/test_login.py	Sat May 14 21:04:26 2016 +0200
@@ -22,18 +22,18 @@
 class TestLoginController(TestControllerPytest):
     def setup_method(self, method):
         remove_all_notifications()
-        self.assertEqual(Notification.query().all(), [])
+        assert Notification.query().all() == []
 
     def test_index(self):
         response = self.app.get(url(controller='login', action='index'))
-        self.assertEqual(response.status, '200 OK')
+        assert response.status == '200 OK'
         # Test response...
 
     def test_login_admin_ok(self):
         response = self.app.post(url(controller='login', action='index'),
                                  {'username': TEST_USER_ADMIN_LOGIN,
                                   'password': TEST_USER_ADMIN_PASS})
-        self.assertEqual(response.status, '302 Found')
+        assert response.status == '302 Found'
         self.assert_authenticated_user(response, TEST_USER_ADMIN_LOGIN)
 
         response = response.follow()
@@ -44,7 +44,7 @@
                                  {'username': TEST_USER_REGULAR_LOGIN,
                                   'password': TEST_USER_REGULAR_PASS})
 
-        self.assertEqual(response.status, '302 Found')
+        assert response.status == '302 Found'
         self.assert_authenticated_user(response, TEST_USER_REGULAR_LOGIN)
 
         response = response.follow()
@@ -55,7 +55,7 @@
                                  {'username': TEST_USER_REGULAR_EMAIL,
                                   'password': TEST_USER_REGULAR_PASS})
 
-        self.assertEqual(response.status, '302 Found')
+        assert response.status == '302 Found'
         self.assert_authenticated_user(response, TEST_USER_REGULAR_LOGIN)
 
         response = response.follow()
@@ -67,10 +67,10 @@
                                      came_from=test_came_from),
                                  {'username': TEST_USER_ADMIN_LOGIN,
                                   'password': TEST_USER_ADMIN_PASS})
-        self.assertEqual(response.status, '302 Found')
+        assert response.status == '302 Found'
         response = response.follow()
 
-        self.assertEqual(response.status, '200 OK')
+        assert response.status == '200 OK'
         response.mustcontain('Users Administration')
 
     def test_login_do_not_remember(self):
@@ -79,10 +79,9 @@
                                   'password': TEST_USER_REGULAR_PASS,
                                   'remember': False})
 
-        self.assertIn('Set-Cookie', response.headers)
+        assert 'Set-Cookie' in response.headers
         for cookie in response.headers.getall('Set-Cookie'):
-            self.assertFalse(re.search(r';\s+(Max-Age|Expires)=', cookie, re.IGNORECASE),
-                'Cookie %r has expiration date, but should be a session cookie' % cookie)
+            assert not re.search(r';\s+(Max-Age|Expires)=', cookie, re.IGNORECASE), 'Cookie %r has expiration date, but should be a session cookie' % cookie
 
     def test_login_remember(self):
         response = self.app.post(url(controller='login', action='index'),
@@ -90,10 +89,9 @@
                                   'password': TEST_USER_REGULAR_PASS,
                                   'remember': True})
 
-        self.assertIn('Set-Cookie', response.headers)
+        assert 'Set-Cookie' in response.headers
         for cookie in response.headers.getall('Set-Cookie'):
-            self.assertTrue(re.search(r';\s+(Max-Age|Expires)=', cookie, re.IGNORECASE),
-                'Cookie %r should have expiration date, but is a session cookie' % cookie)
+            assert re.search(r';\s+(Max-Age|Expires)=', cookie, re.IGNORECASE), 'Cookie %r should have expiration date, but is a session cookie' % cookie
 
     def test_logout(self):
         response = self.app.post(url(controller='login', action='index'),
@@ -103,13 +101,13 @@
         # Verify that a login session has been established.
         response = self.app.get(url(controller='login', action='index'))
         response = response.follow()
-        self.assertIn('authuser', response.session)
+        assert 'authuser' in response.session
 
         response.click('Log Out')
 
         # Verify that the login session has been terminated.
         response = self.app.get(url(controller='login', action='index'))
-        self.assertNotIn('authuser', response.session)
+        assert 'authuser' not in response.session
 
     @parametrize('url_came_from', [
           ('data:text/html,<script>window.alert("xss")</script>',),
@@ -133,7 +131,7 @@
         response = self.app.post(url(controller='login', action='index'),
                                  {'username': TEST_USER_ADMIN_LOGIN,
                                   'password': 'as'})
-        self.assertEqual(response.status, '200 OK')
+        assert response.status == '200 OK'
 
         response.mustcontain('Enter 3 characters or more')
 
@@ -156,11 +154,11 @@
             response = self.app.get(url(controller='summary', action='index',
                                         repo_name=HG_REPO,
                                         **args))
-            self.assertEqual(response.status, '302 Found')
+            assert response.status == '302 Found'
             came_from = urlparse.parse_qs(urlparse.urlparse(response.location).query)['came_from'][0]
             came_from_qs = urlparse.parse_qsl(urlparse.urlparse(came_from).query)
             for encoded in args_encoded:
-                self.assertIn(encoded, came_from_qs)
+                assert encoded in came_from_qs
 
     @parametrize('args,args_encoded', [
         ({'foo':'one', 'bar':'two'}, ('foo=one', 'bar=two')),
@@ -172,7 +170,7 @@
                                     came_from=url('/_admin/users', **args)))
         came_from = urlparse.parse_qs(urlparse.urlparse(response.form.action).query)['came_from'][0]
         for encoded in args_encoded:
-            self.assertIn(encoded, came_from)
+            assert encoded in came_from
 
     @parametrize('args,args_encoded', [
         ({'foo':'one', 'bar':'two'}, ('foo=one', 'bar=two')),
@@ -184,9 +182,9 @@
                                      came_from = url('/_admin/users', **args)),
                                  {'username': TEST_USER_ADMIN_LOGIN,
                                   'password': TEST_USER_ADMIN_PASS})
-        self.assertEqual(response.status, '302 Found')
+        assert response.status == '302 Found'
         for encoded in args_encoded:
-            self.assertIn(encoded, response.location)
+            assert encoded in response.location
 
     @parametrize('args,args_encoded', [
         ({'foo':'one', 'bar':'two'}, ('foo=one', 'bar=two')),
@@ -202,7 +200,7 @@
         response.mustcontain('Invalid username or password')
         came_from = urlparse.parse_qs(urlparse.urlparse(response.form.action).query)['came_from'][0]
         for encoded in args_encoded:
-            self.assertIn(encoded, came_from)
+            assert encoded in came_from
 
     #==========================================================================
     # REGISTRATIONS
@@ -256,7 +254,7 @@
                                              'email': 'goodmailm',
                                              'firstname': 'test',
                                              'lastname': 'test'})
-        self.assertEqual(response.status, '200 OK')
+        assert response.status == '200 OK'
         response.mustcontain('An email address must contain a single @')
         response.mustcontain('Enter a value 6 characters long or more')
 
@@ -328,17 +326,17 @@
                                              'firstname': name,
                                              'lastname': lastname,
                                              'admin': True})  # This should be overridden
-        self.assertEqual(response.status, '302 Found')
+        assert response.status == '302 Found'
         self.checkSessionFlash(response, 'You have successfully registered into Kallithea')
 
         ret = Session().query(User).filter(User.username == 'test_regular4').one()
-        self.assertEqual(ret.username, username)
-        self.assertEqual(check_password(password, ret.password), True)
-        self.assertEqual(ret.email, email)
-        self.assertEqual(ret.name, name)
-        self.assertEqual(ret.lastname, lastname)
-        self.assertNotEqual(ret.api_key, None)
-        self.assertEqual(ret.admin, False)
+        assert ret.username == username
+        assert check_password(password, ret.password) == True
+        assert ret.email == email
+        assert ret.name == name
+        assert ret.lastname == lastname
+        assert ret.api_key != None
+        assert ret.admin == False
 
     #==========================================================================
     # PASSWORD RESET
@@ -356,7 +354,7 @@
     def test_forgot_password(self):
         response = self.app.get(url(controller='login',
                                     action='password_reset'))
-        self.assertEqual(response.status, '200 OK')
+        assert response.status == '200 OK'
 
         username = 'test_password_reset_1'
         password = 'qweqwe'
@@ -395,7 +393,7 @@
                                   'password_confirm': "p@ssw0rd",
                                   'token': token,
                                  })
-        self.assertEqual(response.status, '200 OK')
+        assert response.status == '200 OK'
         response.mustcontain('Invalid password reset token')
 
         # GOOD TOKEN
@@ -411,7 +409,7 @@
                                     email=email,
                                     timestamp=timestamp,
                                     token=token))
-        self.assertEqual(response.status, '200 OK')
+        assert response.status == '200 OK'
         response.mustcontain("You are about to set a new password for the email address %s" % email)
 
         response = self.app.post(url(controller='login',
@@ -422,7 +420,7 @@
                                   'password_confirm': "p@ssw0rd",
                                   'token': token,
                                  })
-        self.assertEqual(response.status, '302 Found')
+        assert response.status == '302 Found'
         self.checkSessionFlash(response, 'Successfully updated password')
 
         response = response.follow()
@@ -444,8 +442,7 @@
     def test_access_not_whitelisted_page_via_api_key(self, test_name, api_key):
         whitelist = self._get_api_whitelist([])
         with mock.patch('kallithea.CONFIG', whitelist):
-            self.assertEqual([],
-                             whitelist['api_access_controllers_whitelist'])
+            assert [] == whitelist['api_access_controllers_whitelist']
             if test_name == 'proper_api_key':
                 #use builtin if api_key is None
                 api_key = User.get_first_admin().api_key
@@ -467,8 +464,7 @@
     def test_access_whitelisted_page_via_api_key(self, test_name, api_key, code):
         whitelist = self._get_api_whitelist(['ChangesetController:changeset_raw'])
         with mock.patch('kallithea.CONFIG', whitelist):
-            self.assertEqual(['ChangesetController:changeset_raw'],
-                             whitelist['api_access_controllers_whitelist'])
+            assert ['ChangesetController:changeset_raw'] == whitelist['api_access_controllers_whitelist']
             if test_name == 'proper_api_key':
                 api_key = User.get_first_admin().api_key
 
@@ -481,8 +477,7 @@
     def test_access_page_via_extra_api_key(self):
         whitelist = self._get_api_whitelist(['ChangesetController:changeset_raw'])
         with mock.patch('kallithea.CONFIG', whitelist):
-            self.assertEqual(['ChangesetController:changeset_raw'],
-                             whitelist['api_access_controllers_whitelist'])
+            assert ['ChangesetController:changeset_raw'] == whitelist['api_access_controllers_whitelist']
 
             new_api_key = ApiKeyModel().create(TEST_USER_ADMIN_LOGIN, u'test')
             Session().commit()
@@ -495,8 +490,7 @@
     def test_access_page_via_expired_api_key(self):
         whitelist = self._get_api_whitelist(['ChangesetController:changeset_raw'])
         with mock.patch('kallithea.CONFIG', whitelist):
-            self.assertEqual(['ChangesetController:changeset_raw'],
-                             whitelist['api_access_controllers_whitelist'])
+            assert ['ChangesetController:changeset_raw'] == whitelist['api_access_controllers_whitelist']
 
             new_api_key = ApiKeyModel().create(TEST_USER_ADMIN_LOGIN, u'test')
             Session().commit()
diff -r 8d4f3a852716 -r be1d366f461c kallithea/tests/functional/test_my_account.py
--- a/kallithea/tests/functional/test_my_account.py	Mon May 09 17:46:34 2016 +0200
+++ b/kallithea/tests/functional/test_my_account.py	Sat May 14 21:04:26 2016 +0200
@@ -145,7 +145,7 @@
             params['admin'] = False
 
         params.pop('_authentication_token')
-        self.assertEqual(params, updated_params)
+        assert params == updated_params
 
     def test_my_account_update_err_email_exists(self):
         self.log_user()
@@ -223,13 +223,13 @@
 
         #now delete our key
         keys = UserApiKeys.query().all()
-        self.assertEqual(1, len(keys))
+        assert 1 == len(keys)
 
         response = self.app.post(url('my_account_api_keys'),
                  {'_method': 'delete', 'del_api_key': keys[0].api_key, '_authentication_token': self.authentication_token()})
         self.checkSessionFlash(response, 'API key successfully deleted')
         keys = UserApiKeys.query().all()
-        self.assertEqual(0, len(keys))
+        assert 0 == len(keys)
 
 
     def test_my_account_reset_main_api_key(self):
diff -r 8d4f3a852716 -r be1d366f461c kallithea/tests/functional/test_pullrequests.py
--- a/kallithea/tests/functional/test_pullrequests.py	Mon May 09 17:46:34 2016 +0200
+++ b/kallithea/tests/functional/test_pullrequests.py	Sat May 14 21:04:26 2016 +0200
@@ -28,9 +28,9 @@
                                   '_authentication_token': self.authentication_token(),
                                  }
                                 )
-        self.assertEqual(response.status, '302 Found')
+        assert response.status == '302 Found'
         response = response.follow()
-        self.assertEqual(response.status, '200 OK')
+        assert response.status == '200 OK'
         response.mustcontain('This pull request has already been merged to default.')
 
     def test_create_with_existing_reviewer(self):
@@ -47,9 +47,9 @@
                                   'review_members': TEST_USER_ADMIN_LOGIN,
                                  }
                                 )
-        self.assertEqual(response.status, '302 Found')
+        assert response.status == '302 Found'
         response = response.follow()
-        self.assertEqual(response.status, '200 OK')
+        assert response.status == '200 OK'
         response.mustcontain('This pull request has already been merged to default.')
 
     def test_create_with_invalid_reviewer(self):
@@ -86,11 +86,11 @@
                                   '_authentication_token': self.authentication_token(),
                                  }
                                 )
-        self.assertEqual(response.status, '302 Found')
+        assert response.status == '302 Found'
         # location is of the form:
         # http://localhost/vcs_test_hg/pull-request/54/_/title
         m = re.search('/pull-request/(\d+)/', response.location)
-        self.assertNotEqual(m, None)
+        assert m != None
         pull_request_id = m.group(1)
 
         # update it
@@ -123,11 +123,11 @@
                                   '_authentication_token': self.authentication_token(),
                                  }
                                 )
-        self.assertEqual(response.status, '302 Found')
+        assert response.status == '302 Found'
         # location is of the form:
         # http://localhost/vcs_test_hg/pull-request/54/_/title
         m = re.search('/pull-request/(\d+)/', response.location)
-        self.assertNotEqual(m, None)
+        assert m != None
         pull_request_id = m.group(1)
 
         # edit it
@@ -159,7 +159,7 @@
     def test_repo_refs_empty_repo(self):
         # empty repo with no commits, no branches, no bookmarks, just one tag
         refs, default = self.c._get_repo_refs(self.main.scm_instance)
-        self.assertEqual(default, 'tag:null:0000000000000000000000000000000000000000')
+        assert default == 'tag:null:0000000000000000000000000000000000000000'
 
     def test_repo_refs_one_commit_no_hints(self):
         cs0 = fixture.commit_change(self.main.repo_name, filename='file1',
@@ -167,9 +167,9 @@
                 parent=None, newfile=True)
 
         refs, default = self.c._get_repo_refs(self.main.scm_instance)
-        self.assertEqual(default, 'branch:default:%s' % cs0.raw_id)
-        self.assertIn(([('branch:default:%s' % cs0.raw_id, 'default (current tip)')],
-                'Branches'), refs)
+        assert default == 'branch:default:%s' % cs0.raw_id
+        assert ([('branch:default:%s' % cs0.raw_id, 'default (current tip)')],
+                'Branches') in refs
 
     def test_repo_refs_one_commit_rev_hint(self):
         cs0 = fixture.commit_change(self.main.repo_name, filename='file1',
@@ -178,8 +178,8 @@
 
         refs, default = self.c._get_repo_refs(self.main.scm_instance, rev=cs0.raw_id)
         expected = 'branch:default:%s' % cs0.raw_id
-        self.assertEqual(default, expected)
-        self.assertIn(([(expected, 'default (current tip)')], 'Branches'), refs)
+        assert default == expected
+        assert ([(expected, 'default (current tip)')], 'Branches') in refs
 
     def test_repo_refs_two_commits_no_hints(self):
         cs0 = fixture.commit_change(self.main.repo_name, filename='file1',
@@ -191,8 +191,8 @@
 
         refs, default = self.c._get_repo_refs(self.main.scm_instance)
         expected = 'branch:default:%s' % cs1.raw_id
-        self.assertEqual(default, expected)
-        self.assertIn(([(expected, 'default (current tip)')], 'Branches'), refs)
+        assert default == expected
+        assert ([(expected, 'default (current tip)')], 'Branches') in refs
 
     def test_repo_refs_two_commits_rev_hints(self):
         cs0 = fixture.commit_change(self.main.repo_name, filename='file1',
@@ -204,14 +204,14 @@
 
         refs, default = self.c._get_repo_refs(self.main.scm_instance, rev=cs0.raw_id)
         expected = 'rev:%s:%s' % (cs0.raw_id, cs0.raw_id)
-        self.assertEqual(default, expected)
-        self.assertIn(([(expected, 'Changeset: %s' % cs0.raw_id[0:12])], 'Special'), refs)
-        self.assertIn(([('branch:default:%s' % cs1.raw_id, 'default (current tip)')], 'Branches'), refs)
+        assert default == expected
+        assert ([(expected, 'Changeset: %s' % cs0.raw_id[0:12])], 'Special') in refs
+        assert ([('branch:default:%s' % cs1.raw_id, 'default (current tip)')], 'Branches') in refs
 
         refs, default = self.c._get_repo_refs(self.main.scm_instance, rev=cs1.raw_id)
         expected = 'branch:default:%s' % cs1.raw_id
-        self.assertEqual(default, expected)
-        self.assertIn(([(expected, 'default (current tip)')], 'Branches'), refs)
+        assert default == expected
+        assert ([(expected, 'default (current tip)')], 'Branches') in refs
 
     def test_repo_refs_two_commits_branch_hint(self):
         cs0 = fixture.commit_change(self.main.repo_name, filename='file1',
@@ -223,8 +223,8 @@
 
         refs, default = self.c._get_repo_refs(self.main.scm_instance, branch='default')
         expected = 'branch:default:%s' % cs1.raw_id
-        self.assertEqual(default, expected)
-        self.assertIn(([(expected, 'default (current tip)')], 'Branches'), refs)
+        assert default == expected
+        assert ([(expected, 'default (current tip)')], 'Branches') in refs
 
     def test_repo_refs_one_branch_no_hints(self):
         cs0 = fixture.commit_change(self.main.repo_name, filename='file1',