tests: stabilize tests for mysql/postgres.

rhodecode/apps/admin/tests/test_admin_auth_settings.py

@@ -155,7 +155,7 b' class TestAuthSettingsView(object):'
         response = self._post_ldap_settings(params, override={
             'port': invalid_port_value,
         })
-        assertr = AssertResponse(response)
+        assertr = response.assert_response()
         assertr.element_contains(
             '.form .field #port ~ .error-message',
             invalid_port_value)

rhodecode/apps/admin/tests/test_admin_repos.py

@@ -81,13 +81,13 b' class TestAdminRepos(object):'
     def test_create_page_restricted_to_single_backend(self, autologin_user, backend):
         with mock.patch('rhodecode.BACKENDS', {'git': 'git'}):
             response = self.app.get(route_path('repo_new'), status=200)
-        assert_response = AssertResponse(response)
+        assert_response = response.assert_response()
         element = assert_response.get_element('#repo_type')
         assert element.text_content() == '\ngit\n'
 
     def test_create_page_non_restricted_backends(self, autologin_user, backend):
         response = self.app.get(route_path('repo_new'), status=200)
-        assert_response = AssertResponse(response)
+        assert_response = response.assert_response()
         assert_response.element_contains('#repo_type', 'git')
         assert_response.element_contains('#repo_type', 'svn')
         assert_response.element_contains('#repo_type', 'hg')

rhodecode/apps/admin/tests/test_admin_settings.py

@@ -367,7 +367,7 b' class TestAdminSettingsVcs(object):'
 
     def test_has_an_input_for_invalidation_of_inline_comments(self):
         response = self.app.get(route_path('admin_settings_vcs'))
-        assert_response = AssertResponse(response)
+        assert_response = response.assert_response()
         assert_response.one_element_exists(
             '[name=rhodecode_use_outdated_comments]')
 
@@ -518,7 +518,7 b' class TestOpenSourceLicenses(object):'
             response = self.app.get(
                 route_path('admin_settings_open_source'), status=200)
 
-        assert_response = AssertResponse(response)
+        assert_response = response.assert_response()
         assert_response.element_contains(
             '.panel-heading', 'Licenses of Third Party Packages')
         for license_data in sample_licenses:
@@ -528,7 +528,7 b' class TestOpenSourceLicenses(object):'
     def test_records_can_be_read(self, autologin_user):
         response = self.app.get(
             route_path('admin_settings_open_source'), status=200)
-        assert_response = AssertResponse(response)
+        assert_response = response.assert_response()
         assert_response.element_contains(
             '.panel-heading', 'Licenses of Third Party Packages')
 

rhodecode/apps/login/tests/test_password_reset.py

@@ -88,7 +88,7 b' class TestPasswordReset(TestController):'
 
         response = self.app.get(route_path('reset_password'))
         
-        assert_response = AssertResponse(response)
+        assert_response = response.assert_response()
         if show_reset:
             response.mustcontain('Send password reset email')
             assert_response.one_element_exists('#email')

rhodecode/apps/login/tests/test_register_captcha.py

@@ -90,7 +90,7 b' class TestRegisterCaptcha(object):'
 
         response = app.get(ADMIN_PREFIX + '/register')
 
-        assertr = AssertResponse(response)
+        assertr = response.assert_response()
         if active:
             assertr.one_element_exists('#recaptcha_field')
         else:
@@ -128,6 +128,6 b' class TestRegisterCaptcha(object):'
         else:
             # If captche input is invalid we expect to stay on the registration
             # page with an error message displayed.
-            assertr = AssertResponse(response)
+            assertr = response.assert_response()
             assert response.status_int == 200
             assertr.one_element_exists('#recaptcha_field ~ span.error-message')

rhodecode/apps/repository/tests/test_repo_feed.py

@@ -116,7 +116,7 b' class TestFeedView(TestController):'
             self, backend, user_util, feed_type):
         user = user_util.create_user()
         auth_token = AuthTokenModel().create(
-            user.user_id, 'test-token', -1, AuthTokenModel.cls.ROLE_API)
+            user.user_id, u'test-token', -1, AuthTokenModel.cls.ROLE_API)
         auth_token = auth_token.api_key
 
         self.app.get(
@@ -127,7 +127,7 b' class TestFeedView(TestController):'
             status=302)
 
         auth_token = AuthTokenModel().create(
-            user.user_id, 'test-token', -1, AuthTokenModel.cls.ROLE_FEED)
+            user.user_id, u'test-token', -1, AuthTokenModel.cls.ROLE_FEED)
         auth_token = auth_token.api_key
         self.app.get(
             route_path(

rhodecode/apps/repository/tests/test_repo_summary.py

@@ -236,7 +236,7 b' class TestSummaryView(object):'
         with scm_patcher:
             response = self.app.get(
                 route_path('repo_summary', repo_name=repo_name))
-        assert_response = AssertResponse(response)
+        assert_response = response.assert_response()
         assert_response.element_contains(
             '.main .alert-warning strong', 'Missing requirements')
         assert_response.element_contains(

rhodecode/apps/repository/tests/test_repo_vcs_settings.py

@@ -98,7 +98,7 b' class TestVcsSettings(object):'
         repo_name = backend.repo_name
         response = self.app.get(route_path('edit_repo_vcs', repo_name=repo_name))
 
-        assert_response = AssertResponse(response)
+        assert_response = response.assert_response()
         element = assert_response.get_element('#inherit_global_settings')
         assert element.checked
 
@@ -111,7 +111,7 b' class TestVcsSettings(object):'
             repo, 'inherit_vcs_settings', checked_value, 'bool')
         response = self.app.get(route_path('edit_repo_vcs', repo_name=repo_name))
 
-        assert_response = AssertResponse(response)
+        assert_response = response.assert_response()
         element = assert_response.get_element('#inherit_global_settings')
         assert element.checked == checked_value
 
@@ -491,7 +491,7 b' class TestVcsSettings(object):'
 
         response = self.app.get(
             route_path('edit_repo_vcs', repo_name=repo_name), status=200)
-        assert_response = AssertResponse(response)
+        assert_response = response.assert_response()
         for branch in branches:
             css_selector = '[name=branch_value_{}]'.format(branch.ui_id)
             element = assert_response.get_element(css_selector)
@@ -668,7 +668,7 b' class TestVcsSettings(object):'
         Session().commit()
 
     def assert_repo_value_equals_global_value(self, response, setting):
-        assert_response = AssertResponse(response)
+        assert_response = response.assert_response()
         global_css_selector = '[name={}_inherited]'.format(setting)
         repo_css_selector = '[name={}]'.format(setting)
         repo_element = assert_response.get_element(repo_css_selector)

rhodecode/apps/repository/tests/test_vcs_settings.py

@@ -59,7 +59,7 b' class TestAdminRepoVcsSettings(object):'
                 rhodecode.CONFIG, {'labs_settings_active': 'true'}):
             response = self.app.get(vcs_settings_url)
 
-        assertr = AssertResponse(response)
+        assertr = response.assert_response()
         assertr.one_element_exists('#rhodecode_{}'.format(setting_name))
 
     @pytest.mark.parametrize('setting_name, setting_backends', [

rhodecode/apps/search/tests/test_search.py

@@ -46,7 +46,7 b' class TestSearchController(TestControlle'
     def test_index(self):
         self.log_user()
         response = self.app.get(route_path('search'))
-        assert_response = AssertResponse(response)
+        assert_response = response.assert_response()
         assert_response.one_element_exists('input#q')
 
     def test_search_files_empty_search(self):

rhodecode/apps/user_profile/tests/test_users.py

@@ -46,14 +46,14 b' class TestUsersController(TestController'
         response = self.app.get(route_path('user_profile', username=username))
         response.mustcontain('testme')
         response.mustcontain('[e-mail]')
-        assert_response = AssertResponse(response)
+        assert_response = response.assert_response()
         assert_response.no_element_exists(edit_link_css)
 
         # edit should be available to superadmin users
         self.logout_user()
         self.log_user(TEST_USER_ADMIN_LOGIN, TEST_USER_ADMIN_PASS)
         response = self.app.get(route_path('user_profile', username=username))
-        assert_response = AssertResponse(response)
+        assert_response = response.assert_response()
         assert_response.element_contains(edit_link_css, 'Edit')
 
     def test_user_profile_not_available(self, user_util):

rhodecode/model/db.py

@@ -584,7 +584,7 b' class User(Base, BaseModel):'
     _user_data = Column("user_data", LargeBinary(), nullable=True)  # JSON data
 
     user_log = relationship('UserLog')
-    user_perms = relationship('UserToPerm', primaryjoin="User.user_id==UserToPerm.user_id", cascade='all')
+    user_perms = relationship('UserToPerm', primaryjoin="User.user_id==UserToPerm.user_id", cascade='all, delete-orphan')
 
     repositories = relationship('Repository')
     repository_groups = relationship('RepoGroup')
@@ -593,9 +593,9 b' class User(Base, BaseModel):'
     user_followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_user_id==User.user_id', cascade='all')
     followings = relationship('UserFollowing', primaryjoin='UserFollowing.user_id==User.user_id', cascade='all')
 
-    repo_to_perm = relationship('UserRepoToPerm', primaryjoin='UserRepoToPerm.user_id==User.user_id', cascade='all')
-    repo_group_to_perm = relationship('UserRepoGroupToPerm', primaryjoin='UserRepoGroupToPerm.user_id==User.user_id', cascade='all')
-    user_group_to_perm = relationship('UserUserGroupToPerm', primaryjoin='UserUserGroupToPerm.user_id==User.user_id', cascade='all')
+    repo_to_perm = relationship('UserRepoToPerm', primaryjoin='UserRepoToPerm.user_id==User.user_id', cascade='all, delete-orphan')
+    repo_group_to_perm = relationship('UserRepoGroupToPerm', primaryjoin='UserRepoGroupToPerm.user_id==User.user_id', cascade='all, delete-orphan')
+    user_group_to_perm = relationship('UserUserGroupToPerm', primaryjoin='UserUserGroupToPerm.user_id==User.user_id', cascade='all, delete-orphan')
 
     group_member = relationship('UserGroupMember', cascade='all')
 
@@ -1328,7 +1328,7 b' class UserGroup(Base, BaseModel):'
     created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
     _group_data = Column("group_data", LargeBinary(), nullable=True)  # JSON data
 
-    members = relationship('UserGroupMember', cascade="all, delete, delete-orphan", lazy="joined")
+    members = relationship('UserGroupMember', cascade="all, delete-orphan", lazy="joined")
     users_group_to_perm = relationship('UserGroupToPerm', cascade='all')
     users_group_repo_to_perm = relationship('UserGroupRepoToPerm', cascade='all')
     users_group_repo_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')
@@ -1665,21 +1665,21 b' class Repository(Base, BaseModel):'
         primaryjoin='UserFollowing.follows_repo_id==Repository.repo_id',
         cascade='all')
     extra_fields = relationship(
-        'RepositoryField', cascade="all, delete, delete-orphan")
+        'RepositoryField', cascade="all, delete-orphan")
     logs = relationship('UserLog')
     comments = relationship(
-        'ChangesetComment', cascade="all, delete, delete-orphan")
+        'ChangesetComment', cascade="all, delete-orphan")
     pull_requests_source = relationship(
         'PullRequest',
         primaryjoin='PullRequest.source_repo_id==Repository.repo_id',
-        cascade="all, delete, delete-orphan")
+        cascade="all, delete-orphan")
     pull_requests_target = relationship(
         'PullRequest',
         primaryjoin='PullRequest.target_repo_id==Repository.repo_id',
-        cascade="all, delete, delete-orphan")
+        cascade="all, delete-orphan")
     ui = relationship('RepoRhodeCodeUi', cascade="all")
     settings = relationship('RepoRhodeCodeSetting', cascade="all")
-    integrations = relationship('Integration', cascade="all, delete, delete-orphan")
+    integrations = relationship('Integration', cascade="all, delete-orphan")
 
     scoped_tokens = relationship('UserApiKeys', cascade="all")
 
@@ -2551,7 +2551,7 b' class RepoGroup(Base, BaseModel):'
     users_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')
     parent_group = relationship('RepoGroup', remote_side=group_id)
     user = relationship('User')
-    integrations = relationship('Integration', cascade="all, delete, delete-orphan")
+    integrations = relationship('Integration', cascade="all, delete-orphan")
 
     def __init__(self, group_name='', parent_group=None):
         self.group_name = group_name
@@ -3270,7 +3270,7 b' class UserRepoToPerm(Base, BaseModel):'
     repository = relationship('Repository')
     permission = relationship('Permission')
 
-    branch_perm_entry = relationship('UserToRepoBranchPermission', cascade="all, delete, delete-orphan", lazy='joined')
+    branch_perm_entry = relationship('UserToRepoBranchPermission', cascade="all, delete-orphan", lazy='joined')
 
     @classmethod
     def create(cls, user, repository, permission):
@@ -3646,7 +3646,7 b' class ChangesetComment(Base, BaseModel):'
 
     author = relationship('User', lazy='joined')
     repo = relationship('Repository')
-    status_change = relationship('ChangesetStatus', cascade="all, delete, delete-orphan", lazy='joined')
+    status_change = relationship('ChangesetStatus', cascade="all, delete-orphan", lazy='joined')
     pull_request = relationship('PullRequest', lazy='joined')
     pull_request_version = relationship('PullRequestVersion')
 
@@ -4120,13 +4120,13 b' class PullRequest(Base, _PullRequestBase'
             return '<DB:PullRequest at %#x>' % id(self)
 
     reviewers = relationship('PullRequestReviewers',
-                             cascade="all, delete, delete-orphan")
+                             cascade="all, delete-orphan")
     statuses = relationship('ChangesetStatus',
-                            cascade="all, delete, delete-orphan")
+                            cascade="all, delete-orphan")
     comments = relationship('ChangesetComment',
-                            cascade="all, delete, delete-orphan")
+                            cascade="all, delete-orphan")
     versions = relationship('PullRequestVersion',
-                            cascade="all, delete, delete-orphan",
+                            cascade="all, delete-orphan",
                             lazy='dynamic')
 
     @classmethod
@@ -4341,7 +4341,7 b' class Notification(Base, BaseModel):'
 
     created_by_user = relationship('User')
     notifications_to_users = relationship('UserNotification', lazy='joined',
-                                          cascade="all, delete, delete-orphan")
+                                          cascade="all, delete-orphan")
 
     @property
     def recipients(self):

rhodecode/model/user.py

@@ -510,8 +510,7 b' class UserModel(BaseModel):'
         from rhodecode.lib.hooks_base import log_delete_user
 
         if not cur_user:
-            cur_user = getattr(
-                get_current_rhodecode_user(), 'username', None)
+            cur_user = getattr(get_current_rhodecode_user(), 'username', None)
         user = self._get_user(user)
 
         try:

rhodecode/tests/lib/test_auth.py

@@ -27,7 +27,7 b' from mock import patch'
 from rhodecode.lib import auth
 from rhodecode.lib.utils2 import md5
 from rhodecode.model.auth_token import AuthTokenModel
-from rhodecode.model.db import User
+from rhodecode.model.db import Session, User
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.user import UserModel
 from rhodecode.model.user_group import UserGroupModel
@@ -93,6 +93,7 b' def test_cached_perms_data_user_group_gl'
 
     granted_permission = 'repository.write'
     UserGroupModel().grant_perm(user_group, granted_permission)
+    Session().commit()
 
     permissions = get_permissions(user)
     assert granted_permission in permissions['global']
@@ -104,6 +105,7 b' def test_cached_perms_data_user_group_gl'
 
     granted_permission = 'repository.write'
     UserGroupModel().grant_perm(user_group, granted_permission)
+    Session().commit()
 
     permissions = get_permissions(user)
     assert granted_permission in permissions['global']
@@ -112,6 +114,7 b' def test_cached_perms_data_user_group_gl'
 def test_cached_perms_data_user_global_permissions(user_util):
     user = user_util.create_user()
     UserModel().grant_perm(user, 'repository.none')
+    Session().commit()
 
     permissions = get_permissions(user, user_inherit_default_permissions=True)
     assert 'repository.read' in permissions['global']
@@ -127,6 +130,7 b' def test_cached_perms_data_repository_pe'
     granted_permission = 'repository.write'
     RepoModel().grant_user_group_permission(
         repo, user_group.users_group_name, granted_permission)
+    Session().commit()
 
     permissions = get_permissions(user)
     assert permissions['repositories'][repo.repo_name] == granted_permission
@@ -153,6 +157,7 b' def test_cached_perms_data_repository_pe'
 
     # Don't inherit default object permissions
     UserModel().grant_perm(user, 'hg.inherit_default_perms.false')
+    Session().commit()
 
     permissions = get_permissions(user)
     assert permissions['repositories'][repo.repo_name] == 'repository.none'
@@ -203,6 +208,7 b' def test_cached_perms_data_default_permi'
     # Don't inherit default object permissions
     user = user_util.create_user()
     UserModel().grant_perm(user, 'hg.inherit_default_perms.false')
+    Session().commit()
 
     permissions = get_permissions(user)
     assert permissions['repositories_groups'][repo_group.group_name] == \
@@ -224,6 +230,7 b' def test_cached_perms_data_repository_pe'
         repo, user_group.users_group_name, 'repository.read')
     RepoModel().grant_user_group_permission(
         repo, user_group2.users_group_name, 'repository.write')
+    Session().commit()
 
     permissions = get_permissions(user)
     assert permissions['repositories'][repo.repo_name] == 'repository.write'
@@ -238,6 +245,7 b' def test_cached_perms_data_repository_pe'
 
     RepoModel().grant_user_group_permission(
         repo, user_group.users_group_name, 'repository.write')
+    Session().commit()
 
     permissions = get_permissions(user)
     assert permissions['repositories'][repo.repo_name] == 'repository.admin'
@@ -249,6 +257,7 b' def test_cached_perms_data_user_reposito'
     repo = backend_random.create_repo()
     granted_permission = 'repository.write'
     RepoModel().grant_user_permission(repo, user, granted_permission)
+    Session().commit()
 
     permissions = get_permissions(user)
     assert permissions['repositories'][repo.repo_name] == granted_permission
@@ -260,6 +269,7 b' def test_cached_perms_data_user_reposito'
     repo = backend_random.create_repo()
     granted_permission = 'repository.none'
     RepoModel().grant_user_permission(repo, user, granted_permission)
+    Session().commit()
 
     permissions = get_permissions(user, explicit=True)
     assert permissions['repositories'][repo.repo_name] == granted_permission
@@ -271,6 +281,7 b' def test_cached_perms_data_user_reposito'
     repo = backend_random.create_repo()
     repo.user_id = user.user_id
     RepoModel().grant_user_permission(repo, user, 'repository.write')
+    Session().commit()
 
     permissions = get_permissions(user)
     assert permissions['repositories'][repo.repo_name] == 'repository.admin'
@@ -380,6 +391,7 b' def test_cached_perms_data_user_group_pe'
     user = user_util.create_user()
     user_group = user_util.create_user_group()
     UserGroupModel().grant_user_permission(user_group, user, 'usergroup.write')
+    Session().commit()
 
     permissions = get_permissions(user)
     assert permissions['user_groups'][user_group.users_group_name] == \
@@ -391,6 +403,7 b' def test_cached_perms_data_user_group_pe'
     user = user_util.create_user()
     user_group = user_util.create_user_group()
     UserGroupModel().grant_user_permission(user_group, user, 'usergroup.none')
+    Session().commit()
 
     permissions = get_permissions(user, explicit=True)
     assert permissions['user_groups'][user_group.users_group_name] == \
@@ -404,6 +417,7 b' def test_cached_perms_data_user_group_pe'
 
     # Don't inherit default object permissions
     UserModel().grant_perm(user, 'hg.inherit_default_perms.false')
+    Session().commit()
 
     permissions = get_permissions(user)
     assert permissions['user_groups'][user_group.users_group_name] == \
@@ -447,6 +461,7 b' def test_permission_calculator_repositor'
 
     RepoModel().grant_user_permission(
         backend_random.repo, user, 'repository.write')
+    Session().commit()
 
     calculator = auth.PermissionCalculator(
         user.user_id, {}, False, False, False, 'higherwin')
@@ -610,7 +625,7 b' def test_auth_by_token(test_token, test_'
     user = user_util.create_user()
     user_id = user.user_id
     for token, role, expires in expected_tokens:
-        new_token = AuthTokenModel().create(user_id, 'test-token', expires, role)
+        new_token = AuthTokenModel().create(user_id, u'test-token', expires, role)
         new_token.api_key = token  # inject known name for testing...
 
     assert auth_result == user.authenticate_by_token(

rhodecode/tests/models/settings/test_vcs_settings.py

@@ -277,6 +277,8 b' class TestCreateOrUpdateRepoHookSettings'
 
         with pytest.raises(ValueError) as exc_info:
             model.create_or_update_repo_hook_settings(data)
+            Session().commit()
+
         msg = 'The given data does not contain {} key'.format(deleted_key)
         assert str(exc_info.value) == msg
 
@@ -286,6 +288,8 b' class TestCreateOrUpdateRepoHookSettings'
             settings_util.create_repo_rhodecode_ui(
                 repo_stub, section, None, key=key, active=False)
         model.create_or_update_repo_hook_settings(HOOKS_FORM_DATA)
+        Session().commit()
+
         for section, key in model.HOOKS_SETTINGS:
             ui = model.repo_settings.get_ui_by_section_and_key(section, key)
             assert ui.ui_active is True
@@ -297,6 +301,7 b' class TestCreateOrUpdateRepoHookSettings'
         with global_patch as global_mock:
             global_mock.get_ui_by_section_and_key.return_value = global_setting
             model.create_or_update_repo_hook_settings(HOOKS_FORM_DATA)
+            Session().commit()
 
 
 class TestUpdateGlobalHookSettings(object):
@@ -309,6 +314,8 b' class TestUpdateGlobalHookSettings(objec'
 
         with pytest.raises(ValueError) as exc_info:
             model.update_global_hook_settings(data)
+            Session().commit()
+
         msg = 'The given data does not contain {} key'.format(deleted_key)
         assert str(exc_info.value) == msg
 
@@ -322,6 +329,8 b' class TestUpdateGlobalHookSettings(objec'
         session_patcher = mock.patch('rhodecode.model.settings.Session')
         with get_settings_patcher as get_settings_mock, session_patcher:
             model.update_global_hook_settings(HOOKS_FORM_DATA)
+            Session().commit()
+
         assert setting_mock.ui_active is True
         assert get_settings_mock.call_count == 3
 
@@ -333,6 +342,8 b' class TestCreateOrUpdateRepoGeneralSetti'
             model, '_create_or_update_general_settings')
         with create_patch as create_mock:
             model.create_or_update_repo_pr_settings(GENERAL_FORM_DATA)
+            Session().commit()
+
         create_mock.assert_called_once_with(
             model.repo_settings, GENERAL_FORM_DATA)
 
@@ -380,6 +391,7 b' class TestCreateOrUpdateGeneralSettings('
 
         with pytest.raises(ValueError) as exc_info:
             model._create_or_update_general_settings(model.repo_settings, data)
+        Session().commit()
 
         msg = 'The given data does not contain {} key'.format(deleted_key)
         assert str(exc_info.value) == msg
@@ -392,6 +404,7 b' class TestCreateOrUpdateGeneralSettings('
 
         model._create_or_update_general_settings(
             model.repo_settings, GENERAL_FORM_DATA)
+        Session().commit()
 
         for name in model.GENERAL_SETTINGS:
             setting = model.repo_settings.get_setting_by_name(name)
@@ -403,12 +416,16 b' class TestCreateRepoSvnSettings(object):'
         model = VcsSettingsModel(repo=repo_stub.repo_name)
         with mock.patch.object(model, '_create_svn_settings') as create_mock:
             model.create_repo_svn_settings(SVN_FORM_DATA)
+            Session().commit()
+
         create_mock.assert_called_once_with(model.repo_settings, SVN_FORM_DATA)
 
     def test_raises_exception_when_repository_is_not_specified(self):
         model = VcsSettingsModel()
         with pytest.raises(Exception) as exc_info:
             model.create_repo_svn_settings(SVN_FORM_DATA)
+            Session().commit()
+
         assert str(exc_info.value) == 'Repository is not specified'
 
 
@@ -547,6 +564,8 b' class TestCreateOrUpdateRepoHgSettings(o'
         data.pop(field_to_remove)
         with pytest.raises(ValueError) as exc_info:
             model.create_or_update_repo_hg_settings(data)
+            Session().commit()
+
         expected_message = 'The given data does not contain {} key'.format(
             field_to_remove)
         assert str(exc_info.value) == expected_message
@@ -555,6 +574,8 b' class TestCreateOrUpdateRepoHgSettings(o'
         model = VcsSettingsModel()
         with pytest.raises(Exception) as exc_info:
             model.create_or_update_repo_hg_settings(self.FORM_DATA)
+            Session().commit()
+
         assert str(exc_info.value) == 'Repository is not specified'
 
 
@@ -563,6 +584,8 b' class TestUpdateGlobalSslSetting(object)'
         model = VcsSettingsModel()
         with mock.patch.object(model, '_create_or_update_ui') as create_mock:
             model.update_global_ssl_setting('False')
+            Session().commit()
+
         create_mock.assert_called_once_with(
             model.global_settings, 'web', 'push_ssl', value='False')
 
@@ -572,6 +595,8 b' class TestUpdateGlobalPathSetting(object'
         model = VcsSettingsModel()
         with mock.patch.object(model, '_create_or_update_ui') as create_mock:
             model.update_global_path_setting('False')
+            Session().commit()
+
         create_mock.assert_called_once_with(
             model.global_settings, 'paths', '/', value='False')
 
@@ -589,6 +614,8 b' class TestCreateOrUpdateGlobalHgSettings'
         model = VcsSettingsModel()
         with mock.patch.object(model, '_create_or_update_ui') as create_mock:
             model.create_or_update_global_hg_settings(self.FORM_DATA)
+            Session().commit()
+
         expected_calls = [
             mock.call(model.global_settings, 'extensions', 'largefiles', active=False, value=''),
             mock.call(model.global_settings, 'largefiles', 'usercache', value='/example/largefiles-store'),
@@ -609,6 +636,8 b' class TestCreateOrUpdateGlobalHgSettings'
         data.pop(field_to_remove)
         with pytest.raises(Exception) as exc_info:
             model.create_or_update_global_hg_settings(data)
+            Session().commit()
+
         expected_message = 'The given data does not contain {} key'.format(
             field_to_remove)
         assert str(exc_info.value) == expected_message
@@ -624,6 +653,8 b' class TestCreateOrUpdateGlobalGitSetting'
         model = VcsSettingsModel()
         with mock.patch.object(model, '_create_or_update_ui') as create_mock:
             model.create_or_update_global_git_settings(self.FORM_DATA)
+            Session().commit()
+
         expected_calls = [
             mock.call(model.global_settings, 'vcs_git_lfs', 'enabled', active=False, value=False),
             mock.call(model.global_settings, 'vcs_git_lfs', 'store_location', value='/example/lfs-store'),
@@ -649,6 +680,8 b' class TestDeleteRepoSvnPattern(object):'
         delete_ui_patch = mock.patch.object(model.repo_settings, 'delete_ui')
         with delete_ui_patch as delete_ui_mock:
             model.delete_repo_svn_pattern(123)
+            Session().commit()
+
         delete_ui_mock.assert_called_once_with(-1)
 
     def test_raises_exception_when_repository_is_not_specified(self):
@@ -748,6 +781,8 b' class TestGetRepoUiSettings(object):'
         for section in svn_sections:
             settings_util.create_rhodecode_ui(
                 section, 'repo', key='deadbeef' + section, active=False)
+            Session().commit()
+
         model = VcsSettingsModel(repo=repo_stub.repo_name)
         result = model.get_repo_ui_settings()
         for setting in result:
@@ -795,6 +830,8 b' class TestGetRepoGeneralSettings(object)'
         for key in VcsSettingsModel.GENERAL_SETTINGS:
             settings_util.create_repo_rhodecode_setting(
                 repo_stub, key, 'abcde', type_='unicode')
+            Session().commit()
+
         model = VcsSettingsModel(repo=repo_stub.repo_name)
         result = model.get_repo_ui_settings()
         for key in result:
@@ -820,6 +857,8 b' class TestGetGlobalGeneralSettings(objec'
         for key in VcsSettingsModel.GENERAL_SETTINGS:
             settings_util.create_repo_rhodecode_setting(
                 repo_stub, key, 'abcde', type_='unicode')
+            Session().commit()
+
         model = VcsSettingsModel(repo=repo_stub.repo_name)
         result = model.get_global_general_settings()
         expected_result = model.global_settings.get_all_settings()
@@ -838,6 +877,8 b' class TestGetGlobalUiSettings(object):'
         for section, key in VcsSettingsModel.HOOKS_SETTINGS:
             settings_util.create_repo_rhodecode_ui(
                 repo_stub, section, 'repo', key=key, active=False)
+            Session().commit()
+
         model = VcsSettingsModel(repo=repo_stub.repo_name)
         result = model.get_global_ui_settings()
         expected_result = model.global_settings.get_ui()
@@ -868,6 +909,8 b' class TestGetGeneralSettings(object):'
         for key in VcsSettingsModel.GENERAL_SETTINGS:
             settings_util.create_repo_rhodecode_setting(
                 repo_stub, key, 'abcde', type_='unicode')
+            Session().commit()
+
         result = model.get_general_settings()
         expected_result = model.get_global_general_settings()
         assert sorted(result) == sorted(expected_result)
@@ -879,6 +922,8 b' class TestGetGeneralSettings(object):'
         for key in VcsSettingsModel.GENERAL_SETTINGS:
             settings_util.create_repo_rhodecode_setting(
                 repo_stub, key, 'abcde', type_='unicode')
+            Session().commit()
+
         result = model.get_general_settings()
         expected_result = model.get_repo_general_settings()
         assert sorted(result) == sorted(expected_result)
@@ -898,6 +943,8 b' class TestGetUiSettings(object):'
         for section, key in VcsSettingsModel.HOOKS_SETTINGS:
             settings_util.create_repo_rhodecode_ui(
                 repo_stub, section, 'repo', key=key, active=True)
+            Session().commit()
+
         result = model.get_ui_settings()
         expected_result = model.get_global_ui_settings()
         assert sorted(result) == sorted(expected_result)
@@ -909,6 +956,8 b' class TestGetUiSettings(object):'
         for section, key in VcsSettingsModel.HOOKS_SETTINGS:
             settings_util.create_repo_rhodecode_ui(
                 repo_stub, section, 'repo', key=key, active=True)
+            Session().commit()
+
         result = model.get_ui_settings()
         expected_result = model.get_repo_ui_settings()
         assert sorted(result) == sorted(expected_result)
@@ -916,9 +965,12 b' class TestGetUiSettings(object):'
     def test_repo_settings_filtered_by_section_and_key(self, repo_stub):
         model = VcsSettingsModel(repo=repo_stub.repo_name)
         model.inherit_global_settings = False
+
         args = ('section', 'key')
         with mock.patch.object(model, 'get_repo_ui_settings') as settings_mock:
             model.get_ui_settings(*args)
+        Session().commit()
+
         settings_mock.assert_called_once_with(*args)
 
     def test_global_settings_filtered_by_section_and_key(self):
@@ -942,6 +994,8 b' class TestGetSvnPatterns(object):'
         args = ('section', )
         with mock.patch.object(model, 'get_repo_ui_settings') as settings_mock:
             model.get_svn_patterns(*args)
+
+        Session().commit()
         settings_mock.assert_called_once_with(*args)
 
     def test_global_settings_filtered_by_section_and_key(self):
@@ -990,6 +1044,8 b' class TestCreateOrUpdateRepoSettings(obj'
         model = VcsSettingsModel()
         with pytest.raises(Exception) as exc_info:
             model.create_or_update_repo_settings(data=self.FORM_DATA)
+            Session().commit()
+
         assert str(exc_info.value) == 'Repository is not specified'
 
     def test_only_svn_settings_are_updated_when_type_is_svn(self, backend_svn):
@@ -998,6 +1054,8 b' class TestCreateOrUpdateRepoSettings(obj'
         with self._patch_model(model) as mocks:
             model.create_or_update_repo_settings(
                 data=self.FORM_DATA, inherit_global_settings=False)
+            Session().commit()
+
         mocks['create_repo_svn_settings'].assert_called_once_with(
             self.FORM_DATA)
         non_called_methods = (
@@ -1013,6 +1071,7 b' class TestCreateOrUpdateRepoSettings(obj'
         with self._patch_model(model) as mocks:
             model.create_or_update_repo_settings(
                 data=self.FORM_DATA, inherit_global_settings=False)
+            Session().commit()
 
         assert mocks['create_repo_svn_settings'].call_count == 0
         called_methods = (
@@ -1060,6 +1119,8 b' class TestCreateOrUpdateRepoSettings(obj'
         with invalidation_patcher as invalidation_mock:
             model.create_or_update_repo_settings(
                 data=self.FORM_DATA, inherit_global_settings=True)
+        Session().commit()
+
         invalidation_mock.assert_called_once_with(
             repo_stub.repo_name, delete=True)
 
@@ -1069,6 +1130,8 b' class TestCreateOrUpdateRepoSettings(obj'
         with self._patch_model(model):
             model.create_or_update_repo_settings(
                 data=self.FORM_DATA, inherit_global_settings=False)
+            Session().commit()
+
         assert model.inherit_global_settings is False
 
     def _patch_model(self, model):

rhodecode/tests/models/test_permissions.py

@@ -79,20 +79,22 b' class TestPermissions(object):'
     def cleanup(self):
         if hasattr(self, 'test_repo'):
             RepoModel().delete(repo=self.test_repo)
+            Session().commit()
 
         if hasattr(self, 'g1'):
             RepoGroupModel().delete(self.g1.group_id)
         if hasattr(self, 'g2'):
             RepoGroupModel().delete(self.g2.group_id)
+        Session().commit()
 
-        UserModel().delete(self.u1)
-        UserModel().delete(self.u2)
-        UserModel().delete(self.u3)
-        UserModel().delete(self.a1)
+        UserModel().delete(self.u1, handle_repos='delete', handle_repo_groups='delete')
+        UserModel().delete(self.u2, handle_repos='delete', handle_repo_groups='delete')
+        UserModel().delete(self.u3, handle_repos='delete', handle_repo_groups='delete')
+        UserModel().delete(self.a1, handle_repos='delete', handle_repo_groups='delete')
+        Session().commit()
 
         if hasattr(self, 'ug1'):
             UserGroupModel().delete(self.ug1, force=True)
-
         Session().commit()
 
     def test_default_perms_set(self, repo_name):
@@ -183,6 +185,7 b' class TestPermissions(object):'
         new_perm_gr = 'repository.write'
         RepoModel().grant_user_group_permission(
             repo=repo_name, group_name=self.ug1, perm=new_perm_gr)
+        Session().commit()
 
         assert repo_perms(self.u1)[repo_name] == new_perm
         assert group_perms(self.u1) == {}
@@ -197,6 +200,7 b' class TestPermissions(object):'
         new_perm_gr = 'repository.write'
         RepoModel().grant_user_group_permission(
             repo=repo_name, group_name=self.ug1, perm=new_perm_gr)
+        Session().commit()
 
         assert repo_perms(self.u3)[repo_name] == new_perm_gr
         assert group_perms(self.u3) == {}
@@ -220,6 +224,7 b' class TestPermissions(object):'
         new_perm_l = 'repository.read'
         RepoModel().grant_user_group_permission(
             repo=repo_name, group_name=self.ug1, perm=new_perm_l)
+        Session().commit()
 
         assert repo_perms(self.u1)[repo_name] == new_perm_h
         assert group_perms(self.u1) == {}
@@ -281,6 +286,8 b' class TestPermissions(object):'
         # set default permission to none
         RepoGroupModel().grant_user_permission(
             repo_group=self.g1, user=self.anon, perm='group.none')
+        Session().commit()
+
         # make group
         self.ug1 = fixture.create_user_group('G1')
         # add user to group
@@ -501,6 +508,7 b' class TestPermissions(object):'
         UserGroupModel().add_user_to_group(self.ug1, self.u1)
         RepoGroupModel().grant_user_group_permission(
             repo_group=self.g1, group_name=self.ug1, perm='group.write')
+        Session().commit()
 
         # Verify that user does not get any special permission if he is not
         # owner
@@ -515,6 +523,7 b' class TestPermissions(object):'
         self.g1 = fixture.create_repo_group('test1')
         RepoGroupModel().grant_user_permission(
             repo_group=self.g1, user=self.u1, perm='group.write')
+        Session().commit()
 
         # Verify that user does not get any special permission if he is not
         # owner
@@ -524,7 +533,7 b' class TestPermissions(object):'
         self.g1.user = self.u1
         assert group_perms(self.u1) == {u'test1': 'group.admin'}
 
-    def _test_def_user_perm_equal(
+    def assert_user_perm_equal(
             self, user, change_factor=0, compare_keys=None):
         perms = UserToPerm.query().filter(UserToPerm.user == user).all()
         assert len(perms) == \
@@ -533,7 +542,7 b' class TestPermissions(object):'
             assert set(
                 x.permissions.permission_name for x in perms) == compare_keys
 
-    def _test_def_user_group_perm_equal(
+    def assert_def_user_group_perm_equal(
             self, user_group, change_factor=0, compare_keys=None):
         perms = UserGroupToPerm.query().filter(
             UserGroupToPerm.users_group == user_group).all()
@@ -545,21 +554,21 b' class TestPermissions(object):'
 
     def test_set_default_permissions(self):
         PermissionModel().create_default_user_permissions(user=self.u1)
-        self._test_def_user_perm_equal(user=self.u1)
+        self.assert_user_perm_equal(user=self.u1)
 
     def test_set_default_permissions_after_one_is_missing(self):
         PermissionModel().create_default_user_permissions(user=self.u1)
-        self._test_def_user_perm_equal(user=self.u1)
+        self.assert_user_perm_equal(user=self.u1)
         # now we delete one, it should be re-created after another call
         perms = UserToPerm.query().filter(UserToPerm.user == self.u1).all()
         Session().delete(perms[0])
         Session().commit()
 
-        self._test_def_user_perm_equal(user=self.u1, change_factor=-1)
+        self.assert_user_perm_equal(user=self.u1, change_factor=-1)
 
         # create missing one !
         PermissionModel().create_default_user_permissions(user=self.u1)
-        self._test_def_user_perm_equal(user=self.u1)
+        self.assert_user_perm_equal(user=self.u1)
 
     @pytest.mark.parametrize("perm, modify_to", [
         ('repository.read', 'repository.none'),
@@ -571,7 +580,7 b' class TestPermissions(object):'
     ])
     def test_set_default_permissions_after_modification(self, perm, modify_to):
         PermissionModel().create_default_user_permissions(user=self.u1)
-        self._test_def_user_perm_equal(user=self.u1)
+        self.assert_user_perm_equal(user=self.u1)
 
         old = Permission.get_by_key(perm)
         new = Permission.get_by_key(modify_to)
@@ -587,27 +596,27 b' class TestPermissions(object):'
         Session().commit()
 
         PermissionModel().create_default_user_permissions(user=self.u1)
-        self._test_def_user_perm_equal(user=self.u1)
+        self.assert_user_perm_equal(user=self.u1)
 
     def test_clear_user_perms(self):
         PermissionModel().create_default_user_permissions(user=self.u1)
-        self._test_def_user_perm_equal(user=self.u1)
+        self.assert_user_perm_equal(user=self.u1)
 
         # now clear permissions
         cleared = PermissionModel()._clear_user_perms(self.u1.user_id)
-        self._test_def_user_perm_equal(user=self.u1,
+        self.assert_user_perm_equal(user=self.u1,
                                        change_factor=len(cleared)*-1)
 
     def test_clear_user_group_perms(self):
         self.ug1 = fixture.create_user_group('G1')
         PermissionModel().create_default_user_group_permissions(
             user_group=self.ug1)
-        self._test_def_user_group_perm_equal(user_group=self.ug1)
+        self.assert_def_user_group_perm_equal(user_group=self.ug1)
 
         # now clear permissions
         cleared = PermissionModel()._clear_user_group_perms(
             self.ug1.users_group_id)
-        self._test_def_user_group_perm_equal(user_group=self.ug1,
+        self.assert_def_user_group_perm_equal(user_group=self.ug1,
                                              change_factor=len(cleared)*-1)
 
     @pytest.mark.parametrize("form_result", [
@@ -626,7 +635,7 b' class TestPermissions(object):'
         Session().commit()
         change_factor = -1 * (len(Permission.DEFAULT_USER_PERMISSIONS)
                               - len(form_result.keys()))
-        self._test_def_user_perm_equal(
+        self.assert_user_perm_equal(
             self.u1, change_factor=change_factor)
 
     @pytest.mark.parametrize("form_result", [
@@ -646,7 +655,7 b' class TestPermissions(object):'
         Session().commit()
         change_factor = -1 * (len(Permission.DEFAULT_USER_PERMISSIONS)
                               - len(form_result.keys()))
-        self._test_def_user_group_perm_equal(
+        self.assert_def_user_group_perm_equal(
             self.ug1, change_factor=change_factor)
 
     @pytest.mark.parametrize("group_active, expected_perm", [

rhodecode/tests/models/test_pullrequest.py

@@ -124,6 +124,8 b' class TestPullRequestModel(object):'
         PullRequestModel().update_reviewers(
             pull_request, [(pull_request.author, ['author'], False, [])],
             pull_request.author)
+        Session().commit()
+
         prs = PullRequestModel().get_awaiting_my_review(
             pull_request.target_repo, user_id=pull_request.author.user_id)
         assert isinstance(prs, list)
@@ -133,6 +135,8 b' class TestPullRequestModel(object):'
         PullRequestModel().update_reviewers(
             pull_request, [(pull_request.author, ['author'], False, [])],
             pull_request.author)
+        Session().commit()
+
         pr_count = PullRequestModel().count_awaiting_my_review(
             pull_request.target_repo, user_id=pull_request.author.user_id)
         assert pr_count == 1
@@ -140,6 +144,7 b' class TestPullRequestModel(object):'
     def test_delete_calls_cleanup_merge(self, pull_request):
         repo_id = pull_request.target_repo.repo_id
         PullRequestModel().delete(pull_request, pull_request.author)
+        Session().commit()
 
         self.workspace_remove_mock.assert_called_once_with(
             repo_id, self.workspace_id)
@@ -147,6 +152,8 b' class TestPullRequestModel(object):'
     def test_close_calls_cleanup_and_hook(self, pull_request):
         PullRequestModel().close_pull_request(
             pull_request, pull_request.author)
+        Session().commit()
+
         repo_id = pull_request.target_repo.repo_id
 
         self.workspace_remove_mock.assert_called_once_with(
@@ -286,6 +293,7 b' class TestPullRequestModel(object):'
         merge_extras['repository'] = pull_request.target_repo.repo_name
         PullRequestModel().merge_repo(
             pull_request, pull_request.author, extras=merge_extras)
+        Session().commit()
 
         message = (
             u'Merge pull request #{pr_id} from {source_repo} {source_ref_name}'
@@ -327,6 +335,7 b' class TestPullRequestModel(object):'
             assert pull_request.pull_request_state == PullRequest.STATE_UPDATING
             PullRequestModel().merge_repo(
                 pull_request, pull_request.author, extras=merge_extras)
+            Session().commit()
 
         assert pull_request.pull_request_state == PullRequest.STATE_CREATED
 
@@ -367,6 +376,7 b' class TestPullRequestModel(object):'
         merge_extras['repository'] = pull_request.target_repo.repo_name
         PullRequestModel().merge_repo(
             pull_request, pull_request.author, extras=merge_extras)
+        Session().commit()
 
         message = (
             u'Merge pull request #{pr_id} from {source_repo} {source_ref_name}'
@@ -442,6 +452,7 b' class TestIntegrationMerge(object):'
         with mock.patch.dict(rhodecode.CONFIG, extra_config, clear=False):
             merge_state = PullRequestModel().merge_repo(
                 pull_request, user_admin, extras=merge_extras)
+            Session().commit()
 
         assert merge_state.executed
         assert '_pre_push_hook' in capture_rcextensions
@@ -459,6 +470,7 b' class TestIntegrationMerge(object):'
             pre_pull.side_effect = RepositoryError("Disallow push!")
             merge_status = PullRequestModel().merge_repo(
                 pull_request, user_admin, extras=merge_extras)
+            Session().commit()
 
         assert not merge_status.executed
         assert 'pre_push' not in capture_rcextensions
@@ -479,6 +491,8 b' class TestIntegrationMerge(object):'
         Session().commit()
         merge_status = PullRequestModel().merge_repo(
             pull_request, user_regular, extras=merge_extras)
+        Session().commit()
+
         assert not merge_status.executed
 
 
@@ -889,6 +903,7 b' def test_link_comments_to_version_only_u'
     version2 = pr_util.create_version_of_pull_request()
 
     PullRequestModel()._link_comments_to_version(version2)
+    Session().commit()
 
     # Expect that only the new comment is linked to version2
     assert (

rhodecode/tests/vcs_operations/test_vcs_operations.py

@@ -395,7 +395,7 b' class TestVCSOperations(object):'
 
         user = user_util.create_user()
         auth_token = AuthTokenModel().create(
-            user.user_id, 'test-token', -10, AuthTokenModel.cls.ROLE_VCS)
+            user.user_id, u'test-token', -10, AuthTokenModel.cls.ROLE_VCS)
         token = auth_token.api_key
 
         clone_url = rc_web_server.repo_clone_url(
@@ -412,7 +412,7 b' class TestVCSOperations(object):'
 
         user = user_util.create_user()
         auth_token = AuthTokenModel().create(
-            user.user_id, 'test-token', -1, AuthTokenModel.cls.ROLE_API)
+            user.user_id, u'test-token', -1, AuthTokenModel.cls.ROLE_API)
         token = auth_token.api_key
 
         clone_url = rc_web_server.repo_clone_url(
@@ -445,7 +445,7 b' class TestVCSOperations(object):'
                              'egg:rhodecode-enterprise-ce#rhodecode'])
         user = user_util.create_user()
         auth_token = AuthTokenModel().create(
-            user.user_id, 'test-token', -1, AuthTokenModel.cls.ROLE_VCS)
+            user.user_id, u'test-token', -1, AuthTokenModel.cls.ROLE_VCS)
         token = auth_token.api_key
 
         # manually set scope
@@ -466,7 +466,7 b' class TestVCSOperations(object):'
                              'egg:rhodecode-enterprise-ce#rhodecode'])
         user = user_util.create_user()
         auth_token = AuthTokenModel().create(
-            user.user_id, 'test-token', -1, AuthTokenModel.cls.ROLE_VCS)
+            user.user_id, u'test-token', -1, AuthTokenModel.cls.ROLE_VCS)
         token = auth_token.api_key
 
         # manually set scope