Changeset - 1de3e5d104bf
Parent rev.
Child rev.
[Not reviewed]
default
0 3 0
Mads Kiilerich (mads) - 6 years ago 2020-06-24 17:12:28
mads@kiilerich.com
Grafted from: 0e14bbd2a0e7
tests: consistent use of more helpful raise_exception "fixture"

"Total Crash" was too misleading when debugging problems.
3 files changed with 29 insertions and 32 deletions:
kallithea/tests/api/api_base.py
25
28
kallithea/tests/fixture.py
2
2
kallithea/tests/functional/test_admin_repos.py
2
2
0 comments (0 inline, 0 general)
kallithea/tests/api/api_base.py
➞
Show inline comments
 
@@ -27,25 +27,26 @@ from kallithea.lib import ext_json
 
from kallithea.lib.auth import AuthUser
 
from kallithea.lib.utils2 import ascii_bytes
 
from kallithea.model.changeset_status import ChangesetStatusModel
 
from kallithea.model.db import ChangesetStatus, PullRequest, RepoGroup, Repository, Setting, Ui, User
 
from kallithea.model.gist import GistModel
 
from kallithea.model.meta import Session
 
from kallithea.model.repo import RepoModel
 
from kallithea.model.repo_group import RepoGroupModel
 
from kallithea.model.scm import ScmModel
 
from kallithea.model.user import UserModel
 
from kallithea.model.user_group import UserGroupModel
 
from kallithea.tests import base
 
from kallithea.tests.fixture import Fixture
 
from kallithea.tests.fixture import Fixture, raise_exception
 

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
API_URL = '/_admin/api'

			




	
	
	
		
 
TEST_USER_GROUP = 'test_user_group'

			




	
	
	
		
 
TEST_REPO_GROUP = 'test_repo_group'

			




	
	
	
		
 

			




	
	
	
		
 
fixture = Fixture()

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def _build_data(apikey, method, **kw):

			




	
	
	
		
 
    """

			




	
	
	
		
 
    Builds API data with given random ID

			




	
	
		
 
@@ -54,28 +55,24 @@ def _build_data(apikey, method, **kw):

			




	
	
	
		
 
    random_id = random.randrange(1, 9999)

			




	
	
	
		
 
    return random_id, ext_json.dumps({

			




	
	
	
		
 
        "id": random_id,

			




	
	
	
		
 
        "api_key": apikey,

			




	
	
	
		
 
        "method": method,

			




	
	
	
		
 
        "args": kw

			




	
	
	
		
 
    })

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
jsonify = lambda obj: ext_json.loads(ext_json.dumps(obj))

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def crash(*args, **kwargs):

			




	
	
	
		
 
    raise Exception('Total Crash !')

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def api_call(test_obj, params):

			




	
	
	
		
 
    response = test_obj.app.post(API_URL, content_type='application/json',

			




	
	
	
		
 
                                 params=params)

			




	
	
	
		
 
    return response

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
## helpers

			




	
	
	
		
 
def make_user_group(name=TEST_USER_GROUP):

			




	
	
	
		
 
    gr = fixture.create_user_group(name, cur_user=base.TEST_USER_ADMIN_LOGIN)

			




	
	
	
		
 
    UserGroupModel().add_user_to_group(user_group=gr,

			




	
	
	
		
 
                                       user=base.TEST_USER_ADMIN_LOGIN)

			




	
	
	
		
 
    Session().commit()

			




	
	
		
 
@@ -340,25 +337,25 @@ class _BaseTestApi(object):

			




	
	
	
		
 
                    'repository': repo_name}

			




	
	
	
		
 
        self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
        fixture.destroy_repo(repo_name)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_rescan_repos(self):

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'rescan_repos')

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        expected = {'added': [], 'removed': []}

			




	
	
	
		
 
        self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    @mock.patch.object(ScmModel, 'repo_scan', crash)

			




	
	
	
		
 
    @mock.patch.object(ScmModel, 'repo_scan', raise_exception)

			




	
	
	
		
 
    def test_api_rescann_error(self):

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'rescan_repos', )

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        expected = 'Error occurred during rescan repositories action'

			




	
	
	
		
 
        self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_create_existing_user(self):

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'create_user',

			




	
	
	
		
 
                                  username=base.TEST_USER_ADMIN_LOGIN,

			




	
	
	
		
 
                                  email='test@example.com',

			




	
	
	
		
 
                                  password='trololo')

			




	
	
		
 
@@ -430,25 +427,25 @@ class _BaseTestApi(object):

			




	
	
	
		
 

			




	
	
	
		
 
        usr = User.get_by_username(username)

			




	
	
	
		
 
        ret = dict(

			




	
	
	
		
 
            msg='created new user `%s`' % username,

			




	
	
	
		
 
            user=jsonify(usr.get_api_data())

			




	
	
	
		
 
        )

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            expected = ret

			




	
	
	
		
 
            self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 
        finally:

			




	
	
	
		
 
            fixture.destroy_user(usr.user_id)

			




	
	
	
		
 

			




	
	
	
		
 
    @mock.patch.object(UserModel, 'create_or_update', crash)

			




	
	
	
		
 
    @mock.patch.object(UserModel, 'create_or_update', raise_exception)

			




	
	
	
		
 
    def test_api_create_user_when_exception_happened(self):

			




	
	
	
		
 

			




	
	
	
		
 
        username = 'test_new_api_user'

			




	
	
	
		
 
        email = username + "@example.com"

			




	
	
	
		
 

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'create_user',

			




	
	
	
		
 
                                  username=username,

			




	
	
	
		
 
                                  email=email,

			




	
	
	
		
 
                                  password='trololo')

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 
        expected = 'failed to create user `%s`' % username

			




	
	
	
		
 
        self._compare_error(id_, expected, given=response.body)

			




	
	
		
 
@@ -464,25 +461,25 @@ class _BaseTestApi(object):

			




	
	
	
		
 
        usr_id = usr.user_id

			




	
	
	
		
 
        ## DELETE THIS USER NOW

			




	
	
	
		
 

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'delete_user',

			




	
	
	
		
 
                                  userid=username, )

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        ret = {'msg': 'deleted user ID:%s %s' % (usr_id, username),

			




	
	
	
		
 
               'user': None}

			




	
	
	
		
 
        expected = ret

			




	
	
	
		
 
        self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    @mock.patch.object(UserModel, 'delete', crash)

			




	
	
	
		
 
    @mock.patch.object(UserModel, 'delete', raise_exception)

			




	
	
	
		
 
    def test_api_delete_user_when_exception_happened(self):

			




	
	
	
		
 
        usr = UserModel().create_or_update(username='test_user',

			




	
	
	
		
 
                                           password='qweqwe',

			




	
	
	
		
 
                                           email='u232@example.com',

			




	
	
	
		
 
                                           firstname='u1', lastname='u1')

			




	
	
	
		
 
        Session().commit()

			




	
	
	
		
 
        username = usr.username

			




	
	
	
		
 

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'delete_user',

			




	
	
	
		
 
                                  userid=username, )

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 
        ret = 'failed to delete user ID:%s %s' % (usr.user_id,

			




	
	
		
 
@@ -552,25 +549,25 @@ class _BaseTestApi(object):

			




	
	
	
		
 
        expected = ret

			




	
	
	
		
 
        self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_update_user_default_user(self):

			




	
	
	
		
 
        usr = User.get_default_user()

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'update_user',

			




	
	
	
		
 
                                  userid=usr.user_id)

			




	
	
	
		
 

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 
        expected = 'editing default user is forbidden'

			




	
	
	
		
 
        self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    @mock.patch.object(UserModel, 'update_user', crash)

			




	
	
	
		
 
    @mock.patch.object(UserModel, 'update_user', raise_exception)

			




	
	
	
		
 
    def test_api_update_user_when_exception_happens(self):

			




	
	
	
		
 
        usr = User.get_by_username(base.TEST_USER_ADMIN_LOGIN)

			




	
	
	
		
 
        ret = jsonify(usr.get_api_data())

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'update_user',

			




	
	
	
		
 
                                  userid=usr.user_id)

			




	
	
	
		
 

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 
        ret = 'failed to update user `%s`' % usr.user_id

			




	
	
	
		
 

			




	
	
	
		
 
        expected = ret

			




	
	
	
		
 
        self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
		
 
@@ -1011,25 +1008,25 @@ class _BaseTestApi(object):

			




	
	
	
		
 
        # it is only possible to create repositories in existing repo groups - and '..' can't be used

			




	
	
	
		
 
        group_name = '%s/..' % TEST_REPO_GROUP

			




	
	
	
		
 
        repo_name = '%s/%s' % (group_name, 'could-be-outside')

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'create_repo',

			




	
	
	
		
 
                                  repo_name=repo_name,

			




	
	
	
		
 
                                  owner=base.TEST_USER_ADMIN_LOGIN,

			




	
	
	
		
 
                                  repo_type=self.REPO_TYPE,)

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 
        expected = 'repo group `%s` not found' % group_name

			




	
	
	
		
 
        self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 
        fixture.destroy_repo(repo_name)

			




	
	
	
		
 

			




	
	
	
		
 
    @mock.patch.object(RepoModel, 'create', crash)

			




	
	
	
		
 
    @mock.patch.object(RepoModel, 'create', raise_exception)

			




	
	
	
		
 
    def test_api_create_repo_exception_occurred(self):

			




	
	
	
		
 
        repo_name = 'api-repo'

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'create_repo',

			




	
	
	
		
 
                                  repo_name=repo_name,

			




	
	
	
		
 
                                  owner=base.TEST_USER_ADMIN_LOGIN,

			




	
	
	
		
 
                                  repo_type=self.REPO_TYPE,)

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 
        expected = 'failed to create repository `%s`' % repo_name

			




	
	
	
		
 
        self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    @base.parametrize('changing_attr,updates', [

			




	
	
	
		
 
        ('owner', {'owner': base.TEST_USER_REGULAR_LOGIN}),

			




	
	
		
 
@@ -1131,25 +1128,25 @@ class _BaseTestApi(object):

			




	
	
	
		
 
        repo_name = 'admin_owned'

			




	
	
	
		
 
        fixture.create_repo(repo_name)

			




	
	
	
		
 
        updates = {'description': 'something else'}

			




	
	
	
		
 
        id_, params = _build_data(self.apikey_regular, 'update_repo',

			




	
	
	
		
 
                                  repoid=repo_name, **updates)

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            expected = 'repository `%s` does not exist' % repo_name

			




	
	
	
		
 
            self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 
        finally:

			




	
	
	
		
 
            fixture.destroy_repo(repo_name)

			




	
	
	
		
 

			




	
	
	
		
 
    @mock.patch.object(RepoModel, 'update', crash)

			




	
	
	
		
 
    @mock.patch.object(RepoModel, 'update', raise_exception)

			




	
	
	
		
 
    def test_api_update_repo_exception_occurred(self):

			




	
	
	
		
 
        repo_name = 'api_update_me'

			




	
	
	
		
 
        fixture.create_repo(repo_name, repo_type=self.REPO_TYPE)

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'update_repo',

			




	
	
	
		
 
                                  repoid=repo_name, owner=base.TEST_USER_ADMIN_LOGIN,)

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            expected = 'failed to update repo `%s`' % repo_name

			




	
	
	
		
 
            self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 
        finally:

			




	
	
	
		
 
            fixture.destroy_repo(repo_name)

			




	
	
	
		
 

			




	
	
		
 
@@ -1255,25 +1252,25 @@ class _BaseTestApi(object):

			




	
	
	
		
 
            id_, params = _build_data(self.apikey_regular, 'delete_repo',

			




	
	
	
		
 
                                      repoid=repo_name, )

			




	
	
	
		
 
            response = api_call(self, params)

			




	
	
	
		
 
            expected = 'repository `%s` does not exist' % (repo_name)

			




	
	
	
		
 
            self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 
        finally:

			




	
	
	
		
 
            fixture.destroy_repo(repo_name)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_delete_repo_exception_occurred(self):

			




	
	
	
		
 
        repo_name = 'api_delete_me'

			




	
	
	
		
 
        fixture.create_repo(repo_name, repo_type=self.REPO_TYPE)

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            with mock.patch.object(RepoModel, 'delete', crash):

			




	
	
	
		
 
            with mock.patch.object(RepoModel, 'delete', raise_exception):

			




	
	
	
		
 
                id_, params = _build_data(self.apikey, 'delete_repo',

			




	
	
	
		
 
                                          repoid=repo_name, )

			




	
	
	
		
 
                response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
                expected = 'failed to delete repository `%s`' % repo_name

			




	
	
	
		
 
                self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 
        finally:

			




	
	
	
		
 
            fixture.destroy_repo(repo_name)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_fork_repo(self):

			




	
	
	
		
 
        fork_name = 'api-repo-fork'

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'fork_repo',

			




	
	
		
 
@@ -1403,25 +1400,25 @@ class _BaseTestApi(object):

			




	
	
	
		
 
        fork_name = self.REPO

			




	
	
	
		
 

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'fork_repo',

			




	
	
	
		
 
                                  repoid=self.REPO,

			




	
	
	
		
 
                                  fork_name=fork_name,

			




	
	
	
		
 
                                  owner=base.TEST_USER_ADMIN_LOGIN,

			




	
	
	
		
 
        )

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        expected = "repo `%s` already exist" % fork_name

			




	
	
	
		
 
        self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    @mock.patch.object(RepoModel, 'create_fork', crash)

			




	
	
	
		
 
    @mock.patch.object(RepoModel, 'create_fork', raise_exception)

			




	
	
	
		
 
    def test_api_fork_repo_exception_occurred(self):

			




	
	
	
		
 
        fork_name = 'api-repo-fork'

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'fork_repo',

			




	
	
	
		
 
                                  repoid=self.REPO,

			




	
	
	
		
 
                                  fork_name=fork_name,

			




	
	
	
		
 
                                  owner=base.TEST_USER_ADMIN_LOGIN,

			




	
	
	
		
 
        )

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        expected = 'failed to fork repository `%s` as `%s`' % (self.REPO,

			




	
	
	
		
 
                                                               fork_name)

			




	
	
	
		
 
        self._compare_error(id_, expected, given=response.body)

			




	
	
		
 
@@ -1475,25 +1472,25 @@ class _BaseTestApi(object):

			




	
	
	
		
 
        self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
        fixture.destroy_user_group(group_name)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_get_user_group_that_exist(self):

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'create_user_group',

			




	
	
	
		
 
                                  group_name=TEST_USER_GROUP)

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        expected = "user group `%s` already exist" % TEST_USER_GROUP

			




	
	
	
		
 
        self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    @mock.patch.object(UserGroupModel, 'create', crash)

			




	
	
	
		
 
    @mock.patch.object(UserGroupModel, 'create', raise_exception)

			




	
	
	
		
 
    def test_api_get_user_group_exception_occurred(self):

			




	
	
	
		
 
        group_name = 'exception_happens'

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'create_user_group',

			




	
	
	
		
 
                                  group_name=group_name)

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        expected = 'failed to create group `%s`' % group_name

			




	
	
	
		
 
        self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    @base.parametrize('changing_attr,updates', [

			




	
	
	
		
 
        ('group_name', {'group_name': 'new_group_name'}),

			




	
	
	
		
 
        ('group_name', {'group_name': 'test_group_for_update'}),

			




	
	
		
 
@@ -1511,25 +1508,25 @@ class _BaseTestApi(object):

			




	
	
	
		
 
            expected = {

			




	
	
	
		
 
               'msg': 'updated user group ID:%s %s' % (user_group.users_group_id,

			




	
	
	
		
 
                                                     user_group.users_group_name),

			




	
	
	
		
 
               'user_group': user_group.get_api_data()

			




	
	
	
		
 
            }

			




	
	
	
		
 
            self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 
        finally:

			




	
	
	
		
 
            if changing_attr == 'group_name':

			




	
	
	
		
 
                # switch to updated name for proper cleanup

			




	
	
	
		
 
                gr_name = updates['group_name']

			




	
	
	
		
 
            fixture.destroy_user_group(gr_name)

			




	
	
	
		
 

			




	
	
	
		
 
    @mock.patch.object(UserGroupModel, 'update', crash)

			




	
	
	
		
 
    @mock.patch.object(UserGroupModel, 'update', raise_exception)

			




	
	
	
		
 
    def test_api_update_user_group_exception_occurred(self):

			




	
	
	
		
 
        gr_name = 'test_group'

			




	
	
	
		
 
        fixture.create_user_group(gr_name)

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            id_, params = _build_data(self.apikey, 'update_user_group',

			




	
	
	
		
 
                                      usergroupid=gr_name)

			




	
	
	
		
 
            response = api_call(self, params)

			




	
	
	
		
 
            expected = 'failed to update user group `%s`' % gr_name

			




	
	
	
		
 
            self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 
        finally:

			




	
	
	
		
 
            fixture.destroy_user_group(gr_name)

			




	
	
	
		
 

			




	
	
		
 
@@ -1550,25 +1547,25 @@ class _BaseTestApi(object):

			




	
	
	
		
 
        finally:

			




	
	
	
		
 
            fixture.destroy_user_group(gr_name)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_add_user_to_user_group_that_doesnt_exist(self):

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'add_user_to_user_group',

			




	
	
	
		
 
                                  usergroupid='false-group',

			




	
	
	
		
 
                                  userid=base.TEST_USER_ADMIN_LOGIN)

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        expected = 'user group `%s` does not exist' % 'false-group'

			




	
	
	
		
 
        self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    @mock.patch.object(UserGroupModel, 'add_user_to_group', crash)

			




	
	
	
		
 
    @mock.patch.object(UserGroupModel, 'add_user_to_group', raise_exception)

			




	
	
	
		
 
    def test_api_add_user_to_user_group_exception_occurred(self):

			




	
	
	
		
 
        gr_name = 'test_group'

			




	
	
	
		
 
        fixture.create_user_group(gr_name)

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            id_, params = _build_data(self.apikey, 'add_user_to_user_group',

			




	
	
	
		
 
                                      usergroupid=gr_name,

			




	
	
	
		
 
                                      userid=base.TEST_USER_ADMIN_LOGIN)

			




	
	
	
		
 
            response = api_call(self, params)

			




	
	
	
		
 
            expected = 'failed to add member to user group `%s`' % gr_name

			




	
	
	
		
 
            self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 
        finally:

			




	
	
	
		
 
            fixture.destroy_user_group(gr_name)

			




	
	
		
 
@@ -1583,25 +1580,25 @@ class _BaseTestApi(object):

			




	
	
	
		
 
                                      usergroupid=gr_name,

			




	
	
	
		
 
                                      userid=base.TEST_USER_ADMIN_LOGIN)

			




	
	
	
		
 
            response = api_call(self, params)

			




	
	
	
		
 
            expected = {

			




	
	
	
		
 
                'msg': 'removed member `%s` from user group `%s`' % (

			




	
	
	
		
 
                    base.TEST_USER_ADMIN_LOGIN, gr_name

			




	
	
	
		
 
                ),

			




	
	
	
		
 
                'success': True}

			




	
	
	
		
 
            self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 
        finally:

			




	
	
	
		
 
            fixture.destroy_user_group(gr_name)

			




	
	
	
		
 

			




	
	
	
		
 
    @mock.patch.object(UserGroupModel, 'remove_user_from_group', crash)

			




	
	
	
		
 
    @mock.patch.object(UserGroupModel, 'remove_user_from_group', raise_exception)

			




	
	
	
		
 
    def test_api_remove_user_from_user_group_exception_occurred(self):

			




	
	
	
		
 
        gr_name = 'test_group_3'

			




	
	
	
		
 
        gr = fixture.create_user_group(gr_name)

			




	
	
	
		
 
        UserGroupModel().add_user_to_group(gr, user=base.TEST_USER_ADMIN_LOGIN)

			




	
	
	
		
 
        Session().commit()

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            id_, params = _build_data(self.apikey, 'remove_user_from_user_group',

			




	
	
	
		
 
                                      usergroupid=gr_name,

			




	
	
	
		
 
                                      userid=base.TEST_USER_ADMIN_LOGIN)

			




	
	
	
		
 
            response = api_call(self, params)

			




	
	
	
		
 
            expected = 'failed to remove member from user group `%s`' % gr_name

			




	
	
	
		
 
            self._compare_error(id_, expected, given=response.body)

			




	
	
		
 
@@ -1642,25 +1639,25 @@ class _BaseTestApi(object):

			




	
	
	
		
 
        finally:

			




	
	
	
		
 
            if UserGroupModel().get_by_name(gr_name):

			




	
	
	
		
 
                fixture.destroy_user_group(gr_name)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_delete_user_group_exception_occurred(self):

			




	
	
	
		
 
        gr_name = 'test_group'

			




	
	
	
		
 
        ugroup = fixture.create_user_group(gr_name)

			




	
	
	
		
 
        gr_id = ugroup.users_group_id

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'delete_user_group',

			




	
	
	
		
 
                                  usergroupid=gr_name)

			




	
	
	
		
 

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            with mock.patch.object(UserGroupModel, 'delete', crash):

			




	
	
	
		
 
            with mock.patch.object(UserGroupModel, 'delete', raise_exception):

			




	
	
	
		
 
                response = api_call(self, params)

			




	
	
	
		
 
                expected = 'failed to delete user group ID:%s %s' % (gr_id, gr_name)

			




	
	
	
		
 
                self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 
        finally:

			




	
	
	
		
 
            fixture.destroy_user_group(gr_name)

			




	
	
	
		
 

			




	
	
	
		
 
    @base.parametrize('name,perm', [

			




	
	
	
		
 
        ('none', 'repository.none'),

			




	
	
	
		
 
        ('read', 'repository.read'),

			




	
	
	
		
 
        ('write', 'repository.write'),

			




	
	
	
		
 
        ('admin', 'repository.admin'),

			




	
	
	
		
 
    ])

			




	
	
		
 
@@ -1684,25 +1681,25 @@ class _BaseTestApi(object):

			




	
	
	
		
 
    def test_api_grant_user_permission_wrong_permission(self):

			




	
	
	
		
 
        perm = 'haha.no.permission'

			




	
	
	
		
 
        id_, params = _build_data(self.apikey,

			




	
	
	
		
 
                                  'grant_user_permission',

			




	
	
	
		
 
                                  repoid=self.REPO,

			




	
	
	
		
 
                                  userid=base.TEST_USER_ADMIN_LOGIN,

			




	
	
	
		
 
                                  perm=perm)

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        expected = 'permission `%s` does not exist' % perm

			




	
	
	
		
 
        self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    @mock.patch.object(RepoModel, 'grant_user_permission', crash)

			




	
	
	
		
 
    @mock.patch.object(RepoModel, 'grant_user_permission', raise_exception)

			




	
	
	
		
 
    def test_api_grant_user_permission_exception_when_adding(self):

			




	
	
	
		
 
        perm = 'repository.read'

			




	
	
	
		
 
        id_, params = _build_data(self.apikey,

			




	
	
	
		
 
                                  'grant_user_permission',

			




	
	
	
		
 
                                  repoid=self.REPO,

			




	
	
	
		
 
                                  userid=base.TEST_USER_ADMIN_LOGIN,

			




	
	
	
		
 
                                  perm=perm)

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        expected = 'failed to edit permission for user: `%s` in repo: `%s`' % (

			




	
	
	
		
 
            base.TEST_USER_ADMIN_LOGIN, self.REPO

			




	
	
	
		
 
        )

			




	
	
		
 
@@ -1714,25 +1711,25 @@ class _BaseTestApi(object):

			




	
	
	
		
 
                                  repoid=self.REPO,

			




	
	
	
		
 
                                  userid=base.TEST_USER_ADMIN_LOGIN, )

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        expected = {

			




	
	
	
		
 
            'msg': 'Revoked perm for user: `%s` in repo: `%s`' % (

			




	
	
	
		
 
                base.TEST_USER_ADMIN_LOGIN, self.REPO

			




	
	
	
		
 
            ),

			




	
	
	
		
 
            'success': True

			




	
	
	
		
 
        }

			




	
	
	
		
 
        self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    @mock.patch.object(RepoModel, 'revoke_user_permission', crash)

			




	
	
	
		
 
    @mock.patch.object(RepoModel, 'revoke_user_permission', raise_exception)

			




	
	
	
		
 
    def test_api_revoke_user_permission_exception_when_adding(self):

			




	
	
	
		
 
        id_, params = _build_data(self.apikey,

			




	
	
	
		
 
                                  'revoke_user_permission',

			




	
	
	
		
 
                                  repoid=self.REPO,

			




	
	
	
		
 
                                  userid=base.TEST_USER_ADMIN_LOGIN, )

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        expected = 'failed to edit permission for user: `%s` in repo: `%s`' % (

			




	
	
	
		
 
            base.TEST_USER_ADMIN_LOGIN, self.REPO

			




	
	
	
		
 
        )

			




	
	
	
		
 
        self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
		
 
@@ -1762,25 +1759,25 @@ class _BaseTestApi(object):

			




	
	
	
		
 
    def test_api_grant_user_group_permission_wrong_permission(self):

			




	
	
	
		
 
        perm = 'haha.no.permission'

			




	
	
	
		
 
        id_, params = _build_data(self.apikey,

			




	
	
	
		
 
                                  'grant_user_group_permission',

			




	
	
	
		
 
                                  repoid=self.REPO,

			




	
	
	
		
 
                                  usergroupid=TEST_USER_GROUP,

			




	
	
	
		
 
                                  perm=perm)

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        expected = 'permission `%s` does not exist' % perm

			




	
	
	
		
 
        self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    @mock.patch.object(RepoModel, 'grant_user_group_permission', crash)

			




	
	
	
		
 
    @mock.patch.object(RepoModel, 'grant_user_group_permission', raise_exception)

			




	
	
	
		
 
    def test_api_grant_user_group_permission_exception_when_adding(self):

			




	
	
	
		
 
        perm = 'repository.read'

			




	
	
	
		
 
        id_, params = _build_data(self.apikey,

			




	
	
	
		
 
                                  'grant_user_group_permission',

			




	
	
	
		
 
                                  repoid=self.REPO,

			




	
	
	
		
 
                                  usergroupid=TEST_USER_GROUP,

			




	
	
	
		
 
                                  perm=perm)

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        expected = 'failed to edit permission for user group: `%s` in repo: `%s`' % (

			




	
	
	
		
 
            TEST_USER_GROUP, self.REPO

			




	
	
	
		
 
        )

			




	
	
		
 
@@ -1796,25 +1793,25 @@ class _BaseTestApi(object):

			




	
	
	
		
 
                                  repoid=self.REPO,

			




	
	
	
		
 
                                  usergroupid=TEST_USER_GROUP, )

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        expected = {

			




	
	
	
		
 
            'msg': 'Revoked perm for user group: `%s` in repo: `%s`' % (

			




	
	
	
		
 
                TEST_USER_GROUP, self.REPO

			




	
	
	
		
 
            ),

			




	
	
	
		
 
            'success': True

			




	
	
	
		
 
        }

			




	
	
	
		
 
        self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    @mock.patch.object(RepoModel, 'revoke_user_group_permission', crash)

			




	
	
	
		
 
    @mock.patch.object(RepoModel, 'revoke_user_group_permission', raise_exception)

			




	
	
	
		
 
    def test_api_revoke_user_group_permission_exception_when_adding(self):

			




	
	
	
		
 
        id_, params = _build_data(self.apikey,

			




	
	
	
		
 
                                  'revoke_user_group_permission',

			




	
	
	
		
 
                                  repoid=self.REPO,

			




	
	
	
		
 
                                  usergroupid=TEST_USER_GROUP, )

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        expected = 'failed to edit permission for user group: `%s` in repo: `%s`' % (

			




	
	
	
		
 
            TEST_USER_GROUP, self.REPO

			




	
	
	
		
 
        )

			




	
	
	
		
 
        self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
		
 
@@ -1898,25 +1895,25 @@ class _BaseTestApi(object):

			




	
	
	
		
 
    def test_api_grant_user_permission_to_repo_group_wrong_permission(self):

			




	
	
	
		
 
        perm = 'haha.no.permission'

			




	
	
	
		
 
        id_, params = _build_data(self.apikey,

			




	
	
	
		
 
                                  'grant_user_permission_to_repo_group',

			




	
	
	
		
 
                                  repogroupid=TEST_REPO_GROUP,

			




	
	
	
		
 
                                  userid=base.TEST_USER_ADMIN_LOGIN,

			




	
	
	
		
 
                                  perm=perm)

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        expected = 'permission `%s` does not exist' % perm

			




	
	
	
		
 
        self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    @mock.patch.object(RepoGroupModel, 'grant_user_permission', crash)

			




	
	
	
		
 
    @mock.patch.object(RepoGroupModel, 'grant_user_permission', raise_exception)

			




	
	
	
		
 
    def test_api_grant_user_permission_to_repo_group_exception_when_adding(self):

			




	
	
	
		
 
        perm = 'group.read'

			




	
	
	
		
 
        id_, params = _build_data(self.apikey,

			




	
	
	
		
 
                                  'grant_user_permission_to_repo_group',

			




	
	
	
		
 
                                  repogroupid=TEST_REPO_GROUP,

			




	
	
	
		
 
                                  userid=base.TEST_USER_ADMIN_LOGIN,

			




	
	
	
		
 
                                  perm=perm)

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        expected = 'failed to edit permission for user: `%s` in repo group: `%s`' % (

			




	
	
	
		
 
            base.TEST_USER_ADMIN_LOGIN, TEST_REPO_GROUP

			




	
	
	
		
 
        )

			




	
	
		
 
@@ -1983,25 +1980,25 @@ class _BaseTestApi(object):

			




	
	
	
		
 
        if access_ok:

			




	
	
	
		
 
            expected = {

			




	
	
	
		
 
                'msg': 'Revoked perm (recursive:%s) for user: `%s` in repo group: `%s`' % (

			




	
	
	
		
 
                    apply_to_children, base.TEST_USER_ADMIN_LOGIN, TEST_REPO_GROUP

			




	
	
	
		
 
                ),

			




	
	
	
		
 
                'success': True

			




	
	
	
		
 
            }

			




	
	
	
		
 
            self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 
        else:

			




	
	
	
		
 
            expected = 'repository group `%s` does not exist' % TEST_REPO_GROUP

			




	
	
	
		
 
            self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    @mock.patch.object(RepoGroupModel, 'revoke_user_permission', crash)

			




	
	
	
		
 
    @mock.patch.object(RepoGroupModel, 'revoke_user_permission', raise_exception)

			




	
	
	
		
 
    def test_api_revoke_user_permission_from_repo_group_exception_when_adding(self):

			




	
	
	
		
 
        id_, params = _build_data(self.apikey,

			




	
	
	
		
 
                                  'revoke_user_permission_from_repo_group',

			




	
	
	
		
 
                                  repogroupid=TEST_REPO_GROUP,

			




	
	
	
		
 
                                  userid=base.TEST_USER_ADMIN_LOGIN, )

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        expected = 'failed to edit permission for user: `%s` in repo group: `%s`' % (

			




	
	
	
		
 
            base.TEST_USER_ADMIN_LOGIN, TEST_REPO_GROUP

			




	
	
	
		
 
        )

			




	
	
	
		
 
        self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
		
 
@@ -2087,25 +2084,25 @@ class _BaseTestApi(object):

			




	
	
	
		
 
    def test_api_grant_user_group_permission_to_repo_group_wrong_permission(self):

			




	
	
	
		
 
        perm = 'haha.no.permission'

			




	
	
	
		
 
        id_, params = _build_data(self.apikey,

			




	
	
	
		
 
                                  'grant_user_group_permission_to_repo_group',

			




	
	
	
		
 
                                  repogroupid=TEST_REPO_GROUP,

			




	
	
	
		
 
                                  usergroupid=TEST_USER_GROUP,

			




	
	
	
		
 
                                  perm=perm)

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        expected = 'permission `%s` does not exist' % perm

			




	
	
	
		
 
        self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    @mock.patch.object(RepoGroupModel, 'grant_user_group_permission', crash)

			




	
	
	
		
 
    @mock.patch.object(RepoGroupModel, 'grant_user_group_permission', raise_exception)

			




	
	
	
		
 
    def test_api_grant_user_group_permission_exception_when_adding_to_repo_group(self):

			




	
	
	
		
 
        perm = 'group.read'

			




	
	
	
		
 
        id_, params = _build_data(self.apikey,

			




	
	
	
		
 
                                  'grant_user_group_permission_to_repo_group',

			




	
	
	
		
 
                                  repogroupid=TEST_REPO_GROUP,

			




	
	
	
		
 
                                  usergroupid=TEST_USER_GROUP,

			




	
	
	
		
 
                                  perm=perm)

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        expected = 'failed to edit permission for user group: `%s` in repo group: `%s`' % (

			




	
	
	
		
 
            TEST_USER_GROUP, TEST_REPO_GROUP

			




	
	
	
		
 
        )

			




	
	
		
 
@@ -2171,25 +2168,25 @@ class _BaseTestApi(object):

			




	
	
	
		
 
        if access_ok:

			




	
	
	
		
 
            expected = {

			




	
	
	
		
 
                'msg': 'Revoked perm (recursive:%s) for user group: `%s` in repo group: `%s`' % (

			




	
	
	
		
 
                    apply_to_children, base.TEST_USER_ADMIN_LOGIN, TEST_REPO_GROUP

			




	
	
	
		
 
                ),

			




	
	
	
		
 
                'success': True

			




	
	
	
		
 
            }

			




	
	
	
		
 
            self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 
        else:

			




	
	
	
		
 
            expected = 'repository group `%s` does not exist' % TEST_REPO_GROUP

			




	
	
	
		
 
            self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    @mock.patch.object(RepoGroupModel, 'revoke_user_group_permission', crash)

			




	
	
	
		
 
    @mock.patch.object(RepoGroupModel, 'revoke_user_group_permission', raise_exception)

			




	
	
	
		
 
    def test_api_revoke_user_group_permission_from_repo_group_exception_when_adding(self):

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'revoke_user_group_permission_from_repo_group',

			




	
	
	
		
 
                                  repogroupid=TEST_REPO_GROUP,

			




	
	
	
		
 
                                  usergroupid=TEST_USER_GROUP,)

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        expected = 'failed to edit permission for user group: `%s` in repo group: `%s`' % (

			




	
	
	
		
 
            TEST_USER_GROUP, TEST_REPO_GROUP

			




	
	
	
		
 
        )

			




	
	
	
		
 
        self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_get_gist(self):

			




	
	
		
 
@@ -2292,25 +2289,25 @@ class _BaseTestApi(object):

			




	
	
	
		
 
                'access_id': response.json['result']['gist']['access_id'],

			




	
	
	
		
 
                'created_on': response.json['result']['gist']['created_on'],

			




	
	
	
		
 
                'description': 'foobar-gist',

			




	
	
	
		
 
                'expires': response.json['result']['gist']['expires'],

			




	
	
	
		
 
                'gist_id': response.json['result']['gist']['gist_id'],

			




	
	
	
		
 
                'type': 'public',

			




	
	
	
		
 
                'url': response.json['result']['gist']['url']

			




	
	
	
		
 
            },

			




	
	
	
		
 
            'msg': 'created new gist'

			




	
	
	
		
 
        }

			




	
	
	
		
 
        self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    @mock.patch.object(GistModel, 'create', crash)

			




	
	
	
		
 
    @mock.patch.object(GistModel, 'create', raise_exception)

			




	
	
	
		
 
    def test_api_create_gist_exception_occurred(self):

			




	
	
	
		
 
        id_, params = _build_data(self.apikey_regular, 'create_gist',

			




	
	
	
		
 
                                  files={})

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 
        expected = 'failed to create gist'

			




	
	
	
		
 
        self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_delete_gist(self):

			




	
	
	
		
 
        gist_id = fixture.create_gist().gist_access_id

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'delete_gist',

			




	
	
	
		
 
                                  gistid=gist_id)

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
		
 
@@ -2324,25 +2321,25 @@ class _BaseTestApi(object):

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 
        expected = {'gist': None, 'msg': 'deleted gist ID:%s' % gist_id}

			




	
	
	
		
 
        self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_delete_gist_regular_user_no_permission(self):

			




	
	
	
		
 
        gist_id = fixture.create_gist().gist_access_id

			




	
	
	
		
 
        id_, params = _build_data(self.apikey_regular, 'delete_gist',

			




	
	
	
		
 
                                  gistid=gist_id)

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 
        expected = 'gist `%s` does not exist' % (gist_id,)

			




	
	
	
		
 
        self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    @mock.patch.object(GistModel, 'delete', crash)

			




	
	
	
		
 
    @mock.patch.object(GistModel, 'delete', raise_exception)

			




	
	
	
		
 
    def test_api_delete_gist_exception_occurred(self):

			




	
	
	
		
 
        gist_id = fixture.create_gist().gist_access_id

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'delete_gist',

			




	
	
	
		
 
                                  gistid=gist_id)

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 
        expected = 'failed to delete gist ID:%s' % (gist_id,)

			




	
	
	
		
 
        self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_get_ip(self):

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'get_ip')

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 
        expected = {

			




        

    


    
    

    

        

                

                    kallithea/tests/fixture.py
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -41,26 +41,26 @@ from kallithea.model.repo_group import R

			




	
	
	
		
 
from kallithea.model.scm import ScmModel

			




	
	
	
		
 
from kallithea.model.user import UserModel

			




	
	
	
		
 
from kallithea.model.user_group import UserGroupModel

			




	
	
	
		
 
from kallithea.tests.base import (GIT_REPO, HG_REPO, IP_ADDR, TEST_USER_ADMIN_EMAIL, TEST_USER_ADMIN_LOGIN, TEST_USER_REGULAR_LOGIN, TESTS_TMP_PATH,

			




	
	
	
		
 
                                  invalidate_all_caches)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
log = logging.getLogger(__name__)

			




	
	
	
		
 

			




	
	
	
		
 
FIXTURES = os.path.join(dirname(dirname(os.path.abspath(__file__))), 'tests', 'fixtures')

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def error_function(*args, **kwargs):

			




	
	
	
		
 
    raise Exception('Total Crash !')

			




	
	
	
		
 
def raise_exception(*args, **kwargs):

			




	
	
	
		
 
    raise Exception('raise_exception raised exception')

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class Fixture(object):

			




	
	
	
		
 

			




	
	
	
		
 
    def __init__(self):

			




	
	
	
		
 
        pass

			




	
	
	
		
 

			




	
	
	
		
 
    def anon_access(self, status):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Context manager for controlling anonymous access.

			




	
	
	
		
 
        Anon access will be set and committed, but restored again when exiting the block.

			




	
	
	
		
 

			




        

    


    
    

    

        

                

                    kallithea/tests/functional/test_admin_repos.py
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -5,25 +5,25 @@ import urllib.parse

			




	
	
	
		
 

			




	
	
	
		
 
import mock

			




	
	
	
		
 
import pytest

			




	
	
	
		
 

			




	
	
	
		
 
from kallithea.lib import vcs

			




	
	
	
		
 
from kallithea.model import db

			




	
	
	
		
 
from kallithea.model.db import Permission, Repository, Ui, User, UserRepoToPerm

			




	
	
	
		
 
from kallithea.model.meta import Session

			




	
	
	
		
 
from kallithea.model.repo import RepoModel

			




	
	
	
		
 
from kallithea.model.repo_group import RepoGroupModel

			




	
	
	
		
 
from kallithea.model.user import UserModel

			




	
	
	
		
 
from kallithea.tests import base

			




	
	
	
		
 
from kallithea.tests.fixture import Fixture, error_function

			




	
	
	
		
 
from kallithea.tests.fixture import Fixture, raise_exception

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
fixture = Fixture()

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def _get_permission_for_user(user, repo):

			




	
	
	
		
 
    perm = UserRepoToPerm.query() \

			




	
	
	
		
 
                .filter(UserRepoToPerm.repository ==

			




	
	
	
		
 
                        Repository.get_by_repo_name(repo)) \

			




	
	
	
		
 
                .filter(UserRepoToPerm.user == User.get_by_username(user)) \

			




	
	
	
		
 
                .all()

			




	
	
	
		
 
    return perm

			




	
	
		
 
@@ -583,25 +583,25 @@ class _BaseTestCase(base.TestController)

			




	
	
	
		
 
        response = self.app.post(base.url('repos'),

			




	
	
	
		
 
                        fixture._get_repo_create_params(repo_private=False,

			




	
	
	
		
 
                                                repo_name=repo_name,

			




	
	
	
		
 
                                                repo_type=self.REPO_TYPE,

			




	
	
	
		
 
                                                repo_description=description,

			




	
	
	
		
 
                                                _session_csrf_secret_token=self.session_csrf_secret_token()))

			




	
	
	
		
 

			




	
	
	
		
 
        response.mustcontain('<span class="error-message">Invalid value</span>')

			




	
	
	
		
 

			




	
	
	
		
 
        RepoModel().delete(repo_name)

			




	
	
	
		
 
        Session().commit()

			




	
	
	
		
 

			




	
	
	
		
 
    @mock.patch.object(RepoModel, '_create_filesystem_repo', error_function)

			




	
	
	
		
 
    @mock.patch.object(RepoModel, '_create_filesystem_repo', raise_exception)

			




	
	
	
		
 
    def test_create_repo_when_filesystem_op_fails(self):

			




	
	
	
		
 
        self.log_user()

			




	
	
	
		
 
        repo_name = self.NEW_REPO

			




	
	
	
		
 
        description = 'description for newly created repo'

			




	
	
	
		
 

			




	
	
	
		
 
        response = self.app.post(base.url('repos'),

			




	
	
	
		
 
                        fixture._get_repo_create_params(repo_private=False,

			




	
	
	
		
 
                                                repo_name=repo_name,

			




	
	
	
		
 
                                                repo_type=self.REPO_TYPE,

			




	
	
	
		
 
                                                repo_description=description,

			




	
	
	
		
 
                                                _session_csrf_secret_token=self.session_csrf_secret_token()))

			




	
	
	
		
 

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








    
        Server instance: clio-4068
    
    
        This site is powered by
            Kallithea 0.7.0,
        which is
        © 2010–2025 by various authors & licensed under GPLv3.
            – Support