copyrights: updated for 2023

conftest.py

@@ -1,58 +1,58 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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 # noqa
 
 # keep the imports to have a toplevel conftest.py but still importable from EE edition
 from rhodecode.tests.conftest_common import ( # noqa
     pytest_generate_tests,
     pytest_runtest_makereport,
     pytest_addoption
 )
 
 
 pytest_plugins = [
     "rhodecode.tests.fixture_mods.fixture_pyramid",
     "rhodecode.tests.fixture_mods.fixture_utils",
 ]
 
 
 def pytest_configure(config):
     from rhodecode.config import patches # noqa
 
 
 def pytest_collection_modifyitems(session, config, items):
     # nottest marked, compare nose, used for transition from nose to pytest
     remaining = [
         i for i in items if getattr(i.obj, '__test__', True)]
     items[:] = remaining
 
     # NOTE(marcink): custom test ordering, db tests and vcstests are slowest and should
     # be executed at the end for faster test feedback
     def sorter(item):
         pos = 0
         key = item._nodeid
         if key.startswith('rhodecode/tests/database'):
             pos = 1
         elif key.startswith('rhodecode/tests/vcs_operations'):
             pos = 2
 
         return pos
 
     items.sort(key=sorter)

rhodecode/__init__.py

@@ -1,88 +1,88 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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 datetime
 import collections
 
 now = datetime.datetime.now()
 now = now.strftime("%Y-%m-%d %H:%M:%S") + '.' + "{:03d}".format(int(now.microsecond/1000))
 
 print(f'{now} Starting RhodeCode imports...')
 
 VERSION = tuple(open(os.path.join(
     os.path.dirname(__file__), 'VERSION')).read().split('.'))
 
 BACKENDS = collections.OrderedDict()
 
 BACKENDS['hg'] = 'Mercurial repository'
 BACKENDS['git'] = 'Git repository'
 BACKENDS['svn'] = 'Subversion repository'
 
 
 CELERY_ENABLED = False
 CELERY_EAGER = False
 
 # link to config for pyramid
 CONFIG = {}
 
 
 class ConfigGet:
     NotGiven = object()
 
     def _get_val_or_missing(self, key, missing):
         if key not in CONFIG:
             if missing == self.NotGiven:
                 return missing
             # we don't get key, we don't get missing value, return nothing similar as config.get(key)
             return None
         else:
             val = CONFIG[key]
         return val
 
     def get_str(self, key, missing=NotGiven):
         from rhodecode.lib.str_utils import safe_str
         val = self._get_val_or_missing(key, missing)
         return safe_str(val)
 
     def get_int(self, key, missing=NotGiven):
         from rhodecode.lib.str_utils import safe_int
         val = self._get_val_or_missing(key, missing)
         return safe_int(val)
 
     def get_bool(self, key, missing=NotGiven):
         from rhodecode.lib.type_utils import str2bool
         val = self._get_val_or_missing(key, missing)
         return str2bool(val)
 
 # 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__ = 114  # defines current db version for migrations
 __license__ = 'AGPLv3, and Commercial License'
 __author__ = 'RhodeCode GmbH'
 __url__ = 'https://code.rhodecode.com'
 
 is_test = False
 disable_error_handler = False

rhodecode/api/__init__.py

@@ -1,576 +1,576 b''
 
 
-# Copyright (C) 2011-2020 RhodeCode GmbH
+# Copyright (C) 2011-2023 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 itertools
 import logging
 import sys
 import fnmatch
 
 import decorator
 import typing
 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.exc_tracking import store_exception
 from rhodecode.lib import ext_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 makes use of our ext_json lib
 
     """
 
     def __init__(self):
         self.serializer = ext_json.formatted_json
 
     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)
 
         return _render
 
 
 def jsonrpc_response(request, result):
     rpc_id = getattr(request, 'rpc_id', None)
 
     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)
     content_type = 'application/json'
     content_type_header = 'Content-Type'
     headers = {
         content_type_header: content_type
     }
     return Response(
         body=raw_body,
         content_type=content_type,
         headerlist=[(k, v) for k, v in headers.items()]
     )
 
 
 def jsonrpc_error(request, message, retid=None, code: typing.Optional[int] = None, headers: typing.Optional[dict] = None):
     """
     Generate a Response object with a JSON-RPC error body
     """
     headers = headers or {}
     content_type = 'application/json'
     content_type_header = 'Content-Type'
     if content_type_header not in headers:
         headers[content_type_header] = content_type
 
     err_dict = {'id': retid, 'result': None, 'error': message}
     raw_body = render(DEFAULT_RENDERER, err_dict, request=request)
 
     return Response(
         body=raw_body,
         status=code,
         content_type=content_type,
         headerlist=[(k, v) for k, v in headers.items()]
     )
 
 
 def exception_view(exc, request):
     rpc_id = getattr(request, 'rpc_id', None)
 
     if isinstance(exc, JSONRPCError):
         fault_message = safe_str(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 colander 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, list(request.registry.jsonrpc_methods.keys()), rpc_id)
 
         similar = 'none'
         try:
             similar_paterns = [f'*{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)
     else:
         fault_message = 'undefined error'
         exc_info = exc.exc_info()
         store_exception(id(exc_info), exc_info, prefix='rhodecode-api')
 
         statsd = request.registry.statsd
         if statsd:
             exc_type = "{}.{}".format(exc.__class__.__module__, exc.__class__.__name__)
             statsd.incr('rhodecode_exception_total',
                         tags=["exc_source:api", "type:{}".format(exc_type)])
 
     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
     """
     # cython compatible inspect
     from rhodecode.config.patches import inspect_getargspec
     inspect = inspect_getargspec()
 
     # 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
         request.environ['rc_auth_user_id'] = str(auth_u.user_id)
 
         # 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]
     defs = argspec[3] or []
     defaults = [type(a) for a in defs]
     default_empty = type(NotImplemented)
 
     # kw arguments required by this method
     func_kwargs = dict(itertools.zip_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 list(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)
 
     statsd = request.registry.statsd
 
     try:
         ret_value = func(**call_params)
         resp = jsonrpc_response(request, ret_value)
         if statsd:
             statsd.incr('rhodecode_api_call_success_total')
         return resp
     except JSONRPCBaseError:
         raise
     except Exception:
         log.exception('Unhandled exception occurred on api call: %s', func)
         exc_info = sys.exc_info()
         exc_id, exc_type_name = store_exception(
             id(exc_info), exc_info, prefix='rhodecode-api')
         error_headers = {
             'RhodeCode-Exception-Id': str(exc_id),
             'RhodeCode-Exception-Type': str(exc_type_name)
         }
         err_resp = jsonrpc_error(
             request, retid=request.rpc_id, message='Internal server error',
             headers=error_headers)
         if statsd:
             statsd.incr('rhodecode_api_call_fail_total')
         return err_resp
 
 
 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
     log.debug("Loading JSON body now")
     try:
         json_body = ext_json.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: %.10240r', request.rpc_method, request.rpc_params)
     except KeyError as e:
         raise JSONRPCError(f'Incorrect JSON data. Missing {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 f'jsonrpc route = {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 f'jsonrpc method not found = {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 f'jsonrpc method = {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 add_api_methods(config):
     from rhodecode.api.views import (
         deprecated_api, gist_api, pull_request_api, repo_api, repo_group_api,
         server_api, search_api, testing_api, user_api, user_group_api)
 
     config.scan('rhodecode.api.views')
 
 
 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_view_predicate('jsonrpc_method_not_found', NotFoundPredicate)
 
     config.add_renderer(DEFAULT_RENDERER, ExtJsonRenderer())
     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)
 
     # register some exception handling view
     config.add_view(exception_view, context=JSONRPCBaseError)
     config.add_notfound_view(exception_view, jsonrpc_method_not_found=True)
 
     add_api_methods(config)

rhodecode/api/exc.py

@@ -1,42 +1,42 b''
 
 
-# Copyright (C) 2011-2020 RhodeCode GmbH
+# Copyright (C) 2011-2023 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):
     def __init__(self, message='', *args):
         self.message = message
         super(JSONRPCBaseError, self).__init__(message, *args)
 
 
 class JSONRPCError(JSONRPCBaseError):
     pass
 
 
 class JSONRPCValidationError(JSONRPCBaseError):
 
     def __init__(self, *args, **kwargs):
         self.colander_exception = kwargs.pop('colander_exc')
         super(JSONRPCValidationError, self).__init__(
             message=self.colander_exception, *args)
 
 
 class JSONRPCForbidden(JSONRPCBaseError):
     pass
 

rhodecode/api/tests/__init__.py

@@ -1,18 +1,18 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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,51 +1,51 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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,61 +1,61 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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,71 +1,71 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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,133 +1,133 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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(b'"args": {}', b'"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(b'"args": {}', b'"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, edit_comment, ' \
                    'get_comment, get_repo_comments'
         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(b'"args": {}', b'"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(b'"args": {}', b'"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''
 
 
-# Copyright (C) 2017-2020 RhodeCode GmbH
+# Copyright (C) 2017-2023 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,112 +1,112 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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(UserLog.user_log_id.asc()) \
             .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,115 +1,115 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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, User
 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().name, 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_commit(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_commit().raw_id, backend.repo_name),
             'status_change': status_change,
             'success': True
         }
         assert_ok(id_, expected, given=response.body)
 
     def test_api_comment_commit_with_extra_recipients(self, backend, user_util):
 
         commit_id = backend.repo.scm_instance().get_commit('tip').raw_id
 
         user1 = user_util.create_user()
         user1_id = user1.user_id
         user2 = user_util.create_user()
         user2_id = user2.user_id
 
         id_, params = build_data(
             self.apikey, 'comment_commit', repoid=backend.repo_name,
             commit_id=commit_id,
             message='abracadabra',
             extra_recipients=[user1.user_id, user2.username])
 
         response = api_call(self.app, params)
         repo = backend.repo.scm_instance()
 
         expected = {
             'msg': 'Commented on commit `%s` for repository `%s`' % (
                 repo.get_commit().raw_id, backend.repo_name),
             'status_change': None,
             'success': True
         }
 
         assert_ok(id_, expected, given=response.body)
         # check user1/user2 inbox for notification
         user1 = User.get(user1_id)
         assert 1 == len(user1.notifications)
         assert 'abracadabra' in user1.notifications[0].notification.body
 
         user2 = User.get(user2_id)
         assert 1 == len(user2.notifications)
         assert 'abracadabra' in user2.notifications[0].notification.body

rhodecode/api/tests/test_comment_pull_request.py

@@ -1,380 +1,380 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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, User, ChangesetComment
 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(UserLog.user_log_id.asc()) \
             .all()
         assert journal[-1].action == 'repo.pull_request.comment.create'
 
     @pytest.mark.backends("git", "hg")
     def test_api_comment_pull_request_with_extra_recipients(self, pr_util, user_util):
         pull_request = pr_util.create_pull_request()
 
         user1 = user_util.create_user()
         user1_id = user1.user_id
         user2 = user_util.create_user()
         user2_id = user2.user_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',
             extra_recipients=[user1.user_id, user2.username]
         )
         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)
         # check user1/user2 inbox for notification
         user1 = User.get(user1_id)
         assert 1 == len(user1.notifications)
         assert 'test message' in user1.notifications[0].notification.body
 
         user2 = User.get(user2_id)
         assert 1 == len(user2.notifications)
         assert 'test message' in user2.notifications[0].notification.body
 
     @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_and_test_commit(
             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',
             message='test-change-of-status-not-allowed',
             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': 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)
 
     @pytest.mark.backends("git", "hg")
     def test_api_edit_comment(self, pr_util):
         pull_request = pr_util.create_pull_request()
 
         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)
         json_response = response.json
         comment_id = json_response['result']['comment_id']
 
         message_after_edit = 'just message'
         id_, params = build_data(
             self.apikey,
             'edit_comment',
             comment_id=comment_id,
             message=message_after_edit,
             version=0,
         )
         response = api_call(self.app, params)
         json_response = response.json
         assert json_response['result']['version'] == 1
 
         text_form_db = ChangesetComment.get(comment_id).text
         assert message_after_edit == text_form_db
 
     @pytest.mark.backends("git", "hg")
     def test_api_edit_comment_wrong_version_mismatch(self, pr_util):
         pull_request = pr_util.create_pull_request()
 
         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)
         json_response = response.json
         comment_id = json_response['result']['comment_id']
 
         message_after_edit = 'just message'
         id_, params = build_data(
             self.apikey,
             'edit_comment',
             comment_id=comment_id,
             message=message_after_edit,
             version=1,
         )
         response = api_call(self.app, params)
         expected = 'comment ({}) version ({}) mismatch'.format(comment_id, 1)
         assert_error(id_, expected, given=response.body)
 
     @pytest.mark.backends("git", "hg")
     def test_api_edit_comment_wrong_version(self, pr_util):
         pull_request = pr_util.create_pull_request()
 
         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)
         json_response = response.json
         comment_id = json_response['result']['comment_id']
 
         id_, params = build_data(
             self.apikey,
             'edit_comment',
             comment_id=comment_id,
             message='',
             version=0,
         )
         response = api_call(self.app, params)
         expected = f"comment ({comment_id}) can't be changed with empty string"
         assert_error(id_, expected, given=response.body)
 
     @pytest.mark.backends("git", "hg")
     def test_api_edit_comment_wrong_user_set_by_non_admin(self, pr_util):
         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_id,
             message='test message'
         )
         response = api_call(self.app, params)
         json_response = response.json
         comment_id = json_response['result']['comment_id']
 
         id_, params = build_data(
             self.apikey_regular,
             'edit_comment',
             comment_id=comment_id,
             message='just message',
             version=0,
             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_edit_comment_wrong_user_with_permissions_to_edit_comment(self, pr_util):
         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_id,
             message='test message'
         )
         response = api_call(self.app, params)
         json_response = response.json
         comment_id = json_response['result']['comment_id']
 
         id_, params = build_data(
             self.apikey_regular,
             'edit_comment',
             comment_id=comment_id,
             message='just message',
             version=0,
         )
         response = api_call(self.app, params)
         expected = "you don't have access to edit this comment"
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_create_gist.py

@@ -1,101 +1,101 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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,367 +1,367 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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',
         }
         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")
     @pytest.mark.parametrize('source_ref', [
         'bookmarg:default:initial'
     ])
     def test_create_with_wrong_refs_data(self, backend, source_ref):
 
         data = self._prepare_data(backend)
         data['source_ref'] = source_ref
 
         id_, params = build_data(
             self.apikey_regular, 'create_pull_request', **data)
 
         response = api_call(self.app, params)
 
         expected = "Ref `{}` type is not allowed. " \
                    "Only:['bookmark', 'book', 'tag', 'branch'] " \
                    "are possible.".format(source_ref)
         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['error'] is None
         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['error'] is None
         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_empty_title(self, backend):
         data = self._prepare_data(backend)
         data.pop('title')
         id_, params = build_data(
             self.apikey_regular, 'create_pull_request', **data)
         response = api_call(self.app, params)
         result = response.json
         pull_request_id = result['result']['pull_request_id']
         pull_request = PullRequestModel().get(pull_request_id)
         data['ref'] = backend.default_branch_name
         title = '{source_repo}#{ref} to {target_repo}'.format(**data)
         assert pull_request.title == title
 
     @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'.format(TEST_USER_REGULAR_LOGIN)]},
             {'username': TEST_USER_ADMIN_LOGIN,
              'reasons': ['{} added manually'.format(TEST_USER_ADMIN_LOGIN)],
              'mandatory': True},
         ]
         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['error'] is None
         assert result['result']['msg'] == expected_message
         pull_request_id = result['result']['pull_request_id']
         pull_request = PullRequestModel().get(pull_request_id)
 
         actual_reviewers = []
         for rev in pull_request.reviewers:
             entry = {
                 'username': rev.user.username,
                 'reasons': rev.reasons,
              }
             if rev.mandatory:
                 entry['mandatory'] = rev.mandatory
             actual_reviewers.append(entry)
 
         owner_username = pull_request.target_repo.user.username
         for spec_reviewer in reviewers[::]:
             # default reviewer will be added who is an owner of the repo
             # this get's overridden by a add owner to reviewers rule
             if spec_reviewer['username'] == owner_username:
                 spec_reviewer['reasons'] = [u'Default reviewer', u'Repository owner']
                 # since owner is more important, we don't inherit mandatory flag
                 del spec_reviewer['mandatory']
 
         assert sorted(actual_reviewers, key=lambda e: e['username']) \
                == sorted(reviewers, key=lambda e: e['username'])
 
     @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['error'] is None
         assert result['result']['msg'] == expected_message
         pull_request_id = result['result']['pull_request_id']
         pull_request = PullRequestModel().get(pull_request_id)
 
         actual_reviewers = []
         for rev in pull_request.reviewers:
             entry = {
                 'username': rev.user.user_id,
                 'reasons': rev.reasons,
              }
             if rev.mandatory:
                 entry['mandatory'] = rev.mandatory
             actual_reviewers.append(entry)
 
         owner_user_id = pull_request.target_repo.user.user_id
         for spec_reviewer in reviewers[::]:
             # default reviewer will be added who is an owner of the repo
             # this get's overridden by a add owner to reviewers rule
             if spec_reviewer['username'] == owner_user_id:
                 spec_reviewer['reasons'] = [u'Default reviewer', u'Repository owner']
 
         assert sorted(actual_reviewers, key=lambda e: e['username']) \
                == sorted(reviewers, key=lambda e: e['username'])
 
     @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 value:{type}:`{name}` ' \
                            'does not exist, or is not allowed.'.format(type='branch',
                                                                        name=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 for merge between specified references'
         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, self.test_user)
         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 = '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,348 +1,348 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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.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
 from rhodecode.lib.ext_json import json
 from rhodecode.lib.str_utils import safe_str
 
 
 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_str(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_str(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,288 +1,288 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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':
                 u"You do not have the permissions to store "
                 u"repository groups inside repository group `{}`".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''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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,
             description='CTO of Things',
             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,126 +1,126 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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,60 +1,60 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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,73 +1,73 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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,85 +1,85 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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,56 +1,56 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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,105 +1,105 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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,78 +1,78 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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,278 +1,278 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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_fts_search.py

@@ -1,114 +1,114 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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 HG_REPO
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_ok)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestApiSearch(object):
 
     @pytest.mark.parametrize("sort_dir", [
         "asc",
         "desc",
     ])
     @pytest.mark.parametrize("sort", [
         "xxx",
         "author_email",
         "date",
         "message",
     ])
     @pytest.mark.parametrize("query, expected_hits, expected_paths", [
         ('todo', 23, [
             'vcs/backends/hg/inmemory.py',
             'vcs/tests/test_git.py']),
         ('extension:rst installation', 6, [
             'docs/index.rst',
             'docs/installation.rst']),
         ('def repo', 87, [
             'vcs/tests/test_git.py',
             'vcs/tests/test_changesets.py']),
         ('repository:%s def test' % HG_REPO, 18, [
             'vcs/tests/test_git.py',
             'vcs/tests/test_changesets.py']),
         ('"def main"', 9, [
             'vcs/__init__.py',
             'vcs/tests/__init__.py',
             'vcs/utils/progressbar.py']),
         ('owner:test_admin', 358, [
             'vcs/tests/base.py',
             'MANIFEST.in',
             'vcs/utils/termcolors.py',
             'docs/theme/ADC/static/documentation.png']),
         ('owner:test_admin def main', 72, [
             'vcs/__init__.py',
             'vcs/tests/test_utils_filesize.py',
             'vcs/tests/test_cli.py']),
         ('owner:michał test', 0, []),
     ])
     def test_search_content_results(self, sort_dir, sort, query, expected_hits, expected_paths):
         id_, params = build_data(
             self.apikey_regular, 'search',
             search_query=query,
             search_sort='{}:{}'.format(sort_dir, sort),
             search_type='content')
 
         response = api_call(self.app, params)
         json_response = response.json
 
         assert json_response['result']['item_count'] == expected_hits
         paths = [x['f_path'] for x in json_response['result']['results']]
 
         for expected_path in expected_paths:
             assert expected_path in paths
 
     @pytest.mark.parametrize("sort_dir", [
         "asc",
         "desc",
     ])
     @pytest.mark.parametrize("sort", [
         "xxx",
         "date",
         "file",
         "size",
     ])
     @pytest.mark.parametrize("query, expected_hits, expected_paths", [
         ('readme.rst', 3, []),
         ('test*', 75, []),
         ('*model*', 1, []),
         ('extension:rst', 48, []),
         ('extension:rst api', 24, []),
     ])
     def test_search_file_paths(self, sort_dir, sort, query, expected_hits, expected_paths):
         id_, params = build_data(
             self.apikey_regular, 'search',
             search_query=query,
             search_sort='{}:{}'.format(sort_dir, sort),
             search_type='path')
 
         response = api_call(self.app, params)
         json_response = response.json
 
         assert json_response['result']['item_count'] == expected_hits
         paths = [x['f_path'] for x in json_response['result']['results']]
 
         for expected_path in expected_paths:
             assert expected_path in paths

rhodecode/api/tests/test_get_gist.py

@@ -1,101 +1,101 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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.str_utils import safe_bytes
 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 = {
             b'filename1.txt': {'content': b'hello world'},
             safe_bytes('filename1ą.txt'): {'content': safe_bytes('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,73 +1,73 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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,35 +1,35 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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,90 +1,90 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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,62 +1,62 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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', 'edit_comment', 'get_comment', 'get_repo_comments'
         ]
         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:'note'>",
                      'commit_id': '<RequiredType>',
                      'extra_recipients': '<Optional:[]>',
                      'message': '<RequiredType>',
                      'repoid': '<RequiredType>',
                      'request': '<RequiredType>',
                      'resolves_comment_id': '<Optional:None>',
                      'status': '<Optional:None>',
                      'userid': '<Optional:<OptionalAttr:apiuser>>',
                      'send_email': '<Optional:True>'}]
         assert_ok(id_, expected, given=response.body)

rhodecode/api/tests/test_get_pull_request.py

@@ -1,143 +1,143 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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.str_utils import safe_str
 
 
 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, merge_state=True)
 
         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_str(
             url_obj.with_netloc(http_host_only_stub))
         source_url = safe_str(
             pull_request.source_repo.clone_url().with_netloc(http_host_only_stub))
         target_url = safe_str(
             pull_request.target_repo.clone_url().with_netloc(http_host_only_stub))
         shadow_url = safe_str(
             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,
             'state': pull_request.pull_request_state,
             '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,83 +1,83 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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, assert_ok)
 
 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',
              'comment_resolved_by': None,
              'pull_request_version': None,
              'comment_last_version': 0,
              'comment_commit_id': None,
              'comment_pull_request_id': pull_request.pull_request_id
              }
         ]
         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,81 +1,81 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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=(),
             observers=(),
             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,142 +1,142 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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()
         repo_id = repo.repo_id
         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 = []
 
         repo = RepoModel().get(repo_id)
         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)
         repo_id = repo.repo_id
         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 = []
 
         repo = RepoModel().get(repo_id)
         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''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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', [])
             branches = [commit.branch] if commit.branch else []
             assert result['refs']['branches'] == branches
             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 got <class 'int'> instead"
         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 range(limit):
             assert result[x]['revision'] == x
 
         if details == 'full':
             for x in range(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 range(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 range(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 got <class 'int'> instead"
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_get_repo_comments.py

@@ -1,141 +1,141 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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, ChangesetComment
 from rhodecode.model.meta import Session
 from rhodecode.model.comment import CommentsModel
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_call_ok)
 
 
 @pytest.fixture()
 def make_repo_comments_factory(request):
 
     class Make(object):
 
         def make_comments(self, repo):
             user = User.get_first_super_admin()
             commit = repo.scm_instance()[0]
 
             commit_id = commit.raw_id
             file_0 = commit.affected_files[0]
             comments = []
 
             # general
             comment = CommentsModel().create(
                 text='General Comment', repo=repo, user=user, commit_id=commit_id,
                 comment_type=ChangesetComment.COMMENT_TYPE_NOTE, send_email=False)
             comments.append(comment)
 
             # inline
             comment = CommentsModel().create(
                 text='Inline Comment', repo=repo, user=user, commit_id=commit_id,
                 f_path=file_0, line_no='n1',
                 comment_type=ChangesetComment.COMMENT_TYPE_NOTE, send_email=False)
             comments.append(comment)
 
             # todo
             comment = CommentsModel().create(
                 text='INLINE TODO Comment', repo=repo, user=user, commit_id=commit_id,
                 f_path=file_0, line_no='n1',
                 comment_type=ChangesetComment.COMMENT_TYPE_TODO, send_email=False)
             comments.append(comment)
 
             return comments
 
     return Make()
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestGetRepo(object):
 
     @pytest.mark.parametrize('filters, expected_count', [
         ({}, 3),
         ({'comment_type': ChangesetComment.COMMENT_TYPE_NOTE}, 2),
         ({'comment_type': ChangesetComment.COMMENT_TYPE_TODO}, 1),
         ({'commit_id': 'FILLED DYNAMIC'}, 3),
     ])
     def test_api_get_repo_comments(self, backend, user_util,
                                    make_repo_comments_factory, filters, expected_count):
         commits = [{'message': 'A'}, {'message': 'B'}]
         repo = backend.create_repo(commits=commits)
         make_repo_comments_factory.make_comments(repo)
 
         api_call_params = {'repoid': repo.repo_name,}
         api_call_params.update(filters)
 
         if 'commit_id' in api_call_params:
             commit = repo.scm_instance()[0]
             commit_id = commit.raw_id
             api_call_params['commit_id'] = commit_id
 
         id_, params = build_data(self.apikey, 'get_repo_comments', **api_call_params)
         response = api_call(self.app, params)
         result = assert_call_ok(id_, given=response.body)
 
         assert len(result) == expected_count
 
     def test_api_get_repo_comments_wrong_comment_type(
             self, make_repo_comments_factory, backend_hg):
         commits = [{'message': 'A'}, {'message': 'B'}]
         repo = backend_hg.create_repo(commits=commits)
         make_repo_comments_factory.make_comments(repo)
 
         api_call_params = {'repoid': repo.repo_name}
         api_call_params.update({'comment_type': 'bogus'})
 
         expected = 'comment_type must be one of `{}` got {}'.format(
                     ChangesetComment.COMMENT_TYPES, 'bogus')
         id_, params = build_data(self.apikey, 'get_repo_comments', **api_call_params)
         response = api_call(self.app, params)
         assert_error(id_, expected, given=response.body)
 
     def test_api_get_comment(self, make_repo_comments_factory, backend_hg):
         commits = [{'message': 'A'}, {'message': 'B'}]
         repo = backend_hg.create_repo(commits=commits)
 
         comments = make_repo_comments_factory.make_comments(repo)
         comment_ids = [x.comment_id for x in comments]
         Session().commit()
 
         for comment_id in comment_ids:
             id_, params = build_data(self.apikey, 'get_comment',
                                      **{'comment_id': comment_id})
             response = api_call(self.app, params)
             result = assert_call_ok(id_, given=response.body)
             assert result['comment_id'] == comment_id
 
     def test_api_get_comment_no_access(self, make_repo_comments_factory, backend_hg, user_util):
         commits = [{'message': 'A'}, {'message': 'B'}]
         repo = backend_hg.create_repo(commits=commits)
         comments = make_repo_comments_factory.make_comments(repo)
         comment_id = comments[0].comment_id
 
         test_user = user_util.create_user()
         user_util.grant_user_permission_to_repo(repo, test_user, 'repository.none')
 
         id_, params = build_data(test_user.api_key, 'get_comment',
                                  **{'comment_id': comment_id})
         response = api_call(self.app, params)
         assert_error(id_,
                      expected='comment `{}` does not exist'.format(comment_id),
                      given=response.body)

rhodecode/api/tests/test_get_repo_group.py

@@ -1,54 +1,54 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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,39 +1,39 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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,141 +1,141 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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,39 +1,39 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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,128 +1,128 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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,83 +1,83 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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,85 +1,85 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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,75 +1,75 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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,69 +1,69 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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
 from rhodecode.lib.ext_json import json
 
 
 @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 result['result'] == expected_list

rhodecode/api/tests/test_get_users.py

@@ -1,39 +1,39 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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,89 +1,89 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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()
         user_util.create_repo(parent=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. Permission should start with prefix: `group.`' % (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,96 +1,96 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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,86 +1,86 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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,156 +1,156 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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. Permission should start with prefix: `group.`' % (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,155 +1,155 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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. Permission should start with prefix: `usergroup.`' % 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,67 +1,67 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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,258 +1,258 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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)
         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_merge_failed_disallowed_state(
             self, pr_util, no_notifications):
         pull_request = pr_util.create_pull_request(mergeable=True, approved=True)
         pull_request_id = pull_request.pull_request_id
         pull_request_repo = pull_request.target_repo.repo_name
 
         pr = PullRequest.get(pull_request_id)
         pr.pull_request_state = pull_request.STATE_UPDATING
         Session().add(pr)
         Session().commit()
 
         id_, params = build_data(
             self.apikey, 'merge_pull_request',
             repoid=pull_request_repo,
             pullrequestid=pull_request_id)
 
         response = api_call(self.app, params)
         expected = 'Operation forbidden because pull request is in state {}, '\
                    'only state {} is allowed.'.format(PullRequest.STATE_UPDATING,
                                                       PullRequest.STATE_CREATED)
         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,
             'merge_status_message': 'This pull request can be automatically merged.',
             '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(UserLog.user_log_id.asc()) \
             .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_as_another_user_no_perms_to_merge(
             self, pr_util, no_notifications, user_util):
         merge_user = user_util.create_user()
         merge_user_id = merge_user.user_id
         merge_user_username = merge_user.username
 
         pull_request = pr_util.create_pull_request(mergeable=True, approved=True)
 
         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,
             userid=merge_user_id
         )
 
         response = api_call(self.app, params)
         expected = 'merge not possible for following reasons: User `{}` ' \
                    'not allowed to perform merge.'.format(merge_user_username)
         assert_error(id_, expected, response.body)
 
     @pytest.mark.backends("git", "hg")
     def test_api_merge_pull_request_as_another_user(self, pr_util, no_notifications, user_util):
         merge_user = user_util.create_user()
         merge_user_id = merge_user.user_id
         pull_request = pr_util.create_pull_request(mergeable=True, approved=True)
         user_util.grant_user_permission_to_repo(
             pull_request.target_repo, merge_user, 'repository.write')
         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,
             userid=merge_user_id
         )
 
         response = api_call(self.app, params)
 
         pull_request = PullRequest.get(pull_request_id)
 
         expected = {
             'executed': True,
             'failure_reason': 0,
             'merge_status_message': 'This pull request can be automatically merged.',
             '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 == merge_user_id) \
             .filter(UserLog.repository_id == repo) \
             .order_by(UserLog.user_log_id.asc()) \
             .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, userid=merge_user_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,54 +1,54 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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 mock
 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
         clone_uri = os.path.join(TESTS_TMP_PATH, backend.repo_name)
         r.clone_uri = clone_uri
 
         id_, params = build_data(self.apikey, 'pull', repoid=repo_name,)
         with mock.patch('rhodecode.model.scm.url_validator'):
             response = api_call(self.app, params)
             msg = 'Pulled from url `%s` on repo `%s`' % (
                 clone_uri, repo_name)
             expected = {'msg': msg,
                         '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 `None`'
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_remove_field_from_repo.py

@@ -1,65 +1,65 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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,57 +1,57 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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,183 +1,183 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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,43 +1,43 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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,66 +1,66 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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,128 +1,128 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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,57 +1,57 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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,65 +1,65 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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,125 +1,125 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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,111 +1,111 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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_store_exception.py

@@ -1,58 +1,58 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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, assert_error
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestStoreException(object):
 
     def test_store_exception_invalid_json(self):
         id_, params = build_data(self.apikey, 'store_exception',
                                  exc_data_json='XXX,{')
         response = api_call(self.app, params)
 
         expected = 'Failed to parse JSON data from exc_data_json field. ' \
                    'Please make sure it contains a valid JSON.'
         assert_error(id_, expected, given=response.body)
 
     def test_store_exception_missing_json_params_json(self):
         id_, params = build_data(self.apikey, 'store_exception',
                                  exc_data_json='{"foo":"bar"}')
         response = api_call(self.app, params)
 
         expected = "Missing exc_traceback, or exc_type_name in " \
                    "exc_data_json field. Missing: 'exc_traceback'"
         assert_error(id_, expected, given=response.body)
 
     def test_store_exception(self):
         id_, params = build_data(
             self.apikey, 'store_exception',
             exc_data_json='{"exc_traceback": "invalid", "exc_type_name":"ValueError"}')
         response = api_call(self.app, params)
         exc_id = response.json['result']['exc_id']
 
         expected = {
             'exc_id': exc_id,
             'exc_url': 'http://example.com/_admin/settings/exceptions/{}'.format(exc_id)
         }
         assert_ok(id_, expected, given=response.body)

rhodecode/api/tests/test_update_pull_request.py

@@ -1,214 +1,214 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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": []},
             "updated_observers": {"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(b'file_b', b'test_content\n')]},
             {'message': 'c', 'added': [FileNode(b'file_c', b'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()]
 
         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": []},
             "updated_observers": {"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, 'reviewer', [])])
 
         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},
             "updated_observers": {"added": [], "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,209 +1,209 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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.model.scm import ScmModel
 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.fixture_mods.fixture_utils import plain_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': ''}),
 
         ({'clone_uri': 'http://example.com/repo_pull'},
          {'clone_uri': 'http://example.com/repo_pull'}),
 
         ({'push_uri': ''},
          {'push_uri': ''}),
 
         ({'push_uri': 'http://example.com/repo_push'},
          {'push_uri': 'http://example.com/repo_push'}),
 
         ({'landing_rev': None},  # auto-updated based on type of repo
          {'landing_rev': [None, None]}),
 
         ({'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(plain_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(
                 plain_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'])
 
         if 'landing_rev' in updates:
             default_landing_ref, _lbl = ScmModel.backend_landing_ref(backend.alias)
             _type, _name = default_landing_ref.split(':')
             updates['landing_rev'] = default_landing_ref
             expected['landing_rev'] = [_type, _name]
 
         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)
 
         with mock.patch('rhodecode.model.validation_schema.validators.url_validator'):
             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,149 +1,149 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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,120 +1,120 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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'),
         ('description', 'CTO 4 Life')
     ])
     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
         expected['user']['last_activity'] = response.json['result']['user'][
             'last_activity']
         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
         expected['user']['last_activity'] = response.json['result']['user'][
             'last_activity']
         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,124 +1,124 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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}),
         ('sync', {'sync': False}),
         ('sync', {'sync': 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)
 
         # special case for sync
         if changing_attr == 'sync' and updates['sync'] is False:
             expected_api_data['sync'] = None
         elif changing_attr == 'sync' and updates['sync'] is True:
             expected_api_data['sync'] = 'manual_api'
 
         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}),
         ('sync', {'sync': False}),
         ('sync', {'sync': 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)
         # special case for sync
         if changing_attr == 'sync' and updates['sync'] is False:
             expected_api_data['sync'] = None
         elif changing_attr == 'sync' and updates['sync'] is True:
             expected_api_data['sync'] = 'manual_api'
 
         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,297 +1,297 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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_method(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_method(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 = 'bookmark:ref'
         with pytest.raises(JSONRPCError) as excinfo:
             utils.resolve_ref_or_error(ref, repo)
         expected_message = (
             'The specified value:bookmark:`ref` does not exist, or is not allowed.')
         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 value:branch:`non-existing-one` does not exist, or is not allowed.')
         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 value:bookmark:`non-existing-one` does not exist, or is not allowed.')
         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_method(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,123 +1,123 b''
 
-# Copyright (C) 2010-2020 RhodeCode GmbH
+# Copyright (C) 2010-2023 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
 import pytest
 
 from rhodecode.api.utils import get_origin
 from rhodecode.lib.ext_json import json
 
 
 def jsonify(obj):
     return json.loads(json.dumps(obj))
 
 
 API_URL = '/_admin/api'
 
 
 def assert_call_ok(id_, given):
     expected = jsonify({
         'id': id_,
         'error': None,
         'result': None
     })
     given = json.loads(given)
 
     assert expected['id'] == given['id']
     assert expected['error'] == given['error']
     return given['result']
 
 
 def assert_ok(id_, expected, given):
     given = json.loads(given)
     if given.get('error'):
         err = given['error']
         pytest.fail(f"Unexpected ERROR in expected success response: `{err}`")
 
     expected = jsonify({
         'id': id_,
         'error': None,
         'result': expected
     })
 
     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 build_data(apikey, method, **kw):
     """
     Builds API data with given 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,
         headers=[('Content-Type', 'application/json')])
     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,458 +1,458 b''
 
 
-# Copyright (C) 2014-2020 RhodeCode GmbH
+# Copyright (C) 2014-2023 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.str_utils import safe_str
 from rhodecode.lib.vcs.exceptions import RepositoryError
 from rhodecode.lib.view_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):
         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):
         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):
         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):
         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:
         msg = 'permission `{}` does not exist.'.format(permid)
         if prefix:
             msg += ' Permission should start with prefix: `{}`'.format(prefix)
         raise JSONRPCError(msg)
 
     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(rhodecode_vcs_repo, commit, detail_level):
     commit2 = commit
     commit1 = commit.first_parent
 
     parsed_diff = []
     if detail_level == 'extended':
         for f_path in commit.added_paths:
             parsed_diff.append(_get_commit_dict(filename=f_path, op='A'))
         for f_path in commit.changed_paths:
             parsed_diff.append(_get_commit_dict(filename=f_path, op='M'))
         for f_path in commit.removed_paths:
             parsed_diff.append(_get_commit_dict(filename=f_path, op='D'))
 
     elif detail_level == 'full':
         from rhodecode.lib import diffs
 
         _diff = rhodecode_vcs_repo.get_diff(commit1, commit2,)
         diff_processor = diffs.DiffProcessor(_diff, diff_format='newdiff', show_full_diff=True)
 
         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 _get_ref_hash(repo, type_, name):
     vcs_repo = repo.scm_instance()
     if type_ in ['branch'] and vcs_repo.alias in ('hg', 'git'):
         return vcs_repo.branches[name]
     elif type_ in ['bookmark', 'book'] and vcs_repo.alias == 'hg':
         return vcs_repo.bookmarks[name]
     else:
         raise ValueError()
 
 
 def resolve_ref_or_error(ref, repo, allowed_ref_types=None):
     allowed_ref_types = allowed_ref_types or ['bookmark', 'book', 'tag', 'branch']
 
     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))
 
     if ref_type not in allowed_ref_types:
         raise JSONRPCError(
             'Ref `{ref}` type is not allowed. '
             'Only:{allowed_refs} are possible.'.format(
                 ref=ref, allowed_refs=allowed_ref_types))
 
     try:
         ref_hash = ref_hash or _get_ref_hash(repo, ref_type, ref_name)
     except (KeyError, ValueError):
         raise JSONRPCError(
             'The specified value:{type}:`{name}` does not exist, or is not allowed.'.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_str(filename),
         "op": op,
 
         # extra details
         "new_revision": new_revision,
         "old_revision": old_revision,
 
         "raw_diff": raw_diff,
         "stats": stats
     }

rhodecode/api/views/__init__.py

@@ -1,19 +1,19 b''
 
 
-# Copyright (C) 2015-2020 RhodeCode GmbH
+# Copyright (C) 2015-2023 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''
 
 
-# Copyright (C) 2011-2020 RhodeCode GmbH
+# Copyright (C) 2011-2023 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:: javascript
 
         {
             "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,257 +1,257 b''
 
 
-# Copyright (C) 2011-2020 RhodeCode GmbH
+# Copyright (C) 2011-2023 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.str_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,1113 +1,1113 b''
 
 
-# Copyright (C) 2011-2020 RhodeCode GmbH
+# Copyright (C) 2011-2023 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 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, validate_set_owner_permissions)
 from rhodecode.lib import channelstream
 from rhodecode.lib.auth import (HasRepoPermissionAnyApi)
 from rhodecode.lib.base import vcs_operation_context
 from rhodecode.lib.utils2 import str2bool
 from rhodecode.lib.vcs.backends.base import unicode_to_reference
 from rhodecode.model.changeset_status import ChangesetStatusModel
 from rhodecode.model.comment import CommentsModel
 from rhodecode.model.db import (
     Session, ChangesetStatus, ChangesetComment, PullRequest, PullRequestReviewers)
 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),
                      merge_state=Optional(False)):
     """
     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
     :param merge_state: Optional calculate merge state for each repository.
         This could result in longer time to fetch the data
     :type merge_state: bool
 
     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>",
             "versions":          "<number_or_versions_of_pr>",
             "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))
 
     # NOTE(marcink): only calculate and return merge state if the pr state is 'created'
     # otherwise we can lock the repo on calculation of merge state while update/merge
     # is happening.
     pr_created = pull_request.pull_request_state == pull_request.STATE_CREATED
     merge_state = Optional.extract(merge_state, binary=True) and pr_created
     data = pull_request.get_api_data(with_merge_state=merge_state)
     return data
 
 
 @jsonrpc_method()
 def get_pull_requests(request, apiuser, repoid, status=Optional('new'),
                       merge_state=Optional(False)):
     """
     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
     :param merge_state: Optional calculate merge state for each repository.
         This could result in longer time to fetch the data
     :type merge_state: bool
 
     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)
     merge_state = Optional.extract(merge_state, binary=True)
     pull_requests = PullRequestModel().get_all(repo, statuses=[status],
                                                order_by='id', order_dir='desc')
     data = [pr.get_api_data(with_merge_state=merge_state) 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_status_message":   "<str>",
             "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
     auth_user = apiuser
 
     if not isinstance(userid, Optional):
         is_repo_admin = HasRepoPermissionAnyApi('repository.admin')(
             user=apiuser, repo_name=repo.repo_name)
         if has_superadmin_permission(apiuser) or is_repo_admin:
             apiuser = get_user_or_error(userid)
             auth_user = apiuser.AuthUser()
         else:
             raise JSONRPCError('userid is not the same as your user')
 
     if pull_request.pull_request_state != PullRequest.STATE_CREATED:
         raise JSONRPCError(
             'Operation forbidden because pull request is in state {}, '
             'only state {} is allowed.'.format(
                 pull_request.pull_request_state, PullRequest.STATE_CREATED))
 
     with pull_request.set_state(PullRequest.STATE_UPDATING):
         check = MergeCheck.validate(pull_request, auth_user=auth_user,
                                     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=auth_user.username, action='push',
         scm=target_repo.repo_type)
     with pull_request.set_state(PullRequest.STATE_UPDATING):
         merge_response = PullRequestModel().merge_repo(
             pull_request, apiuser, extras=extras)
     if merge_response.executed:
         PullRequestModel().close_pull_request(pull_request.pull_request_id, auth_user)
 
         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,
               "comment_last_version: 0,
               "pull_request_version": null,
               "comment_commit_id": None,
               "comment_pull_request_id": <pull_request_id>
             }
         ],
         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), extra_recipients=Optional([]),
         userid=Optional(OAttr('apiuser')), send_email=Optional(True)):
     """
     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 resolves_comment_id: id of comment which this one will resolve
     :type resolves_comment_id: Optional(int)
     :param extra_recipients: list of user ids or usernames to add
         notifications for this comment. Acts like a CC for notification
     :type extra_recipients: Optional(list)
     :param userid: Comment on the pull request as this user
     :type userid: Optional(str or int)
     :param send_email: Define if this comment should also send email notification
     :type send_email: Optional(bool)
 
     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
     """
     _ = 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
 
     db_repo_name = repo.repo_name
     auth_user = apiuser
     if not isinstance(userid, Optional):
         is_repo_admin = HasRepoPermissionAnyApi('repository.admin')(
             user=apiuser, repo_name=db_repo_name)
         if has_superadmin_permission(apiuser) or is_repo_admin:
             apiuser = get_user_or_error(userid)
             auth_user = apiuser.AuthUser()
         else:
             raise JSONRPCError('userid is not the same as your user')
 
     if pull_request.is_closed():
         raise JSONRPCError(f'pull request `{pullrequestid}` comment failed, pull request is closed')
 
     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)
     extra_recipients = Optional.extract(extra_recipients)
     send_email = Optional.extract(send_email, binary=True)
 
     if not message and not status:
         raise JSONRPCError(
             'Both message and status parameters are missing. '
             'At least one is required.')
 
     if status and status not in (st[0] for st in ChangesetStatus.STATUSES):
         raise JSONRPCError(f'Unknown comment status: `{status}`')
 
     if commit_id and commit_id not in pull_request.revisions:
         raise JSONRPCError(f'Invalid commit_id `{commit_id}` for this pull request.')
 
     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 the latest commit_id from the PR
     if commit_id:
         commit_idx = pull_request.revisions.index(commit_id)
         if commit_idx != 0:
             log.warning('Resetting allowed_to_change_status = False because commit is NOT the latest in pull-request')
             allowed_to_change_status = False
 
     if resolves_comment_id:
         comment = ChangesetComment.get(resolves_comment_id)
         if not comment:
             raise JSONRPCError(f'Invalid resolves_comment_id `{resolves_comment_id}` for this pull request.')
         if comment.comment_type != ChangesetComment.COMMENT_TYPE_TODO:
             raise JSONRPCError(f'Comment `{resolves_comment_id}` is wrong type for setting status to resolved.')
 
     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,
         auth_user=auth_user,
         extra_recipients=extra_recipients,
         send_email=send_email
     )
 
     is_inline = comment.is_inline
 
     if allowed_to_change_status and status:
         old_calculated_status = pull_request.calculated_review_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()
 
     PullRequestModel().trigger_pull_request_hook(
         pull_request, apiuser, 'comment',
         data={'comment': comment})
 
     if allowed_to_change_status and status:
         # we now calculate the status of pull request, and based on that
         # calculation we set the commits status
         calculated_status = pull_request.calculated_review_status()
         if old_calculated_status != calculated_status:
             PullRequestModel().trigger_pull_request_hook(
                 pull_request, apiuser, 'review_status_change',
                 data={'status': calculated_status})
 
     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},
     }
 
     comment_broadcast_channel = channelstream.comment_channel(
         db_repo_name, pull_request_obj=pull_request)
 
     comment_data = data
     comment_type = 'inline' if is_inline else 'general'
     channelstream.comment_channelstream_push(
         request, comment_broadcast_channel, apiuser,
         _('posted a new {} comment').format(comment_type),
         comment_data=comment_data)
 
     return data
 
 
 def _reviewers_validation(obj_list):
     schema = ReviewerListSchema()
     try:
         reviewer_objects = schema.deserialize(obj_list)
     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
     return reviewer_objects
 
 
 @jsonrpc_method()
 def create_pull_request(
         request, apiuser, source_repo, target_repo, source_ref, target_ref,
         owner=Optional(OAttr('apiuser')), title=Optional(''), description=Optional(''),
         description_renderer=Optional(''),
         reviewers=Optional(None), observers=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 owner: user_id or username
     :type owner: Optional(str)
     :param title: Optionally Set the pull request title, it's generated otherwise
     :type title: str
     :param description: Set the pull request description.
     :type description: Optional(str)
     :type description_renderer: Optional(str)
     :param description_renderer: Set pull request renderer for the description.
         It should be 'rst', 'markdown' or 'plain'. If not give default
         system renderer will be used
     :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>}]
     :param observers: Set the new pull request observers list.
         Reviewer defined by review rules will be added automatically to the
         defined list. This feature is only available in RhodeCode EE
     :type observers: Optional(list)
         Accepts username strings or objects of the format:
 
             [{'username': 'nick', 'reasons': ['original author']}]
     """
 
     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)
 
     owner = validate_set_owner_permissions(apiuser, owner)
 
     full_source_ref = resolve_ref_or_error(source_ref, source_db_repo)
     full_target_ref = resolve_ref_or_error(target_ref, target_db_repo)
 
     get_commit_or_error(full_source_ref, source_db_repo)
     get_commit_or_error(full_target_ref, target_db_repo)
 
     reviewer_objects = Optional.extract(reviewers) or []
     observer_objects = Optional.extract(observers) or []
 
     # serialize and validate passed in given reviewers
     if reviewer_objects:
         reviewer_objects = _reviewers_validation(reviewer_objects)
 
     if observer_objects:
         observer_objects = _reviewers_validation(reviewer_objects)
 
     get_default_reviewers_data, validate_default_reviewers, validate_observers = \
         PullRequestModel().get_reviewer_functions()
 
     source_ref_obj = unicode_to_reference(full_source_ref)
     target_ref_obj = unicode_to_reference(full_target_ref)
 
     # recalculate reviewers logic, to make sure we can validate this
     default_reviewers_data = get_default_reviewers_data(
         owner,
         source_db_repo,
         source_ref_obj,
         target_db_repo,
         target_ref_obj,
     )
 
     # now MERGE our given with the calculated from the default rules
     just_reviewers = [
         x for x in default_reviewers_data['reviewers']
         if x['role'] == PullRequestReviewers.ROLE_REVIEWER]
     reviewer_objects = just_reviewers + reviewer_objects
 
     try:
         reviewers = validate_default_reviewers(
             reviewer_objects, default_reviewers_data)
     except ValueError as e:
         raise JSONRPCError('Reviewers Validation: {}'.format(e))
 
     # now MERGE our given with the calculated from the default rules
     just_observers = [
         x for x in default_reviewers_data['reviewers']
         if x['role'] == PullRequestReviewers.ROLE_OBSERVER]
     observer_objects = just_observers + observer_objects
 
     try:
         observers = validate_observers(
             observer_objects, default_reviewers_data)
     except ValueError as e:
         raise JSONRPCError('Observer Validation: {}'.format(e))
 
     title = Optional.extract(title)
     if not title:
         title_source_ref = source_ref_obj.name
         title = PullRequestModel().generate_pullrequest_title(
             source=source_repo,
             source_ref=title_source_ref,
             target=target_repo
         )
 
     diff_info = default_reviewers_data['diff_info']
     common_ancestor_id = diff_info['ancestor']
     # NOTE(marcink): reversed is consistent with how we open it in the WEB interface
     commits = [commit['commit_id'] for commit in reversed(diff_info['commits'])]
 
     if not common_ancestor_id:
         raise JSONRPCError('no common ancestor found between specified references')
 
     if not commits:
         raise JSONRPCError('no commits found for merge between specified references')
 
     # recalculate target ref based on ancestor
     full_target_ref = ':'.join((target_ref_obj.type, target_ref_obj.name, common_ancestor_id))
 
     # fetch renderer, if set fallback to plain in case of PR
     rc_config = SettingsModel().get_all_settings()
     default_system_renderer = rc_config.get('rhodecode_markup_renderer', 'plain')
     description = Optional.extract(description)
     description_renderer = Optional.extract(description_renderer) or default_system_renderer
 
     pull_request = PullRequestModel().create(
         created_by=owner.user_id,
         source_repo=source_repo,
         source_ref=full_source_ref,
         target_repo=target_repo,
         target_ref=full_target_ref,
         common_ancestor_id=common_ancestor_id,
         revisions=commits,
         reviewers=reviewers,
         observers=observers,
         title=title,
         description=description,
         description_renderer=description_renderer,
         reviewer_data=default_reviewers_data,
         auth_user=apiuser
     )
 
     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(''), description_renderer=Optional(''),
         reviewers=Optional(None), observers=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)
     :type description_renderer: Optional(str)
     :param description_renderer: Update pull request renderer for the description.
         It should be 'rst', 'markdown' or 'plain'
     :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 observers: Update pull request observers list with new value.
     :type observers: Optional(list)
         Accepts username strings or objects of the format:
 
             [{'username': 'nick', 'reasons': ['should be aware about this PR']}]
     :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_observers": {
               "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 []
     observer_objects = Optional.extract(observers) or []
 
     title = Optional.extract(title)
     description = Optional.extract(description)
     description_renderer = Optional.extract(description_renderer)
 
     # Update title/description
     title_changed = False
     if title or description:
         PullRequestModel().edit(
             pull_request,
             title or pull_request.title,
             description or pull_request.description,
             description_renderer or pull_request.description_renderer,
             apiuser)
         Session().commit()
         title_changed = True
 
     commit_changes = {"added": [], "common": [], "removed": []}
 
     # Update commits
     commits_changed = False
     if str2bool(Optional.extract(update_commits)):
 
         if pull_request.pull_request_state != PullRequest.STATE_CREATED:
             raise JSONRPCError(
                 'Operation forbidden because pull request is in state {}, '
                 'only state {} is allowed.'.format(
                     pull_request.pull_request_state, PullRequest.STATE_CREATED))
 
         with pull_request.set_state(PullRequest.STATE_UPDATING):
             if PullRequestModel().has_valid_update_type(pull_request):
                 db_user = apiuser.get_instance()
                 update_response = PullRequestModel().update_commits(
                     pull_request, db_user)
                 commit_changes = update_response.changes or commit_changes
             Session().commit()
             commits_changed = True
 
     # Update reviewers
     # serialize and validate passed in given reviewers
     if reviewer_objects:
         reviewer_objects = _reviewers_validation(reviewer_objects)
 
     if observer_objects:
         observer_objects = _reviewers_validation(reviewer_objects)
 
     # re-use stored rules
     default_reviewers_data = pull_request.reviewer_data
 
     __, validate_default_reviewers, validate_observers = \
         PullRequestModel().get_reviewer_functions()
 
     if reviewer_objects:
         try:
             reviewers = validate_default_reviewers(reviewer_objects, default_reviewers_data)
         except ValueError as e:
             raise JSONRPCError('Reviewers Validation: {}'.format(e))
     else:
         reviewers = []
 
     if observer_objects:
         try:
             observers = validate_default_reviewers(reviewer_objects, default_reviewers_data)
         except ValueError as e:
             raise JSONRPCError('Observer Validation: {}'.format(e))
     else:
         observers = []
 
     reviewers_changed = False
     reviewers_changes = {"added": [], "removed": []}
     if reviewers:
         old_calculated_status = pull_request.calculated_review_status()
         added_reviewers, removed_reviewers = \
             PullRequestModel().update_reviewers(pull_request, reviewers, apiuser.get_instance())
 
         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()
 
         # trigger status changed if change in reviewers changes the status
         calculated_status = pull_request.calculated_review_status()
         if old_calculated_status != calculated_status:
             PullRequestModel().trigger_pull_request_hook(
                 pull_request, apiuser, 'review_status_change',
                 data={'status': calculated_status})
         reviewers_changed = True
 
     observers_changed = False
     observers_changes = {"added": [], "removed": []}
     if observers:
         added_observers, removed_observers = \
             PullRequestModel().update_observers(pull_request, observers, apiuser.get_instance())
 
         observers_changes['added'] = sorted(
             [get_user_or_error(n).username for n in added_observers])
         observers_changes['removed'] = sorted(
             [get_user_or_error(n).username for n in removed_observers])
         Session().commit()
 
         reviewers_changed = True
 
     # push changed to channelstream
     if commits_changed or reviewers_changed or observers_changed:
         pr_broadcast_channel = channelstream.pr_channel(pull_request)
         msg = 'Pull request was updated.'
         channelstream.pr_update_channelstream_push(
             request, pr_broadcast_channel, apiuser, msg)
 
     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,
         'updated_observers': observers_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
 
     is_repo_admin = HasRepoPermissionAnyApi('repository.admin')(
                     user=apiuser, repo_name=repo.repo_name)
     if not isinstance(userid, Optional):
         if has_superadmin_permission(apiuser) or is_repo_admin:
             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, auth_user=apiuser)
     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