release: update copyright year to 2018

rhodecode/__init__.py

@@ -1,63 +1,63 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017  RhodeCode GmbH
+# Copyright (C) 2010-2018 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/
 
 """
 
 RhodeCode, a web based repository management software
 versioning implementation: http://www.python.org/dev/peps/pep-0386/
 """
 
 import os
 import sys
 import platform
 
 VERSION = tuple(open(os.path.join(
     os.path.dirname(__file__), 'VERSION')).read().split('.'))
 
 BACKENDS = {
     'hg': 'Mercurial repository',
     'git': 'Git repository',
     'svn': 'Subversion repository',
 }
 
 CELERY_ENABLED = False
 CELERY_EAGER = False
 
 # link to config for pyramid
 CONFIG = {}
 
 # Populated with the settings dictionary from application init in
 # rhodecode.conf.environment.load_pyramid_environment
 PYRAMID_SETTINGS = {}
 
 # Linked module for extensions
 EXTENSIONS = {}
 
 __version__ = ('.'.join((str(each) for each in VERSION[:3])))
 __dbversion__ = 85  # defines current db version for migrations
 __platform__ = platform.system()
 __license__ = 'AGPLv3, and Commercial License'
 __author__ = 'RhodeCode GmbH'
 __url__ = 'https://code.rhodecode.com'
 
 is_windows = __platform__ in ['Windows']
 is_unix = not is_windows
 is_test = False
 disable_error_handler = False

rhodecode/api/__init__.py

@@ -1,542 +1,542 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2011-2017  RhodeCode GmbH
+# Copyright (C) 2011-2018 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 inspect
 import itertools
 import logging
 import types
 import fnmatch
 
 import decorator
 import venusian
 from collections import OrderedDict
 
 from pyramid.exceptions import ConfigurationError
 from pyramid.renderers import render
 from pyramid.response import Response
 from pyramid.httpexceptions import HTTPNotFound
 
 from rhodecode.api.exc import (
     JSONRPCBaseError, JSONRPCError, JSONRPCForbidden, JSONRPCValidationError)
 from rhodecode.apps._base import TemplateArgs
 from rhodecode.lib.auth import AuthUser
 from rhodecode.lib.base import get_ip_addr, attach_context_attributes
 from rhodecode.lib.ext_json import json
 from rhodecode.lib.utils2 import safe_str
 from rhodecode.lib.plugins.utils import get_plugin_settings
 from rhodecode.model.db import User, UserApiKeys
 
 log = logging.getLogger(__name__)
 
 DEFAULT_RENDERER = 'jsonrpc_renderer'
 DEFAULT_URL = '/_admin/apiv2'
 
 
 def find_methods(jsonrpc_methods, pattern):
     matches = OrderedDict()
     if not isinstance(pattern, (list, tuple)):
         pattern = [pattern]
 
     for single_pattern in pattern:
         for method_name, method in jsonrpc_methods.items():
             if fnmatch.fnmatch(method_name, single_pattern):
                 matches[method_name] = method
     return matches
 
 
 class ExtJsonRenderer(object):
     """
     Custom renderer that mkaes use of our ext_json lib
 
     """
 
     def __init__(self, serializer=json.dumps, **kw):
         """ Any keyword arguments will be passed to the ``serializer``
         function."""
         self.serializer = serializer
         self.kw = kw
 
     def __call__(self, info):
         """ Returns a plain JSON-encoded string with content-type
         ``application/json``. The content-type may be overridden by
         setting ``request.response.content_type``."""
 
         def _render(value, system):
             request = system.get('request')
             if request is not None:
                 response = request.response
                 ct = response.content_type
                 if ct == response.default_content_type:
                     response.content_type = 'application/json'
 
             return self.serializer(value, **self.kw)
 
         return _render
 
 
 def jsonrpc_response(request, result):
     rpc_id = getattr(request, 'rpc_id', None)
     response = request.response
 
     # store content_type before render is called
     ct = response.content_type
 
     ret_value = ''
     if rpc_id:
         ret_value = {
             'id': rpc_id,
             'result': result,
             'error': None,
         }
 
         # fetch deprecation warnings, and store it inside results
         deprecation = getattr(request, 'rpc_deprecation', None)
         if deprecation:
             ret_value['DEPRECATION_WARNING'] = deprecation
 
     raw_body = render(DEFAULT_RENDERER, ret_value, request=request)
     response.body = safe_str(raw_body, response.charset)
 
     if ct == response.default_content_type:
         response.content_type = 'application/json'
 
     return response
 
 
 def jsonrpc_error(request, message, retid=None, code=None):
     """
     Generate a Response object with a JSON-RPC error body
 
     :param code:
     :param retid:
     :param message:
     """
     err_dict = {'id': retid, 'result': None, 'error': message}
     body = render(DEFAULT_RENDERER, err_dict, request=request).encode('utf-8')
     return Response(
         body=body,
         status=code,
         content_type='application/json'
     )
 
 
 def exception_view(exc, request):
     rpc_id = getattr(request, 'rpc_id', None)
 
     fault_message = 'undefined error'
     if isinstance(exc, JSONRPCError):
         fault_message = exc.message
         log.debug('json-rpc error rpc_id:%s "%s"', rpc_id, fault_message)
     elif isinstance(exc, JSONRPCValidationError):
         colander_exc = exc.colander_exception
         # TODO(marcink): think maybe of nicer way to serialize errors ?
         fault_message = colander_exc.asdict()
         log.debug('json-rpc error rpc_id:%s "%s"', rpc_id, fault_message)
     elif isinstance(exc, JSONRPCForbidden):
         fault_message = 'Access was denied to this resource.'
         log.warning('json-rpc forbidden call rpc_id:%s "%s"', rpc_id, fault_message)
     elif isinstance(exc, HTTPNotFound):
         method = request.rpc_method
         log.debug('json-rpc method `%s` not found in list of '
                   'api calls: %s, rpc_id:%s',
                   method, request.registry.jsonrpc_methods.keys(), rpc_id)
 
         similar = 'none'
         try:
             similar_paterns = ['*{}*'.format(x) for x in method.split('_')]
             similar_found = find_methods(
                 request.registry.jsonrpc_methods, similar_paterns)
             similar = ', '.join(similar_found.keys()) or similar
         except Exception:
             # make the whole above block safe
             pass
 
         fault_message = "No such method: {}. Similar methods: {}".format(
             method, similar)
 
     return jsonrpc_error(request, fault_message, rpc_id)
 
 
 def request_view(request):
     """
     Main request handling method. It handles all logic to call a specific
     exposed method
     """
 
     # check if we can find this session using api_key, get_by_auth_token
     # search not expired tokens only
 
     try:
         api_user = User.get_by_auth_token(request.rpc_api_key)
 
         if api_user is None:
             return jsonrpc_error(
                 request, retid=request.rpc_id, message='Invalid API KEY')
 
         if not api_user.active:
             return jsonrpc_error(
                 request, retid=request.rpc_id,
                 message='Request from this user not allowed')
 
         # check if we are allowed to use this IP
         auth_u = AuthUser(
             api_user.user_id, request.rpc_api_key, ip_addr=request.rpc_ip_addr)
         if not auth_u.ip_allowed:
             return jsonrpc_error(
                 request, retid=request.rpc_id,
                 message='Request from IP:%s not allowed' % (
                     request.rpc_ip_addr,))
         else:
             log.info('Access for IP:%s allowed' % (request.rpc_ip_addr,))
 
         # register our auth-user
         request.rpc_user = auth_u
 
         # now check if token is valid for API
         auth_token = request.rpc_api_key
         token_match = api_user.authenticate_by_token(
             auth_token, roles=[UserApiKeys.ROLE_API])
         invalid_token = not token_match
 
         log.debug('Checking if API KEY is valid with proper role')
         if invalid_token:
             return jsonrpc_error(
                 request, retid=request.rpc_id,
                 message='API KEY invalid or, has bad role for an API call')
 
     except Exception:
         log.exception('Error on API AUTH')
         return jsonrpc_error(
             request, retid=request.rpc_id, message='Invalid API KEY')
 
     method = request.rpc_method
     func = request.registry.jsonrpc_methods[method]
 
     # now that we have a method, add request._req_params to
     # self.kargs and dispatch control to WGIController
     argspec = inspect.getargspec(func)
     arglist = argspec[0]
     defaults = map(type, argspec[3] or [])
     default_empty = types.NotImplementedType
 
     # kw arguments required by this method
     func_kwargs = dict(itertools.izip_longest(
         reversed(arglist), reversed(defaults), fillvalue=default_empty))
 
     # This attribute will need to be first param of a method that uses
     # api_key, which is translated to instance of user at that name
     user_var = 'apiuser'
     request_var = 'request'
 
     for arg in [user_var, request_var]:
         if arg not in arglist:
             return jsonrpc_error(
                 request,
                 retid=request.rpc_id,
                 message='This method [%s] does not support '
                         'required parameter `%s`' % (func.__name__, arg))
 
     # get our arglist and check if we provided them as args
     for arg, default in func_kwargs.items():
         if arg in [user_var, request_var]:
             # user_var and request_var are pre-hardcoded parameters and we
             # don't need to do any translation
             continue
 
         # skip the required param check if it's default value is
         # NotImplementedType (default_empty)
         if default == default_empty and arg not in request.rpc_params:
             return jsonrpc_error(
                 request,
                 retid=request.rpc_id,
                 message=('Missing non optional `%s` arg in JSON DATA' % arg)
             )
 
     # sanitize extra passed arguments
     for k in request.rpc_params.keys()[:]:
         if k not in func_kwargs:
             del request.rpc_params[k]
 
     call_params = request.rpc_params
     call_params.update({
         'request': request,
         'apiuser': auth_u
     })
 
     # register some common functions for usage
     attach_context_attributes(
         TemplateArgs(), request, request.rpc_user.user_id)
 
     try:
         ret_value = func(**call_params)
         return jsonrpc_response(request, ret_value)
     except JSONRPCBaseError:
         raise
     except Exception:
         log.exception('Unhandled exception occurred on api call: %s', func)
         return jsonrpc_error(request, retid=request.rpc_id,
                              message='Internal server error')
 
 
 def setup_request(request):
     """
     Parse a JSON-RPC request body. It's used inside the predicates method
     to validate and bootstrap requests for usage in rpc calls.
 
     We need to raise JSONRPCError here if we want to return some errors back to
     user.
     """
 
     log.debug('Executing setup request: %r', request)
     request.rpc_ip_addr = get_ip_addr(request.environ)
     # TODO(marcink): deprecate GET at some point
     if request.method not in ['POST', 'GET']:
         log.debug('unsupported request method "%s"', request.method)
         raise JSONRPCError(
             'unsupported request method "%s". Please use POST' % request.method)
 
     if 'CONTENT_LENGTH' not in request.environ:
         log.debug("No Content-Length")
         raise JSONRPCError("Empty body, No Content-Length in request")
 
     else:
         length = request.environ['CONTENT_LENGTH']
         log.debug('Content-Length: %s', length)
 
         if length == 0:
             log.debug("Content-Length is 0")
             raise JSONRPCError("Content-Length is 0")
 
     raw_body = request.body
     try:
         json_body = json.loads(raw_body)
     except ValueError as e:
         # catch JSON errors Here
         raise JSONRPCError("JSON parse error ERR:%s RAW:%r" % (e, raw_body))
 
     request.rpc_id = json_body.get('id')
     request.rpc_method = json_body.get('method')
 
     # check required base parameters
     try:
         api_key = json_body.get('api_key')
         if not api_key:
             api_key = json_body.get('auth_token')
 
         if not api_key:
             raise KeyError('api_key or auth_token')
 
         # TODO(marcink): support passing in token in request header
 
         request.rpc_api_key = api_key
         request.rpc_id = json_body['id']
         request.rpc_method = json_body['method']
         request.rpc_params = json_body['args'] \
             if isinstance(json_body['args'], dict) else {}
 
         log.debug(
             'method: %s, params: %s' % (request.rpc_method, request.rpc_params))
     except KeyError as e:
         raise JSONRPCError('Incorrect JSON data. Missing %s' % e)
 
     log.debug('setup complete, now handling method:%s rpcid:%s',
               request.rpc_method, request.rpc_id, )
 
 
 class RoutePredicate(object):
     def __init__(self, val, config):
         self.val = val
 
     def text(self):
         return 'jsonrpc route = %s' % self.val
 
     phash = text
 
     def __call__(self, info, request):
         if self.val:
             # potentially setup and bootstrap our call
             setup_request(request)
 
             # Always return True so that even if it isn't a valid RPC it
             # will fall through to the underlaying handlers like notfound_view
             return True
 
 
 class NotFoundPredicate(object):
     def __init__(self, val, config):
         self.val = val
         self.methods = config.registry.jsonrpc_methods
 
     def text(self):
         return 'jsonrpc method not found = {}.'.format(self.val)
 
     phash = text
 
     def __call__(self, info, request):
         return hasattr(request, 'rpc_method')
 
 
 class MethodPredicate(object):
     def __init__(self, val, config):
         self.method = val
 
     def text(self):
         return 'jsonrpc method = %s' % self.method
 
     phash = text
 
     def __call__(self, context, request):
         # we need to explicitly return False here, so pyramid doesn't try to
         # execute our view directly. We need our main handler to execute things
         return getattr(request, 'rpc_method') == self.method
 
 
 def add_jsonrpc_method(config, view, **kwargs):
     # pop the method name
     method = kwargs.pop('method', None)
 
     if method is None:
         raise ConfigurationError(
             'Cannot register a JSON-RPC method without specifying the '
             '"method"')
 
     # we define custom predicate, to enable to detect conflicting methods,
     # those predicates are kind of "translation" from the decorator variables
     # to internal predicates names
 
     kwargs['jsonrpc_method'] = method
 
     # register our view into global view store for validation
     config.registry.jsonrpc_methods[method] = view
 
     # we're using our main request_view handler, here, so each method
     # has a unified handler for itself
     config.add_view(request_view, route_name='apiv2', **kwargs)
 
 
 class jsonrpc_method(object):
     """
     decorator that works similar to @add_view_config decorator,
     but tailored for our JSON RPC
     """
 
     venusian = venusian  # for testing injection
 
     def __init__(self, method=None, **kwargs):
         self.method = method
         self.kwargs = kwargs
 
     def __call__(self, wrapped):
         kwargs = self.kwargs.copy()
         kwargs['method'] = self.method or wrapped.__name__
         depth = kwargs.pop('_depth', 0)
 
         def callback(context, name, ob):
             config = context.config.with_package(info.module)
             config.add_jsonrpc_method(view=ob, **kwargs)
 
         info = venusian.attach(wrapped, callback, category='pyramid',
                                depth=depth + 1)
         if info.scope == 'class':
             # ensure that attr is set if decorating a class method
             kwargs.setdefault('attr', wrapped.__name__)
 
         kwargs['_info'] = info.codeinfo  # fbo action_method
         return wrapped
 
 
 class jsonrpc_deprecated_method(object):
     """
     Marks method as deprecated, adds log.warning, and inject special key to
     the request variable to mark method as deprecated.
     Also injects special docstring that extract_docs will catch to mark
     method as deprecated.
 
     :param use_method: specify which method should be used instead of
         the decorated one
 
     Use like::
 
         @jsonrpc_method()
         @jsonrpc_deprecated_method(use_method='new_func', deprecated_at_version='3.0.0')
         def old_func(request, apiuser, arg1, arg2):
             ...
     """
 
     def __init__(self, use_method, deprecated_at_version):
         self.use_method = use_method
         self.deprecated_at_version = deprecated_at_version
         self.deprecated_msg = ''
 
     def __call__(self, func):
         self.deprecated_msg = 'Please use method `{method}` instead.'.format(
             method=self.use_method)
 
         docstring = """\n
         .. deprecated:: {version}
 
            {deprecation_message}
 
         {original_docstring}
         """
         func.__doc__ = docstring.format(
             version=self.deprecated_at_version,
             deprecation_message=self.deprecated_msg,
             original_docstring=func.__doc__)
         return decorator.decorator(self.__wrapper, func)
 
     def __wrapper(self, func, *fargs, **fkwargs):
         log.warning('DEPRECATED API CALL on function %s, please '
                     'use `%s` instead', func, self.use_method)
         # alter function docstring to mark as deprecated, this is picked up
         # via fabric file that generates API DOC.
         result = func(*fargs, **fkwargs)
 
         request = fargs[0]
         request.rpc_deprecation = 'DEPRECATED METHOD ' + self.deprecated_msg
         return result
 
 
 def includeme(config):
     plugin_module = 'rhodecode.api'
     plugin_settings = get_plugin_settings(
         plugin_module, config.registry.settings)
 
     if not hasattr(config.registry, 'jsonrpc_methods'):
         config.registry.jsonrpc_methods = OrderedDict()
 
     # match filter by given method only
     config.add_view_predicate('jsonrpc_method', MethodPredicate)
 
     config.add_renderer(DEFAULT_RENDERER, ExtJsonRenderer(
         serializer=json.dumps, indent=4))
     config.add_directive('add_jsonrpc_method', add_jsonrpc_method)
 
     config.add_route_predicate(
         'jsonrpc_call', RoutePredicate)
 
     config.add_route(
         'apiv2', plugin_settings.get('url', DEFAULT_URL), jsonrpc_call=True)
 
     config.scan(plugin_module, ignore='rhodecode.api.tests')
     # register some exception handling view
     config.add_view(exception_view, context=JSONRPCBaseError)
     config.add_view_predicate('jsonrpc_method_not_found', NotFoundPredicate)
     config.add_notfound_view(exception_view, jsonrpc_method_not_found=True)

rhodecode/api/exc.py

@@ -1,39 +1,39 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2011-2017  RhodeCode GmbH
+# Copyright (C) 2011-2018 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/
 
 
 class JSONRPCBaseError(Exception):
     pass
 
 
 class JSONRPCError(JSONRPCBaseError):
     pass
 
 
 class JSONRPCValidationError(JSONRPCBaseError):
 
     def __init__(self, *args, **kwargs):
         self.colander_exception = kwargs.pop('colander_exc')
         super(JSONRPCValidationError, self).__init__(*args, **kwargs)
 
 
 class JSONRPCForbidden(JSONRPCBaseError):
     pass
 

rhodecode/api/tests/__init__.py

@@ -1,19 +1,19 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017  RhodeCode GmbH
+# Copyright (C) 2010-2018 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/

rhodecode/api/tests/conftest.py

@@ -1,52 +1,52 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017  RhodeCode GmbH
+# Copyright (C) 2010-2018 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 pytest
 
 from rhodecode.model.meta import Session
 from rhodecode.model.user import UserModel
 from rhodecode.model.auth_token import AuthTokenModel
 from rhodecode.tests import TEST_USER_ADMIN_LOGIN
 
 
 @pytest.fixture(scope="class")
 def testuser_api(request, baseapp):
     cls = request.cls
 
     # ADMIN USER
     cls.usr = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
     cls.apikey = cls.usr.api_key
 
     # REGULAR USER
     cls.test_user = UserModel().create_or_update(
         username='test-api',
         password='test',
         email='[e-mail]',
         firstname='first',
         lastname='last'
     )
     # create TOKEN for user, if he doesn't have one
     if not cls.test_user.api_key:
         AuthTokenModel().create(
             user=cls.test_user, description=u'TEST_USER_TOKEN')
 
     Session().commit()
     cls.TEST_USER_LOGIN = cls.test_user.username
     cls.apikey_regular = cls.test_user.api_key

rhodecode/api/tests/test_add_field_to_repo.py

@@ -1,62 +1,62 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017  RhodeCode GmbH
+# Copyright (C) 2010-2018 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 pytest
 
 from rhodecode.model.db import Repository, RepositoryField
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_ok, assert_error)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestAddFieldToRepo(object):
     def test_api_add_field_to_repo(self, backend):
         repo = backend.create_repo()
         repo_name = repo.repo_name
         id_, params = build_data(
             self.apikey, 'add_field_to_repo',
             repoid=repo_name,
             key='extra_field',
             label='extra_field_label',
             description='extra_field_desc')
         response = api_call(self.app, params)
         expected = {
             'msg': 'Added new repository field `extra_field`',
             'success': True,
         }
         assert_ok(id_, expected, given=response.body)
 
         repo = Repository.get_by_repo_name(repo_name)
         repo_field = RepositoryField.get_by_key_name('extra_field', repo)
         _data = repo_field.get_dict()
         assert _data['field_desc'] == 'extra_field_desc'
         assert _data['field_key'] == 'extra_field'
         assert _data['field_label'] == 'extra_field_label'
 
         id_, params = build_data(
             self.apikey, 'add_field_to_repo',
             repoid=repo_name,
             key='extra_field',
             label='extra_field_label',
             description='extra_field_desc')
         response = api_call(self.app, params)
         expected = 'Field with key `extra_field` exists for repo `%s`' % (
             repo_name)
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_add_user_to_user_group.py

@@ -1,72 +1,72 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017  RhodeCode GmbH
+# Copyright (C) 2010-2018 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 mock
 import pytest
 
 from rhodecode.model.user_group import UserGroupModel
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_ok, crash)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestAddUserToUserGroup(object):
     def test_api_add_user_to_user_group(self, user_util):
         group = user_util.create_user_group()
         user = user_util.create_user()
         group_name = group.users_group_name
         user_name = user.username
         id_, params = build_data(
             self.apikey, 'add_user_to_user_group',
             usergroupid=group_name, userid=user_name)
         response = api_call(self.app, params)
         expected = {
             'msg': 'added member `%s` to user group `%s`' % (
                 user_name, group_name
             ),
             'success': True
         }
         assert_ok(id_, expected, given=response.body)
 
     def test_api_add_user_to_user_group_that_doesnt_exist(self, user_util):
         user = user_util.create_user()
         user_name = user.username
         id_, params = build_data(
             self.apikey, 'add_user_to_user_group',
             usergroupid='false-group',
             userid=user_name)
         response = api_call(self.app, params)
 
         expected = 'user group `%s` does not exist' % 'false-group'
         assert_error(id_, expected, given=response.body)
 
     @mock.patch.object(UserGroupModel, 'add_user_to_group', crash)
     def test_api_add_user_to_user_group_exception_occurred(self, user_util):
         group = user_util.create_user_group()
         user = user_util.create_user()
         group_name = group.users_group_name
         user_name = user.username
         id_, params = build_data(
             self.apikey, 'add_user_to_user_group',
             usergroupid=group_name, userid=user_name)
         response = api_call(self.app, params)
 
         expected = 'failed to add member to user group `%s`' % (group_name,)
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_api.py

@@ -1,131 +1,131 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017  RhodeCode GmbH
+# Copyright (C) 2010-2018 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 pytest
 
 from rhodecode.api.utils import Optional, OAttr
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_ok)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestApi(object):
     maxDiff = None
 
     def test_Optional_object(self):
 
         option1 = Optional(None)
         assert '<Optional:%s>' % (None,) == repr(option1)
         assert option1() is None
 
         assert 1 == Optional.extract(Optional(1))
         assert 'example' == Optional.extract('example')
 
     def test_Optional_OAttr(self):
         option1 = Optional(OAttr('apiuser'))
         assert 'apiuser' == Optional.extract(option1)
 
     def test_OAttr_object(self):
         oattr1 = OAttr('apiuser')
         assert '<OptionalAttr:apiuser>' == repr(oattr1)
         assert oattr1() == oattr1
 
     def test_api_wrong_key(self):
         id_, params = build_data('trololo', 'get_user')
         response = api_call(self.app, params)
 
         expected = 'Invalid API KEY'
         assert_error(id_, expected, given=response.body)
 
     def test_api_missing_non_optional_param(self):
         id_, params = build_data(self.apikey, 'get_repo')
         response = api_call(self.app, params)
 
         expected = 'Missing non optional `repoid` arg in JSON DATA'
         assert_error(id_, expected, given=response.body)
 
     def test_api_missing_non_optional_param_args_null(self):
         id_, params = build_data(self.apikey, 'get_repo')
         params = params.replace('"args": {}', '"args": null')
         response = api_call(self.app, params)
 
         expected = 'Missing non optional `repoid` arg in JSON DATA'
         assert_error(id_, expected, given=response.body)
 
     def test_api_missing_non_optional_param_args_bad(self):
         id_, params = build_data(self.apikey, 'get_repo')
         params = params.replace('"args": {}', '"args": 1')
         response = api_call(self.app, params)
 
         expected = 'Missing non optional `repoid` arg in JSON DATA'
         assert_error(id_, expected, given=response.body)
 
     def test_api_non_existing_method(self, request):
         id_, params = build_data(self.apikey, 'not_existing', args='xx')
         response = api_call(self.app, params)
         expected = 'No such method: not_existing. Similar methods: none'
         assert_error(id_, expected, given=response.body)
 
     def test_api_non_existing_method_have_similar(self, request):
         id_, params = build_data(self.apikey, 'comment', args='xx')
         response = api_call(self.app, params)
         expected = 'No such method: comment. Similar methods: changeset_comment, comment_pull_request, get_pull_request_comments, comment_commit'
         assert_error(id_, expected, given=response.body)
 
     def test_api_disabled_user(self, request):
 
         def set_active(active):
             from rhodecode.model.db import Session, User
             user = User.get_by_auth_token(self.apikey)
             user.active = active
             Session().add(user)
             Session().commit()
 
         request.addfinalizer(lambda: set_active(True))
 
         set_active(False)
         id_, params = build_data(self.apikey, 'test', args='xx')
         response = api_call(self.app, params)
         expected = 'Request from this user not allowed'
         assert_error(id_, expected, given=response.body)
 
     def test_api_args_is_null(self):
         __, params = build_data(self.apikey, 'get_users', )
         params = params.replace('"args": {}', '"args": null')
         response = api_call(self.app, params)
         assert response.status == '200 OK'
 
     def test_api_args_is_bad(self):
         __, params = build_data(self.apikey, 'get_users', )
         params = params.replace('"args": {}', '"args": 1')
         response = api_call(self.app, params)
         assert response.status == '200 OK'
 
     def test_api_args_different_args(self):
         import string
         expected = {
             'ascii_letters': string.ascii_letters,
             'ws': string.whitespace,
             'printables': string.printable
         }
         id_, params = build_data(self.apikey, 'test', args=expected)
         response = api_call(self.app, params)
         assert response.status == '200 OK'
         assert_ok(id_, expected, response.body)

rhodecode/api/tests/test_cleanup_sessions.py

@@ -1,44 +1,44 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2017-2017 RhodeCode GmbH
+# Copyright (C) 2017-2018 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 mock
 import pytest
 
 from rhodecode.lib.user_sessions import FileAuthSessions
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_ok, assert_error, crash)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestCleanupSessions(object):
     def test_api_cleanup_sessions(self):
         id_, params = build_data(self.apikey, 'cleanup_sessions')
         response = api_call(self.app, params)
 
         expected = {'backend': 'file sessions', 'sessions_removed': 0}
         assert_ok(id_, expected, given=response.body)
 
     @mock.patch.object(FileAuthSessions, 'clean_sessions', crash)
     def test_api_cleanup_error(self):
         id_, params = build_data(self.apikey, 'cleanup_sessions', )
         response = api_call(self.app, params)
 
         expected = 'Error occurred during session cleanup'
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_close_pull_request.py

@@ -1,113 +1,113 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017  RhodeCode GmbH
+# Copyright (C) 2010-2018 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 pytest
 
 from rhodecode.model.db import UserLog
 from rhodecode.model.pull_request import PullRequestModel
 from rhodecode.tests import TEST_USER_ADMIN_LOGIN
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_ok)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestClosePullRequest(object):
 
     @pytest.mark.backends("git", "hg")
     def test_api_close_pull_request(self, pr_util):
         pull_request = pr_util.create_pull_request()
         pull_request_id = pull_request.pull_request_id
         author = pull_request.user_id
         repo = pull_request.target_repo.repo_id
         id_, params = build_data(
             self.apikey, 'close_pull_request',
             repoid=pull_request.target_repo.repo_name,
             pullrequestid=pull_request.pull_request_id)
         response = api_call(self.app, params)
         expected = {
             'pull_request_id': pull_request_id,
             'close_status': 'Rejected',
             'closed': True,
         }
         assert_ok(id_, expected, response.body)
         journal = UserLog.query()\
             .filter(UserLog.user_id == author) \
             .order_by('user_log_id') \
             .filter(UserLog.repository_id == repo)\
             .all()
         assert journal[-1].action == 'repo.pull_request.close'
 
     @pytest.mark.backends("git", "hg")
     def test_api_close_pull_request_already_closed_error(self, pr_util):
         pull_request = pr_util.create_pull_request()
         pull_request_id = pull_request.pull_request_id
         pull_request_repo = pull_request.target_repo.repo_name
         PullRequestModel().close_pull_request(
             pull_request, pull_request.author)
         id_, params = build_data(
             self.apikey, 'close_pull_request',
             repoid=pull_request_repo, pullrequestid=pull_request_id)
         response = api_call(self.app, params)
 
         expected = 'pull request `%s` is already closed' % pull_request_id
         assert_error(id_, expected, given=response.body)
 
     @pytest.mark.backends("git", "hg")
     def test_api_close_pull_request_repo_error(self, pr_util):
         pull_request = pr_util.create_pull_request()
         id_, params = build_data(
             self.apikey, 'close_pull_request',
             repoid=666, pullrequestid=pull_request.pull_request_id)
         response = api_call(self.app, params)
 
         expected = 'repository `666` does not exist'
         assert_error(id_, expected, given=response.body)
 
     @pytest.mark.backends("git", "hg")
     def test_api_close_pull_request_non_admin_with_userid_error(self,
                                                                 pr_util):
         pull_request = pr_util.create_pull_request()
         id_, params = build_data(
             self.apikey_regular, 'close_pull_request',
             repoid=pull_request.target_repo.repo_name,
             pullrequestid=pull_request.pull_request_id,
             userid=TEST_USER_ADMIN_LOGIN)
         response = api_call(self.app, params)
 
         expected = 'userid is not the same as your user'
         assert_error(id_, expected, given=response.body)
 
     @pytest.mark.backends("git", "hg")
     def test_api_close_pull_request_no_perms_to_close(
             self, user_util, pr_util):
         user = user_util.create_user()
         pull_request = pr_util.create_pull_request()
 
         id_, params = build_data(
             user.api_key, 'close_pull_request',
             repoid=pull_request.target_repo.repo_name,
             pullrequestid=pull_request.pull_request_id,)
         response = api_call(self.app, params)
 
         expected = ('pull request `%s` close failed, '
                     'no permission to close.') % pull_request.pull_request_id
 
         response_json = response.json['error']
         assert response_json == expected

rhodecode/api/tests/test_comment_commit.py

@@ -1,81 +1,81 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017  RhodeCode GmbH
+# Copyright (C) 2010-2018 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 pytest
 
 from rhodecode.model.db import ChangesetStatus
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_ok)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestCommentCommit(object):
     def test_api_comment_commit_on_empty_repo(self, backend):
         repo = backend.create_repo()
         id_, params = build_data(
             self.apikey, 'comment_commit', repoid=repo.repo_name,
             commit_id='tip', message='message', status_change=None)
         response = api_call(self.app, params)
         expected = 'There are no commits yet'
         assert_error(id_, expected, given=response.body)
 
     @pytest.mark.parametrize("commit_id, expected_err", [
         ('abcabca', {'hg': 'Commit {commit} does not exist for {repo}',
                      'git': 'Commit {commit} does not exist for {repo}',
                      'svn': 'Commit id {commit} not understood.'}),
         ('idontexist', {'hg': 'Commit {commit} does not exist for {repo}',
                         'git': 'Commit {commit} does not exist for {repo}',
                         'svn': 'Commit id {commit} not understood.'}),
     ])
     def test_api_comment_commit_wrong_hash(self, backend, commit_id, expected_err):
         repo_name = backend.repo.repo_name
         id_, params = build_data(
             self.apikey, 'comment_commit', repoid=repo_name,
             commit_id=commit_id, message='message', status_change=None)
         response = api_call(self.app, params)
 
         expected_err = expected_err[backend.alias]
         expected_err = expected_err.format(
             repo=backend.repo.scm_instance(), commit=commit_id)
         assert_error(id_, expected_err, given=response.body)
 
     @pytest.mark.parametrize("status_change, message, commit_id", [
         (None, 'Hallo', 'tip'),
         (ChangesetStatus.STATUS_APPROVED, 'Approved', 'tip'),
         (ChangesetStatus.STATUS_REJECTED, 'Rejected', 'tip'),
     ])
     def test_api_comment_commit(
             self, backend, status_change, message, commit_id,
             no_notifications):
 
         commit_id = backend.repo.scm_instance().get_changeset(commit_id).raw_id
 
         id_, params = build_data(
             self.apikey, 'comment_commit', repoid=backend.repo_name,
             commit_id=commit_id, message=message, status=status_change)
         response = api_call(self.app, params)
         repo = backend.repo.scm_instance()
         expected = {
             'msg': 'Commented on commit `%s` for repository `%s`' % (
                 repo.get_changeset().raw_id, backend.repo_name),
             'status_change': status_change,
             'success': True
         }
         assert_ok(id_, expected, given=response.body)

rhodecode/api/tests/test_comment_pull_request.py

@@ -1,209 +1,209 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017  RhodeCode GmbH
+# Copyright (C) 2010-2018 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 pytest
 
 from rhodecode.model.comment import CommentsModel
 from rhodecode.model.db import UserLog
 from rhodecode.model.pull_request import PullRequestModel
 from rhodecode.tests import TEST_USER_ADMIN_LOGIN
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_ok)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestCommentPullRequest(object):
     finalizers = []
 
     def teardown_method(self, method):
         if self.finalizers:
             for finalizer in self.finalizers:
                 finalizer()
             self.finalizers = []
 
     @pytest.mark.backends("git", "hg")
     def test_api_comment_pull_request(self, pr_util, no_notifications):
         pull_request = pr_util.create_pull_request()
         pull_request_id = pull_request.pull_request_id
         author = pull_request.user_id
         repo = pull_request.target_repo.repo_id
         id_, params = build_data(
             self.apikey, 'comment_pull_request',
             repoid=pull_request.target_repo.repo_name,
             pullrequestid=pull_request.pull_request_id,
             message='test message')
         response = api_call(self.app, params)
         pull_request = PullRequestModel().get(pull_request.pull_request_id)
 
         comments = CommentsModel().get_comments(
             pull_request.target_repo.repo_id, pull_request=pull_request)
 
         expected = {
             'pull_request_id': pull_request.pull_request_id,
             'comment_id': comments[-1].comment_id,
             'status': {'given': None, 'was_changed': None}
         }
         assert_ok(id_, expected, response.body)
 
         journal = UserLog.query()\
             .filter(UserLog.user_id == author)\
             .filter(UserLog.repository_id == repo) \
             .order_by('user_log_id') \
             .all()
         assert journal[-1].action == 'repo.pull_request.comment.create'
 
     @pytest.mark.backends("git", "hg")
     def test_api_comment_pull_request_change_status(
             self, pr_util, no_notifications):
         pull_request = pr_util.create_pull_request()
         pull_request_id = pull_request.pull_request_id
         id_, params = build_data(
             self.apikey, 'comment_pull_request',
             repoid=pull_request.target_repo.repo_name,
             pullrequestid=pull_request.pull_request_id,
             status='rejected')
         response = api_call(self.app, params)
         pull_request = PullRequestModel().get(pull_request_id)
 
         comments = CommentsModel().get_comments(
             pull_request.target_repo.repo_id, pull_request=pull_request)
         expected = {
             'pull_request_id': pull_request.pull_request_id,
             'comment_id': comments[-1].comment_id,
             'status':  {'given': 'rejected', 'was_changed': True}
         }
         assert_ok(id_, expected, response.body)
 
     @pytest.mark.backends("git", "hg")
     def test_api_comment_pull_request_change_status_with_specific_commit_id(
             self, pr_util, no_notifications):
         pull_request = pr_util.create_pull_request()
         pull_request_id = pull_request.pull_request_id
         latest_commit_id = 'test_commit'
         # inject additional revision, to fail test the status change on
         # non-latest commit
         pull_request.revisions = pull_request.revisions + ['test_commit']
 
         id_, params = build_data(
             self.apikey, 'comment_pull_request',
             repoid=pull_request.target_repo.repo_name,
             pullrequestid=pull_request.pull_request_id,
             status='approved', commit_id=latest_commit_id)
         response = api_call(self.app, params)
         pull_request = PullRequestModel().get(pull_request_id)
 
         expected = {
             'pull_request_id': pull_request.pull_request_id,
             'comment_id': None,
             'status':  {'given': 'approved', 'was_changed': False}
         }
         assert_ok(id_, expected, response.body)
 
     @pytest.mark.backends("git", "hg")
     def test_api_comment_pull_request_change_status_with_specific_commit_id(
             self, pr_util, no_notifications):
         pull_request = pr_util.create_pull_request()
         pull_request_id = pull_request.pull_request_id
         latest_commit_id = pull_request.revisions[0]
 
         id_, params = build_data(
             self.apikey, 'comment_pull_request',
             repoid=pull_request.target_repo.repo_name,
             pullrequestid=pull_request.pull_request_id,
             status='approved', commit_id=latest_commit_id)
         response = api_call(self.app, params)
         pull_request = PullRequestModel().get(pull_request_id)
 
         comments = CommentsModel().get_comments(
             pull_request.target_repo.repo_id, pull_request=pull_request)
         expected = {
             'pull_request_id': pull_request.pull_request_id,
             'comment_id': comments[-1].comment_id,
             'status':  {'given': 'approved', 'was_changed': True}
         }
         assert_ok(id_, expected, response.body)
 
     @pytest.mark.backends("git", "hg")
     def test_api_comment_pull_request_missing_params_error(self, pr_util):
         pull_request = pr_util.create_pull_request()
         pull_request_id = pull_request.pull_request_id
         pull_request_repo = pull_request.target_repo.repo_name
         id_, params = build_data(
             self.apikey, 'comment_pull_request',
             repoid=pull_request_repo,
             pullrequestid=pull_request_id)
         response = api_call(self.app, params)
 
         expected = 'Both message and status parameters are missing. At least one is required.'
         assert_error(id_, expected, given=response.body)
 
     @pytest.mark.backends("git", "hg")
     def test_api_comment_pull_request_unknown_status_error(self, pr_util):
         pull_request = pr_util.create_pull_request()
         pull_request_id = pull_request.pull_request_id
         pull_request_repo = pull_request.target_repo.repo_name
         id_, params = build_data(
             self.apikey, 'comment_pull_request',
             repoid=pull_request_repo,
             pullrequestid=pull_request_id,
             status='42')
         response = api_call(self.app, params)
 
         expected = 'Unknown comment status: `42`'
         assert_error(id_, expected, given=response.body)
 
     @pytest.mark.backends("git", "hg")
     def test_api_comment_pull_request_repo_error(self, pr_util):
         pull_request = pr_util.create_pull_request()
         id_, params = build_data(
             self.apikey, 'comment_pull_request',
             repoid=666, pullrequestid=pull_request.pull_request_id)
         response = api_call(self.app, params)
 
         expected = 'repository `666` does not exist'
         assert_error(id_, expected, given=response.body)
 
     @pytest.mark.backends("git", "hg")
     def test_api_comment_pull_request_non_admin_with_userid_error(
             self, pr_util):
         pull_request = pr_util.create_pull_request()
         id_, params = build_data(
             self.apikey_regular, 'comment_pull_request',
             repoid=pull_request.target_repo.repo_name,
             pullrequestid=pull_request.pull_request_id,
             userid=TEST_USER_ADMIN_LOGIN)
         response = api_call(self.app, params)
 
         expected = 'userid is not the same as your user'
         assert_error(id_, expected, given=response.body)
 
     @pytest.mark.backends("git", "hg")
     def test_api_comment_pull_request_wrong_commit_id_error(self, pr_util):
         pull_request = pr_util.create_pull_request()
         id_, params = build_data(
             self.apikey_regular, 'comment_pull_request',
             repoid=pull_request.target_repo.repo_name,
             status='approved',
             pullrequestid=pull_request.pull_request_id,
             commit_id='XXX')
         response = api_call(self.app, params)
 
         expected = 'Invalid commit_id `XXX` for this pull request.'
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_create_gist.py

@@ -1,102 +1,102 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017  RhodeCode GmbH
+# Copyright (C) 2010-2018 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 mock
 import pytest
 
 from rhodecode.model.db import Gist
 from rhodecode.model.gist import GistModel
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_ok, crash)
 from rhodecode.tests.fixture import Fixture
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestApiCreateGist(object):
     @pytest.mark.parametrize("lifetime, gist_type, gist_acl_level", [
         (10, Gist.GIST_PUBLIC, Gist.ACL_LEVEL_PUBLIC),
         (20, Gist.GIST_PUBLIC, Gist.ACL_LEVEL_PRIVATE),
         (40, Gist.GIST_PRIVATE, Gist.ACL_LEVEL_PUBLIC),
         (80, Gist.GIST_PRIVATE, Gist.ACL_LEVEL_PRIVATE),
     ])
     def test_api_create_gist(self, lifetime, gist_type, gist_acl_level):
         id_, params = build_data(
             self.apikey_regular, 'create_gist',
             lifetime=lifetime,
             description='foobar-gist',
             gist_type=gist_type,
             acl_level=gist_acl_level,
             files={'foobar_ąć': {'content': 'foo'}})
         response = api_call(self.app, params)
         response_json = response.json
         gist = response_json['result']['gist']
         expected = {
             'gist': {
                 'access_id': gist['access_id'],
                 'created_on': gist['created_on'],
                 'modified_at': gist['modified_at'],
                 'description': 'foobar-gist',
                 'expires': gist['expires'],
                 'gist_id': gist['gist_id'],
                 'type': gist_type,
                 'url': gist['url'],
                 # content is empty since we don't show it here
                 'content': None,
                 'acl_level': gist_acl_level,
             },
             'msg': 'created new gist'
         }
         try:
             assert_ok(id_, expected, given=response.body)
         finally:
             Fixture().destroy_gists()
 
     @pytest.mark.parametrize("expected, lifetime, gist_type, gist_acl_level, files", [
         ({'gist_type': '"ups" is not one of private, public'},
          10, 'ups', Gist.ACL_LEVEL_PUBLIC, {'f': {'content': 'f'}}),
 
         ({'lifetime': '-120 is less than minimum value -1'},
          -120, Gist.GIST_PUBLIC, Gist.ACL_LEVEL_PUBLIC, {'f': {'content': 'f'}}),
 
         ({'0.content': 'Required'},
          10, Gist.GIST_PUBLIC, Gist.ACL_LEVEL_PUBLIC, {'f': {'x': 'f'}}),
     ])
     def test_api_try_create_gist(
             self, expected, lifetime, gist_type, gist_acl_level, files):
         id_, params = build_data(
             self.apikey_regular, 'create_gist',
             lifetime=lifetime,
             description='foobar-gist',
             gist_type=gist_type,
             acl_level=gist_acl_level,
             files=files)
         response = api_call(self.app, params)
 
         try:
             assert_error(id_, expected, given=response.body)
         finally:
             Fixture().destroy_gists()
 
     @mock.patch.object(GistModel, 'create', crash)
     def test_api_create_gist_exception_occurred(self):
         id_, params = build_data(self.apikey_regular, 'create_gist', files={})
         response = api_call(self.app, params)
         expected = 'failed to create gist'
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_create_pull_request.py

@@ -1,297 +1,297 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017  RhodeCode GmbH
+# Copyright (C) 2010-2018 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 pytest
 
 from rhodecode.model.db import User
 from rhodecode.model.pull_request import PullRequestModel
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.user import UserModel
 from rhodecode.tests import TEST_USER_ADMIN_LOGIN, TEST_USER_REGULAR_LOGIN
 from rhodecode.api.tests.utils import build_data, api_call, assert_error
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestCreatePullRequestApi(object):
     finalizers = []
 
     def teardown_method(self, method):
         if self.finalizers:
             for finalizer in self.finalizers:
                 finalizer()
             self.finalizers = []
 
     def test_create_with_wrong_data(self):
         required_data = {
             'source_repo': 'tests/source_repo',
             'target_repo': 'tests/target_repo',
             'source_ref': 'branch:default:initial',
             'target_ref': 'branch:default:new-feature',
             'title': 'Test PR 1'
         }
         for key in required_data:
             data = required_data.copy()
             data.pop(key)
             id_, params = build_data(
                 self.apikey, 'create_pull_request', **data)
             response = api_call(self.app, params)
 
             expected = 'Missing non optional `{}` arg in JSON DATA'.format(key)
             assert_error(id_, expected, given=response.body)
 
     @pytest.mark.backends("git", "hg")
     def test_create_with_correct_data(self, backend):
         data = self._prepare_data(backend)
         RepoModel().revoke_user_permission(
             self.source.repo_name, User.DEFAULT_USER)
         id_, params = build_data(
             self.apikey_regular, 'create_pull_request', **data)
         response = api_call(self.app, params)
         expected_message = "Created new pull request `{title}`".format(
             title=data['title'])
         result = response.json
         assert result['result']['msg'] == expected_message
         pull_request_id = result['result']['pull_request_id']
         pull_request = PullRequestModel().get(pull_request_id)
         assert pull_request.title == data['title']
         assert pull_request.description == data['description']
         assert pull_request.source_ref == data['source_ref']
         assert pull_request.target_ref == data['target_ref']
         assert pull_request.source_repo.repo_name == data['source_repo']
         assert pull_request.target_repo.repo_name == data['target_repo']
         assert pull_request.revisions == [self.commit_ids['change']]
         assert len(pull_request.reviewers) == 1
 
     @pytest.mark.backends("git", "hg")
     def test_create_with_empty_description(self, backend):
         data = self._prepare_data(backend)
         data.pop('description')
         id_, params = build_data(
             self.apikey_regular, 'create_pull_request', **data)
         response = api_call(self.app, params)
         expected_message = "Created new pull request `{title}`".format(
             title=data['title'])
         result = response.json
         assert result['result']['msg'] == expected_message
         pull_request_id = result['result']['pull_request_id']
         pull_request = PullRequestModel().get(pull_request_id)
         assert pull_request.description == ''
 
     @pytest.mark.backends("git", "hg")
     def test_create_with_reviewers_specified_by_names(
             self, backend, no_notifications):
         data = self._prepare_data(backend)
         reviewers = [
             {'username': TEST_USER_REGULAR_LOGIN,
              'reasons': ['added manually']},
             {'username': TEST_USER_ADMIN_LOGIN,
              'reasons': ['added manually']},
         ]
         data['reviewers'] = reviewers
         id_, params = build_data(
             self.apikey_regular, 'create_pull_request', **data)
         response = api_call(self.app, params)
 
         expected_message = "Created new pull request `{title}`".format(
             title=data['title'])
         result = response.json
         assert result['result']['msg'] == expected_message
         pull_request_id = result['result']['pull_request_id']
         pull_request = PullRequestModel().get(pull_request_id)
         actual_reviewers = [
             {'username': r.user.username,
              'reasons': ['added manually'],
              } for r in pull_request.reviewers
         ]
         assert sorted(actual_reviewers) == sorted(reviewers)
 
     @pytest.mark.backends("git", "hg")
     def test_create_with_reviewers_specified_by_ids(
             self, backend, no_notifications):
         data = self._prepare_data(backend)
         reviewers = [
             {'username': UserModel().get_by_username(
                 TEST_USER_REGULAR_LOGIN).user_id,
              'reasons': ['added manually']},
             {'username': UserModel().get_by_username(
                 TEST_USER_ADMIN_LOGIN).user_id,
              'reasons': ['added manually']},
         ]
 
         data['reviewers'] = reviewers
         id_, params = build_data(
             self.apikey_regular, 'create_pull_request', **data)
         response = api_call(self.app, params)
 
         expected_message = "Created new pull request `{title}`".format(
             title=data['title'])
         result = response.json
         assert result['result']['msg'] == expected_message
         pull_request_id = result['result']['pull_request_id']
         pull_request = PullRequestModel().get(pull_request_id)
         actual_reviewers = [
             {'username': r.user.user_id,
              'reasons': ['added manually'],
              } for r in pull_request.reviewers
         ]
         assert sorted(actual_reviewers) == sorted(reviewers)
 
     @pytest.mark.backends("git", "hg")
     def test_create_fails_when_the_reviewer_is_not_found(self, backend):
         data = self._prepare_data(backend)
         data['reviewers'] = [{'username': 'somebody'}]
         id_, params = build_data(
             self.apikey_regular, 'create_pull_request', **data)
         response = api_call(self.app, params)
         expected_message = 'user `somebody` does not exist'
         assert_error(id_, expected_message, given=response.body)
 
     @pytest.mark.backends("git", "hg")
     def test_cannot_create_with_reviewers_in_wrong_format(self, backend):
         data = self._prepare_data(backend)
         reviewers = ','.join([TEST_USER_REGULAR_LOGIN, TEST_USER_ADMIN_LOGIN])
         data['reviewers'] = reviewers
         id_, params = build_data(
             self.apikey_regular, 'create_pull_request', **data)
         response = api_call(self.app, params)
         expected_message = {u'': '"test_regular,test_admin" is not iterable'}
         assert_error(id_, expected_message, given=response.body)
 
     @pytest.mark.backends("git", "hg")
     def test_create_with_no_commit_hashes(self, backend):
         data = self._prepare_data(backend)
         expected_source_ref = data['source_ref']
         expected_target_ref = data['target_ref']
         data['source_ref'] = 'branch:{}'.format(backend.default_branch_name)
         data['target_ref'] = 'branch:{}'.format(backend.default_branch_name)
         id_, params = build_data(
             self.apikey_regular, 'create_pull_request', **data)
         response = api_call(self.app, params)
         expected_message = "Created new pull request `{title}`".format(
             title=data['title'])
         result = response.json
         assert result['result']['msg'] == expected_message
         pull_request_id = result['result']['pull_request_id']
         pull_request = PullRequestModel().get(pull_request_id)
         assert pull_request.source_ref == expected_source_ref
         assert pull_request.target_ref == expected_target_ref
 
     @pytest.mark.backends("git", "hg")
     @pytest.mark.parametrize("data_key", ["source_repo", "target_repo"])
     def test_create_fails_with_wrong_repo(self, backend, data_key):
         repo_name = 'fake-repo'
         data = self._prepare_data(backend)
         data[data_key] = repo_name
         id_, params = build_data(
             self.apikey_regular, 'create_pull_request', **data)
         response = api_call(self.app, params)
         expected_message = 'repository `{}` does not exist'.format(repo_name)
         assert_error(id_, expected_message, given=response.body)
 
     @pytest.mark.backends("git", "hg")
     @pytest.mark.parametrize("data_key", ["source_ref", "target_ref"])
     def test_create_fails_with_non_existing_branch(self, backend, data_key):
         branch_name = 'test-branch'
         data = self._prepare_data(backend)
         data[data_key] = "branch:{}".format(branch_name)
         id_, params = build_data(
             self.apikey_regular, 'create_pull_request', **data)
         response = api_call(self.app, params)
         expected_message = 'The specified branch `{}` does not exist'.format(
             branch_name)
         assert_error(id_, expected_message, given=response.body)
 
     @pytest.mark.backends("git", "hg")
     @pytest.mark.parametrize("data_key", ["source_ref", "target_ref"])
     def test_create_fails_with_ref_in_a_wrong_format(self, backend, data_key):
         data = self._prepare_data(backend)
         ref = 'stange-ref'
         data[data_key] = ref
         id_, params = build_data(
             self.apikey_regular, 'create_pull_request', **data)
         response = api_call(self.app, params)
         expected_message = (
             'Ref `{ref}` given in a wrong format. Please check the API'
             ' documentation for more details'.format(ref=ref))
         assert_error(id_, expected_message, given=response.body)
 
     @pytest.mark.backends("git", "hg")
     @pytest.mark.parametrize("data_key", ["source_ref", "target_ref"])
     def test_create_fails_with_non_existing_ref(self, backend, data_key):
         commit_id = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa10'
         ref = self._get_full_ref(backend, commit_id)
         data = self._prepare_data(backend)
         data[data_key] = ref
         id_, params = build_data(
             self.apikey_regular, 'create_pull_request', **data)
         response = api_call(self.app, params)
         expected_message = 'Ref `{}` does not exist'.format(ref)
         assert_error(id_, expected_message, given=response.body)
 
     @pytest.mark.backends("git", "hg")
     def test_create_fails_when_no_revisions(self, backend):
         data = self._prepare_data(backend, source_head='initial')
         id_, params = build_data(
             self.apikey_regular, 'create_pull_request', **data)
         response = api_call(self.app, params)
         expected_message = 'no commits found'
         assert_error(id_, expected_message, given=response.body)
 
     @pytest.mark.backends("git", "hg")
     def test_create_fails_when_no_permissions(self, backend):
         data = self._prepare_data(backend)
         RepoModel().revoke_user_permission(
             self.source.repo_name, User.DEFAULT_USER)
         RepoModel().revoke_user_permission(
             self.source.repo_name, self.test_user)
         id_, params = build_data(
             self.apikey_regular, 'create_pull_request', **data)
         response = api_call(self.app, params)
         expected_message = 'repository `{}` does not exist'.format(
             self.source.repo_name)
         assert_error(id_, expected_message, given=response.body)
 
     def _prepare_data(
             self, backend, source_head='change', target_head='initial'):
         commits = [
             {'message': 'initial'},
             {'message': 'change'},
             {'message': 'new-feature', 'parents': ['initial']},
         ]
         self.commit_ids = backend.create_master_repo(commits)
         self.source = backend.create_repo(heads=[source_head])
         self.target = backend.create_repo(heads=[target_head])
         data = {
             'source_repo': self.source.repo_name,
             'target_repo': self.target.repo_name,
             'source_ref': self._get_full_ref(
                 backend, self.commit_ids[source_head]),
             'target_ref': self._get_full_ref(
                 backend, self.commit_ids[target_head]),
             'title': 'Test PR 1',
             'description': 'Test'
         }
         RepoModel().grant_user_permission(
             self.source.repo_name, self.TEST_USER_LOGIN, 'repository.read')
         return data
 
     def _get_full_ref(self, backend, commit_id):
         return 'branch:{branch}:{commit_id}'.format(
             branch=backend.default_branch_name, commit_id=commit_id)

rhodecode/api/tests/test_create_repo.py

@@ -1,350 +1,350 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017  RhodeCode GmbH
+# Copyright (C) 2010-2018 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 json
 
 import mock
 import pytest
 
 from rhodecode.lib.utils2 import safe_unicode
 from rhodecode.lib.vcs import settings
 from rhodecode.model.meta import Session
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.user import UserModel
 from rhodecode.tests import TEST_USER_ADMIN_LOGIN
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_ok, assert_error, crash)
 from rhodecode.tests.fixture import Fixture
 
 
 fixture = Fixture()
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestCreateRepo(object):
 
     @pytest.mark.parametrize('given, expected_name, expected_exc', [
         ('api repo-1', 'api-repo-1', False),
         ('api-repo 1-ąć', 'api-repo-1-ąć', False),
         (u'unicode-ąć', u'unicode-ąć', False),
         ('some repo v1.2', 'some-repo-v1.2', False),
         ('v2.0', 'v2.0', False),
     ])
     def test_api_create_repo(self, backend, given, expected_name, expected_exc):
 
         id_, params = build_data(
             self.apikey,
             'create_repo',
             repo_name=given,
             owner=TEST_USER_ADMIN_LOGIN,
             repo_type=backend.alias,
         )
         response = api_call(self.app, params)
 
         ret = {
             'msg': 'Created new repository `%s`' % (expected_name,),
             'success': True,
             'task': None,
         }
         expected = ret
         assert_ok(id_, expected, given=response.body)
 
         repo = RepoModel().get_by_repo_name(safe_unicode(expected_name))
         assert repo is not None
 
         id_, params = build_data(self.apikey, 'get_repo', repoid=expected_name)
         response = api_call(self.app, params)
         body = json.loads(response.body)
 
         assert body['result']['enable_downloads'] is False
         assert body['result']['enable_locking'] is False
         assert body['result']['enable_statistics'] is False
 
         fixture.destroy_repo(safe_unicode(expected_name))
 
     def test_api_create_restricted_repo_type(self, backend):
         repo_name = 'api-repo-type-{0}'.format(backend.alias)
         id_, params = build_data(
             self.apikey,
             'create_repo',
             repo_name=repo_name,
             owner=TEST_USER_ADMIN_LOGIN,
             repo_type=backend.alias,
         )
         git_backend = settings.BACKENDS['git']
         with mock.patch(
                 'rhodecode.lib.vcs.settings.BACKENDS', {'git': git_backend}):
             response = api_call(self.app, params)
 
         repo = RepoModel().get_by_repo_name(repo_name)
 
         if backend.alias == 'git':
             assert repo is not None
             expected = {
                 'msg': 'Created new repository `{0}`'.format(repo_name,),
                 'success': True,
                 'task': None,
             }
             assert_ok(id_, expected, given=response.body)
         else:
             assert repo is None
 
         fixture.destroy_repo(repo_name)
 
     def test_api_create_repo_with_booleans(self, backend):
         repo_name = 'api-repo-2'
         id_, params = build_data(
             self.apikey,
             'create_repo',
             repo_name=repo_name,
             owner=TEST_USER_ADMIN_LOGIN,
             repo_type=backend.alias,
             enable_statistics=True,
             enable_locking=True,
             enable_downloads=True
         )
         response = api_call(self.app, params)
 
         repo = RepoModel().get_by_repo_name(repo_name)
 
         assert repo is not None
         ret = {
             'msg': 'Created new repository `%s`' % (repo_name,),
             'success': True,
             'task': None,
         }
         expected = ret
         assert_ok(id_, expected, given=response.body)
 
         id_, params = build_data(self.apikey, 'get_repo', repoid=repo_name)
         response = api_call(self.app, params)
         body = json.loads(response.body)
 
         assert body['result']['enable_downloads'] is True
         assert body['result']['enable_locking'] is True
         assert body['result']['enable_statistics'] is True
 
         fixture.destroy_repo(repo_name)
 
     def test_api_create_repo_in_group(self, backend):
         repo_group_name = 'my_gr'
         # create the parent
         fixture.create_repo_group(repo_group_name)
 
         repo_name = '%s/api-repo-gr' % (repo_group_name,)
         id_, params = build_data(
             self.apikey, 'create_repo',
             repo_name=repo_name,
             owner=TEST_USER_ADMIN_LOGIN,
             repo_type=backend.alias,)
         response = api_call(self.app, params)
         repo = RepoModel().get_by_repo_name(repo_name)
         assert repo is not None
         assert repo.group is not None
 
         ret = {
             'msg': 'Created new repository `%s`' % (repo_name,),
             'success': True,
             'task': None,
         }
         expected = ret
         assert_ok(id_, expected, given=response.body)
         fixture.destroy_repo(repo_name)
         fixture.destroy_repo_group(repo_group_name)
 
     def test_create_repo_in_group_that_doesnt_exist(self, backend, user_util):
         repo_group_name = 'fake_group'
 
         repo_name = '%s/api-repo-gr' % (repo_group_name,)
         id_, params = build_data(
             self.apikey, 'create_repo',
             repo_name=repo_name,
             owner=TEST_USER_ADMIN_LOGIN,
             repo_type=backend.alias,)
         response = api_call(self.app, params)
 
         expected = {'repo_group': 'Repository group `{}` does not exist'.format(
             repo_group_name)}
         assert_error(id_, expected, given=response.body)
 
     def test_api_create_repo_unknown_owner(self, backend):
         repo_name = 'api-repo-2'
         owner = 'i-dont-exist'
         id_, params = build_data(
             self.apikey, 'create_repo',
             repo_name=repo_name,
             owner=owner,
             repo_type=backend.alias)
         response = api_call(self.app, params)
         expected = 'user `%s` does not exist' % (owner,)
         assert_error(id_, expected, given=response.body)
 
     def test_api_create_repo_dont_specify_owner(self, backend):
         repo_name = 'api-repo-3'
         id_, params = build_data(
             self.apikey, 'create_repo',
             repo_name=repo_name,
             repo_type=backend.alias)
         response = api_call(self.app, params)
 
         repo = RepoModel().get_by_repo_name(repo_name)
         assert repo is not None
         ret = {
             'msg': 'Created new repository `%s`' % (repo_name,),
             'success': True,
             'task': None,
         }
         expected = ret
         assert_ok(id_, expected, given=response.body)
         fixture.destroy_repo(repo_name)
 
     def test_api_create_repo_by_non_admin(self, backend):
         repo_name = 'api-repo-4'
         id_, params = build_data(
             self.apikey_regular, 'create_repo',
             repo_name=repo_name,
             repo_type=backend.alias)
         response = api_call(self.app, params)
 
         repo = RepoModel().get_by_repo_name(repo_name)
         assert repo is not None
         ret = {
             'msg': 'Created new repository `%s`' % (repo_name,),
             'success': True,
             'task': None,
         }
         expected = ret
         assert_ok(id_, expected, given=response.body)
         fixture.destroy_repo(repo_name)
 
     def test_api_create_repo_by_non_admin_specify_owner(self, backend):
         repo_name = 'api-repo-5'
         owner = 'i-dont-exist'
         id_, params = build_data(
             self.apikey_regular, 'create_repo',
             repo_name=repo_name,
             repo_type=backend.alias,
             owner=owner)
         response = api_call(self.app, params)
 
         expected = 'Only RhodeCode super-admin can specify `owner` param'
         assert_error(id_, expected, given=response.body)
         fixture.destroy_repo(repo_name)
 
     def test_api_create_repo_by_non_admin_no_parent_group_perms(self, backend):
         repo_group_name = 'no-access'
         fixture.create_repo_group(repo_group_name)
         repo_name = 'no-access/api-repo'
 
         id_, params = build_data(
             self.apikey_regular, 'create_repo',
             repo_name=repo_name,
             repo_type=backend.alias)
         response = api_call(self.app, params)
 
         expected = {'repo_group': 'Repository group `{}` does not exist'.format(
             repo_group_name)}
         assert_error(id_, expected, given=response.body)
         fixture.destroy_repo_group(repo_group_name)
         fixture.destroy_repo(repo_name)
 
     def test_api_create_repo_non_admin_no_permission_to_create_to_root_level(
             self, backend, user_util):
 
         regular_user = user_util.create_user()
         regular_user_api_key = regular_user.api_key
 
         usr = UserModel().get_by_username(regular_user.username)
         usr.inherit_default_permissions = False
         Session().add(usr)
 
         repo_name = backend.new_repo_name()
         id_, params = build_data(
             regular_user_api_key, 'create_repo',
             repo_name=repo_name,
             repo_type=backend.alias)
         response = api_call(self.app, params)
         expected = {
             "repo_name": "You do not have the permission to "
                          "store repositories in the root location."}
         assert_error(id_, expected, given=response.body)
 
     def test_api_create_repo_exists(self, backend):
         repo_name = backend.repo_name
         id_, params = build_data(
             self.apikey, 'create_repo',
             repo_name=repo_name,
             owner=TEST_USER_ADMIN_LOGIN,
             repo_type=backend.alias,)
         response = api_call(self.app, params)
         expected = {
             'unique_repo_name': 'Repository with name `{}` already exists'.format(
                 repo_name)}
         assert_error(id_, expected, given=response.body)
 
     @mock.patch.object(RepoModel, 'create', crash)
     def test_api_create_repo_exception_occurred(self, backend):
         repo_name = 'api-repo-6'
         id_, params = build_data(
             self.apikey, 'create_repo',
             repo_name=repo_name,
             owner=TEST_USER_ADMIN_LOGIN,
             repo_type=backend.alias,)
         response = api_call(self.app, params)
         expected = 'failed to create repository `%s`' % (repo_name,)
         assert_error(id_, expected, given=response.body)
 
     @pytest.mark.parametrize('parent_group, dirty_name, expected_name', [
         (None, 'foo bar x', 'foo-bar-x'),
         ('foo', '/foo//bar x', 'foo/bar-x'),
         ('foo-bar', 'foo-bar //bar x', 'foo-bar/bar-x'),
     ])
     def test_create_repo_with_extra_slashes_in_name(
             self, backend, parent_group, dirty_name, expected_name):
 
         if parent_group:
             gr = fixture.create_repo_group(parent_group)
             assert gr.group_name == parent_group
 
         id_, params = build_data(
             self.apikey, 'create_repo',
             repo_name=dirty_name,
             repo_type=backend.alias,
             owner=TEST_USER_ADMIN_LOGIN,)
         response = api_call(self.app, params)
         expected ={
            "msg": "Created new repository `{}`".format(expected_name),
            "task": None,
            "success": True
         }
         assert_ok(id_, expected, response.body)
 
         repo = RepoModel().get_by_repo_name(expected_name)
         assert repo is not None
 
         expected = {
             'msg': 'Created new repository `%s`' % (expected_name,),
             'success': True,
             'task': None,
         }
         assert_ok(id_, expected, given=response.body)
         fixture.destroy_repo(expected_name)
         if parent_group:
             fixture.destroy_repo_group(parent_group)

rhodecode/api/tests/test_create_repo_group.py

@@ -1,289 +1,289 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017  RhodeCode GmbH
+# Copyright (C) 2010-2018 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 mock
 import pytest
 
 from rhodecode.model.meta import Session
 from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.model.user import UserModel
 from rhodecode.tests import TEST_USER_ADMIN_LOGIN
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_ok, assert_error, crash)
 from rhodecode.tests.fixture import Fixture
 
 
 fixture = Fixture()
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestCreateRepoGroup(object):
     def test_api_create_repo_group(self):
         repo_group_name = 'api-repo-group'
 
         repo_group = RepoGroupModel.cls.get_by_group_name(repo_group_name)
         assert repo_group is None
 
         id_, params = build_data(
             self.apikey, 'create_repo_group',
             group_name=repo_group_name,
             owner=TEST_USER_ADMIN_LOGIN,)
         response = api_call(self.app, params)
 
         repo_group = RepoGroupModel.cls.get_by_group_name(repo_group_name)
         assert repo_group is not None
         ret = {
             'msg': 'Created new repo group `%s`' % (repo_group_name,),
             'repo_group': repo_group.get_api_data()
         }
         expected = ret
         try:
             assert_ok(id_, expected, given=response.body)
         finally:
             fixture.destroy_repo_group(repo_group_name)
 
     def test_api_create_repo_group_in_another_group(self):
         repo_group_name = 'api-repo-group'
 
         repo_group = RepoGroupModel.cls.get_by_group_name(repo_group_name)
         assert repo_group is None
         # create the parent
         fixture.create_repo_group(repo_group_name)
 
         full_repo_group_name = repo_group_name+'/'+repo_group_name
         id_, params = build_data(
             self.apikey, 'create_repo_group',
             group_name=full_repo_group_name,
             owner=TEST_USER_ADMIN_LOGIN,
             copy_permissions=True)
         response = api_call(self.app, params)
 
         repo_group = RepoGroupModel.cls.get_by_group_name(full_repo_group_name)
         assert repo_group is not None
         ret = {
             'msg': 'Created new repo group `%s`' % (full_repo_group_name,),
             'repo_group': repo_group.get_api_data()
         }
         expected = ret
         try:
             assert_ok(id_, expected, given=response.body)
         finally:
             fixture.destroy_repo_group(full_repo_group_name)
             fixture.destroy_repo_group(repo_group_name)
 
     def test_api_create_repo_group_in_another_group_not_existing(self):
         repo_group_name = 'api-repo-group-no'
 
         repo_group = RepoGroupModel.cls.get_by_group_name(repo_group_name)
         assert repo_group is None
 
         full_repo_group_name = repo_group_name+'/'+repo_group_name
         id_, params = build_data(
             self.apikey, 'create_repo_group',
             group_name=full_repo_group_name,
             owner=TEST_USER_ADMIN_LOGIN,
             copy_permissions=True)
         response = api_call(self.app, params)
         expected = {
             'repo_group':
                 'Parent repository group `{}` does not exist'.format(
                     repo_group_name)}
         assert_error(id_, expected, given=response.body)
 
     def test_api_create_repo_group_that_exists(self):
         repo_group_name = 'api-repo-group'
 
         repo_group = RepoGroupModel.cls.get_by_group_name(repo_group_name)
         assert repo_group is None
 
         fixture.create_repo_group(repo_group_name)
         id_, params = build_data(
             self.apikey, 'create_repo_group',
             group_name=repo_group_name,
             owner=TEST_USER_ADMIN_LOGIN,)
         response = api_call(self.app, params)
         expected = {
             'unique_repo_group_name':
                 'Repository group with name `{}` already exists'.format(
                     repo_group_name)}
         try:
             assert_error(id_, expected, given=response.body)
         finally:
             fixture.destroy_repo_group(repo_group_name)
 
     def test_api_create_repo_group_regular_user_wit_root_location_perms(
             self, user_util):
         regular_user = user_util.create_user()
         regular_user_api_key = regular_user.api_key
 
         repo_group_name = 'api-repo-group-by-regular-user'
 
         usr = UserModel().get_by_username(regular_user.username)
         usr.inherit_default_permissions = False
         Session().add(usr)
 
         UserModel().grant_perm(
             regular_user.username, 'hg.repogroup.create.true')
         Session().commit()
 
         repo_group = RepoGroupModel.cls.get_by_group_name(repo_group_name)
         assert repo_group is None
 
         id_, params = build_data(
             regular_user_api_key, 'create_repo_group',
             group_name=repo_group_name)
         response = api_call(self.app, params)
 
         repo_group = RepoGroupModel.cls.get_by_group_name(repo_group_name)
         assert repo_group is not None
         expected = {
             'msg': 'Created new repo group `%s`' % (repo_group_name,),
             'repo_group': repo_group.get_api_data()
         }
         try:
             assert_ok(id_, expected, given=response.body)
         finally:
             fixture.destroy_repo_group(repo_group_name)
 
     def test_api_create_repo_group_regular_user_with_admin_perms_to_parent(
             self, user_util):
 
         repo_group_name = 'api-repo-group-parent'
 
         repo_group = RepoGroupModel.cls.get_by_group_name(repo_group_name)
         assert repo_group is None
         # create the parent
         fixture.create_repo_group(repo_group_name)
 
         # user perms
         regular_user = user_util.create_user()
         regular_user_api_key = regular_user.api_key
 
         usr = UserModel().get_by_username(regular_user.username)
         usr.inherit_default_permissions = False
         Session().add(usr)
 
         RepoGroupModel().grant_user_permission(
             repo_group_name, regular_user.username, 'group.admin')
         Session().commit()
 
         full_repo_group_name = repo_group_name + '/' + repo_group_name
         id_, params = build_data(
             regular_user_api_key, 'create_repo_group',
             group_name=full_repo_group_name)
         response = api_call(self.app, params)
 
         repo_group = RepoGroupModel.cls.get_by_group_name(full_repo_group_name)
         assert repo_group is not None
         expected = {
             'msg': 'Created new repo group `{}`'.format(full_repo_group_name),
             'repo_group': repo_group.get_api_data()
         }
         try:
             assert_ok(id_, expected, given=response.body)
         finally:
             fixture.destroy_repo_group(full_repo_group_name)
             fixture.destroy_repo_group(repo_group_name)
 
     def test_api_create_repo_group_regular_user_no_permission_to_create_to_root_level(self):
         repo_group_name = 'api-repo-group'
 
         id_, params = build_data(
             self.apikey_regular, 'create_repo_group',
             group_name=repo_group_name)
         response = api_call(self.app, params)
 
         expected = {
             'repo_group':
                 u'You do not have the permission to store '
                 u'repository groups in the root location.'}
         assert_error(id_, expected, given=response.body)
 
     def test_api_create_repo_group_regular_user_no_parent_group_perms(self):
         repo_group_name = 'api-repo-group-regular-user'
 
         repo_group = RepoGroupModel.cls.get_by_group_name(repo_group_name)
         assert repo_group is None
         # create the parent
         fixture.create_repo_group(repo_group_name)
 
         full_repo_group_name = repo_group_name+'/'+repo_group_name
 
         id_, params = build_data(
             self.apikey_regular, 'create_repo_group',
             group_name=full_repo_group_name)
         response = api_call(self.app, params)
 
         expected = {
             'repo_group':
                 'Parent repository group `{}` does not exist'.format(
                     repo_group_name)}
         try:
             assert_error(id_, expected, given=response.body)
         finally:
             fixture.destroy_repo_group(repo_group_name)
 
     def test_api_create_repo_group_regular_user_no_permission_to_specify_owner(
             self):
         repo_group_name = 'api-repo-group'
 
         id_, params = build_data(
             self.apikey_regular, 'create_repo_group',
             group_name=repo_group_name,
             owner=TEST_USER_ADMIN_LOGIN,)
         response = api_call(self.app, params)
 
         expected = "Only RhodeCode super-admin can specify `owner` param"
         assert_error(id_, expected, given=response.body)
 
     @mock.patch.object(RepoGroupModel, 'create', crash)
     def test_api_create_repo_group_exception_occurred(self):
         repo_group_name = 'api-repo-group'
 
         repo_group = RepoGroupModel.cls.get_by_group_name(repo_group_name)
         assert repo_group is None
 
         id_, params = build_data(
             self.apikey, 'create_repo_group',
             group_name=repo_group_name,
             owner=TEST_USER_ADMIN_LOGIN,)
         response = api_call(self.app, params)
         expected = 'failed to create repo group `%s`' % (repo_group_name,)
         assert_error(id_, expected, given=response.body)
 
     def test_create_group_with_extra_slashes_in_name(self, user_util):
         existing_repo_group = user_util.create_repo_group()
         dirty_group_name = '//{}//group2//'.format(
             existing_repo_group.group_name)
         cleaned_group_name = '{}/group2'.format(
             existing_repo_group.group_name)
 
         id_, params = build_data(
             self.apikey, 'create_repo_group',
             group_name=dirty_group_name,
             owner=TEST_USER_ADMIN_LOGIN,)
         response = api_call(self.app, params)
         repo_group = RepoGroupModel.cls.get_by_group_name(cleaned_group_name)
         expected = {
             'msg': 'Created new repo group `%s`' % (cleaned_group_name,),
             'repo_group': repo_group.get_api_data()
         }
         assert_ok(id_, expected, given=response.body)
         fixture.destroy_repo_group(cleaned_group_name)

rhodecode/api/tests/test_create_user.py

@@ -1,206 +1,206 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 mock
 import pytest
 
 from rhodecode.lib.auth import check_password
 from rhodecode.model.user import UserModel
 from rhodecode.tests import (
     TEST_USER_ADMIN_LOGIN, TEST_USER_REGULAR_EMAIL)
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_ok, assert_error, jsonify, crash)
 from rhodecode.tests.fixture import Fixture
 from rhodecode.model.db import RepoGroup
 
 
 # TODO: mikhail: remove fixture from here
 fixture = Fixture()
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestCreateUser(object):
     def test_api_create_existing_user(self):
         id_, params = build_data(
             self.apikey, 'create_user',
             username=TEST_USER_ADMIN_LOGIN,
             email='[e-mail]',
             password='trololo')
         response = api_call(self.app, params)
 
         expected = "user `%s` already exist" % (TEST_USER_ADMIN_LOGIN,)
         assert_error(id_, expected, given=response.body)
 
     def test_api_create_user_with_existing_email(self):
         id_, params = build_data(
             self.apikey, 'create_user',
             username=TEST_USER_ADMIN_LOGIN + 'new',
             email=TEST_USER_REGULAR_EMAIL,
             password='trololo')
         response = api_call(self.app, params)
 
         expected = "email `%s` already exist" % (TEST_USER_REGULAR_EMAIL,)
         assert_error(id_, expected, given=response.body)
 
     def test_api_create_user_with_wrong_username(self):
         bad_username = '<> HELLO WORLD <>'
         id_, params = build_data(
             self.apikey, 'create_user',
             username=bad_username,
             email='[e-mail]',
             password='trololo')
         response = api_call(self.app, params)
 
         expected = {'username':
                         "Username may only contain alphanumeric characters "
                         "underscores, periods or dashes and must begin with "
                         "alphanumeric character or underscore"}
         assert_error(id_, expected, given=response.body)
 
     def test_api_create_user(self):
         username = 'test_new_api_user'
         email = username + "@foo.com"
 
         id_, params = build_data(
             self.apikey, 'create_user',
             username=username,
             email=email,
             password='example')
         response = api_call(self.app, params)
 
         usr = UserModel().get_by_username(username)
         ret = {
             'msg': 'created new user `%s`' % (username,),
             'user': jsonify(usr.get_api_data(include_secrets=True)),
         }
         try:
             expected = ret
             assert check_password('example', usr.password)
             assert_ok(id_, expected, given=response.body)
         finally:
             fixture.destroy_user(usr.user_id)
 
     def test_api_create_user_without_password(self):
         username = 'test_new_api_user_passwordless'
         email = username + "@foo.com"
 
         id_, params = build_data(
             self.apikey, 'create_user',
             username=username,
             email=email)
         response = api_call(self.app, params)
 
         usr = UserModel().get_by_username(username)
         ret = {
             'msg': 'created new user `%s`' % (username,),
             'user': jsonify(usr.get_api_data(include_secrets=True)),
         }
         try:
             expected = ret
             assert_ok(id_, expected, given=response.body)
         finally:
             fixture.destroy_user(usr.user_id)
 
     def test_api_create_user_with_extern_name(self):
         username = 'test_new_api_user_passwordless'
         email = username + "@foo.com"
 
         id_, params = build_data(
             self.apikey, 'create_user',
             username=username,
             email=email, extern_name='rhodecode')
         response = api_call(self.app, params)
 
         usr = UserModel().get_by_username(username)
         ret = {
             'msg': 'created new user `%s`' % (username,),
             'user': jsonify(usr.get_api_data(include_secrets=True)),
         }
         try:
             expected = ret
             assert_ok(id_, expected, given=response.body)
         finally:
             fixture.destroy_user(usr.user_id)
 
     def test_api_create_user_with_password_change(self):
         username = 'test_new_api_user_password_change'
         email = username + "@foo.com"
 
         id_, params = build_data(
             self.apikey, 'create_user',
             username=username,
             email=email, extern_name='rhodecode',
             force_password_change=True)
         response = api_call(self.app, params)
 
         usr = UserModel().get_by_username(username)
         ret = {
             'msg': 'created new user `%s`' % (username,),
             'user': jsonify(usr.get_api_data(include_secrets=True)),
         }
         try:
             expected = ret
             assert_ok(id_, expected, given=response.body)
         finally:
             fixture.destroy_user(usr.user_id)
 
     def test_api_create_user_with_personal_repo_group(self):
         username = 'test_new_api_user_personal_group'
         email = username + "@foo.com"
 
         id_, params = build_data(
             self.apikey, 'create_user',
             username=username,
             email=email, extern_name='rhodecode',
             create_personal_repo_group=True)
         response = api_call(self.app, params)
 
         usr = UserModel().get_by_username(username)
         ret = {
             'msg': 'created new user `%s`' % (username,),
             'user': jsonify(usr.get_api_data(include_secrets=True)),
         }
 
         personal_group = RepoGroup.get_by_group_name(username)
         assert personal_group
         assert personal_group.personal == True
         assert personal_group.user.username == username
 
         try:
             expected = ret
             assert_ok(id_, expected, given=response.body)
         finally:
             fixture.destroy_repo_group(username)
             fixture.destroy_user(usr.user_id)
 
     @mock.patch.object(UserModel, 'create_or_update', crash)
     def test_api_create_user_when_exception_happened(self):
 
         username = 'test_new_api_user'
         email = username + "@foo.com"
 
         id_, params = build_data(
             self.apikey, 'create_user',
             username=username,
             email=email,
             password='trololo')
         response = api_call(self.app, params)
         expected = 'failed to create user `%s`' % (username,)
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_create_user_group.py

@@ -1,127 +1,127 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 mock
 import pytest
 
 from rhodecode.model.meta import Session
 from rhodecode.model.user import UserModel
 from rhodecode.model.user_group import UserGroupModel
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_ok, crash, jsonify)
 from rhodecode.tests.fixture import Fixture
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestCreateUserGroup(object):
     fixture = Fixture()
 
     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.app, params)
 
         ret = {
             'msg': 'created new user group `%s`' % (group_name,),
             'user_group': jsonify(
                 UserGroupModel()
                 .get_by_name(group_name)
                 .get_api_data()
             )
         }
         expected = ret
         assert_ok(id_, expected, given=response.body)
         self.fixture.destroy_user_group(group_name)
 
     def test_api_create_user_group_regular_user(self):
         group_name = 'some_new_group'
 
         usr = UserModel().get_by_username(self.TEST_USER_LOGIN)
         usr.inherit_default_permissions = False
         Session().add(usr)
         UserModel().grant_perm(
             self.TEST_USER_LOGIN, 'hg.usergroup.create.true')
         Session().commit()
 
         id_, params = build_data(
             self.apikey_regular, 'create_user_group', group_name=group_name)
         response = api_call(self.app, params)
 
         expected = {
             'msg': 'created new user group `%s`' % (group_name,),
             'user_group': jsonify(
                 UserGroupModel()
                 .get_by_name(group_name)
                 .get_api_data()
             )
         }
         try:
             assert_ok(id_, expected, given=response.body)
         finally:
             self.fixture.destroy_user_group(group_name)
             UserModel().revoke_perm(
                 self.TEST_USER_LOGIN, 'hg.usergroup.create.true')
             usr = UserModel().get_by_username(self.TEST_USER_LOGIN)
             usr.inherit_default_permissions = True
             Session().add(usr)
             Session().commit()
 
     def test_api_create_user_group_regular_user_no_permission(self):
         group_name = 'some_new_group'
         id_, params = build_data(
             self.apikey_regular, 'create_user_group', group_name=group_name)
         response = api_call(self.app, params)
         expected = "Access was denied to this resource."
         assert_error(id_, expected, given=response.body)
 
     def test_api_create_user_group_that_exist(self, user_util):
         group = user_util.create_user_group()
         group_name = group.users_group_name
 
         id_, params = build_data(
             self.apikey, 'create_user_group', group_name=group_name)
         response = api_call(self.app, params)
 
         expected = "user group `%s` already exist" % (group_name,)
         assert_error(id_, expected, given=response.body)
 
     @mock.patch.object(UserGroupModel, 'create', crash)
     def test_api_create_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.app, params)
 
         expected = 'failed to create group `%s`' % (group_name,)
         assert_error(id_, expected, given=response.body)
 
     def test_api_create_user_group_with_wrong_name(self, user_util):
 
         group_name = 'wrong NAME <>'
         id_, params = build_data(
             self.apikey, 'create_user_group', group_name=group_name)
         response = api_call(self.app, params)
 
         expected = {"user_group_name":
                         "Allowed in name are letters, numbers, and `-`, `_`, "
                         "`.` Name must start with a letter or number. "
                         "Got `{}`".format(group_name)}
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_delete_gist.py

@@ -1,61 +1,61 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 mock
 import pytest
 
 from rhodecode.model.gist import GistModel
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_ok, crash)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestApiDeleteGist(object):
     def test_api_delete_gist(self, gist_util):
         gist_id = gist_util.create_gist().gist_access_id
         id_, params = build_data(self.apikey, 'delete_gist', gistid=gist_id)
         response = api_call(self.app, params)
         expected = {'gist': None, 'msg': 'deleted gist ID:%s' % (gist_id,)}
         assert_ok(id_, expected, given=response.body)
 
     def test_api_delete_gist_regular_user(self, gist_util):
         gist_id = gist_util.create_gist(
             owner=self.TEST_USER_LOGIN).gist_access_id
         id_, params = build_data(
             self.apikey_regular, 'delete_gist', gistid=gist_id)
         response = api_call(self.app, params)
         expected = {'gist': None, 'msg': 'deleted gist ID:%s' % (gist_id,)}
         assert_ok(id_, expected, given=response.body)
 
     def test_api_delete_gist_regular_user_no_permission(self, gist_util):
         gist_id = gist_util.create_gist().gist_access_id
         id_, params = build_data(
             self.apikey_regular, 'delete_gist', gistid=gist_id)
         response = api_call(self.app, params)
         expected = 'gist `%s` does not exist' % (gist_id,)
         assert_error(id_, expected, given=response.body)
 
     @mock.patch.object(GistModel, 'delete', crash)
     def test_api_delete_gist_exception_occurred(self, gist_util):
         gist_id = gist_util.create_gist().gist_access_id
         id_, params = build_data(self.apikey, 'delete_gist', gistid=gist_id)
         response = api_call(self.app, params)
         expected = 'failed to delete gist ID:%s' % (gist_id,)
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_delete_repo.py

@@ -1,74 +1,74 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 mock
 import pytest
 
 from rhodecode.model.repo import RepoModel
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_ok, crash)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestApiDeleteRepo(object):
     def test_api_delete_repo(self, backend):
         repo = backend.create_repo()
         repo_name = repo.repo_name
         id_, params = build_data(
             self.apikey, 'delete_repo', repoid=repo.repo_name, )
         response = api_call(self.app, params)
 
         expected = {
             'msg': 'Deleted repository `%s`' % (repo_name,),
             'success': True
         }
         assert_ok(id_, expected, given=response.body)
 
     def test_api_delete_repo_by_non_admin(self, backend, user_regular):
         repo = backend.create_repo(cur_user=user_regular.username)
         repo_name = repo.repo_name
         id_, params = build_data(
             user_regular.api_key, 'delete_repo', repoid=repo.repo_name, )
         response = api_call(self.app, params)
 
         expected = {
             'msg': 'Deleted repository `%s`' % (repo_name,),
             'success': True
         }
         assert_ok(id_, expected, given=response.body)
 
     def test_api_delete_repo_by_non_admin_no_permission(self, backend):
         repo = backend.create_repo()
         repo_name = repo.repo_name
         id_, params = build_data(
             self.apikey_regular, 'delete_repo', repoid=repo.repo_name, )
         response = api_call(self.app, params)
         expected = 'repository `%s` does not exist' % (repo_name)
         assert_error(id_, expected, given=response.body)
 
     def test_api_delete_repo_exception_occurred(self, backend):
         repo = backend.create_repo()
         repo_name = repo.repo_name
         id_, params = build_data(
             self.apikey, 'delete_repo', repoid=repo.repo_name, )
         with mock.patch.object(RepoModel, 'delete', crash):
             response = api_call(self.app, params)
         expected = 'failed to delete repository `%s`' % (repo_name,)
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_delete_repo_group.py

@@ -1,86 +1,86 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 pytest
 
 from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.model.user import UserModel
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_ok)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestApiDeleteRepoGroup(object):
     def test_api_delete_repo_group(self, user_util):
         repo_group = user_util.create_repo_group(auto_cleanup=False)
         repo_group_name = repo_group.group_name
         repo_group_id = repo_group.group_id
         id_, params = build_data(
             self.apikey, 'delete_repo_group', repogroupid=repo_group_name, )
         response = api_call(self.app, params)
 
         ret = {
             'msg': 'deleted repo group ID:%s %s' % (
                 repo_group_id, repo_group_name
             ),
             'repo_group': None
         }
         expected = ret
         assert_ok(id_, expected, given=response.body)
         gr = RepoGroupModel()._get_repo_group(repo_group_name)
         assert gr is None
 
     def test_api_delete_repo_group_regular_user(self, user_util):
         repo_group = user_util.create_repo_group(auto_cleanup=False)
         repo_group_name = repo_group.group_name
         repo_group_id = repo_group.group_id
 
         user = UserModel().get_by_username(self.TEST_USER_LOGIN)
         user_util.grant_user_permission_to_repo_group(
             repo_group, user, 'group.admin')
 
         id_, params = build_data(
             self.apikey, 'delete_repo_group', repogroupid=repo_group_name, )
         response = api_call(self.app, params)
 
         ret = {
             'msg': 'deleted repo group ID:%s %s' % (
                 repo_group_id, repo_group_name
             ),
             'repo_group': None
         }
         expected = ret
         assert_ok(id_, expected, given=response.body)
         gr = RepoGroupModel()._get_repo_group(repo_group_name)
         assert gr is None
 
     def test_api_delete_repo_group_regular_user_no_permission(self, user_util):
         repo_group = user_util.create_repo_group()
         repo_group_name = repo_group.group_name
 
         id_, params = build_data(
             self.apikey_regular, 'delete_repo_group',
             repogroupid=repo_group_name, )
         response = api_call(self.app, params)
 
         expected = 'repository group `%s` does not exist' % (
             repo_group_name,)
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_delete_user.py

@@ -1,57 +1,57 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 mock
 import pytest
 
 from rhodecode.model.user import UserModel
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_ok, assert_error, crash)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestDeleteUser(object):
     def test_api_delete_user(self, user_util):
         usr = user_util.create_user(auto_cleanup=False)
 
         username = usr.username
         usr_id = usr.user_id
 
         id_, params = build_data(self.apikey, 'delete_user', userid=username)
         response = api_call(self.app, params)
 
         ret = {'msg': 'deleted user ID:%s %s' % (usr_id, username),
                'user': None}
         expected = ret
         assert_ok(id_, expected, given=response.body)
 
     @mock.patch.object(UserModel, 'delete', crash)
     def test_api_delete_user_when_exception_happened(self, user_util):
         usr = user_util.create_user()
         username = usr.username
 
         id_, params = build_data(
             self.apikey, 'delete_user', userid=username, )
         response = api_call(self.app, params)
         ret = 'failed to delete user ID:%s %s' % (usr.user_id,
                                                   usr.username)
         expected = ret
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_delete_user_group.py

@@ -1,106 +1,106 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 mock
 import pytest
 
 from rhodecode.model.user import UserModel
 from rhodecode.model.user_group import UserGroupModel
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_ok, crash)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestDeleteUserGroup(object):
     def test_api_delete_user_group(self, user_util):
         user_group = user_util.create_user_group(auto_cleanup=False)
         group_name = user_group.users_group_name
         group_id = user_group.users_group_id
         id_, params = build_data(
             self.apikey, 'delete_user_group', usergroupid=group_name)
         response = api_call(self.app, params)
 
         expected = {
             'user_group': None,
             'msg': 'deleted user group ID:%s %s' % (group_id, group_name)
         }
         assert_ok(id_, expected, given=response.body)
 
     def test_api_delete_user_group_regular_user(self, user_util):
         ugroup = user_util.create_user_group(auto_cleanup=False)
         group_name = ugroup.users_group_name
         group_id = ugroup.users_group_id
         user = UserModel().get_by_username(self.TEST_USER_LOGIN)
 
         user_util.grant_user_permission_to_user_group(
             ugroup, user, 'usergroup.admin')
 
         id_, params = build_data(
             self.apikey_regular, 'delete_user_group', usergroupid=group_name)
         response = api_call(self.app, params)
 
         expected = {
             'user_group': None,
             'msg': 'deleted user group ID:%s %s' % (group_id, group_name)
         }
         assert_ok(id_, expected, given=response.body)
 
     def test_api_delete_user_group_regular_user_no_permission(self, user_util):
         user_group = user_util.create_user_group()
         group_name = user_group.users_group_name
 
         id_, params = build_data(
             self.apikey_regular, 'delete_user_group', usergroupid=group_name)
         response = api_call(self.app, params)
 
         expected = 'user group `%s` does not exist' % (group_name)
         assert_error(id_, expected, given=response.body)
 
     def test_api_delete_user_group_that_is_assigned(self, backend, user_util):
         ugroup = user_util.create_user_group()
         group_name = ugroup.users_group_name
         repo = backend.create_repo()
 
         ugr_to_perm = user_util.grant_user_group_permission_to_repo(
             repo, ugroup, 'repository.write')
         msg = 'UserGroup assigned to %s' % (ugr_to_perm.repository)
 
         id_, params = build_data(
             self.apikey, 'delete_user_group',
             usergroupid=group_name)
         response = api_call(self.app, params)
 
         expected = msg
         assert_error(id_, expected, given=response.body)
 
     def test_api_delete_user_group_exception_occurred(self, user_util):
         ugroup = user_util.create_user_group()
         group_name = ugroup.users_group_name
         group_id = ugroup.users_group_id
         id_, params = build_data(
             self.apikey, 'delete_user_group',
             usergroupid=group_name)
 
         with mock.patch.object(UserGroupModel, 'delete', crash):
             response = api_call(self.app, params)
             expected = 'failed to delete user group ID:%s %s' % (
                 group_id, group_name)
             assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_deprecated_api.py

@@ -1,79 +1,79 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 pytest
 
 from rhodecode.api.views import deprecated_api
 from rhodecode.lib.ext_json import json
 from rhodecode.api.tests.utils import (
     build_data, api_call)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestCommitComment(object):
     def test_deprecated_message_in_docstring(self):
         docstring = deprecated_api.changeset_comment.__doc__
         assert '.. deprecated:: 3.4.0' in docstring
         assert 'Please use method `comment_commit` instead.' in docstring
 
     def test_deprecated_message_in_retvalue(self):
 
         id_, params = build_data(
             self.apikey, 'show_ip')
         response = api_call(self.app, params)
 
         expected = {
             'id': id_,
             'error': None,
             'result': json.loads(response.body)['result'],
             'DEPRECATION_WARNING':
                 'DEPRECATED METHOD Please use method `get_ip` instead.'
         }
         assert expected == json.loads(response.body)
 
     # def test_calls_comment_commit(self, backend, no_notifications):
     #     data = {
     #         'repoid': backend.repo_name,
     #         'status': ChangesetStatus.STATUS_APPROVED,
     #         'message': 'Approved',
     #         'revision': 'tip'
     #     }
     #     with patch.object(repo_api, 'changeset_commit') as comment_mock:
     #         id_, params = build_data(self.apikey, 'comment_commit', **data)
     #         api_call(self.app, params)
     #
     #     _, call_args = comment_mock.call_args
     #     data['commit_id'] = data.pop('revision')
     #     for key in data:
     #         assert call_args[key] == data[key]
 
     # def test_warning_log_contains_deprecation_message(self):
     #     api = self.SampleApi()
     #     with patch.object(utils, 'log') as log_mock:
     #         api.api_method()
     #
     #     assert log_mock.warning.call_count == 1
     #     call_args = log_mock.warning.call_args[0]
     #     assert (
     #         call_args[0] ==
     #         'DEPRECATED API CALL on function %s, please use `%s` instead')
     #     assert call_args[1].__name__ == 'api_method'
     #     assert call_args[2] == 'new_method'
  No newline at end of file

rhodecode/api/tests/test_fork_repo.py

@@ -1,279 +1,279 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 mock
 import pytest
 
 from rhodecode.model.meta import Session
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.model.user import UserModel
 from rhodecode.tests import TEST_USER_ADMIN_LOGIN
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_ok, crash)
 from rhodecode.tests.fixture import Fixture
 
 
 fixture = Fixture()
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestApiForkRepo(object):
     def test_api_fork_repo(self, backend):
         source_name = backend['minimal'].repo_name
         fork_name = backend.new_repo_name()
 
         id_, params = build_data(
             self.apikey, 'fork_repo',
             repoid=source_name,
             fork_name=fork_name,
             owner=TEST_USER_ADMIN_LOGIN)
         response = api_call(self.app, params)
 
         expected = {
             'msg': 'Created fork of `%s` as `%s`' % (source_name, fork_name),
             'success': True,
             'task': None,
         }
         try:
             assert_ok(id_, expected, given=response.body)
         finally:
             fixture.destroy_repo(fork_name)
 
     def test_api_fork_repo_into_group(self, backend, user_util):
         source_name = backend['minimal'].repo_name
         repo_group = user_util.create_repo_group()
         fork_name = '%s/api-repo-fork' % repo_group.group_name
         id_, params = build_data(
             self.apikey, 'fork_repo',
             repoid=source_name,
             fork_name=fork_name,
             owner=TEST_USER_ADMIN_LOGIN)
         response = api_call(self.app, params)
 
         ret = {
             'msg': 'Created fork of `%s` as `%s`' % (source_name, fork_name),
             'success': True,
             'task': None,
         }
         expected = ret
         try:
             assert_ok(id_, expected, given=response.body)
         finally:
             fixture.destroy_repo(fork_name)
 
     def test_api_fork_repo_non_admin(self, backend):
         source_name = backend['minimal'].repo_name
         fork_name = backend.new_repo_name()
 
         id_, params = build_data(
             self.apikey_regular, 'fork_repo',
             repoid=source_name,
             fork_name=fork_name)
         response = api_call(self.app, params)
 
         expected = {
             'msg': 'Created fork of `%s` as `%s`' % (source_name, fork_name),
             'success': True,
             'task': None,
         }
         try:
             assert_ok(id_, expected, given=response.body)
         finally:
             fixture.destroy_repo(fork_name)
 
     def test_api_fork_repo_non_admin_into_group_no_permission(self, backend, user_util):
         source_name = backend['minimal'].repo_name
         repo_group = user_util.create_repo_group()
         repo_group_name = repo_group.group_name
         fork_name = '%s/api-repo-fork' % repo_group_name
 
         id_, params = build_data(
             self.apikey_regular, 'fork_repo',
             repoid=source_name,
             fork_name=fork_name)
         response = api_call(self.app, params)
 
         expected = {
             'repo_group': 'Repository group `{}` does not exist'.format(
                 repo_group_name)}
         try:
             assert_error(id_, expected, given=response.body)
         finally:
             fixture.destroy_repo(fork_name)
 
     def test_api_fork_repo_non_admin_into_group(self, backend, user_util):
         source_name = backend['minimal'].repo_name
         repo_group = user_util.create_repo_group()
         fork_name = '%s/api-repo-fork' % repo_group.group_name
 
         RepoGroupModel().grant_user_permission(
             repo_group, self.TEST_USER_LOGIN, 'group.admin')
         Session().commit()
 
         id_, params = build_data(
             self.apikey_regular, 'fork_repo',
             repoid=source_name,
             fork_name=fork_name)
         response = api_call(self.app, params)
 
         expected = {
             'msg': 'Created fork of `%s` as `%s`' % (source_name, fork_name),
             'success': True,
             'task': None,
         }
         try:
             assert_ok(id_, expected, given=response.body)
         finally:
             fixture.destroy_repo(fork_name)
 
     def test_api_fork_repo_non_admin_specify_owner(self, backend):
         source_name = backend['minimal'].repo_name
         fork_name = backend.new_repo_name()
         id_, params = build_data(
             self.apikey_regular, 'fork_repo',
             repoid=source_name,
             fork_name=fork_name,
             owner=TEST_USER_ADMIN_LOGIN)
         response = api_call(self.app, params)
         expected = 'Only RhodeCode super-admin can specify `owner` param'
         assert_error(id_, expected, given=response.body)
 
     def test_api_fork_repo_non_admin_no_permission_of_source_repo(
             self, backend):
         source_name = backend['minimal'].repo_name
         RepoModel().grant_user_permission(repo=source_name,
                                           user=self.TEST_USER_LOGIN,
                                           perm='repository.none')
         fork_name = backend.new_repo_name()
         id_, params = build_data(
             self.apikey_regular, 'fork_repo',
             repoid=backend.repo_name,
             fork_name=fork_name)
         response = api_call(self.app, params)
         expected = 'repository `%s` does not exist' % (backend.repo_name)
         assert_error(id_, expected, given=response.body)
 
     def test_api_fork_repo_non_admin_no_permission_to_fork_to_root_level(
             self, backend, user_util):
 
         regular_user = user_util.create_user()
         regular_user_api_key = regular_user.api_key
         usr = UserModel().get_by_username(regular_user.username)
         usr.inherit_default_permissions = False
         Session().add(usr)
         UserModel().grant_perm(regular_user.username, 'hg.fork.repository')
 
         source_name = backend['minimal'].repo_name
         fork_name = backend.new_repo_name()
         id_, params = build_data(
             regular_user_api_key, 'fork_repo',
             repoid=source_name,
             fork_name=fork_name)
         response = api_call(self.app, params)
         expected = {
             "repo_name": "You do not have the permission to "
                          "store repositories in the root location."}
         assert_error(id_, expected, given=response.body)
 
     def test_api_fork_repo_non_admin_no_permission_to_fork(
             self, backend, user_util):
 
         regular_user = user_util.create_user()
         regular_user_api_key = regular_user.api_key
         usr = UserModel().get_by_username(regular_user.username)
         usr.inherit_default_permissions = False
         Session().add(usr)
 
         source_name = backend['minimal'].repo_name
         fork_name = backend.new_repo_name()
         id_, params = build_data(
             regular_user_api_key, 'fork_repo',
             repoid=source_name,
             fork_name=fork_name)
         response = api_call(self.app, params)
 
         expected = "Access was denied to this resource."
         assert_error(id_, expected, given=response.body)
 
     def test_api_fork_repo_unknown_owner(self, backend):
         source_name = backend['minimal'].repo_name
         fork_name = backend.new_repo_name()
         owner = 'i-dont-exist'
         id_, params = build_data(
             self.apikey, 'fork_repo',
             repoid=source_name,
             fork_name=fork_name,
             owner=owner)
         response = api_call(self.app, params)
         expected = 'user `%s` does not exist' % (owner,)
         assert_error(id_, expected, given=response.body)
 
     def test_api_fork_repo_fork_exists(self, backend):
         source_name = backend['minimal'].repo_name
         fork_name = backend.new_repo_name()
         fork_repo = fixture.create_fork(source_name, fork_name)
 
         id_, params = build_data(
             self.apikey, 'fork_repo',
             repoid=source_name,
             fork_name=fork_name,
             owner=TEST_USER_ADMIN_LOGIN)
         response = api_call(self.app, params)
 
         try:
             expected = {
                 'unique_repo_name': 'Repository with name `{}` already exists'.format(
                     fork_name)}
             assert_error(id_, expected, given=response.body)
         finally:
             fixture.destroy_repo(fork_repo.repo_name)
 
     def test_api_fork_repo_repo_exists(self, backend):
         source_name = backend['minimal'].repo_name
         fork_name = source_name
 
         id_, params = build_data(
             self.apikey, 'fork_repo',
             repoid=source_name,
             fork_name=fork_name,
             owner=TEST_USER_ADMIN_LOGIN)
         response = api_call(self.app, params)
 
         expected = {
             'unique_repo_name': 'Repository with name `{}` already exists'.format(
                 fork_name)}
         assert_error(id_, expected, given=response.body)
 
     @mock.patch.object(RepoModel, 'create_fork', crash)
     def test_api_fork_repo_exception_occurred(self, backend):
         source_name = backend['minimal'].repo_name
         fork_name = backend.new_repo_name()
         id_, params = build_data(
             self.apikey, 'fork_repo',
             repoid=source_name,
             fork_name=fork_name,
             owner=TEST_USER_ADMIN_LOGIN)
         response = api_call(self.app, params)
 
         expected = 'failed to fork repository `%s` as `%s`' % (source_name,
                                                                fork_name)
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_get_gist.py

@@ -1,101 +1,101 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 pytest
 
 from rhodecode.model.db import Gist
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_ok)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestApiGetGist(object):
     def test_api_get_gist(self, gist_util, http_host_only_stub):
         gist = gist_util.create_gist()
         gist_id = gist.gist_access_id
         gist_created_on = gist.created_on
         gist_modified_at = gist.modified_at
         id_, params = build_data(
             self.apikey, 'get_gist', gistid=gist_id, )
         response = api_call(self.app, params)
 
         expected = {
             'access_id': gist_id,
             'created_on': gist_created_on,
             'modified_at': gist_modified_at,
             'description': 'new-gist',
             'expires': -1.0,
             'gist_id': int(gist_id),
             'type': 'public',
             'url': 'http://%s/_admin/gists/%s' % (http_host_only_stub, gist_id,),
             'acl_level': Gist.ACL_LEVEL_PUBLIC,
             'content': None,
         }
 
         assert_ok(id_, expected, given=response.body)
 
     def test_api_get_gist_with_content(self, gist_util, http_host_only_stub):
         mapping = {
             u'filename1.txt': {'content': u'hello world'},
             u'filename1ą.txt': {'content': u'hello worldę'}
         }
         gist = gist_util.create_gist(gist_mapping=mapping)
         gist_id = gist.gist_access_id
         gist_created_on = gist.created_on
         gist_modified_at = gist.modified_at
         id_, params = build_data(
             self.apikey, 'get_gist', gistid=gist_id, content=True)
         response = api_call(self.app, params)
 
         expected = {
             'access_id': gist_id,
             'created_on': gist_created_on,
             'modified_at': gist_modified_at,
             'description': 'new-gist',
             'expires': -1.0,
             'gist_id': int(gist_id),
             'type': 'public',
             'url': 'http://%s/_admin/gists/%s' % (http_host_only_stub, gist_id,),
             'acl_level': Gist.ACL_LEVEL_PUBLIC,
             'content': {
                 u'filename1.txt': u'hello world',
                 u'filename1ą.txt': u'hello worldę'
             },
         }
 
         assert_ok(id_, expected, given=response.body)
 
     def test_api_get_gist_not_existing(self):
         id_, params = build_data(
             self.apikey_regular, 'get_gist', gistid='12345', )
         response = api_call(self.app, params)
         expected = 'gist `%s` does not exist' % ('12345',)
         assert_error(id_, expected, given=response.body)
 
     def test_api_get_gist_private_gist_without_permission(self, gist_util):
         gist = gist_util.create_gist()
         gist_id = gist.gist_access_id
         id_, params = build_data(
             self.apikey_regular, 'get_gist', gistid=gist_id, )
         response = api_call(self.app, params)
 
         expected = 'gist `%s` does not exist' % (gist_id,)
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_get_gists.py

@@ -1,74 +1,74 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 pytest
 
 from rhodecode.tests import TEST_USER_ADMIN_LOGIN
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestApiGetGist(object):
     def test_api_get_gists(self, gist_util):
         gist_util.create_gist()
         gist_util.create_gist()
 
         id_, params = build_data(self.apikey, 'get_gists')
         response = api_call(self.app, params)
         assert len(response.json['result']) == 2
 
     def test_api_get_gists_regular_user(self, gist_util):
         # by admin
         gist_util.create_gist()
         gist_util.create_gist()
 
         # by reg user
         gist_util.create_gist(owner=self.TEST_USER_LOGIN)
         gist_util.create_gist(owner=self.TEST_USER_LOGIN)
         gist_util.create_gist(owner=self.TEST_USER_LOGIN)
 
         id_, params = build_data(self.apikey_regular, 'get_gists')
         response = api_call(self.app, params)
         assert len(response.json['result']) == 3
 
     def test_api_get_gists_only_for_regular_user(self, gist_util):
         # by admin
         gist_util.create_gist()
         gist_util.create_gist()
 
         # by reg user
         gist_util.create_gist(owner=self.TEST_USER_LOGIN)
         gist_util.create_gist(owner=self.TEST_USER_LOGIN)
         gist_util.create_gist(owner=self.TEST_USER_LOGIN)
 
         id_, params = build_data(
             self.apikey, 'get_gists', userid=self.TEST_USER_LOGIN)
         response = api_call(self.app, params)
         assert len(response.json['result']) == 3
 
     def test_api_get_gists_regular_user_with_different_userid(self):
         id_, params = build_data(
             self.apikey_regular, 'get_gists',
             userid=TEST_USER_ADMIN_LOGIN)
         response = api_call(self.app, params)
         expected = 'userid is not the same as your user'
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_get_ip.py

@@ -1,36 +1,36 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 pytest
 
 from rhodecode.api.tests.utils import build_data, api_call, assert_ok
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestGetIp(object):
     def test_api_get_ip(self):
         id_, params = build_data(self.apikey, 'get_ip')
         response = api_call(self.app, params)
         expected = {
             'server_ip_addr': '0.0.0.0',
             'user_ips': []
         }
         assert_ok(id_, expected, given=response.body)

rhodecode/api/tests/test_get_locks.py

@@ -1,91 +1,91 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 pytest
 
 from rhodecode.model.db import Repository, User
 from rhodecode.tests import TEST_USER_ADMIN_LOGIN, TEST_USER_REGULAR_LOGIN
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_ok, assert_error)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestGetLocks(object):
     def test_api_get_user_locks_regular_user(self):
         id_, params = build_data(self.apikey_regular, 'get_user_locks')
         response = api_call(self.app, params)
         expected = []
         assert_ok(id_, expected, given=response.body)
 
     def test_api_get_user_locks_with_userid_regular_user(self):
         id_, params = build_data(
             self.apikey_regular, 'get_user_locks', userid=TEST_USER_ADMIN_LOGIN)
         response = api_call(self.app, params)
         expected = 'userid is not the same as your user'
         assert_error(id_, expected, given=response.body)
 
     def test_api_get_user_locks(self):
         id_, params = build_data(self.apikey, 'get_user_locks')
         response = api_call(self.app, params)
         expected = []
         assert_ok(id_, expected, given=response.body)
 
     @pytest.mark.parametrize("apikey_attr, expect_secrets", [
         ('apikey', True),
         ('apikey_regular', False),
     ])
     def test_api_get_user_locks_with_one_locked_repo(
             self, apikey_attr, expect_secrets, backend):
 
         repo = backend.create_repo(cur_user=self.TEST_USER_LOGIN)
         Repository.lock(
             repo, User.get_by_username(self.TEST_USER_LOGIN).user_id)
 
         apikey = getattr(self, apikey_attr)
 
         id_, params = build_data(apikey, 'get_user_locks')
         if apikey_attr == 'apikey':
             # super-admin should call in specific user
             id_, params = build_data(apikey, 'get_user_locks',
                                      userid=self.TEST_USER_LOGIN)
 
         response = api_call(self.app, params)
         expected = [repo.get_api_data(include_secrets=expect_secrets)]
         assert_ok(id_, expected, given=response.body)
 
     def test_api_get_user_locks_with_one_locked_repo_for_specific_user(
             self, backend):
         repo = backend.create_repo(cur_user=self.TEST_USER_LOGIN)
 
         Repository.lock(repo, User.get_by_username(
             self.TEST_USER_LOGIN).user_id)
         id_, params = build_data(
             self.apikey, 'get_user_locks', userid=self.TEST_USER_LOGIN)
         response = api_call(self.app, params)
         expected = [repo.get_api_data(include_secrets=True)]
         assert_ok(id_, expected, given=response.body)
 
     def test_api_get_user_locks_with_userid(self):
         id_, params = build_data(
             self.apikey, 'get_user_locks', userid=TEST_USER_REGULAR_LOGIN)
         response = api_call(self.app, params)
         expected = []
         assert_ok(id_, expected, given=response.body)

rhodecode/api/tests/test_get_method.py

@@ -1,59 +1,59 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 pytest
 
 from rhodecode.api.tests.utils import build_data, api_call, assert_ok
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestGetMethod(object):
     def test_get_methods_no_matches(self):
         id_, params = build_data(self.apikey, 'get_method', pattern='hello')
         response = api_call(self.app, params)
 
         expected = []
         assert_ok(id_, expected, given=response.body)
 
     def test_get_methods(self):
         id_, params = build_data(self.apikey, 'get_method', pattern='*comment*')
         response = api_call(self.app, params)
 
         expected = ['changeset_comment', 'comment_pull_request',
                     'get_pull_request_comments', 'comment_commit']
         assert_ok(id_, expected, given=response.body)
 
     def test_get_methods_on_single_match(self):
         id_, params = build_data(self.apikey, 'get_method',
                                  pattern='*comment_commit*')
         response = api_call(self.app, params)
 
         expected = ['comment_commit',
                     {'apiuser': '<RequiredType>',
                      'comment_type': "<Optional:u'note'>",
                      'commit_id': '<RequiredType>',
                      'message': '<RequiredType>',
                      'repoid': '<RequiredType>',
                      'request': '<RequiredType>',
                      'resolves_comment_id': '<Optional:None>',
                      'status': '<Optional:None>',
                      'userid': '<Optional:<OptionalAttr:apiuser>>'}]
         assert_ok(id_, expected, given=response.body)

rhodecode/api/tests/test_get_pull_request.py

@@ -1,142 +1,142 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 pytest
 import urlobject
 
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_ok)
 from rhodecode.lib import helpers as h
 from rhodecode.lib.utils2 import safe_unicode
 
 pytestmark = pytest.mark.backends("git", "hg")
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestGetPullRequest(object):
 
     def test_api_get_pull_request(self, pr_util, http_host_only_stub):
         from rhodecode.model.pull_request import PullRequestModel
         pull_request = pr_util.create_pull_request(mergeable=True)
         id_, params = build_data(
             self.apikey, 'get_pull_request',
             pullrequestid=pull_request.pull_request_id)
 
         response = api_call(self.app, params)
 
         assert response.status == '200 OK'
 
         url_obj = urlobject.URLObject(
             h.route_url(
                 'pullrequest_show',
                 repo_name=pull_request.target_repo.repo_name,
                 pull_request_id=pull_request.pull_request_id))
 
         pr_url = safe_unicode(
             url_obj.with_netloc(http_host_only_stub))
         source_url = safe_unicode(
             pull_request.source_repo.clone_url().with_netloc(http_host_only_stub))
         target_url = safe_unicode(
             pull_request.target_repo.clone_url().with_netloc(http_host_only_stub))
         shadow_url = safe_unicode(
             PullRequestModel().get_shadow_clone_url(pull_request))
 
         expected = {
             'pull_request_id': pull_request.pull_request_id,
             'url': pr_url,
             'title': pull_request.title,
             'description': pull_request.description,
             'status': pull_request.status,
             'created_on': pull_request.created_on,
             'updated_on': pull_request.updated_on,
             'commit_ids': pull_request.revisions,
             'review_status': pull_request.calculated_review_status(),
             'mergeable': {
                 'status': True,
                 'message': 'This pull request can be automatically merged.',
             },
             'source': {
                 'clone_url': source_url,
                 'repository': pull_request.source_repo.repo_name,
                 'reference': {
                     'name': pull_request.source_ref_parts.name,
                     'type': pull_request.source_ref_parts.type,
                     'commit_id': pull_request.source_ref_parts.commit_id,
                 },
             },
             'target': {
                 'clone_url': target_url,
                 'repository': pull_request.target_repo.repo_name,
                 'reference': {
                     'name': pull_request.target_ref_parts.name,
                     'type': pull_request.target_ref_parts.type,
                     'commit_id': pull_request.target_ref_parts.commit_id,
                 },
             },
             'merge': {
                 'clone_url': shadow_url,
                 'reference': {
                     'name': pull_request.shadow_merge_ref.name,
                     'type': pull_request.shadow_merge_ref.type,
                     'commit_id': pull_request.shadow_merge_ref.commit_id,
                 },
             },
             'author': pull_request.author.get_api_data(include_secrets=False,
                                                        details='basic'),
             'reviewers': [
                 {
                     'user': reviewer.get_api_data(include_secrets=False,
                                                   details='basic'),
                     'reasons': reasons,
                     'review_status': st[0][1].status if st else 'not_reviewed',
                 }
                 for obj, reviewer, reasons, mandatory, st in
                 pull_request.reviewers_statuses()
             ]
         }
         assert_ok(id_, expected, response.body)
 
     def test_api_get_pull_request_repo_error(self, pr_util):
         pull_request = pr_util.create_pull_request()
         id_, params = build_data(
             self.apikey, 'get_pull_request',
             repoid=666, pullrequestid=pull_request.pull_request_id)
         response = api_call(self.app, params)
 
         expected = 'repository `666` does not exist'
         assert_error(id_, expected, given=response.body)
 
     def test_api_get_pull_request_pull_request_error(self):
         id_, params = build_data(
             self.apikey, 'get_pull_request', pullrequestid=666)
         response = api_call(self.app, params)
 
         expected = 'pull request `666` does not exist'
         assert_error(id_, expected, given=response.body)
 
     def test_api_get_pull_request_pull_request_error_just_pr_id(self):
         id_, params = build_data(
             self.apikey, 'get_pull_request',
             pullrequestid=666)
         response = api_call(self.app, params)
 
         expected = 'pull request `666` does not exist'
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_get_pull_request_comments.py

@@ -1,82 +1,82 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 pytest
 import urlobject
 
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_ok)
 from rhodecode.lib import helpers as h
 from rhodecode.lib.utils2 import safe_unicode
 
 pytestmark = pytest.mark.backends("git", "hg")
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestGetPullRequestComments(object):
 
     def test_api_get_pull_request_comments(self, pr_util, http_host_only_stub):
         from rhodecode.model.pull_request import PullRequestModel
 
         pull_request = pr_util.create_pull_request(mergeable=True)
         id_, params = build_data(
             self.apikey, 'get_pull_request_comments',
             pullrequestid=pull_request.pull_request_id)
 
         response = api_call(self.app, params)
 
         assert response.status == '200 OK'
         resp_date = response.json['result'][0]['comment_created_on']
         resp_comment_id = response.json['result'][0]['comment_id']
 
         expected = [
             {'comment_author': {'active': True,
                                 'full_name_or_username': 'RhodeCode Admin',
                                 'username': 'test_admin'},
              'comment_created_on': resp_date,
              'comment_f_path': None,
              'comment_id': resp_comment_id,
              'comment_lineno': None,
              'comment_status': {'status': 'under_review',
                                 'status_lbl': 'Under Review'},
              'comment_text': 'Auto status change to |new_status|\n\n.. |new_status| replace:: *"Under Review"*',
              'comment_type': 'note',
              'pull_request_version': None}
         ]
         assert_ok(id_, expected, response.body)
 
     def test_api_get_pull_request_comments_repo_error(self, pr_util):
         pull_request = pr_util.create_pull_request()
         id_, params = build_data(
             self.apikey, 'get_pull_request_comments',
             repoid=666, pullrequestid=pull_request.pull_request_id)
         response = api_call(self.app, params)
 
         expected = 'repository `666` does not exist'
         assert_error(id_, expected, given=response.body)
 
     def test_api_get_pull_request_comments_pull_request_error(self):
         id_, params = build_data(
             self.apikey, 'get_pull_request_comments', pullrequestid=666)
         response = api_call(self.app, params)
 
         expected = 'pull request `666` does not exist'
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_get_pull_requests.py

@@ -1,80 +1,80 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 pytest
 
 from rhodecode.model.meta import Session
 from rhodecode.model.pull_request import PullRequestModel
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestGetPullRequest(object):
     @pytest.mark.backends("git", "hg")
     def test_api_get_pull_requests(self, pr_util):
         pull_request = pr_util.create_pull_request()
         pull_request_2 = PullRequestModel().create(
             created_by=pull_request.author,
             source_repo=pull_request.source_repo,
             source_ref=pull_request.source_ref,
             target_repo=pull_request.target_repo,
             target_ref=pull_request.target_ref,
             revisions=pull_request.revisions,
             reviewers=(),
             title=pull_request.title,
             description=pull_request.description,
         )
         Session().commit()
         id_, params = build_data(
             self.apikey, 'get_pull_requests',
             repoid=pull_request.target_repo.repo_name)
         response = api_call(self.app, params)
         assert response.status == '200 OK'
         assert len(response.json['result']) == 2
 
         PullRequestModel().close_pull_request(
             pull_request_2, pull_request_2.author)
         Session().commit()
 
         id_, params = build_data(
             self.apikey, 'get_pull_requests',
             repoid=pull_request.target_repo.repo_name,
             status='new')
         response = api_call(self.app, params)
         assert response.status == '200 OK'
         assert len(response.json['result']) == 1
 
         id_, params = build_data(
             self.apikey, 'get_pull_requests',
             repoid=pull_request.target_repo.repo_name,
             status='closed')
         response = api_call(self.app, params)
         assert response.status == '200 OK'
         assert len(response.json['result']) == 1
 
     @pytest.mark.backends("git", "hg")
     def test_api_get_pull_requests_repo_error(self):
         id_, params = build_data(self.apikey, 'get_pull_requests', repoid=666)
         response = api_call(self.app, params)
 
         expected = 'repository `666` does not exist'
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_get_repo.py

@@ -1,137 +1,137 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 pytest
 
 from rhodecode.model.meta import Session
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.user import UserModel
 from rhodecode.tests import TEST_USER_ADMIN_LOGIN
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_ok, assert_error, expected_permissions)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestGetRepo(object):
     @pytest.mark.parametrize("apikey_attr, expect_secrets", [
         ('apikey', True),
         ('apikey_regular', False),
     ])
     @pytest.mark.parametrize("cache_param", [
         True,
         False,
         None,
     ])
     def test_api_get_repo(
             self, apikey_attr, expect_secrets, cache_param, backend,
             user_util):
         repo = backend.create_repo()
         usr = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
         group = user_util.create_user_group(members=[usr])
         user_util.grant_user_group_permission_to_repo(
             repo=repo, user_group=group, permission_name='repository.read')
         Session().commit()
         kwargs = {
             'repoid': repo.repo_name,
         }
         if cache_param is not None:
             kwargs['cache'] = cache_param
 
         apikey = getattr(self, apikey_attr)
         id_, params = build_data(apikey, 'get_repo', **kwargs)
         response = api_call(self.app, params)
 
         ret = repo.get_api_data()
 
         permissions = expected_permissions(repo)
 
         followers = []
         for user in repo.followers:
             followers.append(user.user.get_api_data(
                 include_secrets=expect_secrets))
 
         ret['permissions'] = permissions
         ret['followers'] = followers
 
         expected = ret
 
         assert_ok(id_, expected, given=response.body)
 
     @pytest.mark.parametrize("grant_perm", [
         'repository.admin',
         'repository.write',
         'repository.read',
     ])
     def test_api_get_repo_by_non_admin(self, grant_perm, backend):
         # TODO: Depending on which tests are running before this one, we
         # start with a different number of permissions in the database.
         repo = RepoModel().get_by_repo_name(backend.repo_name)
         permission_count = len(repo.repo_to_perm)
 
         RepoModel().grant_user_permission(repo=backend.repo_name,
                                           user=self.TEST_USER_LOGIN,
                                           perm=grant_perm)
         Session().commit()
         id_, params = build_data(
             self.apikey_regular, 'get_repo', repoid=backend.repo_name)
         response = api_call(self.app, params)
 
         repo = RepoModel().get_by_repo_name(backend.repo_name)
         ret = repo.get_api_data()
 
         assert permission_count + 1, len(repo.repo_to_perm)
 
         permissions = expected_permissions(repo)
 
         followers = []
         for user in repo.followers:
             followers.append(user.user.get_api_data())
 
         ret['permissions'] = permissions
         ret['followers'] = followers
 
         expected = ret
         try:
             assert_ok(id_, expected, given=response.body)
         finally:
             RepoModel().revoke_user_permission(
                 backend.repo_name, self.TEST_USER_LOGIN)
 
     def test_api_get_repo_by_non_admin_no_permission_to_repo(self, backend):
         RepoModel().grant_user_permission(repo=backend.repo_name,
                                           user=self.TEST_USER_LOGIN,
                                           perm='repository.none')
 
         id_, params = build_data(
             self.apikey_regular, 'get_repo', repoid=backend.repo_name)
         response = api_call(self.app, params)
 
         expected = 'repository `%s` does not exist' % (backend.repo_name)
         assert_error(id_, expected, given=response.body)
 
     def test_api_get_repo_not_existing(self):
         id_, params = build_data(
             self.apikey, 'get_repo', repoid='no-such-repo')
         response = api_call(self.app, params)
 
         ret = 'repository `%s` does not exist' % 'no-such-repo'
         expected = ret
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_get_repo_changeset.py

@@ -1,140 +1,140 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 pytest
 
 from rhodecode.api.tests.utils import build_data, api_call, assert_error
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestGetRepoChangeset(object):
     @pytest.mark.parametrize("details", ['basic', 'extended', 'full'])
     def test_get_repo_changeset(self, details, backend):
         commit = backend.repo.get_commit(commit_idx=0)
         __, params = build_data(
             self.apikey, 'get_repo_changeset',
             repoid=backend.repo_name, revision=commit.raw_id,
             details=details,
         )
         response = api_call(self.app, params)
         result = response.json['result']
         assert result['revision'] == 0
         assert result['raw_id'] == commit.raw_id
 
         if details == 'full':
             assert result['refs']['bookmarks'] == getattr(
                 commit, 'bookmarks', [])
             assert result['refs']['branches'] == [commit.branch]
             assert result['refs']['tags'] == commit.tags
 
     @pytest.mark.parametrize("details", ['basic', 'extended', 'full'])
     def test_get_repo_changeset_bad_type(self, details, backend):
         id_, params = build_data(
             self.apikey, 'get_repo_changeset',
             repoid=backend.repo_name, revision=0,
             details=details,
         )
         response = api_call(self.app, params)
         expected = 'commit_id must be a string value'
         assert_error(id_, expected, given=response.body)
 
     @pytest.mark.parametrize("details", ['basic', 'extended', 'full'])
     def test_get_repo_changesets(self, details, backend):
         limit = 2
         commit = backend.repo.get_commit(commit_idx=0)
         __, params = build_data(
             self.apikey, 'get_repo_changesets',
             repoid=backend.repo_name, start_rev=commit.raw_id, limit=limit,
             details=details,
         )
         response = api_call(self.app, params)
         result = response.json['result']
         assert result
         assert len(result) == limit
         for x in xrange(limit):
             assert result[x]['revision'] == x
 
         if details == 'full':
             for x in xrange(limit):
                 assert 'bookmarks' in result[x]['refs']
                 assert 'branches' in result[x]['refs']
                 assert 'tags' in result[x]['refs']
 
     @pytest.mark.parametrize("details", ['basic', 'extended', 'full'])
     @pytest.mark.parametrize("start_rev, expected_revision", [
         ("0", 0),
         ("10", 10),
         ("20", 20),
         ])
     @pytest.mark.backends("hg", "git")
     def test_get_repo_changesets_commit_range(
             self, details, backend, start_rev, expected_revision):
         limit = 10
         __, params = build_data(
             self.apikey, 'get_repo_changesets',
             repoid=backend.repo_name, start_rev=start_rev, limit=limit,
             details=details,
         )
         response = api_call(self.app, params)
         result = response.json['result']
         assert result
         assert len(result) == limit
         for i in xrange(limit):
             assert result[i]['revision'] == int(expected_revision) + i
 
     @pytest.mark.parametrize("details", ['basic', 'extended', 'full'])
     @pytest.mark.parametrize("start_rev, expected_revision", [
         ("0", 0),
         ("10", 9),
         ("20", 19),
         ])
     def test_get_repo_changesets_commit_range_svn(
             self, details, backend_svn, start_rev, expected_revision):
 
         # TODO: johbo: SVN showed a problem here: The parameter "start_rev"
         # in our API allows to pass in a "Commit ID" as well as a
         # "Commit Index". In the case of Subversion it is not possible to
         # distinguish these cases. As a workaround we implemented this
         # behavior which gives a preference to see it as a "Commit ID".
 
         limit = 10
         __, params = build_data(
             self.apikey, 'get_repo_changesets',
             repoid=backend_svn.repo_name, start_rev=start_rev, limit=limit,
             details=details,
         )
         response = api_call(self.app, params)
         result = response.json['result']
         assert result
         assert len(result) == limit
         for i in xrange(limit):
             assert result[i]['revision'] == int(expected_revision) + i
 
     @pytest.mark.parametrize("details", ['basic', 'extended', 'full'])
     def test_get_repo_changesets_bad_type(self, details, backend):
         id_, params = build_data(
             self.apikey, 'get_repo_changesets',
             repoid=backend.repo_name, start_rev=0, limit=2,
             details=details,
         )
         response = api_call(self.app, params)
         expected = 'commit_id must be a string value'
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_get_repo_group.py

@@ -1,55 +1,55 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 pytest
 
 from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_ok, assert_error, expected_permissions)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestApiGetRepoGroup(object):
     def test_api_get_repo_group(self, user_util):
         repo_group = user_util.create_repo_group()
         repo_group_name = repo_group.group_name
 
         id_, params = build_data(
             self.apikey, 'get_repo_group', repogroupid=repo_group_name)
         response = api_call(self.app, params)
 
         repo_group = RepoGroupModel()._get_repo_group(repo_group_name)
         ret = repo_group.get_api_data()
 
         permissions = expected_permissions(repo_group)
 
         ret['permissions'] = permissions
         expected = ret
         assert_ok(id_, expected, given=response.body)
 
     def test_api_get_repo_group_not_existing(self):
         id_, params = build_data(
             self.apikey, 'get_repo_group', repogroupid='no-such-repo-group')
         response = api_call(self.app, params)
 
         ret = 'repository group `%s` does not exist' % 'no-such-repo-group'
         expected = ret
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_get_repo_groups.py

@@ -1,40 +1,40 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 pytest
 
 from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.api.tests.utils import build_data, api_call, assert_ok, jsonify
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestApiGetRepoGroups(object):
     def test_api_get_repo_groups(self):
         id_, params = build_data(self.apikey, 'get_repo_groups')
         response = api_call(self.app, params)
 
         result = []
         for repo in RepoGroupModel().get_all():
             result.append(repo.get_api_data())
         ret = jsonify(result)
 
         expected = ret
         assert_ok(id_, expected, given=response.body)

rhodecode/api/tests/test_get_repo_nodes.py

@@ -1,142 +1,142 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 pytest
 
 from rhodecode.model.meta import Session
 from rhodecode.model.repo import RepoModel
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_ok)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestGetRepoNodes(object):
     @pytest.mark.parametrize("name, ret_type", [
         ('all', 'all'),
         ('dirs', 'dirs'),
         ('files', 'files'),
     ])
     def test_api_get_repo_nodes(self, name, ret_type, backend):
         commit_id = 'tip'
         path = '/'
         id_, params = build_data(
             self.apikey, 'get_repo_nodes',
             repoid=backend.repo_name, revision=commit_id,
             root_path=path,
             ret_type=ret_type)
         response = api_call(self.app, params)
 
         # we don't the actual return types here since it's tested somewhere
         # else
         expected = response.json['result']
         assert_ok(id_, expected, given=response.body)
 
     def test_api_get_repo_nodes_bad_commits(self, backend):
         commit_id = 'i-dont-exist'
         path = '/'
         id_, params = build_data(
             self.apikey, 'get_repo_nodes',
             repoid=backend.repo_name, revision=commit_id,
             root_path=path, )
         response = api_call(self.app, params)
 
         expected = 'failed to get repo: `%s` nodes' % (backend.repo_name,)
         assert_error(id_, expected, given=response.body)
 
     def test_api_get_repo_nodes_bad_path(self, backend):
         commit_id = 'tip'
         path = '/idontexits'
         id_, params = build_data(
             self.apikey, 'get_repo_nodes',
             repoid=backend.repo_name, revision=commit_id,
             root_path=path, )
         response = api_call(self.app, params)
 
         expected = 'failed to get repo: `%s` nodes' % (backend.repo_name,)
         assert_error(id_, expected, given=response.body)
 
     def test_api_get_repo_nodes_max_file_bytes(self, backend):
         commit_id = 'tip'
         path = '/'
         max_file_bytes = 500
 
         id_, params = build_data(
             self.apikey, 'get_repo_nodes',
             repoid=backend.repo_name, revision=commit_id, details='full',
             root_path=path)
         response = api_call(self.app, params)
         assert any(file['content'] and len(file['content']) > max_file_bytes
                    for file in response.json['result'])
 
         id_, params = build_data(
             self.apikey, 'get_repo_nodes',
             repoid=backend.repo_name, revision=commit_id,
             root_path=path, details='full',
             max_file_bytes=max_file_bytes)
         response = api_call(self.app, params)
         assert all(
             file['content'] is None if file['size'] > max_file_bytes else True
             for file in response.json['result'])
 
     def test_api_get_repo_nodes_bad_ret_type(self, backend):
         commit_id = 'tip'
         path = '/'
         ret_type = 'error'
         id_, params = build_data(
             self.apikey, 'get_repo_nodes',
             repoid=backend.repo_name, revision=commit_id,
             root_path=path,
             ret_type=ret_type)
         response = api_call(self.app, params)
 
         expected = ('ret_type must be one of %s'
                     % (','.join(['all', 'dirs', 'files'])))
         assert_error(id_, expected, given=response.body)
 
     @pytest.mark.parametrize("name, ret_type, grant_perm", [
         ('all', 'all', 'repository.write'),
         ('dirs', 'dirs', 'repository.admin'),
         ('files', 'files', 'repository.read'),
     ])
     def test_api_get_repo_nodes_by_regular_user(
             self, name, ret_type, grant_perm, backend):
         RepoModel().grant_user_permission(repo=backend.repo_name,
                                           user=self.TEST_USER_LOGIN,
                                           perm=grant_perm)
         Session().commit()
 
         commit_id = 'tip'
         path = '/'
         id_, params = build_data(
             self.apikey_regular, 'get_repo_nodes',
             repoid=backend.repo_name, revision=commit_id,
             root_path=path,
             ret_type=ret_type)
         response = api_call(self.app, params)
 
         # we don't the actual return types here since it's tested somewhere
         # else
         expected = response.json['result']
         try:
             assert_ok(id_, expected, given=response.body)
         finally:
             RepoModel().revoke_user_permission(
                 backend.repo_name, self.TEST_USER_LOGIN)

rhodecode/api/tests/test_get_repo_refs.py

@@ -1,40 +1,40 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 pytest
 
 from rhodecode.model.meta import Session
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.user import UserModel
 from rhodecode.tests import TEST_USER_ADMIN_LOGIN
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_ok, assert_error, expected_permissions)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestGetRepo(object):
     def test_api_get_repo_refs(self, backend, user_util):
         repo = backend.create_repo()
         id_, params = build_data(self.apikey, 'get_repo_refs',
                                  **{'repoid': repo.repo_name,})
         response = api_call(self.app, params)
         expected = repo.scm_instance().refs()
         assert_ok(id_, expected, given=response.body)

rhodecode/api/tests/test_get_repos.py

@@ -1,129 +1,129 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 pytest
 
 from rhodecode.model.repo import RepoModel
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_ok, assert_error, jsonify)
 from rhodecode.model.db import User
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestGetRepos(object):
     def test_api_get_repos(self):
         id_, params = build_data(self.apikey, 'get_repos')
         response = api_call(self.app, params)
 
         result = []
         for repo in RepoModel().get_all():
             result.append(repo.get_api_data(include_secrets=True))
         ret = jsonify(result)
 
         expected = ret
         assert_ok(id_, expected, given=response.body)
 
     def test_api_get_repos_only_toplevel(self, user_util):
         repo_group = user_util.create_repo_group(auto_cleanup=True)
         user_util.create_repo(parent=repo_group)
 
         id_, params = build_data(self.apikey, 'get_repos', traverse=0)
         response = api_call(self.app, params)
 
         result = []
         for repo in RepoModel().get_repos_for_root(root=None):
             result.append(repo.get_api_data(include_secrets=True))
         expected = jsonify(result)
 
         assert_ok(id_, expected, given=response.body)
 
     def test_api_get_repos_with_wrong_root(self):
         id_, params = build_data(self.apikey, 'get_repos', root='abracadabra')
         response = api_call(self.app, params)
 
         expected = 'Root repository group `abracadabra` does not exist'
         assert_error(id_, expected, given=response.body)
 
     def test_api_get_repos_with_root(self, user_util):
         repo_group = user_util.create_repo_group(auto_cleanup=True)
         repo_group_name = repo_group.group_name
 
         user_util.create_repo(parent=repo_group)
         user_util.create_repo(parent=repo_group)
 
         # nested, should not show up
         user_util._test_name = '{}/'.format(repo_group_name)
         sub_repo_group = user_util.create_repo_group(auto_cleanup=True)
         user_util.create_repo(parent=sub_repo_group)
 
         id_, params = build_data(self.apikey, 'get_repos',
                                  root=repo_group_name, traverse=0)
         response = api_call(self.app, params)
 
         result = []
         for repo in RepoModel().get_repos_for_root(repo_group):
             result.append(repo.get_api_data(include_secrets=True))
 
         assert len(result) == 2
         expected = jsonify(result)
         assert_ok(id_, expected, given=response.body)
 
     def test_api_get_repos_with_root_and_traverse(self, user_util):
         repo_group = user_util.create_repo_group(auto_cleanup=True)
         repo_group_name = repo_group.group_name
 
         user_util.create_repo(parent=repo_group)
         user_util.create_repo(parent=repo_group)
 
         # nested, should not show up
         user_util._test_name = '{}/'.format(repo_group_name)
         sub_repo_group = user_util.create_repo_group(auto_cleanup=True)
         user_util.create_repo(parent=sub_repo_group)
 
         id_, params = build_data(self.apikey, 'get_repos',
                                  root=repo_group_name, traverse=1)
         response = api_call(self.app, params)
 
         result = []
         for repo in RepoModel().get_repos_for_root(
                 repo_group_name, traverse=True):
             result.append(repo.get_api_data(include_secrets=True))
 
         assert len(result) == 3
         expected = jsonify(result)
         assert_ok(id_, expected, given=response.body)
 
     def test_api_get_repos_non_admin(self):
         id_, params = build_data(self.apikey_regular, 'get_repos')
         response = api_call(self.app, params)
 
         user = User.get_by_username(self.TEST_USER_LOGIN)
         allowed_repos = user.AuthUser().permissions['repositories']
 
         result = []
         for repo in RepoModel().get_all():
             perm = allowed_repos[repo.repo_name]
             if perm in ['repository.read', 'repository.write', 'repository.admin']:
                 result.append(repo.get_api_data())
         ret = jsonify(result)
 
         expected = ret
         assert_ok(id_, expected, given=response.body)

rhodecode/api/tests/test_get_server_info.py

@@ -1,84 +1,84 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 pytest
 
 from rhodecode.model.scm import ScmModel
 from rhodecode.api.tests.utils import build_data, api_call, assert_ok
 
 
 @pytest.fixture
 def http_host_stub():
     """
     To ensure that we can get an IP address, this test shall run with a
     hostname set to "localhost".
     """
     return 'localhost:80'
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestGetServerInfo(object):
     def test_api_get_server_info(self):
         id_, params = build_data(self.apikey, 'get_server_info')
         response = api_call(self.app, params)
         resp = response.json
         expected = ScmModel().get_server_info()
         expected['memory'] = resp['result']['memory']
         expected['uptime'] = resp['result']['uptime']
         expected['load'] = resp['result']['load']
         expected['cpu'] = resp['result']['cpu']
         expected['storage'] = resp['result']['storage']
         expected['storage_temp'] = resp['result']['storage_temp']
         expected['storage_inodes'] = resp['result']['storage_inodes']
         expected['server'] = resp['result']['server']
 
         expected['index_storage'] = resp['result']['index_storage']
         expected['storage'] = resp['result']['storage']
 
         assert_ok(id_, expected, given=response.body)
 
     def test_api_get_server_info_ip(self):
         id_, params = build_data(self.apikey, 'get_server_info')
         response = api_call(self.app, params)
         resp = response.json
         expected = ScmModel().get_server_info({'SERVER_NAME': 'unknown'})
         expected['memory'] = resp['result']['memory']
         expected['uptime'] = resp['result']['uptime']
         expected['load'] = resp['result']['load']
         expected['cpu'] = resp['result']['cpu']
         expected['storage'] = resp['result']['storage']
         expected['storage_temp'] = resp['result']['storage_temp']
         expected['storage_inodes'] = resp['result']['storage_inodes']
         expected['server'] = resp['result']['server']
 
         expected['index_storage'] = resp['result']['index_storage']
         expected['storage'] = resp['result']['storage']
 
         assert_ok(id_, expected, given=response.body)
 
     def test_api_get_server_info_data_for_search_index_build(self):
         id_, params = build_data(self.apikey, 'get_server_info')
         response = api_call(self.app, params)
         resp = response.json
 
         # required by indexer
         assert resp['result']['index_storage']
         assert resp['result']['storage']

rhodecode/api/tests/test_get_user.py

@@ -1,86 +1,86 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 pytest
 
 from rhodecode.lib.auth import AuthUser
 from rhodecode.model.user import UserModel
 from rhodecode.tests import TEST_USER_ADMIN_LOGIN
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_ok, assert_error)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestGetUser(object):
     def test_api_get_user(self):
         id_, params = build_data(
             self.apikey, 'get_user', userid=TEST_USER_ADMIN_LOGIN)
         response = api_call(self.app, params)
 
         usr = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
         ret = usr.get_api_data(include_secrets=True)
         permissions = AuthUser(usr.user_id).permissions
         ret['permissions'] = permissions
         ret['permissions_summary'] = permissions
 
         expected = ret
         assert_ok(id_, expected, given=response.body)
 
     def test_api_get_user_not_existing(self):
         id_, params = build_data(self.apikey, 'get_user', userid='trololo')
         response = api_call(self.app, params)
 
         expected = "user `%s` does not exist" % 'trololo'
         assert_error(id_, expected, given=response.body)
 
     def test_api_get_user_without_giving_userid(self):
         id_, params = build_data(self.apikey, 'get_user')
         response = api_call(self.app, params)
 
         usr = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
         ret = usr.get_api_data(include_secrets=True)
         permissions = AuthUser(usr.user_id).permissions
         ret['permissions'] = permissions
         ret['permissions_summary'] = permissions
 
         expected = ret
         assert_ok(id_, expected, given=response.body)
 
     def test_api_get_user_without_giving_userid_non_admin(self):
         id_, params = build_data(self.apikey_regular, 'get_user')
         response = api_call(self.app, params)
 
         usr = UserModel().get_by_username(self.TEST_USER_LOGIN)
         ret = usr.get_api_data(include_secrets=True)
         permissions = AuthUser(usr.user_id).permissions
         ret['permissions'] = permissions
         ret['permissions_summary'] = permissions
 
         expected = ret
         assert_ok(id_, expected, given=response.body)
 
     def test_api_get_user_with_giving_userid_non_admin(self):
         id_, params = build_data(
             self.apikey_regular, 'get_user',
             userid=self.TEST_USER_LOGIN)
         response = api_call(self.app, params)
 
         expected = 'userid is not the same as your user'
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_get_user_group.py

@@ -1,76 +1,76 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 pytest
 
 from rhodecode.model.user import UserModel
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_ok, assert_error, expected_permissions)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestGetUserGroups(object):
     def test_api_get_user_group(self, user_util):
         user, group = user_util.create_user_with_group()
         id_, params = build_data(
             self.apikey, 'get_user_group', usergroupid=group.users_group_name)
         response = api_call(self.app, params)
 
         ret = group.get_api_data()
         ret['users'] = [user.get_api_data()]
 
         permissions = expected_permissions(group)
 
         ret['permissions'] = permissions
         ret['permissions_summary'] = response.json['result']['permissions_summary']
         expected = ret
         assert_ok(id_, expected, given=response.body)
 
     def test_api_get_user_group_regular_user(self, user_util):
         user, group = user_util.create_user_with_group()
         id_, params = build_data(
             self.apikey_regular, 'get_user_group',
             usergroupid=group.users_group_name)
         response = api_call(self.app, params)
 
         ret = group.get_api_data()
         ret['users'] = [user.get_api_data()]
 
         permissions = expected_permissions(group)
 
         ret['permissions'] = permissions
         ret['permissions_summary'] = response.json['result']['permissions_summary']
         expected = ret
         assert_ok(id_, expected, given=response.body)
 
     def test_api_get_user_group_regular_user_permission_denied(
             self, user_util):
         group = user_util.create_user_group()
         user = UserModel().get_by_username(self.TEST_USER_LOGIN)
         group_name = group.users_group_name
         user_util.grant_user_permission_to_user_group(
             group, user, 'usergroup.none')
 
         id_, params = build_data(
             self.apikey_regular, 'get_user_group', usergroupid=group_name)
         response = api_call(self.app, params)
 
         expected = 'user group `%s` does not exist' % (group_name,)
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_get_user_groups.py

@@ -1,71 +1,71 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 json
 
 import pytest
 
 from rhodecode.model.user import UserModel
 from rhodecode.api.tests.utils import build_data, api_call
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestGetUserGroups(object):
     @pytest.mark.parametrize("apikey_attr, expect_secrets", [
         ('apikey', True),
         ('apikey_regular', False),
     ])
     def test_api_get_user_groups(self, apikey_attr, expect_secrets, user_util):
         first_group = user_util.create_user_group()
         second_group = user_util.create_user_group()
         expected = [
             g.get_api_data(include_secrets=expect_secrets)
             for g in (first_group, second_group)]
 
         apikey = getattr(self, apikey_attr)
         id_, params = build_data(apikey, 'get_user_groups', )
         response = api_call(self.app, params)
         self._assert_ok(id_, expected, response)
 
     def test_api_get_user_groups_regular_user(self, user_util):
         first_group = user_util.create_user_group()
         second_group = user_util.create_user_group()
         expected = [g.get_api_data() for g in (first_group, second_group)]
 
         id_, params = build_data(self.apikey_regular, 'get_user_groups', )
         response = api_call(self.app, params)
         self._assert_ok(id_, expected, response)
 
     def test_api_get_user_groups_regular_user_no_permission(self, user_util):
         group = user_util.create_user_group()
         user = UserModel().get_by_username(self.TEST_USER_LOGIN)
         user_util.grant_user_permission_to_user_group(
             group, user, 'usergroup.none')
         id_, params = build_data(self.apikey_regular, 'get_user_groups', )
         response = api_call(self.app, params)
         expected = []
         self._assert_ok(id_, expected, response)
 
     def _assert_ok(self, id_, expected_list, response):
         result = json.loads(response.body)
         assert result['id'] == id_
         assert result['error'] is None
         assert sorted(result['result']) == sorted(expected_list)

rhodecode/api/tests/test_get_users.py

@@ -1,40 +1,40 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 pytest
 
 from rhodecode.model.db import User
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_ok, jsonify)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestGetUsers(object):
     def test_api_get_users(self):
         id_, params = build_data(self.apikey, 'get_users', )
         response = api_call(self.app, params)
         ret_all = []
         _users = User.query().filter(User.username != User.DEFAULT_USER) \
             .order_by(User.username).all()
         for usr in _users:
             ret = usr.get_api_data(include_secrets=True)
             ret_all.append(jsonify(ret))
         expected = ret_all
         assert_ok(id_, expected, given=response.body)

rhodecode/api/tests/test_grant_user_group_permission.py

@@ -1,90 +1,90 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 mock
 import pytest
 
 from rhodecode.model.repo import RepoModel
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_ok, crash)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestGrantUserGroupPermission(object):
     @pytest.mark.parametrize("name, perm", [
         ('none', 'repository.none'),
         ('read', 'repository.read'),
         ('write', 'repository.write'),
         ('admin', 'repository.admin')
     ])
     def test_api_grant_user_group_permission(
             self, name, perm, backend, user_util):
         user_group = user_util.create_user_group()
         id_, params = build_data(
             self.apikey,
             'grant_user_group_permission',
             repoid=backend.repo_name,
             usergroupid=user_group.users_group_name,
             perm=perm)
         response = api_call(self.app, params)
 
         ret = {
             'msg': 'Granted perm: `%s` for user group: `%s` in repo: `%s`' % (
                 perm, user_group.users_group_name, backend.repo_name
             ),
             'success': True
         }
         expected = ret
         assert_ok(id_, expected, given=response.body)
 
     def test_api_grant_user_group_permission_wrong_permission(
             self, backend, user_util):
         perm = 'haha.no.permission'
         user_group = user_util.create_user_group()
         id_, params = build_data(
             self.apikey,
             'grant_user_group_permission',
             repoid=backend.repo_name,
             usergroupid=user_group.users_group_name,
             perm=perm)
         response = api_call(self.app, params)
 
         expected = 'permission `%s` does not exist' % (perm,)
         assert_error(id_, expected, given=response.body)
 
     @mock.patch.object(RepoModel, 'grant_user_group_permission', crash)
     def test_api_grant_user_group_permission_exception_when_adding(
             self, backend, user_util):
         perm = 'repository.read'
         user_group = user_util.create_user_group()
         id_, params = build_data(
             self.apikey,
             'grant_user_group_permission',
             repoid=backend.repo_name,
             usergroupid=user_group.users_group_name,
             perm=perm)
         response = api_call(self.app, params)
 
         expected = (
             'failed to edit permission for user group: `%s` in repo: `%s`' % (
                 user_group.users_group_name, backend.repo_name
             )
         )
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_grant_user_group_permission_to_repo_group.py

@@ -1,172 +1,172 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 mock
 import pytest
 
 from rhodecode.model.user import UserModel
 from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_ok, crash)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestGrantUserGroupPermissionFromRepoGroup(object):
     @pytest.mark.parametrize("name, perm, apply_to_children", [
         ('none', 'group.none', 'none'),
         ('read', 'group.read', 'none'),
         ('write', 'group.write', 'none'),
         ('admin', 'group.admin', 'none'),
 
         ('none', 'group.none', 'all'),
         ('read', 'group.read', 'all'),
         ('write', 'group.write', 'all'),
         ('admin', 'group.admin', 'all'),
 
         ('none', 'group.none', 'repos'),
         ('read', 'group.read', 'repos'),
         ('write', 'group.write', 'repos'),
         ('admin', 'group.admin', 'repos'),
 
         ('none', 'group.none', 'groups'),
         ('read', 'group.read', 'groups'),
         ('write', 'group.write', 'groups'),
         ('admin', 'group.admin', 'groups'),
     ])
     def test_api_grant_user_group_permission_to_repo_group(
             self, name, perm, apply_to_children, user_util):
         user_group = user_util.create_user_group()
         repo_group = user_util.create_repo_group()
         id_, params = build_data(
             self.apikey,
             'grant_user_group_permission_to_repo_group',
             repogroupid=repo_group.name,
             usergroupid=user_group.users_group_name,
             perm=perm,
             apply_to_children=apply_to_children,)
         response = api_call(self.app, params)
 
         ret = {
             'msg': (
                 'Granted perm: `%s` (recursive:%s) for user group: `%s`'
                 ' in repo group: `%s`' % (
                     perm, apply_to_children, user_group.users_group_name,
                     repo_group.name
                 )
             ),
             'success': True
         }
         expected = ret
         try:
             assert_ok(id_, expected, given=response.body)
         finally:
             RepoGroupModel().revoke_user_group_permission(
                 repo_group.group_id, user_group.users_group_id)
 
     @pytest.mark.parametrize(
         "name, perm, apply_to_children, grant_admin, access_ok", [
             ('none_fails', 'group.none', 'none', False, False),
             ('read_fails', 'group.read', 'none', False, False),
             ('write_fails', 'group.write', 'none', False, False),
             ('admin_fails', 'group.admin', 'none', False, False),
 
             # with granted perms
             ('none_ok', 'group.none', 'none', True, True),
             ('read_ok', 'group.read', 'none', True, True),
             ('write_ok', 'group.write', 'none', True, True),
             ('admin_ok', 'group.admin', 'none', True, True),
         ]
     )
     def test_api_grant_user_group_permission_to_repo_group_by_regular_user(
             self, name, perm, apply_to_children, grant_admin, access_ok,
             user_util):
         user = UserModel().get_by_username(self.TEST_USER_LOGIN)
         user_group = user_util.create_user_group()
         repo_group = user_util.create_repo_group()
         if grant_admin:
             user_util.grant_user_permission_to_repo_group(
                 repo_group, user, 'group.admin')
 
         id_, params = build_data(
             self.apikey_regular,
             'grant_user_group_permission_to_repo_group',
             repogroupid=repo_group.name,
             usergroupid=user_group.users_group_name,
             perm=perm,
             apply_to_children=apply_to_children,)
         response = api_call(self.app, params)
         if access_ok:
             ret = {
                 'msg': (
                     'Granted perm: `%s` (recursive:%s) for user group: `%s`'
                     ' in repo group: `%s`' % (
                         perm, apply_to_children, user_group.users_group_name,
                         repo_group.name
                     )
                 ),
                 'success': True
             }
             expected = ret
             try:
                 assert_ok(id_, expected, given=response.body)
             finally:
                 RepoGroupModel().revoke_user_group_permission(
                     repo_group.group_id, user_group.users_group_id)
         else:
             expected = 'repository group `%s` does not exist' % (
                 repo_group.name,)
             assert_error(id_, expected, given=response.body)
 
     def test_api_grant_user_group_permission_to_repo_group_wrong_permission(
             self, user_util):
         user_group = user_util.create_user_group()
         repo_group = user_util.create_repo_group()
         perm = 'haha.no.permission'
         id_, params = build_data(
             self.apikey,
             'grant_user_group_permission_to_repo_group',
             repogroupid=repo_group.name,
             usergroupid=user_group.users_group_name,
             perm=perm)
         response = api_call(self.app, params)
 
         expected = 'permission `%s` does not exist' % (perm,)
         assert_error(id_, expected, given=response.body)
 
     @mock.patch.object(RepoGroupModel, 'grant_user_group_permission', crash)
     def test_api_grant_user_group_permission_exception_when_adding_2(
             self, user_util):
         user_group = user_util.create_user_group()
         repo_group = user_util.create_repo_group()
         perm = 'group.read'
         id_, params = build_data(
             self.apikey,
             'grant_user_group_permission_to_repo_group',
             repogroupid=repo_group.name,
             usergroupid=user_group.users_group_name,
             perm=perm)
         response = api_call(self.app, params)
 
         expected = (
             'failed to edit permission for user group: `%s`'
             ' in repo group: `%s`' % (
                 user_group.users_group_name, repo_group.name)
         )
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_grant_user_group_permission_to_user_group.py

@@ -1,97 +1,97 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 pytest
 
 from rhodecode.model.user_group import UserGroupModel
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_ok, assert_error)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestGrantUserGroupPermissionFromUserGroup(object):
     @pytest.mark.parametrize("name, perm", [
         ('none', 'usergroup.none'),
         ('read', 'usergroup.read'),
         ('write', 'usergroup.write'),
         ('admin', 'usergroup.admin'),
 
         ('none', 'usergroup.none'),
         ('read', 'usergroup.read'),
         ('write', 'usergroup.write'),
         ('admin', 'usergroup.admin'),
 
         ('none', 'usergroup.none'),
         ('read', 'usergroup.read'),
         ('write', 'usergroup.write'),
         ('admin', 'usergroup.admin'),
 
         ('none', 'usergroup.none'),
         ('read', 'usergroup.read'),
         ('write', 'usergroup.write'),
         ('admin', 'usergroup.admin'),
     ])
     def test_api_grant_user_group_permission_to_user_group(
             self, name, perm, user_util):
         group = user_util.create_user_group()
         target_group = user_util.create_user_group()
 
         id_, params = build_data(
             self.apikey,
             'grant_user_group_permission_to_user_group',
             usergroupid=target_group.users_group_name,
             sourceusergroupid=group.users_group_name,
             perm=perm)
         response = api_call(self.app, params)
 
         expected = {
             'msg': (
                 'Granted perm: `%s` for user group: `%s`'
                 ' in user group: `%s`' % (
                     perm, group.users_group_name,
                     target_group.users_group_name
                 )
             ),
             'success': True
         }
         try:
             assert_ok(id_, expected, given=response.body)
         finally:
             UserGroupModel().revoke_user_group_permission(
                 target_group.users_group_id, group.users_group_id)
 
     def test_api_grant_user_group_permission_to_user_group_same_failure(
             self, user_util):
         group = user_util.create_user_group()
 
         id_, params = build_data(
             self.apikey,
             'grant_user_group_permission_to_user_group',
             usergroupid=group.users_group_name,
             sourceusergroupid=group.users_group_name,
             perm='usergroup.none')
         response = api_call(self.app, params)
 
         expected = (
             'failed to edit permission for user group: `%s`'
             ' in user group: `%s`' % (
                 group.users_group_name, group.users_group_name)
         )
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_grant_user_permission.py

@@ -1,87 +1,87 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 mock
 import pytest
 
 from rhodecode.model.repo import RepoModel
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_ok, crash)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestGrantUserPermission(object):
     @pytest.mark.parametrize("name, perm", [
         ('none', 'repository.none'),
         ('read', 'repository.read'),
         ('write', 'repository.write'),
         ('admin', 'repository.admin')
     ])
     def test_api_grant_user_permission(self, name, perm, backend, user_util):
         user = user_util.create_user()
         id_, params = build_data(
             self.apikey,
             'grant_user_permission',
             repoid=backend.repo_name,
             userid=user.username,
             perm=perm)
         response = api_call(self.app, params)
 
         ret = {
             'msg': 'Granted perm: `%s` for user: `%s` in repo: `%s`' % (
                 perm, user.username, backend.repo_name
             ),
             'success': True
         }
         expected = ret
         assert_ok(id_, expected, given=response.body)
 
     def test_api_grant_user_permission_wrong_permission(
             self, backend, user_util):
         user = user_util.create_user()
         perm = 'haha.no.permission'
         id_, params = build_data(
             self.apikey,
             'grant_user_permission',
             repoid=backend.repo_name,
             userid=user.username,
             perm=perm)
         response = api_call(self.app, params)
 
         expected = 'permission `%s` does not exist' % (perm,)
         assert_error(id_, expected, given=response.body)
 
     @mock.patch.object(RepoModel, 'grant_user_permission', crash)
     def test_api_grant_user_permission_exception_when_adding(
             self, backend, user_util):
         user = user_util.create_user()
         perm = 'repository.read'
         id_, params = build_data(
             self.apikey,
             'grant_user_permission',
             repoid=backend.repo_name,
             userid=user.username,
             perm=perm)
         response = api_call(self.app, params)
 
         expected = 'failed to edit permission for user: `%s` in repo: `%s`' % (
             user.username, backend.repo_name
         )
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_grant_user_permission_to_repo_group.py

@@ -1,157 +1,157 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 mock
 import pytest
 
 from rhodecode.model.user import UserModel
 from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_ok, crash)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestGrantUserPermissionFromRepoGroup(object):
     @pytest.mark.parametrize("name, perm, apply_to_children", [
         ('none', 'group.none', 'none'),
         ('read', 'group.read', 'none'),
         ('write', 'group.write', 'none'),
         ('admin', 'group.admin', 'none'),
 
         ('none', 'group.none', 'all'),
         ('read', 'group.read', 'all'),
         ('write', 'group.write', 'all'),
         ('admin', 'group.admin', 'all'),
 
         ('none', 'group.none', 'repos'),
         ('read', 'group.read', 'repos'),
         ('write', 'group.write', 'repos'),
         ('admin', 'group.admin', 'repos'),
 
         ('none', 'group.none', 'groups'),
         ('read', 'group.read', 'groups'),
         ('write', 'group.write', 'groups'),
         ('admin', 'group.admin', 'groups'),
     ])
     def test_api_grant_user_permission_to_repo_group(
             self, name, perm, apply_to_children, user_util):
         user = user_util.create_user()
         repo_group = user_util.create_repo_group()
         id_, params = build_data(
             self.apikey, 'grant_user_permission_to_repo_group',
             repogroupid=repo_group.name, userid=user.username,
             perm=perm, apply_to_children=apply_to_children)
         response = api_call(self.app, params)
 
         ret = {
             'msg': (
                 'Granted perm: `%s` (recursive:%s) for user: `%s`'
                 ' in repo group: `%s`' % (
                     perm, apply_to_children, user.username, repo_group.name
                 )
             ),
             'success': True
         }
         expected = ret
         assert_ok(id_, expected, given=response.body)
 
     @pytest.mark.parametrize(
         "name, perm, apply_to_children, grant_admin, access_ok", [
             ('none_fails', 'group.none', 'none', False, False),
             ('read_fails', 'group.read', 'none', False, False),
             ('write_fails', 'group.write', 'none', False, False),
             ('admin_fails', 'group.admin', 'none', False, False),
 
             # with granted perms
             ('none_ok', 'group.none', 'none', True, True),
             ('read_ok', 'group.read', 'none', True, True),
             ('write_ok', 'group.write', 'none', True, True),
             ('admin_ok', 'group.admin', 'none', True, True),
         ]
     )
     def test_api_grant_user_permission_to_repo_group_by_regular_user(
             self, name, perm, apply_to_children, grant_admin, access_ok,
             user_util):
         user = user_util.create_user()
         repo_group = user_util.create_repo_group()
 
         if grant_admin:
             test_user = UserModel().get_by_username(self.TEST_USER_LOGIN)
             user_util.grant_user_permission_to_repo_group(
                 repo_group, test_user, 'group.admin')
 
         id_, params = build_data(
             self.apikey_regular, 'grant_user_permission_to_repo_group',
             repogroupid=repo_group.name, userid=user.username,
             perm=perm, apply_to_children=apply_to_children)
         response = api_call(self.app, params)
         if access_ok:
             ret = {
                 'msg': (
                     'Granted perm: `%s` (recursive:%s) for user: `%s`'
                     ' in repo group: `%s`' % (
                         perm, apply_to_children, user.username, repo_group.name
                     )
                 ),
                 'success': True
             }
             expected = ret
             assert_ok(id_, expected, given=response.body)
         else:
             expected = 'repository group `%s` does not exist' % (
                 repo_group.name, )
             assert_error(id_, expected, given=response.body)
 
     def test_api_grant_user_permission_to_repo_group_wrong_permission(
             self, user_util):
         user = user_util.create_user()
         repo_group = user_util.create_repo_group()
         perm = 'haha.no.permission'
         id_, params = build_data(
             self.apikey,
             'grant_user_permission_to_repo_group',
             repogroupid=repo_group.name,
             userid=user.username,
             perm=perm)
         response = api_call(self.app, params)
 
         expected = 'permission `%s` does not exist' % (perm,)
         assert_error(id_, expected, given=response.body)
 
     @mock.patch.object(RepoGroupModel, 'grant_user_permission', crash)
     def test_api_grant_user_permission_to_repo_group_exception_when_adding(
             self, user_util):
         user = user_util.create_user()
         repo_group = user_util.create_repo_group()
         perm = 'group.read'
         id_, params = build_data(
             self.apikey,
             'grant_user_permission_to_repo_group',
             repogroupid=repo_group.name,
             userid=user.username,
             perm=perm)
         response = api_call(self.app, params)
 
         expected = (
             'failed to edit permission for user: `%s` in repo group: `%s`' % (
                 user.username, repo_group.name
             )
         )
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_grant_user_permission_to_user_group.py

@@ -1,156 +1,156 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 mock
 import pytest
 
 from rhodecode.model.user import UserModel
 from rhodecode.model.user_group import UserGroupModel
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_ok, crash)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestGrantUserPermissionFromUserGroup(object):
     @pytest.mark.parametrize("name, perm", [
         ('none', 'usergroup.none'),
         ('read', 'usergroup.read'),
         ('write', 'usergroup.write'),
         ('admin', 'usergroup.admin'),
 
         ('none', 'usergroup.none'),
         ('read', 'usergroup.read'),
         ('write', 'usergroup.write'),
         ('admin', 'usergroup.admin'),
 
         ('none', 'usergroup.none'),
         ('read', 'usergroup.read'),
         ('write', 'usergroup.write'),
         ('admin', 'usergroup.admin'),
 
         ('none', 'usergroup.none'),
         ('read', 'usergroup.read'),
         ('write', 'usergroup.write'),
         ('admin', 'usergroup.admin'),
     ])
     def test_api_grant_user_permission_to_user_group(
             self, name, perm, user_util):
         user = user_util.create_user()
         group = user_util.create_user_group()
         id_, params = build_data(
             self.apikey,
             'grant_user_permission_to_user_group',
             usergroupid=group.users_group_name,
             userid=user.username,
             perm=perm)
         response = api_call(self.app, params)
 
         ret = {
             'msg': 'Granted perm: `%s` for user: `%s` in user group: `%s`' % (
                 perm, user.username, group.users_group_name
             ),
             'success': True
         }
         expected = ret
         assert_ok(id_, expected, given=response.body)
 
     @pytest.mark.parametrize("name, perm, grant_admin, access_ok", [
         ('none_fails', 'usergroup.none', False, False),
         ('read_fails', 'usergroup.read', False, False),
         ('write_fails', 'usergroup.write', False, False),
         ('admin_fails', 'usergroup.admin', False, False),
 
         # with granted perms
         ('none_ok', 'usergroup.none', True, True),
         ('read_ok', 'usergroup.read', True, True),
         ('write_ok', 'usergroup.write', True, True),
         ('admin_ok', 'usergroup.admin', True, True),
     ])
     def test_api_grant_user_permission_to_user_group_by_regular_user(
             self, name, perm, grant_admin, access_ok, user_util):
         api_user = UserModel().get_by_username(self.TEST_USER_LOGIN)
         user = user_util.create_user()
         group = user_util.create_user_group()
         # grant the user ability to at least read the group
         permission = 'usergroup.admin' if grant_admin else 'usergroup.read'
         user_util.grant_user_permission_to_user_group(
             group, api_user, permission)
 
         id_, params = build_data(
             self.apikey_regular,
             'grant_user_permission_to_user_group',
             usergroupid=group.users_group_name,
             userid=user.username,
             perm=perm)
         response = api_call(self.app, params)
 
         if access_ok:
             ret = {
                 'msg': (
                     'Granted perm: `%s` for user: `%s` in user group: `%s`' % (
                         perm, user.username, group.users_group_name
                     )
                 ),
                 'success': True
             }
             expected = ret
             assert_ok(id_, expected, given=response.body)
         else:
             expected = 'user group `%s` does not exist' % (
                 group.users_group_name)
             assert_error(id_, expected, given=response.body)
 
     def test_api_grant_user_permission_to_user_group_wrong_permission(
             self, user_util):
         user = user_util.create_user()
         group = user_util.create_user_group()
         perm = 'haha.no.permission'
         id_, params = build_data(
             self.apikey,
             'grant_user_permission_to_user_group',
             usergroupid=group.users_group_name,
             userid=user.username,
             perm=perm)
         response = api_call(self.app, params)
 
         expected = 'permission `%s` does not exist' % perm
         assert_error(id_, expected, given=response.body)
 
     def test_api_grant_user_permission_to_user_group_exception_when_adding(
             self, user_util):
         user = user_util.create_user()
         group = user_util.create_user_group()
 
         perm = 'usergroup.read'
         id_, params = build_data(
             self.apikey,
             'grant_user_permission_to_user_group',
             usergroupid=group.users_group_name,
             userid=user.username,
             perm=perm)
         with mock.patch.object(UserGroupModel, 'grant_user_permission', crash):
             response = api_call(self.app, params)
 
         expected = (
             'failed to edit permission for user: `%s` in user group: `%s`' % (
                 user.username, group.users_group_name
             )
         )
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_invalidate_cache.py

@@ -1,68 +1,68 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 mock
 import pytest
 
 from rhodecode.model.scm import ScmModel
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_ok, assert_error, crash)
 from rhodecode.model.repo import RepoModel
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestInvalidateCache(object):
 
     def _set_cache(self, repo_name):
         repo = RepoModel().get_by_repo_name(repo_name)
         repo.scm_instance(cache=True)
 
     def test_api_invalidate_cache(self, backend):
         self._set_cache(backend.repo_name)
 
         id_, params = build_data(
             self.apikey, 'invalidate_cache', repoid=backend.repo_name)
         response = api_call(self.app, params)
 
         expected = {
             'msg': "Cache for repository `%s` was invalidated" % (
                 backend.repo_name,),
             'repository': backend.repo_name,
         }
         assert_ok(id_, expected, given=response.body)
 
     @mock.patch.object(ScmModel, 'mark_for_invalidation', crash)
     def test_api_invalidate_cache_error(self, backend):
         id_, params = build_data(
             self.apikey, 'invalidate_cache', repoid=backend.repo_name)
         response = api_call(self.app, params)
 
         expected = 'Error occurred during cache invalidation action'
         assert_error(id_, expected, given=response.body)
 
     def test_api_invalidate_cache_regular_user_no_permission(self, backend):
         self._set_cache(backend.repo_name)
 
         id_, params = build_data(
             self.apikey_regular, 'invalidate_cache', repoid=backend.repo_name)
         response = api_call(self.app, params)
 
         expected = "repository `%s` does not exist" % (backend.repo_name,)
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_merge_pull_request.py

@@ -1,137 +1,137 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 pytest
 
 from rhodecode.model.db import UserLog, PullRequest
 from rhodecode.model.meta import Session
 from rhodecode.tests import TEST_USER_ADMIN_LOGIN
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_ok)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestMergePullRequest(object):
     @pytest.mark.backends("git", "hg")
     def test_api_merge_pull_request_merge_failed(self, pr_util, no_notifications):
         pull_request = pr_util.create_pull_request(mergeable=True)
         author = pull_request.user_id
         repo = pull_request.target_repo.repo_id
         pull_request_id = pull_request.pull_request_id
         pull_request_repo = pull_request.target_repo.repo_name
 
         id_, params = build_data(
             self.apikey, 'merge_pull_request',
             repoid=pull_request_repo,
             pullrequestid=pull_request_id)
 
         response = api_call(self.app, params)
 
         # The above api call detaches the pull request DB object from the
         # session because of an unconditional transaction rollback in our
         # middleware. Therefore we need to add it back here if we want to use
         # it.
         Session().add(pull_request)
 
         expected = 'merge not possible for following reasons: ' \
                    'Pull request reviewer approval is pending.'
         assert_error(id_, expected, given=response.body)
 
     @pytest.mark.backends("git", "hg")
     def test_api_merge_pull_request(self, pr_util, no_notifications):
         pull_request = pr_util.create_pull_request(mergeable=True, approved=True)
         author = pull_request.user_id
         repo = pull_request.target_repo.repo_id
         pull_request_id = pull_request.pull_request_id
         pull_request_repo = pull_request.target_repo.repo_name
 
         id_, params = build_data(
             self.apikey, 'comment_pull_request',
             repoid=pull_request_repo,
             pullrequestid=pull_request_id,
             status='approved')
 
         response = api_call(self.app, params)
         expected = {
             'comment_id': response.json.get('result', {}).get('comment_id'),
             'pull_request_id': pull_request_id,
             'status': {'given': 'approved', 'was_changed': True}
         }
         assert_ok(id_, expected, given=response.body)
 
         id_, params = build_data(
             self.apikey, 'merge_pull_request',
             repoid=pull_request_repo,
             pullrequestid=pull_request_id)
 
         response = api_call(self.app, params)
 
         pull_request = PullRequest.get(pull_request_id)
 
         expected = {
             'executed': True,
             'failure_reason': 0,
             'possible': True,
             'merge_commit_id': pull_request.shadow_merge_ref.commit_id,
             'merge_ref': pull_request.shadow_merge_ref._asdict()
         }
 
         assert_ok(id_, expected, response.body)
 
         journal = UserLog.query()\
             .filter(UserLog.user_id == author)\
             .filter(UserLog.repository_id == repo) \
             .order_by('user_log_id') \
             .all()
         assert journal[-2].action == 'repo.pull_request.merge'
         assert journal[-1].action == 'repo.pull_request.close'
 
         id_, params = build_data(
             self.apikey, 'merge_pull_request',
             repoid=pull_request_repo, pullrequestid=pull_request_id)
         response = api_call(self.app, params)
 
         expected = 'merge not possible for following reasons: This pull request is closed.'
         assert_error(id_, expected, given=response.body)
 
     @pytest.mark.backends("git", "hg")
     def test_api_merge_pull_request_repo_error(self, pr_util):
         pull_request = pr_util.create_pull_request()
         id_, params = build_data(
             self.apikey, 'merge_pull_request',
             repoid=666, pullrequestid=pull_request.pull_request_id)
         response = api_call(self.app, params)
 
         expected = 'repository `666` does not exist'
         assert_error(id_, expected, given=response.body)
 
     @pytest.mark.backends("git", "hg")
     def test_api_merge_pull_request_non_admin_with_userid_error(self,
                                                                 pr_util):
         pull_request = pr_util.create_pull_request(mergeable=True)
         id_, params = build_data(
             self.apikey_regular, 'merge_pull_request',
             repoid=pull_request.target_repo.repo_name,
             pullrequestid=pull_request.pull_request_id,
             userid=TEST_USER_ADMIN_LOGIN)
         response = api_call(self.app, params)
 
         expected = 'userid is not the same as your user'
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_pull.py

@@ -1,51 +1,51 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 os
 
 import pytest
 
 from rhodecode.tests import TESTS_TMP_PATH
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_ok, assert_error)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestPull(object):
     @pytest.mark.backends("git", "hg")
     def test_api_pull(self, backend):
         r = backend.create_repo()
         repo_name = r.repo_name
         r.clone_uri = os.path.join(TESTS_TMP_PATH, backend.repo_name)
 
         id_, params = build_data(self.apikey, 'pull', repoid=repo_name,)
         response = api_call(self.app, params)
 
         expected = {'msg': 'Pulled from `%s`' % (repo_name,),
                     'repository': repo_name}
         assert_ok(id_, expected, given=response.body)
 
     def test_api_pull_error(self, backend):
         id_, params = build_data(
             self.apikey, 'pull', repoid=backend.repo_name)
         response = api_call(self.app, params)
 
         expected = 'Unable to pull changes from `%s`' % (backend.repo_name,)
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_remove_field_from_repo.py

@@ -1,66 +1,66 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 pytest
 
 from rhodecode.model.db import Repository, RepositoryField
 from rhodecode.api.tests.utils import build_data, api_call, assert_ok
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestRemoveFieldFromRepo(object):
     def test_api_remove_field_from_repo(self, backend):
         repo = backend.create_repo()
         repo_name = repo.repo_name
 
         id_, params = build_data(
             self.apikey, 'add_field_to_repo',
             repoid=repo_name,
             key='extra_field',
             label='extra_field_label',
             description='extra_field_desc')
         response = api_call(self.app, params)
         expected = {
             'msg': 'Added new repository field `extra_field`',
             'success': True,
         }
         assert_ok(id_, expected, given=response.body)
 
         repo = Repository.get_by_repo_name(repo_name)
         repo_field = RepositoryField.get_by_key_name('extra_field', repo)
         _data = repo_field.get_dict()
         assert _data['field_desc'] == 'extra_field_desc'
         assert _data['field_key'] == 'extra_field'
         assert _data['field_label'] == 'extra_field_label'
 
         id_, params = build_data(
             self.apikey, 'remove_field_from_repo',
             repoid=repo_name,
             key='extra_field')
         response = api_call(self.app, params)
         expected = {
             'msg': 'Deleted repository field `extra_field`',
             'success': True,
         }
         assert_ok(id_, expected, given=response.body)
         repo = Repository.get_by_repo_name(repo_name)
         repo_field = RepositoryField.get_by_key_name('extra_field', repo)
 
         assert repo_field is None

rhodecode/api/tests/test_remove_user_from_user_group.py

@@ -1,58 +1,58 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 mock
 import pytest
 
 from rhodecode.model.user_group import UserGroupModel
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_ok, crash)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestRemoveUserFromUserGroup(object):
     def test_api_remove_user_from_user_group(self, user_util):
         user, group = user_util.create_user_with_group()
         user_name = user.username
         group_name = group.users_group_name
         id_, params = build_data(
             self.apikey, 'remove_user_from_user_group',
             usergroupid=group_name,
             userid=user.username)
         response = api_call(self.app, params)
 
         expected = {
             'msg': 'removed member `%s` from user group `%s`' % (
                 user_name, group_name
             ),
             'success': True}
         assert_ok(id_, expected, given=response.body)
 
     @mock.patch.object(UserGroupModel, 'remove_user_from_group', crash)
     def test_api_remove_user_from_user_group_exception_occurred(
             self, user_util):
         user, group = user_util.create_user_with_group()
         id_, params = build_data(
             self.apikey, 'remove_user_from_user_group',
             usergroupid=group.users_group_name, userid=user.username)
         response = api_call(self.app, params)
         expected = 'failed to remove member from user group `%s`' % (
             group.users_group_name)
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_repo_locking.py

@@ -1,184 +1,184 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 mock
 import pytest
 
 from rhodecode.model.db import Repository
 from rhodecode.model.user import UserModel
 from rhodecode.lib.ext_json import json
 from rhodecode.lib.utils2 import time_to_datetime
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_ok, assert_error, crash)
 from rhodecode.tests import TEST_USER_ADMIN_LOGIN
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestLock(object):
     def test_api_lock_repo_lock_aquire(self, backend):
         id_, params = build_data(
             self.apikey, 'lock',
             userid=TEST_USER_ADMIN_LOGIN,
             repoid=backend.repo_name,
             locked=True)
         response = api_call(self.app, params)
         expected = {
             'repo': backend.repo_name, 'locked': True,
             'locked_since': response.json['result']['locked_since'],
             'locked_by': TEST_USER_ADMIN_LOGIN,
             'lock_state_changed': True,
             'lock_reason': Repository.LOCK_API,
             'msg': ('User `%s` set lock state for repo `%s` to `%s`'
                     % (TEST_USER_ADMIN_LOGIN, backend.repo_name, True))
         }
         assert_ok(id_, expected, given=response.body)
 
     def test_repo_lock_aquire_by_non_admin(self, backend):
         repo = backend.create_repo(cur_user=self.TEST_USER_LOGIN)
         repo_name = repo.repo_name
         id_, params = build_data(
             self.apikey_regular, 'lock',
             repoid=repo_name,
             locked=True)
         response = api_call(self.app, params)
         expected = {
             'repo': repo_name,
             'locked': True,
             'locked_since': response.json['result']['locked_since'],
             'locked_by': self.TEST_USER_LOGIN,
             'lock_state_changed': True,
             'lock_reason': Repository.LOCK_API,
             'msg': ('User `%s` set lock state for repo `%s` to `%s`'
                     % (self.TEST_USER_LOGIN, repo_name, True))
         }
         assert_ok(id_, expected, given=response.body)
 
     def test_api_lock_repo_lock_aquire_non_admin_with_userid(self, backend):
         repo = backend.create_repo(cur_user=self.TEST_USER_LOGIN)
         repo_name = repo.repo_name
         id_, params = build_data(
             self.apikey_regular, 'lock',
             userid=TEST_USER_ADMIN_LOGIN,
             repoid=repo_name,
             locked=True)
         response = api_call(self.app, params)
         expected = 'userid is not the same as your user'
         assert_error(id_, expected, given=response.body)
 
     def test_api_lock_repo_lock_aquire_non_admin_not_his_repo(self, backend):
         id_, params = build_data(
             self.apikey_regular, 'lock',
             repoid=backend.repo_name,
             locked=True)
         response = api_call(self.app, params)
         expected = 'repository `%s` does not exist' % (backend.repo_name, )
         assert_error(id_, expected, given=response.body)
 
     def test_api_lock_repo_lock_release(self, backend):
         id_, params = build_data(
             self.apikey, 'lock',
             userid=TEST_USER_ADMIN_LOGIN,
             repoid=backend.repo_name,
             locked=False)
         response = api_call(self.app, params)
         expected = {
             'repo': backend.repo_name,
             'locked': False,
             'locked_since': None,
             'locked_by': TEST_USER_ADMIN_LOGIN,
             'lock_state_changed': True,
             'lock_reason': Repository.LOCK_API,
             'msg': ('User `%s` set lock state for repo `%s` to `%s`'
                     % (TEST_USER_ADMIN_LOGIN, backend.repo_name, False))
         }
         assert_ok(id_, expected, given=response.body)
 
     def test_api_lock_repo_lock_aquire_optional_userid(self, backend):
         id_, params = build_data(
             self.apikey, 'lock',
             repoid=backend.repo_name,
             locked=True)
         response = api_call(self.app, params)
         time_ = response.json['result']['locked_since']
         expected = {
             'repo': backend.repo_name,
             'locked': True,
             'locked_since': time_,
             'locked_by': TEST_USER_ADMIN_LOGIN,
             'lock_state_changed': True,
             'lock_reason': Repository.LOCK_API,
             'msg': ('User `%s` set lock state for repo `%s` to `%s`'
                     % (TEST_USER_ADMIN_LOGIN, backend.repo_name, True))
         }
 
         assert_ok(id_, expected, given=response.body)
 
     def test_api_lock_repo_lock_optional_locked(self, backend):
         # TODO: Provide a fixture locked_repository or similar
         repo = Repository.get_by_repo_name(backend.repo_name)
         user = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
         Repository.lock(repo, user.user_id, lock_reason=Repository.LOCK_API)
 
         id_, params = build_data(self.apikey, 'lock', repoid=backend.repo_name)
         response = api_call(self.app, params)
         time_ = response.json['result']['locked_since']
         expected = {
             'repo': backend.repo_name,
             'locked': True,
             'locked_since': time_,
             'locked_by': TEST_USER_ADMIN_LOGIN,
             'lock_state_changed': False,
             'lock_reason': Repository.LOCK_API,
             'msg': ('Repo `%s` locked by `%s` on `%s`.'
                     % (backend.repo_name, TEST_USER_ADMIN_LOGIN,
                        json.dumps(time_to_datetime(time_))))
         }
         assert_ok(id_, expected, given=response.body)
 
     def test_api_lock_repo_lock_optional_not_locked(self, backend):
         repo = backend.create_repo(cur_user=self.TEST_USER_LOGIN)
         repo_name = repo.repo_name
         assert repo.locked == [None, None, None]
         id_, params = build_data(self.apikey, 'lock', repoid=repo.repo_id)
         response = api_call(self.app, params)
         expected = {
             'repo': repo_name,
             'locked': False,
             'locked_since': None,
             'locked_by': None,
             'lock_state_changed': False,
             'lock_reason': None,
             'msg': ('Repo `%s` not locked.' % (repo_name,))
         }
         assert_ok(id_, expected, given=response.body)
 
     @mock.patch.object(Repository, 'lock', crash)
     def test_api_lock_error(self, backend):
         id_, params = build_data(
             self.apikey, 'lock',
             userid=TEST_USER_ADMIN_LOGIN,
             repoid=backend.repo_name,
             locked=True)
         response = api_call(self.app, params)
 
         expected = 'Error occurred locking repository `%s`' % (
             backend.repo_name,)
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_rescan_repos.py

@@ -1,44 +1,44 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 mock
 import pytest
 
 from rhodecode.model.scm import ScmModel
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_ok, assert_error, crash)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestRescanRepos(object):
     def test_api_rescan_repos(self):
         id_, params = build_data(self.apikey, 'rescan_repos')
         response = api_call(self.app, params)
 
         expected = {'added': [], 'removed': []}
         assert_ok(id_, expected, given=response.body)
 
     @mock.patch.object(ScmModel, 'repo_scan', crash)
     def test_api_rescann_error(self):
         id_, params = build_data(self.apikey, 'rescan_repos', )
         response = api_call(self.app, params)
 
         expected = 'Error occurred during rescan repositories action'
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_revoke_user_group_permission.py

@@ -1,67 +1,67 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 mock
 import pytest
 
 from rhodecode.model.repo import RepoModel
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_ok, crash)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestRevokeUserGroupPermission(object):
     def test_api_revoke_user_group_permission(self, backend, user_util):
         repo = backend.create_repo()
         user_group = user_util.create_user_group()
         user_util.grant_user_group_permission_to_repo(
             repo, user_group, 'repository.read')
         id_, params = build_data(
             self.apikey,
             'revoke_user_group_permission',
             repoid=backend.repo_name,
             usergroupid=user_group.users_group_name)
         response = api_call(self.app, params)
 
         expected = {
             'msg': 'Revoked perm for user group: `%s` in repo: `%s`' % (
                 user_group.users_group_name, backend.repo_name
             ),
             'success': True
         }
         assert_ok(id_, expected, given=response.body)
 
     @mock.patch.object(RepoModel, 'revoke_user_group_permission', crash)
     def test_api_revoke_user_group_permission_exception_when_adding(
             self, backend, user_util):
         user_group = user_util.create_user_group()
         id_, params = build_data(
             self.apikey,
             'revoke_user_group_permission',
             repoid=backend.repo_name,
             usergroupid=user_group.users_group_name)
         response = api_call(self.app, params)
 
         expected = (
             'failed to edit permission for user group: `%s` in repo: `%s`' % (
                 user_group.users_group_name, backend.repo_name
             )
         )
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_revoke_user_group_permission_from_repo_group.py

@@ -1,129 +1,129 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 mock
 import pytest
 
 from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.tests import TEST_USER_ADMIN_LOGIN
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_ok, crash)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestRevokeUserGroupPermissionFromRepoGroup(object):
     @pytest.mark.parametrize("name, apply_to_children", [
         ('none', 'none'),
         ('all', 'all'),
         ('repos', 'repos'),
         ('groups', 'groups'),
     ])
     def test_api_revoke_user_group_permission_from_repo_group(
             self, name, apply_to_children, user_util):
         user_group = user_util.create_user_group()
         repo_group = user_util.create_repo_group()
         user_util.grant_user_group_permission_to_repo_group(
             repo_group, user_group, 'group.read')
 
         id_, params = build_data(
             self.apikey, 'revoke_user_group_permission_from_repo_group',
             repogroupid=repo_group.name,
             usergroupid=user_group.users_group_name,
             apply_to_children=apply_to_children,)
         response = api_call(self.app, params)
 
         expected = {
             'msg': (
                 'Revoked perm (recursive:%s) for user group: `%s`'
                 ' in repo group: `%s`' % (
                     apply_to_children, user_group.users_group_name,
                     repo_group.name
                 )
             ),
             'success': True
         }
         assert_ok(id_, expected, given=response.body)
 
     @pytest.mark.parametrize(
         "name, apply_to_children, grant_admin, access_ok", [
             ('none', 'none', False, False),
             ('all', 'all', False, False),
             ('repos', 'repos', False, False),
             ('groups', 'groups', False, False),
 
             # after granting admin rights
             ('none', 'none', False, False),
             ('all', 'all', False, False),
             ('repos', 'repos', False, False),
             ('groups', 'groups', False, False),
         ]
     )
     def test_api_revoke_user_group_permission_from_repo_group_by_regular_user(
             self, name, apply_to_children, grant_admin, access_ok, user_util):
         user_group = user_util.create_user_group()
         repo_group = user_util.create_repo_group()
         user_util.grant_user_group_permission_to_repo_group(
             repo_group, user_group, 'group.read')
 
         if grant_admin:
             user_util.grant_user_permission_to_repo_group(
                 repo_group.name, self.TEST_USER_LOGIN, 'group.admin')
 
         id_, params = build_data(
             self.apikey_regular,
             'revoke_user_group_permission_from_repo_group',
             repogroupid=repo_group.name,
             usergroupid=user_group.users_group_name,
             apply_to_children=apply_to_children,)
         response = api_call(self.app, params)
         if access_ok:
             expected = {
                 'msg': (
                     'Revoked perm (recursive:%s) for user group: `%s`'
                     ' in repo group: `%s`' % (
                         apply_to_children, TEST_USER_ADMIN_LOGIN,
                         repo_group.name
                     )
                 ),
                 'success': True
             }
             assert_ok(id_, expected, given=response.body)
         else:
             expected = 'repository group `%s` does not exist' % (
                 repo_group.name,)
             assert_error(id_, expected, given=response.body)
 
     @mock.patch.object(RepoGroupModel, 'revoke_user_group_permission', crash)
     def test_api_revoke_user_group_permission_from_repo_group_exception_on_add(
             self, user_util):
         user_group = user_util.create_user_group()
         repo_group = user_util.create_repo_group()
         id_, params = build_data(
             self.apikey, 'revoke_user_group_permission_from_repo_group',
             repogroupid=repo_group.name,
             usergroupid=user_group.users_group_name)
         response = api_call(self.app, params)
 
         expected = (
             'failed to edit permission for user group: `%s`'
             ' in repo group: `%s`' % (
                 user_group.users_group_name, repo_group.name)
         )
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_revoke_user_group_permission_from_user_group.py

@@ -1,58 +1,58 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 pytest
 
 from rhodecode.model.user import UserModel
 from rhodecode.api.tests.utils import build_data, api_call, assert_ok
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestRevokeUserGroupPermissionFromUserGroup(object):
     @pytest.mark.parametrize("name", [
         ('none',),
         ('all',),
         ('repos',),
         ('groups',),
     ])
     def test_api_revoke_user_group_permission_from_user_group(
             self, name, user_util):
         user = UserModel().get_by_username(self.TEST_USER_LOGIN)
         group = user_util.create_user_group()
         source_group = user_util.create_user_group()
 
         user_util.grant_user_permission_to_user_group(
             group, user, 'usergroup.read')
         user_util.grant_user_group_permission_to_user_group(
             source_group, group, 'usergroup.read')
 
         id_, params = build_data(
             self.apikey, 'revoke_user_group_permission_from_user_group',
             usergroupid=group.users_group_name,
             sourceusergroupid=source_group.users_group_name)
         response = api_call(self.app, params)
 
         expected = {
             'msg': 'Revoked perm for user group: `%s` in user group: `%s`' % (
                 source_group.users_group_name, group.users_group_name
             ),
             'success': True
         }
         assert_ok(id_, expected, given=response.body)

rhodecode/api/tests/test_revoke_user_permission.py

@@ -1,66 +1,66 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 mock
 import pytest
 
 from rhodecode.model.repo import RepoModel
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_ok, crash)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestRevokeUserPermission(object):
     def test_api_revoke_user_permission(self, backend, user_util):
         repo = backend.create_repo()
         user = user_util.create_user()
         user_util.grant_user_permission_to_repo(
             repo, user, 'repository.read')
 
         id_, params = build_data(
             self.apikey,
             'revoke_user_permission',
             repoid=repo.repo_name,
             userid=user.username)
         response = api_call(self.app, params)
 
         expected = {
             'msg': 'Revoked perm for user: `%s` in repo: `%s`' % (
                 user.username, backend.repo_name
             ),
             'success': True
         }
         assert_ok(id_, expected, given=response.body)
 
     @mock.patch.object(RepoModel, 'revoke_user_permission', crash)
     def test_api_revoke_user_permission_exception_when_adding(
             self, backend, user_util):
         user = user_util.create_user()
         id_, params = build_data(
             self.apikey,
             'revoke_user_permission',
             repoid=backend.repo_name,
             userid=user.username)
         response = api_call(self.app, params)
 
         expected = 'failed to edit permission for user: `%s` in repo: `%s`' % (
             user.username, backend.repo_name
         )
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_revoke_user_permission_from_repo_group.py

@@ -1,126 +1,126 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 mock
 import pytest
 
 from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_ok, crash)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestRevokeUserPermissionFromRepoGroup(object):
     @pytest.mark.parametrize("name, apply_to_children", [
         ('none', 'none'),
         ('all', 'all'),
         ('repos', 'repos'),
         ('groups', 'groups'),
     ])
     def test_api_revoke_user_permission_from_repo_group(
             self, name, apply_to_children, user_util):
         user = user_util.create_user()
         repo_group = user_util.create_repo_group()
         user_util.grant_user_permission_to_repo_group(
             repo_group, user, 'group.read')
 
         id_, params = build_data(
             self.apikey,
             'revoke_user_permission_from_repo_group',
             repogroupid=repo_group.name,
             userid=user.username,
             apply_to_children=apply_to_children,)
         response = api_call(self.app, params)
 
         expected = {
             'msg': (
                 'Revoked perm (recursive:%s) for user: `%s`'
                 ' in repo group: `%s`' % (
                     apply_to_children, user.username, repo_group.name
                 )
             ),
             'success': True
         }
         assert_ok(id_, expected, given=response.body)
 
     @pytest.mark.parametrize(
         "name, apply_to_children, grant_admin, access_ok", [
             ('none', 'none', False, False),
             ('all', 'all', False, False),
             ('repos', 'repos', False, False),
             ('groups', 'groups', False, False),
 
             # after granting admin rights
             ('none', 'none', False, False),
             ('all', 'all', False, False),
             ('repos', 'repos', False, False),
             ('groups', 'groups', False, False),
         ]
     )
     def test_api_revoke_user_permission_from_repo_group_by_regular_user(
             self, name, apply_to_children, grant_admin, access_ok, user_util):
         user = user_util.create_user()
         repo_group = user_util.create_repo_group()
         permission = 'group.admin' if grant_admin else 'group.read'
         user_util.grant_user_permission_to_repo_group(
             repo_group, user, permission)
 
         id_, params = build_data(
             self.apikey_regular,
             'revoke_user_permission_from_repo_group',
             repogroupid=repo_group.name,
             userid=user.username,
             apply_to_children=apply_to_children,)
         response = api_call(self.app, params)
         if access_ok:
             expected = {
                 'msg': (
                     'Revoked perm (recursive:%s) for user: `%s`'
                     ' in repo group: `%s`' % (
                         apply_to_children, user.username, repo_group.name
                     )
                 ),
                 'success': True
             }
             assert_ok(id_, expected, given=response.body)
         else:
             expected = 'repository group `%s` does not exist' % (
                 repo_group.name)
             assert_error(id_, expected, given=response.body)
 
     @mock.patch.object(RepoGroupModel, 'revoke_user_permission', crash)
     def test_api_revoke_user_permission_from_repo_group_exception_when_adding(
             self, user_util):
         user = user_util.create_user()
         repo_group = user_util.create_repo_group()
         id_, params = build_data(
             self.apikey,
             'revoke_user_permission_from_repo_group',
             repogroupid=repo_group.name,
             userid=user.username
         )
         response = api_call(self.app, params)
 
         expected = (
             'failed to edit permission for user: `%s` in repo group: `%s`' % (
                 user.username, repo_group.name
             )
         )
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_revoke_user_permission_from_user_group.py

@@ -1,112 +1,112 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 mock
 import pytest
 
 from rhodecode.model.user_group import UserGroupModel
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_ok, crash)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestRevokeUserPermissionFromUserGroup(object):
     @pytest.mark.parametrize("name", [
         ('none',),
         ('all',),
         ('repos',),
         ('groups',),
     ])
     def test_api_revoke_user_permission_from_user_group(self, name, user_util):
         user = user_util.create_user()
         group = user_util.create_user_group()
         user_util.grant_user_permission_to_user_group(
             group, user, 'usergroup.admin')
 
         id_, params = build_data(
             self.apikey,
             'revoke_user_permission_from_user_group',
             usergroupid=group.users_group_name,
             userid=user.username)
         response = api_call(self.app, params)
 
         expected = {
             'msg': 'Revoked perm for user: `%s` in user group: `%s`' % (
                 user.username, group.users_group_name
             ),
             'success': True
         }
         assert_ok(id_, expected, given=response.body)
 
     @pytest.mark.parametrize("name, grant_admin, access_ok", [
         ('none', False, False),
         ('all', False, False),
         ('repos', False, False),
         ('groups', False, False),
 
         # after granting admin rights
         ('none', False, False),
         ('all', False, False),
         ('repos', False, False),
         ('groups', False, False),
     ])
     def test_api_revoke_user_permission_from_user_group_by_regular_user(
             self, name, grant_admin, access_ok, user_util):
         user = user_util.create_user()
         group = user_util.create_user_group()
         permission = 'usergroup.admin' if grant_admin else 'usergroup.read'
         user_util.grant_user_permission_to_user_group(group, user, permission)
 
         id_, params = build_data(
             self.apikey_regular,
             'revoke_user_permission_from_user_group',
             usergroupid=group.users_group_name,
             userid=user.username)
         response = api_call(self.app, params)
         if access_ok:
             expected = {
                 'msg': 'Revoked perm for user: `%s` in user group: `%s`' % (
                     user.username, group.users_group_name
                 ),
                 'success': True
             }
             assert_ok(id_, expected, given=response.body)
         else:
             expected = 'user group `%s` does not exist' % (
                 group.users_group_name)
             assert_error(id_, expected, given=response.body)
 
     @mock.patch.object(UserGroupModel, 'revoke_user_permission', crash)
     def test_api_revoke_user_permission_from_user_group_exception_when_adding(
             self, user_util):
         user = user_util.create_user()
         group = user_util.create_user_group()
         id_, params = build_data(
             self.apikey,
             'revoke_user_permission_from_user_group',
             usergroupid=group.users_group_name,
             userid=user.username)
         response = api_call(self.app, params)
 
         expected = (
             'failed to edit permission for user: `%s` in user group: `%s`' % (
                 user.username, group.users_group_name)
         )
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_update_pull_request.py

@@ -1,213 +1,213 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 pytest
 
 from rhodecode.lib.vcs.nodes import FileNode
 from rhodecode.model.db import User
 from rhodecode.model.pull_request import PullRequestModel
 from rhodecode.tests import TEST_USER_ADMIN_LOGIN
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_ok, assert_error)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestUpdatePullRequest(object):
 
     @pytest.mark.backends("git", "hg")
     def test_api_update_pull_request_title_or_description(
             self, pr_util, no_notifications):
         pull_request = pr_util.create_pull_request()
 
         id_, params = build_data(
             self.apikey, 'update_pull_request',
             repoid=pull_request.target_repo.repo_name,
             pullrequestid=pull_request.pull_request_id,
             title='New TITLE OF A PR',
             description='New DESC OF A PR',
         )
         response = api_call(self.app, params)
 
         expected = {
             "msg": "Updated pull request `{}`".format(
                 pull_request.pull_request_id),
             "pull_request": response.json['result']['pull_request'],
             "updated_commits": {"added": [], "common": [], "removed": []},
             "updated_reviewers": {"added": [], "removed": []},
         }
 
         response_json = response.json['result']
         assert response_json == expected
         pr = response_json['pull_request']
         assert pr['title'] == 'New TITLE OF A PR'
         assert pr['description'] == 'New DESC OF A PR'
 
     @pytest.mark.backends("git", "hg")
     def test_api_try_update_closed_pull_request(
             self, pr_util, no_notifications):
         pull_request = pr_util.create_pull_request()
         PullRequestModel().close_pull_request(
             pull_request, TEST_USER_ADMIN_LOGIN)
 
         id_, params = build_data(
             self.apikey, 'update_pull_request',
             repoid=pull_request.target_repo.repo_name,
             pullrequestid=pull_request.pull_request_id)
         response = api_call(self.app, params)
 
         expected = 'pull request `{}` update failed, pull request ' \
                    'is closed'.format(pull_request.pull_request_id)
 
         assert_error(id_, expected, response.body)
 
     @pytest.mark.backends("git", "hg")
     def test_api_update_update_commits(self, pr_util, no_notifications):
         commits = [
             {'message': 'a'},
             {'message': 'b', 'added': [FileNode('file_b', 'test_content\n')]},
             {'message': 'c', 'added': [FileNode('file_c', 'test_content\n')]},
         ]
         pull_request = pr_util.create_pull_request(
             commits=commits, target_head='a', source_head='b', revisions=['b'])
         pr_util.update_source_repository(head='c')
         repo = pull_request.source_repo.scm_instance()
         commits = [x for x in repo.get_commits()]
         print commits
 
         added_commit_id = commits[-1].raw_id  # c commit
         common_commit_id = commits[1].raw_id  # b commit is common ancestor
         total_commits = [added_commit_id, common_commit_id]
 
         id_, params = build_data(
             self.apikey, 'update_pull_request',
             repoid=pull_request.target_repo.repo_name,
             pullrequestid=pull_request.pull_request_id,
             update_commits=True
         )
         response = api_call(self.app, params)
 
         expected = {
             "msg": "Updated pull request `{}`".format(
                 pull_request.pull_request_id),
             "pull_request": response.json['result']['pull_request'],
             "updated_commits": {"added": [added_commit_id],
                                 "common": [common_commit_id],
                                 "total": total_commits,
                                 "removed": []},
             "updated_reviewers": {"added": [], "removed": []},
         }
 
         assert_ok(id_, expected, response.body)
 
     @pytest.mark.backends("git", "hg")
     def test_api_update_change_reviewers(
             self, user_util, pr_util, no_notifications):
         a = user_util.create_user()
         b = user_util.create_user()
         c = user_util.create_user()
         new_reviewers = [
             {'username': b.username,'reasons': ['updated via API'],
              'mandatory':False},
             {'username': c.username, 'reasons': ['updated via API'],
              'mandatory':False},
         ]
 
         added = [b.username, c.username]
         removed = [a.username]
 
         pull_request = pr_util.create_pull_request(
             reviewers=[(a.username, ['added via API'], False, [])])
 
         id_, params = build_data(
             self.apikey, 'update_pull_request',
             repoid=pull_request.target_repo.repo_name,
             pullrequestid=pull_request.pull_request_id,
             reviewers=new_reviewers)
         response = api_call(self.app, params)
         expected = {
             "msg": "Updated pull request `{}`".format(
                 pull_request.pull_request_id),
             "pull_request": response.json['result']['pull_request'],
             "updated_commits": {"added": [], "common": [], "removed": []},
             "updated_reviewers": {"added": added, "removed": removed},
         }
 
         assert_ok(id_, expected, response.body)
 
     @pytest.mark.backends("git", "hg")
     def test_api_update_bad_user_in_reviewers(self, pr_util):
         pull_request = pr_util.create_pull_request()
 
         id_, params = build_data(
             self.apikey, 'update_pull_request',
             repoid=pull_request.target_repo.repo_name,
             pullrequestid=pull_request.pull_request_id,
             reviewers=[{'username': 'bad_name'}])
         response = api_call(self.app, params)
 
         expected = 'user `bad_name` does not exist'
 
         assert_error(id_, expected, response.body)
 
     @pytest.mark.backends("git", "hg")
     def test_api_update_repo_error(self, pr_util):
         pull_request = pr_util.create_pull_request()
         id_, params = build_data(
             self.apikey, 'update_pull_request',
             repoid='fake',
             pullrequestid=pull_request.pull_request_id,
             reviewers=[{'username': 'bad_name'}])
         response = api_call(self.app, params)
 
         expected = 'repository `fake` does not exist'
 
         response_json = response.json['error']
         assert response_json == expected
 
     @pytest.mark.backends("git", "hg")
     def test_api_update_pull_request_error(self, pr_util):
         pull_request = pr_util.create_pull_request()
 
         id_, params = build_data(
             self.apikey, 'update_pull_request',
             repoid=pull_request.target_repo.repo_name,
             pullrequestid=999999,
             reviewers=[{'username': 'bad_name'}])
         response = api_call(self.app, params)
 
         expected = 'pull request `999999` does not exist'
         assert_error(id_, expected, response.body)
 
     @pytest.mark.backends("git", "hg")
     def test_api_update_pull_request_no_perms_to_update(
             self, user_util, pr_util):
         user = user_util.create_user()
         pull_request = pr_util.create_pull_request()
 
         id_, params = build_data(
             user.api_key, 'update_pull_request',
             repoid=pull_request.target_repo.repo_name,
             pullrequestid=pull_request.pull_request_id,)
         response = api_call(self.app, params)
 
         expected = ('pull request `%s` update failed, '
                     'no permission to update.') % pull_request.pull_request_id
 
         assert_error(id_, expected, response.body)

rhodecode/api/tests/test_update_repo.py

@@ -1,192 +1,192 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 mock
 import pytest
 
 from rhodecode.model.repo import RepoModel
 from rhodecode.tests import TEST_USER_ADMIN_LOGIN, TEST_USER_REGULAR_LOGIN
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_ok, crash, jsonify)
 from rhodecode.tests.fixture import Fixture
 from rhodecode.tests.plugin import http_host_stub, http_host_only_stub
 
 fixture = Fixture()
 
 UPDATE_REPO_NAME = 'api_update_me'
 
 
 class SAME_AS_UPDATES(object):
     """ Constant used for tests below """
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestApiUpdateRepo(object):
 
     @pytest.mark.parametrize("updates, expected", [
         ({'owner': TEST_USER_REGULAR_LOGIN},
          SAME_AS_UPDATES),
 
         ({'description': 'new description'},
          SAME_AS_UPDATES),
 
         ({'clone_uri': 'http://foo.com/repo'},
          SAME_AS_UPDATES),
 
         ({'clone_uri': None},
          {'clone_uri': ''}),
 
         ({'clone_uri': ''},
          {'clone_uri': ''}),
 
         ({'landing_rev': 'rev:tip'},
          {'landing_rev': ['rev', 'tip']}),
 
         ({'enable_statistics': True},
          SAME_AS_UPDATES),
 
         ({'enable_locking': True},
          SAME_AS_UPDATES),
 
         ({'enable_downloads': True},
          SAME_AS_UPDATES),
 
         ({'repo_name': 'new_repo_name'},
          {
             'repo_name': 'new_repo_name',
             'url': 'http://{}/new_repo_name'.format(http_host_only_stub())
          }),
 
         ({'repo_name': 'test_group_for_update/{}'.format(UPDATE_REPO_NAME),
           '_group': 'test_group_for_update'},
          {
             'repo_name': 'test_group_for_update/{}'.format(UPDATE_REPO_NAME),
             'url': 'http://{}/test_group_for_update/{}'.format(
                 http_host_only_stub(), UPDATE_REPO_NAME)
          }),
     ])
     def test_api_update_repo(self, updates, expected, backend):
         repo_name = UPDATE_REPO_NAME
         repo = fixture.create_repo(repo_name, repo_type=backend.alias)
         if updates.get('_group'):
             fixture.create_repo_group(updates['_group'])
 
         expected_api_data = repo.get_api_data(include_secrets=True)
         if expected is SAME_AS_UPDATES:
             expected_api_data.update(updates)
         else:
             expected_api_data.update(expected)
 
         id_, params = build_data(
             self.apikey, 'update_repo', repoid=repo_name, **updates)
         response = api_call(self.app, params)
 
         if updates.get('repo_name'):
             repo_name = updates['repo_name']
 
         try:
             expected = {
                 'msg': 'updated repo ID:%s %s' % (repo.repo_id, repo_name),
                 'repository': jsonify(expected_api_data)
             }
             assert_ok(id_, expected, given=response.body)
         finally:
             fixture.destroy_repo(repo_name)
             if updates.get('_group'):
                 fixture.destroy_repo_group(updates['_group'])
 
     def test_api_update_repo_fork_of_field(self, backend):
         master_repo = backend.create_repo()
         repo = backend.create_repo()
         updates = {
             'fork_of': master_repo.repo_name,
             'fork_of_id': master_repo.repo_id
         }
         expected_api_data = repo.get_api_data(include_secrets=True)
         expected_api_data.update(updates)
 
         id_, params = build_data(
             self.apikey, 'update_repo', repoid=repo.repo_name, **updates)
         response = api_call(self.app, params)
         expected = {
             'msg': 'updated repo ID:%s %s' % (repo.repo_id, repo.repo_name),
             'repository': jsonify(expected_api_data)
         }
         assert_ok(id_, expected, given=response.body)
         result = response.json['result']['repository']
         assert result['fork_of'] == master_repo.repo_name
         assert result['fork_of_id'] == master_repo.repo_id
 
     def test_api_update_repo_fork_of_not_found(self, backend):
         master_repo_name = 'fake-parent-repo'
         repo = backend.create_repo()
         updates = {
             'fork_of': master_repo_name
         }
         id_, params = build_data(
             self.apikey, 'update_repo', repoid=repo.repo_name, **updates)
         response = api_call(self.app, params)
         expected = {
             'repo_fork_of': 'Fork with id `{}` does not exists'.format(
                 master_repo_name)}
         assert_error(id_, expected, given=response.body)
 
     def test_api_update_repo_with_repo_group_not_existing(self):
         repo_name = 'admin_owned'
         fake_repo_group = 'test_group_for_update'
         fixture.create_repo(repo_name)
         updates = {'repo_name': '{}/{}'.format(fake_repo_group, repo_name)}
         id_, params = build_data(
             self.apikey, 'update_repo', repoid=repo_name, **updates)
         response = api_call(self.app, params)
         try:
             expected = {
                 'repo_group': 'Repository group `{}` does not exist'.format(fake_repo_group)
             }
             assert_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 = {'active': False}
         id_, params = build_data(
             self.apikey_regular, 'update_repo', repoid=repo_name, **updates)
         response = api_call(self.app, params)
         try:
             expected = 'repository `%s` does not exist' % (repo_name,)
             assert_error(id_, expected, given=response.body)
         finally:
             fixture.destroy_repo(repo_name)
 
     @mock.patch.object(RepoModel, 'update', crash)
     def test_api_update_repo_exception_occurred(self, backend):
         repo_name = UPDATE_REPO_NAME
         fixture.create_repo(repo_name, repo_type=backend.alias)
         id_, params = build_data(
             self.apikey, 'update_repo', repoid=repo_name,
             owner=TEST_USER_ADMIN_LOGIN,)
         response = api_call(self.app, params)
         try:
             expected = 'failed to update repo `%s`' % (repo_name,)
             assert_error(id_, expected, given=response.body)
         finally:
             fixture.destroy_repo(repo_name)

rhodecode/api/tests/test_update_repo_group.py

@@ -1,150 +1,150 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 os
 
 import pytest
 
 from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.model.user import UserModel
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_ok)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestApiUpdateRepoGroup(object):
 
     def test_update_group_name(self, user_util):
         new_group_name = 'new-group'
         initial_name = self._update(user_util, group_name=new_group_name)
         assert RepoGroupModel()._get_repo_group(initial_name) is None
         new_group = RepoGroupModel()._get_repo_group(new_group_name)
         assert new_group is not None
         assert new_group.full_path == new_group_name
 
     def test_update_group_name_change_parent(self, user_util):
 
         parent_group = user_util.create_repo_group()
         parent_group_name = parent_group.name
 
         expected_group_name = '{}/{}'.format(parent_group_name, 'new-group')
         initial_name = self._update(user_util, group_name=expected_group_name)
 
         repo_group = RepoGroupModel()._get_repo_group(expected_group_name)
 
         assert repo_group is not None
         assert repo_group.group_name == expected_group_name
         assert repo_group.full_path == expected_group_name
         assert RepoGroupModel()._get_repo_group(initial_name) is None
 
         new_path = os.path.join(
             RepoGroupModel().repos_path, *repo_group.full_path_splitted)
         assert os.path.exists(new_path)
 
     def test_update_enable_locking(self, user_util):
         initial_name = self._update(user_util, enable_locking=True)
         repo_group = RepoGroupModel()._get_repo_group(initial_name)
         assert repo_group.enable_locking is True
 
     def test_update_description(self, user_util):
         description = 'New description'
         initial_name = self._update(user_util, description=description)
         repo_group = RepoGroupModel()._get_repo_group(initial_name)
         assert repo_group.group_description == description
 
     def test_update_owner(self, user_util):
         owner = self.TEST_USER_LOGIN
         initial_name = self._update(user_util, owner=owner)
         repo_group = RepoGroupModel()._get_repo_group(initial_name)
         assert repo_group.user.username == owner
 
     def test_update_group_name_conflict_with_existing(self, user_util):
         group_1 = user_util.create_repo_group()
         group_2 = user_util.create_repo_group()
         repo_group_name_1 = group_1.group_name
         repo_group_name_2 = group_2.group_name
 
         id_, params = build_data(
             self.apikey, 'update_repo_group', repogroupid=repo_group_name_1,
             group_name=repo_group_name_2)
         response = api_call(self.app, params)
         expected = {
             'unique_repo_group_name':
                 'Repository group with name `{}` already exists'.format(
                     repo_group_name_2)}
         assert_error(id_, expected, given=response.body)
 
     def test_api_update_repo_group_by_regular_user_no_permission(self, user_util):
         temp_user = user_util.create_user()
         temp_user_api_key = temp_user.api_key
         parent_group = user_util.create_repo_group()
         repo_group_name = parent_group.group_name
         id_, params = build_data(
             temp_user_api_key, 'update_repo_group', repogroupid=repo_group_name)
         response = api_call(self.app, params)
         expected = 'repository group `%s` does not exist' % (repo_group_name,)
         assert_error(id_, expected, given=response.body)
 
     def test_api_update_repo_group_regular_user_no_root_write_permissions(
             self, user_util):
         temp_user = user_util.create_user()
         temp_user_api_key = temp_user.api_key
         parent_group = user_util.create_repo_group(owner=temp_user.username)
         repo_group_name = parent_group.group_name
 
         id_, params = build_data(
             temp_user_api_key, 'update_repo_group', repogroupid=repo_group_name,
             group_name='at-root-level')
         response = api_call(self.app, params)
         expected = {
             'repo_group': 'You do not have the permission to store '
                           'repository groups in the root location.'}
         assert_error(id_, expected, given=response.body)
 
     def _update(self, user_util, **kwargs):
         repo_group = user_util.create_repo_group()
         initial_name = repo_group.name
         user = UserModel().get_by_username(self.TEST_USER_LOGIN)
         user_util.grant_user_permission_to_repo_group(
             repo_group, user, 'group.admin')
 
         id_, params = build_data(
             self.apikey, 'update_repo_group', repogroupid=initial_name,
             **kwargs)
         response = api_call(self.app, params)
 
         repo_group = RepoGroupModel.cls.get(repo_group.group_id)
 
         expected = {
             'msg': 'updated repository group ID:{} {}'.format(
                 repo_group.group_id, repo_group.group_name),
             'repo_group': {
                 'repositories': [],
                 'group_name': repo_group.group_name,
                 'group_description': repo_group.group_description,
                 'owner': repo_group.user.username,
                 'group_id': repo_group.group_id,
                 'parent_group': (
                     repo_group.parent_group.name
                     if repo_group.parent_group else None)
             }
         }
         assert_ok(id_, expected, given=response.body)
         return initial_name

rhodecode/api/tests/test_update_user.py

@@ -1,116 +1,116 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 mock
 import pytest
 
 from rhodecode.model.db import User
 from rhodecode.model.user import UserModel
 from rhodecode.tests import TEST_USER_ADMIN_LOGIN
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_ok, assert_error, crash, jsonify)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestUpdateUser(object):
     @pytest.mark.parametrize("name, expected", [
         ('firstname', 'new_username'),
         ('lastname', 'new_username'),
         ('email', 'new_username'),
         ('admin', True),
         ('admin', False),
         ('extern_type', 'ldap'),
         ('extern_type', None),
         ('extern_name', 'test'),
         ('extern_name', None),
         ('active', False),
         ('active', True),
         ('password', 'newpass')
     ])
     def test_api_update_user(self, name, expected, user_util):
         usr = user_util.create_user()
 
         kw = {name: expected, 'userid': usr.user_id}
         id_, params = build_data(self.apikey, 'update_user', **kw)
         response = api_call(self.app, params)
 
         ret = {
             'msg': 'updated user ID:%s %s' % (usr.user_id, usr.username),
             'user': jsonify(
                 UserModel()
                 .get_by_username(usr.username)
                 .get_api_data(include_secrets=True)
             )
         }
 
         expected = ret
         assert_ok(id_, expected, given=response.body)
 
     def test_api_update_user_no_changed_params(self):
         usr = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
         ret = jsonify(usr.get_api_data(include_secrets=True))
         id_, params = build_data(
             self.apikey, 'update_user', userid=TEST_USER_ADMIN_LOGIN)
 
         response = api_call(self.app, params)
         ret = {
             'msg': 'updated user ID:%s %s' % (
                 usr.user_id, TEST_USER_ADMIN_LOGIN),
             'user': ret
         }
         expected = ret
         assert_ok(id_, expected, given=response.body)
 
     def test_api_update_user_by_user_id(self):
         usr = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
         ret = jsonify(usr.get_api_data(include_secrets=True))
         id_, params = build_data(
             self.apikey, 'update_user', userid=usr.user_id)
 
         response = api_call(self.app, params)
         ret = {
             'msg': 'updated user ID:%s %s' % (
                 usr.user_id, TEST_USER_ADMIN_LOGIN),
             'user': ret
         }
         expected = ret
         assert_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.app, params)
         expected = 'editing default user is forbidden'
         assert_error(id_, expected, given=response.body)
 
     @mock.patch.object(UserModel, 'update_user', crash)
     def test_api_update_user_when_exception_happens(self):
         usr = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
         ret = jsonify(usr.get_api_data(include_secrets=True))
         id_, params = build_data(
             self.apikey, 'update_user', userid=usr.user_id)
 
         response = api_call(self.app, params)
         ret = 'failed to update user `%s`' % (usr.user_id,)
 
         expected = ret
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_update_user_group.py

@@ -1,110 +1,110 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 mock
 import pytest
 
 from rhodecode.model.user import UserModel
 from rhodecode.model.user_group import UserGroupModel
 from rhodecode.tests import TEST_USER_ADMIN_EMAIL
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_ok, crash, jsonify)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestUpdateUserGroup(object):
     @pytest.mark.parametrize("changing_attr, updates", [
         ('group_name', {'group_name': 'new_group_name'}),
         ('group_name', {'group_name': 'test_group_for_update'}),
         # ('owner', {'owner': TEST_USER_REGULAR_LOGIN}),
         ('owner_email', {'owner_email': TEST_USER_ADMIN_EMAIL}),
         ('active', {'active': False}),
         ('active', {'active': True})
     ])
     def test_api_update_user_group(self, changing_attr, updates, user_util):
         user_group = user_util.create_user_group()
         group_name = user_group.users_group_name
         expected_api_data = user_group.get_api_data()
         expected_api_data.update(updates)
 
         id_, params = build_data(
             self.apikey, 'update_user_group', usergroupid=group_name,
             **updates)
         response = api_call(self.app, params)
 
         expected = {
             'msg': 'updated user group ID:%s %s' % (
                 user_group.users_group_id, user_group.users_group_name),
             'user_group': jsonify(expected_api_data)
         }
         assert_ok(id_, expected, given=response.body)
 
     @pytest.mark.parametrize("changing_attr, updates", [
         # TODO: mikhail: decide if we need to test against the commented params
         # ('group_name', {'group_name': 'new_group_name'}),
         # ('group_name', {'group_name': 'test_group_for_update'}),
         # ('owner', {'owner': TEST_USER_REGULAR_LOGIN}),
         ('owner_email', {'owner_email': TEST_USER_ADMIN_EMAIL}),
         ('active', {'active': False}),
         ('active', {'active': True})
     ])
     def test_api_update_user_group_regular_user(
             self, changing_attr, updates, user_util):
         user_group = user_util.create_user_group()
         group_name = user_group.users_group_name
         expected_api_data = user_group.get_api_data()
         expected_api_data.update(updates)
 
 
         # grant permission to this user
         user = UserModel().get_by_username(self.TEST_USER_LOGIN)
 
         user_util.grant_user_permission_to_user_group(
             user_group, user, 'usergroup.admin')
         id_, params = build_data(
             self.apikey_regular, 'update_user_group',
             usergroupid=group_name, **updates)
         response = api_call(self.app, params)
         expected = {
             'msg': 'updated user group ID:%s %s' % (
                 user_group.users_group_id, user_group.users_group_name),
             'user_group': jsonify(expected_api_data)
         }
         assert_ok(id_, expected, given=response.body)
 
     def test_api_update_user_group_regular_user_no_permission(self, user_util):
         user_group = user_util.create_user_group()
         group_name = user_group.users_group_name
         id_, params = build_data(
             self.apikey_regular, 'update_user_group', usergroupid=group_name)
         response = api_call(self.app, params)
 
         expected = 'user group `%s` does not exist' % (group_name)
         assert_error(id_, expected, given=response.body)
 
     @mock.patch.object(UserGroupModel, 'update', crash)
     def test_api_update_user_group_exception_occurred(self, user_util):
         user_group = user_util.create_user_group()
         group_name = user_group.users_group_name
         id_, params = build_data(
             self.apikey, 'update_user_group', usergroupid=group_name)
         response = api_call(self.app, params)
         expected = 'failed to update user group `%s`' % (group_name,)
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_utils.py

@@ -1,294 +1,294 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 pytest
 from mock import Mock, patch
 
 from rhodecode.api import utils
 from rhodecode.api import JSONRPCError
 from rhodecode.lib.vcs.exceptions import RepositoryError
 
 
 class TestGetCommitOrError(object):
     def setup(self):
         self.commit_hash = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa10'
 
     @pytest.mark.parametrize("ref", ['ref', '12345', 'a:b:c:d', 'branch:name'])
     def test_ref_cannot_be_parsed(self, ref):
         repo = Mock()
         with pytest.raises(JSONRPCError) as excinfo:
             utils.get_commit_or_error(ref, repo)
         expected_message = (
             'Ref `{ref}` given in a wrong format. Please check the API'
             ' documentation for more details'.format(ref=ref)
         )
         assert excinfo.value.message == expected_message
 
     def test_success_with_hash_specified(self):
         repo = Mock()
         ref_type = 'branch'
         ref = '{}:master:{}'.format(ref_type, self.commit_hash)
 
         with patch('rhodecode.api.utils.get_commit_from_ref_name') as get_commit:
             result = utils.get_commit_or_error(ref, repo)
             get_commit.assert_called_once_with(
                 repo, self.commit_hash)
             assert result == get_commit()
 
     def test_raises_an_error_when_commit_not_found(self):
         repo = Mock()
         ref = 'branch:master:{}'.format(self.commit_hash)
 
         with patch('rhodecode.api.utils.get_commit_from_ref_name') as get_commit:
             get_commit.side_effect = RepositoryError('Commit not found')
             with pytest.raises(JSONRPCError) as excinfo:
                 utils.get_commit_or_error(ref, repo)
             expected_message = 'Ref `{}` does not exist'.format(ref)
             assert excinfo.value.message == expected_message
 
 
 class TestResolveRefOrError(object):
     def setup(self):
         self.commit_hash = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa10'
 
     def test_success_with_no_hash_specified(self):
         repo = Mock()
         ref_type = 'branch'
         ref_name = 'master'
         ref = '{}:{}'.format(ref_type, ref_name)
 
         with patch('rhodecode.api.utils._get_ref_hash') \
                 as _get_ref_hash:
             _get_ref_hash.return_value = self.commit_hash
             result = utils.resolve_ref_or_error(ref, repo)
             _get_ref_hash.assert_called_once_with(repo, ref_type, ref_name)
             assert result == '{}:{}'.format(ref, self.commit_hash)
 
     def test_non_supported_refs(self):
         repo = Mock()
         ref = 'ancestor:ref'
         with pytest.raises(JSONRPCError) as excinfo:
             utils.resolve_ref_or_error(ref, repo)
         expected_message = 'The specified ancestor `ref` does not exist'
         assert excinfo.value.message == expected_message
 
     def test_branch_is_not_found(self):
         repo = Mock()
         ref = 'branch:non-existing-one'
         with patch('rhodecode.api.utils._get_ref_hash')\
                 as _get_ref_hash:
             _get_ref_hash.side_effect = KeyError()
             with pytest.raises(JSONRPCError) as excinfo:
                 utils.resolve_ref_or_error(ref, repo)
         expected_message = (
             'The specified branch `non-existing-one` does not exist')
         assert excinfo.value.message == expected_message
 
     def test_bookmark_is_not_found(self):
         repo = Mock()
         ref = 'bookmark:non-existing-one'
         with patch('rhodecode.api.utils._get_ref_hash')\
                 as _get_ref_hash:
             _get_ref_hash.side_effect = KeyError()
             with pytest.raises(JSONRPCError) as excinfo:
                 utils.resolve_ref_or_error(ref, repo)
         expected_message = (
             'The specified bookmark `non-existing-one` does not exist')
         assert excinfo.value.message == expected_message
 
     @pytest.mark.parametrize("ref", ['ref', '12345', 'a:b:c:d'])
     def test_ref_cannot_be_parsed(self, ref):
         repo = Mock()
         with pytest.raises(JSONRPCError) as excinfo:
             utils.resolve_ref_or_error(ref, repo)
         expected_message = (
             'Ref `{ref}` given in a wrong format. Please check the API'
             ' documentation for more details'.format(ref=ref)
         )
         assert excinfo.value.message == expected_message
 
 
 class TestGetRefHash(object):
     def setup(self):
         self.commit_hash = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa10'
         self.bookmark_name = 'test-bookmark'
 
     @pytest.mark.parametrize("alias, branch_name", [
         ("git", "master"),
         ("hg", "default")
     ])
     def test_returns_hash_by_branch_name(self, alias, branch_name):
         with patch('rhodecode.model.db.Repository') as repo:
             repo.scm_instance().alias = alias
             repo.scm_instance().branches = {branch_name: self.commit_hash}
             result_hash = utils._get_ref_hash(repo, 'branch', branch_name)
             assert result_hash == self.commit_hash
 
     @pytest.mark.parametrize("alias, branch_name", [
         ("git", "master"),
         ("hg", "default")
     ])
     def test_raises_error_when_branch_is_not_found(self, alias, branch_name):
         with patch('rhodecode.model.db.Repository') as repo:
             repo.scm_instance().alias = alias
             repo.scm_instance().branches = {}
             with pytest.raises(KeyError):
                 utils._get_ref_hash(repo, 'branch', branch_name)
 
     def test_returns_hash_when_bookmark_is_specified_for_hg(self):
         with patch('rhodecode.model.db.Repository') as repo:
             repo.scm_instance().alias = 'hg'
             repo.scm_instance().bookmarks = {
                 self.bookmark_name: self.commit_hash}
             result_hash = utils._get_ref_hash(
                 repo, 'bookmark', self.bookmark_name)
             assert result_hash == self.commit_hash
 
     def test_raises_error_when_bookmark_is_not_found_in_hg_repo(self):
         with patch('rhodecode.model.db.Repository') as repo:
             repo.scm_instance().alias = 'hg'
             repo.scm_instance().bookmarks = {}
             with pytest.raises(KeyError):
                 utils._get_ref_hash(repo, 'bookmark', self.bookmark_name)
 
     def test_raises_error_when_bookmark_is_specified_for_git(self):
         with patch('rhodecode.model.db.Repository') as repo:
             repo.scm_instance().alias = 'git'
             repo.scm_instance().bookmarks = {
                 self.bookmark_name: self.commit_hash}
             with pytest.raises(ValueError):
                 utils._get_ref_hash(repo, 'bookmark', self.bookmark_name)
 
 
 class TestUserByNameOrError(object):
     def test_user_found_by_id(self):
         fake_user = Mock(id=123)
 
         patcher = patch('rhodecode.model.user.UserModel.get_user')
         with patcher as get_user:
             get_user.return_value = fake_user
 
             patcher = patch('rhodecode.model.user.UserModel.get_by_username')
             with patcher as get_by_username:
                 result = utils.get_user_or_error(123)
                 assert result == fake_user
 
     def test_user_not_found_by_id_as_str(self):
         fake_user = Mock(id=123)
 
         patcher = patch('rhodecode.model.user.UserModel.get_user')
         with patcher as get_user:
             get_user.return_value = fake_user
             patcher = patch('rhodecode.model.user.UserModel.get_by_username')
             with patcher as get_by_username:
                 get_by_username.return_value = None
 
                 with pytest.raises(JSONRPCError):
                     utils.get_user_or_error('123')
 
     def test_user_found_by_name(self):
         fake_user = Mock(id=123)
 
         patcher = patch('rhodecode.model.user.UserModel.get_user')
         with patcher as get_user:
             get_user.return_value = None
 
             patcher = patch('rhodecode.model.user.UserModel.get_by_username')
             with patcher as get_by_username:
                 get_by_username.return_value = fake_user
 
                 result = utils.get_user_or_error('test')
                 assert result == fake_user
 
     def test_user_not_found_by_id(self):
         patcher = patch('rhodecode.model.user.UserModel.get_user')
         with patcher as get_user:
             get_user.return_value = None
             patcher = patch('rhodecode.model.user.UserModel.get_by_username')
             with patcher as get_by_username:
                 get_by_username.return_value = None
 
                 with pytest.raises(JSONRPCError) as excinfo:
                     utils.get_user_or_error(123)
 
                 expected_message = 'user `123` does not exist'
                 assert excinfo.value.message == expected_message
 
     def test_user_not_found_by_name(self):
         patcher = patch('rhodecode.model.user.UserModel.get_by_username')
         with patcher as get_by_username:
             get_by_username.return_value = None
             with pytest.raises(JSONRPCError) as excinfo:
                 utils.get_user_or_error('test')
 
         expected_message = 'user `test` does not exist'
         assert excinfo.value.message == expected_message
 
 
 class TestGetCommitDict(object):
     @pytest.mark.parametrize('filename, expected', [
         (b'sp\xc3\xa4cial', u'sp\xe4cial'),
         (b'sp\xa4cial', u'sp\ufffdcial'),
     ])
     def test_decodes_filenames_to_unicode(self, filename, expected):
         result = utils._get_commit_dict(filename=filename, op='A')
         assert result['filename'] == expected
 
 
 class TestRepoAccess(object):
     def setup_method(self, method):
 
         self.admin_perm_patch = patch(
             'rhodecode.api.utils.HasPermissionAnyApi')
         self.repo_perm_patch = patch(
             'rhodecode.api.utils.HasRepoPermissionAnyApi')
 
     def test_has_superadmin_permission_checks_for_admin(self):
         admin_mock = Mock()
         with self.admin_perm_patch as amock:
             amock.return_value = admin_mock
             assert utils.has_superadmin_permission('fake_user')
             amock.assert_called_once_with('hg.admin')
 
         admin_mock.assert_called_once_with(user='fake_user')
 
     def test_has_repo_permissions_checks_for_repo_access(self):
         repo_mock = Mock()
         fake_repo = Mock()
         with self.repo_perm_patch as rmock:
             rmock.return_value = repo_mock
             assert utils.validate_repo_permissions(
                 'fake_user', 'fake_repo_id', fake_repo,
                 ['perm1', 'perm2'])
             rmock.assert_called_once_with(*['perm1', 'perm2'])
 
         repo_mock.assert_called_once_with(
             user='fake_user', repo_name=fake_repo.repo_name)
 
     def test_has_repo_permissions_raises_not_found(self):
         repo_mock = Mock(return_value=False)
         fake_repo = Mock()
         with self.repo_perm_patch as rmock:
             rmock.return_value = repo_mock
             with pytest.raises(JSONRPCError) as excinfo:
                 utils.validate_repo_permissions(
                     'fake_user', 'fake_repo_id', fake_repo, 'perms')
                 assert 'fake_repo_id' in excinfo

rhodecode/api/tests/utils.py

@@ -1,106 +1,106 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2010-2017 RhodeCode GmbH
+# Copyright (C) 2010-2018 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 random
 
 from rhodecode.api.utils import get_origin
 from rhodecode.lib.ext_json import json
 
 
 API_URL = '/_admin/api'
 
 
 def assert_ok(id_, expected, given):
     expected = jsonify({
         'id': id_,
         'error': None,
         'result': expected
     })
     given = json.loads(given)
     assert expected == given
 
 
 def assert_error(id_, expected, given):
     expected = jsonify({
         'id': id_,
         'error': expected,
         'result': None
     })
     given = json.loads(given)
     assert expected == given
 
 
 def jsonify(obj):
     return json.loads(json.dumps(obj))
 
 
 def build_data(apikey, method, **kw):
     """
     Builds API data with given random ID
 
     :param random_id:
     """
     random_id = random.randrange(1, 9999)
     return random_id, json.dumps({
         "id": random_id,
         "api_key": apikey,
         "method": method,
         "args": kw
     })
 
 
 def api_call(app, params, status=None):
     response = app.post(
         API_URL, content_type='application/json', params=params, status=status)
     return response
 
 
 def crash(*args, **kwargs):
     raise Exception('Total Crash !')
 
 
 def expected_permissions(object_with_permissions):
     """
     Returns the expected permissions structure for the given object.
 
     The object is expected to be a `Repository`, `RepositoryGroup`,
     or `UserGroup`. They all implement the same permission handling
     API.
     """
     permissions = []
     for _user in object_with_permissions.permissions():
         user_data = {
             'name': _user.username,
             'permission': _user.permission,
             'origin': get_origin(_user),
             'type': "user",
         }
         permissions.append(user_data)
 
     for _user_group in object_with_permissions.permission_user_groups():
         user_group_data = {
             'name': _user_group.users_group_name,
             'permission': _user_group.permission,
             'origin': get_origin(_user_group),
             'type': "user_group",
         }
         permissions.append(user_group_data)
     return permissions

rhodecode/api/utils.py

@@ -1,442 +1,442 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2014-2017 RhodeCode GmbH
+# Copyright (C) 2014-2018 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/
 
 """
 JSON RPC utils
 """
 
 import collections
 import logging
 
 from rhodecode.api.exc import JSONRPCError
 from rhodecode.lib.auth import (
     HasPermissionAnyApi, HasRepoPermissionAnyApi, HasRepoGroupPermissionAnyApi)
 from rhodecode.lib.utils import safe_unicode
 from rhodecode.lib.vcs.exceptions import RepositoryError
 from rhodecode.controllers.utils import get_commit_from_ref_name
 from rhodecode.lib.utils2 import str2bool
 
 log = logging.getLogger(__name__)
 
 
 class OAttr(object):
     """
     Special Option that defines other attribute, and can default to them
 
     Example::
 
         def test(apiuser, userid=Optional(OAttr('apiuser')):
             user = Optional.extract(userid, evaluate_locals=local())
             #if we pass in userid, we get it, else it will default to apiuser
             #attribute
     """
 
     def __init__(self, attr_name):
         self.attr_name = attr_name
 
     def __repr__(self):
         return '<OptionalAttr:%s>' % self.attr_name
 
     def __call__(self):
         return self
 
 
 class Optional(object):
     """
     Defines an optional parameter::
 
         param = param.getval() if isinstance(param, Optional) else param
         param = param() if isinstance(param, Optional) else param
 
     is equivalent of::
 
         param = Optional.extract(param)
 
     """
 
     def __init__(self, type_):
         self.type_ = type_
 
     def __repr__(self):
         return '<Optional:%s>' % self.type_.__repr__()
 
     def __call__(self):
         return self.getval()
 
     def getval(self, evaluate_locals=None):
         """
         returns value from this Optional instance
         """
         if isinstance(self.type_, OAttr):
             param_name = self.type_.attr_name
             if evaluate_locals:
                 return evaluate_locals[param_name]
             # use params name
             return param_name
         return self.type_
 
     @classmethod
     def extract(cls, val, evaluate_locals=None, binary=None):
         """
         Extracts value from Optional() instance
 
         :param val:
         :return: original value if it's not Optional instance else
             value of instance
         """
         if isinstance(val, cls):
             val = val.getval(evaluate_locals)
 
         if binary:
             val = str2bool(val)
 
         return val
 
 
 def parse_args(cli_args, key_prefix=''):
     from rhodecode.lib.utils2 import (escape_split)
     kwargs = collections.defaultdict(dict)
     for el in escape_split(cli_args, ','):
         kv = escape_split(el, '=', 1)
         if len(kv) == 2:
             k, v = kv
             kwargs[key_prefix + k] = v
     return kwargs
 
 
 def get_origin(obj):
     """
     Get origin of permission from object.
 
     :param obj:
     """
     origin = 'permission'
 
     if getattr(obj, 'owner_row', '') and getattr(obj, 'admin_row', ''):
         # admin and owner case, maybe we should use dual string ?
         origin = 'owner'
     elif getattr(obj, 'owner_row', ''):
         origin = 'owner'
     elif getattr(obj, 'admin_row', ''):
         origin = 'super-admin'
     return origin
 
 
 def store_update(updates, attr, name):
     """
     Stores param in updates dict if it's not instance of Optional
     allows easy updates of passed in params
     """
     if not isinstance(attr, Optional):
         updates[name] = attr
 
 
 def has_superadmin_permission(apiuser):
     """
     Return True if apiuser is admin or return False
 
     :param apiuser:
     """
     if HasPermissionAnyApi('hg.admin')(user=apiuser):
         return True
     return False
 
 
 def validate_repo_permissions(apiuser, repoid, repo, perms):
     """
     Raise JsonRPCError if apiuser is not authorized or return True
 
     :param apiuser:
     :param repoid:
     :param repo:
     :param perms:
     """
     if not HasRepoPermissionAnyApi(*perms)(
             user=apiuser, repo_name=repo.repo_name):
         raise JSONRPCError(
             'repository `%s` does not exist' % repoid)
 
     return True
 
 
 def validate_repo_group_permissions(apiuser, repogroupid, repo_group, perms):
     """
     Raise JsonRPCError if apiuser is not authorized or return True
 
     :param apiuser:
     :param repogroupid: just the id of repository group
     :param repo_group: instance of repo_group
     :param perms:
     """
     if not HasRepoGroupPermissionAnyApi(*perms)(
             user=apiuser, group_name=repo_group.group_name):
         raise JSONRPCError(
             'repository group `%s` does not exist' % repogroupid)
 
     return True
 
 
 def validate_set_owner_permissions(apiuser, owner):
     if isinstance(owner, Optional):
         owner = get_user_or_error(apiuser.user_id)
     else:
         if has_superadmin_permission(apiuser):
             owner = get_user_or_error(owner)
         else:
             # forbid setting owner for non-admins
             raise JSONRPCError(
                 'Only RhodeCode super-admin can specify `owner` param')
     return owner
 
 
 def get_user_or_error(userid):
     """
     Get user by id or name or return JsonRPCError if not found
 
     :param userid:
     """
     from rhodecode.model.user import UserModel
     user_model = UserModel()
 
     if isinstance(userid, (int, long)):
         try:
             user = user_model.get_user(userid)
         except ValueError:
             user = None
     else:
         user = user_model.get_by_username(userid)
 
     if user is None:
         raise JSONRPCError(
             'user `%s` does not exist' % (userid,))
     return user
 
 
 def get_repo_or_error(repoid):
     """
     Get repo by id or name or return JsonRPCError if not found
 
     :param repoid:
     """
     from rhodecode.model.repo import RepoModel
     repo_model = RepoModel()
 
     if isinstance(repoid, (int, long)):
         try:
             repo = repo_model.get_repo(repoid)
         except ValueError:
             repo = None
     else:
         repo = repo_model.get_by_repo_name(repoid)
 
     if repo is None:
         raise JSONRPCError(
             'repository `%s` does not exist' % (repoid,))
     return repo
 
 
 def get_repo_group_or_error(repogroupid):
     """
     Get repo group by id or name or return JsonRPCError if not found
 
     :param repogroupid:
     """
     from rhodecode.model.repo_group import RepoGroupModel
     repo_group_model = RepoGroupModel()
 
     if isinstance(repogroupid, (int, long)):
         try:
             repo_group = repo_group_model._get_repo_group(repogroupid)
         except ValueError:
             repo_group = None
     else:
         repo_group = repo_group_model.get_by_group_name(repogroupid)
 
     if repo_group is None:
         raise JSONRPCError(
             'repository group `%s` does not exist' % (repogroupid,))
     return repo_group
 
 
 def get_user_group_or_error(usergroupid):
     """
     Get user group by id or name or return JsonRPCError if not found
 
     :param usergroupid:
     """
     from rhodecode.model.user_group import UserGroupModel
     user_group_model = UserGroupModel()
 
     if isinstance(usergroupid, (int, long)):
         try:
             user_group = user_group_model.get_group(usergroupid)
         except ValueError:
             user_group = None
     else:
         user_group = user_group_model.get_by_name(usergroupid)
 
     if user_group is None:
         raise JSONRPCError(
             'user group `%s` does not exist' % (usergroupid,))
     return user_group
 
 
 def get_perm_or_error(permid, prefix=None):
     """
     Get permission by id or name or return JsonRPCError if not found
 
     :param permid:
     """
     from rhodecode.model.permission import PermissionModel
 
     perm = PermissionModel.cls.get_by_key(permid)
     if perm is None:
         raise JSONRPCError('permission `%s` does not exist' % (permid,))
     if prefix:
         if not perm.permission_name.startswith(prefix):
             raise JSONRPCError('permission `%s` is invalid, '
                                'should start with %s' % (permid, prefix))
     return perm
 
 
 def get_gist_or_error(gistid):
     """
     Get gist by id or gist_access_id or return JsonRPCError if not found
 
     :param gistid:
     """
     from rhodecode.model.gist import GistModel
 
     gist = GistModel.cls.get_by_access_id(gistid)
     if gist is None:
         raise JSONRPCError('gist `%s` does not exist' % (gistid,))
     return gist
 
 
 def get_pull_request_or_error(pullrequestid):
     """
     Get pull request by id or return JsonRPCError if not found
 
     :param pullrequestid:
     """
     from rhodecode.model.pull_request import PullRequestModel
 
     try:
         pull_request = PullRequestModel().get(int(pullrequestid))
     except ValueError:
         raise JSONRPCError('pullrequestid must be an integer')
     if not pull_request:
         raise JSONRPCError('pull request `%s` does not exist' % (
             pullrequestid,))
     return pull_request
 
 
 def build_commit_data(commit, detail_level):
     parsed_diff = []
     if detail_level == 'extended':
         for f in commit.added:
             parsed_diff.append(_get_commit_dict(filename=f.path, op='A'))
         for f in commit.changed:
             parsed_diff.append(_get_commit_dict(filename=f.path, op='M'))
         for f in commit.removed:
             parsed_diff.append(_get_commit_dict(filename=f.path, op='D'))
 
     elif detail_level == 'full':
         from rhodecode.lib.diffs import DiffProcessor
         diff_processor = DiffProcessor(commit.diff())
         for dp in diff_processor.prepare():
             del dp['stats']['ops']
             _stats = dp['stats']
             parsed_diff.append(_get_commit_dict(
                 filename=dp['filename'], op=dp['operation'],
                 new_revision=dp['new_revision'],
                 old_revision=dp['old_revision'],
                 raw_diff=dp['raw_diff'], stats=_stats))
 
     return parsed_diff
 
 
 def get_commit_or_error(ref, repo):
     try:
         ref_type, _, ref_hash = ref.split(':')
     except ValueError:
         raise JSONRPCError(
             'Ref `{ref}` given in a wrong format. Please check the API'
             ' documentation for more details'.format(ref=ref))
     try:
         # TODO: dan: refactor this to use repo.scm_instance().get_commit()
         # once get_commit supports ref_types
         return get_commit_from_ref_name(repo, ref_hash)
     except RepositoryError:
         raise JSONRPCError('Ref `{ref}` does not exist'.format(ref=ref))
 
 
 def resolve_ref_or_error(ref, repo):
     def _parse_ref(type_, name, hash_=None):
         return type_, name, hash_
 
     try:
         ref_type, ref_name, ref_hash = _parse_ref(*ref.split(':'))
     except TypeError:
         raise JSONRPCError(
             'Ref `{ref}` given in a wrong format. Please check the API'
             ' documentation for more details'.format(ref=ref))
 
     try:
         ref_hash = ref_hash or _get_ref_hash(repo, ref_type, ref_name)
     except (KeyError, ValueError):
         raise JSONRPCError(
             'The specified {type} `{name}` does not exist'.format(
                 type=ref_type, name=ref_name))
 
     return ':'.join([ref_type, ref_name, ref_hash])
 
 
 def _get_commit_dict(
         filename, op, new_revision=None, old_revision=None,
         raw_diff=None, stats=None):
     if stats is None:
         stats = {
             "added": None,
             "binary": None,
             "deleted": None
         }
     return {
         "filename": safe_unicode(filename),
         "op": op,
 
         # extra details
         "new_revision": new_revision,
         "old_revision": old_revision,
 
         "raw_diff": raw_diff,
         "stats": stats
     }
 
 
 # TODO: mikhail: Think about moving this function to some library
 def _get_ref_hash(repo, type_, name):
     vcs_repo = repo.scm_instance()
     if type_ == 'branch' and vcs_repo.alias in ('hg', 'git'):
         return vcs_repo.branches[name]
     elif type_ == 'bookmark' and vcs_repo.alias == 'hg':
         return vcs_repo.bookmarks[name]
     else:
         raise ValueError()

rhodecode/api/views/__init__.py

@@ -1,19 +1,19 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2015-2017 RhodeCode GmbH
+# Copyright (C) 2015-2018 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/

rhodecode/api/views/deprecated_api.py

@@ -1,102 +1,102 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2011-2017 RhodeCode GmbH
+# Copyright (C) 2011-2018 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/
 
 
 """
 NOTE:
     Place for deprecated APIs here, if a call needs to be deprecated, please
     put it here, and point to a new version
 """
 import logging
 
 from rhodecode.api import jsonrpc_method, jsonrpc_deprecated_method
 from rhodecode.api.utils import Optional, OAttr
 
 
 log = logging.getLogger(__name__)
 
 
 # permission check inside
 @jsonrpc_method()
 @jsonrpc_deprecated_method(
     use_method='comment_commit', deprecated_at_version='3.4.0')
 def changeset_comment(request, apiuser, repoid, revision, message,
                       userid=Optional(OAttr('apiuser')),
                       status=Optional(None)):
     """
     Set a changeset comment, and optionally change the status of the
     changeset.
 
     This command can only be run using an |authtoken| with admin
     permissions on the |repo|.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: Set the repository name or repository ID.
     :type repoid: str or int
     :param revision: Specify the revision for which to set a comment.
     :type revision: str
     :param message: The comment text.
     :type message: str
     :param userid: Set the user name of the comment creator.
     :type userid: Optional(str or int)
     :param status: Set the comment status. The following are valid options:
         * not_reviewed
         * approved
         * rejected
         * under_review
     :type status: str
 
     Example error output:
 
     .. code-block:: json
 
         {
             "id" : <id_given_in_input>,
             "result" : {
                 "msg": "Commented on commit `<revision>` for repository `<repoid>`",
                 "status_change": null or <status>,
                 "success": true
             },
             "error" : null
         }
 
     """
     from .repo_api import comment_commit
 
     return comment_commit(request=request,
         apiuser=apiuser, repoid=repoid, commit_id=revision,
         message=message, userid=userid, status=status)
 
 
 @jsonrpc_method()
 @jsonrpc_deprecated_method(
     use_method='get_ip', deprecated_at_version='4.0.0')
 def show_ip(request, apiuser, userid=Optional(OAttr('apiuser'))):
     from .server_api import get_ip
     return get_ip(request=request, apiuser=apiuser, userid=userid)
 
 
 @jsonrpc_method()
 @jsonrpc_deprecated_method(
     use_method='get_user_locks', deprecated_at_version='4.0.0')
 def get_locks(request, apiuser, userid=Optional(OAttr('apiuser'))):
     from .user_api import get_user_locks
     return get_user_locks(request=request, apiuser=apiuser, userid=userid)
  No newline at end of file

rhodecode/api/views/gist_api.py

@@ -1,255 +1,255 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2011-2017 RhodeCode GmbH
+# Copyright (C) 2011-2018 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 logging
 import time
 
 from rhodecode.api import jsonrpc_method, JSONRPCError
 from rhodecode.api.exc import JSONRPCValidationError
 from rhodecode.api.utils import (
     Optional, OAttr, get_gist_or_error, get_user_or_error,
     has_superadmin_permission)
 from rhodecode.model.db import Session, or_
 from rhodecode.model.gist import Gist, GistModel
 
 log = logging.getLogger(__name__)
 
 
 @jsonrpc_method()
 def get_gist(request, apiuser, gistid, content=Optional(False)):
     """
     Get the specified gist, based on the gist ID.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param gistid: Set the id of the private or public gist
     :type gistid: str
     :param content: Return the gist content. Default is false.
     :type content: Optional(bool)
     """
 
     gist = get_gist_or_error(gistid)
     content = Optional.extract(content)
     if not has_superadmin_permission(apiuser):
         if gist.gist_owner != apiuser.user_id:
             raise JSONRPCError('gist `%s` does not exist' % (gistid,))
     data = gist.get_api_data()
     if content:
         from rhodecode.model.gist import GistModel
         rev, gist_files = GistModel().get_gist_files(gistid)
         data['content'] = dict([(x.path, x.content) for x in gist_files])
     return data
 
 
 @jsonrpc_method()
 def get_gists(request, apiuser, userid=Optional(OAttr('apiuser'))):
     """
     Get all gists for given user. If userid is empty returned gists
     are for user who called the api
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param userid: user to get gists for
     :type userid: Optional(str or int)
     """
 
     if not has_superadmin_permission(apiuser):
         # make sure normal user does not pass someone else userid,
         # he is not allowed to do that
         if not isinstance(userid, Optional) and userid != apiuser.user_id:
             raise JSONRPCError(
                 'userid is not the same as your user'
             )
 
     if isinstance(userid, Optional):
         user_id = apiuser.user_id
     else:
         user_id = get_user_or_error(userid).user_id
 
     gists = []
     _gists = Gist().query() \
         .filter(or_(
         Gist.gist_expires == -1, Gist.gist_expires >= time.time())) \
         .filter(Gist.gist_owner == user_id) \
         .order_by(Gist.created_on.desc())
     for gist in _gists:
         gists.append(gist.get_api_data())
     return gists
 
 
 @jsonrpc_method()
 def create_gist(
         request, apiuser, files, gistid=Optional(None),
         owner=Optional(OAttr('apiuser')),
         gist_type=Optional(Gist.GIST_PUBLIC), lifetime=Optional(-1),
         acl_level=Optional(Gist.ACL_LEVEL_PUBLIC),
         description=Optional('')):
     """
     Creates a new Gist.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param files: files to be added to the gist. The data structure has
         to match the following example::
 
           {'filename1': {'content':'...'}, 'filename2': {'content':'...'}}
 
     :type files: dict
     :param gistid: Set a custom id for the gist
     :type gistid: Optional(str)
     :param owner: Set the gist owner, defaults to api method caller
     :type owner: Optional(str or int)
     :param gist_type: type of gist ``public`` or ``private``
     :type gist_type: Optional(str)
     :param lifetime: time in minutes of gist lifetime
     :type lifetime: Optional(int)
     :param acl_level: acl level for this gist, can be
         ``acl_public`` or ``acl_private`` If the value is set to
         ``acl_private`` only logged in users are able to access this gist.
         If not set it defaults to ``acl_public``.
     :type acl_level: Optional(str)
     :param description: gist description
     :type description: Optional(str)
 
     Example  output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : {
         "msg": "created new gist",
         "gist": {}
       }
       error :  null
 
     Example error output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : null
       error :  {
         "failed to create gist"
       }
 
     """
     from rhodecode.model import validation_schema
     from rhodecode.model.validation_schema.schemas import gist_schema
 
     if isinstance(owner, Optional):
         owner = apiuser.user_id
 
     owner = get_user_or_error(owner)
 
     lifetime = Optional.extract(lifetime)
     schema = gist_schema.GistSchema().bind(
         # bind the given values if it's allowed, however the deferred
         # validator will still validate it according to other rules
         lifetime_options=[lifetime])
 
     try:
         nodes = gist_schema.nodes_to_sequence(
             files, colander_node=schema.get('nodes'))
 
         schema_data = schema.deserialize(dict(
             gistid=Optional.extract(gistid),
             description=Optional.extract(description),
             gist_type=Optional.extract(gist_type),
             lifetime=lifetime,
             gist_acl_level=Optional.extract(acl_level),
             nodes=nodes
         ))
 
         # convert to safer format with just KEYs so we sure no duplicates
         schema_data['nodes'] = gist_schema.sequence_to_nodes(
             schema_data['nodes'], colander_node=schema.get('nodes'))
 
     except validation_schema.Invalid as err:
         raise JSONRPCValidationError(colander_exc=err)
 
     try:
         gist = GistModel().create(
             owner=owner,
             gist_id=schema_data['gistid'],
             description=schema_data['description'],
             gist_mapping=schema_data['nodes'],
             gist_type=schema_data['gist_type'],
             lifetime=schema_data['lifetime'],
             gist_acl_level=schema_data['gist_acl_level'])
         Session().commit()
         return {
             'msg': 'created new gist',
             'gist': gist.get_api_data()
         }
     except Exception:
         log.exception('Error occurred during creation of gist')
         raise JSONRPCError('failed to create gist')
 
 
 @jsonrpc_method()
 def delete_gist(request, apiuser, gistid):
     """
     Deletes existing gist
 
     :param apiuser: filled automatically from apikey
     :type apiuser: AuthUser
     :param gistid: id of gist to delete
     :type gistid: str
 
     Example output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : {
         "deleted gist ID: <gist_id>",
         "gist": null
       }
       error :  null
 
     Example error output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : null
       error :  {
         "failed to delete gist ID:<gist_id>"
       }
 
     """
 
     gist = get_gist_or_error(gistid)
     if not has_superadmin_permission(apiuser):
         if gist.gist_owner != apiuser.user_id:
             raise JSONRPCError('gist `%s` does not exist' % (gistid,))
 
     try:
         GistModel().delete(gist)
         Session().commit()
         return {
             'msg': 'deleted gist ID:%s' % (gist.gist_access_id,),
             'gist': None
         }
     except Exception:
         log.exception('Error occured during gist deletion')
         raise JSONRPCError('failed to delete gist ID:%s'
                            % (gist.gist_access_id,))
  No newline at end of file

rhodecode/api/views/pull_request_api.py

@@ -1,903 +1,903 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2011-2017 RhodeCode GmbH
+# Copyright (C) 2011-2018 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 logging
 
 from rhodecode import events
 from rhodecode.api import jsonrpc_method, JSONRPCError, JSONRPCValidationError
 from rhodecode.api.utils import (
     has_superadmin_permission, Optional, OAttr, get_repo_or_error,
     get_pull_request_or_error, get_commit_or_error, get_user_or_error,
     validate_repo_permissions, resolve_ref_or_error)
 from rhodecode.lib.auth import (HasRepoPermissionAnyApi)
 from rhodecode.lib.base import vcs_operation_context
 from rhodecode.lib.utils2 import str2bool
 from rhodecode.model.changeset_status import ChangesetStatusModel
 from rhodecode.model.comment import CommentsModel
 from rhodecode.model.db import Session, ChangesetStatus, ChangesetComment
 from rhodecode.model.pull_request import PullRequestModel, MergeCheck
 from rhodecode.model.settings import SettingsModel
 from rhodecode.model.validation_schema import Invalid
 from rhodecode.model.validation_schema.schemas.reviewer_schema import(
     ReviewerListSchema)
 
 log = logging.getLogger(__name__)
 
 
 @jsonrpc_method()
 def get_pull_request(request, apiuser, pullrequestid, repoid=Optional(None)):
     """
     Get a pull request based on the given ID.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: Optional, repository name or repository ID from where
         the pull request was opened.
     :type repoid: str or int
     :param pullrequestid: ID of the requested pull request.
     :type pullrequestid: int
 
     Example output:
 
     .. code-block:: bash
 
       "id": <id_given_in_input>,
       "result":
         {
             "pull_request_id":   "<pull_request_id>",
             "url":               "<url>",
             "title":             "<title>",
             "description":       "<description>",
             "status" :           "<status>",
             "created_on":        "<date_time_created>",
             "updated_on":        "<date_time_updated>",
             "commit_ids":        [
                                      ...
                                      "<commit_id>",
                                      "<commit_id>",
                                      ...
                                  ],
             "review_status":    "<review_status>",
             "mergeable":         {
                                      "status":  "<bool>",
                                      "message": "<message>",
                                  },
             "source":            {
                                      "clone_url":     "<clone_url>",
                                      "repository":    "<repository_name>",
                                      "reference":
                                      {
                                          "name":      "<name>",
                                          "type":      "<type>",
                                          "commit_id": "<commit_id>",
                                      }
                                  },
             "target":            {
                                      "clone_url":   "<clone_url>",
                                      "repository":    "<repository_name>",
                                      "reference":
                                      {
                                          "name":      "<name>",
                                          "type":      "<type>",
                                          "commit_id": "<commit_id>",
                                      }
                                  },
             "merge":             {
                                      "clone_url":   "<clone_url>",
                                      "reference":
                                      {
                                          "name":      "<name>",
                                          "type":      "<type>",
                                          "commit_id": "<commit_id>",
                                      }
                                  },
            "author":             <user_obj>,
            "reviewers":          [
                                      ...
                                      {
                                         "user":          "<user_obj>",
                                         "review_status": "<review_status>",
                                      }
                                      ...
                                  ]
         },
        "error": null
     """
 
     pull_request = get_pull_request_or_error(pullrequestid)
     if Optional.extract(repoid):
         repo = get_repo_or_error(repoid)
     else:
         repo = pull_request.target_repo
 
     if not PullRequestModel().check_user_read(
             pull_request, apiuser, api=True):
         raise JSONRPCError('repository `%s` or pull request `%s` '
                            'does not exist' % (repoid, pullrequestid))
     data = pull_request.get_api_data()
     return data
 
 
 @jsonrpc_method()
 def get_pull_requests(request, apiuser, repoid, status=Optional('new')):
     """
     Get all pull requests from the repository specified in `repoid`.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: Optional repository name or repository ID.
     :type repoid: str or int
     :param status: Only return pull requests with the specified status.
         Valid options are.
         * ``new`` (default)
         * ``open``
         * ``closed``
     :type status: str
 
     Example output:
 
     .. code-block:: bash
 
       "id": <id_given_in_input>,
       "result":
         [
             ...
             {
                 "pull_request_id":   "<pull_request_id>",
                 "url":               "<url>",
                 "title" :            "<title>",
                 "description":       "<description>",
                 "status":            "<status>",
                 "created_on":        "<date_time_created>",
                 "updated_on":        "<date_time_updated>",
                 "commit_ids":        [
                                          ...
                                          "<commit_id>",
                                          "<commit_id>",
                                          ...
                                      ],
                 "review_status":    "<review_status>",
                 "mergeable":         {
                                         "status":      "<bool>",
                                         "message:      "<message>",
                                      },
                 "source":            {
                                          "clone_url":     "<clone_url>",
                                          "reference":
                                          {
                                              "name":      "<name>",
                                              "type":      "<type>",
                                              "commit_id": "<commit_id>",
                                          }
                                      },
                 "target":            {
                                          "clone_url":   "<clone_url>",
                                          "reference":
                                          {
                                              "name":      "<name>",
                                              "type":      "<type>",
                                              "commit_id": "<commit_id>",
                                          }
                                      },
                 "merge":             {
                                          "clone_url":   "<clone_url>",
                                          "reference":
                                          {
                                              "name":      "<name>",
                                              "type":      "<type>",
                                              "commit_id": "<commit_id>",
                                          }
                                      },
                "author":             <user_obj>,
                "reviewers":          [
                                          ...
                                          {
                                             "user":          "<user_obj>",
                                             "review_status": "<review_status>",
                                          }
                                          ...
                                      ]
             }
             ...
         ],
       "error": null
 
     """
     repo = get_repo_or_error(repoid)
     if not has_superadmin_permission(apiuser):
         _perms = (
             'repository.admin', 'repository.write', 'repository.read',)
         validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     status = Optional.extract(status)
     pull_requests = PullRequestModel().get_all(repo, statuses=[status])
     data = [pr.get_api_data() for pr in pull_requests]
     return data
 
 
 @jsonrpc_method()
 def merge_pull_request(
         request, apiuser, pullrequestid, repoid=Optional(None),
         userid=Optional(OAttr('apiuser'))):
     """
     Merge the pull request specified by `pullrequestid` into its target
     repository.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: Optional, repository name or repository ID of the
         target repository to which the |pr| is to be merged.
     :type repoid: str or int
     :param pullrequestid: ID of the pull request which shall be merged.
     :type pullrequestid: int
     :param userid: Merge the pull request as this user.
     :type userid: Optional(str or int)
 
     Example output:
 
     .. code-block:: bash
 
         "id": <id_given_in_input>,
         "result": {
             "executed":         "<bool>",
             "failure_reason":   "<int>",
             "merge_commit_id":  "<merge_commit_id>",
             "possible":         "<bool>",
             "merge_ref":        {
                                     "commit_id": "<commit_id>",
                                     "type":      "<type>",
                                     "name":      "<name>"
                                 }
         },
         "error": null
     """
     pull_request = get_pull_request_or_error(pullrequestid)
     if Optional.extract(repoid):
         repo = get_repo_or_error(repoid)
     else:
         repo = pull_request.target_repo
 
     if not isinstance(userid, Optional):
         if (has_superadmin_permission(apiuser) or
                 HasRepoPermissionAnyApi('repository.admin')(
                     user=apiuser, repo_name=repo.repo_name)):
             apiuser = get_user_or_error(userid)
         else:
             raise JSONRPCError('userid is not the same as your user')
 
     check = MergeCheck.validate(
         pull_request, user=apiuser, translator=request.translate)
     merge_possible = not check.failed
 
     if not merge_possible:
         error_messages = []
         for err_type, error_msg in check.errors:
             error_msg = request.translate(error_msg)
             error_messages.append(error_msg)
 
         reasons = ','.join(error_messages)
         raise JSONRPCError(
             'merge not possible for following reasons: {}'.format(reasons))
 
     target_repo = pull_request.target_repo
     extras = vcs_operation_context(
         request.environ, repo_name=target_repo.repo_name,
         username=apiuser.username, action='push',
         scm=target_repo.repo_type)
     merge_response = PullRequestModel().merge(
         pull_request, apiuser, extras=extras)
     if merge_response.executed:
         PullRequestModel().close_pull_request(
             pull_request.pull_request_id, apiuser)
 
         Session().commit()
 
     # In previous versions the merge response directly contained the merge
     # commit id. It is now contained in the merge reference object. To be
     # backwards compatible we have to extract it again.
     merge_response = merge_response._asdict()
     merge_response['merge_commit_id'] = merge_response['merge_ref'].commit_id
 
     return merge_response
 
 
 @jsonrpc_method()
 def get_pull_request_comments(
         request, apiuser, pullrequestid, repoid=Optional(None)):
     """
     Get all comments of pull request specified with the `pullrequestid`
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: Optional repository name or repository ID.
     :type repoid: str or int
     :param pullrequestid: The pull request ID.
     :type pullrequestid: int
 
     Example output:
 
     .. code-block:: bash
 
         id : <id_given_in_input>
         result : [
             {
               "comment_author": {
                 "active": true,
                 "full_name_or_username": "Tom Gore",
                 "username": "admin"
               },
               "comment_created_on": "2017-01-02T18:43:45.533",
               "comment_f_path": null,
               "comment_id": 25,
               "comment_lineno": null,
               "comment_status": {
                 "status": "under_review",
                 "status_lbl": "Under Review"
               },
               "comment_text": "Example text",
               "comment_type": null,
               "pull_request_version": null
             }
         ],
         error :  null
     """
 
     pull_request = get_pull_request_or_error(pullrequestid)
     if Optional.extract(repoid):
         repo = get_repo_or_error(repoid)
     else:
         repo = pull_request.target_repo
 
     if not PullRequestModel().check_user_read(
             pull_request, apiuser, api=True):
         raise JSONRPCError('repository `%s` or pull request `%s` '
                            'does not exist' % (repoid, pullrequestid))
 
     (pull_request_latest,
      pull_request_at_ver,
      pull_request_display_obj,
      at_version) = PullRequestModel().get_pr_version(
         pull_request.pull_request_id, version=None)
 
     versions = pull_request_display_obj.versions()
     ver_map = {
         ver.pull_request_version_id: cnt
         for cnt, ver in enumerate(versions, 1)
     }
 
     # GENERAL COMMENTS with versions #
     q = CommentsModel()._all_general_comments_of_pull_request(pull_request)
     q = q.order_by(ChangesetComment.comment_id.asc())
     general_comments = q.all()
 
     # INLINE COMMENTS with versions  #
     q = CommentsModel()._all_inline_comments_of_pull_request(pull_request)
     q = q.order_by(ChangesetComment.comment_id.asc())
     inline_comments = q.all()
 
     data = []
     for comment in inline_comments + general_comments:
         full_data = comment.get_api_data()
         pr_version_id = None
         if comment.pull_request_version_id:
             pr_version_id = 'v{}'.format(
                 ver_map[comment.pull_request_version_id])
 
         # sanitize some entries
 
         full_data['pull_request_version'] = pr_version_id
         full_data['comment_author'] = {
             'username': full_data['comment_author'].username,
             'full_name_or_username': full_data['comment_author'].full_name_or_username,
             'active': full_data['comment_author'].active,
         }
 
         if full_data['comment_status']:
             full_data['comment_status'] = {
                 'status': full_data['comment_status'][0].status,
                 'status_lbl': full_data['comment_status'][0].status_lbl,
             }
         else:
             full_data['comment_status'] = {}
 
         data.append(full_data)
     return data
 
 
 @jsonrpc_method()
 def comment_pull_request(
         request, apiuser, pullrequestid, repoid=Optional(None),
         message=Optional(None), commit_id=Optional(None), status=Optional(None),
         comment_type=Optional(ChangesetComment.COMMENT_TYPE_NOTE),
         resolves_comment_id=Optional(None),
         userid=Optional(OAttr('apiuser'))):
     """
     Comment on the pull request specified with the `pullrequestid`,
     in the |repo| specified by the `repoid`, and optionally change the
     review status.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: Optional repository name or repository ID.
     :type repoid: str or int
     :param pullrequestid: The pull request ID.
     :type pullrequestid: int
     :param commit_id: Specify the commit_id for which to set a comment. If
         given commit_id is different than latest in the PR status
         change won't be performed.
     :type commit_id: str
     :param message: The text content of the comment.
     :type message: str
     :param status: (**Optional**) Set the approval status of the pull
         request. One of: 'not_reviewed', 'approved', 'rejected',
         'under_review'
     :type status: str
     :param comment_type: Comment type, one of: 'note', 'todo'
     :type comment_type: Optional(str), default: 'note'
     :param userid: Comment on the pull request as this user
     :type userid: Optional(str or int)
 
     Example output:
 
     .. code-block:: bash
 
         id : <id_given_in_input>
         result : {
             "pull_request_id":  "<Integer>",
             "comment_id":       "<Integer>",
             "status": {"given": <given_status>,
                        "was_changed": <bool status_was_actually_changed> },
         },
         error :  null
     """
     pull_request = get_pull_request_or_error(pullrequestid)
     if Optional.extract(repoid):
         repo = get_repo_or_error(repoid)
     else:
         repo = pull_request.target_repo
 
     if not isinstance(userid, Optional):
         if (has_superadmin_permission(apiuser) or
                 HasRepoPermissionAnyApi('repository.admin')(
                     user=apiuser, repo_name=repo.repo_name)):
             apiuser = get_user_or_error(userid)
         else:
             raise JSONRPCError('userid is not the same as your user')
 
     if not PullRequestModel().check_user_read(
             pull_request, apiuser, api=True):
         raise JSONRPCError('repository `%s` does not exist' % (repoid,))
     message = Optional.extract(message)
     status = Optional.extract(status)
     commit_id = Optional.extract(commit_id)
     comment_type = Optional.extract(comment_type)
     resolves_comment_id = Optional.extract(resolves_comment_id)
 
     if not message and not status:
         raise JSONRPCError(
             'Both message and status parameters are missing. '
             'At least one is required.')
 
     if (status not in (st[0] for st in ChangesetStatus.STATUSES) and
             status is not None):
         raise JSONRPCError('Unknown comment status: `%s`' % status)
 
     if commit_id and commit_id not in pull_request.revisions:
         raise JSONRPCError(
             'Invalid commit_id `%s` for this pull request.' % commit_id)
 
     allowed_to_change_status = PullRequestModel().check_user_change_status(
         pull_request, apiuser)
 
     # if commit_id is passed re-validated if user is allowed to change status
     # based on latest commit_id from the PR
     if commit_id:
         commit_idx = pull_request.revisions.index(commit_id)
         if commit_idx != 0:
             allowed_to_change_status = False
 
     if resolves_comment_id:
         comment = ChangesetComment.get(resolves_comment_id)
         if not comment:
             raise JSONRPCError(
                 'Invalid resolves_comment_id `%s` for this pull request.'
                 % resolves_comment_id)
         if comment.comment_type != ChangesetComment.COMMENT_TYPE_TODO:
             raise JSONRPCError(
                 'Comment `%s` is wrong type for setting status to resolved.'
                 % resolves_comment_id)
 
     text = message
     status_label = ChangesetStatus.get_status_lbl(status)
     if status and allowed_to_change_status:
         st_message = ('Status change %(transition_icon)s %(status)s'
                       % {'transition_icon': '>', 'status': status_label})
         text = message or st_message
 
     rc_config = SettingsModel().get_all_settings()
     renderer = rc_config.get('rhodecode_markup_renderer', 'rst')
 
     status_change = status and allowed_to_change_status
     comment = CommentsModel().create(
         text=text,
         repo=pull_request.target_repo.repo_id,
         user=apiuser.user_id,
         pull_request=pull_request.pull_request_id,
         f_path=None,
         line_no=None,
         status_change=(status_label if status_change else None),
         status_change_type=(status if status_change else None),
         closing_pr=False,
         renderer=renderer,
         comment_type=comment_type,
         resolves_comment_id=resolves_comment_id
     )
 
     if allowed_to_change_status and status:
         ChangesetStatusModel().set_status(
             pull_request.target_repo.repo_id,
             status,
             apiuser.user_id,
             comment,
             pull_request=pull_request.pull_request_id
         )
         Session().flush()
 
     Session().commit()
     data = {
         'pull_request_id': pull_request.pull_request_id,
         'comment_id': comment.comment_id if comment else None,
         'status': {'given': status, 'was_changed': status_change},
     }
     return data
 
 
 @jsonrpc_method()
 def create_pull_request(
         request, apiuser, source_repo, target_repo, source_ref, target_ref,
         title, description=Optional(''), reviewers=Optional(None)):
     """
     Creates a new pull request.
 
     Accepts refs in the following formats:
 
         * branch:<branch_name>:<sha>
         * branch:<branch_name>
         * bookmark:<bookmark_name>:<sha> (Mercurial only)
         * bookmark:<bookmark_name> (Mercurial only)
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param source_repo: Set the source repository name.
     :type source_repo: str
     :param target_repo: Set the target repository name.
     :type target_repo: str
     :param source_ref: Set the source ref name.
     :type source_ref: str
     :param target_ref: Set the target ref name.
     :type target_ref: str
     :param title: Set the pull request title.
     :type title: str
     :param description: Set the pull request description.
     :type description: Optional(str)
     :param reviewers: Set the new pull request reviewers list.
         Reviewer defined by review rules will be added automatically to the
         defined list.
     :type reviewers: Optional(list)
         Accepts username strings or objects of the format:
 
             [{'username': 'nick', 'reasons': ['original author'], 'mandatory': <bool>}]
     """
 
     source_db_repo =  get_repo_or_error(source_repo)
     target_db_repo = get_repo_or_error(target_repo)
     if not has_superadmin_permission(apiuser):
         _perms = ('repository.admin', 'repository.write', 'repository.read',)
         validate_repo_permissions(apiuser, source_repo, source_db_repo, _perms)
 
     full_source_ref = resolve_ref_or_error(source_ref, source_db_repo)
     full_target_ref = resolve_ref_or_error(target_ref, target_db_repo)
     source_commit = get_commit_or_error(full_source_ref, source_db_repo)
     target_commit = get_commit_or_error(full_target_ref, target_db_repo)
     source_scm = source_db_repo.scm_instance()
     target_scm = target_db_repo.scm_instance()
 
     commit_ranges = target_scm.compare(
         target_commit.raw_id, source_commit.raw_id, source_scm,
         merge=True, pre_load=[])
 
     ancestor = target_scm.get_common_ancestor(
         target_commit.raw_id, source_commit.raw_id, source_scm)
 
     if not commit_ranges:
         raise JSONRPCError('no commits found')
 
     if not ancestor:
         raise JSONRPCError('no common ancestor found')
 
     reviewer_objects = Optional.extract(reviewers) or []
 
     if reviewer_objects:
         schema = ReviewerListSchema()
         try:
             reviewer_objects = schema.deserialize(reviewer_objects)
         except Invalid as err:
             raise JSONRPCValidationError(colander_exc=err)
 
         # validate users
         for reviewer_object in reviewer_objects:
             user = get_user_or_error(reviewer_object['username'])
             reviewer_object['user_id'] = user.user_id
 
     get_default_reviewers_data, get_validated_reviewers = \
         PullRequestModel().get_reviewer_functions()
 
     reviewer_rules = get_default_reviewers_data(
         apiuser.get_instance(), source_db_repo,
         source_commit, target_db_repo, target_commit)
 
     # specified rules are later re-validated, thus we can assume users will
     # eventually provide those that meet the reviewer criteria.
     if not reviewer_objects:
         reviewer_objects = reviewer_rules['reviewers']
 
     try:
         reviewers = get_validated_reviewers(
             reviewer_objects, reviewer_rules)
     except ValueError as e:
         raise JSONRPCError('Reviewers Validation: {}'.format(e))
 
     pull_request_model = PullRequestModel()
     pull_request = pull_request_model.create(
         created_by=apiuser.user_id,
         source_repo=source_repo,
         source_ref=full_source_ref,
         target_repo=target_repo,
         target_ref=full_target_ref,
         revisions=reversed(
             [commit.raw_id for commit in reversed(commit_ranges)]),
         reviewers=reviewers,
         title=title,
         description=Optional.extract(description)
     )
 
     Session().commit()
     data = {
         'msg': 'Created new pull request `{}`'.format(title),
         'pull_request_id': pull_request.pull_request_id,
     }
     return data
 
 
 @jsonrpc_method()
 def update_pull_request(
         request, apiuser, pullrequestid, repoid=Optional(None),
         title=Optional(''), description=Optional(''), reviewers=Optional(None),
         update_commits=Optional(None)):
     """
     Updates a pull request.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: Optional repository name or repository ID.
     :type repoid: str or int
     :param pullrequestid: The pull request ID.
     :type pullrequestid: int
     :param title: Set the pull request title.
     :type title: str
     :param description: Update pull request description.
     :type description: Optional(str)
     :param reviewers: Update pull request reviewers list with new value.
     :type reviewers: Optional(list)
         Accepts username strings or objects of the format:
 
             [{'username': 'nick', 'reasons': ['original author'], 'mandatory': <bool>}]
 
     :param update_commits: Trigger update of commits for this pull request
     :type: update_commits: Optional(bool)
 
     Example output:
 
     .. code-block:: bash
 
         id : <id_given_in_input>
         result : {
             "msg": "Updated pull request `63`",
             "pull_request": <pull_request_object>,
             "updated_reviewers": {
               "added": [
                 "username"
               ],
               "removed": []
             },
             "updated_commits": {
               "added": [
                 "<sha1_hash>"
               ],
               "common": [
                 "<sha1_hash>",
                 "<sha1_hash>",
               ],
               "removed": []
             }
         }
         error :  null
     """
 
     pull_request = get_pull_request_or_error(pullrequestid)
     if Optional.extract(repoid):
         repo = get_repo_or_error(repoid)
     else:
         repo = pull_request.target_repo
 
     if not PullRequestModel().check_user_update(
             pull_request, apiuser, api=True):
         raise JSONRPCError(
             'pull request `%s` update failed, no permission to update.' % (
                 pullrequestid,))
     if pull_request.is_closed():
         raise JSONRPCError(
             'pull request `%s` update failed, pull request is closed' % (
                 pullrequestid,))
 
     reviewer_objects = Optional.extract(reviewers) or []
 
     if reviewer_objects:
         schema = ReviewerListSchema()
         try:
             reviewer_objects = schema.deserialize(reviewer_objects)
         except Invalid as err:
             raise JSONRPCValidationError(colander_exc=err)
 
         # validate users
         for reviewer_object in reviewer_objects:
             user = get_user_or_error(reviewer_object['username'])
             reviewer_object['user_id'] = user.user_id
 
         get_default_reviewers_data, get_validated_reviewers = \
             PullRequestModel().get_reviewer_functions()
 
         # re-use stored rules
         reviewer_rules = pull_request.reviewer_data
         try:
             reviewers = get_validated_reviewers(
                 reviewer_objects, reviewer_rules)
         except ValueError as e:
             raise JSONRPCError('Reviewers Validation: {}'.format(e))
     else:
         reviewers = []
 
     title = Optional.extract(title)
     description = Optional.extract(description)
     if title or description:
         PullRequestModel().edit(
             pull_request, title or pull_request.title,
             description or pull_request.description, apiuser)
         Session().commit()
 
     commit_changes = {"added": [], "common": [], "removed": []}
     if str2bool(Optional.extract(update_commits)):
         if PullRequestModel().has_valid_update_type(pull_request):
             update_response = PullRequestModel().update_commits(
                 pull_request)
             commit_changes = update_response.changes or commit_changes
         Session().commit()
 
     reviewers_changes = {"added": [], "removed": []}
     if reviewers:
         added_reviewers, removed_reviewers = \
             PullRequestModel().update_reviewers(pull_request, reviewers, apiuser)
 
         reviewers_changes['added'] = sorted(
             [get_user_or_error(n).username for n in added_reviewers])
         reviewers_changes['removed'] = sorted(
             [get_user_or_error(n).username for n in removed_reviewers])
         Session().commit()
 
     data = {
         'msg': 'Updated pull request `{}`'.format(
             pull_request.pull_request_id),
         'pull_request': pull_request.get_api_data(),
         'updated_commits': commit_changes,
         'updated_reviewers': reviewers_changes
     }
 
     return data
 
 
 @jsonrpc_method()
 def close_pull_request(
         request, apiuser, pullrequestid, repoid=Optional(None),
         userid=Optional(OAttr('apiuser')), message=Optional('')):
     """
     Close the pull request specified by `pullrequestid`.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: Repository name or repository ID to which the pull
         request belongs.
     :type repoid: str or int
     :param pullrequestid: ID of the pull request to be closed.
     :type pullrequestid: int
     :param userid: Close the pull request as this user.
     :type userid: Optional(str or int)
     :param message: Optional message to close the Pull Request with. If not
         specified it will be generated automatically.
     :type message: Optional(str)
 
     Example output:
 
     .. code-block:: bash
 
         "id": <id_given_in_input>,
         "result": {
             "pull_request_id":  "<int>",
             "close_status":     "<str:status_lbl>,
             "closed":           "<bool>"
         },
         "error": null
 
     """
     _ = request.translate
 
     pull_request = get_pull_request_or_error(pullrequestid)
     if Optional.extract(repoid):
         repo = get_repo_or_error(repoid)
     else:
         repo = pull_request.target_repo
 
     if not isinstance(userid, Optional):
         if (has_superadmin_permission(apiuser) or
                 HasRepoPermissionAnyApi('repository.admin')(
                     user=apiuser, repo_name=repo.repo_name)):
             apiuser = get_user_or_error(userid)
         else:
             raise JSONRPCError('userid is not the same as your user')
 
     if pull_request.is_closed():
         raise JSONRPCError(
             'pull request `%s` is already closed' % (pullrequestid,))
 
     # only owner or admin or person with write permissions
     allowed_to_close = PullRequestModel().check_user_update(
             pull_request, apiuser, api=True)
 
     if not allowed_to_close:
         raise JSONRPCError(
             'pull request `%s` close failed, no permission to close.' % (
                 pullrequestid,))
 
     # message we're using to close the PR, else it's automatically generated
     message = Optional.extract(message)
 
     # finally close the PR, with proper message comment
     comment, status = PullRequestModel().close_pull_request_with_comment(
         pull_request, apiuser, repo, message=message)
     status_lbl = ChangesetStatus.get_status_lbl(status)
 
     Session().commit()
 
     data = {
         'pull_request_id': pull_request.pull_request_id,
         'close_status': status_lbl,
         'closed': True,
     }
     return data

rhodecode/api/views/repo_api.py

@@ -1,2042 +1,2042 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2011-2017 RhodeCode GmbH
+# Copyright (C) 2011-2018 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 logging
 import time
 
 import rhodecode
 from rhodecode.api import (
     jsonrpc_method, JSONRPCError, JSONRPCForbidden, JSONRPCValidationError)
 from rhodecode.api.utils import (
     has_superadmin_permission, Optional, OAttr, get_repo_or_error,
     get_user_group_or_error, get_user_or_error, validate_repo_permissions,
     get_perm_or_error, parse_args, get_origin, build_commit_data,
     validate_set_owner_permissions)
 from rhodecode.lib import audit_logger
 from rhodecode.lib import repo_maintenance
 from rhodecode.lib.auth import HasPermissionAnyApi, HasUserGroupPermissionAnyApi
 from rhodecode.lib.celerylib.utils import get_task_id
 from rhodecode.lib.utils2 import str2bool, time_to_datetime
 from rhodecode.lib.ext_json import json
 from rhodecode.lib.exceptions import StatusChangeOnClosedPullRequestError
 from rhodecode.model.changeset_status import ChangesetStatusModel
 from rhodecode.model.comment import CommentsModel
 from rhodecode.model.db import (
     Session, ChangesetStatus, RepositoryField, Repository, RepoGroup,
     ChangesetComment)
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.scm import ScmModel, RepoList
 from rhodecode.model.settings import SettingsModel, VcsSettingsModel
 from rhodecode.model import validation_schema
 from rhodecode.model.validation_schema.schemas import repo_schema
 
 log = logging.getLogger(__name__)
 
 
 @jsonrpc_method()
 def get_repo(request, apiuser, repoid, cache=Optional(True)):
     """
     Gets an existing repository by its name or repository_id.
 
     The members section so the output returns users groups or users
     associated with that repository.
 
     This command can only be run using an |authtoken| with admin rights,
     or users with at least read rights to the |repo|.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: The repository name or repository id.
     :type repoid: str or int
     :param cache: use the cached value for last changeset
     :type: cache: Optional(bool)
 
     Example output:
 
     .. code-block:: bash
 
         {
           "error": null,
           "id": <repo_id>,
           "result": {
             "clone_uri": null,
             "created_on": "timestamp",
             "description": "repo description",
             "enable_downloads": false,
             "enable_locking": false,
             "enable_statistics": false,
             "followers": [
               {
                 "active": true,
                 "admin": false,
                 "api_key": "****************************************",
                 "api_keys": [
                   "****************************************"
                 ],
                 "email": "[e-mail]",
                 "emails": [
                   "[e-mail]"
                 ],
                 "extern_name": "rhodecode",
                 "extern_type": "rhodecode",
                 "firstname": "username",
                 "ip_addresses": [],
                 "language": null,
                 "last_login": "2015-09-16T17:16:35.854",
                 "lastname": "surname",
                 "user_id": <user_id>,
                 "username": "name"
               }
             ],
             "fork_of": "parent-repo",
             "landing_rev": [
               "rev",
               "tip"
             ],
             "last_changeset": {
               "author": "User <[e-mail]>",
               "branch": "default",
               "date": "timestamp",
               "message": "last commit message",
               "parents": [
                 {
                   "raw_id": "commit-id"
                 }
               ],
               "raw_id": "commit-id",
               "revision": <revision number>,
               "short_id": "short id"
             },
             "lock_reason": null,
             "locked_by": null,
             "locked_date": null,
             "owner": "owner-name",
             "permissions": [
               {
                 "name": "super-admin-name",
                 "origin": "super-admin",
                 "permission": "repository.admin",
                 "type": "user"
               },
               {
                 "name": "owner-name",
                 "origin": "owner",
                 "permission": "repository.admin",
                 "type": "user"
               },
               {
                 "name": "user-group-name",
                 "origin": "permission",
                 "permission": "repository.write",
                 "type": "user_group"
               }
             ],
             "private": true,
             "repo_id": 676,
             "repo_name": "user-group/repo-name",
             "repo_type": "hg"
           }
         }
     """
 
     repo = get_repo_or_error(repoid)
     cache = Optional.extract(cache)
 
     include_secrets = False
     if has_superadmin_permission(apiuser):
         include_secrets = True
     else:
         # check if we have at least read permission for this repo !
         _perms = (
             'repository.admin', 'repository.write', 'repository.read',)
         validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     permissions = []
     for _user in repo.permissions():
         user_data = {
             'name': _user.username,
             'permission': _user.permission,
             'origin': get_origin(_user),
             'type': "user",
         }
         permissions.append(user_data)
 
     for _user_group in repo.permission_user_groups():
         user_group_data = {
             'name': _user_group.users_group_name,
             'permission': _user_group.permission,
             'origin': get_origin(_user_group),
             'type': "user_group",
         }
         permissions.append(user_group_data)
 
     following_users = [
         user.user.get_api_data(include_secrets=include_secrets)
         for user in repo.followers]
 
     if not cache:
         repo.update_commit_cache()
     data = repo.get_api_data(include_secrets=include_secrets)
     data['permissions'] = permissions
     data['followers'] = following_users
     return data
 
 
 @jsonrpc_method()
 def get_repos(request, apiuser, root=Optional(None), traverse=Optional(True)):
     """
     Lists all existing repositories.
 
     This command can only be run using an |authtoken| with admin rights,
     or users with at least read rights to |repos|.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param root: specify root repository group to fetch repositories.
         filters the returned repositories to be members of given root group.
     :type root: Optional(None)
     :param traverse: traverse given root into subrepositories. With this flag
         set to False, it will only return top-level repositories from `root`.
         if root is empty it will return just top-level repositories.
     :type traverse: Optional(True)
 
 
     Example output:
 
     .. code-block:: bash
 
         id : <id_given_in_input>
         result: [
                   {
                     "repo_id" :          "<repo_id>",
                     "repo_name" :        "<reponame>"
                     "repo_type" :        "<repo_type>",
                     "clone_uri" :        "<clone_uri>",
                     "private": :         "<bool>",
                     "created_on" :       "<datetimecreated>",
                     "description" :      "<description>",
                     "landing_rev":       "<landing_rev>",
                     "owner":             "<repo_owner>",
                     "fork_of":           "<name_of_fork_parent>",
                     "enable_downloads":  "<bool>",
                     "enable_locking":    "<bool>",
                     "enable_statistics": "<bool>",
                   },
                   ...
                 ]
         error:  null
     """
 
     include_secrets = has_superadmin_permission(apiuser)
     _perms = ('repository.read', 'repository.write', 'repository.admin',)
     extras = {'user': apiuser}
 
     root = Optional.extract(root)
     traverse = Optional.extract(traverse, binary=True)
 
     if root:
         # verify parent existance, if it's empty return an error
         parent = RepoGroup.get_by_group_name(root)
         if not parent:
             raise JSONRPCError(
                 'Root repository group `{}` does not exist'.format(root))
 
         if traverse:
             repos = RepoModel().get_repos_for_root(root=root, traverse=traverse)
         else:
             repos = RepoModel().get_repos_for_root(root=parent)
     else:
         if traverse:
             repos = RepoModel().get_all()
         else:
             # return just top-level
             repos = RepoModel().get_repos_for_root(root=None)
 
     repo_list = RepoList(repos, perm_set=_perms, extra_kwargs=extras)
     return [repo.get_api_data(include_secrets=include_secrets)
             for repo in repo_list]
 
 
 @jsonrpc_method()
 def get_repo_changeset(request, apiuser, repoid, revision,
                        details=Optional('basic')):
     """
     Returns information about a changeset.
 
     Additionally parameters define the amount of details returned by
     this function.
 
     This command can only be run using an |authtoken| with admin rights,
     or users with at least read rights to the |repo|.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: The repository name or repository id
     :type repoid: str or int
     :param revision: revision for which listing should be done
     :type revision: str
     :param details: details can be 'basic|extended|full' full gives diff
         info details like the diff itself, and number of changed files etc.
     :type details: Optional(str)
 
     """
     repo = get_repo_or_error(repoid)
     if not has_superadmin_permission(apiuser):
         _perms = (
             'repository.admin', 'repository.write', 'repository.read',)
         validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     changes_details = Optional.extract(details)
     _changes_details_types = ['basic', 'extended', 'full']
     if changes_details not in _changes_details_types:
         raise JSONRPCError(
             'ret_type must be one of %s' % (
                 ','.join(_changes_details_types)))
 
     pre_load = ['author', 'branch', 'date', 'message', 'parents',
                 'status', '_commit', '_file_paths']
 
     try:
         cs = repo.get_commit(commit_id=revision, pre_load=pre_load)
     except TypeError as e:
         raise JSONRPCError(e.message)
     _cs_json = cs.__json__()
     _cs_json['diff'] = build_commit_data(cs, changes_details)
     if changes_details == 'full':
         _cs_json['refs'] = cs._get_refs()
     return _cs_json
 
 
 @jsonrpc_method()
 def get_repo_changesets(request, apiuser, repoid, start_rev, limit,
                         details=Optional('basic')):
     """
     Returns a set of commits limited by the number starting
     from the `start_rev` option.
 
     Additional parameters define the amount of details returned by this
     function.
 
     This command can only be run using an |authtoken| with admin rights,
     or users with at least read rights to |repos|.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: The repository name or repository ID.
     :type repoid: str or int
     :param start_rev: The starting revision from where to get changesets.
     :type start_rev: str
     :param limit: Limit the number of commits to this amount
     :type limit: str or int
     :param details: Set the level of detail returned. Valid option are:
         ``basic``, ``extended`` and ``full``.
     :type details: Optional(str)
 
     .. note::
 
        Setting the parameter `details` to the value ``full`` is extensive
        and returns details like the diff itself, and the number
        of changed files.
 
     """
     repo = get_repo_or_error(repoid)
     if not has_superadmin_permission(apiuser):
         _perms = (
             'repository.admin', 'repository.write', 'repository.read',)
         validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     changes_details = Optional.extract(details)
     _changes_details_types = ['basic', 'extended', 'full']
     if changes_details not in _changes_details_types:
         raise JSONRPCError(
             'ret_type must be one of %s' % (
                 ','.join(_changes_details_types)))
 
     limit = int(limit)
     pre_load = ['author', 'branch', 'date', 'message', 'parents',
                 'status', '_commit', '_file_paths']
 
     vcs_repo = repo.scm_instance()
     # SVN needs a special case to distinguish its index and commit id
     if vcs_repo and vcs_repo.alias == 'svn' and (start_rev == '0'):
         start_rev = vcs_repo.commit_ids[0]
 
     try:
         commits = vcs_repo.get_commits(
             start_id=start_rev, pre_load=pre_load)
     except TypeError as e:
         raise JSONRPCError(e.message)
     except Exception:
         log.exception('Fetching of commits failed')
         raise JSONRPCError('Error occurred during commit fetching')
 
     ret = []
     for cnt, commit in enumerate(commits):
         if cnt >= limit != -1:
             break
         _cs_json = commit.__json__()
         _cs_json['diff'] = build_commit_data(commit, changes_details)
         if changes_details == 'full':
             _cs_json['refs'] = {
                 'branches': [commit.branch],
                 'bookmarks': getattr(commit, 'bookmarks', []),
                 'tags': commit.tags
             }
         ret.append(_cs_json)
     return ret
 
 
 @jsonrpc_method()
 def get_repo_nodes(request, apiuser, repoid, revision, root_path,
                    ret_type=Optional('all'), details=Optional('basic'),
                    max_file_bytes=Optional(None)):
     """
     Returns a list of nodes and children in a flat list for a given
     path at given revision.
 
     It's possible to specify ret_type to show only `files` or `dirs`.
 
     This command can only be run using an |authtoken| with admin rights,
     or users with at least read rights to |repos|.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: The repository name or repository ID.
     :type repoid: str or int
     :param revision: The revision for which listing should be done.
     :type revision: str
     :param root_path: The path from which to start displaying.
     :type root_path: str
     :param ret_type: Set the return type. Valid options are
         ``all`` (default), ``files`` and ``dirs``.
     :type ret_type: Optional(str)
     :param details: Returns extended information about nodes, such as
         md5, binary, and or content.  The valid options are ``basic`` and
         ``full``.
     :type details: Optional(str)
     :param max_file_bytes: Only return file content under this file size bytes
     :type details: Optional(int)
 
     Example output:
 
     .. code-block:: bash
 
         id : <id_given_in_input>
         result: [
                   {
                     "name" : "<name>"
                     "type" : "<type>",
                     "binary": "<true|false>" (only in extended mode)
                     "md5"  : "<md5 of file content>" (only in extended mode)
                   },
                   ...
                 ]
         error:  null
     """
 
     repo = get_repo_or_error(repoid)
     if not has_superadmin_permission(apiuser):
         _perms = (
             'repository.admin', 'repository.write', 'repository.read',)
         validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     ret_type = Optional.extract(ret_type)
     details = Optional.extract(details)
     _extended_types = ['basic', 'full']
     if details not in _extended_types:
         raise JSONRPCError(
             'ret_type must be one of %s' % (','.join(_extended_types)))
     extended_info = False
     content = False
     if details == 'basic':
         extended_info = True
 
     if details == 'full':
         extended_info = content = True
 
     _map = {}
     try:
         # check if repo is not empty by any chance, skip quicker if it is.
         _scm = repo.scm_instance()
         if _scm.is_empty():
             return []
 
         _d, _f = ScmModel().get_nodes(
             repo, revision, root_path, flat=False,
             extended_info=extended_info, content=content,
             max_file_bytes=max_file_bytes)
         _map = {
             'all': _d + _f,
             'files': _f,
             'dirs': _d,
         }
         return _map[ret_type]
     except KeyError:
         raise JSONRPCError(
             'ret_type must be one of %s' % (','.join(sorted(_map.keys()))))
     except Exception:
         log.exception("Exception occurred while trying to get repo nodes")
         raise JSONRPCError(
             'failed to get repo: `%s` nodes' % repo.repo_name
         )
 
 
 @jsonrpc_method()
 def get_repo_refs(request, apiuser, repoid):
     """
     Returns a dictionary of current references. It returns
     bookmarks, branches, closed_branches, and tags for given repository
 
     It's possible to specify ret_type to show only `files` or `dirs`.
 
     This command can only be run using an |authtoken| with admin rights,
     or users with at least read rights to |repos|.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: The repository name or repository ID.
     :type repoid: str or int
 
     Example output:
 
     .. code-block:: bash
 
         id : <id_given_in_input>
         "result": {
             "bookmarks": {
               "dev": "5611d30200f4040ba2ab4f3d64e5b06408a02188",
               "master": "367f590445081d8ec8c2ea0456e73ae1f1c3d6cf"
             },
             "branches": {
               "default": "5611d30200f4040ba2ab4f3d64e5b06408a02188",
               "stable": "367f590445081d8ec8c2ea0456e73ae1f1c3d6cf"
             },
             "branches_closed": {},
             "tags": {
               "tip": "5611d30200f4040ba2ab4f3d64e5b06408a02188",
               "v4.4.0": "1232313f9e6adac5ce5399c2a891dc1e72b79022",
               "v4.4.1": "cbb9f1d329ae5768379cdec55a62ebdd546c4e27",
               "v4.4.2": "24ffe44a27fcd1c5b6936144e176b9f6dd2f3a17",
             }
         }
         error:  null
     """
 
     repo = get_repo_or_error(repoid)
     if not has_superadmin_permission(apiuser):
         _perms = ('repository.admin', 'repository.write', 'repository.read',)
         validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     try:
         # check if repo is not empty by any chance, skip quicker if it is.
         vcs_instance = repo.scm_instance()
         refs = vcs_instance.refs()
         return refs
     except Exception:
         log.exception("Exception occurred while trying to get repo refs")
         raise JSONRPCError(
             'failed to get repo: `%s` references' % repo.repo_name
         )
 
 
 @jsonrpc_method()
 def create_repo(
         request, apiuser, repo_name, repo_type,
         owner=Optional(OAttr('apiuser')),
         description=Optional(''),
         private=Optional(False),
         clone_uri=Optional(None),
         landing_rev=Optional('rev:tip'),
         enable_statistics=Optional(False),
         enable_locking=Optional(False),
         enable_downloads=Optional(False),
         copy_permissions=Optional(False)):
     """
     Creates a repository.
 
     * If the repository name contains "/", repository will be created inside
       a repository group or nested repository groups
 
       For example "foo/bar/repo1" will create |repo| called "repo1" inside
       group "foo/bar". You have to have permissions to access and write to
       the last repository group ("bar" in this example)
 
     This command can only be run using an |authtoken| with at least
     permissions to create repositories, or write permissions to
     parent repository groups.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repo_name: Set the repository name.
     :type repo_name: str
     :param repo_type: Set the repository type; 'hg','git', or 'svn'.
     :type repo_type: str
     :param owner: user_id or username
     :type owner: Optional(str)
     :param description: Set the repository description.
     :type description: Optional(str)
     :param private: set repository as private
     :type private: bool
     :param clone_uri: set clone_uri
     :type clone_uri: str
     :param landing_rev: <rev_type>:<rev>
     :type landing_rev: str
     :param enable_locking:
     :type enable_locking: bool
     :param enable_downloads:
     :type enable_downloads: bool
     :param enable_statistics:
     :type enable_statistics: bool
     :param copy_permissions: Copy permission from group in which the
         repository is being created.
     :type copy_permissions: bool
 
 
     Example output:
 
     .. code-block:: bash
 
         id : <id_given_in_input>
         result: {
                   "msg": "Created new repository `<reponame>`",
                   "success": true,
                   "task": "<celery task id or None if done sync>"
                 }
         error:  null
 
 
     Example error output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : null
       error :  {
          'failed to create repository `<repo_name>`'
       }
 
     """
 
     owner = validate_set_owner_permissions(apiuser, owner)
 
     description = Optional.extract(description)
     copy_permissions = Optional.extract(copy_permissions)
     clone_uri = Optional.extract(clone_uri)
     landing_commit_ref = Optional.extract(landing_rev)
 
     defs = SettingsModel().get_default_repo_settings(strip_prefix=True)
     if isinstance(private, Optional):
         private = defs.get('repo_private') or Optional.extract(private)
     if isinstance(repo_type, Optional):
         repo_type = defs.get('repo_type')
     if isinstance(enable_statistics, Optional):
         enable_statistics = defs.get('repo_enable_statistics')
     if isinstance(enable_locking, Optional):
         enable_locking = defs.get('repo_enable_locking')
     if isinstance(enable_downloads, Optional):
         enable_downloads = defs.get('repo_enable_downloads')
 
     schema = repo_schema.RepoSchema().bind(
         repo_type_options=rhodecode.BACKENDS.keys(),
         # user caller
         user=apiuser)
 
     try:
         schema_data = schema.deserialize(dict(
             repo_name=repo_name,
             repo_type=repo_type,
             repo_owner=owner.username,
             repo_description=description,
             repo_landing_commit_ref=landing_commit_ref,
             repo_clone_uri=clone_uri,
             repo_private=private,
             repo_copy_permissions=copy_permissions,
             repo_enable_statistics=enable_statistics,
             repo_enable_downloads=enable_downloads,
             repo_enable_locking=enable_locking))
     except validation_schema.Invalid as err:
         raise JSONRPCValidationError(colander_exc=err)
 
     try:
         data = {
             'owner': owner,
             'repo_name': schema_data['repo_group']['repo_name_without_group'],
             'repo_name_full': schema_data['repo_name'],
             'repo_group': schema_data['repo_group']['repo_group_id'],
             'repo_type': schema_data['repo_type'],
             'repo_description': schema_data['repo_description'],
             'repo_private': schema_data['repo_private'],
             'clone_uri': schema_data['repo_clone_uri'],
             'repo_landing_rev': schema_data['repo_landing_commit_ref'],
             'enable_statistics': schema_data['repo_enable_statistics'],
             'enable_locking': schema_data['repo_enable_locking'],
             'enable_downloads': schema_data['repo_enable_downloads'],
             'repo_copy_permissions': schema_data['repo_copy_permissions'],
         }
 
         task = RepoModel().create(form_data=data, cur_user=owner)
         task_id = get_task_id(task)
         # no commit, it's done in RepoModel, or async via celery
         return {
             'msg': "Created new repository `%s`" % (schema_data['repo_name'],),
             'success': True,  # cannot return the repo data here since fork
             # can be done async
             'task': task_id
         }
     except Exception:
         log.exception(
             u"Exception while trying to create the repository %s",
             schema_data['repo_name'])
         raise JSONRPCError(
             'failed to create repository `%s`' % (schema_data['repo_name'],))
 
 
 @jsonrpc_method()
 def add_field_to_repo(request, apiuser, repoid, key, label=Optional(''),
                       description=Optional('')):
     """
     Adds an extra field to a repository.
 
     This command can only be run using an |authtoken| with at least
     write permissions to the |repo|.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: Set the repository name or repository id.
     :type repoid: str or int
     :param key: Create a unique field key for this repository.
     :type key: str
     :param label:
     :type label: Optional(str)
     :param description:
     :type description: Optional(str)
     """
     repo = get_repo_or_error(repoid)
     if not has_superadmin_permission(apiuser):
         _perms = ('repository.admin',)
         validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     label = Optional.extract(label) or key
     description = Optional.extract(description)
 
     field = RepositoryField.get_by_key_name(key, repo)
     if field:
         raise JSONRPCError('Field with key '
                            '`%s` exists for repo `%s`' % (key, repoid))
 
     try:
         RepoModel().add_repo_field(repo, key, field_label=label,
                                    field_desc=description)
         Session().commit()
         return {
             'msg': "Added new repository field `%s`" % (key,),
             'success': True,
         }
     except Exception:
         log.exception("Exception occurred while trying to add field to repo")
         raise JSONRPCError(
             'failed to create new field for repository `%s`' % (repoid,))
 
 
 @jsonrpc_method()
 def remove_field_from_repo(request, apiuser, repoid, key):
     """
     Removes an extra field from a repository.
 
     This command can only be run using an |authtoken| with at least
     write permissions to the |repo|.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: Set the repository name or repository ID.
     :type repoid: str or int
     :param key: Set the unique field key for this repository.
     :type key: str
     """
 
     repo = get_repo_or_error(repoid)
     if not has_superadmin_permission(apiuser):
         _perms = ('repository.admin',)
         validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     field = RepositoryField.get_by_key_name(key, repo)
     if not field:
         raise JSONRPCError('Field with key `%s` does not '
                            'exists for repo `%s`' % (key, repoid))
 
     try:
         RepoModel().delete_repo_field(repo, field_key=key)
         Session().commit()
         return {
             'msg': "Deleted repository field `%s`" % (key,),
             'success': True,
         }
     except Exception:
         log.exception(
             "Exception occurred while trying to delete field from repo")
         raise JSONRPCError(
             'failed to delete field for repository `%s`' % (repoid,))
 
 
 @jsonrpc_method()
 def update_repo(
         request, apiuser, repoid, repo_name=Optional(None),
         owner=Optional(OAttr('apiuser')), description=Optional(''),
         private=Optional(False), clone_uri=Optional(None),
         landing_rev=Optional('rev:tip'), fork_of=Optional(None),
         enable_statistics=Optional(False),
         enable_locking=Optional(False),
         enable_downloads=Optional(False), fields=Optional('')):
     """
     Updates a repository with the given information.
 
     This command can only be run using an |authtoken| with at least
     admin permissions to the |repo|.
 
     * If the repository name contains "/", repository will be updated
       accordingly with a repository group or nested repository groups
 
       For example repoid=repo-test name="foo/bar/repo-test" will update |repo|
       called "repo-test" and place it inside group "foo/bar".
       You have to have permissions to access and write to the last repository
       group ("bar" in this example)
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: repository name or repository ID.
     :type repoid: str or int
     :param repo_name: Update the |repo| name, including the
         repository group it's in.
     :type repo_name: str
     :param owner: Set the |repo| owner.
     :type owner: str
     :param fork_of: Set the |repo| as fork of another |repo|.
     :type fork_of: str
     :param description: Update the |repo| description.
     :type description: str
     :param private: Set the |repo| as private. (True | False)
     :type private: bool
     :param clone_uri: Update the |repo| clone URI.
     :type clone_uri: str
     :param landing_rev: Set the |repo| landing revision. Default is ``rev:tip``.
     :type landing_rev: str
     :param enable_statistics: Enable statistics on the |repo|, (True | False).
     :type enable_statistics: bool
     :param enable_locking: Enable |repo| locking.
     :type enable_locking: bool
     :param enable_downloads: Enable downloads from the |repo|, (True | False).
     :type enable_downloads: bool
     :param fields: Add extra fields to the |repo|. Use the following
         example format: ``field_key=field_val,field_key2=fieldval2``.
         Escape ', ' with \,
     :type fields: str
     """
 
     repo = get_repo_or_error(repoid)
 
     include_secrets = False
     if not has_superadmin_permission(apiuser):
         validate_repo_permissions(apiuser, repoid, repo, ('repository.admin',))
     else:
         include_secrets = True
 
     updates = dict(
         repo_name=repo_name
         if not isinstance(repo_name, Optional) else repo.repo_name,
 
         fork_id=fork_of
         if not isinstance(fork_of, Optional) else repo.fork.repo_name if repo.fork else None,
 
         user=owner
         if not isinstance(owner, Optional) else repo.user.username,
 
         repo_description=description
         if not isinstance(description, Optional) else repo.description,
 
         repo_private=private
         if not isinstance(private, Optional) else repo.private,
 
         clone_uri=clone_uri
         if not isinstance(clone_uri, Optional) else repo.clone_uri,
 
         repo_landing_rev=landing_rev
         if not isinstance(landing_rev, Optional) else repo._landing_revision,
 
         repo_enable_statistics=enable_statistics
         if not isinstance(enable_statistics, Optional) else repo.enable_statistics,
 
         repo_enable_locking=enable_locking
         if not isinstance(enable_locking, Optional) else repo.enable_locking,
 
         repo_enable_downloads=enable_downloads
         if not isinstance(enable_downloads, Optional) else repo.enable_downloads)
 
     ref_choices, _labels = ScmModel().get_repo_landing_revs(
         request.translate, repo=repo)
 
     old_values = repo.get_api_data()
     schema = repo_schema.RepoSchema().bind(
         repo_type_options=rhodecode.BACKENDS.keys(),
         repo_ref_options=ref_choices,
         # user caller
         user=apiuser,
         old_values=old_values)
     try:
         schema_data = schema.deserialize(dict(
             # we save old value, users cannot change type
             repo_type=repo.repo_type,
 
             repo_name=updates['repo_name'],
             repo_owner=updates['user'],
             repo_description=updates['repo_description'],
             repo_clone_uri=updates['clone_uri'],
             repo_fork_of=updates['fork_id'],
             repo_private=updates['repo_private'],
             repo_landing_commit_ref=updates['repo_landing_rev'],
             repo_enable_statistics=updates['repo_enable_statistics'],
             repo_enable_downloads=updates['repo_enable_downloads'],
             repo_enable_locking=updates['repo_enable_locking']))
     except validation_schema.Invalid as err:
         raise JSONRPCValidationError(colander_exc=err)
 
     # save validated data back into the updates dict
     validated_updates = dict(
         repo_name=schema_data['repo_group']['repo_name_without_group'],
         repo_group=schema_data['repo_group']['repo_group_id'],
 
         user=schema_data['repo_owner'],
         repo_description=schema_data['repo_description'],
         repo_private=schema_data['repo_private'],
         clone_uri=schema_data['repo_clone_uri'],
         repo_landing_rev=schema_data['repo_landing_commit_ref'],
         repo_enable_statistics=schema_data['repo_enable_statistics'],
         repo_enable_locking=schema_data['repo_enable_locking'],
         repo_enable_downloads=schema_data['repo_enable_downloads'],
     )
 
     if schema_data['repo_fork_of']:
         fork_repo = get_repo_or_error(schema_data['repo_fork_of'])
         validated_updates['fork_id'] = fork_repo.repo_id
 
     # extra fields
     fields = parse_args(Optional.extract(fields), key_prefix='ex_')
     if fields:
         validated_updates.update(fields)
 
     try:
         RepoModel().update(repo, **validated_updates)
         audit_logger.store_api(
             'repo.edit', action_data={'old_data': old_values},
             user=apiuser, repo=repo)
         Session().commit()
         return {
             'msg': 'updated repo ID:%s %s' % (repo.repo_id, repo.repo_name),
             'repository': repo.get_api_data(include_secrets=include_secrets)
         }
     except Exception:
         log.exception(
             u"Exception while trying to update the repository %s",
             repoid)
         raise JSONRPCError('failed to update repo `%s`' % repoid)
 
 
 @jsonrpc_method()
 def fork_repo(request, apiuser, repoid, fork_name,
               owner=Optional(OAttr('apiuser')),
               description=Optional(''),
               private=Optional(False),
               clone_uri=Optional(None),
               landing_rev=Optional('rev:tip'),
               copy_permissions=Optional(False)):
     """
     Creates a fork of the specified |repo|.
 
     * If the fork_name contains "/", fork will be created inside
       a repository group or nested repository groups
 
       For example "foo/bar/fork-repo" will create fork called "fork-repo"
       inside group "foo/bar". You have to have permissions to access and
       write to the last repository group ("bar" in this example)
 
     This command can only be run using an |authtoken| with minimum
     read permissions of the forked repo, create fork permissions for an user.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: Set repository name or repository ID.
     :type repoid: str or int
     :param fork_name: Set the fork name, including it's repository group membership.
     :type fork_name: str
     :param owner: Set the fork owner.
     :type owner: str
     :param description: Set the fork description.
     :type description: str
     :param copy_permissions: Copy permissions from parent |repo|. The
         default is False.
     :type copy_permissions: bool
     :param private: Make the fork private. The default is False.
     :type private: bool
     :param landing_rev: Set the landing revision. The default is tip.
 
     Example output:
 
     .. code-block:: bash
 
         id : <id_for_response>
         api_key : "<api_key>"
         args:     {
                     "repoid" :          "<reponame or repo_id>",
                     "fork_name":        "<forkname>",
                     "owner":            "<username or user_id = Optional(=apiuser)>",
                     "description":      "<description>",
                     "copy_permissions": "<bool>",
                     "private":          "<bool>",
                     "landing_rev":      "<landing_rev>"
                   }
 
     Example error output:
 
     .. code-block:: bash
 
         id : <id_given_in_input>
         result: {
                   "msg": "Created fork of `<reponame>` as `<forkname>`",
                   "success": true,
                   "task": "<celery task id or None if done sync>"
                 }
         error:  null
 
     """
 
     repo = get_repo_or_error(repoid)
     repo_name = repo.repo_name
 
     if not has_superadmin_permission(apiuser):
         # check if we have at least read permission for
         # this repo that we fork !
         _perms = (
             'repository.admin', 'repository.write', 'repository.read')
         validate_repo_permissions(apiuser, repoid, repo, _perms)
 
         # check if the regular user has at least fork permissions as well
         if not HasPermissionAnyApi('hg.fork.repository')(user=apiuser):
             raise JSONRPCForbidden()
 
     # check if user can set owner parameter
     owner = validate_set_owner_permissions(apiuser, owner)
 
     description = Optional.extract(description)
     copy_permissions = Optional.extract(copy_permissions)
     clone_uri = Optional.extract(clone_uri)
     landing_commit_ref = Optional.extract(landing_rev)
     private = Optional.extract(private)
 
     schema = repo_schema.RepoSchema().bind(
         repo_type_options=rhodecode.BACKENDS.keys(),
         # user caller
         user=apiuser)
 
     try:
         schema_data = schema.deserialize(dict(
             repo_name=fork_name,
             repo_type=repo.repo_type,
             repo_owner=owner.username,
             repo_description=description,
             repo_landing_commit_ref=landing_commit_ref,
             repo_clone_uri=clone_uri,
             repo_private=private,
             repo_copy_permissions=copy_permissions))
     except validation_schema.Invalid as err:
         raise JSONRPCValidationError(colander_exc=err)
 
     try:
         data = {
             'fork_parent_id': repo.repo_id,
 
             'repo_name': schema_data['repo_group']['repo_name_without_group'],
             'repo_name_full': schema_data['repo_name'],
             'repo_group': schema_data['repo_group']['repo_group_id'],
             'repo_type': schema_data['repo_type'],
             'description': schema_data['repo_description'],
             'private': schema_data['repo_private'],
             'copy_permissions': schema_data['repo_copy_permissions'],
             'landing_rev': schema_data['repo_landing_commit_ref'],
         }
 
         task = RepoModel().create_fork(data, cur_user=owner)
         # no commit, it's done in RepoModel, or async via celery
         task_id = get_task_id(task)
 
         return {
             'msg': 'Created fork of `%s` as `%s`' % (
                 repo.repo_name, schema_data['repo_name']),
             'success': True,  # cannot return the repo data here since fork
             # can be done async
             'task': task_id
         }
     except Exception:
         log.exception(
             u"Exception while trying to create fork %s",
             schema_data['repo_name'])
         raise JSONRPCError(
             'failed to fork repository `%s` as `%s`' % (
                 repo_name, schema_data['repo_name']))
 
 
 @jsonrpc_method()
 def delete_repo(request, apiuser, repoid, forks=Optional('')):
     """
     Deletes a repository.
 
     * When the `forks` parameter is set it's possible to detach or delete
       forks of deleted repository.
 
     This command can only be run using an |authtoken| with admin
     permissions on the |repo|.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: Set the repository name or repository ID.
     :type repoid: str or int
     :param forks: Set to `detach` or `delete` forks from the |repo|.
     :type forks: Optional(str)
 
     Example error output:
 
     .. code-block:: bash
 
         id : <id_given_in_input>
         result: {
                   "msg": "Deleted repository `<reponame>`",
                   "success": true
                 }
         error:  null
     """
 
     repo = get_repo_or_error(repoid)
     repo_name = repo.repo_name
     if not has_superadmin_permission(apiuser):
         _perms = ('repository.admin',)
         validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     try:
         handle_forks = Optional.extract(forks)
         _forks_msg = ''
         _forks = [f for f in repo.forks]
         if handle_forks == 'detach':
             _forks_msg = ' ' + 'Detached %s forks' % len(_forks)
         elif handle_forks == 'delete':
             _forks_msg = ' ' + 'Deleted %s forks' % len(_forks)
         elif _forks:
             raise JSONRPCError(
                 'Cannot delete `%s` it still contains attached forks' %
                 (repo.repo_name,)
             )
         old_data = repo.get_api_data()
         RepoModel().delete(repo, forks=forks)
 
         repo = audit_logger.RepoWrap(repo_id=None,
                                      repo_name=repo.repo_name)
 
         audit_logger.store_api(
             'repo.delete', action_data={'old_data': old_data},
             user=apiuser, repo=repo)
 
         ScmModel().mark_for_invalidation(repo_name, delete=True)
         Session().commit()
         return {
             'msg': 'Deleted repository `%s`%s' % (repo_name, _forks_msg),
             'success': True
         }
     except Exception:
         log.exception("Exception occurred while trying to delete repo")
         raise JSONRPCError(
             'failed to delete repository `%s`' % (repo_name,)
         )
 
 
 #TODO: marcink, change name ?
 @jsonrpc_method()
 def invalidate_cache(request, apiuser, repoid, delete_keys=Optional(False)):
     """
     Invalidates the cache for the specified repository.
 
     This command can only be run using an |authtoken| with admin rights to
     the specified repository.
 
     This command takes the following options:
 
     :param apiuser: This is filled automatically from |authtoken|.
     :type apiuser: AuthUser
     :param repoid: Sets the repository name or repository ID.
     :type repoid: str or int
     :param delete_keys: This deletes the invalidated keys instead of
         just flagging them.
     :type delete_keys: Optional(``True`` | ``False``)
 
     Example output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : {
         'msg': Cache for repository `<repository name>` was invalidated,
         'repository': <repository name>
       }
       error :  null
 
     Example error output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : null
       error : {
          'Error occurred during cache invalidation action'
       }
 
     """
 
     repo = get_repo_or_error(repoid)
     if not has_superadmin_permission(apiuser):
         _perms = ('repository.admin', 'repository.write',)
         validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     delete = Optional.extract(delete_keys)
     try:
         ScmModel().mark_for_invalidation(repo.repo_name, delete=delete)
         return {
             'msg': 'Cache for repository `%s` was invalidated' % (repoid,),
             'repository': repo.repo_name
         }
     except Exception:
         log.exception(
             "Exception occurred while trying to invalidate repo cache")
         raise JSONRPCError(
             'Error occurred during cache invalidation action'
         )
 
 
 #TODO: marcink, change name ?
 @jsonrpc_method()
 def lock(request, apiuser, repoid, locked=Optional(None),
          userid=Optional(OAttr('apiuser'))):
     """
     Sets the lock state of the specified |repo| by the given user.
     From more information, see :ref:`repo-locking`.
 
     * If the ``userid`` option is not set, the repository is locked to the
       user who called the method.
     * If the ``locked`` parameter is not set, the current lock state of the
       repository is displayed.
 
     This command can only be run using an |authtoken| with admin rights to
     the specified repository.
 
     This command takes the following options:
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: Sets the repository name or repository ID.
     :type repoid: str or int
     :param locked: Sets the lock state.
     :type locked: Optional(``True`` | ``False``)
     :param userid: Set the repository lock to this user.
     :type userid: Optional(str or int)
 
     Example error output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : {
         'repo': '<reponame>',
         'locked': <bool: lock state>,
         'locked_since': <int: lock timestamp>,
         'locked_by': <username of person who made the lock>,
         'lock_reason': <str: reason for locking>,
         'lock_state_changed': <bool: True if lock state has been changed in this request>,
         'msg': 'Repo `<reponame>` locked by `<username>` on <timestamp>.'
         or
         'msg': 'Repo `<repository name>` not locked.'
         or
         'msg': 'User `<user name>` set lock state for repo `<repository name>` to `<new lock state>`'
       }
       error :  null
 
     Example error output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : null
       error :  {
         'Error occurred locking repository `<reponame>`'
       }
     """
 
     repo = get_repo_or_error(repoid)
     if not has_superadmin_permission(apiuser):
         # check if we have at least write permission for this repo !
         _perms = ('repository.admin', 'repository.write',)
         validate_repo_permissions(apiuser, repoid, repo, _perms)
 
         # make sure normal user does not pass someone else userid,
         # he is not allowed to do that
         if not isinstance(userid, Optional) and userid != apiuser.user_id:
             raise JSONRPCError('userid is not the same as your user')
 
     if isinstance(userid, Optional):
         userid = apiuser.user_id
 
     user = get_user_or_error(userid)
 
     if isinstance(locked, Optional):
         lockobj = repo.locked
 
         if lockobj[0] is None:
             _d = {
                 'repo': repo.repo_name,
                 'locked': False,
                 'locked_since': None,
                 'locked_by': None,
                 'lock_reason': None,
                 'lock_state_changed': False,
                 'msg': 'Repo `%s` not locked.' % repo.repo_name
             }
             return _d
         else:
             _user_id, _time, _reason = lockobj
             lock_user = get_user_or_error(userid)
             _d = {
                 'repo': repo.repo_name,
                 'locked': True,
                 'locked_since': _time,
                 'locked_by': lock_user.username,
                 'lock_reason': _reason,
                 'lock_state_changed': False,
                 'msg': ('Repo `%s` locked by `%s` on `%s`.'
                         % (repo.repo_name, lock_user.username,
                            json.dumps(time_to_datetime(_time))))
             }
             return _d
 
     # force locked state through a flag
     else:
         locked = str2bool(locked)
         lock_reason = Repository.LOCK_API
         try:
             if locked:
                 lock_time = time.time()
                 Repository.lock(repo, user.user_id, lock_time, lock_reason)
             else:
                 lock_time = None
                 Repository.unlock(repo)
             _d = {
                 'repo': repo.repo_name,
                 'locked': locked,
                 'locked_since': lock_time,
                 'locked_by': user.username,
                 'lock_reason': lock_reason,
                 'lock_state_changed': True,
                 'msg': ('User `%s` set lock state for repo `%s` to `%s`'
                         % (user.username, repo.repo_name, locked))
             }
             return _d
         except Exception:
             log.exception(
                 "Exception occurred while trying to lock repository")
             raise JSONRPCError(
                 'Error occurred locking repository `%s`' % repo.repo_name
             )
 
 
 @jsonrpc_method()
 def comment_commit(
         request, apiuser, repoid, commit_id, message, status=Optional(None),
         comment_type=Optional(ChangesetComment.COMMENT_TYPE_NOTE),
         resolves_comment_id=Optional(None),
         userid=Optional(OAttr('apiuser'))):
     """
     Set a commit comment, and optionally change the status of the commit.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: Set the repository name or repository ID.
     :type repoid: str or int
     :param commit_id: Specify the commit_id for which to set a comment.
     :type commit_id: str
     :param message: The comment text.
     :type message: str
     :param status: (**Optional**) status of commit, one of: 'not_reviewed',
         'approved', 'rejected', 'under_review'
     :type status: str
     :param comment_type: Comment type, one of: 'note', 'todo'
     :type comment_type: Optional(str), default: 'note'
     :param userid: Set the user name of the comment creator.
     :type userid: Optional(str or int)
 
     Example error output:
 
     .. code-block:: bash
 
         {
             "id" : <id_given_in_input>,
             "result" : {
                 "msg": "Commented on commit `<commit_id>` for repository `<repoid>`",
                 "status_change": null or <status>,
                 "success": true
             },
             "error" :  null
         }
 
     """
     repo = get_repo_or_error(repoid)
     if not has_superadmin_permission(apiuser):
         _perms = ('repository.read', 'repository.write', 'repository.admin')
         validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     try:
         commit_id = repo.scm_instance().get_commit(commit_id=commit_id).raw_id
     except Exception as e:
         log.exception('Failed to fetch commit')
         raise JSONRPCError(e.message)
 
     if isinstance(userid, Optional):
         userid = apiuser.user_id
 
     user = get_user_or_error(userid)
     status = Optional.extract(status)
     comment_type = Optional.extract(comment_type)
     resolves_comment_id = Optional.extract(resolves_comment_id)
 
     allowed_statuses = [x[0] for x in ChangesetStatus.STATUSES]
     if status and status not in allowed_statuses:
         raise JSONRPCError('Bad status, must be on '
                            'of %s got %s' % (allowed_statuses, status,))
 
     if resolves_comment_id:
         comment = ChangesetComment.get(resolves_comment_id)
         if not comment:
             raise JSONRPCError(
                 'Invalid resolves_comment_id `%s` for this commit.'
                 % resolves_comment_id)
         if comment.comment_type != ChangesetComment.COMMENT_TYPE_TODO:
             raise JSONRPCError(
                 'Comment `%s` is wrong type for setting status to resolved.'
                 % resolves_comment_id)
 
     try:
         rc_config = SettingsModel().get_all_settings()
         renderer = rc_config.get('rhodecode_markup_renderer', 'rst')
         status_change_label = ChangesetStatus.get_status_lbl(status)
         comment = CommentsModel().create(
             message, repo, user, commit_id=commit_id,
             status_change=status_change_label,
             status_change_type=status,
             renderer=renderer,
             comment_type=comment_type,
             resolves_comment_id=resolves_comment_id
         )
         if status:
             # also do a status change
             try:
                 ChangesetStatusModel().set_status(
                     repo, status, user, comment, revision=commit_id,
                     dont_allow_on_closed_pull_request=True
                 )
             except StatusChangeOnClosedPullRequestError:
                 log.exception(
                     "Exception occurred while trying to change repo commit status")
                 msg = ('Changing status on a changeset associated with '
                        'a closed pull request is not allowed')
                 raise JSONRPCError(msg)
 
         Session().commit()
         return {
             'msg': (
                 'Commented on commit `%s` for repository `%s`' % (
                     comment.revision, repo.repo_name)),
             'status_change': status,
             'success': True,
         }
     except JSONRPCError:
         # catch any inside errors, and re-raise them to prevent from
         # below global catch to silence them
         raise
     except Exception:
         log.exception("Exception occurred while trying to comment on commit")
         raise JSONRPCError(
             'failed to set comment on repository `%s`' % (repo.repo_name,)
         )
 
 
 @jsonrpc_method()
 def grant_user_permission(request, apiuser, repoid, userid, perm):
     """
     Grant permissions for the specified user on the given repository,
     or update existing permissions if found.
 
     This command can only be run using an |authtoken| with admin
     permissions on the |repo|.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: Set the repository name or repository ID.
     :type repoid: str or int
     :param userid: Set the user name.
     :type userid: str
     :param perm: Set the user permissions, using the following format
         ``(repository.(none|read|write|admin))``
     :type perm: str
 
     Example output:
 
     .. code-block:: bash
 
         id : <id_given_in_input>
         result: {
                   "msg" : "Granted perm: `<perm>` for user: `<username>` in repo: `<reponame>`",
                   "success": true
                 }
         error:  null
     """
 
     repo = get_repo_or_error(repoid)
     user = get_user_or_error(userid)
     perm = get_perm_or_error(perm)
     if not has_superadmin_permission(apiuser):
         _perms = ('repository.admin',)
         validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     try:
 
         RepoModel().grant_user_permission(repo=repo, user=user, perm=perm)
 
         Session().commit()
         return {
             'msg': 'Granted perm: `%s` for user: `%s` in repo: `%s`' % (
                 perm.permission_name, user.username, repo.repo_name
             ),
             'success': True
         }
     except Exception:
         log.exception(
             "Exception occurred while trying edit permissions for repo")
         raise JSONRPCError(
             'failed to edit permission for user: `%s` in repo: `%s`' % (
                 userid, repoid
             )
         )
 
 
 @jsonrpc_method()
 def revoke_user_permission(request, apiuser, repoid, userid):
     """
     Revoke permission for a user on the specified repository.
 
     This command can only be run using an |authtoken| with admin
     permissions on the |repo|.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: Set the repository name or repository ID.
     :type repoid: str or int
     :param userid: Set the user name of revoked user.
     :type userid: str or int
 
     Example error output:
 
     .. code-block:: bash
 
         id : <id_given_in_input>
         result: {
                   "msg" : "Revoked perm for user: `<username>` in repo: `<reponame>`",
                   "success": true
                 }
         error:  null
     """
 
     repo = get_repo_or_error(repoid)
     user = get_user_or_error(userid)
     if not has_superadmin_permission(apiuser):
         _perms = ('repository.admin',)
         validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     try:
         RepoModel().revoke_user_permission(repo=repo, user=user)
         Session().commit()
         return {
             'msg': 'Revoked perm for user: `%s` in repo: `%s`' % (
                 user.username, repo.repo_name
             ),
             'success': True
         }
     except Exception:
         log.exception(
             "Exception occurred while trying revoke permissions to repo")
         raise JSONRPCError(
             'failed to edit permission for user: `%s` in repo: `%s`' % (
                 userid, repoid
             )
         )
 
 
 @jsonrpc_method()
 def grant_user_group_permission(request, apiuser, repoid, usergroupid, perm):
     """
     Grant permission for a user group on the specified repository,
     or update existing permissions.
 
     This command can only be run using an |authtoken| with admin
     permissions on the |repo|.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: Set the repository name or repository ID.
     :type repoid: str or int
     :param usergroupid: Specify the ID of the user group.
     :type usergroupid: str or int
     :param perm: Set the user group permissions using the following
         format: (repository.(none|read|write|admin))
     :type perm: str
 
     Example output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : {
         "msg" : "Granted perm: `<perm>` for group: `<usersgroupname>` in repo: `<reponame>`",
         "success": true
 
       }
       error :  null
 
     Example error output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : null
       error :  {
         "failed to edit permission for user group: `<usergroup>` in repo `<repo>`'
       }
 
     """
 
     repo = get_repo_or_error(repoid)
     perm = get_perm_or_error(perm)
     if not has_superadmin_permission(apiuser):
         _perms = ('repository.admin',)
         validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     user_group = get_user_group_or_error(usergroupid)
     if not has_superadmin_permission(apiuser):
         # check if we have at least read permission for this user group !
         _perms = ('usergroup.read', 'usergroup.write', 'usergroup.admin',)
         if not HasUserGroupPermissionAnyApi(*_perms)(
                 user=apiuser, user_group_name=user_group.users_group_name):
             raise JSONRPCError(
                 'user group `%s` does not exist' % (usergroupid,))
 
     try:
         RepoModel().grant_user_group_permission(
             repo=repo, group_name=user_group, perm=perm)
 
         Session().commit()
         return {
             'msg': 'Granted perm: `%s` for user group: `%s` in '
                    'repo: `%s`' % (
                        perm.permission_name, user_group.users_group_name,
                        repo.repo_name
                    ),
             'success': True
         }
     except Exception:
         log.exception(
             "Exception occurred while trying change permission on repo")
         raise JSONRPCError(
             'failed to edit permission for user group: `%s` in '
             'repo: `%s`' % (
                 usergroupid, repo.repo_name
             )
         )
 
 
 @jsonrpc_method()
 def revoke_user_group_permission(request, apiuser, repoid, usergroupid):
     """
     Revoke the permissions of a user group on a given repository.
 
     This command can only be run using an |authtoken| with admin
     permissions on the |repo|.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: Set the repository name or repository ID.
     :type repoid: str or int
     :param usergroupid: Specify the user group ID.
     :type usergroupid: str or int
 
     Example output:
 
     .. code-block:: bash
 
         id : <id_given_in_input>
         result: {
                   "msg" : "Revoked perm for group: `<usersgroupname>` in repo: `<reponame>`",
                   "success": true
                 }
         error:  null
     """
 
     repo = get_repo_or_error(repoid)
     if not has_superadmin_permission(apiuser):
         _perms = ('repository.admin',)
         validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     user_group = get_user_group_or_error(usergroupid)
     if not has_superadmin_permission(apiuser):
         # check if we have at least read permission for this user group !
         _perms = ('usergroup.read', 'usergroup.write', 'usergroup.admin',)
         if not HasUserGroupPermissionAnyApi(*_perms)(
                 user=apiuser, user_group_name=user_group.users_group_name):
             raise JSONRPCError(
                 'user group `%s` does not exist' % (usergroupid,))
 
     try:
         RepoModel().revoke_user_group_permission(
             repo=repo, group_name=user_group)
 
         Session().commit()
         return {
             'msg': 'Revoked perm for user group: `%s` in repo: `%s`' % (
                 user_group.users_group_name, repo.repo_name
             ),
             'success': True
         }
     except Exception:
         log.exception("Exception occurred while trying revoke "
                       "user group permission on repo")
         raise JSONRPCError(
             'failed to edit permission for user group: `%s` in '
             'repo: `%s`' % (
                 user_group.users_group_name, repo.repo_name
             )
         )
 
 
 @jsonrpc_method()
 def pull(request, apiuser, repoid):
     """
     Triggers a pull on the given repository from a remote location. You
     can use this to keep remote repositories up-to-date.
 
     This command can only be run using an |authtoken| with admin
     rights to the specified repository. For more information,
     see :ref:`config-token-ref`.
 
     This command takes the following options:
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: The repository name or repository ID.
     :type repoid: str or int
 
     Example output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : {
         "msg": "Pulled from `<repository name>`"
         "repository": "<repository name>"
       }
       error :  null
 
     Example error output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : null
       error :  {
         "Unable to pull changes from `<reponame>`"
       }
 
     """
 
     repo = get_repo_or_error(repoid)
     if not has_superadmin_permission(apiuser):
         _perms = ('repository.admin',)
         validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     try:
         ScmModel().pull_changes(repo.repo_name, apiuser.username)
         return {
             'msg': 'Pulled from `%s`' % repo.repo_name,
             'repository': repo.repo_name
         }
     except Exception:
         log.exception("Exception occurred while trying to "
                       "pull changes from remote location")
         raise JSONRPCError(
             'Unable to pull changes from `%s`' % repo.repo_name
         )
 
 
 @jsonrpc_method()
 def strip(request, apiuser, repoid, revision, branch):
     """
     Strips the given revision from the specified repository.
 
     * This will remove the revision and all of its decendants.
 
     This command can only be run using an |authtoken| with admin rights to
     the specified repository.
 
     This command takes the following options:
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: The repository name or repository ID.
     :type repoid: str or int
     :param revision: The revision you wish to strip.
     :type revision: str
     :param branch: The branch from which to strip the revision.
     :type branch: str
 
     Example output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : {
         "msg": "'Stripped commit <commit_hash> from repo `<repository name>`'"
         "repository": "<repository name>"
       }
       error :  null
 
     Example error output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : null
       error :  {
         "Unable to strip commit <commit_hash> from repo `<repository name>`"
       }
 
     """
 
     repo = get_repo_or_error(repoid)
     if not has_superadmin_permission(apiuser):
         _perms = ('repository.admin',)
         validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     try:
         ScmModel().strip(repo, revision, branch)
         audit_logger.store_api(
             'repo.commit.strip', action_data={'commit_id': revision},
             repo=repo,
             user=apiuser, commit=True)
 
         return {
             'msg': 'Stripped commit %s from repo `%s`' % (
                 revision, repo.repo_name),
             'repository': repo.repo_name
         }
     except Exception:
         log.exception("Exception while trying to strip")
         raise JSONRPCError(
             'Unable to strip commit %s from repo `%s`' % (
                 revision, repo.repo_name)
         )
 
 
 @jsonrpc_method()
 def get_repo_settings(request, apiuser, repoid, key=Optional(None)):
     """
     Returns all settings for a repository. If key is given it only returns the
     setting identified by the key or null.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: The repository name or repository id.
     :type repoid: str or int
     :param key: Key of the setting to return.
     :type: key: Optional(str)
 
     Example output:
 
     .. code-block:: bash
 
         {
             "error": null,
             "id": 237,
             "result": {
                 "extensions_largefiles": true,
                 "extensions_evolve": true,
                 "hooks_changegroup_push_logger": true,
                 "hooks_changegroup_repo_size": false,
                 "hooks_outgoing_pull_logger": true,
                 "phases_publish": "True",
                 "rhodecode_hg_use_rebase_for_merging": true,
                 "rhodecode_pr_merge_enabled": true,
                 "rhodecode_use_outdated_comments": true
             }
         }
     """
 
     # Restrict access to this api method to admins only.
     if not has_superadmin_permission(apiuser):
         raise JSONRPCForbidden()
 
     try:
         repo = get_repo_or_error(repoid)
         settings_model = VcsSettingsModel(repo=repo)
         settings = settings_model.get_global_settings()
         settings.update(settings_model.get_repo_settings())
 
         # If only a single setting is requested fetch it from all settings.
         key = Optional.extract(key)
         if key is not None:
             settings = settings.get(key, None)
     except Exception:
         msg = 'Failed to fetch settings for repository `{}`'.format(repoid)
         log.exception(msg)
         raise JSONRPCError(msg)
 
     return settings
 
 
 @jsonrpc_method()
 def set_repo_settings(request, apiuser, repoid, settings):
     """
     Update repository settings. Returns true on success.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: The repository name or repository id.
     :type repoid: str or int
     :param settings: The new settings for the repository.
     :type: settings: dict
 
     Example output:
 
     .. code-block:: bash
 
         {
             "error": null,
             "id": 237,
             "result": true
         }
     """
     # Restrict access to this api method to admins only.
     if not has_superadmin_permission(apiuser):
         raise JSONRPCForbidden()
 
     if type(settings) is not dict:
         raise JSONRPCError('Settings have to be a JSON Object.')
 
     try:
         settings_model = VcsSettingsModel(repo=repoid)
 
         # Merge global, repo and incoming settings.
         new_settings = settings_model.get_global_settings()
         new_settings.update(settings_model.get_repo_settings())
         new_settings.update(settings)
 
         # Update the settings.
         inherit_global_settings = new_settings.get(
             'inherit_global_settings', False)
         settings_model.create_or_update_repo_settings(
             new_settings, inherit_global_settings=inherit_global_settings)
         Session().commit()
     except Exception:
         msg = 'Failed to update settings for repository `{}`'.format(repoid)
         log.exception(msg)
         raise JSONRPCError(msg)
 
     # Indicate success.
     return True
 
 
 @jsonrpc_method()
 def maintenance(request, apiuser, repoid):
     """
     Triggers a maintenance on the given repository.
 
     This command can only be run using an |authtoken| with admin
     rights to the specified repository. For more information,
     see :ref:`config-token-ref`.
 
     This command takes the following options:
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: The repository name or repository ID.
     :type repoid: str or int
 
     Example output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : {
         "msg": "executed maintenance command",
         "executed_actions": [
            <action_message>, <action_message2>...
         ],
         "repository": "<repository name>"
       }
       error :  null
 
     Example error output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : null
       error :  {
         "Unable to execute maintenance on `<reponame>`"
       }
 
     """
 
     repo = get_repo_or_error(repoid)
     if not has_superadmin_permission(apiuser):
         _perms = ('repository.admin',)
         validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     try:
         maintenance = repo_maintenance.RepoMaintenance()
         executed_actions = maintenance.execute(repo)
 
         return {
             'msg': 'executed maintenance command',
             'executed_actions': executed_actions,
             'repository': repo.repo_name
         }
     except Exception:
         log.exception("Exception occurred while trying to run maintenance")
         raise JSONRPCError(
             'Unable to execute maintenance on `%s`' % repo.repo_name)

rhodecode/api/views/repo_group_api.py

@@ -1,719 +1,719 b''
 # -*- coding: utf-8 -*-
 
-# Copyright (C) 2011-2017 RhodeCode GmbH
+# Copyright (C) 2011-2018 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 logging
 
 from rhodecode.api import JSONRPCValidationError
 from rhodecode.api import jsonrpc_method, JSONRPCError
 from rhodecode.api.utils import (
     has_superadmin_permission, Optional, OAttr, get_user_or_error,
     get_repo_group_or_error, get_perm_or_error, get_user_group_or_error,
     get_origin, validate_repo_group_permissions, validate_set_owner_permissions)
 from rhodecode.lib import audit_logger
 from rhodecode.lib.auth import (
     HasRepoGroupPermissionAnyApi, HasUserGroupPermissionAnyApi)
 from rhodecode.model.db import Session
 from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.model.scm import RepoGroupList
 from rhodecode.model import validation_schema
 from rhodecode.model.validation_schema.schemas import repo_group_schema
 
 
 log = logging.getLogger(__name__)
 
 
 @jsonrpc_method()
 def get_repo_group(request, apiuser, repogroupid):
     """
     Return the specified |repo| group, along with permissions,
     and repositories inside the group
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repogroupid: Specify the name of ID of the repository group.
     :type repogroupid: str or int
 
 
     Example output:
 
     .. code-block:: bash
 
         {
           "error": null,
           "id": repo-group-id,
           "result": {
             "group_description": "repo group description",
             "group_id": 14,
             "group_name": "group name",
             "permissions": [
               {
                 "name": "super-admin-username",
                 "origin": "super-admin",
                 "permission": "group.admin",
                 "type": "user"
               },
               {
                 "name": "owner-name",
                 "origin": "owner",
                 "permission": "group.admin",
                 "type": "user"
               },
               {
                 "name": "user-group-name",
                 "origin": "permission",
                 "permission": "group.write",
                 "type": "user_group"
               }
             ],
             "owner": "owner-name",
             "parent_group": null,
             "repositories": [ repo-list ]
           }
         }
     """
 
     repo_group = get_repo_group_or_error(repogroupid)
     if not has_superadmin_permission(apiuser):
         # check if we have at least read permission for this repo group !
         _perms = ('group.admin', 'group.write', 'group.read',)
         if not HasRepoGroupPermissionAnyApi(*_perms)(
                 user=apiuser, group_name=repo_group.group_name):
             raise JSONRPCError(
                 'repository group `%s` does not exist' % (repogroupid,))
 
     permissions = []
     for _user in repo_group.permissions():
         user_data = {
             'name': _user.username,
             'permission': _user.permission,
             'origin': get_origin(_user),
             'type': "user",
         }
         permissions.append(user_data)
 
     for _user_group in repo_group.permission_user_groups():
         user_group_data = {
             'name': _user_group.users_group_name,
             'permission': _user_group.permission,
             'origin': get_origin(_user_group),
             'type': "user_group",
         }
         permissions.append(user_group_data)
 
     data = repo_group.get_api_data()
     data["permissions"] = permissions
     return data
 
 
 @jsonrpc_method()
 def get_repo_groups(request, apiuser):
     """
     Returns all repository groups.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     """
 
     result = []
     _perms = ('group.read', 'group.write', 'group.admin',)
     extras = {'user': apiuser}
     for repo_group in RepoGroupList(RepoGroupModel().get_all(),
                                     perm_set=_perms, extra_kwargs=extras):
         result.append(repo_group.get_api_data())
     return result
 
 
 @jsonrpc_method()
 def create_repo_group(
         request, apiuser, group_name,
         owner=Optional(OAttr('apiuser')),
         description=Optional(''),
         copy_permissions=Optional(False)):
     """
     Creates a repository group.
 
     * If the repository group name contains "/", repository group will be
       created inside a repository group or nested repository groups
 
       For example "foo/bar/group1" will create repository group called "group1"
       inside group "foo/bar". You have to have permissions to access and
       write to the last repository group ("bar" in this example)
 
     This command can only be run using an |authtoken| with at least
     permissions to create repository groups, or admin permissions to
     parent repository groups.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param group_name: Set the repository group name.
     :type group_name: str
     :param description: Set the |repo| group description.
     :type description: str
     :param owner: Set the |repo| group owner.
     :type owner: str
     :param copy_permissions:
     :type copy_permissions:
 
     Example output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : {
           "msg": "Created new repo group `<repo_group_name>`"
           "repo_group": <repogroup_object>
       }
       error :  null
 
 
     Example error output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : null
       error :  {
         failed to create repo group `<repogroupid>`
       }
 
     """
 
     owner = validate_set_owner_permissions(apiuser, owner)
 
     description = Optional.extract(description)
     copy_permissions = Optional.extract(copy_permissions)
 
     schema = repo_group_schema.RepoGroupSchema().bind(
         # user caller
         user=apiuser)
 
     try:
         schema_data = schema.deserialize(dict(
             repo_group_name=group_name,
             repo_group_owner=owner.username,
             repo_group_description=description,
             repo_group_copy_permissions=copy_permissions,
         ))
     except validation_schema.Invalid as err:
         raise JSONRPCValidationError(colander_exc=err)
 
     validated_group_name = schema_data['repo_group_name']
 
     try:
         repo_group = RepoGroupModel().create(
             owner=owner,
             group_name=validated_group_name,
             group_description=schema_data['repo_group_name'],
             copy_permissions=schema_data['repo_group_copy_permissions'])
         Session().flush()
 
         repo_group_data = repo_group.get_api_data()
         audit_logger.store_api(
             'repo_group.create', action_data={'data': repo_group_data},
             user=apiuser)
 
         Session().commit()
         return {
             'msg': 'Created new repo group `%s`' % validated_group_name,
             'repo_group': repo_group.get_api_data()
         }
     except Exception:
         log.exception("Exception occurred while trying create repo group")
         raise JSONRPCError(
             'failed to create repo group `%s`' % (validated_group_name,))
 
 
 @jsonrpc_method()
 def update_repo_group(
         request, apiuser, repogroupid, group_name=Optional(''),
         description=Optional(''), owner=Optional(OAttr('apiuser')),
         enable_locking=Optional(False)):
     """
     Updates repository group with the details given.
 
     This command can only be run using an |authtoken| with admin
     permissions.
 
     * If the group_name name contains "/", repository group will be updated
       accordingly with a repository group or nested repository groups
 
       For example repogroupid=group-test group_name="foo/bar/group-test"
       will update repository group called "group-test" and place it
       inside group "foo/bar".
       You have to have permissions to access and write to the last repository
       group ("bar" in this example)
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repogroupid: Set the ID of repository group.
     :type repogroupid: str or int
     :param group_name: Set the name of the |repo| group.
     :type group_name: str
     :param description: Set a description for the group.
     :type description: str
     :param owner: Set the |repo| group owner.
     :type owner: str
     :param enable_locking: Enable |repo| locking. The default is false.
     :type enable_locking: bool
     """
 
     repo_group = get_repo_group_or_error(repogroupid)
 
     if not has_superadmin_permission(apiuser):
         validate_repo_group_permissions(
             apiuser, repogroupid, repo_group, ('group.admin',))
 
     updates = dict(
         group_name=group_name
         if not isinstance(group_name, Optional) else repo_group.group_name,
 
         group_description=description
         if not isinstance(description, Optional) else repo_group.group_description,
 
         user=owner
         if not isinstance(owner, Optional) else repo_group.user.username,
 
         enable_locking=enable_locking
         if not isinstance(enable_locking, Optional) else repo_group.enable_locking
     )
 
     schema = repo_group_schema.RepoGroupSchema().bind(
         # user caller
         user=apiuser,
         old_values=repo_group.get_api_data())
 
     try:
         schema_data = schema.deserialize(dict(
             repo_group_name=updates['group_name'],
             repo_group_owner=updates['user'],
             repo_group_description=updates['group_description'],
             repo_group_enable_locking=updates['enable_locking'],
         ))
     except validation_schema.Invalid as err:
         raise JSONRPCValidationError(colander_exc=err)
 
     validated_updates = dict(
         group_name=schema_data['repo_group']['repo_group_name_without_group'],
         group_parent_id=schema_data['repo_group']['repo_group_id'],
         user=schema_data['repo_group_owner'],
         group_description=schema_data['repo_group_description'],
         enable_locking=schema_data['repo_group_enable_locking'],
     )
 
     old_data = repo_group.get_api_data()
     try:
         RepoGroupModel().update(repo_group, validated_updates)
         audit_logger.store_api(
             'repo_group.edit', action_data={'old_data': old_data},
             user=apiuser)
 
         Session().commit()
         return {
             'msg': 'updated repository group ID:%s %s' % (
                 repo_group.group_id, repo_group.group_name),
             'repo_group': repo_group.get_api_data()
         }
     except Exception:
         log.exception(
             u"Exception occurred while trying update repo group %s",
             repogroupid)
         raise JSONRPCError('failed to update repository group `%s`'
                            % (repogroupid,))
 
 
 @jsonrpc_method()
 def delete_repo_group(request, apiuser, repogroupid):
     """
     Deletes a |repo| group.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repogroupid: Set the name or ID of repository group to be
         deleted.
     :type repogroupid: str or int
 
     Example output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : {
         'msg': 'deleted repo group ID:<repogroupid> <repogroupname>'
         'repo_group': null
       }
       error :  null
 
     Example error output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : null
       error :  {
         "failed to delete repo group ID:<repogroupid> <repogroupname>"
       }
 
     """
 
     repo_group = get_repo_group_or_error(repogroupid)
     if not has_superadmin_permission(apiuser):
         validate_repo_group_permissions(
             apiuser, repogroupid, repo_group, ('group.admin',))
 
     old_data = repo_group.get_api_data()
     try:
         RepoGroupModel().delete(repo_group)
         audit_logger.store_api(
             'repo_group.delete', action_data={'old_data': old_data},
             user=apiuser)
         Session().commit()
         return {
             'msg': 'deleted repo group ID:%s %s' %
                    (repo_group.group_id, repo_group.group_name),
             'repo_group': None
         }
     except Exception:
         log.exception("Exception occurred while trying to delete repo group")
         raise JSONRPCError('failed to delete repo group ID:%s %s' %
                            (repo_group.group_id, repo_group.group_name))
 
 
 @jsonrpc_method()
 def grant_user_permission_to_repo_group(
         request, apiuser, repogroupid, userid, perm,
         apply_to_children=Optional('none')):
     """
     Grant permission for a user on the given repository group, or update
     existing permissions if found.
 
     This command can only be run using an |authtoken| with admin
     permissions.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repogroupid: Set the name or ID of repository group.
     :type repogroupid: str or int
     :param userid: Set the user name.
     :type userid: str
     :param perm: (group.(none|read|write|admin))
     :type perm: str
     :param apply_to_children: 'none', 'repos', 'groups', 'all'
     :type apply_to_children: str
 
     Example output:
 
     .. code-block:: bash
 
         id : <id_given_in_input>
         result: {
                   "msg" : "Granted perm: `<perm>` (recursive:<apply_to_children>) for user: `<username>` in repo group: `<repo_group_name>`",
                   "success": true
                 }
         error:  null
 
     Example error output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : null
       error :  {
         "failed to edit permission for user: `<userid>` in repo group: `<repo_group_name>`"
       }
 
     """
 
     repo_group = get_repo_group_or_error(repogroupid)
 
     if not has_superadmin_permission(apiuser):
         validate_repo_group_permissions(
             apiuser, repogroupid, repo_group, ('group.admin',))
 
     user = get_user_or_error(userid)
     perm = get_perm_or_error(perm, prefix='group.')
     apply_to_children = Optional.extract(apply_to_children)
 
     perm_additions = [[user.user_id, perm, "user"]]
     try:
         RepoGroupModel().update_permissions(repo_group=repo_group,
                                             perm_additions=perm_additions,
                                             recursive=apply_to_children,
                                             cur_user=apiuser)
         Session().commit()
         return {
             'msg': 'Granted perm: `%s` (recursive:%s) for user: '
                    '`%s` in repo group: `%s`' % (
                        perm.permission_name, apply_to_children, user.username,
                        repo_group.name
                    ),
             'success': True
         }
     except Exception:
         log.exception("Exception occurred while trying to grant "
                       "user permissions to repo group")
         raise JSONRPCError(
             'failed to edit permission for user: '
             '`%s` in repo group: `%s`' % (userid, repo_group.name))
 
 
 @jsonrpc_method()
 def revoke_user_permission_from_repo_group(
         request, apiuser, repogroupid, userid,
         apply_to_children=Optional('none')):
     """
     Revoke permission for a user in a given repository group.
 
     This command can only be run using an |authtoken| with admin
     permissions on the |repo| group.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repogroupid: Set the name or ID of the repository group.
     :type repogroupid: str or int
     :param userid: Set the user name to revoke.
     :type userid: str
     :param apply_to_children: 'none', 'repos', 'groups', 'all'
     :type apply_to_children: str
 
     Example output:
 
     .. code-block:: bash
 
         id : <id_given_in_input>
         result: {
                   "msg" : "Revoked perm (recursive:<apply_to_children>) for user: `<username>` in repo group: `<repo_group_name>`",
                   "success": true
                 }
         error:  null
 
     Example error output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : null
       error :  {
         "failed to edit permission for user: `<userid>` in repo group: `<repo_group_name>`"
       }
 
     """
 
     repo_group = get_repo_group_or_error(repogroupid)
 
     if not has_superadmin_permission(apiuser):
         validate_repo_group_permissions(
             apiuser, repogroupid, repo_group, ('group.admin',))
 
     user = get_user_or_error(userid)
     apply_to_children = Optional.extract(apply_to_children)
 
     perm_deletions = [[user.user_id, None, "user"]]
     try:
         RepoGroupModel().update_permissions(repo_group=repo_group,
                                             perm_deletions=perm_deletions,
                                             recursive=apply_to_children,
                                             cur_user=apiuser)
         Session().commit()
         return {
             'msg': 'Revoked perm (recursive:%s) for user: '
                    '`%s` in repo group: `%s`' % (
                        apply_to_children, user.username, repo_group.name
                    ),
             'success': True
         }
     except Exception:
         log.exception("Exception occurred while trying revoke user "
                       "permission from repo group")
         raise JSONRPCError(
             'failed to edit permission for user: '
             '`%s` in repo group: `%s`' % (userid, repo_group.name))
 
 
 @jsonrpc_method()
 def grant_user_group_permission_to_repo_group(
         request, apiuser, repogroupid, usergroupid, perm,
         apply_to_children=Optional('none'), ):
     """
     Grant permission for a user group on given repository group, or update
     existing permissions if found.
 
     This command can only be run using an |authtoken| with admin
     permissions on the |repo| group.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repogroupid: Set the name or id of repository group
     :type repogroupid: str or int
     :param usergroupid: id of usergroup
     :type usergroupid: str or int
     :param perm: (group.(none|read|write|admin))
     :type perm: str
     :param apply_to_children: 'none', 'repos', 'groups', 'all'
     :type apply_to_children: str
 
     Example output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : {
         "msg" : "Granted perm: `<perm>` (recursive:<apply_to_children>) for user group: `<usersgroupname>` in repo group: `<repo_group_name>`",
         "success": true
 
       }
       error :  null
 
     Example error output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : null
       error :  {
         "failed to edit permission for user group: `<usergroup>` in repo group: `<repo_group_name>`"
       }
 
     """
 
     repo_group = get_repo_group_or_error(repogroupid)
     perm = get_perm_or_error(perm, prefix='group.')
     user_group = get_user_group_or_error(usergroupid)
     if not has_superadmin_permission(apiuser):
         validate_repo_group_permissions(
             apiuser, repogroupid, repo_group, ('group.admin',))
 
         # check if we have at least read permission for this user group !
         _perms = ('usergroup.read', 'usergroup.write', 'usergroup.admin',)
         if not HasUserGroupPermissionAnyApi(*_perms)(
                 user=apiuser, user_group_name=user_group.users_group_name):
             raise JSONRPCError(
                 'user group `%s` does not exist' % (usergroupid,))
 
     apply_to_children = Optional.extract(apply_to_children)
 
     perm_additions = [[user_group.users_group_id, perm, "user_group"]]
     try:
         RepoGroupModel().update_permissions(repo_group=repo_group,
                                             perm_additions=perm_additions,
                                             recursive=apply_to_children,
                                             cur_user=apiuser)
         Session().commit()
         return {
             'msg': 'Granted perm: `%s` (recursive:%s) '
                    'for user group: `%s` in repo group: `%s`' % (
                        perm.permission_name, apply_to_children,
                        user_group.users_group_name, repo_group.name
                    ),
             'success': True
         }
     except Exception:
         log.exception("Exception occurred while trying to grant user "
                       "group permissions to repo group")
         raise JSONRPCError(
             'failed to edit permission for user group: `%s` in '
             'repo group: `%s`' % (
                 usergroupid, repo_group.name
             )
         )
 
 
 @jsonrpc_method()
 def revoke_user_group_permission_from_repo_group(
         request, apiuser, repogroupid, usergroupid,
         apply_to_children=Optional('none')):
     """
     Revoke permission for user group on given repository.
 
     This command can only be run using an |authtoken| with admin
     permissions on the |repo| group.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repogroupid: name or id of repository group
     :type repogroupid: str or int
     :param usergroupid:
     :param apply_to_children: 'none', 'repos', 'groups', 'all'
     :type apply_to_children: str
 
     Example output:
 
     .. code-block:: bash
 
         id : <id_given_in_input>
         result: {
                   "msg" : "Revoked perm (recursive:<apply_to_children>) for user group: `<usersgroupname>` in repo group: `<repo_group_name>`",
                   "success": true
                 }
         error:  null
 
     Example error output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : null
       error :  {
         "failed to edit permission for user group: `<usergroup>` in repo group: `<repo_group_name>`"
       }
 
 
     """
 
     repo_group = get_repo_group_or_error(repogroupid)
     user_group = get_user_group_or_error(usergroupid)
     if not has_superadmin_permission(apiuser):
         validate_repo_group_permissions(
             apiuser, repogroupid, repo_group, ('group.admin',))
 
         # check if we have at least read permission for this user group !
         _perms = ('usergroup.read', 'usergroup.write', 'usergroup.admin',)
         if not HasUserGroupPermissionAnyApi(*_perms)(
                 user=apiuser, user_group_name=user_group.users_group_name):
             raise JSONRPCError(
                 'user group `%s` does not exist' % (usergroupid,))
 
     apply_to_children = Optional.extract(apply_to_children)
 
     perm_deletions = [[user_group.users_group_id, None, "user_group"]]
     try:
         RepoGroupModel().update_permissions(repo_group=repo_group,
                                             perm_deletions=perm_deletions,
                                             recursive=apply_to_children,
                                             cur_user=apiuser)
         Session().commit()
         return {
             'msg': 'Revoked perm (recursive:%s) for user group: '
                    '`%s` in repo group: `%s`' % (
                        apply_to_children, user_group.users_group_name,
                        repo_group.name
                    ),
             'success': True
         }
     except Exception:
         log.exception("Exception occurred while trying revoke user group "
                       "permissions from repo group")
         raise JSONRPCError(
             'failed to edit permission for user group: '
             '`%s` in repo group: `%s`' % (
                 user_group.users_group_name, repo_group.name
             )
         )