repo_name = 'api-repo'

        owner = 'i-dont-exist'

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

                                  repo_name=repo_name,

                                  repo_type=self.REPO_TYPE,

        )

        response = api_call(self, params)

        repo = RepoModel().get_by_repo_name(repo_name)

        assert repo is not None

        ret = {

            'msg': 'Created new repository `%s`' % repo_name,

            'success': True,

        }

        expected = ret

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

        fixture.destroy_repo(repo_name)

    def test_api_create_repo_by_non_admin(self):

        repo_name = 'api-repo'

        owner = 'i-dont-exist'

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

                                  repo_name=repo_name,

                                  repo_type=self.REPO_TYPE,

        )

        response = api_call(self, params)

        repo = RepoModel().get_by_repo_name(repo_name)

        assert repo is not None

        ret = {

            'msg': 'Created new repository `%s`' % repo_name,

            'success': True,

        }

        expected = ret

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

        fixture.destroy_repo(repo_name)

    def test_api_create_repo_by_non_admin_specify_owner(self):

        repo_name = 'api-repo'

        owner = 'i-dont-exist'

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

                                  repo_name=repo_name,

                                  repo_type=self.REPO_TYPE,

                                  owner=owner)

        response = api_call(self, params)

        expected = 'Only Kallithea admin can specify `owner` param'

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

        fixture.destroy_repo(repo_name)

    def test_api_create_repo_exists(self):

        repo_name = self.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 = "repo `%s` already exist" % repo_name

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

    def test_api_create_repo_dot_dot(self):

        # 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', 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}),

        ('description', {'description': 'new description'}),

        ('clone_uri', {'clone_uri': 'http://example.com/repo'}), # will fail - pulling from non-existing repo should fail

        ('clone_uri', {'clone_uri': '/repo'}), # will fail - pulling from local repo was a mis-feature - it would bypass access control

        ('clone_uri', {'clone_uri': None}),

        ('landing_rev', {'landing_rev': 'branch:master'}),

        ('enable_statistics', {'enable_statistics': True}),

        ('enable_downloads', {'enable_downloads': True}),

        ('name', {'name': 'new_repo_name'}),

        ('repo_group', {'group': 'test_group_for_update'}),

    ])

    def test_api_update_repo(self, changing_attr, updates):

        repo_name = 'api_update_me'

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

        if changing_attr == 'repo_group':

            fixture.create_repo_group(updates['group'])

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

                                  repoid=repo_name, **updates)

        response = api_call(self, params)

        if changing_attr == 'name':

            repo_name = updates['name']

        if changing_attr == 'repo_group':

            repo_name = '/'.join([updates['group'], repo_name])

        try:

            if changing_attr == 'clone_uri' and updates['clone_uri']:

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

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

            else:

                expected = {

                    'msg': 'updated repo ID:%s %s' % (repo.repo_id, repo_name),

                    'repository': repo.get_api_data()

                }

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

        finally:

            fixture.destroy_repo(repo_name)

            if changing_attr == 'repo_group':

                fixture.destroy_repo_group(updates['group'])

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

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

        ('description', {'description': 'new description'}),

        ('clone_uri', {'clone_uri': 'http://example.com/repo'}), # will fail - pulling from non-existing repo should fail

        ('clone_uri', {'clone_uri': '/repo'}), # will fail - pulling from local repo was a mis-feature - it would bypass access control

        ('clone_uri', {'clone_uri': None}),

        ('landing_rev', {'landing_rev': 'branch:master'}),

        ('enable_statistics', {'enable_statistics': True}),

        ('enable_downloads', {'enable_downloads': True}),

        ('name', {'name': 'new_repo_name'}),

        ('repo_group', {'group': 'test_group_for_update'}),

    ])

    def test_api_update_group_repo(self, changing_attr, updates):

        group_name = 'lololo'

        fixture.create_repo_group(group_name)

        repo_name = '%s/api_update_me' % group_name

        repo = fixture.create_repo(repo_name, repo_group=group_name, repo_type=self.REPO_TYPE)

        if changing_attr == 'repo_group':

            fixture.create_repo_group(updates['group'])

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

                                  repoid=repo_name, **updates)

        response = api_call(self, params)

        if changing_attr == 'name':

            repo_name = '%s/%s' % (group_name, updates['name'])

        if changing_attr == 'repo_group':

            repo_name = '/'.join([updates['group'], repo_name.rsplit('/', 1)[-1]])

        try:

            if changing_attr == 'clone_uri' and updates['clone_uri']:

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

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

            else:

                expected = {

                    'msg': 'updated repo ID:%s %s' % (repo.repo_id, repo_name),

                    'repository': repo.get_api_data()

                }

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

        finally:

            fixture.destroy_repo(repo_name)

            if changing_attr == 'repo_group':

                fixture.destroy_repo_group(updates['group'])

        fixture.destroy_repo_group(group_name)

    def test_api_update_repo_repo_group_does_not_exist(self):

        repo_name = 'admin_owned'

        fixture.create_repo(repo_name)

        updates = {'group': 'test_group_for_update'}

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

                                  repoid=repo_name, **updates)

        response = api_call(self, params)

        try:

            expected = 'repository group `%s` does not exist' % updates['group']

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

        finally:

            fixture.destroy_repo(repo_name)

    def test_api_update_repo_regular_user_not_allowed(self):

        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', 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)

    def test_api_update_repo_regular_user_change_top_level_repo_name(self):

        repo_name = 'admin_owned'

        new_repo_name = 'new_repo_name'

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

        RepoModel().grant_user_permission(repo=repo_name,

                                          user=self.TEST_USER_LOGIN,

                                          perm='repository.admin')

        UserModel().revoke_perm('default', 'hg.create.repository')

        UserModel().grant_perm('default', 'hg.create.none')

        updates = {'name': new_repo_name}

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

                                  repoid=repo_name, **updates)

        response = api_call(self, params)

        try:

            expected = 'no permission to create (or move) top level repositories'

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

        finally:

            fixture.destroy_repo(repo_name)

            fixture.destroy_repo(new_repo_name)

    def test_api_update_repo_regular_user_change_repo_name_allowed(self):

        repo_name = 'admin_owned'

        new_repo_name = 'new_repo_name'

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

        RepoModel().grant_user_permission(repo=repo_name,

                                          user=self.TEST_USER_LOGIN,

                                          perm='repository.admin')

        UserModel().revoke_perm('default', 'hg.create.none')

        UserModel().grant_perm('default', 'hg.create.repository')

        updates = {'name': new_repo_name}

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

                                  repoid=repo_name, **updates)

        response = api_call(self, params)

        try:

            expected = {

                'msg': 'updated repo ID:%s %s' % (repo.repo_id, new_repo_name),

                'repository': repo.get_api_data()

            }

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

        finally:

            fixture.destroy_repo(repo_name)

            fixture.destroy_repo(new_repo_name)

    def test_api_update_repo_regular_user_change_owner(self):

        repo_name = 'admin_owned'

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

        RepoModel().grant_user_permission(repo=repo_name,

                                          user=self.TEST_USER_LOGIN,

                                          perm='repository.admin')

        updates = {'owner': base.TEST_USER_ADMIN_LOGIN}

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

                                  repoid=repo_name, **updates)

        response = api_call(self, params)

        try:

            expected = 'Only Kallithea admin can specify `owner` param'

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

        finally:

            fixture.destroy_repo(repo_name)

    def test_api_delete_repo(self):

        repo_name = 'api_delete_me'

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

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

                                  repoid=repo_name, )

        response = api_call(self, params)

        ret = {

            'msg': 'Deleted repository `%s`' % repo_name,

            'success': True

        }

        try:

            expected = ret

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

        finally:

            fixture.destroy_repo(repo_name)

    def test_api_delete_repo_by_non_admin(self):

        repo_name = 'api_delete_me'

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

                            cur_user=self.TEST_USER_LOGIN)

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

                                  repoid=repo_name, )

        response = api_call(self, params)

        ret = {

            'msg': 'Deleted repository `%s`' % repo_name,

            'success': True

        }

        try:

            expected = ret

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

        finally:

            fixture.destroy_repo(repo_name)

    def test_api_delete_repo_by_non_admin_no_permission(self):

        repo_name = 'api_delete_me'

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

        try:

            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', 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',

                                  repoid=self.REPO,

                                  fork_name=fork_name,

                                  owner=base.TEST_USER_ADMIN_LOGIN,

        )

        response = api_call(self, params)

        ret = {

            'msg': 'Created fork of `%s` as `%s`' % (self.REPO,

                                                     fork_name),

            'success': True,

        }

        expected = ret

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

        fixture.destroy_repo(fork_name)

    @base.parametrize('fork_name', [

        'api-repo-fork',

        '%s/api-repo-fork' % TEST_REPO_GROUP,

    ])

    def test_api_fork_repo_non_admin(self, fork_name):

        RepoGroupModel().grant_user_permission(TEST_REPO_GROUP,

                                               self.TEST_USER_LOGIN,

                                               'group.write')

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

                                  repoid=self.REPO,

                                  fork_name=fork_name,

        )

        response = api_call(self, params)

        ret = {

            'msg': 'Created fork of `%s` as `%s`' % (self.REPO,

                                                     fork_name),

            'success': True,

        }

        expected = ret

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

        fixture.destroy_repo(fork_name)

    def test_api_fork_repo_non_admin_specify_owner(self):

        fork_name = 'api-repo-fork'

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

                                  repoid=self.REPO,

                                  fork_name=fork_name,

                                  owner=base.TEST_USER_ADMIN_LOGIN,

        )

        response = api_call(self, params)

        expected = 'Only Kallithea admin can specify `owner` param'

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

        fixture.destroy_repo(fork_name)

    def test_api_fork_repo_non_admin_no_permission_to_fork(self):

        RepoModel().grant_user_permission(repo=self.REPO,

                                          user=db.User.DEFAULT_USER_NAME,

                                          perm='repository.none')

        try:

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

                                      repoid=self.REPO,

                                      fork_name=fork_name,

            )

            response = api_call(self, params)

            expected = 'repository `%s` does not exist' % (self.REPO)

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

        finally:

            RepoModel().grant_user_permission(repo=self.REPO,

                                              user=db.User.DEFAULT_USER_NAME,

                                              perm='repository.read')

            fixture.destroy_repo(fork_name)

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

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

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

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

    ])

    def test_api_fork_repo_non_admin_no_create_repo_permission(self, name, perm):

        fork_name = 'api-repo-fork'

        # regardless of base repository permission, forking is disallowed

        # when repository creation is disabled

        RepoModel().grant_user_permission(repo=self.REPO,

                                          user=self.TEST_USER_LOGIN,

                                          perm=perm)

        UserModel().revoke_perm('default', 'hg.create.repository')

        UserModel().grant_perm('default', 'hg.create.none')

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

                                  repoid=self.REPO,

                                  fork_name=fork_name,

        )

        response = api_call(self, params)

        expected = 'no permission to create top level repo'

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

        fixture.destroy_repo(fork_name)

    def test_api_fork_repo_unknown_owner(self):

        fork_name = 'api-repo-fork'

        owner = 'i-dont-exist'

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

                                  repoid=self.REPO,

                                  fork_name=fork_name,

                                  owner=owner,

        )

        response = api_call(self, params)

        expected = 'user `%s` does not exist' % owner

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

    def test_api_fork_repo_fork_exists(self):

        fork_name = 'api-repo-fork'

        fixture.create_fork(self.REPO, fork_name)

        try:

            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 = "fork `%s` already exist" % fork_name

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

        finally:

            fixture.destroy_repo(fork_name)

    def test_api_fork_repo_repo_exists(self):

        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', 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)

    def test_api_get_user_group(self):

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

                                  usergroupid=TEST_USER_GROUP)

        response = api_call(self, params)

        user_group = UserGroupModel().get_group(TEST_USER_GROUP)

        members = []

        for user in user_group.members:

            user = user.user

            members.append(user.get_api_data())

        ret = user_group.get_api_data()

        ret['members'] = members

        expected = ret

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

    def test_api_get_user_groups(self):

        gr_name = 'test_user_group2'

        make_user_group(gr_name)

        try:

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

            response = api_call(self, params)

            expected = []

            for gr_name in [TEST_USER_GROUP, 'test_user_group2']:

                user_group = UserGroupModel().get_group(gr_name)

                ret = user_group.get_api_data()

                expected.append(ret)

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

        finally:

            fixture.destroy_user_group(gr_name)

    def test_api_create_user_group(self):

        group_name = 'some_new_group'

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

                                  group_name=group_name)

        response = api_call(self, params)

        ret = {

            'msg': 'created new user group `%s`' % group_name,

            'user_group': jsonify(UserGroupModel() \

                .get_by_name(group_name) \

                .get_api_data())

        }

        expected = ret

        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', 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'}),

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

        ('active', {'active': False}),

        ('active', {'active': True}),

    ])

    def test_api_update_user_group(self, changing_attr, updates):

        gr_name = 'test_group_for_update'

        user_group = fixture.create_user_group(gr_name)

        try:

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

                                      usergroupid=gr_name, **updates)

            response = api_call(self, params)

            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', 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)

    def test_api_add_user_to_user_group(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 = {

            'msg': 'added member `%s` to 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)

    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', 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)

    def test_api_remove_user_from_user_group(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)

        meta.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 = {

                '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', 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)

        meta.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)

        finally:

            fixture.destroy_user_group(gr_name)

    def test_api_delete_user_group(self):

        gr_name = 'test_group'

        ugroup = fixture.create_user_group(gr_name)

        gr_id = ugroup.users_group_id

        try:

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

                                      usergroupid=gr_name)

            response = api_call(self, params)

            expected = {

                'user_group': None,

                'msg': 'deleted user group ID:%s %s' % (gr_id, gr_name)

            }

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

        finally:

            if UserGroupModel().get_by_name(gr_name):

                fixture.destroy_user_group(gr_name)

    def test_api_delete_user_group_that_is_assigned(self):

        gr_name = 'test_group'

        ugroup = fixture.create_user_group(gr_name)

        gr_id = ugroup.users_group_id

        ugr_to_perm = RepoModel().grant_user_group_permission(self.REPO, gr_name, 'repository.write')

        msg = 'User Group assigned to %s' % ugr_to_perm.repository.repo_name

        try:

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

                                      usergroupid=gr_name)

            response = api_call(self, params)

            expected = msg

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

        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', 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'),

    ])

    def test_api_grant_user_permission(self, name, perm):

        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)

        ret = {

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

                perm, base.TEST_USER_ADMIN_LOGIN, self.REPO

            ),

            'success': True

        }

        expected = ret

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

    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', 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

        )

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

    def test_api_revoke_user_permission(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 = {