tests: fix user/user groups schema tests

rhodecode/tests/models/schemas/test_user_usergroup_types.py

@@ -1,139 +1,141 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2016-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import colander
 import pytest
 
 from rhodecode.model import validation_schema
+from rhodecode.model.db import Session
 from rhodecode.model.user import UserModel
 from rhodecode.model.user_group import UserGroupModel
 from rhodecode.model.validation_schema.types import (
     UserOrUserGroupType, UserType, UserGroupType
 )
 
 
 class TestUserAndUserGroupSchemaType(object):
 
     class Schema(colander.Schema):
         user_or_usergroup = colander.SchemaNode(UserOrUserGroupType())
 
     def test_serialize(self, user_regular, test_user_group):
         schema = self.Schema()
 
         assert schema.serialize({'user_or_usergroup': user_regular}) == (
             {'user_or_usergroup': 'user:' + user_regular.username})
         assert schema.serialize({'user_or_usergroup': test_user_group}) == (
             {'user_or_usergroup': 'usergroup:' + test_user_group.users_group_name})
 
         with pytest.raises(colander.Invalid):
             schema.serialize({'user_or_usergroup': 'invalidusername'})
 
     def test_deserialize(self, test_user_group, user_regular):
         schema = self.Schema()
 
         assert schema.deserialize(
             {'user_or_usergroup': test_user_group.users_group_name}
         ) == {'user_or_usergroup': test_user_group}
 
         assert schema.deserialize(
             {'user_or_usergroup': user_regular.username}
         ) == {'user_or_usergroup': user_regular}
 
     def test_deserialize_user_user_group_with_same_name(self):
         schema = self.Schema()
         try:
             user = UserModel().create_or_update(
                 'test_user_usergroup', 'nopass', 'test_user_usergroup')
             usergroup = UserGroupModel().create(
                 'test_user_usergroup', 'test usergroup', user)
 
             with pytest.raises(colander.Invalid) as exc_info:
                 schema.deserialize(
                     {'user_or_usergroup': user.username}
                 ) == {'user_or_usergroup': user}
 
             err = exc_info.value.asdict()
             assert 'is both a user and usergroup' in err['user_or_usergroup']
         finally:
+            UserGroupModel().delete(usergroup)
+            Session().commit()
             UserModel().delete(user)
-            UserGroupModel().delete(usergroup)
 
 
 class TestUserType(object):
 
     class Schema(colander.Schema):
         user = colander.SchemaNode(UserType())
 
     def test_serialize(self, user_regular, test_user_group):
         schema = self.Schema()
 
         assert schema.serialize({'user': user_regular}) == (
             {'user': user_regular.username})
 
         with pytest.raises(colander.Invalid):
             schema.serialize({'user': test_user_group})
 
         with pytest.raises(colander.Invalid):
             schema.serialize({'user': 'invaliduser'})
 
     def test_deserialize(self, user_regular, test_user_group):
         schema = self.Schema()
 
         assert schema.deserialize(
             {'user': user_regular.username}) == {'user': user_regular}
 
         with pytest.raises(colander.Invalid):
             schema.deserialize({'user': test_user_group.users_group_name})
 
         with pytest.raises(colander.Invalid):
             schema.deserialize({'user': 'invaliduser'})
 
 
 class TestUserGroupType(object):
 
     class Schema(colander.Schema):
         usergroup = colander.SchemaNode(
             UserGroupType()
         )
 
     def test_serialize(self, user_regular, test_user_group):
         schema = self.Schema()
 
         assert schema.serialize({'usergroup': test_user_group}) == (
             {'usergroup': test_user_group.users_group_name})
 
         with pytest.raises(colander.Invalid):
             schema.serialize({'usergroup': user_regular})
 
         with pytest.raises(colander.Invalid):
             schema.serialize({'usergroup': 'invalidusergroup'})
 
     def test_deserialize(self, user_regular, test_user_group):
         schema = self.Schema()
 
         assert schema.deserialize({
             'usergroup': test_user_group.users_group_name
         }) == {'usergroup': test_user_group}
 
         with pytest.raises(colander.Invalid):
             schema.deserialize({'usergroup': user_regular.username})
 
         with pytest.raises(colander.Invalid):
             schema.deserialize({'usergroup': 'invaliduser'})